TweetFollow Us on Twitter

Window Management
Volume Number:10
Issue Number:12
Column Tag:Improving the Framework

Related Info: Window Manager

Better Window Management in MacApp

Plugging some holes in MacApp windows

By Richard Gillam, GE Information Services

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

The little things count. This article doesn’t aim to present any Higher Truths of Object-Oriented Computing, or to show you how to solve third-order differential equations using the THINK Class Library, or anything like that. Instead, I want to share with you a little class I created a while back to plug up a few holes in MacApp 3.0.1’s window-management code.

What’s Wrong With
MacApp’s Window Stuff?

Some things don’t quite live up to their press. As with printing in MacApp (“It’s only a couple lines of code” only if you’re doing really basic, no-frills printing), so it is with window management in MacApp, only not quite as bad. I found two significant deficiencies in MacApp’s window-management code and one feature I wanted to add.

The first feature was MacApp’s window-staggering code. If you want the initial positions of your document windows to march down the screen and to the right as you successively open windows, rather than opening directly on top of each other, you can set the window’s fMustStagger flag in the view template resource. But if you do that without implementing a staggering routine of your own, you’ll run into two big problems. The first is a truly brain-dead positioning algorithm. MacApp keeps a global variable that contains a count of how many staggered windows it has opened. To figure out where to open the next one, it just multiplies the standard staggering offset by the number of windows that have already been opened. That’s it. This means that if you’ve opened ten windows and then closed all of them, the next window you open will still be halfway down the screen. Ugly.

Worse, there’s a bug in their algorithm. The algorithm is smart enough to sense when you’ve marched off the edge of the monitor and move you back to the upper left-hand corner, but they didn’t do it quite right. If you have two monitors and the auxiliary monitor is placed to the right of the main monitor (the one with the menu bar), you can run into a situation where new windows open with their initial position straddling monitors, a definite human-interface no-no. This is either because they don’t take multiple monitors into account or because they only check to see if the window has gone off the bottom of the screen and not if it’s gone off the right-hand side. [To see what I’m talking about, comment out the line that begins “RegisterStdType(“TBetterWindow” )” in the demo program and compile and run it. On a two-monitor machine, if you open enough windows, several of them will hang off on the right-hand monitor. They won’t move back to the upper left-hand corner until they march off the bottom.]

The other feature I wanted to improve was the window-zooming code. Here, MacApp does take multiple monitors into account, but doesn’t take the contents of the window itself into account. The human-interface guidelines say that clicking the zoom box of a window should make it just large enough to hold its contents (if that’ll fit on the screen), but no larger. MacApp’s default window-zooming algorithm always zooms the window to full-screen size.

Finally, I needed to add the ability to save and restore window positions.

The TBetterWindow Class

You’ll find source for a class designed to solve that above problems and a demo program called BetterWindow in the usual source code locations. The program is basically the Nothing application beefed up with the addition of the TBetterWindow class. I made the default view wider so that you could see the multiple-monitor bug, and I added the ability to make the view itself larger and smaller. You may want to follow along in the demo program as I go through these examples.

It would be nice if we could improve the positioning and zooming algorithms by adding a behavior to a regular TWindow. Unfortunately, we can’t, because we have to override too many routines which are specific to TWindow and not available to override from TBehavior. So I had to subclass TWindow and create a class called TBetterWindow. Fortunately, for certain classes, MacApp provides a way to use a subclass instead of standard class. In your application’s initialization code (probably in your application class’s I method), call RegisterStdType(). My call to RegisterStdType() looks like this:

RegisterStdType("TBetterWindow", kStdWindow);

kStdWindow tells MacApp you’re providing a class name to use when opening a standard window, and the string parameter is the class name to use instead of TWindow. Now anywhere you use TWindow, TBetterWindow will be substituted.

You can probably safely use TBetterWindow all the time, even in cases (such as dialog boxes) where you don’t need its features. But if you want more control over when specifically you use TBetterWindow, you need to specify it in all of the view hierarchy resources where you intend to use it.

Smart Window Positioning

To control how a window is staggered, you override TWindow::SimpleStagger(). TWindow::Open() calls this routine any time the window being opened has its fMustStagger flag set. This routine positions and resizes the window as appropriate. It takes two parameters: the amount to offset each window from the previous one, and a count of the staggered windows opened so far. We don’t use the count parameter.

