TweetFollow Us on Twitter

Apr 00 Getting Started

Volume Number: 16 (2000)
Issue Number: 4
Column Tag: Getting Started

Opening a File

by Dan Parks Sydow

How a program opens a file and displays that file's contents in a window

In past Getting Started articles we've had occasion to have our example programs open files. For instance, back in February of 1999 the SoundPlayer program opened a sound file, and a few months back, in December of 1999, our MoreQT program opened two QuickTime movie files. In both those examples our programs relied on the desired files being in the same folder as the application, and we had the applications take control of opening those files. That's not always the way it works in the real world. Your user-friendly program might offer the user the opportunity to select the file to open. This month you see how to write a program that does just that. In particular we'll examine how a program opens a text file and displays that file's text in a window. Many of the techniques you read about here apply to opening other types of files - such as sound, picture, and movie files - as well.

Windows and File Data

This article's example program opens a window that displays the text that's stored in a text file. In doing that the program opens a text file and reads the file's text to memory. The program keeps a handle to the data in memory, and associates that handle with one particular window. While the example program doesn't allow for the opening of a second window, we want to establish the foundation for a program that does. And if a program is capable of opening two, three, or thirty windows each displaying the text from a different file, we certainly want to make sure that the program displays the proper text in the proper window. This is true for a program that opens text files, but it's also true for any program that displays the contents of files in widows.

One such scheme for associating a file's contents with a particular window is to employ the use of a document record data type. This application-defined data type holds information about any one of a program's windows. While such a data type can include any number of fields, in our simple example one suffices:

typedef  struct 
{
   TEHandle   windText;
   
} WindData, *WindDataPtr, **WindDataHandle;

As you'll see ahead, a TEHandle is an Apple-defined data type that serves as a handle to editable text (with the TE standing for TextEdit). So our structure of type WindData exists to keep track of a single handle that references a block of memory that holds the text copied from a file. The above snippet also defines a pointer to such a structure (a WindDataPtr) and a handle to such a structure (a WindDataHandle). To create a new WindData structure and return a handle to it, make use of the Toolbox function NewHandleClear().

WindData	theData;

theData = (WindDataHandle)NewHandleClear( sizeof(WindData) ); 

Our WindData structure is initially empty - we'll soon remedy that by filling its one field (the windText TEHandle field) with a reference to some text. Before doing that, let's open a window:

WindowPtr	theWindow;

theWindow = GetNewWindow( 128, nil, (WindowPtr)-1L );

At this point we have memory space reserved for a WindData structure, and we have an open window - but we don't have a connection between the two. That is, there is no association between the theData data structure and the theWindow window. To do that we make a call to the Toolbox function SetWRefCon().

SetWRefCon( theWindow, (long)theData );

A WindowPtr is a pointer to a WindowRecord. One of the fields of a WindowRecord is refCon - a long that can be used to hold any four bytes of data. Programmers often use the refCon field of a window as a reference to application-defined data that pertains to that window. That's what we're doing here. Four bytes doesn't sound like much room to store data, and it's not. So these four bytes are instead used to hold a pointer (or a handle) that lead to a memory block of any size - and it's in this memory block that the application-defined window information is stored. As you ponder this concept, keep in mind two memory-related issues. First, a handle is a pointer to a pointer. That is, a handle is a type of pointer. Second, a pointer is held in four bytes of memory. The above call to SetWRefCon() accepts a WindowPtr as its first argument and any long as its second argument. By storing a reference to application-data in the second argument we wed the WindData structure to a window.

Opening a File

To this point we've created an empty data structure and associated it with a window. But we haven't opened an existing text file, brought that file's text into memory, and then created a tie between the text in memory and a window. We'll open the file now.

Your program can display the standard open file dialog box to give the user the ability to open any existing text file. A call to the Toolbox function StandardGetFilePreview() does the trick:

SFTypeList				typeList = { 'TEXT', 0, 0, 0 };
StandardFileReply	reply;

