TweetFollow Us on Twitter

Printing Windows
Volume Number:6
Issue Number:5
Column Tag:C Workshop

Related Info: Quickdraw TextEdit Picture Utilities

Printing Windows and Dialogs

By Kirk Chase, Anaheim, CA

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

Printing Windows

Not so long ago, I was working on a small, in-house project. I got it running, debugged it, and then showed it to a co-worker for that ever-refreshing pat on the back for a job well done. Well, the co-worker looked at it and played around with it for a moment. Then he looked up to me and said, “I can’t print it out!”

The project did not have the ability to print out its contents. It was small enough that I thought that nobody would ever be on it long enough to care about a hard copy print out. In fact, the only reason I had put a “save” and “open” procedure was because I had a small, single data structure that was easy to write out and read in. I figured printing was not really needed since the job was small and the window contents contained some items that were not made for printing (scroll bars, buttons, lists, and so on).

After talking myself into finding a way to print it out, I went back to the keyboard to try and find an easy, generic way, to print out the window. My first attempt was this:

1. Open up a picture.

2. Call the update procedure for my window, thereby recording the drawing commands.

3. Close the picture.

4. When it came time to print, I would draw the picture in the print port in a rectangle that was positioned where I wanted it to be.

This had all the elements of being simple. A quick “cut and paste” brought the print loop in. A few more lines of code, and I was printing out the picture just fine. It worked great, at least on windows that were not very complex. Another approach was needed for more complex windows.

Another Approach

Looking at my update procedure, I saw many simple drawing commands, a line here, a rectangle there, some text, and so on. So I said, why not just skip the picture and call the drawing routines directly when needed. Cut, cut, paste, paste. And all was well until I printed it out. Oh, most of it came out. I took a closer look at those items that did not show up on the printed page. There were no controls, no scrolling list, and no edit text field. A quick look at the offending structures all yielded a simple conclusion: they were all tied to the grafport that was my window. It was a battle between the window and the printer port. When it came time to draw those structures, they could not be coaxed into changing sides for just a moment. Well, no bucket of sand and metal was going to tell me what I could and could not print.

It was clear that I needed to put in a flag so that I could branch off to a different update routine when printing. Then I got to work on the structures: the TextEdit record, the list, and the controls.

The TextEdit record was fairly simple. I just changed the port temporarily to the print port. The code looked like this:

/* 1 */

if (theTE != NIL)
 if (!forPrinting)
 TEUpdate(&tempRect,theTE); /* normal updating */
 else {
 OldPort = (**theTE).inPort; /* change port in TE */
 GetPort(&aPort);
 (**theTE).inPort = aPort;
 TEUpdate(&tempRect,theTE); /* normal updating */
 (**theTE).inPort = OldPort; /* restore port in TE */
 }

Simple and sweet.

In Control

The control routines were a touch more difficult. I started out with my own version of DrawControls(). It looked like this:

/* 2 */

/* Draw or Print Controls */
 if (!forPrinting)
 DrawControls(MyWindow);
 else
 PrintControls(((WindowPeek) MyWindow)->controlList);

and the PrintControls() looked like this:

/* 3 */

PrintControls(theControl)
ControlHandle theControl;
{ /* PrintControls() */
ProcPtr controlRoutine;
long dummy;
int varCode;

while (theControl != NULL) { /* control loop */
 varCode = GetCVariant(theControl);
 
 HLock((Handle) (**theControl).contrlDefProc);
 controlRoutine =(ProcPtr) *((**theControl).contrlDefProc);
 dummy = CallPascalL(varCode, theControl, 0, 0L, controlRoutine); /* 
Call CDEF to Draw */
 HUnlock((Handle) (**theControl).contrlDefProc);
 
 theControl = (**theControl).nextControl;
 } /* control loop */
} /* PrintControls() */

What this bit of code does is this. It loops through the control list. It gets the control’s variant and CDEF proc. It then calls the control proc with the message to draw the control.

