TweetFollow Us on Twitter

Spreadsheet
Volume Number:5
Issue Number:3
Column Tag:C Workshop

Related Info: List Manager

How to Write a Spreadsheet in LS C

By Bryan Waters, Casselberry, FL

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

Bryan Waters is a Software Engineer for Maynard Electronics, and is currently working as part of a team to develop a finder-like tape backup system.

Dear Cary Mariash

In the January ’88 issue of MacTutor, a letter sent by Cary Mariash requested information on Macintosh tools to create spreadsheet type windows. MacTutorCalc is an example of a simple (very simple!) spreadsheet type application, that uses the List Manager ( IM - IV ) to create it’s windows. (Note: MacTutorCalc is written in Think C 3.0, see the project window in figure 1 )

Figure 1. Lightspeed C Project Window

List Manager in action!

The call to Lnew is used to create the list (figure 2). The dataBounds parameter is set to have an extra row and column than our work area. This, of course, is to support the row and column headers. After the list has been created the programmer has several more options, involving selection, and installing a routine in the lClikLoop field to be called repeatedly while LClick has control. The selFlags field of the list handle allow complete customization of the selection algorithm used by the list manager. MacTutorCalc is content to use the default selection, but when we call LClick to handle our mouseDown events in the window, any scrolling causes the spreadsheet to scroll, without the grid being updated. To fix this, MacTutorCalc installs a lClickLoop routine to update the grid continuously during calls to LClick. This works great, except the List Manager does not call this routine when the mouse button is pressed in the scroll bars, so that the grid is updated then only after the mouse button is released. Although it is not implemented here, this could be fixed by installing a pointer to our grid routine in the system global DragHook ( $9F6 ) which is called by DragGrayRgn. Since the control manager routine TrackControl calls DragGrayRgn to drag the outline of the scroll bars thumb button, this would achieve the desired effect.

Figure 2. Spreadsheet & Dialog Entry

There are other points to take into account when using a window such as this. For example, when the user resizes the window, it would not be desirable to allow the user to size the window out of alignment with the cell boundries simply because it looks bad. To handle this, after the call to GrowWindow, we make sure that the new size is a multiple of the cell size. Updating is handled almost completely by the list manager routine LUpdate, although we still have to draw the grid, and the grow icon.

Data entry is probably where MacTutorCalc could be improved the most. Currently data entry is implemented by double-clicking on the desired cell ( LClick returns TRUE when a cell was double-clicked and a call to LLastClick is used to get the cell’s address). This brings up a dialog prompting for the data. In an application intended for serious use, this would get extremely tiring. This could be fixed by adding a data entry window at the top of the screen ( Excel Style ) and allowing the user to enter data into the currently selected cell through this window. At this point we have data that needs to processed, so we determine the type of data ( formula, or string ) and then set our calculation flag. The routine DoCalc is called in response to this, and processes the whole spreadsheet, calling the parser for formula, and ignoring strings. After the data has been parsed, LSetCell is used to put the data into the list. Alternatively, if the cell has been blanked out, then LClrCell is used to clear the data.

About MacTutorCalc

MacTutorCalc is a simple spreadsheet written for the purpose of demonstrating use of the list manager. The work area for our application is set to 8 columns by 8 rows. It is capable of accepting both strings and formulae, and constants. Data is entered into a cell by double-clicking on it. I know that this is awkward, but other methods would have unnecessarily complicated this example. Any data entered into a cell that starts with “=” is considered a formula and will be parsed, and any number will be treated as a constant, everything else is considered a string. A formula can be any simple algebraic expression, using floating or absolute cell addresses. There a few simple functions in MacTutorCalc that use the Math library distributed with Think C. In the future, we could expand our spreadsheet to include:

• ability to save and retrieve spreadsheets

• a full function library

• cell formatting and spreadsheet editing features

• memory paging system to support larger spreadsheet sizes

• support for SYLK format

[There is a known bug in the text to binary conversion routines. Apple's conversion routines were used, and so large formatted numbers will not be converted to text correctly. Note also that Apple frowns on trying to use the List Manager to write the next Excel Product, so if you get serious about this project, re-write it without using the List Manager. -Ed]

Listing:  CalcData.h

/* Global data */
extern int quit_flag ;

extern Rect minmax_size ;
extern Rect curr_screen ;
extern int automatic_calculation ;
extern int calc_data ;
extern int do_calc_now ;
extern SHEET_WIN_PTR curr_sheet_ptr ;
extern SHEET_WIN_HDL calc_hdl ;
extern FUN_ENTRY fun_table[] ;
extern ARG arg_free_pool[ ] ;
Listing:  MacCalc.h

#include <MacTypes.h>
#include <ListMgr.h>
#ifndef NULL
#define NULL    0L
#endif
#define MAX_ROWS     8
#define MAX_COLUMNS       8
#define CELL_WIDTH        96
#define CELL_HEIGTH  16

#define ENTER_DATA_DIALOG        128
#define APPLE_MENU                1
#define FILE_MENU                256
#define EDIT_MENU                257

/* Types for cell */
#define CLEARED        -1
#define UNDEFINED    0
#define STRING        1
#define FORMULA        2
#define CONSTANT    3

struct cell_struct{
    int type ;
    double value ;
    Str255 formula ;
} ;

typedef struct cell_struct CELL, *CELL_PTR, **CELL_HDL ;

struct sheet_win{
    WindowPtr sheet_window_ptr ;
    ListHandle sheet_list_hdl ;
    CELL sheet_data[MAX_ROWS][MAX_COLUMNS] ;
} ;

typedef struct sheet_win SHEET_WIN, *SHEET_WIN_PTR, **SHEET_WIN_HDL ;

/* Argument types */
#define VALUE_ARG 1
#define STRING_ARG 2
/* Arg usage defines */
#define IN_USE   TRUE
#define FREE_ARG FALSE

struct fun_arg{
    struct fun_arg *next_arg ;
    int in_use ;
    int type ;
    double value ;
    Str255 string ;
} ;

typedef struct fun_arg ARG, *ARG_PTR, **ARG_HDL ;
struct fun_entry{
    char fun_name[32] ;
    double (*fun_ptr)( ) ;
} ;

typedef struct fun_entry FUN_ENTRY, *FUN_ENTRY_PTR, **FUN_ENTRY_HDL ;

/* Prototypes */
int DoInit( void ) ;
void DoEventLoop( void ) ;
void DoActivate( EventRecord * ) ;
void DoUpdate( EventRecord * ) ;
void DoMouseDown( EventRecord * ) ;

int ClikLoop( void ) ;
void EnterData( Cell, SHEET_WIN_HDL ) ;
void DoCalc( SHEET_WIN_HDL ) ;
Listing:  SheetHndlg.h

/* SpreadSheet Handling prototypes */
int OpenNewSpreadsheet( char * ) ;
int DrawGrid( WindowPtr ) ;
Listing:  Parser.h

/* Parse errors */
#define MISMATCHED_PARENTHESIS      200
#define INVALID_NUMBER              201
#define INVALID_ADDRESS             202
#define ADDRESS_TOO_LARGE            203
#define INVALID_FUNCTION            204

/* Prototypes */
void SetType( CELL_PTR, int ) ;
double ParseFormula( unsigned char *, int * ) ;
double ParseExpression( void ) ;
double ParseFactor( void ) ;
double ParseValue( void ) ;
double ParseAddress( void ) ;
#define IsDigit(x) (((x)<=’9') && ((x)>=’0'))
#define IsAlpha(x) ( ( ( (x) >= ‘A’ ) && ( (x) <= ‘Z’ ) ) || ( ( (x) 
>= ‘a’ ) && ( (x) <= ‘z’ ) ) )
int IsFunction( void ) ;
int GetRow( void ) ;
int GetColumn( void ) ;
double CallFunction( ) ;
int Lookup( unsigned char * ) ;
ARG_PTR BuildArg( void ) ;
double atof( void ) ;
void ftoa( double, unsigned char * ) ;
double GetFloat( unsigned char *, int * ) ;
ARG_PTR GetArg( void ) ;
void PutArg( ARG_PTR ) ;
void DestroyArgs( ARG_PTR ) ;
Listing:  CalcData.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”

