TweetFollow Us on Twitter

Window Menu
Volume Number:5
Issue Number:7
Column Tag:ABC's of Macintosh

Related Info: Menu Manager

A Window Menu

By Clifford Story, Goleta, CA

The Standard Window Menu

A Macintosh program with several windows really ought to have a Window menu. This menu is a list of all open application windows; choosing a window from the menu brings it to the front.

The problem for the programmer is menu maintenance. Every time the program opens a new window, the window’s name has to be added to the Window menu, and, what is worse, every time a window is closed, its name must be removed from the menu. There is no ROM trap to delete a menu item in the 64K ROM.

Still uglier problems arise if the menu is supposed to be kept in order. Every time a window is selected, the window order changes, and the menu must be re-ordered.

One solution: each time the menu must be updated, delete the whole menu and recreate it from the window list. That isn’t very pretty, but it would work.

The solution I present here is similar but less work: Draw the menu with an MDEF that reads the window list. This approach requires virtually no menu maintenance (only a call to CalcMenuSize when a window is opened or closed). As an extra, the menu includes a “Zoom Front Window” item.

Advertisement

This is my third article for MacTutor, and I’ve got a fourth and a fifth in the works. Maybe I’m becoming a regular? Anyway, I thought I might mention ways to respond to my stuff.

The cheapest way is by mail:

Clifford Story

Attic Software

P.O. Box 219

Goleta, California 93116

The fastest way is by modem. I run a BBS called THE ATTIC, phone number (805) 683-0322, hours 6:00 PM to 2:00 AM, Pacific time, daily. The board isn’t very active, but I read and respond each morning.

#****************************************    
#Window.make
#MPW make file for
#dynamic Window menu demo
#(c) 1988, by Clifford Story
#& Attic Software
#****************************************
#****************************************
#Compile the resources
#****************************************
Window ƒƒ Window.make Window.r
 Rez Window.r -append -o Window
#****************************************
#Compile common declarations
#****************************************
Common.p.o ƒƒ Window.make Common.p
 Pascal Common.p
#****************************************
#Compile and link the MDEF
#****************************************
‘Window Menu’.p.o ƒ Window.make 
 ‘Window Menu’.p Common.p.o
 Pascal ‘Window Menu’.p
Window ƒƒ Window.make ‘Window Menu’.p.o
 Link -m MENUDEF -w -t ‘APPL’ 
 -c ‘????’  -rt MDEF=1001 
 -sn Main=’Window Menu’ 
 ‘Window Menu’.p.o 
 “{Libraries}”Interface.o 
 “{Libraries}”Runtime.o 
 “{PLibraries}”PasLib.o 
 “{PLibraries}”SANELib.o 
 -o Window
#****************************************
#Compile and link the main program
#****************************************
Window.p.o ƒ Window.make 
 Window.p Common.p.o
 Pascal Window.p
Window ƒƒ Window.make Window.p.o
 Link -w -t APPL -c ‘????’ 
 Window.p.o 
 “{Libraries}”Interface.o 
 “{Libraries}”Runtime.o 
 “{PLibraries}”PasLib.o 
 “{PLibraries}”SANELib.o 
 -o Window
#****************************************

The Program’s Resources

The only feature that needs to be pointed out is the declaration of the Window menu. The “Zoom Front Window” item must be declared here, so MenuKey will be able to find its keyboard equivalent.