StandardGetFilePreview( nil, 1, typeList, &reply );

Before discussing the particulars of working with StandardGetFilePreview(), a quick Mac OS X note is in order. You may be familiar with the Toolbox function StandardGetFile(). That routine has a parameter list that's identical to the list for StandardGetFilePreview(). And both functions perform essentially the same task - they each display a standard open dialog box. The difference is that StandardGetFilePreview() is capable of displaying a small view of a part of a selected file. For a selected QuickTime movie, for instance, the dialog box will show a thumbnail image of the first frame of the movie. For our text file-opening example the dialog box will display the first several words in the selected text file (see Figure 3). Here's where Mac OS X comes into play. If you don't consider the display of a preview of the first bit of a text file to be of particular importance to the user, then you might consider using StandardGetFile() rather than StandardGetFilePreview(). Before making that move, consider this. StandardGetFile() won't be supported as a Carbon function for Mac OS X development, while StandardGetFilePreview() will be supported. So you'd be wise to use StandardGetFilePreview().

The first three arguments to StandardGetFilePreview() tell the File Manager which types of files to display in the dialog box. The open dialog box can readily display all types of files, or just files of up to four different types (such as text files, picture files, movie files, and so forth). If your application is capable of opening more than four different types, and you want the open dialog box to display files of each of these types (but not files of all types), you'll need to pass a pointer to a filter function as the first argument. This application-defined filter function will then serve as the means of displaying the appropriate files. If your program is capable of opening four or fewer types of files, then pass nil as the first argument to indicate that no filter function is used.

In the second argument to StandardGetFilePreview() pass the number of file types to be displayed. We'll pass 1 since it's assumed our program only works with one type of file - text files).

The third argument is of type SFTypeList. The SFTypeList variable is a list that specifies the four-character file type (surrounded in single quotes) of each of the types of files your program can work with. Fill the SFTypeList variable upon declaration, as shown above. A text file has a file type of 'TEXT', so that serves as one of the four elements in the above list. Fill the list with four values, using a 0 for each unused file type. Assuming a program is to only display text files in the open dialog box, there'll be three 0's in the list. Other common file types are 'PICT' for a picture file and 'moov' for a QuickTime movie file.

The last argument is a pointer to a variable of type StandardFileReply. When the user clicks on the Open or Cancel button in the standard open file dialog box, the StandardGetFilePreview() fills the members of the StandardFileReply structure. You'll be interested in two of the many members of this structure: sfGood and sfFile. By examining the value of sfGood your program can determine if the user clicked on the Open button (sfGood will have a value of true) or the Cancel button (sfGood will have a value of false).

if ( reply.sfGood == false )
	// handle canceling of file opening
else
	// handle opening of selected file

If the sfGood field has a value of true, your program should go on to open the selected file. An FSSpec - a file system specification - for that file is held in the sfFile field of the StandardFileReply variable filled in by StandardGetFilePreview(). Pass a pointer to this FSSpec as the first argument to the Toolbox function FSpOpenDF().

short	fileRefNum;

FSpOpenDF( &reply.sfFile, fsRdPerm, &fileRefNum );

