TweetFollow Us on Twitter

Scroll Bar CDEF
Volume Number:5
Issue Number:11
Column Tag:C Workshop

Related Info: Control Manager

Alternate Scroll Bar CDEF

By Alexander S. Colwell, Redondo Beach, CA

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

Introduction

Why another CDEF? MacTutor already have several articles relating to the CDEF. Especially relating to is the excellent Designer CDEFs article in April 1989 issue. Having read every single MacTutor issue, I’ve never seen a scroll bar CDEF article containing sample code!

I wanted a scroll bar that has two up and down arrow buttons on both ends of the scroll bar as shown in Figure 1, rather than standard single arrow buttons scroll bar. My primary reason for a dual arrow buttons scroll bar is for large 19-inch screen monitors. I find it’s a real pain to perform simple scrolling function whenever your window is fully zoomed-out. I must pick-up the mouse several times to get the mouse cursor position over the scroll bar’s arrow buttons. Or, I need a large uncluttered desk to navigate the mouse cursor over the scroll bar. Anyway, enough excuses!

Figure 1. CDEF Definition

The scroll bar control definition comprises two sections: control’s messages and control’s color. The messages are described in Inside Macintosh Volume I in Control Manager chapter. I found I had to read the CDEF description in the Control Manager chapter several times before I fully understood it’s implications on certain issues relating to message relationships with the ROM routines. The control’s color is described in the Inside Macintosh Volume V in Control Manager chapter. ( I only had to read this chapter a couple of times relating to the CDEF’s color controls. Either I am getting better or the ROM documentation is getting better. I’m more likely inclined to believe the latter ).

Each of the control messages are described relating to the scroll bar definition. I will not reiterate the same description found in the Control Manager chapter, but I will attempt to describe how the scroll bar definition is related to each of the control messages.

Scroll Bar Layout

Figure 2 shows how the alternate scroll bar layout would appear in the user’s application or desk accessory. This is similar to the Control Manager chapter in Inside Macintosh Volume I description of the standard scroll bar’s parts. The functionality between the standard scroll bar and this alternate scroll bar is identical. The only differences are the appearance of the “up arrow” and “down arrow” control parts.

Figure 2. Entry Point

/* 1 */

pascal long main(varCode, theControl, message, param)
short varCode;   /* Variation ctrl code */
ControlHandle theControl; /* Ctrl hdl */
short message;   /* Ctrl message code   */
long  param;/* Ctrl parameter code */

The scroll bar entry point receives four arguments : varCode, theControl, message, and param. This scroll bar definition does not have any variation. Therefore the varCode argument is nevered used. The “simple button”, “check box”, and “radio button” controls are examples of the variation control code usage.

The theControl variable is the scroll bar’s control handle. This is where the definition keeps all its necessary data structures for various control’s operations.

The message argument informs the scroll bar to perform the necessary control operations. This definition will use all the control messages except autoTrack control message. Each message will be fully described in the following sections.

The param argument is extra information passed with the associated control message. The scroll bar definition code is type-casted the param’s value before using it. For example, the testCntl control message’s param value is “Point” data type while the calcCRgns control message’s param value is “RgnHandle” data type. The usage of the param’s value is described in each of the control message that is used by this scroll bar definition.

drawCntl

The drawCntl control message comprises the largest chunk of code and the most complex portion of the scroll bar definition. The different parts of the scroll bar to be drawn depends on several combination of the CDEF’s param, and ControlRecord’s contrlVis, contrlValue/contrlMin/contrlMax, and contrlHilite variables.

The CDEF’s param variable contains different values for different parts of the scroll bar operations. Note: The param value is type-casted as long word. The actual value is 16-bit low word quantity. This is not clear in the Inside Macintosh I Control Manager chapter but is explained in the Technical Note #196. Each param is described in the following:

param = 0: This indicates that the scroll bar should be completely re-drawned during window’s update or control’s transition from an invisible to visible state.

param = 0xff: This indicates that the scroll bar should transition into unhighlited state. The scroll bar’s “page up” and “page down” and “thumb” parts should be removed from the scroll bar.

param = inPageUp: This indicates that the “page up” region should be re-drawned.

param = inPageDown: This indicates that the “page down” region should be re-drawned.

param = inUpButton: This indicates that the either upper or lower “up arrow” should be highlited or unhighlited. If the contrlHilite value is equal to zero then the “up arrow” should be unhighlited. Otherwise, if the contrlHilite value is equal to non-zero, and if the contrlMin and contrlMax values are not the same value, then it should highlite the “up arrow” button. Note: The altButton variable in the CDEF is used to determined if using the upper or lower arrows for highliting or unhighliting purposes.

param = inDownButton: This indicates that the either upper or lower “down arrow” should be highlited or unhighlited. The highliting rules are the same as the param’s inUpButton case.

testCntl

The testCntl message should check if the scroll bar control is currently visible then it checks if the mouse is within the control’s contrlRect rectangle area by comparing the mouse location specified by the param’s “Point” value.

If the mouse location is within the control’s rectangle area then DSTestControl function is invoked to compare the mouse location with the different parts of the scroll bar : inPageUp, inPageDown, inThumb, both inUpButtons, and both inDownbuttons. If a matching control part is found then it will return the scroll bar’s control part. Otherwise, zero is returned indicating no scroll bar’s part was found. Note: Again, the altButtonvariable is set depending on which of the upper and lower arrow buttons selected for highliting and unhighliting purposes.

calcCRgns

The calcCRgns control message should return the specified scroll bar part’s region. The param’s “RgnHandle” value contains a region handle to be reset to the scroll bar part’s region. However, there are only two cases this control message is invoked.

First case, the whole scroll bar region indicated by the high-order bit of param is set. Note: The param region’s high-order bit should be cleared before operating on the region handle. Otherwise, the CDEF runs a risk of ALA BOMBA country. Technically speaking, the param value should not have high-order bit set in the region handle due to 32-bit mode addressing future implementation. But according to Technical Note #212 the solution for this particular problem is to separate the two cases into calcCntlRgn and calcThumbRgn control messages equivalent to this message for System 7.0 and henceforth versions in 32-bit mode addressing.

The second case is the “thumb” scroll bar part request by TrackControl ROM function. The TrackControl ROM function will invoke the calcCRgns message for the “thumb” outline area to be passed onto the DragGrayRgn ROM function for dragging the “thumb” part of the scroll bar. One extra thing this message should do is set the drag region’s pattern used by the DragGrayRgn routine. I set ltGray pattern into the global DragPattern variable. This is the same pattern used to fill-in the inPageUp and inPageDown control parts.

calcCntlRgn

The calcCntlRgn control message is equivalent to the calcCRgns’s first case.

calcThumbRgn

The calcThumbRgn control message is equivalent to the calcCRgns’s second case.

initCntl

The initCntl control message is where any necessary initialization required by the scroll bar control. Typically, the control definition will allocate one or more data structures to be used during the course of the control’s operations.