This worked like a dream except for the controls the that were inactive. In there place was a gray box. The problem was simple. When controls go inactive, for the most part, they just paint a gray rectangle over their control with the pen mode set to exclusive-or. This little trick “dims” the control. Unfortunately, the LaserWriter does not support this mode of drawing. Hence the gray box is the only thing that is seen (overdrawing the control). The only solution I could think of was to temporarily activate the control and then set it back when finished drawing. Something like this:

/* 4 */

PrintControls(theControl)
ControlHandle theControl;
{ /* PrintControls() */
ProcPtr controlRoutine;
long dummy;
int varCode, hilite;

while (theControl != NULL) { /* control loop */
 varCode = GetCVariant(theControl);
 hilite = (**theControl).contrlHilite;
 
 HiliteControl(theControl, 0); /* LW does not support XOR */
 HLock((Handle) (**theControl).contrlDefProc);
 controlRoutine =(ProcPtr) *((**theControl).contrlDefProc);
 dummy = CallPascalL(varCode, theControl, 0, 0L, controlRoutine); /* 
Call CDEF to Draw */
 HUnlock((Handle) (**theControl).contrlDefProc);
 HiliteControl(theControl, hilite);
 
 theControl = (**theControl).nextControl;
 } /* control loop */
} /* PrintControls() */

This worked out well, and I was happy again. In addition to this, it would work on all controls, not just the standard ones.

Next on the List

The next step was the printing of the list. This turned out to be the hardest. My first step was to try and fake out the list into thinking that it belonged to the printer port. No such luck. I then tried calling the LDEF like with the controls, still no luck. At last resort, I wrote a routine for just text lists. The call in my window update procedure looks like:

/* 5 */

if (List_I_AList != NIL)
 if (!forPrinting)
 LUpdate(MyWindow->visRgn,List_I_AList);
 else 
 PrintList(List_I_AList); /* call print list */

And PrintList() is as follows:

/* 6 */

PrintList(theList)
ListHandle theList;
{ /* PrintList() */
Cell lCell;
Rect lRect, dstRect;
int lDataOffset, lDataLen;
char dataPtr[255];

if (theList == NULL) return;
lCell.h =  0;
lCell.v = 0;
LDoDraw(TRUE, theList);
do { /* loop through cells */
 LFind(&lDataOffset, &lDataLen, lCell, theList);
 LGetCell(&dataPtr, &lDataLen, lCell, theList);
 
 LRect(&lRect, lCell, theList);
 if (SectRect(&((**theList).rView), &lRect, &dstRect))
 if (EqualRect(&lRect, &dstRect)) { /* Draw it */
 TextBox(&dataPtr, lDataLen, &lRect, teJustLeft);
 }
 } while (LNextCell(TRUE, TRUE, &lCell, theList)); /* loop through cells 
*/
} /* PrintList() */

What this procedure does is to loop through all the cells checking if the cell is visible. If it is, it extracts the text and prints it out using TextBox() (Not very efficient).

PrintWindow()

PrintWindow() is fairly simple. You need only offset the origin of the print port by the proper amount, set the printing flag, and call your update routine. In your update routine, you should make sure not to set the port to your window (do this before the call) and then check the printing flag to use the proper update routines for TE records, lists, and controls. PrintWindow() could stand for a few improvements.

1. Thumb controls are still not drawn.

2. A routine that handled any LDEF not just the standard text LDEF.

3. Scrolling the text in a TE record to the proper place.

4. Hilighting list and text selections.

Printing Dialogs

Dialogs turned out to be a bit more difficult. Granted, dialogs are not printed very often, but it is nice to be able to do so when the occasion requires. Drawing is a two step process. First you print the items in the dialog item list, and then you call any update routines you use (like bolding the default button) just as you did for printing the window. In my print loop, I call all the various drawing routines, passing it the port I wish to print, and let the various routines decide if this is their window/dialog or not.

The Dialog Item List

The dialog item list is found in the dialog structure as shown in figure 1.

Figure 1. The Dialog Structure

Figure 2. The Item List Structure

The item list is a more complicated structure. I found the item list at a single indirection rather than a double indirection (items in the dialog record is a pointer instead of a handle) Refer to figure 2 while I explain the item list structure.

