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:

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.

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:

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.

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:

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.

Community Search:

MacTech Search:

Software Updates via MacUpdate

MacFamilyTree 7.3.4 - Create and explore...

MacFamilyTree gives genealogy a facelift: it's modern, interactive, incredibly fast, and easy to use. We're convinced that generations of chroniclers would have loved to trade in their genealogy... Read more

Yummy FTP 1.10.2 - FTP/SFTP/FTPS client...

Yummy FTP is an FTP + SFTP + FTPS file transfer client which focuses on speed, reliability and productivity.
Whether you need to transfer a few files or a few thousand, schedule automatic backups, or... Read more

VueScan 9.5.08 - Scanner software with a...

VueScan is a scanning program that works with most high-quality flatbed and film scanners to produce scans that have excellent color fidelity and color balance. VueScan is easy to use, and has... Read more

Iridient Developer 3.0.1 - Powerful imag...

Iridient Developer (was RAW Developer) is a powerful image conversion application designed specifically for OS X. Iridient Developer gives advanced photographers total control over every aspect of... Read more

Air Video Server HD 2.1.0 - Stream video...

Air Video Server HD streams videos instantly from your computer on your iPhone, iPad, iPod touch or Apple TV. No need to worry about converting or transferring files.
We took everything that was... Read more

Duplicate Annihilator 5.7.5 - Find and d...

Duplicate Annihilator takes on the time-consuming task of comparing the images in your iPhoto library using effective algorithms to make sure that no duplicate escapes.
Duplicate Annihilator... Read more

BusyContacts 1.0.2 - Fast, efficient con...

BusyContacts is a contact manager for OS X that makes creating, finding, and managing contacts faster and more efficient. It brings to contact management the same power, flexibility, and sharing... Read more

Capture One Pro 8.2.0.82 - RAW workflow...

Capture One Pro 8 is a professional RAW converter offering you ultimate image quality with accurate colors and incredible detail from more than 300 high-end cameras -- straight out of the box. It... Read more

Backblaze 4.0.0.872 - Online backup serv...

Backblaze is an online backup service designed from the ground-up for the Mac.With unlimited storage available for $5 per month, as well as a free 15-day trial, peace of mind is within reach with... Read more

Little Snitch 3.5.2 - Alerts you about o...

Little Snitch gives you control over your private outgoing data.
Track background activity As soon as your computer connects to the Internet, applications often have permission to send any... Read more

Pie In The Sky: A Pizza Odyssey 1.0
Device: iOS Universal
Category: Games
Price: $2.99, Version: 1.0 (iTunes)
Description:
A game about delivering pizza. In space.
| Read more »

Chosen Gives Hopeful Singers, Songwriter...

If YouTube videos and reality TV shows like The Voice have taught us one thing, it’s that there are a lot of people out there who are anxious to show the world their talents. And if they’ve taught us a second thing, it’s that there’s an almost... | Read more »

Android's Popular OfficeSuite Now A...

Once only available for Android devices, OfficeSuite has finally landed on the app store. The Mobile Systems app lets you view, edit, create, and share Word, Excel, and PowerPoint documents as well as convert them to/from PDFs. It's touted as being... | Read more »

Warhammer: Arcane Magic is Coming Soon,...

Turbo Tape Games has announced that they're joining forces with Games Workshop to bring the turn-based strategy board game, Warhammer: Arcane Magic, to life on the iOS.
| Read more »

Fast & Furious: Legacy's Creati...

| Read more »

N-Fusion and 505's Ember is Totally...

| Read more »

These are All the Apple Watch Apps and G...

The Apple Watch is less than a month from hitting store shelves, and once you get your hands on it you're probably going to want some apps and games to install. Fear not! We've compiled a list of all the Apple Watch apps and games we've been able to... | Read more »

Appy to Have Known You - Lee Hamlet Look...

Being at 148Apps these past 2 years has been an awesome experience that has taught me a great deal, and working with such a great team has been a privilege. Thank you to Rob Rich, and to both Rob LeFebvre and Jeff Scott before him, for helping me... | Read more »

Hands-On With Allstar Heroes - A Promisi...

Let’s get this out of the way quickly. Allstar Heroes looks a lot like a certain other recent action RPG release, but it turns out that while it’s not yet available here, Allstar Heroes has been around for much longer than that other title. Now that... | Read more »

Macho Man and Steve Austin Join the Rank...

WWE Immortals, by Warner Bros. Interactive Entertainment and WWE, has gotten a superstar update. You'll now have access to Macho Man Randy Savage and Steve Austin. Both characters have two different versions: Macho Man Randy Savage Renegade or Macho... | Read more »

Price Scanner via MacPrices.net

Adobe Brings Powerful Layout-Design Capabilit...

Adobe today announced the availability of Adobe Comp CC, a free iPad app that enables rapid creation of layout concepts for mobile, Web and print projects. With Comp CC, designers can rough out and... Read more

Apple offering refurbished 27-inch 5K iMacs f...

The Apple Store is offering Apple Certified Refurbished 27″ 3.5GHz 5K iMacs for $2119 including free shipping. Their price is $380 off the price of new models, and it’s the lowest price available for... Read more

16GB iPad mini on sale for $199, save $50

Walmart has 16GB iPad minis (1st generation) available for $199.99 on their online store, including free shipping. Their price is $50 off MSRP. Online orders only.
Read more

The Apple Store has Apple Certified Refurbished 13″ 2.6GHz/128GB Retina MacBook Pros available for $979 including free shipping. Original MSRP for this model was $1299.
Read more

Save up to $600 with Apple refurbished Mac Pr...

The Apple Store is offering Apple Certified Refurbished 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

Samsung Galaxy S 6 and Galaxy S 6 edge U.S. P...

Samsung Electronics America, Inc. has announced the Galaxy S 6 and Galaxy S 6 edge will be available in the U.S. beginning April 10, with pre-orders being accepted now.
“We have completely reimagined... Read more

13-inch 2.5GHz MacBook Pro (refurbished) avai...

The Apple Store has Apple Certified Refurbished 13″ 2.5GHz MacBook Pros available for $829, or $270 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free:
- 13″ 2.... Read more

MacTech is a registered trademark of Xplain Corporation. Xplain, "The journal of Apple technology", Apple Expo, Explain It, MacDev, MacDev-1, THINK Reference, NetProfessional, Apple Expo, MacTech Central, MacTech Domains, MacNews, MacForge, and the MacTutorMan are trademarks or service marks of Xplain Corporation. Sprocket is a registered trademark of eSprocket Corporation. Other trademarks and copyrights appearing in this printing or software remain the property of their respective holders. Not responsible for typographical errors.

All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.