/****************************************
 Window.r
 Resources for 
 dynamic Window menu demo.
 (c) 1988, by Clifford Story
 & Attic Software
****************************************/
#include “types.r”
/****************************************
 Menu resources:
****************************************/
resource ‘MENU’ (1001) {
 1001,
 textMenuProc,
 $7FFFFFFB,
 enabled,
 apple,
 { /* array: 3 elements */
 /* [1] */
 “About Window...”, noicon,
 “”, “”, plain,
 /* [2] */
 “About Attic Software...”,
 noicon, “”, “”, plain,
 /* [3] */
 “-”, noIcon, “”, “”, plain
 }
};
resource ‘MENU’ (1002, preload) {
 1002,
 textMenuProc,
 0x7FFFFFFB,
 enabled,
 “File”,
 { /* array: 4 elements */
 /* [1] */
 “New”, noIcon, “N”, “”, plain,
 /* [2] */
 “Close”, noIcon, “K”, “”, plain,
 /* [3] */
 “-”, noIcon, “”, “”, plain,
 /* [4] */
 “Quit”, noIcon, “Q”, “”, plain
 }
};
resource ‘MENU’ (1003, preload) {
 1003,
 textMenuProc,
 0x7FFFFFFD,
 enabled,
 “Edit”,
 { /* array: 6 elements */
 /* [1] */
 “Undo”, noIcon, “Z”, “”, plain,
 /* [2] */
 “-”, noIcon, “”, “”, plain,
 /* [3] */
 “Cut”, noIcon, “X”, “”, plain,
 /* [4] */
 “Copy”, noIcon, “C”, “”, plain,
 /* [5] */
 “Paste”, noIcon, “V”, “”, plain,
 /* [6] */
 “Clear”, noIcon, “”, “”, plain
 }
};
resource ‘MENU’ (1004, preload) {
 1004,
 1001,
 0x7FFFFFFC,
 enabled,
 “Window”,
 { /* array: 2 elements */
 /* [1] */
 “Zoom Front Window”, noIcon,
 “W”, “”, plain,
 /* [2] */
 “-”, noIcon, “”, “”, plain
 }
};
/***********************
Picture resources
************************************/
resource ‘PICT’ (1001, “About”, 
purgeable) {1157,
 {7, 7, 306, 497},
 $”1101 A000 82A0 008C”
 $”0100 0A00 0700 0701"
 $”3201 F10A 0000 0000"
 $”0000 0000 0B00 1B00"
 $”1B44 0009 0009 0130"
 $”01EF 0700 0200 0248"
 $”A100 9600 0606 0000"
 $”0002 03A1 009A 0008"
 $”FFFD 0000 00D4 0000"
 $”A000 9803 0003 0D00"
 $”0A28 0128 0024 22A9"
 $”2031 3938 3820 6279"
 $”2043 6C69 6666 6F72"
 $”6420 5374 6F72 7920"
 $”616E 6420 4174 7469"
 $”6329 AC22 2053 6F66"
 $”7477 6172 652C 2050"
 $”2E4F 2E20 426F 7820"
 $”3231 392C 2047 6F6C”
 $”6574 612C 2043 29A6"
 $”1161 6C69 666F 726E”
 $”6961 2020 2039 3331"
 $”3136 A000 99A0 0097"
 $”A100 9600 0605 0000"
 $”0002 03A1 009A 0008"
 $”004C 0000 00D8 0000"
 $”A000 980D 000C 2800"
 $”5200 2222 5769 6E64"
 $”6F77 2064 656D 6F6E”
 $”7374 7261 7465 7320"
 $”6120 6479 6E61 6D69"
 $”6320 5769 6E64 29ED”
 $”1D6F 7720 6D65 6E75"
 $”2E20 2045 6163 6820"
 $”7469 6D65 2061 2077"
 $”696E 646F 770D A000"
 $”99A1 009A 0008 003C”
 $”0000 00D8 0000 A000"
 $”9828 0062 0022 2269"
 $”7320 6F70 656E 6564"
 $”206F 7220 636C 6F73"
 $”6564 2C20 6F72 2074"
 $”6865 2077 696E 646F”
 $”7729 D81C 206F 7264"
 $”6572 2063 6861 6E67"
 $”6573 2C20 7468 6520"
 $”6D65 6E75 2069 730D”
 $”A000 99A1 009A 0008"
 $”002C 0000 00D8 0000"
 $”A000 9828 0072 0022"
 $”2261 7574 6F6D 6174"
 $”6963 616C 6C79 2075"
 $”7064 6174 6564 2074"
 $”6F20 7265 666C 6563"
 $”7420 7429 D61E 6865"
 $”206E 6577 2077 696E”
 $”646F 7720 6F72 6465"
 $”722C 2077 6974 6820"
 $”7468 650D A000 99A1"
 $”009A 0008 001C 0000"
 $”00D8 0000 A000 9828"
 $”0082 0022 2274 6F70"
 $”2077 696E 646F 7720"
 $”6174 2074 6865 2074"
 $”6F70 206F 6620 7468"
 $”6520 6D65 6E75 2C29"
 $”DA22 2061 6E64 2073"
 $”6F20 6F6E 2E20 2054"
 $”6869 7320 6973 2061"
 $”6C6C 2064 6F6E 6520"
 $”6279 2074 29C4 0368"
 $”650D A000 99A1 009A”
 $”0008 000C 0000 00D8"
 $”0000 A000 9828 0092"
 $”0022 224D 4445 463B”
 $”2074 6865 2070 726F”
 $”6772 616D 2069 7473"
 $”656C 6620 6E65 6564"
 $”206E 6F74 2029 D61E”
 $”6265 2063 6F6E 6365"
 $”726E 6564 2077 6974"
 $”6820 6D61 696E 7461"
 $”696E 696E 670D A000"
 $”99A1 009A 0008 FFFC”
 $”0000 00D8 0000 A000"
 $”9828 00A2 0022 0A74"
 $”6865 206D 656E 752E”
 $”0DA0 0099 A100 9A00"
 $”08FF EC00 0000 D800"
 $”00A0 0098 2A10 010D”
 $”A000 99A1 009A 0008"
 $”FFDC 0000 00D8 0000"
 $”A000 982A 1022 596F”
 $”7520 6361 6E20 6164"
 $”6420 7468 6973 206D”
 $”656E 7520 746F 2079"
 $”6F75 7220 6F77 6E20"
 $”29D9 1F70 726F 6772"
 $”616D 7320 6279 2073"
 $”696D 706C 7920 636F”
 $”7079 696E 6720 7468"
 $”650D A000 99A1 009A”
 $”0008 FFCC 0000 00D8"
 $”0000 A000 9828 00D2"
 $”0022 224D 4445 4620"
 $”7265 736F 7572 6365"
 $”2077 6974 6820 5265"
 $”7365 6469 742E 2020"
 $”416E 2061 7229 D921"
 $”7469 636C 6520 6F6E”
 $”2074 6869 7320 7072"
 $”6F67 7261 6D2C 2069"
 $”6E63 6C75 6469 6E67"
 $”0DA0 0099 A100 9A00"
 $”08FF BC00 0000 D800"
 $”00A0 0098 2800 E200"
 $”2222 636F 6D70 6C65"
 $”7465 2050 6173 6361"
 $”6C20 736F 7572 6365"
 $”2063 6F64 652C 2068"
 $”6173 2062 29DB 1F65"
 $”656E 2073 7562 6D69"
 $”7474 6564 2074 6F20"
 $”4D61 6320 5475 746F”
 $”7220 2869 660D A000"
 $”99A1 009A 0008 FFAC”
 $”0000 00D8 0000 A000"
 $”9828 00F2 0022 2269"
 $”7420 646F 6573 6E27"
 $”7420 6765 7420 7075"
 $”626C 6973 6865 642C”
 $”2049 276C 6C20 7265"
 $”6C29 C218 6561 7365"
 $”2074 6865 2073 6F75"
 $”7263 6520 6D79 7365"
 $”6C66 292E A000 99A0"
 $”0097 A100 9600 0606"
 $”0000 0002 03A1 009A”
 $”0008 FFFA 0000 0025"
 $”0000 A000 9804 050D”
 $”0012 2800 2B00 D806"
 $”5769 6E64 6F77 A000"
 $”99A0 0097 A000 8DA0"
 $”0083 FF”
};
resource ‘PICT’ (1002, “Attic”, 
purgeable) {
 1125,
 {7, 7, 306, 497},
 $”1101 A000 82A0 008C”
 $”0100 0A00 0700 0701"
 $”3201 F10A 0000 0000"
 $”0000 0000 0B00 1B00"
 $”1B44 0009 0009 0130"
 $”01EF 0700 0200 0248"
 $”A100 9600 0606 0000"
 $”0002 03A1 009A 0008"
 $”FFFA 0000 004B 0000"
 $”A000 9803 0003 0405"
 $”0D00 122B BA2B 0E41"
 $”7474 6963 2053 6F66"
 $”7477 6172 65A0 0099"
 $”A000 97A1 0096 0006"
 $”0500 0000 0203 A100"
 $”9A00 0800 5C00 0000"
 $”E600 00A0 0098 0400"
 $”0D00 0C28 004D 001D”
 $”2241 7474 6963 2053"
 $”6F66 7477 6172 6520"
 $”6973 2061 2073 6D61"
 $”6C6C 204D 6163 696E”
 $”746F 7329 DC22 6820"
 $”7072 6F67 7261 6D6D”
 $”696E 6720 636F 6D70"
 $”616E 792E 2069 6E20"
 $”6275 7369 6E65 7373"
 $”29E2 010D A000 99A1"
 $”009A 0008 004C 0000"
 $”00E6 0000 A000 9828"
 $”005D 001D 2273 696E”
 $”6365 2031 3938 362E”
 $”2020 5765 2064 6F20"
 $”6120 7661 7269 6574"
 $”7920 6F66 2077 6F29"
 $”D722 726B 3B20 D249"
 $”6465 616C 696E 6572"
 $”D32C 2061 2073 6861"
 $”7265 7761 7265 206F”
 $”7574 6C69 29D1 056E”
 $”6572 2C0D A000 99A1"
 $”009A 0008 003C 0000"
 $”00E6 0000 A000 9828"
 $”006D 001D 2269 7320"
 $”6F75 7220 6265 7374"
 $”2D6B 6E6F 776E 2070"
 $”726F 6475 6374 2E20"
 $”2057 6520 616C 7329"
 $”D81B 6F20 646F 2063"
 $”6F6E 7472 6163 7420"
 $”7072 6F67 7261 6D6D”
 $”696E 672E 0DA0 0099"
 $”A100 9A00 0800 2C00"
 $”0000 E600 00A0 0098"
 $”2800 7D00 1D01 0DA0"
 $”0099 A100 9A00 0800"
 $”1C00 0000 E600 00A0"
 $”0098 2A10 1E57 6520"
 $”6361 6E20 6265 2072"
 $”6561 6368 6564 2062"
 $”7920 6D61 696C 2061"
 $”743A 0DA0 0099 A100"
 $”9A00 0800 0C00 0000"
 $”E600 00A0 0098 2A10"
 $”010D A000 99A1 009A”
 $”0008 FFFC 0000 00E6"
 $”0000 A000 982A 1022"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2041"
 $”7474 2991 0C69 6320"
 $”536F 6674 7761 7265"
 $”0DA0 0099 A100 9A00"
 $”08FF EC00 0000 E600"
 $”00A0 0098 2800 BD00"
 $”1D22 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2050 2E4F 298F 0A2E”
 $”2042 6F78 2032 3139"
 $”0DA0 0099 A100 9A00"
 $”08FF DC00 0000 E600"
 $”00A0 0098 2800 CD00"
 $”1D22 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2020 2020 2020 2020"
 $”2047 6F6C 2990 1865"
 $”7461 2C20 4361 6C69"
 $”666F 726E 6961 2020"
 $”2039 3331 3136 0DA0"
 $”0099 A100 9A00 08FF”
 $”CC00 0000 E600 00A0"
 $”0098 2800 DD00 1D01"
 $”0DA0 0099 A100 9A00"
 $”08FF BC00 0000 E600"
 $”00A0 0098 2A10 2257"
 $”6520 616C 736F 206F”
 $”7065 7261 7465 2061"
 $”2062 756C 6C65 7469"
 $”6E20 626F 6172 6420"
 $”7329 D422 7973 7465"
 $”6D20 6174 2028 3830"
 $”3529 2036 3833 2D30"
 $”3332 322C 2062 6574"
 $”7765 656E 2074 29E6"
 $”0368 650D A000 99A1"
 $”009A 0008 FFAC 0000"
 $”00E6 0000 A000 9828"
 $”00FD 001D 2268 6F75"
 $”7273 206F 6620 363A”
 $”3030 2050 4D20 616E”
 $”6420 323A 3030 2041"
 $”4D2C 2050 6163 6929"
 $”D822 6669 6320 7469"
 $”6D65 2C20 7365 7665"
 $”6E20 6461 7973 2061"
 $”2077 6565 6B2E 2020"
 $”506C 6561 29D3 0373"
 $”650D A000 99A1 009A”
 $”0008 FF9C 0000 00E6"
 $”0000 A000 9828 010D”
 $”001D 1566 6565 6C20"
 $”6672 6565 2074 6F20"
 $”6361 6C6C 2069 6E21"
 $”A000 99A0 0097 A100"
 $”9600 0606 0000 0002"
 $”03A1 009A 0008 FFFD”
 $”0000 006D 0000 A000"
 $”980D 000A 2B73 1722"
 $”A920 3139 3838 2062"
 $”7920 436C 6966 666F”
 $”7264 2053 746F 7279"
 $”2061 6E64 2041 7474"
 $”6963 29AC 0920 536F”
 $”6674 7761 7265 A000"
 $”99A0 0097 A000 8DA0"
 $”0083 FF”
};
/**************************
Alert resource
****************************************/
resource ‘ALRT’ (1001,
 “Message”, purgeable) {
 {0, 0, 122, 300},
 1001,
 { /* array: 4 elements */
 /* [1] */
 OK, visible, sound1,
 /* [2] */
 OK, visible, sound1,
 /* [3] */
 OK, visible, sound1,
 /* [4] */
 OK, visible, sound1
 }
};
/****************************
Item list resource
****************************************/
resource ‘DITL’ (1001,
 “Message”, purgeable) {
 { /* array DITLarray: 2 elements */
 /* [1] */
 {92, 120, 112, 180},
 Button {
 enabled,
 “OK”
 },
 /* [2] */
 {10, 10, 74, 290},
 StaticText {
 disabled,
 “Sorry!  This program”
 “ can open only 18 wi”
 “ndows at one time (i”
 “f it opened more, th”
 “e menu would be too “
 “long for the screen)”
 “.”
 }
 }
};
/****************************
Window resources
*************************************/
resource ‘WIND’ (1001, purgeable) {
 {0, 0, 200, 320},
 documentProc,
 invisible,
 goaway,
 0x0,
 “untitled”
};
resource ‘WIND’ (1002, purgeable) {
 {0, 0, 200, 320},
 zoomDocProc,
 invisible,
 -1,
 0x0,
 “untitled”
};
/****************************
Multifinder resource
****************************************/
resource ‘SIZE’ (-1) {
 saveScreen,
 acceptSuspendResumeEvents,
 enableOptionSwitch,
 cannotBackground,
 MultiFinderAware,
 98304,
 98304
};
/***************************************/