The basic idea behind this routine is that every new window opens offset by the specified amount from the window right behind it. But we’ve added two important refinements: 1) If that position will run partially off the screen or straddle two monitors, we don’t use it, but instead move back toward the upper left-hand corner of the monitor containing the largest part of the previous active window. 2) If the position where we want to open the window is already occupied by another window (i.e., another window has its upper left-hand corner where we were going to put this window’s upper left-hand corner), then move down and to the right until we find an unoccupied position.


/* 1 */
pascal void TBetterWindow :: SimpleStagger(
 CPoint delta,
 short& /*count*/)
 {
 CPoint ulhc(7, 20);
 CPoint newPos;
 WindowPtrfrontWindow;
 CRect  temp;
 CRect  monitorRect;
 CPoint localUlhc;
 VRect  frame;
 
 // take into account the menu bar when determining
 // where to put the first window
 ulhc.v += *(short*)MBarHeight;
 
 // find the front window and take note of its monitor
 // rectangle
 frontWindow = MAGetActiveWindow();
 GetMonitorInfo(frontWindow, monitorRect);
 
 // if there is no front window, the new window will go
 // in the upper left-hand corner of the main monitor,
 // defined above
 if (frontWindow == NULL) {
 newPos = ulhc;
 localUlhc = ulhc;
 }
 
 // if there is a front window, the new one will be
 // offset from it by the value of "delta" and the upper
 // left-hand corner we use for positioning will be that
 // of the monitor containing the most of the current
 // front window (notice we have to adjust for the menu
 // bar size)
 else {
 temp = (**((WindowPeek)frontWindow)->contRgn)
 .rgnBBox;
 newPos = temp[topLeft];
 newPos += delta;
 localUlhc = ulhc;
 if (monitorRect[topLeft] != gZeroPt) {
 localUlhc += monitorRect[topLeft];
 localUlhc.v -= *(short*)MBarHeight;
 }
 }
 this->MakePositionUnique(newPos, localUlhc, delta,
 monitorRect);
 this->Locate(VPoint(newPos), false);
 }

Note the extra code that is required to take the menu bar and multiple monitors into account. Most of this code is fairly self-explanatory, but it is worth noting that “ulhc” is initialized to (7, 20) to give adequate clearance around the window. The position the Mac OS uses is actually the upper left-hand corner of the window’s content area, so we have to leave room for the title bar (hence the 20), and it looks a little better if we also leave some room on the left-hand side (hence the 7).

There are two refinements that can be added to the above algorithm. First, for performance reasons, it’s a good idea to take advantage of the window’s fStaggered flag:


/* 2 */
// if fStaggered is true, then we've already done all this
if (this->fStaggered)
 return;
 
// otherwise, go ahead and set the flag now so we won't go
// through all this the next time
this->fStaggered = true;

Second, if the window is a text-editing window, it’s nice to take advantage of all available screen real estate by elongating the window after you’ve positioned it:


/* 3 */
 if ( /*I'm a text-editing window*/ ) {
 this->GetFrame(frame);
 frame.bottom = monitorRect.bottom - 3;
 this->Resize(frame.GetSize(), false);
 }

If you elongate the window afterwards, the window can take up all available vertical space, no matter how much there is. It also means you can define the window’s size in your view template as the minimum size of the window. The positioning algorithm will move the window back to the upper left-hand corner when you’re too far down to show this minimum height.

Of course, much of the real work of the above routine is being done in subroutines. GetMonitorInfo() is used several different places to retrieve the bounding rectangle of the monitor containing the largest part of the specified window.