This scroll bar will allocate DS handle to be used for the scroll bar’s operation saved into the contrlData variable of the ControlRecord. During the initialization, the black and light gray pattern are initialized. The light gray pattern is used in the “upPage” and “downPage” regions of the scroll bar, and for the “thumb” drag region area. The DS’s hasColor variable is initialized indicating if the monitor has color by using the SysEnvirons’s hasColorQD variable. The scroll bar definition uses this variable to determine if will need to perform color drawing of the scroll bar parts. Finally, the contrlAction variable is initialized to -1L for the TrackControl’s actionProc parameter “thumb” tracking.

The DSInitControl routine will be invoked to initialized the DS data structure. It’s primary job is to compute the size of the “thumb” rectangle area and create the polygon handle equivalent to the “up arrow” and “down arrow” buttons.

dispCntl

The dispCntl control message informs the scroll bar control to release all it’s internal data structures within the controlData handle. This scroll bar will release the polygon handles and the DS handle to the memory manager.

posCntl

The postCntl control message informs the scroll bar definition to re-compute the new “thumb” position and re-draw the scroll bar with the new “thumb” position. The param’s “Point” value contains the local-coordinates point position within the scroll bar’s contrlRect rectangle area. The scroll bar definition will look at the h part of the point for horizontal scroll bar, and use v part of the point for vertical scroll bar orientation.

thumbCntl

The thumbCntl control message informs the scroll bar definition to compute the “thumb” dragging rectangle area. The param value contains a pointer to a data structure described in DragGrayRgn in Window Manager chapter. Its will briefly describe it here:

/* 2 */

struct {         /* Dragging region*/
 Rect limitRect; /* Limit rect scrl*/
 Rect slopRect;  /* Slop rect scrl */
 short axis;     /* Draw axis ctrl */
};

The scroll bar definition will set the axis variable to hAxisOnly constant for horizontal scroll bar or vAxisOnly constant for vertical scroll bar. The limitRect variable is the rectangle area comprising the “upPage” and “downPage” rectangle areas. And, the slopRect variable is the slop area allowed for the mouse to move outside the limit rectangle area.

The slopRect rectangle area require special calculation base on the current mouse position within the “thumb”. Before setting up the limit rectangle area, the limitRect.left and limitRect.top contain the current mouse position. This is saved into temporary mouse point variable to be used in the slop rectangle area calculation. The problem is that the slop rectangle area cannot be the same as the limit rectangle area. Or else, the “thumb” dragging outline will go over the “up arrow” and “down arrow” regions. Hence, the slop rectangle area must be adjusted where the mouse position within the “thumb” rectangle area.

dragCntl

The dragCntl control message informs the scroll bar that the control or the “thumb” is going to be dragged since, the scroll bar has no custom dragging requirements. It returns zero value to inform the Control Manager to use the default dragging method.

autoTrack

The autoTrack control message is not used by the scroll bar definition. Since the initCntl control message initializes the ControlRecord’s contrlAction to -1L value. This will cause the TrackControl call the default control tracking mechanism. Since the dragCntl message always return zero value this control message is never invoked. Note: I had always been confused on the purpose of the dragCntl and autoTrack control message combinations. Perhaps, someone could explain this in Apple’s Technical Note series someday.

Color descriptions

The scroll bar CDEF uses the GetAuxCtl ROM routine to determine how to color different parts of the scroll bar. The CDEF uses four different RGB colors for the control’s frame, body, text, and thumb parts.

The control’s frame color is the outline parts of the scroll bar, arrows, up & down page regions, and thumb. The control’s body color is the inside parts of the arrows, and up & down page regions. The control’s thumb color is the inside part of the thumb. The text color is not used in this scroll bar definition. Note: Standard control buttons uses the control’s text color value.

Accessing the scroll bar’s colors is very easy. The GetAuxCtl ROM call is used to retrieve the scroll bar’s colors. The calling proto-type definition is as follows:

Boolean
  GetAuxCtl(ControlHandle theControl,
       AuxCtlHndl &acHndl);

The function will return TRUE indicator if the scroll bar’s theControl control handle has it’s own copy of the color data set. Otherwise, FALSE indicates the scroll bar using default color data set. The acHndl auxiliary control handle will return the scroll bar’s color data set. To access the frame, body, and thumb RGB colors are shown in the following:

/* 3 */

(*(*acHndl)->acCTable)->
                ctTable[cFrameColor].rgb

(*(*acHndl)->acCTable)->
                ctTable[cBodyColor].rgb

(*(*acHndl)->acCTable)->
                ctTable[cThumbColor].rgb

I recommend reading Inside Macintosh V’s Control Manager chapter on more details relating to the control’s color displays. There are two main color routines relating to the controls : GetAuxCtl and SetCtlColor.

Other CDEF Descriptions

The scroll bar definition uses a weird technique handling black & white and color situations. I defined DSDrawObject to draw various control’s part onto the window. This generic routine simplifies the scroll bar definition without worrying if drawing black & white or color. And, the DSDrawObject routine is coupled with series of macro definitions to perform various drawing operations for the scroll bar.

Finally, I used floating-point to perform various calculations to position the “thumb” properly based on the control’s contrlValue, contrlMin, and contrlMax variables. I could have used fix-integer arithmetic, but I was too lazy to bother with it.

Scroll Bar Demonstration

The scroll bar demonstration is a simple text editor application using new THINK C 4.0 Object Library. It’s not great American word processor, but it is used to illustrate the Alternate Scroll Bar CDEF.

Wrapping Things Up

I did not realize how difficult writing a scroll bar definition was until writing this CDEF example. I am not for sure this is a good alternative scroll bar interface, but it was fun writing it. I believe Apple’s Human Interface Guidelines are excellent set of rules to follow. So how does this scroll bar definition fit into their scheme of things? Probably none. However, several of my associates at work want a scroll bar definition that varies the size of the “thumb” relative to how much visible text (or contents) versus hidden text, but I said “It’s almost impossible, since the CDEF does not have enough information to determine how to vary the ‘thumb’ size.”. Anyway, until then onward to other Mac programming!

/*
 *
 *      Source   - Alternate.c
 *      Author   - Alexander S. Colwell,
 *                 Copyright (C) 1989
 *      Purpose  - This application will demostrate the
 *                 AlternateCDEF scroll bar using THINK
 *                 C 4.0 Object Library.
 * 
 */

#include <Global.h>          /* Global variables      */
#include <CApplication.h>    /* Application defs      */
#include <Commands.h>        /* Command handler defs  */
#include <CBartender.h>      /* Menu handler defs     */
#include <CDecorator.h>      /* Window handler defs   */
#include <CDesktop.h>        /* Window layer hdler def*/
#include <CDocument.h>       /* Document handler defs */
#include <CEditText.h>       /* Text edit handler defs*/
#include <CScrollPane.h>     /* Scrolling pane defs   */

struct CAltDemoApp : CApplication {/* Appl object     */
 void    CreateDocument(void);/* Creat new doc method */
 };

struct CAltDemoDoc : CDocument {/* Document object    */
 void    NewFile(void);      /* Net (bogus) fil method*/
 };

struct CAltDemoPane : CEditText {/* Text pane obj     */
 void    IEditPane(CView *anEnclosure,
                   CBureaucrat *aSupervisor);
 };