Some Standard Declarations

This first bit of code is a simple unit that I include in all my stuff these days. Every time I use a new low-memory global, I stick it in here. I keep the unit in the “PInterfaces” folder, so I can use it easily in any program.

(****************************************
Common.p
Declarations for
 dynamic Window menu demo.
(c) 1988, by Clifford Story
 & Attic Software
****************************************)
unit Common;
(***************************************)
interface
(****************************************
Key codes:
****************************************)
const
 enterkey = 3;
 backspace= 8;
 tabkey = 9;
 returnkey= 13;
 clearkey = 27;
 leftarrow= 28;
 rightarrow =  29;
 uparrow= 30;
 downarrow= 31;
 periodkey= 46;

(****************************************
Dialog items:
****************************************)
 themask= 3;
(****************************************
Low-memory globals:
****************************************)
 applscratch=  $A78;
 bootdrive= $210;
 curappname =  $910;
 curdirstore=  $398;
 currenta5= $904;
 findername =  $2E0;
 fsfcblen = $3F6;
 grayrgn= $9EE;
 iaznotify= $33C;
 mbarheight =  $BAA;
 menuflash= $A24;
 resload= $A5E;
 rom85  = $28E;
 sfsavedisk =  $214;
 sysmap = $A58;
 windowlist =  $9D6;