/* 4 */
pascal void TBetterWindow :: GetMonitorInfo(
 WindowPtrfrontWindow,
 CRect& monitorRect)
 {
 GDHandle monitor;
 GrafPtrwMgrPort;
 TWindow* frontTWindow;
 
// if we don't have Color QuickDraw, we can't have
// multiple monitors, so by definition our entire
// universe is defined by the Window Manager port's
// portRect
 if (!gConfiguration.hasColorQD) {
 GetWMgrPort(wMgrPort);
 monitorRect = wMgrPort->portRect;
 return;
 }
 
// if there are no open windows, use the main monitor
 if (frontWindow == NULL) {
 monitor = GetMainDevice();
 monitorRect = (**monitor).gdRect;
 }
 
// otherwise, use a method in TWindow to find out which
// monitor contains more of the frontmost window and
// then get info for it
 else {
 frontTWindow = WMgrToWindow(frontWindow);
 if (frontTWindow == NULL) {
 monitor = GetMainDevice();
 monitorRect = (**monitor).gdRect;
 }
 else {
 monitor = frontTWindow->
 GetMaxIntersectedDevice(monitorRect);
 monitorRect.top -= *(short*)MBarHeight;
 }
 }
 }

In most cases, we can take advantage of a MacApp routine called TWindow::GetMaxIntersectedDevice() to find out which monitor a window is on. GetMonitorInfo() helps us by taking care of the situation where we don’t have Color QuickDraw (in which case we can use the Window Manager port’s portRect, since there can only be one monitor), and the situation where there isn’t actually an open window to use (in which case we get the rectangle of the main monitor).

The job of find an unoccupied position for the new window is done by TBetterWindow::MakePositionUnique().


/* 5 */
pascal void TBetterWindow :: MakePositionUnique(
 CPoint&newPos,
 CPoint ulhc,
 CPoint delta,
 const CRect&  monitorRect)
 {
 CPoint workPos(newPos);
 CPoint tempUlhc;
 
// for as long as the proposed position is on the
// screen and another window occupies this position,
// keep advancing down and to the right until we
// either march off the screen or find an unoccupied
// position
 while (monitorRect.Contains(workPos) &&
 !IsPositionUnique(workPos))
 workPos += delta;
 
// if we've marched off the screen or if the unoccupied
// position won't allow the whole window to be on the
// screen, try again starting at the monitor's upper
// left-hand corner
 if (!monitorRect.Contains(workPos) ||
 !WillWindowFit(workPos, monitorRect)) {
 if (newPos != ulhc) {
 workPos = ulhc;
 if (!IsPositionUnique(workPos)) {
 MakePositionUnique(workPos, ulhc, delta,
 monitorRect);
 
// if we can't find an unoccupied position that
// will hold the window after starting at the
// upper left-hand corner of the monitor, try
// again, but start halfway between the first
// two window positions on the monitor (the test
// here causes recursive calls to fall out if
// they don't find an acceptable position)
 if (workPos == ulhc) {
 workPos += CPoint(delta.h / 2, delta.v / 2);
 
 if (!IsPositionUnique(workPos)) {
 tempUlhc = workPos;
 MakePositionUnique(workPos, tempUlhc, delta, monitorRect);
 
// if that doesn't work either, give up and
// just put the window in the upper left-
// hand corner of the monitor
 if (workPos == tempUlhc)
 workPos = ulhc;
 }
 }
 }
 }
 else
 workPos = newPos;
 }
 
// return the new position
 newPos = workPos;
 }

The basic idea here is that we check the current position of the window. If it’s occupied or part of the window dangles off the monitor, move down and to the right by the offset amount and try again. If the upper left-hand corner of the window marches off the screen, start over again (calling ourselves recursively), but start at the upper left-hand corner of the monitor. If that doesn’t work either, try again (with another recursive call), with the first spot being half the offset value from the upper left-hand corner of the screen. If that doesn’t work either (at which point some twenty-odd positions will have been tried), we just give up and put the window in the upper left-hand corner of the screen.

I’ll grant that the giving-up part isn’t real cool, but it should only happen under extreme conditions, and there is no easy way to modify this algorithm to reuse used positions (we’d have to count the windows in each position, which is painful). We could go hog-wild with the staggering (after all, there are some 15 valid positions between two windows offset from each other by the standard offset amount). I didn’t do this either, but it would be a good way of handling it if you often find yourself in a state where there are too many windows open for this algorithm to support.

MakePositionUnique() relies on another routine, IsPositionUnique(), to determine when it’s found a usable position. IsPositionUnique() in turn relies on a routine called WillWindowFit() to determine whether the whole window can fit at the specified position without hanging off the screen or straddling monitors:


/* 6 */
pascal Boolean TBetterWindow :: IsPositionUnique(
 CPoint pos)
 {
 CWMgrIterator   iter;
 WindowPtraWindowPtr;
 CRect  windowRect;
 
 for (aWindowPtr = iter.FirstWMgrWindow(); 
 iter.More();
 aWindowPtr = iter.NextWMgrWindow())
 if ((((WindowPeek)aWindowPtr)->visible) 
 &&   IsDocumentWindow(aWindowPtr)) {
 windowRect = (**((WindowPeek)aWindowPtr)
 ->contRgn).rgnBBox;
 if (windowRect[topLeft] == pos)
 return false;
 }
 return true;
 }

pascal Boolean TBetterWindow :: WillWindowFit(
 CPoint pos,
 const CRect&  monitorRect)
 {
 CRect  frame;
 
 frame[topLeft] = pos;
 frame[botRight] = pos + this->fSize.ToPoint();
 
// the insetting here takes into account the frame and
// drop shadow (we don't care about the title bar,
// since we're always going down and to the right
// and we know we started in a position where the title
// bar will work)
 frame.Inset(CPoint(-2, -2));
 
 return monitorRect.Contains(frame);
 }

WillWindowFit() is pretty self-explanatory. IsPositionUnique() takes advantage of an internal MacApp class, the CWMgrIterator, to walk the Window Manager’s window list to find out whether any other windows already on the screen occupy our proposed position. It’s a lot easier to walk the Window Manager’s list than to walk MacApp’s list.

Smart Window Zooming

To fix the zooming problem, the primary place to tap in is TWindow::GetStandardStateFrame(). There are two TWindow routines: GetStandardStateFrame() and GetUserStateFrame(). The standard state is the system-supplied position and size for the window, a canonical “most natural size” for the window (which is why it’s called the “standard state”). The user state is the size the window was before zooming, a state the window probably got into because the user resized or moved it (which is why it’s called the “user state”). Resizing the window by dragging the size box always puts the window into the user state. Clicking the window’s zoom box toggles between the user and standard states.

We don’t need to override GetUserStateFrame() because we’re not doing anything to the user state. But the standard state supplied by MacApp is always the full size of the monitor, which is often way too big in at least one dimension for what’s actually in the window, so

 
/* 7 */
pascal void TBetterWindow :: GetStandardStateFrame(
 const VRect&  /*boundingRect*/,
 VRect& stdFrame)
 {
 TView* targetView;
 TScroller* targetScroller;
 VRect  targetFrame;
 VRect  windowFrame;
 VPoint difference;
 GDHandle monitor;
 CRect  tempMonitorRect;
 VRect  monitorRect;
 VPoint ulhc(7, 20);
 
// get the window target view and figure out the
// difference between its current size and the window's
// current size (if the window target view is
// enclosed in a scroller, we're actually interested in
// the size of the scroller here instead [this probably
// won't work right if the window target view isn't the
// only thing in the scroller])
 targetView = (TView*)this->GetWindowTarget();
 targetScroller = targetView->GetScroller(false);
 if (targetScroller == NULL)
 targetView->GetFrame(targetFrame);
 else
 targetScroller->GetFrame(targetFrame);
 this->GetFrame(windowFrame);
 difference = windowFrame.GetSize() -
 targetFrame.GetSize();
 
// calculate the target view's minimum frame size, and
// calculate a new frame rectangle for the window by
// adding the difference between the window
// size and the old frame size to the new frame size
// and making the window frame that new size
 targetView->CalcMinFrame(targetFrame);
 windowFrame[botRight] = windowFrame[topLeft] +
 targetFrame.GetSize() + difference;
 if (windowFrame.GetLength(hSel) < 
 fResizeLimits.left)
 windowFrame.right = windowFrame.left +
 fResizeLimits.left;
 if (windowFrame.GetLength(vSel) < 
 fResizeLimits.top)
 windowFrame.bottom = windowFrame.top +
 fResizeLimits.top;
 
// get the rectangle of the monitor containing the
// largest part of the window (inset it a little to
// leave some slop on the sides and to leave
// room for the menu bar (if we have one) and the
// window's title bar)
// [NOTE: GetMaxIntersectedDevice() will usually take
// the menu bar into account. If it does, the else
// clause below will automatically adjust
// ulhc to take the menu bar into account too.]
 monitor = this->GetMaxIntersectedDevice
 (tempMonitorRect);
 monitorRect = VRect(tempMonitorRect);
 if (monitorRect[topLeft] == gZeroVPt)
 ulhc.v += *(short*)MBarHeight;
 else
 ulhc += monitorRect[topLeft];
 monitorRect[topLeft] = ulhc;
 monitorRect[botRight] -= VPoint(3, 3);
 
// does the new window frame fit on that monitor? If
// not, move the window to the upper left-hand corner
// of the monitor
 if (!monitorRect.Contains(windowFrame)) {
 windowFrame += ulhc - windowFrame[topLeft];
 
// does it fit now? If not, resize it so that as
// much of it as possible does
 if (!monitorRect.Contains(windowFrame)) {
 windowFrame.bottom = Min(windowFrame.bottom,
 monitorRect.bottom);
 windowFrame.right = Min(windowFrame.right,
 monitorRect.right);
 }
 }
 
// and return the result
 stdFrame = windowFrame;
 }

