TweetFollow Us on Twitter

Real Window XCMD
Volume Number:5
Issue Number:2
Column Tag:HyperChat™

A Real Window XCMD

By Joe Zuffoletto, Cupertino, CA

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

Window XCMD

Part 1: Windows, XCMD’s, and MultiFinder

Joe has been at Apple a little over a year, where he works in the Software Quality Assurance department. His group develops automated software test tools. Before coming to Apple, He earned a BS in EE & CS from Princeton University. He has been programming the Mac for about 8 months and spends a lot of time experimenting with HyperCard. This article contains important windowing technology for dealing with gray regions, contirbuted by Scott Boyd and Greg Marriott.

Of Cards and Windows

For some reason, XCMD’s that put up windows intrigue me. I think it’s because windows imply event loops, and running an event loop in an XCMD is an interesting idea because it allows you to temporarily “steal the show” from HyperCard. Also, once you throw a window on the screen there’s a lot of neat stuff you can put inside it, like graphics too large for HyperCard’s card window, files generated by other applications, color pictures, and human interfaces for sophisticated tasks.

In this article I will present an XCMD that displays a document window with scroll bars. This XCMD is full-featured and very robust -- essentially a mini-Macintosh application running on top of HyperCard. It is MultiFinder aware, shows how to scroll bitmapped graphics documents, and also demonstrates how to support multiple screens on the Mac II. Finally, it demonstrates how to cope with some human interface issues when it comes to displaying windows on top of HyperCard.

Figure 1a: Before...

My discussion assumes you are somewhat familiar with the issues behind writing XCMD’s and XFCN’s for HyperCard. In particular, I assume you have a nodding acquaintance with the glue routines that perform special functions and facilitate communication between your XCMD and HyperCard. Plenty of introductory articles on the subject have appeared in MacTutor over the past few months, and Gary Bond has written an excellent book, XCMD’s for HyperCard (MIS Press, 1988), which gives you a head start in writing XCMD’s (Like Gary, I refer to XCMD’s and XFCN’s simply as XCMD’s).

Figure 1b: _After

However, even if you are not writing XCMD’s you might learn a lot of useful stuff by reading this article. My XCMD uses an event loop much like one you would find in a normal application, and I show you how to cope effectively with event handling and cursor tracking under MultiFinder. Also, if you’d like to see a rare example of scrolling code, that will be coming next month. In short, there’s something here for just about everyone.

One article will not hold all this material, so I’m splitting it into two parts. This month I will show you how to put the window up and deal with MultiFinder, multiple screens, and human interface issues. The window will have scroll bars but they won’t work. Next month I’ll breathe life into the scroll bars by demonstrating techniques for scrolling bitmapped graphics documents. As a newcomer to Mac programming I feel there is a critical shortage of example scrolling code, so I’d like to add some to the pool.

First Stop: The Drawing Board

I would like to start by describing the design of this fairly extensive XCMD, which I call Window.

The goal is to create a “full-featured” window -- one that is draggable, growable, zoomable, and contains scroll bars. Some other aspects of the design:

• Window is “semi-modal.” This means we cannot use HyperCard while the window is up, but we can switch to other applications under MultiFinder. Boo! Hiss! Yecch! Unfortunately, this “feature” is imposed on us by HyperCard, which, like all Macintosh applications, doesn’t like to share its event loop with strangers.

• Window is “MultiFinder aware;” i.e., the main event loop calls WaitNextEvent and handles suspend/resume events. We don’t need a SIZE resource because we’re running under the auspices of HyperCard and are using whatever space is available in HyperCard’s application heap. Window doesn’t use the clipboard, so it doesn’t need to convert its own private scrap when the user clicks on another open application. This feature could be added, however.

If you’d like more information about programming under MultiFinder, see the “Programmer’s Guide to MultiFinder,” an Apple publication available from APDA.

• Window supports multiple screens on the Mac II. This means the window can be dragged to any screen, grown or zoomed to the size of the largest screen, or grown to span adjacent screens. If the user clicks on the zoom box, the window zooms to whatever screen the zoom box is on at the time, instead of the default behavior of zooming to the main screen.

• Window accounts for human interface anomalies introduced by HyperCard. This means it deals sensibly with HyperCard’s windoids and with the current state of the menubar, which may or may not be visible when Window is invoked. As we’ll see, inattention to the state of the menubar can get you into trouble under MultiFinder!

• The HyperTalk call is:

 Window title,top,left,bottom,right

where title is a string (enclosed in double quotes), and the other parameters are integers specifying the window’s screen location in global coordinates; i.e., (0,0) is the top left corner of the screen (or of the main device on a Mac II), with coordinates increasing as you move down and right.

• Window won’t allow you to draw a window whose title bar is off the screen or under the menubar.

• Command-spacebar toggles the menubar off and on, just like in HyperCard. If the menubar is visible and the user clicks the mouse outside the window, the menubar flashes unless the click causes MultiFinder to switch to another open application.

• Clicking on the window’s close box ends the XCMD. Command-W, which closes windows in the Finder and many other applications, is also supported for this purpose.

For now, the window we put up will be empty, but will demonstrate all of the features described above. Next month I’ll add contents to the window when I talk about scrolling.

Plan of Attack

Now that we know the main features of the XCMD, it’s time to think about what steps to take to implement them.

Window, of course, will have an event loop, much like a normal Macintosh application. Because of its semi-modal nature, however, Window will not respond to mouse clicks inside HyperCard’s card window or menubar. Instead, it will just flash the menubar.

Incidentally, we could put up our own menubar and turn Window into a true mini-application, and then restore the menubar to HyperCard’s on exit. As soon as someone thinks of a useful mini-application that runs as an XCMD they will do this, but for now let’s keep things simple and ignore the menubar.

By the way, because we’re ignoring the menubar, what will happen under MultiFinder when the user clicks on the application icon in the upper righthand corner? Will we switch applications? Yes! This is the other side of Window’s semi-modal nature. The only thing that prevents MultiFinder from switching in this situation is if the frontmost window is of the dBoxProc type, which MultiFinder associates with modal dialog boxes. Our window is of type zoomDocProc, so MultiFinder will switch. MultiFinder will also switch if we click on a visible window belonging to a different application.

I want to avoid adding extra resources (besides the XCMD itself) for the user to copy into his or her stack, so I’ll use NewWindow to build my window on the fly instead of pulling it out of a resource with GetNewWindow. This is no big deal because the window is just a standard document window with a zoom box.

As with writing desk accessories, we can have no global variables. This should be no problem.

Early Frustrations

If you have ever tried to put a window on top of HyperCard with an XCMD, you probably experienced all kinds of interesting and unexpected problems. You will therefore recognize some of the obstacles I encountered in early development, which I will now describe to you -- solutions included.

