TweetFollow Us on Twitter

Building PICT 2
Volume Number:10
Issue Number:3
Column Tag:Getting Started

Related Info: List Manager Resource Manager

Using The List Manager

Building and using a list of PICT resources

By Dave Mark, MacTech Magazine Regular Contributing Author

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

Last month’s column presented PictLister, a program designed to showcase the Mac Toolbox’s List Manager. The vast majority of Macintosh applications make use of the List Manager, albeit indirectly. Figure 1 shows a call to StandardGetFile(), the Mac Toolbox’s standard mechanism for selecting a file to open. The scrolling list in Figure 1 was implemented by the List Manager.

Figure 1. The List Manager, as used by StandardGetFile().

Just as a reminder, we’ll put PictLister through its paces before we walk through the source code. Startup THINK C by double-clicking on the file PictLister.Π. When the project opens, select Run from the Project menu.

PictLister features three menus: Apple, File, and Edit. Figure 2 shows the File menu.

Figure 2. PictLister’s File menu.

Close closes the frontmost window and Quit quits PictLister. New List builds a list out of all available PICT resources, then creates a window to display the list. It’s important to note that the Resource Manager searches all open resource files in its quest for a particular resource type. At the very least, this search includes the application’s resource fork as well as the System file in the currently blessed System Folder (a.k.a., the System on the startup disk).

Figure 3 shows a sample PictLister window.

Figure 3. A PictLister window.

The entire content region of the window (including both scroll bars, but not the window’s title bar) is dedicated to the window’s list. With very little effort on our part (just a call here or there) the List Manager will handle the scroll bars, clicks in the list, auto-scrolling (click in the bottom of the list and drag down), update events, etc. As you’ll see, the List Manager gives you a lot of functionality with very little work on your part.

Once the PictLister window appears, you can do all the normal window-type things. You can drag the window, resize it, and close it by clicking in the close box.

If you click on a name in the list, the List Manager will highlight the name. Click on another name, the first name will be unhighlighted, then that name will be highlighted. If you double-click on a name, a new window will appear showing the specified PICT.

By the way, the names in the list are drawn directly from the names of the associated PICT resource. If the resource isn’t named, we use the string “Unnamed” to name the string.

Walking Through the Source Code

PictLister starts off with a bunch of #defines, some familiar, some not. As usual, you’ll see what they do in context.


/* 1 */
#define kMBARResID 128
#define kSleep   60L
#define kMoveToFront (WindowPtr)-1L
#define kNilFilterProc    (ProcPtr)0L
#define kEmptyString "\p"
#define kHasGoAway true
#define kInvisible false

#define kListDefProc 0
#define kDontDrawYet false
#define kHasGrow true
#define kHasHScrolltrue
#define kHasVScrolltrue
#define kFindNexttrue

#define kListWindow0
#define kDAWindow1
#define kUnknownWindow    2
#define kPictWindow3
#define kNilWindow 4

#define kMinWindowWidth   210
#define kMinWindowHeight  63
#define kWindowHeight255
#define kMinPictWinHeight 50
#define kMinPictWinWidth  150

#define mApple   128
#define iAbout   1

#define mFile    129
#define iNewList 1
#define iClose   2
#define iQuit    4

#define kErrorAlertID128

Frequently, you’ll want to attach additional information to a window. Suppose you wrote a program that implemented a personal phone book. Suppose your program creates an individual window for each person in the phone book. Each window would have the same fields but would contain different data to place in the fields when the window was updated.

One way to write this program is to create a struct containing the data for each window, allocate memory for the struct when you create the window, then tie it to the window. When it comes time to update the window, retrieve the struct tied to that window and use the data in the struct to fill in the window’s fields. This technique is known as window piggybacking. You’ll see how this works as we walk through the code.!cuses the piggybacking technique to tie the list to the list window and to tie the PICT to the PICT window. This is done by embedding a WindowRecord in each of the following typedefs.


/* 2 */
/************************/
/*      Typedefs        */
/************************/