The algorithm I’m using here isn’t completely general, but it should cover most of the common cases. It works on the theory that when you resize a window by dragging the resize box, the part of the window that actually changes size is the window target view (or more accurately, the scroller containing the window target view). Everything else (scroll bars, other panes, etc.) derives its new size or position from the new size of the window target view’s scroller. Obviously, if you have a window for which this isn’t true, you’ll need to modify this algorithm, but it ought to work for most cases.

At any rate, the routine figures out the optimum size for the window by getting the current size of the window target view’s scroller and taking note of the difference between this size and the size of the window’s whole content area. It then adds this difference to the size returned by the window target view’s CalcMinFrame() routine, which is by definition the smallest frame size that will hold the view’s contents.

Actually, that’s not always true. We’ve probably all had a programming situation where a view was smaller than its scroller (or window, or containing view, or whatever), but where we wanted to take mouse hits or draw selections and mouse-tracking feedback in the area outside the view. Often, the best way to do this is to enlarge to view so it is always at least as large as its containing view. This, of course, messes up the zooming algorithm.

My solution to this is have CalcMinFrame() always return the smallest possible view size and do the adjustment in ComputeFrame() instead.


/* 8 */
pascal void TBetterView :: ComputeFrame(
 VRect& newFrame)
 {
 VPoint superViewSize;
 SizeDeterminer  saveHSizeDet, saveVSizeDet;
 BooleantryAgain = false;
 
 inherited::ComputeFrame(newFrame);
 
// the inherited is sufficient if we're printing or if
// by some weird twist of fate we don't have a
// superview
 if (!fSuperView || gPrinting)
 return;
 
// otherwise, save off our size determiners (we're
// going to change them)
 saveHSizeDet = fSizeDeterminer[hSel];
 saveVSizeDet = fSizeDeterminer[vSel];
 superViewSize = fSuperView->fSize;
 
// if this view is smaller than its superview in the x
// direction, change the size determiner to
// sizeSuperView so we make ourselves the same size
 if (fSizeDeterminer[hSel] == sizeVariable &&
 superViewSize[hSel] > newFrame.
 GetLength(hSel)) {
 fSizeDeterminer[hSel] = sizeSuperView;
 tryAgain = true;
 }
 
// if this view is smaller than its superview in the y
// direction, change the size determiner to 
// sizeSuperView so we make ourselves the same size
 if (fSizeDeterminer[vSel] == sizeVariable &&
 superViewSize[vSel] > newFrame.
 GetLength(vSel)) {
 fSizeDeterminer[vSel] = sizeSuperView;
 tryAgain = true;
 }
 
// if we changed either size determiner, call inherited
// again to make this view at least as big as its
// superview in each direction, and restore the
// real size determiners
 if (tryAgain) {
 inherited :: ComputeFrame(newFrame);
 fSizeDeterminer[hSel] = saveHSizeDet;
 fSizeDeterminer[vSel] = saveVSizeDet;
 }
 }

Of course, you can’t override ComputeFrame() from a behavior either, so it’s probably best to put this override of ComputeFrame() (possibly controlled by a flag so you don’t always have to use it) in a subclass of TView that all your view classes descend from.