The first item is a 2 byte number that is the number of items in the item list minus 1 (for 7 items, the number would be 6). Next comes the items.

Each item has a 4 byte placeholder for a handle to the object or a procedure pointer. The next 8 bytes are the display rectangle (Top, Left, Bottom, Right order). The next byte is the item type. The types are as follows:

0 User item (userItem)

4 Control item (ctrlItem)

add the following constants for the exact control

0 for a button (btnCtrl)

1 for a checkbox (chkCtrl)

2 for a radio button (radCtrl)

3 for a resource defined control (resCtrl)

8 Static text item (statText)

16 Editable text item (editText)

32 Icon (iconItem)

64 Picture (picItem)

In addition to this, for any disabled item, you add 128 (itemDisable).

Following the item type byte is a length byte of the data that is to follow. Then it is followed by that many bytes of data. If the number of bytes is odd, then an extra byte is added to pad the item to an even byte boundary. The length byte still contains the actual data length.

The data and the placeholder vary by the item type. A user item has 0 bytes of data and the placeholder is interpreted as a procedure pointer to the drawing routine. A picture or icon has the resource ID of the item in the data bytes and the placeholder holds the handle to the picture or icon. Static and edit text hold the default text in their data bytes; the placeholder holds a handle to the actual text. All controls, except for the resource defined control have their control titles in the data bytes; for a resource control, it has the resource ID number; the placeholder holds the control handle for all control types.

Printing the Dialog

My routine for printing the dialog is as follows:

/* 7 */

PrintDialog(d, s0, s1, s2, s3)
DialogPeek d;
Str255 s0, s1, s2, s3;
{ /* PrintDialog() */
ditlheader *dh;
Ptr p;
int itemCount, i, theItem, datalen;
int ResID, theType;
Handle hItem;
char text[256];
Rect tempRect, box;

p = (Ptr) *(*d).items;
itemCount = *((int *) p); /* get number of dialog items */

p = p + 2;
for (i=0; i<= itemCount; i++) { /* Item Loop */
 dh = (ditlheader *) p;
 
 /* get type */
 theItem = dh->itemType;
 if (theItem < 0)
 theItem = theItem * -1;
 if (theItem >= 128)
 theItem -= 128;
 
 /* get length of data */
 datalen = dh->dataLength;
 if ((datalen % 2) != 0)
 datalen += 1;
 
 switch (theItem) { /* ItemType Switch */
 case ctrlItem + btnCtrl: /* Standard Button */
 case ctrlItem + chkCtrl: /* Checkbox */
 case ctrlItem + radCtrl: /* Radio Button */
 case ctrlItem + resCtrl: /* Resource Control */
 PrintControls((ControlHandle) dh->HorP); /* Draw controls */
 break;
 
 case editText:
 case statText:
 GetDItem((DialogPtr) d, i + 1, &theType, &hItem, &box);
 GetIText(hItem, (Str255 *) text);
 PtoCstr(text);
 
 /* make substitution of ParamText */
 PtoCstr((char *) s0);
 PtoCstr((char *) s1);
 PtoCstr((char *) s2);
 PtoCstr((char *) s3);
 while(StrReplace(text, “^0”, (char *) s0));
 while(StrReplace(text, “^1”, (char *) s1));
 while(StrReplace(text, “^2”, (char *) s2));
 while(StrReplace(text, “^3”, (char *) s3));
 CtoPstr((char *) s0);
 CtoPstr((char *) s1);
 CtoPstr((char *) s2);
 CtoPstr((char *) s3);
 
 TextBox(text, strlen(text), &(dh->displayRect), teJustLeft); /* draw 
text */
 if (theItem == editText) { /* draw edit text box */
 tempRect = dh->displayRect;
 FrameRect(&tempRect);
 } 
 break;
 
 case iconItem:
 PlotIcon(&(dh->displayRect), (Handle) dh->HorP); /* draw icon */
 break;
 
 case picItem:
 DrawPicture((PicHandle) dh->HorP, &(dh->displayRect)); /* draw picture 
*/
 break;
 
 case userItem:
 CallPascal((WindowPtr) ThePrintPort, i+ 1, (ProcPtr) dh->HorP); /* draw 
user item */
 break;
 
 default:
 break;
 } /* ItemType Switch */
 p = p + sizeof(ditlheader) + datalen;
 } /* Item Loop */
} /* PrintDialog() */