(****************************************
Standard types:
****************************************)

type
 logical= boolean;
 long   = longint;
 
 shortpointer    = ^integer;
 longpointer=  ^long;

(***************************************)
end.
(***************************************)

The Menu Definition

An MDEF is called to do three things: draw the menu, hit-test the mouse location, and calculate the size of the menu rectangle.

Drawing the Menu

The menu has two parts: the first two items, which are fixed, and the list of open windows. I’ve hard-coded the first two items, since I know what they are. Note that if the “Zoom Front Window” item is disabled, then it is grayed out by drawing a gray rectangle over it.

To draw the list of open windows, I start with the window whose pointer is stored in the low-memory global “windowlist”. The windows form a chain, with each window record including a pointer to the next one; the final window has a nil pointer in the “nextwindow” field. So I walk down this list, looking for windows to add to the menu. I’m only going to show application windows, since DA windows may not have titles, and of course I’ll omit hidden windows.

Hit-Testing the Mouse

This is simple, since each menu item is 16 pixels high - just divide the distance from the top of the menu by 16 (result: a number in the range from 0 to the number of menu items minus one) and add one (since the first item is item one, not item zero).

There’s a small complication: if the item is disabled, then the routine should return zero (no choice).

The “whichitem” argument is a var parameter that initially contains the value of the last choice. If the newly-calculated item is the same as the last choice, then nothing has changed, so there’s nothing else to do. If it is different, then the old item should be un-highlighted and the new highlighted.

Calculating the Menu Size

This routine must compute the width and height of the menu rectangle and update the menu record accordingly. The approach here is similar to that of the draw routine: hard-code the fixed items and walk the window list for the rest, looking for the widest menu item.

Note the formulae by which the width of an item is calculated. I worked these out with screen shots and fatbits, and they (with the corresponding formula in the draw routine) will produce a menu identical to one created with the standard MDEF.

(****************************************
Window Menu.p
MDEF for dynamic Window menu demo.
(c) 1988, by Clifford Story
 & Attic Software
****************************************)

unit WDEF;

(***************************************)
interface
(***************************************)

uses memtypes, quickdraw, osintf,
 toolintf, Common;

(***************************************)
procedure menudef(message : integer; themenu : MenuHandle;
 var menurect : Rect; hitpoint : Point; var whichitem : integer);
(***************************************)
implementation
(***************************************)

type
 QDrecord = record
 randSeed : long;
 screenBits :  BitMap;
 arrow  : Cursor;
 dkGray : Pattern;
 ltGray : Pattern;
 gray   : Pattern;
 black  : Pattern;
 white  : Pattern;
 thePort: GrafPtr;
 end;
 QDpointer= ^QDrecord;

(***************************************)

procedure menudraw(themenu : MenuHandle; var menurect : Rect); forward;
procedure menuchoose(themenu : MenuHandle; var menurect : Rect;
 hitpoint : Point; var whichitem : integer); forward;
procedure menusize(themenu : MenuHandle); forward;

(***************************************)
{$R-}
{$SC+}
(***************************************)
procedure menudef(message : integer; themenu : MenuHandle;
 var menurect : Rect; hitpoint : Point; var whichitem : integer);
begin
 case message of
 mDrawMsg : menudraw(themenu, menurect);
 mChooseMsg : menuchoose(themenu, menurect,
 hitpoint, whichitem);
 mSizeMsg : menusize(themenu);
 end;
end;

(**************************************)
function QDglobals : QDpointer;
var
 thepointer :  longpointer;
begin
 thepointer := longpointer(currenta5);
 thepointer := longpointer(thepointer^);
 QDglobals := QDpointer(long(thepointer^)
 - sizeof(QDrecord) + sizeof(GrafPtr));
end;

(***************************************)
procedure menudraw(themenu: MenuHandle; var menurect: Rect);
var
 height : integer;
 width  : integer;
 therect: Rect;
 thewindow: WindowPeek;
begin
 height := menurect.top + 12;
 width := menurect.left + 12;
 
 MoveTo(width, height);
 DrawString(‘Zoom Front Window’);
 MoveTo(menurect.right - CharWidth(‘W’) - 15, height);
 DrawChar(chr(17));
 DrawChar(‘W’);
 
 if not BitTst(@themenu^^.enableFlags, 30) then begin
 PenPat(QDglobals^.gray);
 PenMode(patBic);
 with menurect do
 SetRect(therect, left, top, right, top + 16);
 PaintRect(therect);
 PenNormal;
 end;
 
 height := height + 16;
 MoveTo(menurect.left, menurect.top + 24);
 Line(menurect.right - menurect.left, 0);
 
 thewindow := WindowPeek(longpointer(windowlist)^);
 
 while thewindow <> nil do
 with thewindow^ do begin
 if visible and (windowkind = userKind) then begin
 height := height + 16;
 MoveTo(width, height);
 DrawString(titlehandle^^);
 end;
 thewindow := nextwindow;
 end;
end;

(***************************************)
procedure menuchoose(themenu : MenuHandle; var menurect : Rect;
 hitpoint : Point; var whichitem : integer);
var
 theitem: integer;
 therect: Rect;
begin
 if PtInRect(hitpoint, menurect) then
 theitem := 1 + ((hitpoint.v - menurect.top) div 16)
 else
 theitem := 0;
 
 if not BitTst(@themenu^^.enableFlags, 31 - theitem) then
 theitem := 0;
 
 if theitem <> whichitem then begin
 therect := menurect;
 therect.bottom := therect.top + 16 * theitem;
 therect.top := therect.bottom - 16;
 InvertRect(therect);
 if whichitem > 0 then begin
 therect.bottom := menurect.top + 16 * whichitem;
 therect.top := therect.bottom - 16;
 InvertRect(therect);
 end;
 whichitem := theitem;
 end;