/* Global data */
int quit_flag = FALSE ;

/* Grow window limits */
Rect minmax_size ;
/* Current screen size */
Rect curr_screen ;

/* do calculation switches */
int automatic_calculation = TRUE ;
int calc_data = FALSE ;
int do_calc_now = FALSE ;

/* Current spreadsheet globals */
SHEET_WIN_PTR curr_sheet_ptr ;
SHEET_WIN_HDL calc_hdl ;

extern double fsum( ), fabsolute( ), fmodulus( ), fsqrt( ) ;

/* Function table */
FUN_ENTRY fun_table[] = {
    /* Standard math functions */
    { “SUM”, fsum },
    { “ABS”, fabsolute },
    { “MOD”, fmodulus },
    { “SQRT”, fsqrt },
    { 0 } } ;
    
ARG arg_free_pool[30] = {
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 },
    { NULL, FREE_ARG, 0, 0, 0 } };
Listing:  DoActivate.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”

void DoActivate( ev )
EventRecord *ev ;
{
    WindowPtr curr_window_ptr ;
    SHEET_WIN_HDL sheet_record_hdl ;
    int activate ;
 
    activate = ev->modifiers&0x0001 ;
 
    /* Get spreadsheet hdl */
    curr_window_ptr = (WindowPtr)ev->message ;
    sheet_record_hdl = (SHEET_WIN_HDL)GetWRefCon( curr_window_ptr ) ;
 
    /* Do list activation or deactivation */
    LActivate( activate, (**sheet_record_hdl).sheet_list_hdl);
    return ;
}
Listing:  DoCalc.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “CalcData.h”
#include “Parser.h”

void DoCalc( sheet_record_hdl )
SHEET_WIN_HDL sheet_record_hdl ;
{
    int i, j ;
    Str255 buffer ;
    Cell curr_cell ;
    int error ;
    char *err_mess ;
    
    /* Lock and dereference the handle */
    HLock( (Handle)sheet_record_hdl ) ;
    curr_sheet_ptr = *sheet_record_hdl ;
    
    /* Process all cells */
    for( i=0;i<MAX_ROWS;i++ ) {
        for( j=0;j<MAX_COLUMNS;j++) {
            switch( curr_sheet_ptr->sheet_data[i][j].type ) {
            /* If cell type is undefined then do nothing */
            case UNDEFINED:
                break ;
            /* If cell type is undefined then clear cell */
            case CLEARED:
                SetPt( &curr_cell, j+1, i+1 ) ;
                LClrCell( curr_cell, curr_sheet_ptr->sheet_list_hdl ) 
;
                curr_sheet_ptr->sheet_data[i][j].type = UNDEFINED ;
                break ;
            /* If cell type is string,  put string in cell */
            case STRING:
                SetPt( &curr_cell, j+1, i+1 ) ;
                LSetCell( &curr_sheet_ptr->sheet_data[i][j].formula[1],
                          curr_sheet_ptr->sheet_data[i][j].formula[0],
                          curr_cell,
                          curr_sheet_ptr->sheet_list_hdl ) ;
                break ;
            case CONSTANT:
                SetPt( &curr_cell, j+1, i+1 ) ;
                curr_sheet_ptr->sheet_data[i][j].value = 
                    GetFloat( curr_sheet_ptr->sheet_data[i][j].formula, 
&error ) ;
                if( error ) {
                    Alert( error, NULL ) ;
                    err_mess = “\p***ERROR***” ;
                    LSetCell( err_mess+1, *err_mess, curr_cell, curr_sheet_ptr->sheet_list_hdl 
) ;
                }else{
                    ftoa( curr_sheet_ptr->sheet_data[i][j].value, buffer 
) ;
                    LSetCell( &buffer[1],
                          buffer[0],
                          curr_cell,
                          curr_sheet_ptr->sheet_list_hdl ) ;
                }
                break ;
            /* Parse formula then convert value to string and put in 
cell */
            case FORMULA:
                SetPt( &curr_cell, j+1, i+1 ) ;
                curr_sheet_ptr->sheet_data[i][j].value = 
                    ParseFormula( curr_sheet_ptr->sheet_data[i][j].formula, 
&error ) ;
                if( error ) {
                    Alert( error, NULL ) ;
                    err_mess = “\p***ERROR***” ;
                    LSetCell( err_mess+1, *err_mess, curr_cell, curr_sheet_ptr->sheet_list_hdl 
) ;
                }else{
                    ftoa( curr_sheet_ptr->sheet_data[i][j].value, buffer 
) ;
                    LSetCell( &buffer[1],
                          buffer[0],
                          curr_cell,
                          curr_sheet_ptr->sheet_list_hdl ) ;
                }
                break ;
            }
        }
    }
    calc_data = FALSE ;
    DrawGrid( curr_sheet_ptr->sheet_window_ptr ) ;
    HUnlock( (Handle)sheet_record_hdl ) ;
    return ;
}
Listing:  DoInit.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”