The FSpOpenDF() function finds the requested file and opens its data fork. If a permission level of the Apple-defined constant fsRdPerm is specified, the application will only be able to read the file (a value of fsRdWrPerm can be used if your program needs to also be able to alter the file's contents). After opening the file, FSpOpenDF() returns a file reference number. It is this number that your application can then use to reference the file.

Bringing a File's Text Into Memory

With a file open, it's time to bring that file's contents into memory. The Toolbox function FSRead() will take care of that, but first we need to do a little preparatory work:

long		fileLength;
Ptr		textBuffer;

GetEOF( fileRefNum, &fileLength );
SetFPos( fileRefNum, fsFromStart, 0 );

textBuffer = NewPtr( fileLength );

GetEOF() gets the size in bytes of the contents of a file. Here we use the file reference number returned by FSpOpenDF() to tell GetEOF() which file we're interested in. SetFPos() moves the file mark - the position marker used to keep track of the current position to read from or write to - to a particular byte location in a file. The Apple-defined constant fsFromStart tells SetFPos() to count from the start of the file, while the third argument indicates how many bytes to move the file mark. Here we're moving the file mark to the very start of the file (start counting from the start of the file, fsFromStart, and then move the mark 0 bytes). The ability to move the mark isn't important to our opening a text file, but it is important in some other cases. For instance, a file of some file types (such as a file of type 'PICT') includes several bytes of header information that is unrelated to the main data in the file. When opening a picture file a program will set the file mark past this header information before reading the file's contents.

GetEOF() returned the number of bytes in the open file, and we use that value when creating a new buffer (a block of memory) in which we'll store the file's contents. The call to NewPtr() returns a pointer to the memory block. Then, it's time to read the file's contents, storing the file data in the block of memory referenced by the textBuffer pointer.

FSRead( fileRefNum, &fileLength, textBuffer );

The call to FSRead() reads in the text from the text file with the reference number fileRefNum. The data has now been stored in memory, but we want our program to be able to easily work with the text. To do that, create a text edit record. A call to TENew() creates such a record. Before creating the text edit record, set up two rectangles. The destination rectangle is the area in which text is drawn. The view rectangle is the area in which text is displayed. While the boundaries of these two rectangles are often the same, they don't have to be. If the view rectangle is inset from the destination rectangle, then when it comes time to display the edit record text in a window, some text will be clipped. Figure 1 shows a view rectangle that's smaller than a destination rectangle. Figure 2 shows a window displaying text of a text edit record that uses the rectangles from Figure 1.

Rect				destRect;
Rect				viewRect;   
TEHandle		textHandle;

SetRect( &destRect, 10, 10, 410, 270 );
viewRect = destRect;
textHandle = TENew( &destRect, &viewRect );


Figure 1.A view rectangle that's smaller than the destination rectangle.


Figure 2.Displaying text from a text edit record that uses the rectangles from Figure 1.

The above snippet creates a destination rectangle 400 pixels across and 260 pixels in height. We'll soon be placing this rectangle snuggly in a window, so giving the destination rectangle a left boundary and top boundary of 10 means that there'll be small left and top margins (as opposed to the text touching the left and top of the window in which it's displayed). The view rectangle is set to the same coordinates as the destination rectangle, and these two Rects are used in the call to TENew().

TENew() creates a new empty text edit record. A call to TESetText() fills the new record with text.

HLock( (Handle)textHandle );
	TESetText( textBuffer, fileLength, textHandle );   
HUnlock( (Handle)textHandle );

The call to TESetText() moves the text from the buffer referenced by the textBuffer pointer to the memory referenced by the TEHandle textHandle. Keeping in mind that during routine memory management the system can move memory referenced by a handle, but can't move memory referenced by a pointer, we play it safe and lock the handle. Doing that prevents the system from moving the memory referenced by textHandle while TESetText() is copying text from one area of memory to another.

Associating a File's Contents With a Window

A file is open and it's contents are held in a block of memory that's referenced by a handle (the textHandle variable). And an application-defined data structure (a WindData structure) that includes a handle as its one field (the windText field), and that is associated with a window (theWindow), is also held in memory. If we now create a tie between the handle that references the file's contents in memory (textHandle) and the handle that is a part of the application-defined data structure in memory (windText), we in effect associate the file contents with the window.

(**theData).windText = textHandle;

The above line dereferences the handle twice to allow access to the structure member windText. The windText member is of type TEHandle, as is the textHandle variable - so we can simply give one the value of the other. After the above code executes windText references the same block of memory as textHandle.

At this point our program now has a simple means of accessing the additional data associated with a window. All we need to do is follow the path from the window's refCon field to the WindData structure. To store a handle in the refCon field we called the Toolbox function SetWRefCon(). To retrieve that same handle we now call the Toolbox function GetWRefCon().

long		windRefCon;

windRefCon = GetWRefCon( theWindow );

The variable windRefCon now holds a value that is a handle to the window's WindData structure. The refCon field held this value as a long, whereas WindData is of our application-defined type WindDataHandle. So we need to typecast it to our specific type in order to make use of it.

WindDataHandle	theData;

theData = (WindDataHandle)windRefCon;

Double-dereferencing the handle makes the field of the structure accessible. If we want to access the text edit record we've associated with the window, we can assign the structure's windText field to a TEHandle variable.

TEHandle		textHandle;

textHandle = (**theData).windText;

Having a TEHandle means we can work with the text edit record the handle references. Specifically we'll want to update the text edit record. Updating the record draws the record's text to a specified port. If we make that port the window's port (as defined by the window's portRect field), the text gets drawn to the window. We'll first erase any existing window content and then draw the entire text edit record text to the window.

SetPort( theWindow );
EraseRect( &(*theWindow).portRect );
TEUpdate( &(*theWindow).portRect, textHandle );

TEUpdate() draws the text edit record's text in a rectangle bounded by the coordinates of the view rectangle and display rectangle used in the creation of the text edit record (by the call to TENew()).

OpenTextFile

This month's program is OpenTextFile. When you run OpenTextFile you'll be presented with the dialog box pictured in Figure 3.


Figure 3.The OpenTextFile dialog box with the preview section expanded.

When you click on a text file in the dialog box file list you'll see the first several words from that file displayed under the Preview heading at the left side of the open file dialog box - as shown in Figure 3. If you uncheck the Show Preview checkbox the dialog box will collapse and the preview information will disappear (see Figure 4).


Figure 4.The OpenTextFile dialog box with the preview section collapsed.

When you select a text file and click the Open button, the open file dialog box is dismissed and a new window holding the contents of the selected text file appears - as shown in Figure 5.


Figure 5.The OpenTextFile program displaying the contents of a text file.

If the selected file consists of a modest amount of text, the entire contents of the file will be displayed in the window. If the file holds a good deal of text, some of the text will be clipped at the bottom of the window. The OpenTextFile program doesn't support scrollable text (that's material for another Getting Started article!), so text that doesn't fit in the window is lost. When finished, click the mouse button to end the program.