#define altWIND 500          /* WIND template res ID  */

                             /* Define external refs  */
extern  CApplication *gApplication;/* Appl object     */
extern  CDecorator   *gDecorator;/* Window object     */
extern  CDesktop     *gDesktop;  /* Desktop object    */
extern  CBartender   *gBartender;/* Menu object       */

void main()
 {
  gApplication = new(CAltDemoApp);/* Creat appln object*/
  gApplication->IApplication(4,4096L,2048L);/* Init it */
  gApplication->Run();       /* Startup application    */
  gApplication->Exit();      /* Return to da “Finder”  */
 }

void CAltDemoApp::CreateDocument()
 {
  CAltDemoDoc *theDocument;  /* New document obj      */

  theDocument = new(CAltDemoDoc);/* Create doc object */
  theDocument->IDocument(this,FALSE);/* Init doc obj  */
  theDocument->NewFile();    /* Create (bogus) doc    */
 }

void CAltDemoDoc::NewFile(void)
 {
  CScrollPane  *theScrollPane;/* Scroll pane object   */
  CAltDemoPane *theMainPane; /* Main pane object      */

  itsWindow = new(CWindow); /* Create window object   */
  itsWindow->IWindow(altWIND,FALSE,gDesktop,this);

                            /* Create scrolling object*/
  theScrollPane = new(CScrollPane);
  theScrollPane->IScrollPane(itsWindow,this,10,10,0,0,
              sizELASTIC,sizELASTIC, TRUE,TRUE,TRUE);
  theScrollPane->FitToEnclFrame(TRUE, TRUE);
  theMainPane = new(CAltDemoPane);
  itsMainPane = theMainPane;
  itsGopher = theMainPane;
  theMainPane->IEditPane(theScrollPane,this);
   theScrollPane->InstallPanorama(theMainPane);

  itsWindow->Select();       /* Select our window now!*/
 }

void CAltDemoPane::IEditPane(CView *anEnclosure,
                             CBureaucrat *aSupervisor)
 {
  Rect    margin;            /* Margin rect area      */

                             /* Setup text edit stuff */
  CEditText::IEditText(anEnclosure,aSupervisor,1,1,0,0,
                       sizELASTIC,sizELASTIC,432);
  FitToEnclosure(TRUE,TRUE);
  SetRect(&margin,2,2,-2,-2);
  ChangeSize(&margin,FALSE);
 }

/*
 *
 *     Source  - AlternateCDEF.c
 *     Author  - Alexander S. Colwell,
 *               Copyright (C) 1988, 1989
 *     Purpose - This is a dual-arrow scroll bar control
 *               definition procedure. It is similiar to
 *               the standard scroll bar except this has
 *               two arrow indicators on both ends.
 */

#include <QuickDraw.h>       /* QuickDraw defs        */
#include <Color.h>           /* Color defs            */
#include <WindowMgr.h>       /* Window Manager defs   */
#include <ControlMgr.h>      /* Control Manager defs  */
#include <ToolBoxUtil.h>     /* Tool Box Utilities    */
#include <ColorToolBox.h>    /* Color Tool Box defs   */

typedef struct {          /* Dual Control          */
   short        hasColor;    /* Has color monitor flag*/
   short        altButton;   /* Using alternate button*/
   Rect         thumb;       /* Thumb rectangle area  */
   Rect         cThumb;      /* Current thmb rect area*/
   PolyHandle   up;          /* Up button handle      */
   PolyHandle   down;        /* Down button handle    */
   short        bLen;        /* Button length         */
   short        hBLen;       /* Half button length    */
   short        sLen;        /* Scroll bar length     */
   double       tFactor;     /* Thumb factor          */
   short        hFactor;     /* Horizontal factor     */
   short        vFactor;     /* Vertical factor       */
   ControlHandle cHdl;       /* Ctrl hdl to reference */
   long         blackPat[2]; /* Black pattern         */
   long         ltGrayPat[2];/* Light gray pattern    */
   } DS;
typedef DS      *DSPTR;
typedef DSPTR   *DSHDL;

typedef struct {         /* Thumb Info            */
   Rect         limitRect;   /* Limit rect scrolling  */
   Rect         slopRect;    /* Slop rect scrolling   */
   short        axis;        /* Drag axis control     */
   } THUMB;
typedef THUMB   *THUMBPTR;
                             /* Misc definitions      */
#define NIL     (0L)         /* NIL pointer           */
#define abs(a)  (a<0?-a:a)   /* Absolute macro func   */
#define min(a,b) (a<b?a:b)   /* Minumim macro function*/
#define max(a,b) (a<b?b:a)   /* Maximum macro function*/

                             /* Trap definitions      */
#define SysEnvironsTrap 0xa090/* System Enviroment    */
#define UnknownTrap     0xa89f/* Unknown instruction  */

                             /* System 7.0 CDEF msgs  */
#define calcCntlRgn  10      /* Calculate ctnl region */
#define calcThumbRgn 11      /* Calculate “thumb” rgn */
                             /* Control’s macro procs */
#define DSFrameHUpBtn()                                \
        DSDrawHBtn(dPtr,dPtr->up,FALSE)
#define DSFrameHDownBtn()                              \
        DSDrawHBtn(dPtr,dPtr->down,FALSE)
#define DSFrameLUpBtn()                                \
        DSDrawLBtn(dPtr,dPtr->up,FALSE)
#define DSFrameLDownBtn()                              \
        DSDrawLBtn(dPtr,dPtr->down,FALSE)
#define DSFillHUpBtn()                                 \
        DSDrawHBtn(dPtr,dPtr->up,TRUE)
#define DSFillHDownBtn()                               \
        DSDrawHBtn(dPtr,dPtr->down,TRUE)
#define DSFillLUpBtn()                                 \
        DSDrawLBtn(dPtr,dPtr->up,TRUE)
#define DSFillLDownBtn()                               \
        DSDrawLBtn(dPtr,dPtr->down,TRUE)

#define DSFrameBody(a)                                 \
        DSDrawObject(dPtr->cHdl,DSGetForeGround,       \
                     DSSetForeGround,DSFrameRect,      \
                     cFrameColor,a)
#define DSClearBody(a)                                 \
        DSDrawObject(dPtr->cHdl,DSGetBackGround,       \
                     DSSetBackGround,DSEraseRect,      \
                     cBodyColor,a)
#define DSFillBody(a)                                  \
        DSDrawObject(dPtr->cHdl,DSGetBackGround,       \
        DSSetBackGround,DSFillRect,cBodyColor,a,       \
        dPtr->ltGrayPat)
#define DSFrameThumb(a)                                \
        DSDrawObject(dPtr->cHdl,DSGetForeGround,       \
                     DSSetForeGround,DSFrameRect,      \
                     cFrameColor,a)
#define DSFillThumb(a)                                 \
        DSDrawObject(dPtr->cHdl,DSGetBackGround,       \
                     DSSetBackGround,DSEraseRect,      \
                     cThumbColor,a)
