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 
 
AAPL
$111.78
Apple Inc.
-0.87
MSFT
$47.66
Microsoft Corpora
+0.14
GOOG
$516.35
Google Inc.
+5.25

MacTech Search:
Community Search:

Software Updates via MacUpdate

calibre 2.13 - Complete e-library manage...
Calibre is a complete e-book library manager. Organize your collection, convert your books to multiple formats, and sync with all of your devices. Let Calibre be your multi-tasking digital librarian... Read more
Mellel 3.3.7 - Powerful word processor w...
Mellel is the leading word processor for OS X and has been widely considered the industry standard since its inception. Mellel focuses on writers and scholars for technical writing and multilingual... Read more
ScreenFlow 5.0.1 - Create screen recordi...
Save 10% with the exclusive MacUpdate coupon code: AFMacUpdate10 Buy now! ScreenFlow is powerful, easy-to-use screencasting software for the Mac. With ScreenFlow you can record the contents of your... Read more
Simon 4.0 - Monitor changes and crashes...
Simon monitors websites and alerts you of crashes and changes. Select pages to monitor, choose your alert options, and customize your settings. Simon does the rest. Keep a watchful eye on your... Read more
BBEdit 11.0.2 - Powerful text and HTML e...
BBEdit is the leading professional HTML and text editor for the Mac. Specifically crafted in response to the needs of Web authors and software developers, this award-winning product provides a... Read more
ExpanDrive 4.2.1 - Access cloud storage...
ExpanDrive builds cloud storage in every application, acts just like a USB drive plugged into your Mac. With ExpanDrive, you can securely access any remote file server directly from the Finder or... Read more
Adobe After Effects CC 2014 13.2 - Creat...
After Effects CC 2014 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). After Effects CS6 is still available... Read more
Evernote 6.0.5 - Create searchable notes...
Evernote allows you to easily capture information in any environment using whatever device or platform you find most convenient, and makes this information accessible and searchable at anytime, from... Read more
Command-C 1.1.7 - Clipboard sharing tool...
Command-C is a revolutionary app which makes easy to share your clipboard between iOS and OS X using your local WiFi network, even if the app is not currently opened. Copy anything (text, pictures,... Read more
Tidy Up 4.0.2 - Find duplicate files and...
Tidy Up is a complete duplicate finder and disk-tidiness utility. With Tidy Up you can search for duplicate files and packages by the owner application, content, type, creator, extension, time... Read more

Latest Forum Discussions

See All

Make your own Tribez Figures (and More)...
Make your own Tribez Figures (and More) with Toyze Posted by Jessica Fisher on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
So Many Holiday iOS Sales Oh My Goodness...
The holiday season is in full-swing, which means a whole lot of iOS apps and games are going on sale. A bunch already have, in fact. Naturally this means we’re putting together a hand-picked list of the best discounts and sales we can find in order... | Read more »
It’s Bird vs. Bird in the New PvP Mode f...
It’s Bird vs. Bird in the New PvP Mode for Angry Birds Epic Posted by Jessica Fisher on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Telltale Games and Mojang Announce Minec...
Telltale Games and Mojang Announce Minecraft: Story Mode – A Telltale Games Series Posted by Jessica Fisher on December 19th, 2014 [ permalink ] | Read more »
WarChest and Splash Damage Annouce Their...
WarChest and Splash Damage Annouce Their New Game: Tempo Posted by Jessica Fisher on December 19th, 2014 [ permalink ] WarChest Ltd and Splash Damage Ltd are teaming up again to work | Read more »
BulkyPix Celebrates its 6th Anniversary...
BulkyPix Celebrates its 6th Anniversary with a Bunch of Free Games Posted by Jessica Fisher on December 19th, 2014 [ permalink ] BulkyPix has | Read more »
Indulge in Japanese cuisine in Cooking F...
Indulge in Japanese cuisine in Cooking Fever’s new sushi-themed update Posted by Simon Reed on December 19th, 2014 [ permalink ] Lithuanian developer Nordcurrent has yet again updated its restaurant simulat | Read more »
Badland Daydream Level Pack Arrives to C...
Badland Daydream Level Pack Arrives to Celebrate 20 Million Downloads Posted by Ellis Spice on December 19th, 2014 [ permalink ] | Read more »
Far Cry 4, Assassin’s Creed Unity, Desti...
Far Cry 4, Assassin’s Creed Unity, Destiny, and Beyond – AppSpy Takes a Look at AAA Companion Apps Posted by Rob Rich on December 19th, 2014 [ permalink ] These day | Read more »
A Bunch of Halfbrick Games Are Going Fre...
A Bunch of Halfbrick Games Are Going Free for the Holidays Posted by Ellis Spice on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »

Price Scanner via MacPrices.net

The Apple Store offering free next-day shippi...
The Apple Store is now offering free next-day shipping on all in stock items if ordered before 12/23/14 at 10:00am PT. Local store pickup is also available within an hour of ordering for any in stock... Read more
It’s 1992 Again At Sony Pictures, Except For...
Techcrunch’s John Biggs interviewed a Sony Pictures Entertainment (SPE) employee, who quite understandably wished to remain anonymous, regarding post-hack conditions in SPE’s L.A office, explaining “... Read more
Holiday sales this weekend: MacBook Pros for...
 B&H Photo has new MacBook Pros on sale for up to $300 off MSRP as part of their Holiday pricing. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.2GHz Retina MacBook Pro: $1699... Read more
Holiday sales this weekend: MacBook Airs for...
B&H Photo has 2014 MacBook Airs on sale for up to $120 off MSRP, for a limited time, for the Thanksgiving/Christmas Holiday shopping season. Shipping is free, and B&H charges NY sales tax... Read more
Holiday sales this weekend: iMacs for up to $...
B&H Photo has 21″ and 27″ iMacs on sale for up to $200 off MSRP including free shipping plus NY sales tax only. B&H will also include a free copy of Parallels Desktop software: - 21″ 1.4GHz... Read more
Holiday sales this weekend: Mac minis availab...
B&H Photo has new 2014 Mac minis on sale for up to $80 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 1.4GHz Mac mini: $459 $40 off MSRP - 2.6GHz Mac mini: $629 $70 off MSRP... Read more
Holiday sales this weekend: Mac Pros for up t...
B&H Photo has Mac Pros on sale for up to $500 off MSRP. Shipping is free, and B&H charges sales tax in NY only: - 3.7GHz 4-core Mac Pro: $2599, $400 off MSRP - 3.5GHz 6-core Mac Pro: $3499, $... Read more
Save up to $400 on MacBooks with Apple Certif...
The Apple Store has Apple Certified Refurbished 2014 MacBook Pros and MacBook Airs available for up to $400 off the cost of new models. An Apple one-year warranty is included with each model, and... Read more
Save up to $300 on Macs, $30 on iPads with Ap...
Purchase a new Mac or iPad at The Apple Store for Education 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
iOS and Android OS Targeted by Man-in-the-Mid...
Cloud services security provider Akamai Technologies, Inc. has released, through the company’s Prolexic Security Engineering & Research Team (PLXsert), a new cybersecurity threat advisory. The... Read more

Jobs Board

*Apple* Store Leader Program (US) - Apple, I...
…Summary Learn and grow as you explore the art of leadership at the Apple Store. You'll master our retail business inside and out through training, hands-on experience, Read more
Project Manager, *Apple* Financial Services...
**Job Summary** Apple Financial Services (AFS) offers consumers, businesses and educational institutions ways to finance Apple purchases. We work with national and Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.