The first step in the routine is to figure out how many items there are in the item list. Then it loops through the item getting the associated data and moving the pointer if needed so that it can get the next dialog item.

It then switches on the item type (accounting for any disabled items in the process). For controls, it just sends the placeholder as a control handle to my PrintControls() that I wrote for printing a window. For icons and pictures, it interprets the placeholder as an icon or picture handle and calls the toolbox routines for printing these items. For user items, it calls the procedure pointer found in the placeholder.

Editable and static text took just a little more coding. After calling GetDItem() and GetIText() to get the actual text, I call a substitution routine to remove the parameter text characters (“^0”, “^1”, “^2”, “^3”) with the strings passed to PrintDialog(). The substitution routine makes the first possible substitution then returns 1 if a substitution was made and 0 if no substitutions were made. Putting the call in a while loop removes all occurrences. After this, it just calls TextBox() again to draw the text, and, if the item was an edit text item, it frames the box.

Conclusion

All in all, printing dialogs and windows are not too hard with a little work on the drawing procedures and an routine to go through a dialog’s item list. In my listing, I reference "Messenger.h" which was in last month's MacTutor. These routines are not made for printing out more than the contents of the window or dialog that you can see. It is not made for text editors or drawing applications. But if the window just needs a quick print with minimal set up, PrintWindow() and PrintDialog() are for you.

Listing:  PrintWD.c

/*******************
PrintWD.c
*******************/

/**********************
Include files
***********************/
#include “String.h”
#include “Messenger.h”
#include “PrintTraps.h”

/**********************
Structures
***********************/
typedef struct ditlheader {
 long HorP;
 Rect displayRect;
 char itemType;
 char dataLength;
 } ditlheader, *ditlheaderPtr, **ditlheaderHdl;

/**********************
Globals
***********************/
THPrint ThePrintRec; /* Printing Stuff */
TPPrPortThePrintPort;
TPrStatus PrintStatus;
Rect  PageRect;
char  forPrinting;

/*************************************************/
/*********** Printing Routines *******************/
/*************************************************/

/***************************/
/* PrintControls() handles printing of standard buttons */
PrintControls(theControl)
ControlHandle theControl;
{ /* PrintControls() */
ProcPtr controlRoutine;
long dummy;
int varCode, hilite;

while (theControl != NULL) { /* control loop */
 varCode = GetCVariant(theControl);
 hilite = (**theControl).contrlHilite;
 
 HiliteControl(theControl, 0); /* LW does not support XOR */
 HLock((Handle) (**theControl).contrlDefProc);
 controlRoutine =(ProcPtr) *((**theControl).contrlDefProc);
 dummy = CallPascalL(varCode, theControl, 0, 0L, controlRoutine); /* 
Call CDEF to Draw */
 HUnlock((Handle) (**theControl).contrlDefProc);
 HiliteControl(theControl, hilite);
 
 theControl = (**theControl).nextControl;
 } /* control loop */
} /* PrintControls() */

/***************************/
/* PrintList() handles printing of standard list */
PrintList(theList)
ListHandle theList;
{ /* PrintList() */
Cell lCell;
Rect lRect, dstRect;
int lDataOffset, lDataLen;
char dataPtr[255];

if (theList == NULL) return;
lCell.h =  0;
lCell.v = 0;
LDoDraw(TRUE, theList);
do { /* loop through cells */
 LFind(&lDataOffset, &lDataLen, lCell, theList);
 LGetCell(&dataPtr, &lDataLen, lCell, theList);
 LRect(&lRect, lCell, theList);
 if (SectRect(&((**theList).rView), &lRect, &dstRect))
 if (EqualRect(&lRect, &dstRect)) { /* Draw it */
 TextBox(&dataPtr, lDataLen, &lRect, teJustLeft);
 }
 } while (LNextCell(TRUE, TRUE, &lCell, theList)); /* loop through cells 
*/
} /* PrintList() */