Creating the OpenTextFile Resources

Start your resource development by creating a new folder named OpenTextFile in your main CodeWarrior folder. Launch ResEdit and create a new resource file named OpenTextFile.rsrc. Specify that the OpenTextFile folder act as the resource file's destination. This resource file will hold just three resources, two of which you've created for each of our examples: the one ALRT and one DITL. Collectively ALRT 128 and DITL 128 define the program's error-handling alert. If the OpenTextFile program encounters a serious problem while executing, then this alert appears and the program quits.

The remaining one resource is WIND 128. The placement of this window isn't critical, but you will want to make it large enough to hold the text from a small text file. If you download the project files from MacTech's ftp site at <ftp://ftp.mactech.com/src/mactech/volume16_2000/16.04.sit>, then you'll find that you have an example text file named Joyce.text. To provide a window large enough to hold all of the text from this file, use the window coordinates shown in Figure 6.


Figure 6.The OpenTextFile resources.

Creating the OpenTextFile Project

Create a new project by running CodeWarrior and choosing New Project from the File menu. Use the MacOS:C_C++:MacOS Toolbox:MacOS Toolbox Multi-Target project stationary for the new project. Uncheck the Create Folder check box, then click the OK button. Now name the project OpenTextFile.mcp and choose the existing OpenTextFile folder as the project's destination.

Add the OpenTextFile.rsrc resource file to the project and then remove the SillyBalls.rsrc file. If you want, go ahead and remove the ANSI Libraries folder - this project won't be making use of any ANSI C libraries.

