TweetFollow Us on Twitter

XCMD Sort
Volume Number:4
Issue Number:8
Column Tag:HyperChat™

XCMD Cookbook: Sorting Routines

By Donald Koscheka, Apple Computer, Inc.

In the last two issues we covered XCMD programming basics. First we looked at the interface between Hypercard and XCMDs and then we discussed the callbacks and how they can make your XCMD programming a little easier. This month, I present an XCMD that adds a useful feature to Hypercard - the ability to sort lines in a text field.

This is a good example of XCMD programming since it extends Hypercard by adding a new feature. In addition to adding features, XCMDs are a useful way of speeding up some process that may have been written in HyperTalk. Sorting lines of text is certainly something that could be accomplished in Hypertalk. But if you have a lot of lines in the field, the Hypertalk script may be too slow. Enter the XCMD!

Before we can write the sort program, we must decide what it is we want to sort and what form the data will be presented in. Let’s define a line as a string of text that is spearated by a newline character. Next we’ll want to be able to sort both alphabetic strings and numeric strings. We need the numeric sort because strings of characters are sorted by ASCII value rather than numeric value.

Once we decide on the form and value of the data to sort, we can decide what we need to pass to the XCMD from Hypercard. Obviously, we’ll need the lines. Parameter 1 will contain a handle to the field, parameter 2 will tell the XCMD whether to sort by ASCII value (alphanumeric sort) or by numeric value (decimal sort). Parameter 3 tells the xcmd to sort in ascending or descending order. Actually LineSort only sorts in ascending (smallest to largest) order. There really is no need to sort from largest to smallest. You can simply report the lines “backwards” to get descending order. I’ve left this as an exercise to the reader since it involves little more than reversing the order of the FOR loop in two of the routines in SetNewText and SetNewNums.

When LineSort is complete, we’ll return the sorted list in the parameter block’s returnValue. By making this an XFCN we can invoke it using the follwing format:

Put LineSort( card field “my list”, alpha ) into card field “my list”

The actual process of sorting can be broken down into the following steps:

(1) LineStart: Create an array of offsets into the list marking the start of each line.

(2) SortText: Sort the list of text by comparing lines using some sorting algorithm.

(3) SetNewText: Report the sorted list back to Hypercard.

(Note: the process is identical for numeric sorting. Because the numeric sort is quite a bit simpler in implementation, we’ll concentrate this discussion on the text sort).

How we accomplish these three tasks is quite another story. Sorting lines of text is not as straightforward as sorting integers or characters since each line can be of an arbitrary length. Before performing the sort, we need to calculate where in the large chunk of text each line starts. We create an array, LineStart, that gives us an offset into the list of the start and length of each line. Consider the list:

Margaret
Colleen
Donald

The first line in the list has an offset of 0 and a length of 8. The next item in the list has an offset of 9 and a length of 7. The third item has an offset of 17 and a length of 6. If the numbers don’t seem to add up it’s because the linestart array accounts for the newline character that terminates every entry in the list!

This matter of creating a linestart array pays handsome dividends. When it comes time to sort the list, we don’t have to move the strings around in memory. Rather, we simply rearrange the linestart array to reflect the sort order. For example, the line start array for the above array looks like this before the sort:

[0,8]
[9,7]
[17,6]

and like this after the sort:

[9,7]
[17,6]
[0,8]

To report the sorted list back to hypercard now becomes a simple task. SetNewText extracts N elements from the linestart array where N is the number of elements in the array. We determine this number by dividing the size of the array by the size of one element in the array. For each element in the array, the first value in the array is the offset of the first byte in the string and the second element is the number of bytes to copy onto that line. Each line is already terminated with a newline so the process of building the output string is a simple process of concatenating the strings in the order prescribed by LineStart. If you want to perform a descending sort, build the output list starting with the last element in the array and work your way backwards, one element at a time! This is good practice for the beginner so I haven’t included the sort order part of the code.

I glossed over the actual sorting of the linestart array for two reasons. First off, it looks a lot scarier than it is. Second off, you may want to replace my sorting algorithm with one of your own. I use a Shell sort because it is one of the easier sorting methods to follow. If you’re programming in MPW “C” you should consider replacing SortText and SortNums with Apple’s QuickerSort. Greg Kimberly of Apple Computer, Inc. demonstrated an XCMD to me that uses QuickerSort. It was at least three times faster than my Shell sort implementation!