/***************************/
/* StrReplace() substitutes the first occurrence of t with r in s.  It 
returns TRUE if there was a substitution*/
int StrReplace(s, t, r)
char *s, *t, *r;
{ /* StrReplace() */
char temp[256], *p;

strcpy(temp, s);
p = strstr(temp, t); /* find first occurrence */
if (*p == ‘\0’) return (0); /* no occurence */

*p = ‘\0’; /* delete t */
p = p + strlen(t); /* go to second half of string */

strcpy(s, temp); /* get first part */
strcat(s, r); /* put in replacement */
strcat(s, p); /* put in second half */

return (1);
} /* StrReplace() */

/***************************/
/* PrintDialog() 
prints dialog substituting sX for ParamText */     
PrintDialog(d, s0, s1, s2, s3)
DialogPeek d;
Str255 s0, s1, s2, s3;
{ /* PrintDialog() */
ditlheader *dh;
Ptr p;
int itemCount, i, theItem, datalen;
int ResID, theType;
Handle hItem;
char text[256];
Rect tempRect, box;

p = (Ptr) *(*d).items;
itemCount = *((int *) p); /* get number of dialog items */

p = p + 2;
for (i=0; i<= itemCount; i++) { /* Item Loop */
 dh = (ditlheader *) p;
 
 /* get type */
 theItem = dh->itemType;
 if (theItem < 0)
 theItem = theItem * -1;
 if (theItem >= 128)
 theItem -= 128;
 
 /* get length of data */
 datalen = dh->dataLength;
 if ((datalen % 2) != 0)
 datalen += 1;
 
 switch (theItem) { /* ItemType Switch */
 case ctrlItem + btnCtrl: /* Standard Button */
 case ctrlItem + chkCtrl: /* Checkbox */
 case ctrlItem + radCtrl: /* Radio Button */
 case ctrlItem + resCtrl: /* Resource Control */
 PrintControls((ControlHandle) dh->HorP); /* Draw controls */
 break;
 
 case editText:
 case statText:
 GetDItem((DialogPtr) d, i + 1, &theType, &hItem, &box);
 GetIText(hItem, (Str255 *) text);
 PtoCstr(text);
 
 /* make substitution of ParamText */
 PtoCstr((char *) s0);
 PtoCstr((char *) s1);
 PtoCstr((char *) s2);
 PtoCstr((char *) s3);
 while(StrReplace(text, “^0”, (char *) s0));
 while(StrReplace(text, “^1”, (char *) s1));
 while(StrReplace(text, “^2”, (char *) s2));
 while(StrReplace(text, “^3”, (char *) s3));
 CtoPstr((char *) s0);
 CtoPstr((char *) s1);
 CtoPstr((char *) s2);
 CtoPstr((char *) s3);
 
 TextBox(text, strlen(text), &(dh->displayRect), teJustLeft); /* draw 
text */
 if (theItem == editText) { /* draw edit text box */
 tempRect = dh->displayRect;
 FrameRect(&tempRect);
 } 
 break;
 
 case iconItem:
 PlotIcon(&(dh->displayRect), (Handle) dh->HorP); /* draw icon */
 break;
 
 case picItem:
 DrawPicture((PicHandle) dh->HorP, &(dh->displayRect)); /* draw picture 
*/
 break;
 
 case userItem:
 CallPascal((WindowPtr) ThePrintPort, i+ 1, (ProcPtr) dh->HorP); /* draw 
user item */
 break;
 
 default:
 break;
 } /* ItemType Switch */
 p = p + sizeof(ditlheader) + datalen;
 } /* Item Loop */
} /* PrintDialog() */