Now create a new source code window by choosing New from the File menu.. Save the window, giving it the name OpenTextFile.c. Choose Add Window from the Project menu to add the new empty file to the project. Now remove the SillyBalls.c placeholder file from the project window. You're now ready to type in the source code.

If you want to save yourself some work, log on to the Internet and head to MacTech's ftp site at ftp://ftp.mactech.com/src/mactech/volume16_2000/16.04.sit. There you'll find the OpenTextFile source code file available for downloading.

Walking Through the Source Code

OpenTextFile begins with the definition of a couple of constants. The constant kALRTResID holds the ID of the ALRT resource used to define the error-handling alert. kWINDResID holds the ID of the WIND resource used to define the window that's to hold the text from a user-selected text file.

/********************* constants *********************/

#define		kALRTResID						128 
#define		kWINDResID						128

Now we define our own data structure - the WindData structure that holds supplemental window information.

/****************** data structures ******************/

typedef  struct 
{
   TEHandle   windText;
   
} WindData, *WindDataPtr, **WindDataHandle;

We'll use a global variable to keep track of the one window that the program opens.

/****************** global variables *****************/

WindowPtr  gTextWindow;

Next come the program's function prototypes.

/********************* functions *********************/

void		ToolBoxInit( void );
void		OpenExistingTextFile( void );
void		UpdateTextWindow( void );
void		DoError( Str255 errorString );

The main() function of OpenTextFile begins with the initialization of the Toolbox. After that the application-defined function OpenExistingTextFile() does just that. Just before displaying text in the window via the application-defined function UpdateTextWindow() we display the previously hidden window by calling the Toolbox function ShowWindow(). A simple while loop waits for a click of the mouse button. When that click occurs main() (and the program) ends.

/********************** main *************************/

void		main( void )
{ 
	ToolBoxInit();
      
	OpenExistingTextFile();

	ShowWindow( gTextWindow );

	UpdateTextWindow();
      
	while ( !Button() )
		;
}

The Toolbox initialization function ToolBoxInit() remains the same as previous versions.

/******************* ToolBoxInit *********************/

void  ToolBoxInit( void )
{
   InitGraf( &qd.thePort );
   InitFonts();
   InitWindows();
   InitMenus();
   TEInit();
   InitDialogs( nil );
   InitCursor();
}

The OpenExistingTextFile() function takes care of most of the tasks discussed in this article. The routine starts with a number of variable declarations.

/*************** OpenExistingTextFile ****************/