#define DSFrameArrow(a)                                \
        DSDrawObject(dPtr->cHdl,DSGetForeGround,       \
                     DSSetForeGround,DSFramePoly,      \
                     cFrameColor,a)
#define DSClearArrow(a)                                \
        DSDrawObject(dPtr->cHdl,DSGetBackGround,       \
                     DSSetBackGround,DSErasePoly,      \
                     cBodyColor,a)
#define DSFillArrow(a)                                 \
        DSDrawObject(dPtr->cHdl,DSGetForeGround,       \
                     DSSetForeGround,DSFillPoly,       \
                     cFrameColor,a,dPtr->blackPat)
                             /* Define forward refs   */
void    DSInitControl(),DSDrawThumb(),DSPositionThumb(),
        DSSetupThumb(),DSDrawHBtn(),DSDrawLBtn(),
        DSGetBackGround(),DSGetForeGround(),
        DSSetBackGround(),DSSetForeGround(),
        DSFrameButtons(),DSEraseRect(),DSFrameRect(),
        DSFillRect(),DSErasePoly(),DSFramePoly(),
        DSFillPoly(),DSDrawObject();
long    DSTestControl();

pascal long     main(varCode,theControl,message,param)
 short         varCode;      /* Variable control code */
 ControlHandle theControl;   /* Control handle        */
 short         message;      /* Control message       */
 long          param;        /* Control parameter     */
 {
  ControlPtr   cPtr;         /* Working control ptr   */
  DSHDL        dHdl;         /* Working dual ctrl hdl */
  DSPTR        dPtr = NIL;   /* Working dual ctrl ptr */
  Rect         wRect;        /* Working scroll area   */
  SysEnvRec    sysEnv;       /* Working system envt   */
  long         status = 0;   /* Working status flag   */
      
  HLock(theControl);         /* Lock down the ctrl hdl*/
  cPtr = *theControl;        /* Set control pointer   */
  if (message != initCntl) { /* Check if already init */
   if (cPtr->contrlData) {   /* Check if valid handle */
    HLock(cPtr->contrlData); /* Lock it down for work */
    dPtr = *((DSHDL)cPtr->contrlData);/* Set dual ptr */
   }
  }
  switch(message) {          /* Process specified msg */
   case drawCntl:            /* Draw the control      */
    if (dPtr) {              /* Check if it’s valid   */
     if (cPtr->contrlVis) {  /* Check if it’s visible */
      PenNormal();           /* Set to normal pen     */
      switch(LoWord(param)) {/* Switch on control part*/
       case 0:               /* Re-draw scroll bar    */
        DSInitControl(dPtr,cPtr);/* Re-init it        */
        DSFrameBody(&cPtr->contrlRect);/* Init scroll */
        DSFrameButtons(dPtr);/* Frame the buttons     */
        DSFrameHUpBtn();
        DSFrameHDownBtn();
        DSFrameLUpBtn();
        DSFrameLDownBtn();
        DSDrawThumb(dPtr,theControl); break;
       case 129:             /* Value/Min/Max changed */
        DSDrawThumb(dPtr,theControl); break;
       case 0xff:            /* Control to be inactive*/
        DSSetScrollRgn(dPtr,&wRect);
        DSClearBody(&wRect); break;
       case inPageUp:        /* Hilite scroll bar     */
       case inPageDown:
        DSDrawThumb(dPtr,theControl); break;
       case inUpButton:      /* Hilite high up button */
        if (dPtr->altButton) {/* Check if alt button  */
         if (cPtr->contrlHilite == 0 ||
             cPtr->contrlMin == cPtr->contrlMax)
          DSFrameLUpBtn();
         else
          DSFillLUpBtn();
        }
        else {
         if (cPtr->contrlHilite == 0 ||
             cPtr->contrlMin == cPtr->contrlMax)
          DSFrameHUpBtn();
         else
          DSFillHUpBtn();
        }
        break;
       case inDownButton:    /* Hilite high down buttn*/
        if (dPtr->altButton) {/* Check if alt button  */
         if (cPtr->contrlHilite == 0 ||
             cPtr->contrlMin == cPtr->contrlMax)
          DSFrameLDownBtn();
         else
          DSFillLDownBtn();
        }
        else {
         if (cPtr->contrlHilite == 0 ||
             cPtr->contrlMin == cPtr->contrlMax)
          DSFrameHDownBtn();
         else
          DSFillHDownBtn();
        }
      }
     }
    }
    break;
   case testCntl:            /* Test the control      */
    if (dPtr)                /* Check if ptr valid    */
     if (cPtr->contrlHilite != -1)/* Check if active  */
      if (cPtr->contrlMin != cPtr->contrlMax)
       if (PtInRect(param,&cPtr->contrlRect))
        status = DSTestControl(dPtr,param);/* Find it */
    break;
   case calcCRgns:           /* Calculate ctrl region */
    if (dPtr) {              /* Check if pointer valid*/
     if (!(param & 0x80000000L))/* Check if whole ctrl*/
      RectRgn((Handle)(param & 0x7fffffffL),
              &cPtr->contrlRect);
     else {                  /* Want thumb’s region   */
                             /* Setup thumb’s area    */
      RectRgn((Handle)(param & 0x7fffffffL),
              &dPtr->cThumb);
                             /* Setup drag pattern    */
      BlockMove(dPtr->ltGrayPat,DragPattern,8L);
     }
    }
    break;
   case calcCntlRgn:         /* Calculate cntl region */
    if (dPtr)                /* Check if ptr valid    */
     RectRgn((Handle)(param),&cPtr->contrlRect);
     break;
   case calcThumbRgn:        /* Calculate “thumb” rgn */
    if (dPtr) {              /* Check if pointer valid*/
                             /* Setup thumb’s region  */
     RectRgn((Handle)(param),&dPtr->cThumb);
                             /* Setup drag pattern    */
     BlockMove(dPtr->ltGrayPat,DragPattern,8L);
    }
    break;
   case initCntl:            /* Initialized control   */
                             /* Allocate data handle  */
    if (dHdl = (DSHDL)NewHandle(sizeof(DS))) {
     HLock(dHdl);            /* Lock it down for init */
     dPtr = *dHdl;           /* Set dual control ptr  */
     dPtr->cHdl = theControl;/* Save it for reference */
     dPtr->up = dPtr->down = NIL;/* Init poly handles */
     dPtr->blackPat[0] = 0xffffffffL;/* Init patterns */
     dPtr->blackPat[1] = 0xffffffffL;
     dPtr->ltGrayPat[0] = 0x88228822L;
     dPtr->ltGrayPat[1] = 0x88228822L;
     dPtr->hasColor = FALSE; /* Set to black & white  */
     dPtr->altButton = FALSE;/* Not using alt button  */
                             /* Check SysEnvirons OK  */
     if ((long)NGetTrapAddress(SysEnvironsTrap,OSTrap)!=
         (long)NGetTrapAddress(UnknownTrap,ToolTrap)) {
      SysEnvirons(1,&sysEnv);/* Get system enviroment */
      dPtr->hasColor = sysEnv.hasColorQD;/* Save color*/
     }
     DSInitControl(dPtr,cPtr);/* Init control’s stuff */
     cPtr->contrlAction = (ProcPtr)(-1L);
     cPtr->contrlData = (Handle)dHdl;/* Save data hdl */
    }
    break;
   case dispCntl:            /* Dispose the control   */
    if (dPtr) {              /* Check if pointer valid*/
     if (dPtr->up)           /* Kill the polys        */
      KillPoly(dPtr->up);
     if (dPtr->down)
      KillPoly(dPtr->down);
     HUnlock(cPtr->contrlData);/* Unlock it now       */
     DisposHandle(cPtr->contrlData);/* Return it      */
    }
    cPtr->contrlData = NIL;  /* Clear it              */
    break;
   case posCntl:             /* Re-position control   */
    if (dPtr)                /* Check if pointer valid*/
     DSPositionThumb(dPtr,theControl,param);
    break;
   case thumbCntl:           /* Calculate for dragging*/
    if (dPtr)                /* Check if pointer valid*/
     DSSetupThumb(dPtr,param);/* Setup for dragging   */
    break;
   case dragCntl:            /* Drag the control      */
    status = 0;              /* Only drag thumb!      */
    break;
   case autoTrack:           /* Execute ctrl’s action */
    break;
  }
  if (cPtr->contrlData)      /* Check if valid pointer*/
   HUnlock(cPtr->contrlData);/* Unlock for memory mgr */
  HUnlock(theControl);       /* Unlock control handle */
  return(status);            /* Return status code    */
 }