Up to now, GetStandardStateFrame() has just figured the optimum size for the window. If the size will fit on the monitor without moving the window, we’re done and we return. If not, we move the window to the upper left-hand corner of the monitor. If it’ll fit there, we’re done. Otherwise, we shrink the window in each direction until it fits. This way, the window will fill the whole monitor only when all that space is actually filled with information.

We’re not done yet. There’s one more wrinkle that must be taken into account. Now that the size of the window’s standard state is based on the size of the information in the window, the size of the standard state will change when the size of the window’s content changes. Since the size of the window can’t change when the size of the standard state does, the window must be considered to have transitioned to the user state when its content changes size, just as it does when the user manually resizes the window.

To see what I’m talking about, run the demo program. Open a window. The window is in its user state. Now click on its zoom box. The window is now in its standard state. Now change the size of the window’s content. I have fixed it so that hitting U and D make the window’s content larger and smaller, respectively (creative, huh?) so you can see this. Make the content bigger by hitting U a couple times. Now if you click on the zoom box again, you don’t want to go back to the last user state (the window’s original frame size). You want to go to the new standard state size (the current size of the content). If you click the zoom box, you’ll see that this is what happens. Now hit D four times to make the view smaller than it originally was. Again, clicking the zoom box should make the window shrink to the current size of the view, not go back to the size it was before you last clicked the zoom box. Again, if you click it, you’ll see this is what is does.

To accomplish this, I had to override TWindow::Zoom() as well as TWindow:: GetStandardStateFrame(). This method checks anytime we’re in the standard state to make sure the standard state size is still valid:


/* 9 */
pascal void TBetterWindow :: Zoom(shortpartCode)
 {
 VRect  curFrame;
 VRect  newStdStateFrame;
 
 if (partCode == inZoomOut)
 inherited :: Zoom(partCode);
 else {
 this->GetFrame(curFrame);
 this->GetStandardStateFrame(curFrame,
 newStdStateFrame);
// ("curFrame" will be ignored)
 if (curFrame == newStdStateFrame)
 inherited :: Zoom(partCode);
 else {
 if (fProcID & zoomDocProc)
 (*((WStateDataHandle)(((WindowPeek)fWMgrWindow)
 ->dataHandle)))-> userState =
 curFrame.ToRect();
 inherited :: Zoom(inZoomOut);
 }
 }
 }

If the window is in the user state (partCode == inZoomOut), we can just go ahead and zoom. If the window is in the standard state, we check (by calling GetStandardStateFrame()) to see if the standard state has changed size (because the window target view has changed size and the change affects the window size [going from two feet high to three feet high won’t resize the window because two feet is already bigger than the monitor]). If it hasn’t, we can call the inherited routine with no further ado. Otherwise, we have to manually transition ourselves to the user state (saving off the window’s current size in the WindowRecord’s auxiliary data block) and then call the inherited routine as if we had been in the user state all along.

Saving Window Positions

I didn’t actually include any window-position-saving code in this article. This is because the act of saving a window position is so application-specific. The way we did it in the application I’ve been working on doesn’t really apply to anybody else’s application, and uses proprietary code. But TBetterWindow does include hooks for it.

The basic idea here is that we add two flags to TBetterWindow: fInDefaultPosition and fSavePosition. fInDefaultPosition starts out true when a window is first opened (if its position hasn’t been restored from disk). You override MoveByUser(), ResizeByUser(), and ZoomByUser() to set it false so that anytime the user manually moves or resizes the window, you know you have to resize it. fSavePosition starts out false, and is set to true by some outside routine (through the MarkPositionAsDirty() routine) anytime something else has happened that would cause you to save the window position (in case you’re saving other stuff, such as sort order or selection position, with the window position).

Now you have a routine called SavePosition(), which is called by an override of TWindow::Close(). It checks these flags and if fInDefaultPosition is false or fSavePosition is true, it saves the window’s position. SimpleStagger() now calls a routine called PositionIsSaved() before doing its normal staggering. If PositionIsSaved() returns true, the window’s position has been previously saved, and we want to use the saved position rather than deriving a new position algorithmically. So we call RestorePosition(), which restores the window’s position, and return without doing anything. The expression of all this in C++ code is included in the source code to the demo program.

#include stddisclaimers.h