The Shell sort starts by comparing the first element in the array with every element that is at least jump elements away from the first element. If an some element is smaller than the first element, then we swap that element, and test the next one. Once no more elements can be swapped, we exit the FOR loop, decrease the jump size and start the comparison process all over again.

The ToolBox call IUMagString compares the two string elements and returns -1 if string 1 is less than string 2, 0 if they’re equal and 1 if string 1 is greater (the swap condition). IUMagString takes two string pointers and the length of each string as input. The length is easy, that’s simply the second element of each linestart array entry. We can create a pointer to each line by adding the offset element of each array entry to the starting address of the text. Since the text is referenced via a handle (passed to sortText as hField), we lock down the handle to make sure that this starting address doesn’t change on us during the sort.

The numeric sorting scheme is very similar to the alpha scheme, only easier because the size of each element is fixed at 4 bytes (the size of a longInt). If you have trouble reading the sort Text routines, try starting with the sort numeric code.

Next month: File I/O. You can take it with you!

{*************************}
{* File: LineSort.p*}
{* *}
{* Sorts lines of text (delimited by *}
{* newline and null terminated).   *}
{* Returns the sorted  container.  *}
{*-------------------------------- *}
{* In:  paramPtr=pointer to the XCMD *}
{* Parameter Block *}
{* *}
{* params[1] = handle to the text  *}
{* params[2] = handle to sort type *}
{* (ALPHA, NUMERIC)*}
{* params[3] = Sort Order *}
{* (ASCENDING, DESCENDING)*}
{* *}
{* Defaults : ALPHA, ASCENDING*}
{* Out: returnValue = handle to the*}
{* sorted data   *}
{* *}
{*-------------------------------- *}
{* © 1988, Donald Koscheka*}
{* All Rights Reserved    *}
{*-------------------------------- *}
{*************************}