void    DSInitControl(dPtr,cPtr)
 DSPTR        dPtr;          /* Dual control pointer  */
 ControlPtr   cPtr;          /* Control pointer       */
 {
   PolyHandle pHdl;          /* Working poly handle   */
   short      bLen;          /* Working button length */
   short      hBLen;         /* Working 1/2 button len*/
   short      hLen;          /* Working horizontal len*/
   short      vLen;          /* Working vertical len  */
   short      tmp1,tmp2;     /* Working tmp variables */
   Rect       cRect;         /* Working ctrl rect area*/

   cRect = cPtr->contrlRect; /* Set scroll bar area   */
   InsetRect(&cRect,1,1);    /* Shrink it by one-pixel*/
                             /* Set horz & vert lens  */
   hLen = abs(cRect.right - cRect.left) + 1;
   vLen = abs(cRect.bottom - cRect.top) + 1;
   
   if (hLen > vLen) {        /* Check if horz longer  */
    dPtr->bLen = vLen;       /* Set button length     */
    dPtr->sLen = hLen + 1;   /* Set scroll bar length */
    dPtr->hFactor = 1;       /* Set horizontal factor */
    dPtr->vFactor = 0;       /* Set vertical factor   */
   }
   else {                    /* Nope, must be vertical*/
    dPtr->bLen = hLen;       /* Set button length     */
    dPtr->sLen = vLen + 1;   /* Set scroll bar length */
    dPtr->hFactor = 0;       /* Set horizontal factor */
    dPtr->vFactor = 1;       /* Set vertical factor   */
   }
   bLen = dPtr->bLen;        /* Set button length     */
   hBLen = dPtr->hBLen = bLen / 2;/* Set 1/2 buttn len*/
   dPtr->thumb.top = dPtr->thumb.left = 0;/* Init pt  */
   if (dPtr->hFactor) {      /* Check if horz position*/
    dPtr->thumb.bottom = bLen - 1;
    dPtr->thumb.right = hBLen + hBLen / 2;
   }
   else {                    /* Nope, vert position   */
    dPtr->thumb.bottom = hBLen + hBLen / 2;
    dPtr->thumb.right = bLen - 1;
   }
   tmp1 = hBLen - 1;         /* Set tmp calculations  */
   tmp2 = hBLen - 2;
                             /* Create up poly handle */
   if (pHdl = OpenPoly()) {  /* Check if got poly hdl */
    if (dPtr->hFactor) {     /* Check horz position   */
     MoveTo(0,tmp1);
     LineTo(tmp2,tmp2 * 2 + 1);
     LineTo(tmp2,1);
     LineTo(0,tmp1);
    }
    else {                   /* Nope, vert position   */
     MoveTo(tmp1,0);
     LineTo(1,tmp2);
     LineTo(tmp2 * 2 + 1,tmp2);
     LineTo(tmp1,0);
    }
    ClosePoly();             /* Close the poly handle */
   }
   if (dPtr->up)             /* Check if old poly hdl */
    KillPoly(dPtr->up);      /* Release this poly hdl */
   dPtr->up = pHdl;          /* Set up poly handle    */
                             /* Create down poly hdl  */
   if (pHdl = OpenPoly()) {  /* Check if got poly hdl */
    if (dPtr->hFactor) {     /* Check horz position   */
     MoveTo(tmp2,tmp1);
     LineTo(0,tmp2 * 2 + 1);
     LineTo(0,1);
     LineTo(tmp2,tmp1);
     OffsetPoly(pHdl,hBLen,0);
    }
    else {                   /* Nope,  vert position  */
     MoveTo(1,0);
     LineTo(tmp2 * 2 + 1,0);
     LineTo(tmp1,tmp1);
     LineTo(1,0);
     OffsetPoly(pHdl,0,hBLen);
    }
    ClosePoly();             /* Close the poly handle */
   }
   if (dPtr->down)           /* Check if old poly hdl */
    KillPoly(dPtr->down);    /* Release this poly hdl */
   dPtr->down = pHdl;        /* Set down poly handle  */
  }
   
void    DSCalcThumb(dPtr,cPtr)
 DSPTR       dPtr;           /* Dual control pointer  */
 ControlPtr  cPtr;           /* Control pointer       */
 {
   double    tmp1,tmp2;      /* Working tmp registers */
   short     offset;         /* Working pixel offset  */
   Rect      wRect;          /* Working scroll area   */
   
                             /* Make sure this is min */
   cPtr->contrlMin = min(cPtr->contrlMin, cPtr->contrlMax);
      
                             /* Make sure this is max */
   cPtr->contrlMax = max(cPtr->contrlMin, cPtr->contrlMax);
                            
                             /* Make it min<value<max */
   cPtr->contrlValue = min(cPtr->contrlMax,
           max(cPtr->contrlMin, cPtr->contrlValue));
                                  
   DSSetScrollRgn(dPtr,&wRect);/* Set scroll region   */
                             /* Init thumb factor calc*/
   tmp1 = max(abs(wRect.bottom - wRect.top) * dPtr->vFactor,
              abs(wRect.right - wRect.left) * dPtr->hFactor)
                  - dPtr->bLen + dPtr->hBLen - 2;
   tmp2 = abs(cPtr->contrlMax - cPtr->contrlMin);
   
   dPtr->tFactor = tmp1 / tmp2;/* Set relative factor */
   tmp1 = cPtr->contrlValue - /*Set thumb pixel offset*/
          cPtr->contrlMin;
   tmp2 = tmp1 * dPtr->tFactor;
   offset = tmp2;
   dPtr->cThumb = dPtr->thumb;/* Set thumb rect area  */
   OffsetRect(&dPtr->cThumb, wRect.left + offset * dPtr->hFactor, wRect.top 
+ offset * dPtr->vFactor);
  }