The first problem is a complete show-stopper with the following symptoms: The XCMD successfully puts up some kind of window -- a dialog box, document window, or whatever -- but then bombs consistently on exit. Inspecting the code reveals no obvious problems. What on earth could possibly be wrong? The answer is contained in the following Fundamental Law: Thou shalt save the current grafPort upon entering thy XCMD and restore it upon leaving.

When an XCMD starts, the current grafPort is always HyperCard’s card window, and HyperCard expects things to be no different when the XCMD ends. If you set the port to something different, say to a window you put up or to a printing grafPort, and then don’t set it back, HyperCard gets very confused and dances La Bomba.

Let’s now assume the grafPort problem is solved and we have a window up that can be dragged, grown, and zoomed. The next problem pertains to update events; namely, the HyperCard window and the little windoids don’t seem to be getting any. Instead, when we drag our window on top of them and move it away, big white blotches remain. But under MultiFinder, when we drag our window over other applications and move it away, they update normally. What’s going on here?

The answer to this question is fairly interesting, and the described behavior under MultiFinder adds additional insight. First of all, it should be clear why the other applications update normally: It’s because MultiFinder sends them update events whenever our window’s movements corrupt their displays. Well then, shouldn’t MultiFinder be sending HyperCard update events for the same reason? Yes, it should, and indeed it is, but update events for HyperCard are being intercepted by our XCMD’s event loop!

At this point we have two choices. We can either throw up our hands and live with the white blotches, or we can figure out a way to pass update events to HyperCard. Following the second path is best, of course, but before you dive into your MultiFinder documentation to figure out how to fake an app4 event, think for a minute about the HyperTalk callback routines. These are routines like ZeroToPas, GetFieldByName, SendHCMessage, StrToNum -- hey, wait a minute! SendHCMessage! That sounds promising.... As you may know, SendHCMessage delivers messages from XCMD’s to HyperCard (and its cousin, SendCardMessage, delivers messages from XCMD’s to the current card). Maybe we can do something like this when we get an update event:


  myWindow:  WindowPtr;
  HCPort:    GrafPtr;
  CASE myEvent.what OF
      IF WindowPtr(myEvent.message) =
         myWindow) THEN
      ELSE IF
      = WindowPtr(HCPort)) THEN

This is the right idea, but SendHCMessage takes only legal HyperTalk commands as input parameters! Which HyperTalk command(s) will send an update event to the card window? It turns out that going to any card (including the current card) will do the trick. Since we don’t want to switch cards on the user in the middle of our XCMD, let’s replace the bogus SendHCMessage command above with


SendHCMessage(‘go to this card’);

and, like magic, both our window and the card window will get update events when they need them. But what about the windoids? They still suffer from white-blotchitis.

Egads! Human Interface Issues!

This is where we can be good boys and girls and think about Human Interface Issues. Every Mac programmer should do this at least once in his or her lifetime, and here’s a wonderful opportunity to get it over with. We know our window is semi-modal, which implies it is on top of every other window in our layer, including the windoids. We also know that the user can’t use any of the windoids while our XCMD is running because we don’t know how to process events in them. Despite all this, the windoids remain hilited and appear to be as active and available as ever -- a potentially confusing situation for the user. So why don’t we hide them?

I happen to think this is a Very Good Idea, and I would like to propose that all HyperCard authors, be they XCMD writers or HyperTalk scripters, observe the following guidelines when creating their products:

• Always hide windoids upon entering event-driven XCMD’s or XFCN’s.

• Please don’t hide windoids from within HyperTalk scripts unless absolutely necessary. Leave the menubar alone, too.

• Whenever you hide windoids, get and save their current state (i.e., which ones are visible, where they are located on the screen, and which tools/patterns are selected) and return them to that state when you are finished. The same goes for the menubar.

If I make only one contribution to the Macintosh programming community before I die I hope it is the italicized guideline above. I spend a fair amount of time customizing my HyperCard environment, and I have all the windoids displayed right where I want them. I just can’t stand it when someone’s script comes along, blows them all away for no apparent reason, and then leaves it to me to put them back. Verrry rude. I also can’t stand it when people take the menubar away from me and never restore it, especially on a Mac II.