void CreateMenus( void ) ;

int DoInit( )
{
    
    /* initialize all the MacIntosh Managers */ 
    InitGraf( ( Ptr)&thePort ) ; /* initialize quickdraw */ 
    InitFonts( ) ; /* initialize the font manager */ 
    InitWindows( ) ; /* initialize the window manager */ 
    InitCursor( ) ; /* initialize the cursor */ 
 InitMenus( ) ; /* initialize the menu manager */ 
 TEInit( ) ; /* initialize the text edit manager */ 
 InitDialogs( NULL ) ; /* initialize dialog manager */ 
    
    /* Flush events */
    
    FlushEvents( everyEvent, 0 ) ;
    
    /* Get curr screen size */
    curr_screen = screenBits.bounds ;
    SetRect( &minmax_size, 207, 77, 447, 159 ) ;

    /* Expand heap to maximum and allocate more masters */ 
    MaxApplZone( ) ; 
    MoreMasters( ) ; 
    MoreMasters( ) ; 
    MoreMasters( ) ; 
    MoreMasters( ) ; 
    MoreMasters( ) ;
    
    CreateMenus( ) ;
    
    OpenNewSpreadsheet( “\pUntitled” ) ;
}
void CreateMenus( )
{
    MenuHandle menu ;
    
    menu = GetMenu( 1 ) ;
    AddResMenu( menu, ‘DRVR’ ) ;
    InsertMenu( menu, 0 ) ;
    InsertMenu( GetMenu( 256 ), 0 ) ;
    InsertMenu( GetMenu( 257 ), 0 ) ;
    DrawMenuBar( ) ;
}
Listing:  DoMouse.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”

WindowPtr curr_window_ptr ;

void DoMouseDown( ev )
EventRecord *ev ;
{
    SHEET_WIN_HDL sheet_record_hdl ;
    Point new_point ;
    int location ;
    GrafPtr tmp_port ;
    Rect boundsRect ;
    long newsize ;
    long menuchoice ;
    int width, heigth ;
    union {
        long tmp ;
        Cell last_cell ;
    } a ;
    
    location = FindWindow( ev->where, &curr_window_ptr ) ;
    
    if( ( curr_window_ptr != FrontWindow( ) ) && ( curr_window_ptr != 
NULL ) ) {
        SelectWindow( curr_window_ptr ) ;
        return ;
    }
    
    new_point = ev->where ;
    GetPort( &tmp_port ) ;
    SetPort( curr_window_ptr ) ;
    GlobalToLocal( &new_point ) ;
    
    switch( location ) {
    case inDesk:
        break ;
    case inMenuBar:
        menuchoice = MenuSelect( ev->where ) ;
        if( HiWord( menuchoice ) == FILE_MENU ) {
            quit_flag = TRUE ;
        }
        HiliteMenu( 0 ) ;
        break ;
    case inContent:
        sheet_record_hdl = (SHEET_WIN_HDL)GetWRefCon( curr_window_ptr 
) ;
        if( LClick( new_point, ev->modifiers, (**sheet_record_hdl).sheet_list_hdl 
) ) {
   a.tmp = LLastClick((**sheet_record_hdl).sheet_list_hdl ) ;
            EnterData( a.last_cell, sheet_record_hdl ) ;
        }
        DrawGrid( curr_window_ptr ) ;
        break ;
    case inDrag:
        boundsRect = curr_screen ;
        DragWindow( curr_window_ptr, ev->where, &boundsRect ) ;
        break ;
    case inGrow:
        sheet_record_hdl = (SHEET_WIN_HDL)GetWRefCon( curr_window_ptr 
) ;
        newsize = GrowWindow( curr_window_ptr, ev->where, &minmax_size 
) ;
        if( newsize ) {
            width = ( ( LoWord( newsize ) / CELL_WIDTH ) * CELL_WIDTH 
) + 15 ;
            heigth = ( ( HiWord( newsize ) / CELL_HEIGTH ) * CELL_HEIGTH 
) + 15 ;
            SizeWindow( curr_window_ptr, width, heigth, TRUE ) ;
            LSize( width-15, heigth-15, (**sheet_record_hdl).sheet_list_hdl 
) ;
            DrawGrid( curr_window_ptr ) ;
            DrawGrowIcon( curr_window_ptr ) ;
        }
        break ;
    case inGoAway:
        if( TrackGoAway( curr_window_ptr, ev->where ) ) {
            quit_flag = TRUE ;
        }
        break ;
    }
    SetPort( tmp_port ) ;

    return ;
}
int ClikLoop( )
{
    DrawGrid( curr_window_ptr ) ;
    return TRUE ;
}
Listing:  DoUpdate.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”

void DoUpdate( ev )
EventRecord *ev ;
{
    WindowPtr curr_window_ptr ;
    SHEET_WIN_HDL sheet_record_hdl ;

    curr_window_ptr = (WindowPtr)ev->message ;
    
    sheet_record_hdl = (SHEET_WIN_HDL)GetWRefCon( curr_window_ptr ) ;
    
    BeginUpdate( curr_window_ptr ) ;
    
    LUpdate( curr_window_ptr->visRgn, (**sheet_record_hdl).sheet_list_hdl 
) ;
    
    DrawGrid( curr_window_ptr ) ;
    
    DrawGrowIcon( curr_window_ptr ) ;
    
    EndUpdate( curr_window_ptr ) ;
    
    return ;
}
Listing:  DrawGrid.c

#include <ListMgr.h>
#include <WindowMgr.h>
#include <MacTypes.h>
#include <QuickDraw.h>

#include “MacCalc.h”
#include “SheetHndlg.h”