void    DSDrawThumb(dPtr,cHdl)
 DSPTR         dPtr;         /* Dual control pointer  */
 ControlHandle cHdl;         /* Control handle        */
 {
  Rect         tRect;        /* Working thumb area    */
  ControlPtr   cPtr = *cHdl; /* Working control ptr   */
     
  DSSetScrollRgn(dPtr,&tRect);/* Set scroll region    */
  if (cPtr->contrlHilite != 255 &&/* Check if show it */
      cPtr->contrlMax != cPtr->contrlMin) {
  DSCalcThumb(dPtr,cPtr);   /* Re-calculate thumb    */
   ForeColor((long)(blackColor));/* Make it’s b & w   */
   BackColor((long)(whiteColor));
   DSFillBody(&tRect);       /* Fill in scroll bar    */
   tRect = dPtr->cThumb;     /* Set thumb rect area   */
   DSFrameThumb(&tRect);     /* Frame thumb           */
   InsetRect(&tRect,1,1);    /* Inset by one pixel    */
   DSFillThumb(&tRect);      /* Clear inside of thumb */
  }
  else                       /* Nope, don’t want it   */
   DSClearBody(&tRect);      /* Clr scroll region     */
 }
   
void    DSPositionThumb(dPtr,cHdl,pt)
 DSPTR         dPtr;         /* Dual control pointer  */
 ControlHandle cHdl;         /* Control handle        */
 Point         pt;           /* Pt position of thumb  */
 {
  double       offset;       /* Working value offset  */

  if (dPtr->hFactor)         /* Check if horizontal   */
   offset = pt.h;            /* Use horizontal offset */
  else                       /* Nope, it’s vertical   */
   offset = pt.v;            /* Use vertical offset   */
  offset = offset / dPtr->tFactor;/* Reset ctrl value */
  (*cHdl)->contrlValue += offset;
  DSDrawThumb(dPtr,cHdl);    /* Draw da thumb, again! */
 }
   
void    DSSetupThumb(dPtr,thumbPtr)
 DSPTR    dPtr;              /* Dual control pointer  */
 THUMBPTR thumbPtr;          /* Thumb’s info pointer  */
 {
  Point   msePt;             /* Working mouse point   */
      
  msePt.h = thumbPtr->limitRect.left;/* Save mse down */
  msePt.v = thumbPtr->limitRect.top;
  DSSetScrollRgn(dPtr,&thumbPtr->limitRect);/*Set limt*/
  if (dPtr->hFactor) {       /* Check if horz scroll  */
                             /* Adjust it for mse     */
   thumbPtr->limitRect.left += msePt.h - dPtr->cThumb.left;
thumbPtr->limitRect.right -= dPtr->cThumb.right - msePt.h - 1;
                             /* Set slop rect area    */
   thumbPtr->slopRect.top = thumbPtr->limitRect.top - 16;
   thumbPtr->slopRect.bottom = thumbPtr->limitRect.bottom + 16;
   thumbPtr->slopRect.left = -32000;
   thumbPtr->slopRect.right = 32000;
   thumbPtr->axis = hAxisOnly;/* Set axis dragging dir*/
  }
  else {                     /* Nope,  vert scroll bar*/
                             /* Adjust it for mse     */
   thumbPtr->limitRect.top += msePt.v - dPtr->cThumb.top;
  thumbPtr->limitRect.bottom -= dPtr->cThumb.bottom - msePt.v - 1;
                             /* Set slop rect area    */
   thumbPtr->slopRect.left = thumbPtr->limitRect.left - 16;
   thumbPtr->slopRect.right = thumbPtr->limitRect.right + 16;
   thumbPtr->slopRect.top = -32000;
   thumbPtr->slopRect.bottom = 32000;
   thumbPtr->axis = vAxisOnly;/* Set axis dragging dir*/
  }
 }
   
void    DSDrawHBtn(dPtr,btn,fill)

 DSPTR       dPtr;           /* Dual control pointer  */
 PolyHandle  btn;            /* Poly button handle    */
 short       fill;           /* Fill flag indicator   */
   
 {
                             /* Offset where button   */
  OffsetPoly(btn,(*dPtr->cHdl)->contrlRect.left + 1,
                 (*dPtr->cHdl)->contrlRect.top + 1);
  if (fill)                  /* Check if filling arrow*/
   DSFillArrow(btn);         /* Fill in arrow button  */
  else                       /* Nope, not clearing it */
   DSClearArrow(btn);        /* Clear the arrow button*/
  DSFrameArrow(btn);         /* Frame the arrow button*/
                             /* Restore the button    */
  OffsetPoly(btn,-(*dPtr->cHdl)->contrlRect.left - 1,
                 -(*dPtr->cHdl)->contrlRect.top - 1);
 }

void    DSDrawLBtn(dPtr,btn,fill)
 DSPTR       dPtr;           /* Dual control pointer  */
 PolyHandle  btn;            /* Poly button handle    */
 short       fill;           /* Fill flag indicator   */
 {
  short    tmp1,tmp2;        /* Working tmp variables */
  short    offset;           /* Working offset        */
      
  offset = dPtr->sLen - dPtr->bLen - 1;/* Set offset  */
                             /* Offset where button   */
  OffsetPoly(btn,tmp1 = (*dPtr->cHdl)->contrlRect.left + 
       dPtr->hFactor * offset + 1,tmp2 = (*dPtr->cHdl)->contrlRect.top 
+ dPtr->vFactor * offset + 1);
  if (fill)                 /* Check if filling arrow */
   DSFillArrow(btn);        /* Fill in arrow button   */
  else                      /* Nope, not clearing it  */
   DSClearArrow(btn);       /* Clear the arrow button */
  DSFrameArrow(btn);        /* Frame the arrow button */
  OffsetPoly(btn,-tmp1,-tmp2);/* Restore the button   */
 }

void    DSFrameButtons(dPtr)
 DSPTR       dPtr;           /* Dual control pointer  */
 {
  Rect       bRect;          /* Working box rect area */
  short      offset;         /* Working low button    */
      
  bRect.left = bRect.top = 0;/* Setup rect area       */
  bRect.right = bRect.bottom = dPtr->bLen + 1;
                             /* Offset high button box*/
  OffsetRect(&bRect,(*dPtr->cHdl)->contrlRect.left,
                    (*dPtr->cHdl)->contrlRect.top);
  DSClearBody(&bRect);       /* Clear the body part   */
  DSFrameBody(&bRect);       /* Frame high button box */
                             /* Set low button offset */
  offset = dPtr->sLen - dPtr->bLen - 1;
  OffsetRect(&bRect,dPtr->hFactor * offset,
                    dPtr->vFactor * offset);
  DSClearBody(&bRect);       /* Clear the body part   */
  DSFrameBody(&bRect);       /* Frame low button box  */
 }