As I mentioned at the top of this article, TBetterWindow aims to fix deficiencies in the MacApp 3.0.1 window-handling code. I haven’t yet made the switch to MacApp 3.1, so I can’t say whether these problems are still there. I suspect they are. I hope, if anyone on the MacApp team is listening, that you adopt something like these solutions in MacApp 3.5.

Meanwhile, I hope someone out there finds these techniques useful. They made a big difference in our application. As always, I welcome your questions, comments, and potshots.

 
AAPL
$104.83
Apple Inc.
+1.84
MSFT
$45.02
Microsoft Corpora
+0.64
GOOG
$543.98
Google Inc.
+11.27

MacTech Search:
Community Search:

Software Updates via MacUpdate

Delicious Library 3.3.2 - Import, browse...
Delicious Library allows you to import, browse, and share all your books, movies, music, and video games with Delicious Library. Run your very own library from your home or office using our... Read more
Art Text 2.4.8 - Create high quality hea...
Art Text is an OS X application for creating high quality textual graphics, headings, logos, icons, Web site elements, and buttons. Thanks to multi-layer support, creating complex graphics is no... Read more
Live Interior 3D Pro 2.9.6 - Powerful an...
Live Interior 3D Pro is a powerful yet very intuitive interior designing application. View Video Tutorials It has every feature of Live Interior 3D Standard, plus some exclusive ones: Create multi... Read more
The Hit List 1.1.7 - Advanced reminder a...
The Hit List manages the daily chaos of your modern life. It's easy to learn - it's as easy as making lists. And it's powerful enough to let you plan, then forget, then act when the time is right.... Read more
jAlbum Pro 12.2.4 - Organize your digita...
jAlbum Pro has all the features you love in jAlbum, but comes with a commercial license. With jAlbum, you can create gorgeous custom photo galleries for the Web without writing a line of code!... Read more
jAlbum 12.2.4 - Create custom photo gall...
With jAlbum, you can create gorgeous custom photo galleries for the Web without writing a line of code! Beginner-friendly, with pro results Simply drag and drop photos into groups, choose a design... Read more
ExpanDrive 4.1.7 - Access remote files o...
ExpanDrive builds cloud storage in every application, acts just like a USB drive plugged into your Mac. With ExpanDrive, you can securely access any remote file server directly from the Finder or... Read more
OmniOutliner Pro 4.1.3 - Pro version of...
OmniOutliner Pro is a flexible program for creating, collecting, and organizing information. Give your creativity a kick start by using an application that's actually designed to help you think. It'... Read more
Evernote 5.6.2 - Create searchable notes...
Evernote allows you to easily capture information in any environment using whatever device or platform you find most convenient, and makes this information accessible and searchable at anytime, from... Read more
OmniOutliner 4.1.3 - Organize your ideas...
OmniOutliner is a flexible program for creating, collecting, and organizing information. Give your creativity a kick start by using an application that's actually designed to help you think. It's... Read more

Latest Forum Discussions

See All

Toca Boo (Education)
Toca Boo 1.0.2 Device: iOS Universal Category: Education Price: $2.99, Version: 1.0.2 (iTunes) Description: BOO! Did I scare you!? My name is Bonnie and my family loves to spook! Do you want to scare them back? Follow me and I'll... | Read more »
Intuon (Games)
Intuon 1.1 Device: iOS Universal Category: Games Price: $.99, Version: 1.1 (iTunes) Description: Join the battle with your intuition in a new hardcore game Intuon! How well do you trust your intuition? Can you find a needle in a... | Read more »
Ravenous Rampage (Games)
Ravenous Rampage 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: | Read more »
Partia 2 (Games)
Partia 2 1.0.1 Device: iOS Universal Category: Games Price: $5.99, Version: 1.0.1 (iTunes) Description: Partia 2 is a SRPG (Strategy Role-playing) video game inspired by Fire Emblem and Tear Ring Saga series. In a high fantasy... | Read more »
Puzzle to the Center of the Earth Review
Puzzle to the Center of the Earth Review By Campbell Bird on October 23rd, 2014 Our Rating: :: SPELUNKING PUZZLESUniversal App - Designed for iPhone and iPad Do some puzzles to make some platforms in this smart and fun free-to-play... | Read more »
Sleep Attack TD Review
Sleep Attack TD Review By Jennifer Allen on October 23rd, 2014 Our Rating: :: A TRUE TWISTUniversal App - Designed for iPhone and iPad Sleep Attack TD is a tower defense game with a difference – you can rotate the layout – and it’s... | Read more »
Mecanic (Education)
Mecanic 1.0 Device: iOS Universal Category: Education Price: $1.99, Version: 1.0 (iTunes) Description: Plates, screws, wheels ... Everything you need to achieve whatever you want... MECHANICWith 'MECANIC' kids will have fun... | Read more »
Earn Your Master Camper Badge in Camp Po...
Earn Your Master Camper Badge in Camp Pokemon Posted by Jessica Fisher on October 23rd, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Garruk Gets His Revenge in a New Magic 2...
Garruk Gets His Revenge in a New Magic 2015 Expansion, Coming This November Posted by Jessica Fisher on October 23rd, 2014 [ permalink ] | Read more »
Sentinels of the Multiverse Review
Sentinels of the Multiverse Review By Rob Thomas on October 23rd, 2014 Our Rating: :: SENTINELS ASSEMBLEiPad Only App - Designed for the iPad Greater Than Games’ tabletop classic, Sentinels of the Multiverse swoops in to save the... | Read more »