void	OpenExistingTextFile( void )
{
	SFTypeList				typeList = { 'TEXT', 0, 0, 0 };
	StandardFileReply	reply;
	short						fileRefNum;
	long							fileLength;
	Ptr							textBuffer;
	Rect							destRect;
	Rect							viewRect;   
	WindDataHandle		theData;
	TEHandle					textHandle;

StandardGetFilePreview() is called to display the standard open file dialog box. After the user dismisses the dialog box, the sfGood field of the returned reply variable is examined. If the user canceled, the program calls DoError() to quit.

	StandardGetFilePreview( nil, 1, typeList, &reply );
   
	if ( reply.sfGood == false )
		DoError( "\pError selecting a file." );

If the user didn't cancel, but instead made a selection, a new window is opened. A call to the Toolbox function SetWTitle() sets the window's title bar title to the name of the selected file. After that the window's port is made the current port to ensure that the eventual display of text occurs in this new window.

	gTextWindow = GetNewWindow( kWINDResID, nil, 
														(WindowPtr)-1L);
	if ( gTextWindow == nil )
		DoError( "\pError attempting to open a new window." );
	
	SetWTitle( gTextWindow, reply.sfFile.name );

	SetPort( gTextWindow );

Next, a new TEHandle is created. This handle will serve as a reference to the text that we'll soon be reading in from the selected file.

	SetRect( &destRect, 10, 10, 410, 270 );
	viewRect = destRect;
	textHandle = TENew( &destRect, &viewRect );

A call to FSpOpenDF() opens the selected file, and calls to GetEOF() and SetFPos() determine the file length in bytes and set the file mark to the start of the file.

	FSpOpenDF( &reply.sfFile, fsRdPerm, &fileRefNum );

	GetEOF( fileRefNum, &fileLength );
	SetFPos( fileRefNum, fsFromStart, 0 );

Now we create a file buffer - an area in memory in which we temporarily store data. Into that memory we read the contents of the user-selected file. After that we transfer the data to the text edit record by way of a call to TESetText().

	textBuffer = NewPtr( fileLength );

	FSRead( fileRefNum, &fileLength, textBuffer );

	HLock( (Handle)textHandle );
		TESetText( textBuffer, fileLength, textHandle );   
	HUnlock( (Handle)textHandle );

We've got the file's contents stored in a text edit record. Now we need to create a new structure of the application-defined type WindData and set that structure's windText field to reference the text edit record.

	theData = (WindDataHandle)NewHandleClear(sizeof(WindData));   
	(**theData).windText = textHandle;

Finally, let's set the window's refCon field to hold the handle that references the WindData data structure in memory. Then when we need to access the window information (the text edit record) for this window we'll be able to retrieve it.

	SetWRefCon( gTextWindow, (long)theData );
}

The primary use of the application-defined data structure is to hold the text that's to be displayed in a window. To display that text for the first time - and to update, or refresh, the text in the window at any time - UpdateTextWindow() is called. UpdateTextWindow() begins with the declaration of a few variables.

/***************** UpdateTextWindow ******************/

void  UpdateTextWindow( void )
{
	WindDataHandle		theData;
	long							windRefCon;
	TEHandle					textHandle;

Next we set the port to the window to update to ensure that the text we're about to display does indeed end up in the desired window.

	SetPort( gTextWindow );

A call to GetWRefCon() retrieves from the window's refCon field the handle to the window's supplemental data. Typecasting is then performed to coerce the long variable to a handle to the WindData structure.

	windRefCon = GetWRefCon( gTextWindow );
   
	theData = (WindDataHandle)windRefCon;

Now we retrieve the text edit handle and store it in the local TEHandle variable textHandle.

	textHandle = (**theData).windText;

Calls to EraseRect() and TEUpdate() clear the window and write the text from the text edit record to the window.

	EraseRect( &(*gTextWindow).portRect );
	TEUpdate( &(*gTextWindow).portRect, textHandle );
}

DoError() is unchanged from prior versions. A call to this function results in the posting of an alert that holds an error message. After the alert is dismissed the program ends.

/********************** DoError **********************/

void		DoError( Str255 errorString )
{
	ParamText( errorString, "\p", "\p", "\p" );
	
	StopAlert( kALRTResID, nil );
	
	ExitToShell();
}

Running OpenTextFile

Run OpenTextFile by choosing Run from CodeWarrior's Project menu. After the code is compiled, CodeWarrior launches the OpenTextFile program and displays the standard open file dialog box. Use this dialog box to select any text file on your local drives. If you click the Cancel button, the program will quit. If you instead select a text file, that file will be opened and its contents will be displayed in a new window. Clicking the mouse button ends the program.

Till Next Month...

We've covered a lot of ground this month. Here you saw how to create an application-defined data structure that can be used to hold any type of information, and you saw how to bind that structure with a window. You also saw how to display the standard open dialog box to give the user the power to choose a text file to open. You now know how to open a text file, copy that file's contents to memory, associate that file's text with a window, and display that same text to a window. If you'd like to know more about files, consider browsing the Files volume of Inside Macintosh. Doing that will provide you with a preview of the code you'll see next month when we delve deeper into working with files...

 
AAPL
$567.77
Apple Inc.
+43.02
MSFT
$39.86
Microsoft Corpora
+0.17
GOOG
$525.16
Google Inc.
-1.78