end;

(***************************************)
procedure menusize(themenu : MenuHandle);
var
 thewidth : integer;
 theheight: integer;
 thewindow: WindowPeek;
 newwidth : integer;
begin
 TextFont(systemFont);
 TextSize(12);
 TextFace([]);
 
 theheight := 32;
 thewidth := StringWidth(‘Zoom Front Window’) + CharWidth(‘W’) + 39;
 
 thewindow := WindowPeek(longpointer(windowlist)^);
 
 while thewindow <> nil do
 with thewindow^ do begin
 if visible and (windowkind = userKind) then begin
 theheight := theheight + 16;
 newwidth := StringWidth(titlehandle^^) + 16;
 if newwidth > thewidth then
 thewidth := newwidth;
 end;
 thewindow := nextwindow;
 end;
 
 themenu^^.menuHeight := theheight;
 themenu^^.menuWidth := thewidth;
end;

(***************************************)
end.
(***************************************)

The Main Program

This is, I think, a pretty straight-forward program, so I won’t say much about it except for four features: menu maintenance, opening and closing windows, zooming windows, and window selection.

Menu Maintenance

I thought I said there wouldn’t be any maintenance? Well, there is a little, but not very much.

When the length of the menu changes, I have to call CalcMenuSize to provoke the Menu Manager into calling the MDEF with an “mSizeMsg” message. If I don’t do this, either there will be a blank space at the bottom of the menu, or the last item will be missing.

The size of the menu changes whenever I open or close a window, so I call CalcMenuSize at these times.

Opening and Closing Windows

The Window menu doesn’t scroll; that limits it to 18 windows (20 items minus the zoom item and the dividing line). So, logically, I ought to limit the program to 18 windows as well.

If the program can open only 18 windows, there’s no reason to open them dynamically and clutter up the heap with a bunch of fixed objects (WindowRecords). So instead I’ll declare a global array of WindowRecords. I’ll just pass the address of one of these (instead of a nil pointer) for the wStorage argument of GetNewWindow.

Ah, but now I have to keep track of which records belong to open windows, and which are free. This is actually easy to do.

First, extend the WindowRecord with a couple of new fields (see the datarecord declaration below): an integer ID and an integer “pointer” to the next record. The ID is just the index of the record in the array, and the “next” field initially points to the next record in the array (with the last one -1). Then there’s another global, an integer called FREE, which initially points to the first record in the array.

What I’m doing is keeping a list of all the free WindowRecords. Initially, they’re all free and, sure enough, they’re all on the list. Each time I open a window, I pass the address of the Window-Record pointed to by FREE, and set FREE to that record’s “next” field. That pops it off the list. When I close a window, I add the WindowRecord back to the free list, by setting its “next” field to FREE, and FREE to its ID. If FREE is ever -1, then the list is empty, and I can’t open a window.

Zooming: When?

The first question is, when should I allow zooming?

Since I’m zooming with ZoomWindow (see my Corners article, April 1989, for another method that works on all ROMs), I don’t want to allow zooming on the 64K ROM. So I keep a global flag, OLDROM, to tell me if the program is running on the 64K ROM, and I keep the “Zoom Front Window” item disabled if it is.

Also, I only want to zoom application windows. (I tried zooming the Alarm Clock, once, just to see what would happen...) So if the front window isn’t an application window, I disable the “Zoom Front Window” item. I do this in the “anactivate” routine, disabling on deactivates and enabling on activates.

Zooming: How?

The short answer to this is: with ZoomWindow. Unfortunately, ZoomWindow ain’t the smartest trap in the world, or maybe it’s just to subtle for me. The problem is this “inZoomIn”, “inZoomOut” nonsense. If you send it an “inZoomIn” part code, and it thinks the window is already zoomed in, it will do nothing. So I have to figure out when it thinks it’s zoomed in, and when it thinks it’s zoomed out. Maybe there’s an easy way; for my part, this is the last time I plan to use ZoomWindow.

This wouldn’t trouble me if I was only zooming from the zoom box, since FindWindow will tell me which part code to use. The problem arises because I’m also zooming from the menu.

What I decided to do is keep a flag in the reference constant of each window, setting it when the window is zoomed out, and clearing it otherwise. So when the time comes to zoom, I just look at the flag and zoom in if it’s set, and out if it’s cleared. This is done in the routine “zoomthewindow”.

Now I’ve got a flag to maintain. Besides the obvious in the “zoomthewindow” routine, I also must initialize the flag (in “donew”), and clear it if the window is dragged (in “clickindrag”) or re-sized from the grow box (in “clickingrow”).

Selecting a Window from the Menu

There is a little bit of work to do when a selection is made from the window list in the Window menu. After all, what the Menu Manager returns is an integer, not a WindowPtr. I have to walk the window list, just like in the MDEF, until I find the correct window, and then select it.

(****************************************
Window.p
Demo of a dynamic Window menu.
(c) 1988, by Clifford Story
 & Attic Software
****************************************)

program Window;

(***************************************)
uses memtypes, quickdraw, osintf,
 toolintf, packintf, Common;

(****************************************
Program constants:
****************************************)
const
 applenum = 1001;
 aboutitem= 1;
 atticitem= 2;

 filenum= 1002;
 newitem= 1;
 closeitem= 2;
 quititem = 4;

 editnum= 1003;
 undoitem = 1;
 cutitem= 3;
 copyitem = 4;
 pasteitem= 5;
 clear  = 6;
 
 windnum= 1004;
 zoomitem = 1;
 
 messagedialog   = 1001;
 
 windownum= 1001;
 zoomwindnum=  1002;
 
 hoffset= 32;
 voffset= 20;
 
(****************************************
Program types:
****************************************)
type
 
 datarecord =  record
 dummy  : WindowRecord;
 recordid : integer;
 next   : integer;
 end;
 datapointer=  ^datarecord;

(****************************************
Program variables:
****************************************)
var
 APPLEMENU: MenuHandle;
 FILEMENU : MenuHandle;
 EDITMENU : MenuHandle;
 WINDOWMENU :  MenuHandle;
 
 MENUHEIGHT :  integer;
 DRAGRECT : Rect;
 GROWRECT : Rect;
 SCREENRECT :  Rect;
 
 WINDOWS: array [0..17] of datarecord;
 FREE   : integer;

 OLDROM : logical;
 COLUMNS: integer;
 ROWS   : integer;
 WINDOWCOUNT:  integer;
 
 DONE   : logical;
 JEVENT : logical;
 MAINEVENT: EventRecord;