/***************************/
/* InitPrint() initializes print variables */
InitPrint()
{
ThePrintRec = NUL;
PrOpen();
ThePrintRec = (THPrint) NewHandle(sizeof(TPrint));
PrintDefault(ThePrintRec);
PageRect = (*ThePrintRec)->prInfo.rPage;
PrClose();
forPrinting = FALSE;
PrSetError(noErr);
} /* end InitPrint() */

/***************************/
/* doPageSetUp() handles page setup dialog */
doPageSetUp()
{
char  confirmed;
WindowPtr SavePort;
OSErr theError;

InitCursor();
GetPort(&SavePort);
PrOpen();
confirmed = PrValidate(ThePrintRec);
confirmed = PrStlDialog(ThePrintRec);
PrClose();
theError = PrError();
SetPort(SavePort);
if (confirmed) {
 PageRect = (*ThePrintRec)->prInfo.rPage;
 }
} /* end doPageSetUp() */

/***************************/
/* PrintWindow() handles printing */
PrintWindow(theWindow)
WindowPtr theWindow;
{
char  DoIt; /* flag to do printing */
TPrStatus PrintStatus; /* print variables */
TPPrPortmyPrPort;
WindowPtr savePort;
intcopies, i, j, firstPage, lastPage, oldiPlayer;
char  dummy;
Rect  tempRect, pictRect, nameRect, windowRect;
OSErr theError;
GrafPtr aPort;
Point oldOrigin;

GetPort(&savePort); /* initialize printing */
InitCursor();
PrOpen();

if (PrError() == noErr){ /* do print dialog */
 DoIt = PrValidate(ThePrintRec);
 DoIt = PrJobDialog(ThePrintRec);
 dummy = (int) AnOSError(PrError(), “\pProblem with Print Dialog”, “\p”);
 
 if (DoIt && !dummy) { /* Print Document */
 tempRect = theWindow->portRect;
 /* SetCursor(*watch); */
 InsetRect(&tempRect, -4, -4);
 pictRect = tempRect; /* set print variables up */
 PositionRect(&pictRect, &PageRect, CENTER, THIRD);
 
 ThePrintPort = PrOpenDoc(ThePrintRec, NUL, NUL);
 theError = PrError();
 if (!AnOSError(theError, “\pProblem with Printer”, “\p”)) { /* good 
port */
 /* get copies and page range */
 copies = (*ThePrintRec)->prJob.iCopies;
 firstPage = (*ThePrintRec)->prJob.iFstPage;
 lastPage = (*ThePrintRec)->prJob.iLstPage;

 if ((*ThePrintRec)->prJob.bJDocLoop == bSpoolLoop) /* check for spooling 
*/
 copies = 1;
 
 /* check bad page range */
 if (firstPage > lastPage) {
 InitCursor();
 dummy = Message(M_OK, noIcon, “\pBad page range”, “\p”, “\p”, “\p”);
 }
 else { /* good page range */
 for (i=0; i<copies; i++) { /* valid picture */
 PrOpenPage(ThePrintPort, NUL); /* print page */
 theError = PrError();
 if (!AnOSError(theError, “\pProblem with page”, “\p”)) {
 FrameRect(&pictRect);
 GetPort(&aPort);
 oldOrigin = topLeft(aPort->portRect);
 SetOrigin(oldOrigin.h - pictRect.left, oldOrigin.v - pictRect.top);
 forPrinting = TRUE;
 
 UpDate_MyWindow(theWindow);
 UpDate_AboutDialog(theWindow);
 UpDate_TestDialog(theWindow);
 
 forPrinting = FALSE;
 SetOrigin(oldOrigin.h, oldOrigin.v);
 
 }
 PrClosePage(ThePrintPort);
 } /*  end valid picture */
 }
 } /* end else good port */
 PrCloseDoc(ThePrintPort);
 if (((*ThePrintRec)->prJob.bJDocLoop == bSpoolLoop) && (PrError() == 
noErr))
 PrPicFile(ThePrintRec, NUL, NUL, NUL, &PrintStatus); 
 /* print spool file, if any */
 
 } /* end of print document */
 } /* no error on PrOpen() */

PrClose();
SetPort(savePort);
InvalRect(&tempRect);
InitCursor();
} /* end doPrint() */
 