int DrawGrid( win_ptr )
WindowPtr win_ptr ;
{
    GrafPtr tmp_port ;
    Rect win_rect ;
    int bottom ;
    int right ;
    int num_h_lines ;
    int num_v_lines ;
    int i, max ;
    
    GetPort( &tmp_port ) ;
    SetPort( win_ptr ) ;
    
    PenNormal( ) ;
    PenPat( gray ) ;
    
    win_rect = win_ptr->portRect ;
    bottom = win_rect.bottom - 15 ;
    right = win_rect.right - 15 ;
    num_h_lines = bottom / CELL_HEIGTH ;
    num_v_lines = right / CELL_WIDTH ;
    
    max = ( num_h_lines > num_v_lines ) ? num_h_lines:num_v_lines ;
    
    for( i = 1 ; i <= max ; i++ ) {
        if( i < num_h_lines ) {
            MoveTo( 0, i*CELL_HEIGTH ) ;
            LineTo( right, i*CELL_HEIGTH ) ;
        }
        if( i < num_v_lines ) {
            MoveTo( i*CELL_WIDTH, 0 ) ;
            LineTo( i*CELL_WIDTH, bottom ) ;
        }
    }
    PenNormal( ) ;
    SetPort( tmp_port ) ;
            return ;
}
Listing:  EntrData.c

#include <ListMgr.h>
#include <DialogMgr.h>
#include <MemoryMgr.h>
#include <QuickDraw.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”
#include “Parser.h”

#define ENTER_BUTTON  1
#define CANCEL_BUTTON 2
#define DATA_ITEM     4

void EnterData( cell, sheet_record_hdl )
Cell cell ;
SHEET_WIN_HDL sheet_record_hdl ;
{
    DialogPtr new_dialog ;
    int item_hit ;
    Handle hdl ;
    Rect box ;
    int type ;
    int had_data = FALSE ;
     
    if( ( cell.v ) != 0 && ( cell.h != 0 ) ) {
     
        HLock( (Handle)sheet_record_hdl ) ;
        new_dialog = GetNewDialog( ENTER_DATA_DIALOG, NULL, (WindowPtr)-1L 
) ;
        
        /* Outline button */
        SetPort( new_dialog ) ;
        GetDItem( new_dialog, ENTER_BUTTON, &type, &hdl,&box) ;
        PenNormal( ) ;
        PenSize( 3,3 ) ;
        InsetRect( &box, -4,-4 ) ;
        FrameRoundRect( &box, 16,16 ) ;

        GetDItem( new_dialog, DATA_ITEM, &type, &hdl, &box ) ;
          
        if( (**sheet_record_hdl).sheet_data[cell.v-1][cell.h-1].formula[0] 
!= 0 ) {
            SetIText( hdl, (**sheet_record_hdl).sheet_data[cell.v-1][cell.h-1].formula) 
;
            SelIText( new_dialog, DATA_ITEM, 0, 255 ) ;
            had_data = TRUE ;
        }
          
        do{
            ModalDialog( NULL, &item_hit ) ;
        }while( item_hit == DATA_ITEM ) ;
          
        if( item_hit != CANCEL_BUTTON ) {
            GetIText( hdl, &(**sheet_record_hdl).sheet_data[cell.v-1][cell.h-1].formula);
            SetType( &(**sheet_record_hdl).sheet_data[cell.v-1][cell.h-1], 
had_data ) ;
            calc_hdl = sheet_record_hdl ;
            calc_data = TRUE ;
        }
        CloseDialog( new_dialog ) ;
        HUnlock( (Handle)sheet_record_hdl ) ;
    }else{
        SysBeep( 1 ) ;
    }
    return ;
}
Listing:  functions.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include <Math.h>

#include “MacCalc.h”
#include “CalcData.h”
#include “Parser.h”

double fsum( arg )
ARG_PTR arg ;
{
    double value = 0 ;
    
    value += arg->value ;
    
    while( arg->next_arg != NULL ) {
        arg = arg->next_arg ;
        value += arg->value ;
    }
    return value ;
}
double fabsolute( arg )
ARG_PTR arg ;
{
    register double value ;
    
    value = arg->value ;
    return( ( value >= 0 ) ? value:-value ) ;
}
double fmodulus( arg )
ARG_PTR arg ;
{
    register double value1 ;
    register double value2 ;
    ARG_PTR curr_arg = arg ;
    
    value1 = arg->value ;
    value2 = arg->next_arg->value ;
    return( fmod( value1, value2 ) ) ;
}
double fsqrt( arg )
ARG_PTR arg ;
{
    register double value ;
    
    value = arg->value ;
 return( sqrt( value ) ) ;
}
Listing:  MacCalc.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”
#include “CalcData.h”
#include “parser.h”

main( ) 
{
        
    DoInit( ) ;
    DoEventLoop( ) ;
}
void DoEventLoop( )
{
    EventRecord ev ;
    
    while( !quit_flag ) {
        SystemTask( ) ;
        if( GetNextEvent( everyEvent, &ev ) ) {
            switch( ev.what ) {
            case mouseDown:
                DoMouseDown( &ev ) ;
                break ;
            case mouseUp:
                break ;
            case keyDown:
                break ;
            case keyUp:
                break ;
            case activateEvt:
                DoActivate( &ev ) ;
                break ;
            case updateEvt:
                DoUpdate( &ev ) ;
                break ;
            }
        }else{
            if( ( automatic_calculation || do_calc_now ) && calc_data 
) {
                DoCalc( calc_hdl ) ;
                do_calc_now = FALSE ;
                calc_data = FALSE ;
            }
        }
    }
    return ;
}
Listing:  Parser.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include <Strings.h>
#include <Math.h>
#include <Ctype.h>
#include <Stdio.h>

#include “MacCalc.h”
#include “CalcData.h”
#include “Parser.h”

unsigned char *curr_pos = NULL ;
int parse_err = 0 ;
Str255 buffer ;

/* Simple algabraic expression parser */