typedef struct
{
 WindowRecord  w;
 short  wType;
 ListHandle list;
} ListRecord, *ListPeek;

typedef struct
{
 WindowRecord  w;
 short  wType;
 short  PictResID;
} PictRecord, *PictPeek;

Since NewWindow() allows you to allocate your own memory for your windows, you can allocate one of the above structs instead, passing a pointer to the struct to NewWindow(). To refer to the WindowRecord, just cast the struct pointer to a WindowPtr. This works because the WindowRecord is the first element in the struct. To refer to the entire struct, cast the struct pointer to a ListPeek or PictPeek, depending on which struct you are referring to.

Given a WindowPtr, how do you know which struct type is piggybacked on top of the window? That’s what the wType field is for. When the struct is allocated, the wType field is set to either kListWindow or kPictWindow. You’ll see how all this works as we go along.

The global variable gDone serves its usual role, indicating when it’s time to drop out of the main event loop. gNewWindowX and gNewWindowY specify the upper left corner of the next window to be created.


/* 3 */
/*************/
/*  Globals  */
/*************/

Boolean gDone;
short   gNewWindowX = 20, gNewWindowY = 50;

As usual, we provide a function prototype for each function in the source file.


/* 4 */
/***************/
/*  Functions  */
/***************/

void    ToolboxInit( void );
void    MenuBarInit( void );
void    CreateListWindow( void );
void    DestroyWindow( WindowPtr w );
void    EventLoop( void );
void    DoEvent( EventRecord *eventPtr );
void    DoUpdate( EventRecord *eventPtr );
void    DoActivate( EventRecord *eventPtr );
void    HandleMouseDown( EventRecord *eventPtr );
void    DoContentClick( EventRecord *eventPtr, WindowPtr w );
void    CreatePictWindow( ListHandle list );
void    BumpGlobalXandY( void );
void    DoGrow( EventRecord *eventPtr, WindowPtr w );
void    HandleMenuChoice( long menuChoice );
void    HandleAppleChoice( short item );
void    HandleFileChoice( short item );
void    CenterWindow( WindowPtr w );
void    CenterPict( PicHandle picture, Rect *destRectPtr );
short WindowType( WindowPtr window );
void    DoError( Str255 errorString );

main() initializes the Toolbox, sets up the menu bar, then enters the main event loop.


/* 5 */
/********************* main *********************/

void    main( void )
{
 ToolboxInit();
 MenuBarInit();
 
 EventLoop();
}

ToolboxInit() does its usual thing.


/* 6 */
/********************* ToolboxInit *********************/

void    ToolboxInit( void )
{
 InitGraf( &thePort );
 InitFonts();
 InitWindows();
 InitMenus();
 TEInit();
 InitDialogs( nil );
 InitCursor();
}

MenuBarInit() loads the MBAR, adds the normal resources to the Apple menu, and draws the menu bar.


/* 7 */
/********************* MenuBarInit *********************/

void    MenuBarInit( void )
{
 Handle menuBar;
 MenuHandle menu;
 
 menuBar = GetNewMBar( kMBARResID );
 SetMenuBar( menuBar );

 menu = GetMHandle( mApple );
 AddResMenu( menu, 'DRVR' );
 
 DrawMenuBar();
}

CreateListWindow() gets called when New List... is selected from the File menu. It starts by creating a Rect that specifies the size and position of the new window.


/* 8 */
/********************* CreateListWindow *********************/