long    DSTestControl(dPtr,pt)
 DSPTR       dPtr;           /* Dual control pointer  */
 Point       pt;             /* Point position        */
 {
  Rect       cRect;          /* Working control rect  */
  Rect       tRect;          /* Working temp rect area*/
  Rect       bRect;          /* Working button rect   */
  short      offset;         /* Working offset        */
  short      point;          /* Working pt in region  */
  long       status = 0;     /* Working status flag   */
      
  cRect = (*dPtr->cHdl)->contrlRect;/* Set ctrl rect  */
  bRect = dPtr->thumb;       /* Set button rect area  */
  if (dPtr->hFactor)         /* Check if horz button  */
   bRect.right = dPtr->hBLen;/* Adjust for horz button*/
  else
   bRect.bottom = dPtr->hBLen;/* Adjust for vert buttn*/
  tRect = bRect;             /* Set the temp rect area*/
  OffsetRect(&tRect,cRect.left,cRect.top);
  if (PtInRect(pt,&tRect)) { /* Check if high up buttn*/
   status = inUpButton;      /* Set high up button    */
   dPtr->altButton = FALSE;  /* Not using alt button  */
  }
  if (!status) {             /* Check if prev part    */
                             /* Adjust for down button*/
   OffsetRect(&tRect,dPtr->hFactor * dPtr->hBLen,
                     dPtr->vFactor * dPtr->hBLen);
   if (PtInRect(pt,&tRect)) {/* Check if high down    */
    status = inDownButton;   /* Set high down button  */
   dPtr->altButton = FALSE;  /* Not using alt button  */
   }
  }
  if (!status) {             /* Check if prev part    */
   tRect = bRect;            /* Set the temp rect area*/
   offset = dPtr->sLen - dPtr->bLen;
                             /* Offset where low up   */
   OffsetRect(&tRect,cRect.left + dPtr->hFactor*offset,
                     cRect.top + dPtr->vFactor*offset);
   if (PtInRect(pt,&tRect)) {/* Check if low up button*/
    status = inUpButton;     /* Set low up button     */
    dPtr->altButton = TRUE; /* Using alt button       */
   }
  }
  if (!status) {             /* Check if prev part    */
                             /* Offset where low down */
   OffsetRect(&tRect,dPtr->hFactor * dPtr->hBLen,
                     dPtr->vFactor * dPtr->hBLen);
   if (PtInRect(pt,&tRect)) {/* Check if the low down */
    status = inDownButton;  /* Set low down button    */
    dPtr->altButton = TRUE; /* Using alt button       */
   }

  }
  if (!status) {             /* Check if prev part    */
   if (PtInRect(pt,&dPtr->cThumb))/* Check if thumb   */
    status = inThumb;        /* Set thumb part        */
  }
  if (!status) {             /* Check if prev part    */
                             /* Set relative point    */
   point = pt.h * dPtr->hFactor + pt.v * dPtr->vFactor;
                             /* Set relative offset   */
   offset = dPtr->cThumb.left * dPtr->hFactor + 
            dPtr->cThumb.top * dPtr->vFactor;
   if (point > offset)       /* Check if in down page */
    status = inPageDown;     /* Set down page region  */
   else
    status = inPageUp;       /* Set up page region    */
  }
  return(status);            /* Return status part    */
 }
   
DSSetScrollRgn(dPtr,scrollRgn)
  DSPTR   dPtr;              /* Dual control pointer  */
  Rect    *scrollRgn;        /* Scrolling region area */
  {
   *scrollRgn = (*dPtr->cHdl)->contrlRect;/* Set area */
   InsetRect(scrollRgn,1,1);/* Shrink it a bit        */
   if (dPtr->hFactor) {     /* Check if horizontal bar*/
    scrollRgn->left += dPtr->bLen;/* Adjust rect area */
    scrollRgn->right -= dPtr->bLen;
   }
   else {                   /* It’s a vert scroll bar */
    scrollRgn->top += dPtr->bLen;/* Adjust rect area  */
    scrollRgn->bottom -= dPtr->bLen;
   }
  }
   
void    DSGetBackGround(color) 
 RGBColor *color; { GetBackColor(color); }
void    DSGetForeGround(color) 
 RGBColor *color; { GetForeColor(color); }
void    DSSetBackGround(color) 
 RGBColor *color; { RGBBackColor(color); }
void    DSSetForeGround(color) 
 RGBColor *color; { RGBForeColor(color); }
   
void    DSEraseRect(rect) 
 Rect *rect; { EraseRect(rect); }
void    DSFrameRect(rect) 
 Rect *rect; { FrameRect(rect); }
void    DSFillRect(rect,pattern) 
 Rect *rect; Pattern *pattern; {FillRect(rect,pattern);}
void    DSErasePoly(poly) 
 PolyHandle poly; { ErasePoly(poly); }
void    DSFramePoly(poly) 
 PolyHandle poly; { FramePoly(poly); }
void    DSFillPoly(poly,pattern) 
 PolyHandle poly; Pattern *pattern;
 { FillPoly(poly,pattern); }

void    DSDrawObject(cHdl,getGround,setGround,
                     object,color,arg1,arg2)
 ControlHandle cHdl;         /* Control handle        */
 ProcPtr       getGround;    /* Get back/fore grd proc*/
 ProcPtr       setGround;    /* Set back/fore grd proc*/
 ProcPtr       object;       /* Draw object proc      */
 short         color;        /* Color index           */
 long          arg1,arg2;    /* Argument’s parameters */
 {
  AuxCtlHndl   acHdl = NIL;  /* Working aux color hdl */
  RGBColor     oldColor;     /* Working old color     */
  RGBColor     newColor;     /* Working new color     */
                             /* Check if has color    */
  if ((*((DSHDL)((*cHdl)->contrlData)))->hasColor) {
   GetAuxCtl(cHdl,&acHdl);   /* Get control color info*/
   if (acHdl) {              /* Check if really got it*/
    (*getGround)(&oldColor); /* Get back-ground color */
                             /* Get object’s color    */
    newColor =(*(*acHdl)->acCTable)->ctTable[color].rgb;
    (*setGround)(&newColor); /* Set control obj color */
   }
  }
  (*object)(arg1,arg2);      /* Draw the object       */
  if (acHdl)                 /* Check if have aux hdl */
   (*setGround)(&oldColor);  /* Restore back-grd color*/
 }

 
AAPL
$98.38
Apple Inc.
-0.64
MSFT
$43.89
Microsoft Corpora
-0.09
GOOG
$585.61
Google Inc.
-4.99

MacTech Search:
Community Search:

Software Updates via MacUpdate