double ParseFormula( formula, error )
unsigned char *formula ;
int *error ;
{
    register double value ;

    /* convert into c string in buffer */
    BlockMove( &formula[2], buffer, formula[0]-1 ) ;
    buffer[formula[0]-1] = 0 ;  /* 0 terminate buffer */
    
    curr_pos = buffer ;
    parse_err = 0 ;
    
    v( = ParseExpression( ) ;
    
    *error = parse_err ;        /* Set error flag */
    
    return ( value ) ;
}
double ParseExpression( )
{
    register double val ;
    
    val = ParseFactor( ) ;
    
    switch( *curr_pos ) {
    case ‘+’:
        curr_pos++ ;
        val += ParseExpression( ) ;
        break ;
    case ‘-’:
        curr_pos++ ;
        val -= ParseExpression( ) ;
        break ;
    case ‘*’:
        curr_pos++ ;
        val *= ParseExpression( ) ;
        break ;
    case ‘/’:
        curr_pos++ ;
        val /= ParseExpression( ) ;
        break ;
    }
    return val ;
}
double ParseFactor( )
{
    register double val = 0 ;
    register double val2 ;
    register int has_sign = FALSE ;
    
    if( *curr_pos == ‘-’ ) {
        has_sign = TRUE ;
        curr_pos++ ;
    }
    
    if( *curr_pos != ‘(‘ ) {
        /* determine whether this is an address or not */
        if( IsDigit( *curr_pos ) || *curr_pos == ‘.’ ) {
            val = ParseValue( ) ;
        }else{
            if( IsFunction( ) ) {
                val = CallFunction( ) ;
            }else{
                val = ParseAddress( ) ;
            }
        }

        switch( *curr_pos ) {
        case ‘^’:
            curr_pos++ ;
            val2 = ParseFactor( ) ;
            val = pow( val, val2 ) ;
            break ;
        case ‘*’:
            curr_pos++ ;
            val2 = ParseFactor( ) ;
            val *= val2 ;
            break ;
        case ‘/’:
            curr_pos++ ;
            val2 = ParseFactor( ) ;
            val /= val2 ;
            break ;
        }
    }else{
        curr_pos++ ;
        val = ParseExpression( ) ;
        if( *curr_pos == ‘)’ ) {
            curr_pos++ ;
        }else{
            parse_err = MISMATCHED_PARENTHESIS ;
        }
    }
    
    return ( has_sign ? -( val ):val ) ;
}
double ParseValue( )
{
    register double val = 0 ;
    
    if( IsDigit( *curr_pos ) || ( *curr_pos == ‘.’ ) ) {
        val = atof( ) ;
    }else{
        parse_err = INVALID_NUMBER ;
    }
    return val ;
}
double ParseAddress( )
{
    register int row ;
    register int column ;
    register double val = 0 ;
    
    column = GetColumn( ) ;
    row = GetRow( ) ;
    
    if( ( row > MAX_ROWS ) || ( column > MAX_COLUMNS ) ) {
        parse_err = ADDRESS_TOO_LARGE ;
    }else{
        val = curr_sheet_ptr->sheet_data[row-1][column-1].value ;
    }
    return val ;
}
int GetRow( )
{
    register int row ;
    
    if( IsDigit( *curr_pos ) ) {
        row = *curr_pos - ‘0’ ;
    }else{
        parse_err = INVALID_ADDRESS ;
    }
    curr_pos++ ;
    
    return row ;
}
int GetColumn( )
{
    register int column ;
    
    if( IsAlpha( *curr_pos ) ) {
        if( *curr_pos >= ‘a’ ) {
            column = ( *curr_pos - ‘a’ ) + 1 ;
        }else{
            column = ( *curr_pos - ‘A’ ) + 1 ;
        }
    }else{
        parse_err = INVALID_ADDRESS ;
    }
    curr_pos++ ;
    return column ;
}
int IsFunction( )
{
    register unsigned char *p ;
    
    p = curr_pos ;
    while( IsAlpha( *p ) || IsDigit( *p ) ) {
        p++ ;
    }
    return ( *p == ‘(‘ ) ? TRUE:FALSE ;
}
double CallFunction( )
{
    unsigned char fun_name[32] ;
    register unsigned char *p ;
    register int fun_number ;
    register double value ;
    register ARG_PTR args ;
    
    p = fun_name ;
    while( IsAlpha( *curr_pos ) || IsDigit( *curr_pos ) ) {
        *p = toupper( *curr_pos ) ;
        p++; curr_pos++;
    }
    *p = ‘\0’ ;
    curr_pos++ ;
    args = BuildArg( ) ;
    if( ( fun_number = Lookup( fun_name ) ) > -1 ) {
        value = (*fun_table[fun_number].fun_ptr)( args ) ;
    }else{
        parse_err = INVALID_FUNCTION ;
    }
    DestroyArgs( args ) ;
    return value ;
}
int Lookup( fun_name )
unsigned char *fun_name ;
{
    register int i = 0 ;
    
    while( fun_table[i].fun_name[0] != 0 ) {
        if( !strcmp( fun_name, fun_table[i].fun_name ) ) {
            return i ;
        }
        i++ ;
    }
    return -1 ;
}
ARG_PTR BuildArg( )
{
    int error ;
    ARG_PTR first_arg_ptr = NULL, last_arg_ptr = NULL, next_arg_ptr = 
NULL ;
    
    /* This needs to be changed so that recursive functions calls can 
be made */
    while( *curr_pos != ‘)’ ) {
        next_arg_ptr = GetArg( ) ;
        next_arg_ptr->value = ParseExpression( ) ;
        next_arg_ptr->type = VALUE_ARG ;
        if( *curr_pos == ‘,’ ) {
            curr_pos++ ;
        }
        if( last_arg_ptr != NULL ) {
            last_arg_ptr->next_arg = next_arg_ptr ;
        }
        if( first_arg_ptr == NULL ) {
            first_arg_ptr = next_arg_ptr ;
        }
        last_arg_ptr = next_arg_ptr ;
    }
    next_arg_ptr->next_arg = NULL ;
    
    /* Now pass the last parenthesis by */
    if( *curr_pos == ‘)’ ) {
        curr_pos++ ;
        return first_arg_ptr ;
    }else{
        parse_err = MISMATCHED_PARENTHESIS ;
        return NULL ;
    }
}
double atof( )
{
    register double val = 0.0 ;
    register double val2 = 0.0 ;
    
    if( IsDigit( *curr_pos ) || ( *curr_pos == ‘.’ ) ) {
        while( *curr_pos && IsDigit( *curr_pos ) ) {
            val = ( val * 10 ) + ( *curr_pos - ‘0’ ) ;
            curr_pos++ ;
        }
        if( *curr_pos == ‘.’ ) {
            curr_pos++ ;
        }
        while( *curr_pos && IsDigit( *curr_pos ) ) {
            val2 = ( val2 * 10 ) + ( *curr_pos - ‘0’ ) ;
            curr_pos++ ;
        }
        if( val2 != 0.0 ) {
            while( val2 > 1 ) {
                val2 /= 10 ;
            }
        }
        val += val2 ;
    }else{
        parse_err = INVALID_NUMBER ;
    }
    return val ;

}
void ftoa( val, buffer )
double val ;
unsigned char *buffer ;
{
    long whole ;
    Str255 buff ;
    Str255 tmp ;
    int has_sign ;
    int prec = /*curr_precision*/5 ;

    has_sign = ( val < 0 ) ? TRUE:FALSE ;
    whole = val/1 ;
    NumToString( whole, buffer ) ;
    /* convert into c string in buffer */
    BlockMove( &buffer[1], buff, buffer[0] ) ;
    buff[buffer[0]] = 0 ;  /* 0 terminate buffer */
    val -= whole ;
    if( prec ) {
        do{
            val *= 10.0 ;
        }while( --prec ) ;
        whole = val ;
        NumToString( whole, buffer ) ;
        /* convert into c string in buffer */
        BlockMove( &buffer[1], tmp, buffer[0] ) ;
        tmp[buffer[0]] = 0 ;  /* 0 terminate buffer */
        strcat( buff, “.” ) ;
        strcat( buff, tmp ) ;
    }
    if( has_sign ) {
        tmp[0] = ‘-’ ;
        tmp[1] = ‘\0’ ;
        strcat( tmp, buff ) ;
        strcpy( &buffer[1], tmp ) ;
        buffer[0] = strlen( tmp ) ;
    }else{
        strcpy( &buffer[1], buff ) ;
        buffer[0] = strlen( buff ) ;
    }
    
    return ;
}
double GetFloat( formula, error )
unsigned char *formula ;
int *error ;
{
    register double value ;

    /* convert into c string in buffer */
    BlockMove( &formula[1], buffer, formula[0] ) ;
    buffer[formula[0]] = 0 ;  /* 0 terminate buffer */
    
    curr_pos = buffer ;
    parse_err = 0 ;
    value = atof( ) ;
    *error = parse_err ;        /* Set error flag */
    return ( value ) ;
}
ARG_PTR GetArg( )
{
    register int i ;
    
    for( i=0;i<30;i++){
        if( arg_free_pool[i].in_use == FREE_ARG ) {
            arg_free_pool[i].in_use = IN_USE ;
            return &arg_free_pool[i] ;
        }
    }
    return NULL ;
}
void DestroyArgs( arg_ptr )
ARG_PTR arg_ptr ;
{
    if( arg_ptr != NULL ) {
        PutArg( arg_ptr ) ;
        while( arg_ptr->next_arg != NULL ) {
            arg_ptr = arg_ptr->next_arg ;
            PutArg( arg_ptr ) ;
        }
    }
    return ;
}
void PutArg( arg_ptr )
ARG_PTR arg_ptr ;
{
    arg_ptr->in_use = FREE_ARG ;
    return ;
}
Listing:  SetType.c