(***************************************)
procedure _datainit; external;
(***************************************)
{$R-}
{$SC+}
(***************************************)
procedure panic;
begin
 ExitToShell;
end;

(***************************************)
procedure centerdialog( thetype : OSType; theid : integer);
var
 thehandle: AlertTHndl;
begin
 thehandle := AlertTHndl(GetResource(thetype, theid));
 HLock(Handle(thehandle));
 with thehandle^^ do begin
 with boundsRect do
 SetRect(boundsRect, 0, 0, right - left, bottom - top);
 with screenBits.bounds,
 boundsRect.botright do
 OffsetRect(boundsRect, (right - left - h) div 2,
 (bottom - top - v + 2 * MENUHEIGHT) div 3);
 end;
 HUnlock(Handle(thehandle));
end;

(***************************************)
procedure initmac;
begin
 MaxApplZone;
 InitGraf(@thePort);
 InitFonts;
 InitWindows;
 InitCursor;
 InitMenus;
 TEInit;
 InitDialogs(@panic);
 UnloadSeg(@_datainit);
end;

(***************************************)
procedure setupmenus;
begin
 APPLEMENU := GetMenu(applenum);
 AddResMenu(APPLEMENU, ‘DRVR’);
 InsertMenu(APPLEMENU, 0);
 FILEMENU := GetMenu(filenum);
 InsertMenu(FILEMENU, 0);
 EDITMENU := GetMenu(editnum);
 InsertMenu(EDITMENU, 0);
 WINDOWMENU := GetMenu(windnum);
 InsertMenu(WINDOWMENU, 0);
 DrawMenuBar;
end;

(***************************************)
procedure initglobals;
var
 index  : integer;
begin
 for index := 1 to 10 do
 MoreMasters;
 
 OLDROM := BitTst(Ptr(rom85), 0);
 
 if OLDROM then
 MENUHEIGHT := 20
 else
 MENUHEIGHT := shortpointer(mbarheight)^;
 
 if GetResource(‘PACK’, 0) = nil then
 JEVENT := false
 else
 JEVENT := (NGetTrapAddress($A860, ToolTrap)
 <> NGetTrapAddress($A89F, ToolTrap));
 
 with screenBits.bounds do begin
 SetRect(DRAGRECT, left + 5, top + MENUHEIGHT + 5,
 right - 5, bottom - 25);
 SetRect(GROWRECT, 160, 100, right - left - 10, bottom
 - top - MENUHEIGHT - 10);
 SetRect(SCREENRECT, left + 5, top + MENUHEIGHT + 25,
 right - 5, bottom - 5);
 COLUMNS := 1 + ((right - left - 330) div hoffset);
 ROWS := 1 + ((bottom -top -MENUHEIGHT - 230) div voffset);
 end;
 for index := 0 to 17 do
 with WINDOWS[index] do begin
 recordid := index;
 next := index + 1;
 end;
 WINDOWS[17].next := -1;
 
 FREE := 0;
 WINDOWCOUNT := 0;
 DONE := false;
end;

(***************************************)
procedure clickapplemenu(theitem : integer);
var
 itemname : Str255;
 savedport: GrafPtr;
 dummy  : integer;
 newport: GrafPort;
 thepicture :  PicHandle;
 therect: Rect;
begin
 if theitem > 3 then begin
 GetItem(APPLEMENU, theitem, itemname);
 GetPort(savedport);
 dummy := OpenDeskAcc(itemname);
 SetPort(savedport);
 end else if theitem < 3 then begin
 InitCursor;
 GetPort(savedport);
 OpenPort(@newport);
 SetPort(@newport);
 thepicture:=PicHandle(GetResource(‘PICT’, 1000+ theitem));
 with thepicture^^.picFrame do
 SetRect(therect, 0, 0, right - left, bottom - top);
 with screenBits.bounds, therect.botright do
 OffsetRect(therect, (right - left - h) div 2,
 (bottom - top - v) div 3);
 DrawPicture(thepicture, therect);
 repeat until Button;
 ClosePort(@newport);
 EnableItem(EDITMENU, 0);
 DrawMenuBar;
 PaintBehind(WindowPeek(FrontWindow), RgnHandle(
 longpointer(grayrgn)^));
 SetPort(savedport);
 FlushEvents(everyEvent, 0);
 end;
end;

(***************************************)
procedure placewindow(thewindow : WindowPtr);
var
 left   : integer;
 top    : integer;
begin
 left := 5 + hoffset * (WINDOWCOUNT mod COLUMNS);
 top := 5 +MENUHEIGHT +voffset *(1 + (WINDOWCOUNT mod ROWS));
 MoveWindow(thewindow, left, top, true);
end;

(***************************************)
procedure donew;
label
 100;
var
 dummy  : integer;
 windowtype :  integer;
 thewindow: WindowPtr;
 thestring: Str255;