AAPL
$99.02
Apple Inc.
+1.35
MSFT
$43.97
Microsoft Corpora
-0.53
GOOG
$590.60
Google Inc.
+1.58

MacTech Search:
Community Search:

Software Updates via MacUpdate

Acorn 4.4 - Bitmap image editor. (Demo)
Acorn is a new image editor built with one goal in mind - simplicity. Fast, easy, and fluid, Acorn provides the options you'll need without any overhead. Acorn feels right, and won't drain your bank... Read more
Bartender 1.2.20 - Organize your menu ba...
Bartender lets you organize your menu bar apps. Features: Lets you tidy your menu bar apps how you want. See your menu bar apps when you want. Hide the apps you need to run, but do not need to... Read more
TotalFinder 1.6.2 - Adds tabs, hotkeys,...
TotalFinder is a universally acclaimed navigational companion for your Mac. Enhance your Mac's Finder with features so smart and convenient, you won't believe you ever lived without them. Tab-based... Read more
Vienna 3.0.0 RC 2 :be5265e: - RSS and At...
Vienna is a freeware and Open-Source RSS/Atom newsreader with article storage and management via a SQLite database, written in Objective-C and Cocoa, for the OS X operating system. It provides... Read more
VLC Media Player 2.1.5 - Popular multime...
VLC Media Player is a highly portable multimedia player for various audio and video formats (MPEG-1, MPEG-2, MPEG-4, DivX, MP3, OGG, ...) as well as DVDs, VCDs, and various streaming protocols. It... Read more
Default Folder X 4.6.7 - Enhances Open a...
Default Folder X attaches a toolbar to the right side of the Open and Save dialogs in any OS X-native application. The toolbar gives you fast access to various folders and commands. You just click... Read more
TinkerTool 5.3 - Expanded preference set...
TinkerTool is an application that gives you access to additional preference settings Apple has built into Mac OS X. This allows to activate hidden features in the operating system and in some of the... Read more
Audio Hijack Pro 2.11.0 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Intermission 1.1.1 - Pause and rewind li...
Intermission allows you to pause and rewind live audio from any application on your Mac. Intermission will buffer up to 3 hours of audio, allowing users to skip through any assortment of audio... Read more
Autopano Giga 3.6 - Stitch multiple imag...
Autopano Giga allows you to stitch 2, 20, or 2,000 images. Version 3.0 integrates impressive new features that will definitely make you adopt Autopano Pro or Autopano Giga: Choose between 9... Read more

Latest Forum Discussions

See All