#include <WindowMgr.h>
#include <ListMgr.h>
#include <OSUtil.h>
#include <EventMgr.h>

#include “MacCalc.h”
#include “CalcData.h”
#include “Parser.h”

void RemoveLeadingBlanks( unsigned char * ) ;
void PackLine( unsigned char * ) ;

void SetType( cell_ptr, had_data )
CELL_PTR cell_ptr ;
int had_data ;
{
    if( cell_ptr->formula[0] != 0 ) {
        RemoveLeadingBlanks( cell_ptr->formula ) ;
        if( cell_ptr->formula[1] == ‘=’ ) { /* formula */
            cell_ptr->type = FORMULA ;
            PackLine( cell_ptr->formula ) ;
        }else{
            if( IsDigit( cell_ptr->formula[1] ) || 
                ( cell_ptr->formula[1] == ‘.’ ) ) {
                cell_ptr->type = CONSTANT ;
            }else{
                cell_ptr->type = STRING ;
            }
        }
    }else{
        if( had_data ) {
            cell_ptr->type = CLEARED ;
        }else{
            cell_ptr->type = UNDEFINED ;
        }
    }
    return ;
}
void RemoveLeadingBlanks( formula )
unsigned char *formula ;
{
    int length ;
    unsigned char *str ;
    
    length = formula[0] ;
    str = &formula[1] ;
    while( ( *str == ‘ ‘ ) || ( *str == ‘\t’ ) ) {
        str++ ;
        length-- ;
    }
    BlockMove( str, &formula[1], length ) ;
    formula[0] = length ;
    return ;
}
void PackLine( formula )
unsigned char *formula ;
{
    int old_length ;
    int new_length ;
    int i ;
    unsigned char *str ;
    Str255 buffer ;
    int str_flag = FALSE ;
    
    old_length = formula[0] ;
    new_length = 0 ;
    str = buffer ;
    for( i=1 ; i<= old_length ; i++ ) {
        if( ( ( formula[i] != ‘ ‘ ) || str_flag )
            && ( formula[i] != ‘\t’ ) ) {
            *str = formula[i] ;
            if( formula[i] == ‘\”’ ) {
                str_flag = str_flag ? FALSE:TRUE ;
            }
            new_length++ ;
            str++ ;
        }
    }
    BlockMove( buffer, &formula[1], new_length ) ;
    formula[0] = new_length ;
    return ;
}
Listing:  SheetHndlg.c

#include <ListMgr.h>
#include <WindowMgr.h>

#include “MacCalc.h”
#include “SheetHndlg.h”