MacTech Search:
Community Search:

Software Updates via MacUpdate

Ember 1.5.1 - Versatile digital scrapboo...
Ember (formerly LittleSnapper) is your digital scrapbook of things that inspire you: websites, photos, apps or other things. Just drag in images that you want to keep, organize them into relevant... Read more
Cyberduck 4.4.4 - FTP and SFTP browser....
Cyberduck is a robust FTP/FTP-TLS/SFTP browser for the Mac whose lack of visual clutter and cleverly intuitive features make it easy to use. Support for external editors and system technologies such... Read more
TechTool Pro 7.0.3 - Hard drive and syst...
TechTool Pro is now 7, and this is the most advanced version of the acclaimed Macintosh troubleshooting utility created in its 20-year history. Micromat has redeveloped TechTool Pro 7 to be fully 64... Read more
MacFamilyTree 7.1.6 - Create and explore...
MacFamilyTree gives genealogy a facelift: it's modern, interactive, incredibly fast, and easy to use. We're convinced that generations of chroniclers would have loved to trade in their genealogy... Read more
EtreCheck 1.9.9 - For troubleshooting yo...
EtreCheck is a simple little app to display the important details of your system configuration and allow you to copy that information to the Clipboard. It is meant to be used with Apple Support... Read more
TeamViewer 9.0.28116 - Establish remote...
TeamViewer gives you remote control of any computer or Mac over the Internet within seconds, or can be used for online meetings. Find out why more than 200 million users trust TeamViewer! Free for... Read more
DiskAid 6.6.3 - Use your iOS device as a...
DiskAid is the ultimate transfer tool for accessing the iPod, iPhone or iPad directly from the desktop. Access data such as: music, video, photos, contacts, notes, call history, text messages (SMS),... Read more
Viber 4.1.0 - Send messages and make cal...
Viber lets you send free messages and make free calls to other Viber users, on any device and network, in any country! Viber syncs your contacts, messages and call history with your mobile device,... Read more
Apple iOS 7.1.1 - The latest version of...
The latest version of iOS can be downloaded through iTunes. Apple iOS 7 brings an all-new design and all-new features. Simplicity Simplicity is often equated with minimalism. Yet true simplicity is... Read more
1Password 4.3 - Powerful password manage...
1Password is a password manager that uniquely brings you both security and convenience. It is the only program that provides anti-phishing protection and goes beyond password management by adding Web... Read more

Latest Forum Discussions

See All