Drive Genius 3.2.4 - Powerful system uti...
Drive Genius is an OS X utility designed to provide unsurpassed storage management. Featuring an easy-to-use interface, Drive Genius is packed with powerful tools such as a drive optimizer, a... Read more
Vitamin-R 2.15 - Personal productivity t...
Vitamin-R creates the optimal conditions for your brain to work at its best by structuring your work into short bursts of distraction-free, highly focused activity alternating with opportunities for... Read more
Toast Titanium 12.0 - The ultimate media...
Toast Titanium goes way beyond the very basic burning in the Mac OS and iLife software, and sets the standard for burning CDs, DVDs, and now Blu-ray discs on the Mac. Create superior sounding audio... Read more
OS X Yosemite Wallpaper 1.0 - Desktop im...
OS X Yosemite Wallpaper is the gorgeous new background image for Apple's upcoming OS X 10.10 Yosemite. This wallpaper is available for all screen resolutions with a source file that measures 5,418... Read more
Acorn 4.4 - Bitmap image editor. (Demo)
Acorn is a new image editor built with one goal in mind - simplicity. Fast, easy, and fluid, Acorn provides the options you'll need without any overhead. Acorn feels right, and won't drain your bank... Read more
Bartender 1.2.20 - Organize your menu ba...
Bartender lets you organize your menu bar apps. Features: Lets you tidy your menu bar apps how you want. See your menu bar apps when you want. Hide the apps you need to run, but do not need to... Read more
TotalFinder 1.6.2 - Adds tabs, hotkeys,...
TotalFinder is a universally acclaimed navigational companion for your Mac. Enhance your Mac's Finder with features so smart and convenient, you won't believe you ever lived without them. Tab-based... Read more
Vienna 3.0.0 RC 2 :be5265e: - RSS and At...
Vienna is a freeware and Open-Source RSS/Atom newsreader with article storage and management via a SQLite database, written in Objective-C and Cocoa, for the OS X operating system. It provides... Read more
VLC Media Player 2.1.5 - Popular multime...
VLC Media Player is a highly portable multimedia player for various audio and video formats (MPEG-1, MPEG-2, MPEG-4, DivX, MP3, OGG, ...) as well as DVDs, VCDs, and various streaming protocols. It... Read more
Default Folder X 4.6.7 - Enhances Open a...
Default Folder X attaches a toolbar to the right side of the Open and Save dialogs in any OS X-native application. The toolbar gives you fast access to various folders and commands. You just click... Read more

Latest Forum Discussions

See All

Note Review
Note Review By Jennifer Allen on July 29th, 2014 Our Rating: :: TOO SIMPLEiPhone App - Designed for the iPhone, compatible with the iPad Note is a note taking app that’s a little too short on features to be worth its asking price... | Read more »
Chainsaw Warrior Goes on Sale & Ther...
Chainsaw Warrior Goes on Sale & There’s a Chance to Win a Copy of the Original Board Game Posted by Jennifer Allen on July 29th, 2014 [ permalink | Read more »
It Came From Canada: Tiny Tower Vegas
If you go to a casino, you might make a lot of money. If you run a casino, you’re guaranteed to make a lot of money. The choice seems pretty obvious. So while waiting for your shady real estate deals to move forward, get prepared with Tiny Tower... | Read more »
Z Hunter Review
Z Hunter Review By Lee Hamlet on July 29th, 2014 Our Rating: :: RIGHT ON TARGETUniversal App - Designed for iPhone and iPad While it might not necessarily break new ground, Z Hunter has enough tricks up its sleeve to ensure that... | Read more »
Huge Update Comes To Duet, Adding 48 New...
Huge Update Comes To Duet, Adding 48 New Stages Posted by Jennifer Allen on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Sharknado: The Video Game Available Now....
Sharknado: The Video Game Available Now. Seriously. Posted by Rob Rich on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Frog Orbs 2 Review
Frog Orbs 2 Review By Nadia Oxford on July 29th, 2014 Our Rating: :: THIS MAGIC IS A TAD MONOTONOUS Universal App - Designed for iPhone and iPad Frog Orbs 2 is repetitive, but younger players should enjoy it nonetheless.   | Read more »
Puzzix Review
Puzzix Review By Jennifer Allen on July 29th, 2014 Our Rating: :: NICE IDEAUniversal App - Designed for iPhone and iPad A little like Tetris, Puzzix is all about piecing together blocks and watching them vanish. It could do with... | Read more »
Cannonball eMail is Now Live – Works Wit...
Cannonball eMail is Now Live – Works With Gmail, Yahoo, Outlook, Hotmail, and AOL Posted by Jessica Fisher on July 29th, 2014 [ permalink ] | Read more »
To The End Review
To The End Review By Lee Hamlet on July 29th, 2014 Our Rating: :: A VICIOUS CYCLEUniversal App - Designed for iPhone and iPad To The End will test players’ patience, timing, and dedication as they try to navigate all 13 levels in... | Read more »

Price Scanner via MacPrices.net

Up to $250 price drop on leftover 15-inch Mac...
B&H Photo has dropped prices on 2013 15″ Retina MacBook Pros by as much as $250 off original MSRP. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.3GHz Retina MacBook Pro: $2349... Read more
Updated MacBook Pro Price Trackers
We’ve updated our MacBook Pro Price Trackers with the latest information on prices, bundles, and availability on the new 2014 models from Apple’s authorized internet/catalog resellers as well as... Read more
Apple updates MacBook Pros with slightly fast...
Apple updated 13″ and 15″ Retina MacBook Pros today with slightly faster Haswell processors. 13″ models now ship with 8GB of RAM standard, while 15″ MacBook Pros ship with 16GB across the board. Most... Read more
Apple drops price on 13″ 2.5GHz MacBook Pro b...
The Apple Store has dropped their price for the 13″ 2.5GHz MacBook Pro by $100 to $1099 including free shipping. Read more
Apple drops prices on refurbished 2013 MacBoo...
The Apple Store has dropped prices on Apple Certified Refurbished 13″ and 15″ 2013 MacBook Pros, with model now available starting at $929. Apple’s one-year warranty is standard, and shipping is free... Read more
iOS 8 and OS X 10.10 To Support DuckDuckGo As...
Writing for Quartz, Dan Frommer reports that Apple’s forthcoming iOS 8 and OS X 10.10 operating systems version updates will allow users to select DuckDuckGo as their default search engine. He notes... Read more
U.K. Hospital Using iPods and iPads To Record...
British news journal GazetteLive’s. Ian McNeal notes that the old “an apple a day keeps the doctor away” proverb is being turned on its head at http://southtees.nhs.uk/hospitals/james-cook/ James... Read more
13-inch 2.5GHz MacBook Pro on sale for $1099,...
Best Buy has the 13″ 2.5GHz MacBook Pro available for $1099.99 on their online store. Choose free shipping or free instant local store pickup (if available). Their price is $100 off MSRP. Price is... Read more
Roundup of Apple refurbished MacBook Pros, th...
The Apple Store has Apple Certified Refurbished 13″ and 15″ MacBook Pros available for up to $400 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free. Their prices... Read more
Record Mac Shipments In Q2/14 Confound Analys...
A Seeking Alpha Trefis commentary notes that Apple’s fiscal Q3 2014 results released July 22, beat market predictions on earnings, although revenues were slightly lower than anticipated. Apple’s Mac’... Read more

Jobs Board

Sr Software Lead Engineer, *Apple* Online S...
Sr Software Lead Engineer, Apple Online Store Publishing Systems Keywords: Company: Apple Job Code: E3PCAK8MgYYkw Location (City or ZIP): Santa Clara Status: Full Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Sr. Product Leader, *Apple* Store Apps - Ap...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.