Price Scanner via MacPrices.net

Save up to $125 on Retina MacBook Pros
B&H Photo has the new 2014 13″ and 15″ Retina MacBook Pros on sale for up to $125 off MSRP. Shipping is free, and B&H charges NY sales tax only. They’ll also include free copies of Parallels... Read more
Apple refurbished Time Capsules available sta...
The Apple Store has certified refurbished Time Capsules available for up to $60 off MSRP. Apple’s one-year warranty is included with each Time Capsule, and shipping is free: - 2TB Time Capsule: $255... Read more
Textilus New Word, Notes and PDF Processor fo...
Textilus is new word-crunching, notes, and PDF processor designed exclusively for the iPad. I haven’t had time to thoroughly check it out yet, but it looks great and early reviews are positive.... Read more
WD My Passport Pro Bus-Powered Thunderbolt RA...
WD’s My Passport Pro RAID solution is powered by an integrated Thunderbolt cable for true portability and speeds as high as 233 MB/s. HighlightsOverviewSpecifications Transfer, Back Up And Edit In... Read more
Save with Best Buy’s College Student Deals
Take an additional $50 off all MacBooks and iMacs at Best Buy Online with their College Students Deals Savings, valid through November 1st. Anyone with a valid .EDU email address can take advantage... Read more
iPad Air 2 & iPad mini 3 Best Tablets Yet...
The new iPads turned out to be pretty much everything I’d been hoping for and more than I’d expected.”More” particularly in terms of a drinking-from-a-firehose choice of models and configurations,... Read more
Drafts 4 Reinvents iOS Productivity App
N Richland Hills, Texas based Agile Tortoise has announced the release of Drafts 4 for iPhone and iPad. Drafts is a quick capture note taking app with flexible output actions. Drafts 4 scales from... Read more
AT&T accepting preorders for new iPads fo...
AT&T Wireless is accepting preorders for the new iPad Air 2 and iPad mini 3, cellular models, for $100 off MSRP with a 2-year service agreement: - 16GB iPad Air 2 WiFi + Cellular: $529.99 - 64GB... Read more
Apple offering refurbished Mac Pros for up to...
The Apple Store is offering Apple Certified Refurbished 2013 Mac Pros for up to $600 off the cost of new models. An Apple one-year warranty is included with each Mac Pro, and shipping is free. The... Read more
Select MacBook Airs $100 off MSRP, free shipp...
B&H Photo has 2014 a couple of MacBook Airs on sale for $100 off MSRP. Shipping is free, and B&H charges NY sales tax only. They also include free copies of Parallels Desktop and LoJack for... Read more

Jobs Board

Senior Event Manager, *Apple* Retail Market...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global event strategy. Delivering an overarching brand story; in-store, Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Project Manager / Business Analyst, WW *Appl...
…a senior project manager / business analyst to work within our Worldwide Apple Fulfillment Operations and the Business Process Re-engineering team. This role will work Read more
*Apple* Retail - Multiple Positions (US) - A...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Position Opening at *Apple* - Apple (United...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.