Traps n’ Gemstones Review
Traps n’ Gemstones Review By Campbell Bird on July 28th, 2014 Our Rating: :: CASTLEVANIA JONESUniversal App - Designed for iPhone and iPad Fight mummies, dig tunnels, and ride a runaway minecart to discover ancient secrets in this... | Read more »
The Phantom PI Mission Apparition Review
The Phantom PI Mission Apparition Review By Jordan Minor on July 28th, 2014 Our Rating: :: GHOSTS BUSTEDUniversal App - Designed for iPhone and iPad The Phantom PI is an exceedingly clever and well-crafted adventure game.   | Read more »
More Stubies Are Coming Your Way in a Ne...
More Stubies Are Coming Your Way in a New Update Posted by Jessica Fisher on July 28th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
The Great Prank War Review
The Great Prank War Review By Nadia Oxford on July 28th, 2014 Our Rating: :: PRANKING IS SERIOUS BUSINESSUniversal App - Designed for iPhone and iPad Though short, The Great Prank War offers an interesting and fun mix of action and... | Read more »
Marvel Contest of Champions Announced at...
Marvel Contest of Champions Announced at Comic-Con Posted by Jennifer Allen on July 28th, 2014 [ permalink ] Announced over the weekend at San Diego Comic-Con was the fairly exciting looking Marvel Contest of Champions. | Read more »
Teenage Mutant Ninja Turtles Review
Teenage Mutant Ninja Turtles Review By Jennifer Allen on July 28th, 2014 Our Rating: :: DULL SWIPINGUniversal App - Designed for iPhone and iPad The pizza power is weak when it comes to this Teenage Mutant Ninja Turtles game.   | Read more »
Exploration Focused Puzzle Game Beatbudd...
Exploration Focused Puzzle Game Beatbuddy Set to Make Transition from PC to iOS this September Posted by Jennifer Allen on July 28th, 2014 [ permalink ] | Read more »
PlanetHD
PlanetHD By Nadia Oxford on July 28th, 2014 Our Rating: :: SPACE MADNESSUniversal App - Designed for iPhone and iPad PlanetHD will keep players busy for a while, though its unpredictable physics are a handful to deal with.   | Read more »
This Week at 148Apps: July 21-25, 2014
Another Week of Expert App Reviews   At 148Apps, we help you sort through the great ocean of apps to find the ones we think you’ll like and the ones you’ll need. Our top picks become Editor’s Choice, our stamp of approval for apps with that little... | Read more »
Reddme for iPhone - The Reddit Client (...
Reddme for iPhone - The Reddit Client 1.0 Device: iOS iPhone Category: News Price: $.99, Version: 1.0 (iTunes) Description: Reddme for iPhone is an iOS 7-optimized Reddit client that offers a refreshing new way to experience Reddit... | Read more »

Price Scanner via MacPrices.net

13-inch 2.5GHz MacBook Pro on sale for $1099,...
Best Buy has the 13″ 2.5GHz MacBook Pro available for $1099.99 on their online store. Choose free shipping or free instant local store pickup (if available). Their price is $100 off MSRP. Price is... Read more
Roundup of Apple refurbished MacBook Pros, th...
The Apple Store has Apple Certified Refurbished 13″ and 15″ MacBook Pros available for up to $400 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free. Their prices... Read more
Record Mac Shipments In Q2/14 Confound Analys...
A Seeking Alpha Trefis commentary notes that Apple’s fiscal Q3 2014 results released July 22, beat market predictions on earnings, although revenues were slightly lower than anticipated. Apple’s Mac’... Read more
Intel To Launch Core M Silicon For Use In Not...
Digitimes’ Monica Chen and Joseph Tsai, report that Intel will launch 14nm-based Core M series processors specifically for use in fanless notebook/tablet 2-in-1 models in Q4 2014, with many models to... Read more
Apple’s 2014 Back to School promotion: $100 g...
 Apple’s 2014 Back to School promotion includes a free $100 App Store Gift Card with the purchase of any new Mac (Mac mini excluded), or a $50 Gift Card with the purchase of an iPad or iPhone,... Read more
iMacs on sale for $150 off MSRP, $250 off for...
Best Buy has iMacs on sale for up to $160 off MSRP for a limited time. Choose free home shipping or free instant local store pickup (if available). Prices are valid for online orders only, in-store... Read more
Mac minis on sale for $100 off MSRP, starting...
Best Buy has Mac minis on sale for $100 off MSRP. Choose free shipping or free instant local store pickup. Prices are for online orders only, in-store prices may vary: 2.5GHz Mac mini: $499.99 2.3GHz... Read more
Global Tablet Market Grows 11% in Q2/14 Notwi...
Worldwide tablet sales grew 11.0 percent year over year in the second quarter of 2014, with shipments reaching 49.3 million units according to preliminary data from the International Data Corporation... Read more
New iPhone 6 Models to Have Staggered Release...
Digitimes’ Cage Chao and Steve Shen report that according to unnamed sources in Apple’s upstream iPhone supply chain, the new 5.5-inch iPhone will be released several months later than the new 4.7-... Read more
New iOS App Helps People Feel Good About thei...
Mobile shoppers looking for big savings at their favorite stores can turn to the Goodshop app, a new iOS app with the latest coupons and deals at more than 5,000 online stores. In addition to being a... Read more

Jobs Board

*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
Sr. Product Leader, *Apple* Store Apps - Ap...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring 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
*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
WW Sales Program Manager, *Apple* Online St...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.