char column_header[MAX_COLUMNS] ={ ‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’} ;
char row_header[MAX_ROWS] = {‘1’,’2',’3',’4',’5',’6',’7',’8'} ;
                       
void SetupRowandColumnHeader( ListHandle ) ;
void InitData( SHEET_WIN_HDL ) ;

int OpenNewSpreadsheet( title )
char *title ;
{
    WindowPtr new_window_ptr ;
    SHEET_WIN_HDL new_sheet_hdl ;
    Rect rView, dataBounds ;
    Point cSize ;
    int i ;

    /* variable initialization for screen */
    new_window_ptr = GetNewWindow( 128, NULL, (WindowPtr)-1L );
    new_sheet_hdl =(SHEET_WIN_HDL)NewHandle(sizeof(SHEET_WIN));
    
    /* Set the window title */
    SetWTitle( new_window_ptr, title ) ;
    
    SetRect( &dataBounds, 0, 0, MAX_COLUMNS+1, MAX_ROWS+1 ) ;
    SetRect( &rView, new_window_ptr->portRect.left,
                     new_window_ptr->portRect.top,
                     new_window_ptr->portRect.right - 15,
                     new_window_ptr->portRect.bottom - 15 ) ;
                     
    SetPt( &cSize, CELL_WIDTH, CELL_HEIGTH ) ;
    
    (**new_sheet_hdl).sheet_list_hdl = LNew( &rView, &dataBounds, cSize, 
0,new_window_ptr, TRUE, TRUE, TRUE, TRUE);
                                             
    SetWRefCon( new_window_ptr, (long)new_sheet_hdl ) ;
    
    InitData( new_sheet_hdl ) ;
    
    (**new_sheet_hdl).sheet_window_ptr = new_window_ptr ;
    
    (**(**new_sheet_hdl).sheet_list_hdl).lClikLoop = (Ptr)ClikLoop ;

    SetupRowandColumnHeader( (**new_sheet_hdl).sheet_list_hdl);
    
    ShowWindow( new_window_ptr ) ;
    
    return noErr ;
}
void SetupRowandColumnHeader( list_hdl )
ListHandle list_hdl ;
{
    Cell curr_cell ;
    int i ;
    
    i = 0 ;
    
    for( i = 1 ; i <= MAX_ROWS ; i++ ) {
    
        SetPt( &curr_cell, i, 0 ) ;
        LSetCell( &column_header[i-1], 1, curr_cell, list_hdl);
        SetPt( &curr_cell, 0, i ) ;
        LSetCell( &row_header[i-1],1, curr_cell, list_hdl ) ;
    }
    return ;
}
void InitData( sheet_record_hdl )
SHEET_WIN_HDL sheet_record_hdl ;
{
    int i,j ;
    for( i=0; i<MAX_ROWS;i++){
        for( j=0; j<MAX_COLUMNS;j++ ) {
            (**sheet_record_hdl).sheet_data[i][j].type = 0 ;
            (**sheet_record_hdl).sheet_data[i][j].value = 0L ;
            (**sheet_record_hdl).sheet_data[i][j].formula[0] = 0 ;
        }
    }
    return ;
}
Listing:  Resources.r

*
* MacTutorCalc.R

MacTutorCalc.rsrc
????CALx

Type CALx = STR 
 ,0
Spreadsheet Demo \0D© by Bryan Waters for MacTutor

* Multifinder Menu for Quit Cmd
Type mstr = STR 
 ,100
File

* Multifinder Quit name
Type mstr = STR 
 ,101
Quit

Type SIZE = GNRL
 ,-1
.H
0800    ;; $0800 = bits 11 set
.L
80000 ;; ( recomended)
.L
40000 ;; ( minimum)
.I

Type vers = GNRL
 , 1
.H
01 ;; byte vers # in BCD
10 ;; byte vers part 2 & 3
50 ;; byte release stage $50=release
00 ;; byte stage of non-release
00 00 ;; integer country 0=US
.P
1.1 (US)
.P
SpreadSheet Demo, © by Bryan Waters for MacTutor 1989

Type vers = GNRL
 , 2
.H
05 ;; byte vers # in BCD
30 ;; byte vers part 2 & 3
50 ;; byte release stage $50=release
00 ;; byte stage of non-release
00 00 ;; integer country 0=US
.P
V5.3
.P
MacTutor Volume 5 Number 3

* ------------ menus ------------

Type MENU
  ,1 (0)
 \14

Type MENU
  ,256 (0)
 File
Quit

Type MENU
  ,257 (0)
 Edit
Undo
(-
Cut
Copy
Paste
Clear

Type WIND
  ,128 (0)
MacCalc
43 20 202 419 
Invisible GoAway
0 
0 

Type DLOG
  ,128 (32)
New Dialog
208 70 330 424 
Visible NoGoAway
1 
0 
12258

Type DITL
  ,12258 (0)
4

Button 
96 184 116 244 
Enter

Button 
96 264 116 324 
Cancel

staticText Disabled
8 8 24 88 
Enter data:

editText 
8 96 80 328 


Type DITL
  ,200 (0)
3

Button 
56 160 76 220 
OK

IconItem Disabled
8 16 40 48 
128

staticText Disabled
24 56 40 224 
Mismatched Parenthesis.

Type DITL
  ,201 (0)
3

Button 
56 160 76 220 
OK

IconItem Disabled
8 16 40 48 
128

staticText Disabled
24 56 40 224 
Invalid Number.

Type DITL
  ,202 (0)
3

Button 
56 160 76 220 
OK

IconItem Disabled
8 16 40 48 
128

staticText Disabled
24 56 40 224 
Invalid address.

Type DITL
  ,204 (0)
3

Button 
56 160 76 220 
OK

IconItem Disabled
8 16 40 48 
128

staticText Disabled
24 56 40 224 
Invalid function.

Type DITL
  ,203 (0)
3

Button 
56 160 76 220 
OK

IconItem Disabled
8 16 40 48 
128

staticText Disabled
24 56 40 224 
Address too large.

Type ALRT
  ,200 (32)
118 94 214 338 
200
4444 

Type ALRT
  ,201 (32)
118 94 214 338 
201
4444 

Type ALRT
  ,202 (32)
118 94 214 338 
202
4444 

Type ALRT
  ,204 (32)
118 94 214 338 
204
4444 

Type ALRT
  ,203 (32)
118 94 214 338 
203
4444 

Type ICON = GNRL
  ,128 (32)
.H
0001 8000 0003 C000 0003 C000 0006 6000 
0006 6000 000C 3000 000C 3000 0018 1800 
0019 9800 0033 CC00 0033 CC00 0063 C600 
0063 C600 00C3 C300 00C3 C300 0183 C180 
0183 C180 0303 C0C0 0303 C0C0 0603 C060 
0601 8060 0C01 8030 0C00 0030 1800 0018 
1801 8018 3003 C00C 3003 C00C 6001 8006 
6000 0006 C000 0003 FFFF FFFF 7FFF FFFE 
 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Bookends 12.7.8 - Reference management a...
Bookends is a full-featured bibliography/reference and information-management system for students and professionals. Bookends uses the cloud to sync reference libraries on all the Macs you use.... Read more
VirtualBox 5.1.14 - x86 virtualization s...
VirtualBox is a family of powerful x86 virtualization products for enterprise as well as home use. Not only is VirtualBox an extremely feature rich, high performance product for enterprise customers... Read more
FileZilla 3.24.0 - Fast and reliable FTP...
FileZilla (ported from Windows) is a fast and reliable FTP client and server with lots of useful features and an intuitive interface. Version 3.24.0: New The context menu for remote file search... Read more
BusyContacts 1.1.6 - Fast, efficient con...
BusyContacts is a contact manager for OS X that makes creating, finding, and managing contacts faster and more efficient. It brings to contact management the same power, flexibility, and sharing... Read more
BusyCal 3.1.4 - Powerful calendar app wi...
BusyCal is an award-winning desktop calendar that combines personal productivity features for individuals with powerful calendar sharing capabilities for families and workgroups. Its unique features... Read more
Duplicate Annihilator 5.8.3 - Find and d...
Duplicate Annihilator takes on the time-consuming task of comparing the images in your iPhoto library using effective algorithms to make sure that no duplicate escapes. Duplicate Annihilator detects... Read more
MarsEdit 3.7.10 - Quick and convenient b...
MarsEdit is a blog editor for OS X that makes editing your blog like writing email, with spell-checking, drafts, multiple windows, and even AppleScript support. It works with with most blog services... Read more
WALTR 2 2.0.9 - $39.95
WALTR 2 helps you wirelessly drag-and-drop any music, ringtones, videos, PDF, and ePub files onto your iPhone, iPad, or iPod without iTunes. It is the second major version of Softorino's critically-... Read more
Paperless 2.3.9 - $49.95
Paperless is a digital documents manager. Remember when everyone talked about how we would soon be a paperless society? Now it seems like we use paper more than ever. Let's face it - we need and we... Read more
Adobe After Effects CC 2017 14.1 - Creat...
After Effects CC 2017 is available as part of Adobe Creative Cloud for as little as $19.99/month (or $9.99/month if you're a previous After Effects customer). The new, more connected After Effects CC... Read more

Super Mario Run dashes onto Android in M...
Super Mario Run was one of the biggest mobile launches in 2016 before it was met with a lukewarm response by many. While the game itself plays a treat, it's pretty hard to swallow the steep price for the full game. With that said, Android users... | Read more »
WarFriends Beginner's Guide: How to...
Chillingo's new game, WarFriends, is finally available world wide, and so far it's a refreshing change from common mobile game trends. The game's a mix of tower defense, third person shooter, and collectible card game. There's a lot to unpack here... | Read more »
Super Gridland (Entertainment)
Super Gridland 1.0 Device: iOS Universal Category: Entertainment Price: $1.99, Version: 1.0 (iTunes) Description: Match. Build. Survive. "exquisitely tuned" - Rock Paper Shotgun No in-app purches, and no ads! | Read more »
Red's Kingdom (Games)
Red's Kingdom 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: Mad King Mac has kidnapped your father and stolen your golden nut! Solve puzzles and battle goons as you explore and battle your... | 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 »

Price Scanner via MacPrices.net

Twelve South Releases RelaxedLeather Cases fo...
Inspired by the laid-back luxury of burnished leather boots and crafted in rich tones of taupe, herb and marsala, RelaxedLeather cases deliver smart, easy protection for the iPhone 7. Each genuine... Read more
Week’s Best Deal: New 2016 13-inch 2.0GHz Mac...
Amazon has the new 2016 13″ 2.0GHz non-Touch Bar MacBook Pros on sale for a limited time for $225 off MSRP including free shipping: - 13″ 2.0GHz MacBook Pro, Space Gray (MLL42LL/A): $1274.99 $225 off... Read more
Back in stock: Apple refurbished Mac minis fr...
Apple has Certified Refurbished Mac minis available starting at $419. Apple’s one-year warranty is included with each mini, and shipping is free: - 1.4GHz Mac mini: $419 $80 off MSRP - 2.6GHz Mac... Read more
Apple Ranked ‘Most Intimate Brand’
The top ranked ‘”intimate” brands continued to outperform the S&P and Fortune 500 indices in revenue and profit over the past 10 years, according to MBLM’s Brand Intimacy 2017 Report, the largest... Read more
B-Eng introduces SSD Health Check for Mac OS
Fehraltorf, Switzerland based independant Swiss company- B-Eng has announced the release and immediate availability of SSD Health Check 1.0, the company’s new hard drive utility for Mac OS X. As the... Read more
Apple’s Education discount saves up to $300 o...
Purchase a new Mac or iPad using Apple’s Education Store and take up to $300 off MSRP. All teachers, students, and staff of any educational institution qualify for the discount. Shipping is free: -... Read more
4-core 3.7GHz Mac Pro on sale for $2290, save...
Guitar Center has the 3.7GHz 4-core Mac Pro (MD253LL/A) on sale for $2289.97 including free shipping or free local store pickup (if available). Their price is a $710 savings over standard MSRP for... Read more
128GB Apple iPad Air 2, refurbished, availabl...
Apple has Certified Refurbished 128GB iPad Air 2s WiFis available for $419 including free shipping. That’s an $80 savings over standard MSRP for this model. A standard Apple one-year warranty is... Read more
13-inch 2.7GHz Retina MacBook Pro on sale for...
B&H Photo has the 2015 13″ 2.7GHz/128GB Retina Apple MacBook Pro on sale for $100 off MSRP. Shipping is free, and B&H charges NY tax only: - 13″ 2.7GHz/128GB Retina MacBook Pro (MF839LL/A): $... Read more
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

Jobs Board

*Apple* & PC Desktop Support Technician...
Apple & PC Desktop Support Technician job in Manhattan, NY Introduction: We have immediate job openings for several Desktop Support Technicians with one of our most Read more
Senior Workstation Administrator - *Apple*...
…with extraordinary HR. QualificationsJOB SUMMARY/OVERVIEWThe Senior Workstation Administrator - Apple supports the mission of TriNet by providing advanced level Read more
Intermediate *Apple* macOS Systems Integrat...
**Position Summary:** SC3 is actively seeking an Intermediate Apple macOS systems integration administrator that will be responsible for providing Apple Mac Read more
*Apple* & PC Desktop Support Technician...
Apple & PC Desktop Support Technician job in Los Angeles, CA Introduction: We have immediate job openings for several Desktop Support Technicians with one of our Read more
*Apple* Retail - Multiple Positions - Apple,...
SalesSpecialist - Retail Customer Service and SalesTransform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.