void    CreateListWindow( void )
{
 Rect   r, dataBounds;
 WindowPtrw;
 Point  cSize, cIndex;
 ListHandle list;
 short  i, dummy, numPicts;
 Handle rHandle;
 short  resID;
 ResTypetheResType;
 Str255 rName;
 Ptr    wStorage;
 ListPeek l;
 
 SetRect( &r, gNewWindowX, gNewWindowY, gNewWindowX + 
 kMinWindowWidth, gNewWindowY + kWindowHeight);

The routine BumpGlobalXandY() increment gNewWindowX and gNewWindowY to the preferred position for the next window.


/* 9 */
 BumpGlobalXandY();

Since we’re creating a list window, we’ll allocate a ListRecord and pass a pointer to it to NewWindow().


/* 10 */
 wStorage = NewPtr( sizeof( ListRecord ) );
 
 w = NewWindow( wStorage, &r, "\pPicture List", kInvisible,
 documentProc, kMoveToFront, kHasGoAway, 0L );

 SetPort( w );

The call to TextFont() ensures that the list is drawn using the system font (Chicago).


/* 11 */
 TextFont( systemFont );

Next, we’ll prepare to create our list. dataBounds specifies the initial size of the list. In this case, we’re specifying a list 1 column wide and 0 rows deep. We’ll add rows to the list a little later.


/* 12 */
 SetRect( &dataBounds, 0, 0, 1, 0 );

cSize specifies the size, in pixels, of each cell in the list. By passing (0,0) as the cell size, we ask the List Manager to calcualte the size for us.


/* 13 */
 SetPt( &cSize, 0, 0 );

Finally, r is a Rect that specifies the bounds of the list. Note that the scroll bars are drawn outside this area.


/* 14 */
 SetRect (&r, 0, 0, kMinWindowWidth -15, kWindowHeight -15);

The list is created via a call to LNew(). kDontDrawYet tells the List Manager not to draw the list yet. We’ll draw the list later, once we add all the rows to it. kHasGrow, kHasHScroll, and kHasHScroll tell the List Manager to add two scroll bars and a grow box to the list.


/* 15 */
 list = LNew( &r, &dataBounds, cSize, kListDefProc,
 w, kDontDrawYet, kHasGrow, kHasHScroll, kHasVScroll );

LNew() returns a handle to a ListRec, the data structure representing the list. The selFlags field lets you specify how the list reacts to clicks in the list. We’ll use the flag lOnlyOne to tell the List Manager that only one item at a time can be highlighted in this list.


/* 16 */
 (**list).selFlags = lOnlyOne;

Our next step is to set the fields in our piggybacking list struct. We’ll set wType to kListWindow and save the handle to the ListRec for later recall.


/* 17 */
 l = (ListPeek)w;
 
 l->wType = kListWindow;
 l->list = list;

This next chunk of code adds the rows to the list. We’ll add one row to the list for every available PICT resource.


/* 18 */
 numPicts = CountResources( 'PICT' );
 
 for ( i = 0; i<numPicts; i++ )
 {

For each resource, retrieve the resource handle using GetIndResource(), then call GetResInfo() to retrieve the resource name, if it exists.


/* 19 */
 rHandle = GetIndResource( 'PICT', i + 1 );
 GetResInfo( rHandle, &resID, &theResType, rName );

LAddRow() adds 1 row the list specified by list. cIndex is set to the cell in the first (and only) column and in the i-th row.


/* 20 */
 dummy = LAddRow( 1, i, list );
 SetPt( &cIndex, 0, i );

Next, the data is added to the cell specified by cIndex. If the resource is not named, the string “<Unnamed>” is used instead.


/* 21 */
 if ( rName[ 0 ] > 0 )
 LAddToCell( &(rName[1]), rName[0], cIndex, list );
 else
 LAddToCell( "<Unnamed>", 10, cIndex, list );
 }

Next, the window is made visible, and LDoDraw() is called to enable drawing in the list. This doesn’t mean that the list will be drawn at this point. Instead, the next time the List Manager is asked to draw the list (perhaps via a call to LUpdate(), it will be able to.


/* 22 */
 ShowWindow( w );
 LDoDraw( true, list );
}

DestroyWindow() is called to close and deallocate the specified window.


/* 23 */
/********************* DestroyWindow *********************/

void    DestroyWindow( WindowPtr w )
{
 ListPeek l;

If the window is a list window, we need to deallocate the memory allocated for the list by calling LDispose() and then the memory allocated for the window itself by calling DisposePtr().


/* 24 */
 if ( WindowType( w ) == kListWindow )
 {
 HideWindow( w );
 l = (ListPeek)w;
 
 LDispose( l->list );
 
 CloseWindow( w );
 
 DisposePtr( (Ptr)w );
 }

If the window was a PICT window, all we need to deallocate is the memory allocated for the window.


/* 25 */
 else if ( WindowType( w ) == kPictWindow )
 {
 CloseWindow( w );
 DisposePtr( (Ptr)w );
 }
}

EventLoop() does what it always did.


/* 26 */
/********************* EventLoop *********************/

void    EventLoop( void )
{
 EventRecordevent;
 
 gDone = false;
 while ( gDone == false )
 {
 if ( WaitNextEvent( everyEvent, &event, kSleep, NULL ) )
 DoEvent( &event );
 }
}

DoEvent() dispatches the specified event.


/* 27 */
/********************* DoEvent *********************/

void    DoEvent( EventRecord *eventPtr )
{
 char   theChar;
 
 switch ( eventPtr->what )
 {
 case mouseDown: 
 HandleMouseDown( eventPtr );
 break;
 case keyDown:
 case autoKey:
 theChar = eventPtr->message & charCodeMask;
 if ( (eventPtr->modifiers & cmdKey) != 0 ) 
 HandleMenuChoice( MenuKey( theChar ) );
 break;
 case updateEvt:
 DoUpdate( eventPtr );
 break;
 case activateEvt:
 DoActivate( eventPtr );
 break;
 }
}

DoUpdate() handles update events.


/* 28 */
/********************* DoUpdate *********************/

void    DoUpdate( EventRecord *eventPtr )
{
 WindowPtrw;
 short  numPicts, i;
 ListPeek l;
 ListHandle list;
 GrafPtroldPort;
 Rect   r;
 Point  cellIndex;
 PicHandlepic;
 PictPeek p;

We’ll retrieve the WindowPtr from the EventRecord. As always, we’ll sandwich our update processing code between calls to BeginUpdate() and EndUpdate().


/* 29 */
 w = (WindowPtr)(eventPtr->message);
 BeginUpdate( w );

If the window is a list window (See explanation of WindowType() later in the column), we’ll retrieve the list handle from the piggybacking list struct, redraw the grow box, then call LUpdate() to update the list as needed. Simple, eh?


/* 30 */
 if ( WindowType( w ) == kListWindow )
 {
 GetPort( &oldPort );
 SetPort( w );
 
 l = (ListPeek)w;
 list = l->list;
 
 DrawGrowIcon( w );
 
 LUpdate( (**list).port->visRgn, list );
 
 SetPort( oldPort );
 }

If the window is a pict window, we’ll retrieve the PICT resource id from the piggybacked pict struct, retrieve the PICT resource by calling GetPicture(), then center and draw the picture.


/* 31 */
 else if ( WindowType( w ) == kPictWindow )
 {
 GetPort( &oldPort );
 SetPort( w );
 
 r = w->portRect;
 
 p = (PictPeek)w;
 
 pic = GetPicture( p->PictResID );
 
 CenterPict( pic, &r );
 DrawPicture( pic, &r );
 
 SetPort( oldPort );
 }
 EndUpdate( w );
}

DoActivate() handles activate events. Since the Pict window doesn’t need any special activate event processing, all we have to do is handle list window activates.


/* 32 */
/********************* DoActivate *********************/

void    DoActivate( EventRecord *eventPtr )
{
 WindowPtrw;
 ListPeek l;
 ListHandle list;
 
 w = (WindowPtr)(eventPtr->message);

If the window receiving the activate event is a list window, we’ll check to see whether the activate event is an activate or deactivate event, then make the appropriate call to LActivate(), then redraw the grow box.


/* 33 */
 if ( WindowType( w ) == kListWindow )
 {
 l = (ListPeek)w;
 list = l->list;
 
 if ( eventPtr->modifiers & activeFlag )
 LActivate( true, list );
 else
 LActivate( false, list );
 
 DrawGrowIcon( w );
 }
}

Most of HandleMouseDown() should look familiar to you.


/* 34 */
/********************* HandleMouseDown *********************/

void    HandleMouseDown( EventRecord *eventPtr )
{
 WindowPtrwindow;
 short  thePart;
 long   menuChoice;
 GrafPtroldPort;
 long   windSize;
 Rect   growRect;
 
 thePart = FindWindow( eventPtr->where, &window );
 
 switch ( thePart )
 {
 case inMenuBar:
 menuChoice = MenuSelect( eventPtr->where );
 HandleMenuChoice( menuChoice );
 break;
 case inSysWindow : 
 SystemClick( eventPtr, window );
 break;
 case inContent:
 DoContentClick( eventPtr, window );
 break;
 case inGrow:
 DoGrow( eventPtr, window );
 break;
 case inDrag : 
 DragWindow( window, eventPtr->where, 
 &screenBits.bounds );
 break;

The one exception is the call to DestroyWindow() when the mouse is clicked in the go away box.


/* 35 */
 case inGoAway:
 if ( TrackGoAway( window, eventPtr->where ) )
 DestroyWindow( window );
 break;
 }
}

DoContentClick() is called when the mouse is clicked in the specified window’s content region.


/* 36 */
/********************* DoContentClick *********************/

void    DoContentClick( EventRecord *eventPtr, WindowPtr w )
{
 GrafPtroldPort;
 ListHandle list;
 ListPeek l;

If the window is not currently in front, SelectWindow() is called to bring the window to the front.


/* 37 */
 if ( w != FrontWindow() )
 {
 SelectWindow( w );
 }

If the click was in the frontmost window and the window is a list window, we’ll convert the current mouse coordinates (which are in global coordinates) to the window’s local coordinate system.


/* 38 */
 else if ( WindowType( w ) == kListWindow )
 {
 GetPort( &oldPort );
 SetPort( w );
 
 GlobalToLocal( &(eventPtr->where) );

Next, we’ll retrieve the list handle and pass it to LClick(). LClick() handles all types of clicks, from clicks in the scroll bars to clicks in the list cells. LClick() returns true if a double-click occurs. In that case, we’ll create a new pict window from the currently selected list item.


/* 39 */
 l = (ListPeek)w;
 list = l->list;
 
 if (LClick( eventPtr->where, eventPtr->modifiers, list ))
 CreatePictWindow( list );
 SetPort( oldPort );
 }
}

CreatePictWindow() first must figure out which of the list’s cells is selected, then create a pict window based on the resource associated with that cell.


/* 40 */
/********************* CreatePictWindow *********************/

void    CreatePictWindow( ListHandle list )
{
 Cell   cell;
 PicHandlepic;
 Handle rHandle;
 Rect   r;
 short  resID;
 ResTypetheResType;
 Str255 rName;
 PictPeek p;
 Ptr    wStorage;
 WindowPtrw;

We’ll start by setting cell to identify the first cell in the list.


/* 41 */
 SetPt( &cell, 0, 0 );

LGetSelect() starts at cell, then moves through the list until it finds a cell that is highlighted. If LGetSelect() finds a highlighted cell, it puts the cell’s coordinates in cell and returns true.

 
/* 42 */
 if ( LGetSelect( kFindNext, &cell, list ) )
 {

If a highlighted cell was found, we’ll use cell.v to retrieve the appropriate PICT resource. Notice that cell is zero-based, while GetIndResource() is one-based.


/* 43 */
 rHandle = GetIndResource( 'PICT', cell.v + 1 );
 pic = (PicHandle)rHandle;
 
 r = (**pic).picFrame;

Once the PICT is loaded, we’ll make sure the new window is at least as wide as kMinPictWinWidth and at least as tall as kMinPictWinHeight.


/* 44 */
 if ( r.right - r.left < kMinPictWinWidth )
 r.right = r.left + kMinPictWinWidth;
 
 if ( r.bottom - r.top < kMinPictWinHeight )
 r.bottom = r.top + kMinPictWinHeight;

Next, we’ll offset the window’s Rect to correspond to the appropriate upper-left corner and the upper-left globals are bumped again.


/* 45 */
 OffsetRect( &r, gNewWindowX - r.left, 
 gNewWindowY - r.top );
 
 BumpGlobalXandY();

Next, a PictRecord is allocated and the new storage is used to create the new window.


/* 46 */
 wStorage = NewPtr( sizeof( PictRecord ) );
 
 GetResInfo( rHandle, &resID, &theResType, rName );
 
 if ( rName[ 0 ] > 0 )
 {
 w = NewWindow( wStorage, &r, rName, kInvisible,
 noGrowDocProc, kMoveToFront, kHasGoAway, 0L );
 }
 else
 {
 w = NewWindow( wStorage, &r, "\p<Unnamed>", kInvisible,
 noGrowDocProc, kMoveToFront, kHasGoAway, 0L );
 }
 
 ShowWindow( w );
 SetPort( w );

Finally, the PictRecord’s wType field is set to kPictWindow and the PICT’s resource id is stored in the PictResID field for use by DoUpdate().


/* 47 */
 p = (PictPeek)w;
 p->wType = kPictWindow;
 p->PictResID = resID;
 }
}

BumpGlobalXandY() bumps the global X and Y coordinates of the next window’s upper left corner by 20 pixels.


/* 48 */
/********************* BumpGlobalXandY *********************/

void    BumpGlobalXandY( void )
{
 gNewWindowX += 20;
 gNewWindowY += 20;

If the window is threatening to move off the bottom or right hand side of the screen, the gNewWindowX and gNewWindowY are reset.


/* 49 */
 if ( (gNewWindowX > screenBits.bounds.right - 100) ||
 (gNewWindowY > screenBits.bounds.bottom - 100) )
 {
 gNewWindowX = 20;
 gNewWindowY = 50;
 }
}

DoGrow() is called when the mouse is clicked in a window’s grow box.


/* 50 */
/********************* DoGrow  *********************/

void    DoGrow( EventRecord *eventPtr, WindowPtr w )
{
 Rect   r;
 GrafPtroldPort;
 Cell   cSize;
 long   windSize;
 ListHandle list;

If the window is a list window, we’ll first establish the minimum and maximum size 
of the window.

/* 51 */
 if ( WindowType( w ) == kListWindow )
 {
 r.top = kMinWindowHeight;
 r.bottom = 32767;
 r.left = kMinWindowWidth;
 r.right = 32767;

Next, we’ll call GrowWindow(). If the window was resized, we’ll call SizeWindow() to resize the window, then LSize() to let the List Manager know that the list has been resized.


/* 52 */
 windSize = GrowWindow( w, eventPtr->where, &r );
 if ( windSize )
 {
 GetPort( &oldPort );
 SetPort( w );
 EraseRect( &w->portRect );

 SizeWindow( w, LoWord (windSize),
 HiWord(windSize), true );

Notice that the scroll bars are not included in the list’s height and width.


/* 53*/
 list = ((ListPeek)w)->list;
 LSize( LoWord(windSize)-15,
 HiWord(windSize)-15, list );

Next, cSize is set to the current cell size in pixels (including both height and width).


/* 54 */
 cSize = (*list)->cellSize;

Though the height of a cell hasn’t changed, we’re going to make our cell as wide as the window. Note that this won’t always be the case (resize an Excel spreadsheet and the cells don’t change size). We’ll call LCellSize() to resize all the cells and InvalRect() to force an update.

If you have any doubts about any of these calls, try commenting them out and see what happens.


/* 55 */
 cSize.h = LoWord( windSize ) - 15;
 LCellSize( cSize, list );
 InvalRect( &w->portRect );
 SetPort( oldPort );
 }
 }
}

HandleMenuChoice() dispatches a menu selection.


/* 56 */
/********************* HandleMenuChoice *********************/

void    HandleMenuChoice( long menuChoice )
{
 short  menu;
 short  item;
 
 if ( menuChoice != 0 )
 {
 menu = HiWord( menuChoice );
 item = LoWord( menuChoice );
 
 switch ( menu )
 {
 case mApple:
 HandleAppleChoice( item );
 break;
 case mFile:
 HandleFileChoice( item );
 break;
 }
 HiliteMenu( 0 );
 }
}

HandleAppleChoice() does what it always does.


/* 57 */
/********************* HandleAppleChoice ********************/

void    HandleAppleChoice( short item )
{
 MenuHandle appleMenu;
 Str255 accName;
 short  accNumber;
 
 switch ( item )
 {
 case iAbout:
 SysBeep( 20 );
 break;
 default:
 appleMenu = GetMHandle( mApple );
 GetItem( appleMenu, item, accName );
 accNumber = OpenDeskAcc( accName );
 break;
 }
}

HandleFileChoice() dispatches selections from the File menu.


/* 58 */
/********************* HandleFileChoice *********************/

void    HandleFileChoice( short item )
{
 switch ( item )
 {
 case iNewList:
 CreateListWindow();
 break;
 case iClose:
 DestroyWindow( FrontWindow() );
 break;
 case iQuit:
 gDone = true;
 break;
 }
}

CenterPict() centers the specified picture in the specified Rect, setting the Rect to the newly centered Pict’s Rect.


/* 59 */
/********************* CenterPict *********************/

void    CenterPict( PicHandle picture, Rect *destRectPtr )
{
 Rect   windRect, pictRect;
 
 windRect = *destRectPtr;
 pictRect = (**( picture )).picFrame;
 OffsetRect( &pictRect, windRect.left - pictRect.left,
 windRect.top   - pictRect.top);
 OffsetRect( &pictRect, (windRect.right - pictRect.right)/2,
 (windRect.bottom - pictRect.bottom)/2);
 *destRectPtr = pictRect;
}

WindowType() returns the type of the specified window. If the window has a negative windowKind field, it’s a Desk Accessory. If the window’s wType field is kListWindow or kPictWindow, one of those is returned, otherwise kUnknownWindow is returned.


/* 60 */
/********************* WindowType *********************/

short WindowType( WindowPtr window )
{
 if ( window == nil )
 return( kNilWindow );
 if ( ((WindowPeek)window)->windowKind < 0 )
 return( kDAWindow );
 
 if ( ((ListPeek)window)->wType == kListWindow )
 return( kListWindow );
 
 if ( ((ListPeek)window)->wType == kPictWindow )
 return( kPictWindow );
 
 return( kUnknownWindow );
}

DoError() puts up a StopAlert(), then exits.


/* 61 */
/********************* DoError *********************/

void    DoError( Str255 errorString )
{
 ParamText( errorString, kEmptyString, 
 kEmptyString, kEmptyString );
 
 StopAlert( kErrorAlertID, kNilFilterProc );
 
 ExitToShell();
}

Till Next Month

If you want to know more about the List Manager, check out the appropriate chapters in Inside Macintosh or read about it online in THINK Reference. For some real thrills, try writing your own LDEF that displays small icons as well as text in your list. If you want to exceed 32K worth of list data, you’ll have to write your own LDEF.

Next month, I’m going to try my hardest to get to that PixMap program I keep promising to do. We’ll see. In the meantime, Deneen and I are going to Santa Fe to take Daniel skiing for the first time. Can you believe how quickly time flies?

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

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
Monolingual 1.6.4 - Remove unwanted OS X...
Monolingual is a program for removing unnecesary language resources from OS X, in order to reclaim several hundred megabytes of disk space. If you use your computer in only one (human) language, you... Read more
CleanApp 5.0 - Application deinstaller a...
CleanApp is an application deinstaller and archiver.... Your hard drive gets fuller day by day, but do you know why? CleanApp 5 provides you with insights how to reclaim disk space. There are... Read more
Fantastical 2.0 - Create calendar events...
Fantastical is the Mac calendar you'll actually enjoy using. Creating an event with Fantastical is quick, easy, and fun: Open Fantastical with a single click or keystroke Type in your event details... Read more
Cocktail 8.2 - General maintenance and o...
Cocktail is a general purpose utility for OS X that lets you clean, repair and optimize your Mac. It is a powerful digital toolset that helps hundreds of thousands of Mac users around the world get... Read more
Skype 7.6.0.409 - Voice-over-internet ph...
Skype allows you to talk to friends, family and co-workers across the Internet without the inconvenience of long distance telephone charges. Using peer-to-peer data transmission technology, Skype... 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 »
Fearless Fantasy is Fantastic for the iF...
I actually had my first look at Fearless Fantasy last year at E3, but it was on a PC so there wasn't much for me to talk about. But now that I've been able to play with a pre-release version of the iOS build, there's quite a bit for me to talk... | Read more »
MLB Manager 2015 (Games)
MLB Manager 2015 5.0.14 Device: iOS Universal Category: Games Price: $4.99, Version: 5.0.14 (iTunes) Description: Guide your favorite MLB franchise to glory! MLB Manager 2015, officially licensed by MLB.com and based on the award-... | Read more »
Breath of Light (Games)
Breath of Light 1.0.1421 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0.1421 (iTunes) Description: Hold a quiet moment. Breath of Light is a meditative and beautiful puzzle game with a hypnotic soundtrack by... | Read more »
WWE WrestleMania Tags into the App Store
Are You ready to rumble? The official WWE WrestleMania app, by World Wrestling Entertainment, is now available. Now you can get all your WrestleMania info in one place before anyone else. The app offers details on superstar signings, interactive... | Read more »

Price Scanner via MacPrices.net

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
Save up to $80 on iPad Air 2s, NY tax only, f...
 B&H Photo has iPad Air 2s on sale for $80 off MSRP including free shipping plus NY sales tax only: - 16GB iPad Air 2 WiFi: $469.99 $30 off - 64GB iPad Air 2 WiFi: $549.99 $50 off - 128GB iPad... Read more
iMacs on sale for up to $205 off MSRP
B&H Photo has 21″ and 27″ iMacs on sale for up to $205 off MSRP including free shipping plus NY sales tax only: - 21″ 1.4GHz iMac: $1019 $80 off - 21″ 2.7GHz iMac: $1189 $110 off - 21″ 2.9GHz... Read more
Färbe Technik Offers iPhone Battery Charge LI...
Färbe Technik, which manufactures and markets of mobile accessories for Apple, Blackberry and Samsung mobile devices, is offering tips on how to keep your iPhone charged while in the field: •... Read more
Electronic Recyclers International CEO Urges...
Citing a recent story on CNBC about concerns some security professionals have about the forthcoming Apple Watch, John Shegerian, Chairman and CEO of Electronic Recyclers International (ERI), the... Read more
Save up to $380 with Apple refurbished iMacs
The Apple Store has Apple Certified Refurbished iMacs available for up to $380 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free: - 27″ 3.5GHz 5K iMac – $2119 $... Read more
Mac minis on sale for up to $75 off, starting...
MacMall has Mac minis on sale for up to $75 off MSRP including free shipping. Their prices are the lowest available for these models from any reseller: - 1.4GHz Mac mini: $459.99 $40 off - 2.6GHz Mac... Read more
College Student Deals: Additional $50 off Mac...
Take an additional $50 off all MacBooks and iMacs at Best Buy Online with their College Students Deals Savings, valid through April 11, 2015. Anyone with a valid .EDU email address can take advantage... Read more

Jobs Board

DevOps Software Engineer - *Apple* Pay, iOS...
**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* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Sr. Technical Services Consultant, *Apple*...
**Job Summary** Apple Professional Services (APS) has an opening for a senior technical position that contributes to Apple 's efforts for strategic and transactional Read more
Lead *Apple* Solutions Consultant - Retail...
**Job Summary** Job Summary The Lead ASC is an Apple employee who serves as the Apple business manager and influencer in a hyper-business critical Reseller's store Read more
*Apple* Pay - Site Reliability Engineer - 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
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.