begin
 if FREE < 0 then begin
 InitCursor;
 centerdialog(‘ALRT’, messagedialog);
 dummy := Alert(messagedialog, nil);
 goto 100;
 end;
 
 if OLDROM then
 windowtype := windownum
 else
 windowtype := zoomwindnum;
 
 thewindow := GetNewWindow(windowtype,
 @WINDOWS[FREE], WindowPtr(-1));
 placewindow(thewindow);
 
 WINDOWCOUNT := WINDOWCOUNT + 1;
 NumToString(WINDOWCOUNT, thestring);
 SetWTitle(thewindow, concat(
 ‘Window Without a Title #’, thestring));
 
 ShowWindow(thewindow);
 
 CalcMenuSize(WINDOWMENU);
 
 FREE := WINDOWS[FREE].next;
100:  end;

(***************************************)
procedure doclose(thepeek : WindowPeek);
begin
 if thepeek^.windowkind < 0 then
 CloseDeskAcc(thepeek^.windowkind)
 else begin
 CloseWindow(WindowPtr(thepeek));
 with datapointer(thepeek)^
 do begin
 next := FREE;
 FREE := recordid;
 end;
 CalcMenuSize(WINDOWMENU);
 end;
end;

(***************************************)
procedure doquit;
var
 thelong: longpointer;
 thepeek: WindowPeek;
begin
 thelong := longpointer(windowlist);
 thepeek := WindowPeek(thelong^);
 while thepeek <> nil do begin
 doclose(thepeek);
 thepeek := thepeek^.nextwindow;
 end;
 DONE := true;
end;

(***************************************)
procedure clickfilemenu(theitem : integer);
begin
 case theitem of
 newitem: donew;
 closeitem: doclose(WindowPeek(FrontWindow));
 quititem : doquit;
 end;
end;

(***************************************)
procedure zoomthewindow(thewindow : WindowPtr);
begin
 if GetWRefCon(thewindow) = 0
 then begin
 ZoomWindow(thewindow, inZoomOut, true);
 SetWRefCon(thewindow, 1);
 end else begin
 ZoomWindow(thewindow, inZoomIn, true);
 SetWRefCon(thewindow, 0);
 end;
end;

(***************************************)
procedure clickwindowmenu(theitem : integer);
var
 thewindow: WindowPeek;
begin
 if theitem = 1 then
 zoomthewindow(FrontWindow)
 else if theitem > 2 then begin
 theitem := theitem - 2;
 thewindow := WindowPeek(longpointer(windowlist)^);
 while (not thewindow^.visible)
 or (thewindow^.windowkind <> userKind) do
 thewindow := thewindow^.nextwindow;
 while theitem > 1 do begin
 theitem := theitem - 1;
 repeat
 thewindow:= thewindow^.nextwindow;
 until thewindow^.visible and (thewindow^.windowkind = userKind);
 end;
 SelectWindow(WindowPtr(thewindow));
 end;
end;

(***************************************)
procedure checkmenu(thewindow : WindowPeek);
begin
 DisableItem(EDITMENU, 0);
 DisableItem(WINDOWMENU, zoomitem);
 if thewindow = nil then
 DisableItem(FILEMENU, closeitem)
 else begin
 if thewindow^.windowkind <> userKind then
 EnableItem(EDITMENU, 0)
 else if not OLDROM then
 EnableItem(WINDOWMENU, zoomitem);
 EnableItem(FILEMENU, closeitem);
 end;
end;

(***************************************)
procedure clickinmenu;
var
 choice : long;
begin
 checkmenu(WindowPeek(FrontWindow));
 choice := MenuSelect(MAINEVENT.where);
 case HiWord(choice) of
 applenum : clickapplemenu(LoWord(choice));
 filenum: clickfilemenu(LoWord(choice));
 editnum: if SystemEdit(LoWord(choice) - 1) then;
 windnum: clickwindowmenu(LoWord(choice));
 end;
 HiliteMenu(0);
end;

(***************************************)
procedure clickindrag(thewindow : WindowPtr);
begin
 DragWindow(thewindow,
 MAINEVENT.where, DRAGRECT);
 SetWRefCon(thewindow, 0);
end;

(***************************************)
procedure clickingrow(thewindow : WindowPtr);
var
 newsize: long;
begin
 newsize := GrowWindow(thewindow, MAINEVENT.where, GROWRECT);
 if newsize <> 0 then begin
 InvalRect(thewindow^.portRect);
SizeWindow(thewindow, LoWord(newsize), HiWord(newsize), true);
 SetWRefCon(thewindow, 0);
 end;
end;

(***************************************)
procedure clickingoaway(thewindow : WindowPtr);
begin
 if TrackGoAway(thewindow, MAINEVENT.where) then
 doclose(WindowPeek(thewindow));
end;

(***************************************)
procedure clickinzoom(thewindow : WindowPtr; thezoom : integer);
begin
 if TrackBox(thewindow, MAINEVENT.where, thezoom) then
 zoomthewindow(thewindow);
end;

(***************************************)
procedure aclick;
var
 location : integer;
 thewindow: WindowPtr;
begin
 location := FindWindow(MAINEVENT.where, thewindow);
 case location of
 inDesk : SysBeep(1);
 inMenuBar: clickinmenu;
 inSysWindow: SystemClick(MAINEVENT,thewindow);
 inContent: SelectWindow(thewindow);
 inDrag : clickindrag(thewindow);
 inGrow : clickingrow(thewindow);
 inGoAway : clickingoaway(thewindow);
 inZoomIn : clickinzoom(thewindow, inZoomIn);
 inZoomOut: clickinzoom(thewindow, inZoomOut);
 end;
end;

(***************************************)
procedure akey;
var
 charcode : integer;
 choice : long;
begin
 if BitAnd(MAINEVENT.modifiers, cmdKey) <> 0 then begin
 charcode := BitAnd(MAINEVENT.message, charCodeMask);
 checkmenu(WindowPeek(FrontWindow));
 choice := MenuKey(chr(charcode));
 if choice <> 0 then begin
 case HiWord(choice) of
 applenum : clickapplemenu(LoWord(choice));
 filenum: clickfilemenu(LoWord(choice));
 editnum: if SystemEdit(LoWord(choice) - 1) then;
 windnum: clickwindowmenu(LoWord(choice));
 end;
 HiliteMenu(0);
 end;
 end;
end;

(***************************************)
procedure anactivate(thewindow : WindowPtr);
var
 savedport: GrafPtr;
begin
 SetPort(thewindow);
 DrawGrowIcon(thewindow);
end;

(***************************************)
procedure anupdate(thewindow : WindowPtr);
var
 savedport: GrafPtr;
begin
 GetPort(savedport);
 SetPort(thewindow);
 BeginUpdate(thewindow);
 ClipRect(thewindow^.portRect);
 EraseRect(thewindow^.portRect);
 DrawGrowIcon(thewindow);
 EndUpdate(thewindow);
 SetPort(savedport);
end;

(***************************************)
procedure mainloop;
var
 dummy  : logical;
begin
 repeat
 if JEVENT then
 dummy := waitnextevent(everyEvent, MAINEVENT,
 GetCaretTime, nil)
 else begin
 SystemTask;
 dummy := GetNextEvent(everyEvent, MAINEVENT);
 end;
 if dummy then begin
 case MAINEVENT.what of
 mouseDown: aclick;
 keyDown: akey;
 activateEvt:
 anactivate(WindowPtr(MAINEVENT.message));
 updateEvt:
 anupdate(WindowPtr(MAINEVENT.message));
 end;
 end;
 until DONE;
end;

(***************************************)
begin
 initmac;
 setupmenus;
 initglobals;
 mainloop;
end.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

VLC Media Player 2.2.0 - 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
Sound Studio 4.7.8 - Robust audio record...
Sound Studio lets you easily record and professionally edit audio on your Mac. Easily rip vinyls and digitize cassette tapes, or record lectures and voice memos. Prepare for live shows with live... Read more
LibreOffice 4.4.1.2 - Free, open-source...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
Freeway Pro 7.0.3 - Drag-and-drop Web de...
Freeway Pro lets you build websites with speed and precision... without writing a line of code! With its user-oriented drag-and-drop interface, Freeway Pro helps you piece together the website of... Read more
Cloud 3.3.0 - File sharing from your men...
Cloud is simple file sharing for the Mac. Drag a file from your Mac to the CloudApp icon in the menubar and we take care of the rest. A link to the file will automatically be copied to your clipboard... Read more
Cyberduck 4.6.5 - FTP and SFTP browser....
Cyberduck is a robust FTP/FTP-TLS/SFTP browser for the Mac whose lack of visual clutter and cleverly intuitive features make it easy to use. Support for external editors and system technologies such... Read more
Firefox 36.0 - Fast, safe Web browser. (...
Firefox for Mac offers a fast, safe Web browsing experience. Browse quickly, securely, and effortlessly. With its industry-leading features, Firefox is the choice of Web development professionals and... Read more
Thunderbird 31.5.0 - Email client from M...
As of July 2012, Thunderbird has transitioned to a new governance model, with new features being developed by the broader free software and open source community, and security fixes and improvements... Read more
VOX 2.4 - Music player that supports man...
VoxIt just sounds better! The beauty is in its simplicity, yet behind the minimal exterior lies a powerful music player with a ton of features & support for all audio formats you should ever need... Read more
A Better Finder Rename 9.46 - File, phot...
A Better Finder Rename is the most complete renaming solution available on the market today. That's why, since 1996, tens of thousands of hobbyists, professionals and businesses depend on A Better... Read more

Get The Whole Story – Lone Wolf Complete...
Get The Whole Story – Lone Wolf Complete is Now Available and On Sale Posted by Jessica Fisher on February 27th, 2015 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Check Out the Trailer for the Upcoming F...
Check Out the Trailer for the Upcoming FINAL FANTASY: Record Keeper Posted by Jessica Fisher on February 26th, 2015 [ permalink ] DeNA and Square Enix have announced that | Read more »
Legacy Quest is an Upcoming Rouge-like T...
Legacy Quest is an Upcoming Rouge-like That’ll Kill the Whole Family Posted by Jessica Fisher on February 26th, 2015 [ permalink ] Nexon Co. | Read more »
Grudgeball: Enter the Chaosphere Review
Grudgeball: Enter the Chaosphere Review By Jordan Minor on February 26th, 2015 Our Rating: :: MUSCLE MENUniversal App - Designed for iPhone and iPad Regular Show gets an above average game.   | Read more »
Action RPG League of Angels – Fire Raide...
Gaia is being invaded by the Devil Prince and the demonic Devil Army at his disposal, and it’s up to you and your avatar to defeat him in League of Angels – Fire Raiders. Raise a mighty army from hundreds of recruitable angel heroes and take the... | Read more »
Burn Rubber on the Ice With a New Cars:...
Burn Rubber on the Ice With a New Cars: Fast as Lightning Update Posted by Jessica Fisher on February 26th, 2015 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
AdVenture Capitalist Review
AdVenture Capitalist Review By Jordan Minor on February 26th, 2015 Our Rating: :: DAS KAPITALUniversal App - Designed for iPhone and iPad An inadvertent Marxist manifesto.   | Read more »
Monster vs Sheep Review
Monster vs Sheep Review By Jennifer Allen on February 25th, 2015 Our Rating: :: SAMEY FUNUniversal App - Designed for iPhone and iPad What Monster vs Sheep lacks in variety it makes up for with stress relieving fun. At least, for a... | Read more »
Is Your Face Ready for the New Outwitter...
Is Your Face Ready for the New Outwitters 2.0 Trailer? Posted by Jessica Fisher on February 25th, 2015 [ permalink ] One Man Left Studios has announced that their turn-based strategy game, | Read more »
HowToFormat Review
HowToFormat Review By Jennifer Allen on February 25th, 2015 Our Rating: :: USEFUL TIPSiPhone App - Designed for the iPhone, compatible with the iPad Making a presentation and want to get it just right? HowToFormat teaches you how... | Read more »

Price Scanner via MacPrices.net

Apple restocks refurbished Mac minis for up t...
The Apple Store has restocked Apple Certified Refurbished 2014 Mac minis, with models available starting at $419. Apple’s one-year warranty is included with each mini, and shipping is free: - 1.4GHz... Read more
Save up to $50 on iPad Air 2s, NY tax only, f...
 B&H Photo has iPad Air 2s on sale for $50 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 $50 off - 128GB iPad Air 2... Read more
16GB iPad Air 2 on sale for $447, save $52
Walmart has the 16GB iPad Air 2 WiFi on sale for $446.99 on their online store for a limited time. Choose free shipping or free local store pickup (if available). Sale price for online orders only,... 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: $1029 $70 off - 21″ 2.7GHz iMac: $1199 $100 off - 21″ 2.9GHz... Read more
Apple Takes 89 Percent Share of Global Smartp...
According to the latest research from Strategy Analytics, global smartphone operating profit reached US$21 billion in Q4 2014. The Android operating system captured a record-low 11 percent global... Read more
New Travel Health App “My Travel Health” iOS...
Rochester, Minnesota based Travel Health and Wellness LLC has announced that its new iOS app help safeguard the user’s health when traveling abroad — “My Travel Health” is now available on the Apple... Read more
Sale! MacBook Airs for up to $115 off MSRP
B&H Photo has MacBook Airs on sale for up to $100 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 11″ 128GB MacBook Air: $799 100 off MSRP - 11″ 256GB MacBook Air: $999 $100... Read more
15-inch 2.0GHz Retina MacBook Pro (refurbishe...
The Apple Store has Apple Certified Refurbished previous-generation 15″ 2.0GHz Retina MacBook Pros available for $1489 including free shipping plus Apple’s standard one-year warranty. Their price is... Read more
Wither The iPad mini? End Of The Road Imminen...
AppleDailyReport’s Dennis Sellers predicts that the iPad mini is going to be left to wither on the vine, as it were, and then just allowed to fade away — a casualty of the IPhone 6 Plus and other... Read more
Android and iOS Duopoly Owns 96.3% of Smartph...
IDC reports that Android and iOS inched closer to total domination of the worldwide smartphone market in both the fourth quarter (4Q14) and the calendar year 2014 (CY14). According to data from the... Read more

Jobs Board

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
Event Director, *Apple* Retail Marketing -...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global engagement strategy and team. Delivering an overarching brand 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
*Apple* Solutions Consultant - Retail Sales...
**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 - Retail Sales...
**Job Summary** As an Apple Solutions Consultant (ASC) you are the link between our customers and our products. Your role is to drive the Apple business in a retail Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.