Pen & Ink Review
Pen & Ink Review By Jennifer Allen on April 24th, 2014 Our Rating: :: CONVENIENT ARTISTRYiPad Only App - Designed for the iPad Pen & Ink is an ideal way to sketch down some visual ideas or simply spark your imagination.   | Read more »
Sonic & All-Stars Racing Transformed...
Sonic & All-Stars Racing Transformed Now Free, to Add New Iconic Characters and Elements Posted by Tre Lawrence on April 24th, 2014 [ | Read more »
Soccer Rally 2 Review
Soccer Rally 2 Review By Carter Dotson on April 24th, 2014 Our Rating: :: GOALKEEPINGUniversal App - Designed for iPhone and iPad Soccer Rally 2 is the most serious vehicular soccer game ever created.   | Read more »
Galaxy Conquerors Review
Galaxy Conquerors Review By Jennifer Allen on April 24th, 2014 Our Rating: :: RETRO SHOOTINGUniversal App - Designed for iPhone and iPad Old school shooting is fun but inaccurate in Galaxy Conquerors.   | Read more »
Yomi Review
Yomi Review By Rob Thomas on April 24th, 2014 Our Rating: :: C-C-C-COMBO BREAKERiPad Only App - Designed for the iPad Round One – Fight! No quarters required for this iOS adaptation of a tabletop adaptation of the arcade fighting... | Read more »
Injustice: Gods Among Us Updated with Ne...
Injustice: Gods Among Us Updated with New Characters, Leaderboards, Gear, and Online Multiplayer Posted by Rob Rich on April 24th, 2014 [ | Read more »
Spin It Review
Spin It Review By Jordan Minor on April 24th, 2014 Our Rating: :: SPIN ME RIGHT ROUNDUniversal App - Designed for iPhone and iPad Spin It has a fine puzzle game model, but its execution lacks energy.   | Read more »
Productivity App NoteSuite is Having its...
Productivity App NoteSuite is Having its Biggest Sale Ever, Just for One Week Posted by Rob Rich on April 24th, 2014 [ permalink ] | Read more »
Wayward Souls Review
Wayward Souls Review By Carter Dotson on April 24th, 2014 Our Rating: :: CARRY ON, WAYWARD SONUniversal App - Designed for iPhone and iPad Wayward Souls is a roguelike-inspired action-RPG that sets a high bar for other games to... | Read more »
The Sandbox Gets Update, Receives New Ca...
The Sandbox Gets Update, Receives New Campaign and New Elements Posted by Tre Lawrence on April 24th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »

Price Scanner via MacPrices.net

Strong iPhone Sales Drive Apple Record March...
Apple on Wednesday announced financial results for its fiscal 2014 second quarter ended March 29, 2014. The Company posted quarterly revenue of $45.6 billion and quarterly net profit of $10.2 billion... Read more
Award-Winning NoteSuite Productivity App is $...
Minneapolis based Theory.io has announced an 80-Percent Markdown NoteSuite for iPad. NoteSuite helps users stay organized by capturing their notes, to-dos and documents in one organized place.... Read more
16GB 1st generation iPad mini available for $...
Radio Shack has a select number of refurbished 1st generation 16GB WiFi iPad minis available for $199.99 on their online store. Choose free shipping or free ship-to-store. We expect these to sell out... Read more
13-inch 2.5GHz MacBook Pro on sale for $100 o...
B&H Photo has the 13″ 2.5GHz MacBook Pro on sale for $1099 including free shipping plus NY sales tax only. Their price is $100 off MSRP. Read more
iPad Sales “Lull” A Reality Correction Of Unm...
I have lots of time for Jean-Louis Gassée, the former Apple Computer executive (1981 to 1990) who succeeded Steve Jobs as head of Macintosh development when the latter was dismissed in 1985. Mr.... Read more
Apple Makes OS X Betas Available To All – Wit...
Apple’s OS X Beta Seed Program, which lets you install the latest pre-release builds, try it out, and submit your feedback, is now open to anyone who wants to sign on rather than to developers and... Read more
Apple Releases iOS 7.1.1 Update
The latest iOS 7.1.1 update contains improvements, bug fixes and security updates, including: • Further improvements to Touch ID fingerprint recognition • Fixes a bug that could impact keyboard... Read more
Logitech Announces Thinner, Lighter, More Fle...
Logitech has announced an update to its Ultrathin for iPad Air, iPad mini and iPad mini with Retina display, improving the flexibility and design of its award-winning predecessor with an even thinner... Read more
Logitech Introduces Hinge, Big Bang and Turna...
Logitech has announced expansion of its tablet product line with three new cases – the Logitech Hinge, the Logitech Big Bang and the Logitech Turnaround – each for the iPad Air, iPad mini and iPad... Read more
WaterField’s Rough Rider Leather Messenger Ba...
WaterField Designs have announced the new 15-inch size of their popular Rough Rider leather messenger bag, a vintage-looking bag that combines Old West charm and ruggedness with distinctly modern... Read more

Jobs Board

*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Position Opening at *Apple* - Apple (United...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Inc. Research Data Specialist - Appl...
…of Worldwide Market Research & Intelligence. The team is responsible for conducting Apple branded consumer market research. It is also responsible for analyzing data Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.