(*************************
 BUILD SEQUENCE
pascal LineSort.p
link -m ENTRYPOINT -rt XFCN=65535 
 -sn Main=LineSort 
 LineSort.p.o 
 “{Libraries}”Interface.o 
 “{PLibraries}”Paslib.o 
 -o “{xcmds}”testxcmds

*************************

{$S LineSort }

UNIT Donald_Koscheka; 

{----------INTERFACE------------}

INTERFACE

USES
 MemTypes,QuickDraw,OSIntf,ToolIntf, 
 PackIntf,HyperXCmd;


PROCEDURE EntryPoint(paramPtr:XCmdPtr);

{--------IMPLEMENTATION--------}

IMPLEMENTATION

{$R-}
CONST
 NULL   = $00;
 NEWLINE= $0D;
 ALPHA  = $00;
 NUMERIC= $01;
 ASCEND = $00;
 DESCEND= $01;
 
 LESSTHAN = -1;
 EQUALTO= 0;
 GREATERTHAN= 1;
 
TYPE
 Str31  = String[31];
 
 LinePtr  = ^LineElem;  
 LineHand = ^LinePtr;
 LineElem = PACKED RECORD 
   Start: LongInt; 
   Size : LongInt; 
 END;
 
 numPtr = ^LongInt;
 numHand= ^numPtr; 

 
PROCEDURE LineSort(paramPtr:XCmdPtr);
 FORWARD;

{------------EntryPoint------------}

PROCEDURE EntryPoint(paramPtr: XCmdPtr);
 BEGIN
 LineSort(paramPtr);
 END;

{----------LineSort----------------}

PROCEDURE LineSort(paramPtr:XCmdPtr);
(*************************
* Main code segment  follows
*************************)
VAR
 SortType : INTEGER;
 SortOrder: INTEGER;
 LineStart: LineHand;
 hNums  : numHand;
 NewField : Handle;
 SortStr: Str255;
 
{$I XCmdGlue.inc }


(************************)
(***  Alpha Sorting Routines***)
(************************)


FUNCTION GetLineStarts(hField:Handle)
 : LineHand;
(**************************
* Given a pointer to a block of text,
* scan for line-terminators (NEWLINE
* | NULL) and  fill out a dynamically
* allocated array of line starts 
* information.
* 
* The line starts array contains 
* the offset in the text to the start
* of the line as well  as the length
* of the line in bytes.  
*
* Offsets are used to allow the record
* to remain valid across relocation 
* of the basic text.
*
* In: Pointer to a block of text,
* null terminated.
*
* Out: Handle to an array of
* linestart indices.
*
*************************)
VAR
 done   : BOOLEAN;
 arraySize: LongInt;
 startText: LongInt; { Base pointer of the text }
 sizeText : LongInt;    { length of the current run}
 lineStart: LineHand;   { array of lineStarts pointers}
 txStart: Ptr;   { pointer to the input text}
 txPtr  : Ptr;   { pointer into input text (FIELD)}
 lineArray: LinePtr; { Pointer into lineStart array }
 
BEGIN
 IF (hField<>NIL)AND(hField^^<>NULL)THEN
 BEGIN
 HLock( hField );
 txPtr  := hField^;
 startText := ORD( txPtr );
 lineStart := LineHand(NewHandle(0));
 done := FALSE;
 
 WHILE NOT done DO
 BEGIN
 txStart := txPtr;
 ScanToReturn( txPtr );
 
 IF txPtr^ = NULL THEN
 BEGIN
 txPtr^ := NEWLINE;
 done   := TRUE;
 END;
 
 txPtr := Pointer( ORD(txPtr) + 1);
 sizeText := ORD(txPtr)-ORD(txStart);
 
 IF sizeText > 1 THEN
 BEGIN
 {*** point to next record in linestarts array ***}
 arraySize := GetHandleSize( Handle(LineStart) );
 SetHandleSize( Handle(LineStart), 
 arraySize + sizeOf( lineElem ));
 lineArray := Pointer( ORD(lineStart^) + arraySize );
 
 {*** Put away offset and length of line ***}
 WITH lineArray^ DO 
 BEGIN
 Start:= ORD(txStart) - startText;
 Size := SizeText;
 END;
 END;
 END; {*** While ***}
 
 HUnlock( hField );
 END;
 GetLineStarts := lineStart;
END;


PROCEDURE  SortText( hField:Handle );
(************************
* Given a handle to an run of text, 
* sort the lines of text pointed to and 
* rearrange the array accordingly.
*
* Text is sorted by rearranging the line
* starts array.
*
* In:   Pointer to  array of linestarts
*linestarts, linecount (global)
* Out:  sorted array of linestarts.
************************)
VAR
 done   : BOOLEAN;
 jump,len1,len2: INTEGER;
 n,m,lineCount : LongInt;
 str1, str2 : Ptr;
 tempElem : LineElem;
 elem1, elem2  : LinePtr;

BEGIN
 LineCount:= GetHandleSize( Handle(lineStart) );
 LineCount:= LineCount DIV sizeOf( LineElem );
 
 jump := lineCount;
 HLock( Handle(lineStart) );
 HLock( hField );
 
 WHILE jump > 1 DO
 BEGIN
 jump := jump DIV 2;
 REPEAT
 done := TRUE;
 FOR m := 0 to ( lineCount - jump - 1 ) DO
 BEGIN
 n := m + jump;
 
 {*** Calculate the offsets of the two elements ***}
 elem1 := LinePtr( ORD(LineStart^) + 
 (n * sizeof( LineElem )) );
 
 str1 := Pointer( ORD( hField^ ) + elem1^.Start) ;
 len1:= INTEGER( elem1^.Size );
 
 elem2  := LinePtr( ORD(LineStart^)  +
  (m * sizeof( LineElem )) );

 str2   := Pointer( ORD( hField^ ) + 
 elem2^.Start) ;
 len2 := INTEGER( elem2^.Size );
 
 IF IUMagString( str2, str1, len2, len1 ) 
 = GREATERTHAN THEN
 BEGIN
 tempElem.Start  := elem1^.Start;
 tempElem.Size := elem1^.Size;
 elem1^.Start  := elem2^.Start;
 elem1^.Size:= elem2^.Size;
 elem2^.Start  := tempElem.Start;
 elem2^.Size:= tempElem.Size;
 done := FALSE;
 END;
 END; {*** FOR loop ***}
 UNTIL done;
 END; {*** WHILE jump > 1 ***}
 
 HUnlock( Handle(lineStart) );
 HUnlock( hField );
END;


FUNCTION SetNewText( hField: Handle; 
 Dir : INTEGER ): Handle;
(*****************************
* Given a pointer to a linestarts array, and
* a corresponding block of text, rearrange
* the text to match the line starts in the 
* array.  This is useful after doing a search
* since the linestarts array will be in order
* but the text won’t be.
*
* return a run of null-terminated text 
* with each line NEWLINE-terminated.
*
* In:   Handle to text array
*Handle to linestarts array.
*
* Out: Handle lines of newline terminated text.
****************************)
VAR
 LineNum,
 LineCount,
 oldSize: LongInt;
 NewText: Handle;
 StartOfLine: Ptr;
 NextLine : LinePtr;
 
BEGIN 
 LineCount:= GetHandleSize( Handle(lineStart) );
 LineCount:= LineCount DIV sizeOf( LineElem );
 
 NewText:= NewHandle( 0 );

 FOR LineNum := 0 to LineCount-1  DO
 BEGIN
 NextLine := LinePtr( ORD( LineStart^ ) +
  (LineNum * sizeOf( LineElem )) );
 StartOfLine := Pointer( ORD( hField^ ) +
  NextLine^.Start );
 
{*** add length of new line to output text ***}
 oldSize := GetHandleSize( NewText );
 SetHandleSize( NewText, oldSize + NextLine^.Size );
 
 {*** move the line into the array ***}
 BlockMove( StartOfLine, Pointer( ORD( NewText^ ) + oldSize), NextLine^.Size 
);
 END;
 
 {*** Tack a NULL on the end of the new text ***}
 oldSize  := GetHandleSize( newText );
 SetHandleSize( newText, oldSize + 1 );
 StartOfLine   := Pointer( ORD( newText^ ) + oldSize );
 StartOfLine^  := NULL;
 SetNewText := NewText;
END;



(***************************)
(***  Number Sorting Routines ***)
(***************************)


FUNCTION  GetNums( hField : Handle ): numHand;
(***************************
* Given a handle to a block of text, scan
* for line-terminators (NEWLINE | NULL) and
* fill out a dynamically allocated array of
* long integers, one for each line.
*
* Out: Handle to an array of longInt.
*
***************************)
VAR
 done   : BOOLEAN;
 arraySize,
 theNum : LongInt;
 txStart: Ptr;
 txPtr  : Ptr;   
 numArray : numPtr;
 hNum   : NumHand; 
 tStr   : Str255;
 
BEGIN
 IF ( hField <> NIL ) AND ( hField^^ <> NULL ) THEN
 BEGIN
 HLock( hField );
 txPtr  := hField^;
 hNum   := NumHand( NewHandle( 0 ) );
 done := FALSE;
 
 WHILE NOT done DO
 BEGIN
 txStart := txPtr;
 ScanToReturn( txPtr );
 
 IF txPtr^ = NULL THEN
 done := TRUE
 ELSE
 txPtr^ := NULL;
 
 ZeroToPas( txStart, tStr );
 theNum := StrToNum( tStr );
 txPtr  := Pointer( ORD(txPtr) + 1);
 
 arraySize := GetHandleSize( Handle( hNum ) );
 SetHandleSize( Handle( hNum ), arraySize + sizeOf( longInt ));
 numArray := Pointer( ORD( hNum^) + arraySize );
 numArray^:= theNum;
 
 END; {*** While ***}
 HUnlock( hField );
 END;
 GetNums := hNum;
END;

PROCEDURE  SortNums( theNums : NumHand );
(*********************
* Given a pointer to an array of longints, 
* sort the numbers  and rearrange the array
* accordingly.
*
* In:   Handle to an array of longInts;
*  uses linecount and lineNum;
* Out:  sorted array of linestarts.
********************)
VAR
 done   : BOOLEAN;
 jump,len1,len2  : INTEGER;
 n,m  ,swap,
 lineCount: LongInt;
 num1,num2: numPtr;

BEGIN
 LineCount := GetHandleSize( Handle(theNums) ) DIV sizeOf( LongInt );
 jump := lineCount;
 
 WHILE jump > 1 DO
 BEGIN
 jump := jump DIV 2;
 REPEAT
 done := TRUE;
 FOR m := 0 to ( lineCount - jump - 1 ) DO
 BEGIN
 n := m + jump;
 
 {*** Calculate the offsets of the two elements ***}
 num1 := Pointer(ORD(theNums^) + (n * sizeof( LongInt )) );
 num2   := Pointer(ORD(theNums^) + (m * sizeof( LongInt )) );

 IF num2^ > num1^ THEN
 BEGIN
 swap := num1^;
 num1^:= num2^;
 num2^:= swap;
 done := FALSE;
 END;
 END; {*** FOR loop ***}
 UNTIL done;
 END; {*** WHILE jump > 1 ***}
END;


FUNCTION SetNewNums( hNum: numHand; Dir : INTEGER ): Handle;
(********************
* Given a handle to an array of 
* longints, convert  them back to 
* strings and put them away in
*  a new handle as text
*
* In:   Handle to num array
*
* Out: Handle lines of newline 
* terminated text.
*********************)
VAR
 index, intCount,
 oldSize, numLen : LongInt;
 nexNum : NumPtr;
 NewText: Handle;
 tempPtr: Ptr;
 tempStr: Str255;
 
BEGIN 
 NewText:= NewHandle( 0 );
 intCount := (GetHandleSize( Handle(hNum) ) DIV sizeOf( LongInt ));
 
 FOR index := 0 to intCount-1  DO
 BEGIN
 nexNum := NumPtr( ORD( hNum^ ) +
  (index * sizeOf( LongInt )) );
 tempStr := NumToStr( nexNum^ );
 numLen  := LongInt( ORD( tempStr[0] ) );
 
 {*** add length of new line to output text  ***}
 oldSize := GetHandleSize( NewText );
 SetHandleSize( NewText, oldSize + NumLen + 1 );
 
 {*** move the line into the array ***}
 TempPtr := Pointer( ORD( @tempStr ) + 1 );
 BlockMove( TempPtr , Pointer(ORD( NewText^)+ oldSize),NumLen);
 TempPtr := Pointer(ORD( NewText^) + oldSize + NumLen);
 TempPtr^ := NEWLINE;
 END;
 
 {*** Tack a NULL on the end of the new text ***}
 oldSize  := GetHandleSize( newText );
 SetHandleSize( newText, oldSize + 1 );
 tempPtr  := Pointer( ORD( newText^ ) + oldSize );
 TempPtr^ := NULL;
 SetNewNums := NewText;
END;


{******* Main Block for LineSort *******}
BEGIN
 NewField := NIL;
 
 WITH paramPtr^ DO
 IF (params[1] <> NIL) AND (params[1]^^ <> NULL) THEN
 BEGIN
 SortType := ALPHA;
 SortOrder := ASCEND;
 
 IF params[2] <> NIL THEN
 BEGIN
 ZeroToPas( params[2]^, sortStr );
 IF StringEqual(‘NUMERIC’, sortStr)  THEN 
 SortType := NUMERIC;
 END;
 
 IF params[3] <> NIL THEN
 BEGIN
 ZeroToPas( params[3]^, sortStr );
 IF StringEqual(‘DESCENDING’, sortStr )  THEN 
 SortOrder := DESCEND;
 END;
 
 CASE SortType OF
 ALPHA:
 BEGIN
 LineStart := GetLineStarts( params[1] );
 SortText( params[1] );
 newField := SetNewText( params[1], SortOrder );
 DisposHandle( Handle( LineStart ) );
 END;
 
 NUMERIC:
 BEGIN
 hNums := GetNums( params[1] );
 SortNums( hNums );
 newField := SetNewNums( hNums, SortOrder );
 DisposHandle( Handle( hNums ) );
 END;   
 END; {*** CASE SortOrder OF ***}
 END; 
 
 paramPtr^.returnValue := newField;
END; 
END.
 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Bean 3.3.1 - Fast and uncluttered word p...
Bean is no longer being actively developed, but will be updated as necessary to patch bugs and maintain OS X compatibility Bean is lean, fast, and uncluttered. If you get depressed at the thought... Read more
RetroArch 1.9.0 - Game emulator.
RetroArch is most popularly known for being a program with which you can play many emulators and games, which have all been customized and tailor-ported to the libretro API. It is designed to be fast... Read more
NetNewsWire 5.0.4 - RSS and Atom news re...
NetNewsWire is the best way to keep up with the sites and authors you read most regularly. Let NetNewsWire pull down the latest articles, and read them in a distraction-free and Mac-like way. Native... Read more
EarthDesk 7.4.5 - $24.99
EarthDesk replaces your static desktop picture with a rendered image of Earth showing correct sun, moon, and city illumination. With an Internet connection, EarthDesk displays near-real-time global... Read more
BetterTouchTool 3.401 - Customize multi-...
BetterTouchTool adds many new, fully customizable gestures to the Magic Mouse, Multi-Touch MacBook trackpad, and Magic Trackpad. These gestures are customizable: Magic Mouse: Pinch in / out (zoom)... Read more
Vienna 3.5.6 :e12c952d: - RSS and Atom n...
Vienna is a freeware and Open-Source RSS/Atom newsreader with article storage and management via a SQLite database, written in Objective-C and Cocoa, for the OS X operating system. It provides... Read more
WhatsApp 2.2031.5 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more
Day One 4.16 - Maintain a daily journal.
Day One is an easy, great-looking way to use a journal / diary / text-logging application. Day One is well designed and extremely focused to encourage you to write more through quick Menu Bar entry,... Read more
VMware Fusion 11.5.6 - Run Windows apps...
VMware Fusion and Fusion Pro - virtualization software for running Windows, Linux, and other systems on a Mac without rebooting. The latest version includes full support for Windows 10, macOS Mojave... Read more
Alfred 4.1 - Quick launcher for apps and...
Alfred is an award-winning productivity application for OS X. Alfred saves you time when you search for files online or on your Mac. Be more productive with hotkeys, keywords, and file actions at... Read more

Latest Forum Discussions

See All

Motorball is a car football game from No...
A few years back Noodlecake Studios announced that they would be dipping in the multiplayer gaming realm with two different games. The first of those, Golf Blitz, released a while back and has proven to be very popular. Now, the second has arrived... | Read more »
SINoALICE's latest update introduce...
SINoALICE's latest update has now arrived, adding several fan-favourite characters from popular RPG series NieR. Young Nier, Kaine, and Young Emil are available in-game as part of a limited-time crossover event set to run until August 20th. [Read... | Read more »
Rocat Jumpurr is an intense roguelite pl...
Rocat Jumpurr is a roguelite platformer from developer Mousetrap Games. You might already be familiar with it if you follow the Big Indie Pitch, where it won first place during this year's Pocket Gamer Connects London competition. Following its... | Read more »
PUBG Mobile's Play As One campaign...
Back in mid-July, we reported that PUGB Mobile had teamed up with Direct Relief to help raise money for the charity's COVID-19 response project. It focused on an in-game running challenge for players, which lead to the PUBG Mobile donating $2... | Read more »
Marvel Contest of Champions' latest...
Marvel Contest of Champions' latest motion comic has arrived, and it shows off new fighters Air-Walker and Dragon Man. Both characters are set to arrive in-game this month. [Read more] | Read more »
Clash Royale: The Road to Legendary Aren...
Supercell recently celebrated its 10th anniversary and their best title, Clash Royale, is as good as it's ever been. Even for lapsed players, returning to the game is as easy as can be. If you want to join us in picking the game back up, we've put... | Read more »
Global Spy is an intriguing 2D spy sim f...
Developer Yuyosoft Innovations' Global Spy launched last month for iOS and Android, though if you missed it at the time, we're here to tell you why it's well worth a go. This one's all about international espionage, tracking down elusive spies,... | Read more »
Distract Yourself With These Great Mobil...
There’s a lot going on right now, and I don’t really feel like trying to write some kind of pithy intro for it. All I’ll say is lots of people have been coming together and helping each other in small ways, and I’m choosing to focus on that as I... | Read more »
Hyena Squad is sci-fi turn-based strateg...
Wave Light Games has just revealed its latest release, Hyena Squad, a turn-based RPG set in a space station infested by gross aliens and the living dead. The announcement was first reported on by Touch Arcade. [Read more] | Read more »
Idle Guardians: Never Die is a pixel art...
SuperPlanet has been fairly prolific with game releases so far this year with both Evil Hunter Tycoon and Lucid Adventure releasing earlier this year. Now, they've released another idle RPG called Idle Guardians: Never Die, which you can download... | Read more »

Price Scanner via MacPrices.net

Sale! Apple’s 16″ MacBook Pros for up to $349...
Apple Authorized Reseller Adorama has new 2019 16″ MacBook Pros in stock on sale today for $100-$349 off Apple’s MSRP, each including free shipping. Their prices for 8-core models ($349 off) are the... Read more
Save hundreds of dollars on a custom-configur...
Save up to $920 on a custom-configured 16″ MacBook Pro with these Certified Refurbished models that Apple has restocked today. Each MacBook Pro features a new outer case, free shipping, and includes... Read more
New 2020 12.9″ iPad Pros on sale for up to $8...
Apple reseller Expercom has new 2020 Apple 12.9″ iPad Pros on sale today for $60-$85 off MSRP, with prices starting at $939. These are the same iPad Pros sold by Apple in their retail and online... Read more
Woot offers numerous 2018-2020 MacBook Pros a...
Amazon-owned Woot has many open-box return MacBook Airs and MacBook Pros available today at prices starting at $879. Shipping is free for Prime members. Here’s what they have as of this post, and... Read more
Apple restocks refurbished 2020 13″ MacBook A...
Apple has restocked Certified Refurbished 2020 13″ MacBook Airs starting at only $849 and up to $200 off the cost of new Airs. Each MacBook features a new outer case, comes with a standard Apple one-... Read more
Apple restocks clearance 2019 13″ 2.4GHz MacB...
Apple has restocked Certified Refurbished 2019 13″ 2.4GHz 4-Core Touch Bar MacBook Pros starting at $1359 and up to $560 off original MSRP. Apple’s one-year warranty is included, shipping is free,... Read more
Apple restocks refurbished iPhone XR models s...
Apple has restocked Certified Refurbished, unlocked, iPhone XR models in the refurbished section of their online store starting at $539. Each iPhone comes with Apple’s standard one-year warranty,... Read more
Price drops! $100-$200 off clearance 27″ 5K i...
B&H Photo has dropped prices on clearance, previous-generation 27″ 5K iMacs by up to $200 off Apple’s original MSRP: – 27″ 3.0GHz 6-Core 5K iMac: $1699 $100 off original MSRP – 27″ 3.1GHz 6-Core... Read more
Woot offers Apple Watch and iPhone models fro...
Amazon-owned Woot has refurbished Apple Watch and iPhone models available from $99-$749 through August 6th. According to Woot, the items may show some wear, but they have all been fully tested and... Read more
Apple’s Phil Schiller Steps Down As SVP OF Wo...
NEWS: 08.05.20 – Former Apple senior Vice President of worldwide marketing, Phil Schiller, is stepping down from his long time role at the company in order to focus on spending more time with family... Read more

Jobs Board

Cub Foods - *Apple* Valley - Now Hiring Par...
Cub Foods - Apple Valley - Now Hiring Part Time! United States of America, Minnesota, Apple Valley New Retail Post Date 5 days ago Requisition # 122305 Sign Up Read more
Blue *Apple* Cafe Student Worker - Fall - P...
…to enhance your work experience. Student positions are available at the Blue Apple Cafe. Employee meal discount during working hours is provided. Duties include food Read more
Cub Foods - *Apple* Valley - Now Hiring Par...
Cub Foods - Apple Valley - Now Hiring Part Time! United States of America, Minnesota, Apple Valley New Retail Post Date 4 days ago Requisition # 122305 Sign Up Read more
Cub Foods - *Apple* Valley - Now Hiring Par...
Cub Foods - Apple Valley - Now Hiring Part Time! United States of America, Minnesota, Apple Valley New Retail Post Date 3 days ago Requisition # 122305 Sign Up Read more
Executive Team Leader GM Sales (Assistant Man...
…(Assistant Manager General Merchandise and Operations) - Apple Valley, CaliforniaApply NowJob ID:R0000082364job family:Store Managementschedule:Full Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.