For the purpose of writing event-driven XCMD’s, we can satisfy the first and third guidelines with the following code:


  mBarHeight = $BAA;  {global}
  toolVis,menuVis:  BOOLEAN;
  toolH:  Handle;
  menuBarHeight: INTEGER;
  menuBarHeightPtr:  ^INTEGER;
  {Get and save current state of 
  toolH := EvalExpr(‘visible of tool 
  toolVis := StrToBool(toolStr);
  IF toolVis THEN
    SendHCMessage(‘hide tool

  {Get and save current state of 
  menuBarHeightPtr :=
  menuBarHeight := menuBarHeightPtr^;
  IF menuBarHeight > 0 THEN
    menuVis := TRUE
    menuVis := FALSE;
  {“Meat” of XCMD goes here”}
  {Restore windoid when finished}
  IF toolVis THEN
    SendHCMessage(‘show tool 
  {Restore menubar if you changed it}

Of course, we would repeat the tool windoid code for the pattern and message windoids. You don’t need to worry about the locations of the windoids because HyperCard “remembers” their positions between hide and show commands.

HyperCard has one other windoid called FatBits that appears whenever you go into fatbits mode, but there are no HyperTalk commands to hide it or show it! Fortunately, Bill Atkinson names all his windoids, and the HyperCard people tell me the names won’t change, so all we have to do is walk the window list until we find the window called “FatBits,” then hide it if appropriate. I accomplish this in the HideFatBits procedure, which is nested in HideWindoids. Once HideFatBits finds the FatBits window, it saves the WindowPtr to it so we can show it again (if necessary) in the RestoreWindoids routine.

Aack! More Human Interface Issues!!

OK, as long as we’re hiding the windoids, why not hide the card window? And since we’re ignoring the menubar, we might as well get rid of it too, right?

I don’t have strong opinions about either of these ideas. Concerning the card window, I prefer to leave it up for four reasons. First, the current card may contain information we want to see while we are looking at the contents of the window. Second, leaving the card window showing gives us a visual reminder of who owns the window when we are running under MultiFinder, because clicking on either window will bring HyperCard’s layer to the front (with our window on top, of course). Third, it gets a little annoying to watch the card window disappear and reappear every time we invoke Window. And fourth, since larger human interface concerns are not at stake here (as they are with the windoids), I’m content to let the user decide in his or her HyperTalk script whether or not the card window will be left showing.

I solve the menubar problem by allowing the user to toggle it with command-space, just like in HyperCard.

Dashing through the Code...

Once I got past the initial obstacles and human interface issues, coding the XCMD was fairly straightforward. In this section I’ll zip through the program listing and give you some idea of what’s going on. Remember that I’m going to cover the scrolling of bitmaps next month, so all the scrolling and bitmap routines are stubbed out.

Take a look at the Main Program. The first thing we do (after checking the HyperCard version and saving thy grafPort) is make sure the number of input parameters sent to us is correct by calling CheckParamCount. CheckParamCount tells us nothing about the parameter types; if they’re mixed up or wrong we could be in trouble.

Assuming the input parameters are cool, we use the standard battery of ZeroToPas and StrToNum calls to convert them to useable form for our program. Then we hide the windoids and draw the window with scroll bars.

Next we enter the main event loop, where we call WaitNextEvent (if available) and pre-process suspend/resume events if MultiFinder feeds them to us. I say “pre-process” because all we do here is set a flag telling us if we are running in the background or not. This information is used later when activate and update events are handled.

A Short Digression:

Cursor Tracking with WaitNextEvent

While we’re talking about WaitNextEvent, let me say a few words about cursor tracking. Imagine a routine called AdjustCursor which does the following:

1. Get the mouse location in global coordinates;

2. Get the location and size of my window;

3. If the mouse lies within my window’s content region (minus the scroll bars), set the cursor to HyperCard’s browse tool, and set a region called cursorRgn to region A (see Figure 2a);

4. If the mouse lies outside region A, set the cursor to arrow, and set cursorRgn to region B (see Figure 2b).

Figure 2a

In the old days (before WaitNextEvent), Macintosh programmers would call a routine similar to AdjustCursor on every pass through the event loop because that was the easiest way to make sure the correct cursor was showing over various parts of a program’s human interface. This technique, although reliable, is inefficient because lots of time is spent crunching through AdjustCursor, even when the cursor is not moving.

WaitNextEvent has an interesting feature that makes cursor tracking more efficient. If I call the hypothetical AdjustCursor routine and then pass a handle to cursorRgn as the last input parameter to WaitNextEvent, I will get a mouse-moved event from MultiFinder when the cursor leaves cursorRgn, and then I can call AdjustCursor again to update the cursor and redefine cursorRgn for next time. This saves me from needlessly updating the cursor on every pass through the event loop.

This is very efficient, but using WaitNextEvent’s cursor tracking feature solves only part of the cursor tracking problem. Let me illustrate with an example. Assume I’m using the WaitNextEvent feature, and let’s say my window is small and I’m going to zoom it to fill the screen. When I move to the zoom box from region A I’ll get a mouse-moved event. Then I’ll call AdjustCursor to switch cursorRgn to region B and the cursor to arrow. So far, so good.

Now if I zoom the window and don’t move the cursor, the cursor will be sitting somewhere over my window’s contents, where it should become the browse tool cursor. But it’s still the arrow! Why? Because the old region B is still in effect (instead of a new region A), and a new region A won’t be created until I cross into the old region A again! To solve this problem, I can call AdjustCursor immediately after zooming the window to account for the window’s new size. But I’ll experience the same problem after dragging and growing the window, so now I have to call AdjustCursor in these cases as well. Of course, I could just call AdjustCursor when I handle update events, but I still need to call it immediately after dragging the window because dragging doesn’t always generate an update event in my layer. I think you can see my point -- WaitNextEvent’s cursor tracking feature is helpful because it saves you from calling AdjustCursor on every pass through the event loop, but there are a few special cases, mostly related to window movement and sizing, that you must handle yourself. Also, if you are calling GetNextEvent instead of WaitNextEvent, you must still use the old cursor tracking technique (or a more efficient technique of your own invention).

You might have noticed while using HyperCard that the cursor is kind of flaky. In particular, it is sometimes the arrow when it should be the browse tool, but if you move it outside of the card window and then back again, the browse tool reappears! You can probably guess my theory as to why this happens....

Figure 2b.

The Main Event

OK, we’ve pre-processed our MultiFinder events and adjusted our cursor. Now we can handle events in our window. Not too many surprises here -- I’ll zip through each event and summarize what’s happening.


Flash the menubar (when it is visible) if the mouse click is outside our window; otherwise:


• Drag the window. If you haven’t read the Window Manager chapter of Inside Macintosh, Volume V, now’s a great time to do it. Notice I obtain the dragRect (the rectangle within which we can drag the window) by calling GetGrayRgn, which replaces old-style references to the QuickDraw global screenBits.bounds and automatically takes multiple screens into account for us.

• Update the card window (must do it explicitly because there is no update event in our layer)

• Adjust the cursor region.


• Grow the window. The GrowWindow routine has been modified for multiple screen systems; again, see the Window Manager chapter of Inside Macintosh, volume V for details.

• Move the scroll bars


• Zoom the window according to the rules implemented n the ZoomIt procedure.


• Deal with scroll bars, if appropriate; otherwise ignore.


• Exit event loop and XCMD!


If inBackground is true, then we’ve just been sent behind another application under MultiFinder. We deactivate our scroll bars and show the menubar if it was hidden. MultiFinder will not take care of the menubar for us, and it’s terribly unkind to send the user off to another application without a menubar!

Similarly, when we return, inBackground will be false. We reactivate our scroll bars and return the menubar to whatever state it was in when we left.


If inBackground is true, then we have been fed an update event by MultiFinder because the user’s mousing around in another application has corrupted our window, HyperCard’s card window, or both.

If our window is corrupted, we redraw our deactivated scroll bars and the other stuff in our window.

If HyperCard’s window is corrupted, we update Hyper-Card’s window without updating ours. We also call BeginUpdate and EndUpdate to empty the HyperCard window’s update region because SendHCMessage alone doesn’t do this, and we’ll get into an infinite loop of update events if we don’t do it ourselves.

If inBackground is false, then we have been fed an update event because our window has either been grown or zoomed.

If our window is corrupted, we redraw our activated scroll bars and the other stuff in the window. Then we adjust the cursor.

If HyperCard’s window is corrupted, we update it as described above.


The only other event that concerns us is keyDown. If we get command-space, we toggle the menubar off and on, just like in HyperCard. If we get command-W, we close the window and leave the XCMD.

Sneak Preview

That does it for putting up the window, building an event loop, and dealing with MultiFinder. Next month I’ll describe the routines and data structures for scrolling and offscreen bitmaps, which are stubbed out in this month’s code listing. I’ll show you how to set up an offscreen bitmap, then I’ll demonstrate a technique called blitting that produces flicker-free, high-speed scrolling.

Thanks, Everybody!

At this point I would like to mention a few people whose ideas and assistance were of great help to me in this glorious project. At the top of the list is “Mr. Toolbox” himself, Greg Marriott, who responded to most of my questions with an understanding nod and a correct answer. Greg also supplied the code for zooming the window on multiple screens.

Not far behind is “Mr. Window Manager,” Scott T Boyd, who taught me how to live without the QuickDraw globals.

[MacTutor readers will be very familar with both Scott Boyd and Greg Marriott as contributors and friends of MacTutor particularly during their "MacHax days". -Ed]

Thanks to Steve Maller for teaching me how to update HyperCard’s window, and to Ginger Jernigan, who took time to review the manuscript.

Thanks to Gary Bond for his excellent book on writing XCMD’s, and for the time he took to review the manuscript.

And, gosh, I almost forgot: Thanks, Bill!


© 1988, Apple Computer, Inc.
All rights reserved. Publication rights granted to MacTutor.

Window1.p:  A HyperCard XCMD in MPW Pascal 2.0.2 
           by Joe Zuffoletto
           Version 1.0, 29 June 1988

Form:      Window title,top,left,bottom,right

Example:   window “My Window”,50,100,300,400

Notes:     Window puts up a standard document window with
           scroll bars. The window can be dragged, resized,
           zoomed, and closed.

           Command-W is supported for closing the window.
           Command-spacebar toggles the menubar on and off,
           as in HyperCard. If you try to draw the window’s 
           title bar off the screen or under the menubar, 
           Window will abort with an error message. Error 
           messages can be examined by looking at 
           HyperCard’s global variable “the result” after 
           calling Window.

           Window is MultiFinder friendly and works with 
           HyperCard 1.2 or later. It supports multiple 
           displays on the Mac II as well. 

           You must supply your own code for displaying 
           whatever you want to display in the window.


To compile and link this file using MPW Pascal 2.0.2, select the following 
lines and press ENTER:

Pascal Window1.p
link   -o “Hard Disk”:HyperCard:”HyperCard Stacks”:Home 
       -rt XCMD=2000 -sn Main=Window 
       Window1.p.o {MPW}Libraries:Interface.o 
       {MPW}PLibraries:PasLib.o 
       -m ENTRYPOINT

Use other link files as necessary.

The above link directives install the XCMD resource into the Home stack. 
You can substitute the name of any stack you want; be sure to provide 
the correct pathname. Also, make sure the target stack already has a 
resource fork or it won’t work. You can create an empty resource fork 
in a stack
with ResEdit.




{$S Window}

UNIT DummyUnit;



PROCEDURE EntryPoint(paramPtr:XCmdPtr);


TYPE Str31 = String[31];

     OffScrHandle = ^OffScrRecPtr; 
       {Attach to refCon of a window}
     OffScrRecPtr = ^OffScrRecord;
     OffScrRecord = RECORD
                      {Next month!}

     ScrollHandle = ^ScrollPtr;
       {Attach to refCon of a control}
     ScrollPtr = ^ScrollRecord;
     ScrollRecord = RECORD
                      {Next month!}

PROCEDURE Window(paramPtr:XCmdPtr);FORWARD;

PROCEDURE EntryPoint(paramPtr:XCmdPtr);

  {Next month!}
END; {Min}

PROCEDURE InitBlit(theWindow:WindowPtr);
  {Next month!}
END; {InitBlit}

PROCEDURE InvalContents(theWindow:WindowPtr;
  {More to come next month!}
END; {InvalContents}

PROCEDURE DrawContents(theWindow:WindowPtr);
  {Next month!}
END; {DrawContents}

PROCEDURE ScrollContents(theWindow:WindowPtr;dh,dv:INTEGER);
  {Next month!}
END; {ScrollContents}

PROCEDURE MyScroll(theControl:ControlHandle;partCode:INTEGER);
  {Next month!}
END; {MyScroll}

PROCEDURE Window(paramPtr:XCmdPtr);
  minParamCount     =  5;
  smallestHeight    =  100;
  smallestWidth     =  100;
  _WaitNextEvent    =  $A860;
  _Unimplemented    =  $A89F;
  active            =  0;
  inactive          =  255;
  MouseMovedEvt     =  $FA;
  SuspendResumeEvt  =  $01;
  SuspendEventMask  =  $1;
  ConvertScrapMask  =  $2;
  browseTool        =  6069;
  HCWidth           =  512;
  HCHeight          =  342;
  padding           =  16;
  toolVis,patVis:             BOOLEAN;
  msgVis,fatVis:              BOOLEAN;
  hasWaitNextEvent:           BOOLEAN;
  inBackGround,smallScreen:   BOOLEAN;
  DoneFlag,HaveEvent:          BOOLEAN;
  wTop,wLeft,wBottom,wRight:   INTEGER;
  partCode,controlCode:        INTEGER;
  largestHeight,largestWidth:  INTEGER;
  dummy,charCode:              INTEGER;
  screenWidth,screenHeight:    INTEGER;
  myDocWidth,myDocHeight:      INTEGER;
  eventPoint:                  Point;
  wRect,screenRect,dragRect:   Rect;
  winSizeLimits:               Rect;
  oldSize:                     Rect;
  newSize,dontCare:            LONGINT;
  envError:                    OSErr;
  cursorRgn:                   RgnHandle;
  hScroll,vScroll:             ControlHandle;
  whichControl:                ControlHandle;
  myWindow,whichWindow:        WindowPtr;
  fatBitsWindow:               WindowPtr;
  HCrefresh:                   Str31;
  wT,wL,wB,wR,wTitle:          Str255;
  toolStr,patStr,msgStr:       Str255;
  widthStr,heightStr:          Str255;
  myBits:                      BitMap;
  theEnv:                      SysEnvRec;
  myEvent:                     EventRecord;
  wRecord:                     WindowRecord;
  HCPort:                      GrafPtr;
  theOffScrHandle:             OffScrHandle;
  theScrollHandle:             ScrollHandle;
  myOffScr:                    OffScrRecord;
  myScrollRecord:              ScrollRecord;
  FUNCTION TrapAvailable(tNumber: INTEGER; tType:
  {Check to see if a given trap is implemented.}
    TrapAvailable := NGetTrapAddress(tNumber, tType) <> 
  END; {TrapAvailable}

  FUNCTION CreateHScrollBar(theWindow:WindowPtr;
  {Allocate and draw a horizontal scroll bar in theWindow.
   Return a controlHandle to the scroll bar.}
    myWindowRect,hScrRect:  Rect;
    myWindowRect := theWindow^.portRect;
    SetRect(hScrRect,myWindowRect.left -1,
                     myWindowRect.bottom - 15,
                     myWindowRect.right - 14,
                     myWindowRect.bottom + 1);
    CreateHScrollBar := NewControl(theWindow,hScrRect,
  END; {CreateHScrollBar}

  FUNCTION CreateVScrollBar(theWindow:WindowPtr;
  {Allocate and draw a vertical scroll bar in theWindow.
   Return a controlHandle to the scroll bar.}
    myWindowRect,vScrRect:  Rect;
    myWindowRect := theWindow^.portRect;
    SetRect(vScrRect,myWindowRect.right -15,
            - 1,
                     myWindowRect.right + 1,
                     myWindowRect.bottom - 14);
    CreateVScrollBar := NewControl(theWindow,vScrRect,
  END; {CreateVScrollBar}
  PROCEDURE InvalScroll(theWindow:WindowPtr);
  {Accumulate the rectangles occupied by theWindow’s
   horizontal and vertical scroll bars into the update
    theRect,tallRect,wideRect:  Rect;
    theRect := theWindow^.portRect;
    {Accumulate tallRect, which is occupied by the vertical
     scroll bar }
    {Accumulate wideRect, which is occupied by the 
     horizontal scroll bar }
  END; {InvalScroll}

  PROCEDURE Deactivate(theWindow:WindowPtr);
  {Deactivate the scroll bars in theWindow in accordance
   with the human interface guidelines. This means we
   must erase everything enclosed by the control rec-
    theControl:      ControlHandle;
    theControlRect:  Rect;
    {I always title my scroll bars ‘MyVert’ and ‘MyHoriz’
     so I can easily find them by walking a window’s
     control list.}
    theControl := WindowPeek(theWindow)^.controlList;
    WHILE (theControl <> NIL) DO
      IF (theControl^^.contrlTitle = ‘MyVert’) OR
         (theControl^^.contrlTitle = ‘MyHoriz’) THEN
        theControlRect := theControl^^.contrlRect;
      END; {IF}
      theControl := theControl^^.nextControl;
    END; {WHILE}
  END; {Deactivate}

  PROCEDURE HiliteScrollBars(theWindow:WindowPtr);
    {Reactivate the scroll bars; e.g., when we resume
     under MultiFinder. More next month!}
  END; {HiliteScrollBars}

  PROCEDURE MoveScrollBars(theWindow:WindowPtr);
  {Call this procedure after theWindow has changed size.
   MoveScrollBars erases theWindow’s scroll bars, resizes
   them, and redraws them.}
    myWindowRect:       Rect;
    vScrRect,hScrRect:  Rect;
    myWindowRect := theWindow^.portRect;
    SetRect(hScrRect,myWindowRect.left - 1,
                     myWindowRect.bottom - 15,
                     myWindowRect.right - 14,
                     myWindowRect.bottom + 1);
    SetRect(vScrRect,myWindowRect.right - 15,
            - 1,
                     myWindowRect.right + 1,
                     myWindowRect.bottom - 14);
    {Hide and resize the scroll bars to fit the new window 
    SizeControl(hScroll,(hScrRect.right - hScrRect.left),
                        (hScrRect.bottom -;
    SizeControl(vScroll,(vScrRect.right - vScrRect.left),
                        (vScrRect.bottom -;
  END; {MoveScrollBars}
  PROCEDURE ScrollWithThumb(theControl:ControlHandle;
    {Next month!}
  END; {ScrollWithThumb}

  FUNCTION WhichDevice(thePoint:Point):GDHandle;
  {For machines that support color QuickDraw and
   multiple screens, WhichDevice figures out which screen 
   thePoint is on and returns a GDHandle to that screen. 
   thePoint might be where the mouse was clicked, for 
   example. Thanks to Greg Marriott for this code.}
    aDevice:   GDHandle;
    foundOne:  BOOLEAN;
    aDevice := GetDeviceList;
    foundOne := FALSE;
    {Walk the device list until thePoint is contained
     in some device’s screen rectangle.}
    WHILE (aDevice <> NIL) AND NOT foundOne DO
      IF PtInRect(thePoint,aDevice^^.gdRect) THEN
        WhichDevice := aDevice;
        foundOne := TRUE;
      aDevice := aDevice^^.gdNextGD;
  END; {WhichDevice}

  {Returns the height of the menubar in pixels, as read
   from the low memory global mBarHeight.}
    mBarHeight = $BAA;
    menuBarHeightPtr:  ^INTEGER;
    menuBarHeightPtr := Pointer(mBarHeight);
    MenuBarHeight := menuBarHeightPtr^;
  END; {MenuBarHeight}

  FUNCTION OnAScreen(theRect:Rect):BOOLEAN;
  {OnAScreen returns FALSE if all of a window’s title
   bar is off the screen or if any part of it is under
   the menubar. The portRect of the window to be checked
   should be passed in theRect.}
    titleBarHeight  =  18;
    deskRgn:           RgnHandle;
    topLeft,topRight:  Point;
    deskRgn := GetGrayRgn;
    topLeft.v := - titleBarHeight;
    topLeft.h := theRect.left + titleBarHeight;
    topRight.v := topLeft.v;
    topRight.h := theRect.right - titleBarHeight;
    IF ((PtInRgn(topLeft,deskRgn)) OR 
    (PtInRgn(topRight,deskRgn))) THEN
      OnAScreen := TRUE
      OnAScreen := FALSE;
  END; {OnAScreen}

  PROCEDURE ZoomIt(theWindow:WindowPtr;partCode:INTEGER;
  {ZoomIt supports more elegant window zooming on multiple
   screen systems. theWindow will zoom to fill whatever
   screen the zoom box was on when it was clicked. The
   window state toggles between original size and zoomed
   size, as usual. Thanks to Greg Marriott for this code.}
    titleBarHeight  =  18;
    WStatePtr     =  ^WStateData;
    WStateHandle  =  ^WStatePtr;
    oldRect,newRect:  Rect;
    maxHeight:        INTEGER;
    oldRect := theWindow^.portRect;
    IF theEnv.hasColorQD THEN
      newRect := WhichDevice(clickedWhere)^^.gdRect;
      IF WhichDevice(clickedWhere) = GetMainDevice THEN := + MenuBarHeight;
      newRect := GetGrayRgn^^.rgnBBox;
    newRect.left := newRect.left + 2; := + titleBarHeight + 2;
    newRect.right := newRect.right - 3;
    newRect.bottom := newRect.bottom - 3;
    IF NOT EqualRect(oldRect,newRect) THEN
      WITH WindowPeek(theWindow)^ DO
        WStateHandle(dataHandle)^^.stdState := newRect;
  END; {ZoomIt}

  PROCEDURE Fail(errStr:Str255);
  {Fail returns errStr to HyperCard and exits the XCMD.
   errStr can then be checked by inspecting HyperCard’s
   global variable “the result.” See “XCMD’s for Hyper-
   Card” by Gary Bond (MIS Press, 1988) for more details.
   © 1988 by Gary Bond
   All rights reserved. Publication rights granted MacTutor
   You may use this code for NON-COMMERCIAL purposes.}
    paramPtr^.returnValue := PasToZero(errStr);
  END; {Fail}

  PROCEDURE CheckParamCount;

  {CheckParamCount sees if the number of parameters
   passed to the XCMD matches the number expected. If
   not, we exit from the XCMD with an error message.
   See “XCMD’s for HyperCard” by Gary Bond (MIS Press,
   1988) for more details.
   © 1988 by Gary Bond
   All rights reserved. Publication rights granted MacTutor
   You may use this code for NON-COMMERCIAL purposes.}
    numParams:  INTEGER;
    numParams := paramPtr^.paramCount;
    IF(numParams <> minParamCount) THEN
      Fail(‘Form: HyperWindow “Window 
  END;  {CheckParamCount}

  FUNCTION GetHCVersion: Str255;
  {Return a string containing the version of HyperCard
   being used; e.g., ‘1.2’}
    ZeroToPas(EvalExpr(‘the version’)^,GetHCVersion);
  END; {GetHCVersion}

  PROCEDURE HideWindoids;
  {Get and save the visible state of the tool, pattern,
   message and fatbits windoids; then hide them if they
   are showing.}
    toolH,patH,msgH,fatH:  Handle;
    PROCEDURE HideFatBits;
    {HyperCard does not have a built-in command for hiding
     and showing the fatbits windoid, so we have to do it
     ourselves. HideFatBits walks the window list until it
     finds a window with title “FatBits,” then hides it if
     the visible field of its WindowRecord is true. 
     HideFatBits also saves the WindowPtr to the fatbits
     windoid so we can use it later (e.g., to show the
     windoid again).}
      windowList  =  $9D6; {Low memory global location.}
      theWindow:     WindowPeek;
      theWindowPtr:  ^WindowPtr;
      theWindowPtr := Pointer(windowList);
      theWindow := WindowPeek(theWindowPtr^);
      fatVis := FALSE;
      WHILE (theWindow <> NIL) DO
        IF (theWindow^.titleHandle^^ = ‘FatBits’) THEN
          fatBitsWindow := WindowPtr(theWindow);
          IF (theWindow^.visible = TRUE) THEN
            fatVis := TRUE;
            theWindow := NIL;
        IF (theWindow <> NIL) THEN
          theWindow := WindowPeek(theWindow)^.nextWindow;
      END; {WHILE}
    END; {HideFatBits}

  BEGIN {HideWindoids}
    {Get visible state of windoids.}
    toolH := EvalExpr(‘visible of tool window’);
    toolVis := StrToBool(toolStr);
    patH := EvalExpr(‘visible of pattern window’);
    patVis := StrToBool(patStr);
    msgH := EvalExpr(‘visible of message window’);
    msgVis := StrToBool(msgStr);
    {Hide the ones that are showing.}
    IF toolVis THEN
      SendHCMessage(‘hide tool window’);
    IF patVis THEN
      SendHCMessage(‘hide pattern window’);
    IF msgVis THEN
      SendHCMessage(‘hide message window’);
  END; {HideWindoids}

  PROCEDURE ShowWindoids;
  {This routine assumes HideWindoids has been called
   before. ShowWindoids restores the visible state of
   the windoids to that saved by HideWindoids.}
    IF toolVis THEN
      SendHCMessage(‘show tool window’);
    IF patVis THEN
      SendHCMessage(‘show pattern window’);
    IF msgVis THEN
      SendHCMessage(‘show message window’);
    {As in HideWindoids, we must take care of the FatBits
     windoid ourselves.}
    IF fatVis THEN
  END; {ShowWindoids}

  PROCEDURE ToggleMenuBar;
  {Set the visible of the menubar to not the visible of
   the menubar.}
    IF MenuBarHeight = 0 THEN
      SendHCMessage(‘show menubar’)
      SendHCMessage(‘hide menubar’);
  END; {ToggleMenuBar}

    {Next month!}
  END; {GetHCBitMap}

  PROCEDURE AdjustCursor;
  {AdjustCursor changes cursorRgn to the region that 
   contains the cursor.  As soon as the cursor moves out of 
   cursorRgn, we get an event and can change the cursor and 
   cursorRgn again. cursorRgn is either the content region 
   of our window or the region containing everything BUT the 
   content region of our window.}
    mousePt:        Point;
    myWinContRect:  Rect;
    myWinContRgn:   RgnHandle;
    deskRgn:        RgnHandle;
    handHdl:        CursHandle;
    myWinContRgn := NewRgn;
    {Calculate the “work region” of our window, which is its
     content region minus the scroll bars and grow icon. 
     This is the region within which we want the cursor to 
     change to HyperCard’s browse tool, and outside of which 
     we want it to be an arrow.}
    WITH WindowPeek(myWindow)^.contRgn^^.rgnBBox DO
                            right - 15,
                            bottom - 15);
    IF PtInRect(mousePt,myWinContRect) THEN
      {The cursor is in the work region of our window. Set
       to browse tool.}
      handHdl := GetCursor(browseTool);
      IF (handHdl <> NIL) THEN
        {Set to arrow if can’t find browse tool resource.}
      {Set the cursor region equal to our window’s work 
      {The cursor is outside our window. Set to arrow.}
      {Get the current desktop region.}
      deskRgn := GetGrayRgn;
      {Set cursorRgn to the desktop region’s bounding box.  
       It is important to add the menu bar area to cursorRgn 
      SetRectRgn(cursorRgn, deskRgn^^.rgnBBox.left,
      {Punch out our window’s content region from the big 
  END; {AdjustCursor}

BEGIN {Main Program}
  {Check the HyperCard version. Must be 1.2 or greater.}
  IF GetHCVersion < ‘1.2’ THEN
    Fail(‘Sorry, must have HyperCard 1.2 or greater.’);
  {Save thy grafPort upon entering!}
  {Check and reset our environment.}
  {Find out what kind of machine we’re running on.}
  envError := SysEnvirons(1,theEnv);
  IF (envError <> noErr) THEN
    Fail(‘SysEnvirons call failed.’);
  {Convert HyperTalk input parameters for use here.}
  wTop := INTEGER(StrToNum(wT));
  wLeft := INTEGER(StrToNum(wL));
  wBottom := INTEGER(StrToNum(wB));
  wRight := INTEGER(StrToNum(wR));
  {If window size parameters are too small or illegal, set
   the window to a predefined minimum size.}
  IF ((wRight - wLeft) < smallestWidth) THEN
    wRight := wLeft + smallestWidth;
  IF ((wBottom - wTop) < smallestHeight) THEN
    wBottom := wTop + smallestHeight;
  {Make sure the user is not trying to draw the window off
   the screen or under the menubar.}

  IF NOT OnAScreen(wRect) THEN
    Fail(‘You are trying to draw your window off the 
  {Get the bounds of the desktop.}
  screenRect := GetGrayRgn^^.rgnBBox;
  {If we have a small screen, make a note of it so we can
   hide the card window during context switches under
  ZeroToPas(EvalExpr(‘item 3 of the screenRect’)^,widthStr);
  screenWidth := INTEGER(StrToNum(widthStr));
  ZeroToPas(EvalExpr(‘item 4 of the screenRect’)^,
  screenHeight := INTEGER(StrToNum(heightStr));
  IF (screenWidth = 512) AND (screenHeight = 342) THEN
    smallScreen := TRUE
    smallScreen := FALSE;
  IF MenuBarHeight > 0 THEN
    menuWasHidden := FALSE
    menuWasHidden := TRUE;
  {This is for scrolling and will be explained next month.}
  theOffScrHandle := OffScrHandle(NewHandle
  IF MemError <> noErr THEN
    Fail(‘Out of memory.  Buy more.’);

  myDocWidth := HCWidth + padding;
  myDocHeight := HCHeight + padding;
  WITH theOffScrHandle^^ DO
    {Next month!}
  {Draw the window!}
  myWindow := NewWindow(@wRecord,wRect,
  IF (myWindow = NIL) THEN
    Fail(‘Not enough memory to draw window.’);
    {This is for scrolling. Stay tuned....}
    theScrollHandle := ScrollHandle(NewHandle
    IF MemError <> noErr THEN
      Fail(‘Out of memory.  Buy more.’);
    {Draw horizontal and vertical scroll bars in our 
    hScroll := CreateHScrollBar(myWindow,0,0,
    vScroll := CreateVScrollBar(myWindow,0,0,
    SetRect(dragRect,screenRect.left + 4,
                     screenRect.right - 4,
                     screenRect.bottom - 4);
    largestHeight := screenRect.bottom -;
    largestWidth := screenRect.right - screenRect.left;
    HCRefresh := ‘Go to this card’;
    cursorRgn := NewRgn;
    inBackGround := FALSE;
    DoneFlag := FALSE;
      {Call WaitNextEvent, if available. Otherwise call
      IF hasWaitNextEvent THEN
        HaveEvent := WaitNextEvent(everyEvent,
        HaveEvent := GetNextEvent(everyEvent,myEvent);
      IF HaveEvent THEN
        IF (myEvent.what = app4Evt) THEN
          {Pre-process app4Evt’s fed to us by MultiFinder.}
          CASE BSR(myEvent.message,24) OF
        myEvent.what := activateEvt;
              {Resume event.}
              IF (BAND(myEvent.message,SuspendEventMask) <> 
              0) THEN
                inBackground := FALSE
                {Suspend event.}
                inBackground := TRUE;
              myEvent.message := LONGINT(myWindow);
            END; {SuspendResumeEvt}
          END; {CASE BSR}
      END; {IF HaveEvent}
      CASE myEvent.what OF
          partCode := FindWindow(myEvent.where,whichWindow);
          IF (whichWindow = myWindow) THEN
            {Deal with mouse hits to our window.}
            CASE partCode OF
                SelectWindow(whichWindow); {DragWindow bug}
                IF StillDown THEN {GrowWindow bug}
                  oldSize := whichWindow^.portRect;
                  newSize := GrowWindow(whichWindow,
                  IF (newSize <> 0) THEN
                  END; {IF newSize}
                END; {IF StillDown}
              END; {inGrow}

                IF (TrackBox(whichWindow,
                             partCode)) THEN
                END; {IF TrackBox}
              END; {inZoomIn,inZoomOut}
                eventPoint := myEvent.where;
                controlCode := FindControl(eventPoint,
                IF (controlCode = inThumb) THEN
                ELSE IF (controlCode <> 0) THEN
                  dummy := TrackControl(whichControl,
              END; {inContent}
                IF (TrackGoAway(whichWindow,myEvent.where)) 
                  DoneFlag := TRUE;
              END; {inGoAway}
            END; {CASE partCode}
          END; {IF whichWindow = myWindow}
        END; {mouseDown}  
          IF (WindowPtr(myEvent.message) = myWindow) THEN
            IF inBackground THEN
              {We’ve been sent behind another application
               under MultiFinder, so deactivate the scroll
               bars and show the menubar if it was hidden.}
              IF smallScreen THEN
              IF MenuBarHeight = 0 THEN
                SendHCMessage(‘show menubar’);
                menuWasHidden := TRUE;
                menuWasHidden := FALSE;
              {We’ve been brought to the front under Multi-
               Finder, so reactivate the scroll bars and
               hide the menubar if it was hidden before.}
              IF menuWasHidden THEN
                SendHCMessage(‘hide menubar’);
            END; {IF inBackground}
          END; {IF WindowPtr}
        END; {activateEvt}
          {Handle updates to our window.}
          IF (WindowPtr(myEvent.message) = myWindow) THEN
            {Always do this stuff}
            {Always do this stuff under single Finder but
             only if in foreground under MultiFinder}
            IF NOT inBackground THEN
            {Always do this stuff}
          END {IF myEvent.message}
          {Handle updates to HyperCard’s card window.}
          ELSE IF (WindowPtr(myEvent.message) = 
          WindowPtr(HCPort)) THEN
            {Must zero out card window’s update region
             ourselves because the SendHCMessage call
             doesn’t do it, and we’ll wind up in an
             infinite loop if we don’t.}

          END; {IF... ELSE}
        END; {updateEvt}
          IF (BitAnd(myEvent.modifiers,cmdKey) <> 0) THEN
            charCode := BitAnd(myEvent.message,
            {Pressing command-spacebar toggles the menubar.}
            IF (CHR(charCode) = ‘ ‘) THEN
            {Pressing command-W closes the window and exits
             the XCMD.}
            IF (CHR(charCode) = ‘w’) THEN
              DoneFlag := True;
      END; {CASE myEvent.what}
    UNTIL (DoneFlag = True);
    {Clean up and get outta here!}
    {Restore thy grafPort}
  END; {IF myWindow...ELSE}
END; {Main}
END. {Window}


Community Search:
MacTech Search:

Software Updates via MacUpdate

Logic Pro X 10.3 - Music creation and au...
Logic Pro X is the most advanced version of Logic ever. Sophisticated new tools for professional songwriting, editing, and mixing are built around a modern interface that's designed to get creative... Read more
iMazing 2.1.8 - Complete iOS device mana...
iMazing (was DiskAid) is the ultimate iOS device manager with capabilities far beyond what iTunes offers. With iMazing and your iOS device (iPhone, iPad, or iPod), you can: Copy music to and from... Read more
Civilization VI 1.0.2 - Next iteration o...
Sid Meier’s Civilization VI is the next entry in the popular Civilization franchise. Originally created by legendary game designer Sid Meier, Civilization is a strategy game in which you attempt to... Read more
TurboTax 2016 - Manage your 2016 U.S. ta...
TurboTax guides you through your tax return step by step, does all the calculations, and checks your return for errors and overlooked deductions. It lets you file your return electronically to get... Read more
Microsoft Office 2016 15.30 - Popular pr...
Microsoft Office 2016 - Unmistakably Office, designed for Mac. The new versions of Word, Excel, PowerPoint, Outlook and OneNote provide the best of both worlds for Mac users - the familiar Office... Read more
FotoMagico 5.3 - Powerful slideshow crea...
FotoMagico lets you create professional slideshows from your photos and music with just a few, simple mouse clicks. It sports a very clean and intuitive yet powerful user interface. High image... Read more
Acorn 5.6.1 - Bitmap image editor.
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
Dash 3.4.3 - Instant search and offline...
Dash is an API documentation browser and code snippet manager. Dash helps you store snippets of code, as well as instantly search and browse documentation for almost any API you might use (for a full... Read more
Microsoft Remote Desktop 8.0.37 - Connec...
With Microsoft Remote Desktop, you can connect to a remote PC and your work resources from almost anywhere. Experience the power of Windows with RemoteFX in a Remote Desktop client designed to help... Read more
Macs Fan Control - Monitor and c...
Macs Fan Control allows you to monitor and control almost any aspect of your computer's fans, with support for controlling fan speed, temperature sensors pane, menu-bar icon, and autostart with... Read more

Turbo League Guide: How to tame the cont...
| Read more »
Fire Emblem: Heroes coming to Google Pla...
Nintendo gave us our first look at Fire Emblem: Heroes, the upcoming mobile Fire Emblem game the company hinted at last year. Revealed at the Fire Emblem Direct event held today, the game will condense the series' tactical RPG combat into bite-... | Read more »
ReSlice (Music)
ReSlice 1.0 Device: iOS Universal Category: Music Price: $9.99, Version: 1.0 (iTunes) Description: Audio Slice Machine Slice your audio samples with ReSlice and create flexible musical atoms which can be triggered by MIDI notes or... | Read more »
Stickman Surfer rides in with the tide t...
Stickson is back and this time he's taken up yet another extreme sport - surfing. Stickman Surfer is out this Thursday on both iOS and Android, so if you've been following the other Stickman adventures, you might be interested in picking this one... | Read more »
Z-Exemplar (Games)
Z-Exemplar 1.4 Device: iOS Universal Category: Games Price: $3.99, Version: 1.4 (iTunes) Description: | Read more »
5 dastardly difficult roguelikes like th...
Edmund McMillen's popular roguelike creation The Binding of Isaac: Rebirth has finally crawled onto mobile devices. It's a grotesque dual-stick shooter that tosses you into an endless, procedurally generated basement as you, the pitiable Isaac,... | Read more »
Last week on PocketGamer
Welcome to a weekly feature looking back on the past seven days of coverage on our sister website, PocketGamer. It’s taken a while for 2017 to really get going, at least when it comes to the world of portable gaming. Thank goodness, then, for... | Read more »
ROME: Total War - Barbarian Invasion set...
To the delight of mobile strategy fans, Feral Interactive released ROME: Total War just a few months ago. Now the game's expansion, Barbarian Invasion is marching onto iPads as a standalone release. [Read more] | Read more »
Yuri (Games)
Yuri 1.0 Device: iOS iPhone Category: Games Price: $3.99, Version: 1.0 (iTunes) Description: It's night. Yuri opens his eyes. He wakes up in a strange forest.The small, courageous explorer rides on his bed on casters in this... | Read more »
Space schmup Xenoraid launches on the Ap...
10Tons Xenoraid is out today on the App Store, bringing some high-speed space action to your mobile gadgets just in time for the weekend. The company's last premium title, another sci-fi game titled Neon Chrome, did quite well for itself, so... | Read more »

Price Scanner via

Laptop Market – Flight To Quality? – The ‘Boo...
Preliminary quarterly PC shipments data released by Gartner Inc. last week reveal an interesting disparity between sales performance of major name PC vendors as opposed to that of less well-known... Read more
IBM and Bell Transform Canadian Enterprise Mo...
IBM and Bell Canada have announced they are joining forces to offer IBM MobileFirst for iOS market-ready enterprise applications for iPad, iPhone or Apple Watch. Bell, Canada’s largest communications... Read more
Otter Products is Closing… For a Day of Givin...
On Thursday, Feb. 9, Otter Products is closing doors to open hearts. In partnership with the OtterCares Foundation, the company is pausing operations for a day so all employees can volunteer with... Read more
15-inch 2.2GHz Retina MacBook Pro on sale for...
Amazon has 2015 15″ 2.2GHz Retina MacBook Pros (MJLQ2LL/A) available for $1799.99 including free shipping. Apple charges $1999 for this model, so Amazon’s price is represents a $200 savings. Read more
Back in stock: Apple refurbished 13-inch Reti...
Apple has Certified Refurbished 2015 13″ Retina MacBook Pros available for up to $360 off original MSRP, starting at $1099. An Apple one-year warranty is included with each model, and shipping is... Read more
CalcTape for macOS 1.2 Adding Machine App for...
schoettler Software has announced CalcTape 1.2, an update to their desktop calculator for macOS. When it comes to adding long columns of numbers, doing complex calculations or playing around with... Read more
New MacBooks And MacBook Pros WIth Kaby Lake...
Digitimes’ Joseph Tsai cites a Chinese-language Economic Daily News (EDN) report that unnamed market watchers are predicting Apple MacBook shipments to grow 10 percent in 2017, and projecting 15... Read more
New 2016 13-inch MacBook Pros on sale for up...
B&H Photo has the new 2016 13″ MacBook Pros in stock today and on sale for up to $150 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 13″ 2.9GHz/512GB Touch Bar MacBook Pro... Read more
New 15-inch Touch Bar MacBook Pros in stock a...
B&H Photo has the new 2016 15″ Apple Touch Bar MacBook Pros in stock today and on sale for up to $150 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.7GHz Touch Bar... Read more
Opera Announces Neon Concept Browser For Mac
Opera is inviting users to get a glimpse of what Opera for computers could become with its Opera Neon browser concept. Each Opera Neon feature is described as “an alternate reality” for the Opera... Read more

Jobs Board

*Apple* Retail - Multiple Positions (Multi-L...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* & PC Desktop Support Technician...
Apple & PC Desktop Support Technician job in Stamford, CT We have immediate job openings for several Desktop Support Technicians with one of our most well-known Read more
*Apple* macOS Systems Integration Administra...
…most exceptional support available in the industry. SCI is seeking an Junior Apple macOS systems integration administrator that will be responsible for providing Read more
*Apple* Premier Retailer - Service Technicia...
DescriptionSimply Mac is the largest premier retailer for Apple products and solutions. At Simply Mac we are all Apple , all the time. Same products. Same prices. Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.