Creating a typical "Hello, world!" program can show you three important parts about Mac programming.

First, you'll learn how to use Objective-C to display a message. Second, you'll learn how a Mac program can run commands based on an event that occurs. Finally, you'll start getting familiar with the basic steps and commands needed to create a program using Xcode.

To create your first real Mac program, follow these steps:

If you mistyped something or forgot a punctuation mark, such as the semicolon, Xcode will display an error message, as shown in Figure 3-2.

Figure 3-2. Xcode can alert you to errors or problems in your code.

If you did type everything correctly, Xcode will compile and run your program, displaying a window with pull-down menus at the top of the screen. In case you're wondering why you can't see the "Hello, world!" message, it's because the command you wrote prints to a special screen called the Log or Console, which does not appear on the Mac user interface. To view the log, you need to do the following:

Figure 3-3. The Debugger Console window is where the NSLog command prints its messages.

There are four lessons you should learn from this brief exercise. First, you must type Objective-C code exactly right using both uppercase and lowercase characters. If you mistype a command and use the wrong case (such as uppercase instead of lowercase, or vice versa), your program will not work. That's because Objective-C considers uppercase and lowercase characters to be completely different, so a lowercase a is as different from an uppercase A as the letter Z is completely different from the letter T. Typing Objective-C commands incorrectly is the most common source of errors.

Second, to define the end of each Objective-C line, you must use a semicolon. If you forget this semicolon, your program will not work correctly. Omitting the semicolon is another common source of errors.

Third, the NSLog command displays text to the Debugger Console window, but not to the Mac screen. The Debugger Console window often displays messages that explain what your program has done, which can be useful later when you're testing your program to make sure it's working.

Fourth, a Mac program is typically divided into subprograms that respond to different types of events. In this example, you wrote a command inside a subprogram that ran only when a certain event occurred. In this case, the event is when your program first loads and runs.

Although this may seem like a simple example, it's already taught you much about how Mac programming works using Xcode.

By using the NSLog command, you can verify that certain parts of your program are actually running. In a normal program, you would delete these NSLog commands before giving your program to others.

Of course, displaying messages to the Debugger Console window is meant for the programmer to see, not for the user of your program to see. In today's world of computers, nearly every program displays and accepts information through a graphical user interface (GUI) consisting of pull-down menus, windows, and buttons. In this exercise, you'll display "Hello, world!" on your program's user interface by modifying the project you created in the previous section of this chapter.

In this short example, you learned that Xcode stores your user interface as a .xib file, stored inside the Resources folder. To view and modify your user interface, you have to open the .xib file. Large programs may have multiple .xib files, but a simple program needs only one .xib file since it needs only one user interface.

Your user interface consists of multiple parts such as a window (for displaying information) and pull-down menus. In this example, you only modified the window portion of the user interface by clicking the Window icon that appears among other icons.

To customize your user interface, you had to open the Library window and choose to view the Object Library, which contains common user interface items such as buttons and text fields. In this example, you dragged a Label object onto the user interface window and then customized the text inside that label to display "Hello, world!"

Using a label on the user interface to display text might work, but it's a static, fixed solution. To change the text displayed, you have to modify the label on the user interface. A more flexible solution is to allow the user interface to accept and display different types of text without having to edit the user interface directly.

In this example, you'll customize the same program you edited from the previous section in this chapter, but you'll add a button that users can click. When the user clicks the button, the text in the label will change.

At this point, you've created a push button on your user interface, but it won't do anything. To make the push button work, you need to complete two additional tasks. First, you need to write a subprogram filled with instructions or code that tells the computer what to do if the user clicks that push button. In Objective-C, subprograms are called methods, so in technical terms, you have to create a push button method.

Second, you need to "connect" your method to the actual push button on your user interface. Connecting your method to your user interface push button tells Xcode to run the connected method whenever the user clicks that particular push button.

Writing Objective-C Code

The goal is to make the push button change the currently displayed text in the label. To do this, you need to write two types of Objective-C code called Actions and Outlets. An Action responds to something from the user interface, such as the user clicking a push button. An Outlet connects to a user interface item such as displaying text in a label object.

To define an Action, you'll need to write a method and fill it with Objective-C code that tells the computer what to do if the user does something. In this case, you'll be creating a method to respond when the user clicks the push button.

To make your user interface display information through an Outlet, you need to declare a variable as an Outlet. Then you'll have to define which part of your user interface is connected to that particular variable.

Creating an Action Method

There are three steps to creating an Action method:

1. Declare the name of your method.

2. Write the code that makes your method work.

3. Connect your Objective-C method to your user interface object, such as a push button.

If you peek into the Classes folder of your project, you'll see two identically named files (such as TestProgramAppDelegate.h and TestProgramAppDelegate.m). The .h file is known as a header file, and the .m file is known as the implementation file.

The header (.h) file defines all the methods and variables (called properties) that other parts of the program need to know about.

The implementation (.m) file defines all the details of your methods, which is actually hidden from the rest of your program.

So to write a method, you'll need to first declare just that method name in the header (.h) file, and then you have to write the actual method code in the implementation (.m) file.

After you've done this, you'll be ready for the third and final step of connecting your method to your user interface object, such as a push button.

To create the Action method for the push button on your user interface, follow these steps:

1. Switch to the Xcode window, and click the TestProgramAppDelegate.h file stored in the Classes folder. The Objective-C code for this file appears.

2. Type the following bold text in the existing Objective-C code:

   @interfaceTestProgramAppDelegate : NSObject<NSApplicationDelegate> {
   
   NSWindow *window;
   NSTextField *message;
   }
   
   @property (assign) IBOutletNSWindow *window;
   @property (assign) IBOutletNSTextField *message;
   
   -(IBAction)goodBye:(id)sender;
   
   @end

Here's what you just typed:

• NSTextField *message: This declares a variable called message, which can display data in the Label user interface object. (The Label user interface object is based on another object called NSTextField.)

• @property (assign) IBOutletNSTextField *message;: This defines the variable message as a property that other parts of your program can use to retrieve information out of the message variable or store information into the message variable. Note the keyword IBOutlet, which lets you know that the variable is meant for displaying information as an Outlet to a user interface object.

• -(IBAction)goodBye:(id)sender;: This declares your Action method for the push button on your user interface. The name goodBye is the name of the method and is completely arbitrary; feel free to use a name of your own choosing.

After typing these three lines of Objective-C code into the header (.h) file, you need to save this file by choosing File

1. Click the TestProgramAppDelegate.m file stored in the Classes folder. The Objective-C code for this file appears in the middle pane of the Xcode window.

2. Type the following bold text in the existing Objective-C code:

   #import "TestProgramAppDelegate.h"
   @implementation TestProgramAppDelegate
   @synthesize window;
   @synthesize message;
   
   - (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
   
       NSLog (@"Hello, world!"); // Insert code here to initialize your application
   }
    - (void)dealloc {
          [window release];
       [super dealloc];
   }
   -(IBAction)goodBye:(id)sender
   {

   message.stringValue = @"Good-bye";
   }
   
   @end

The @synthesize message; line lets your program read and save data in the message variable.

Note

In other object-oriented programming languages, you often have to write two additional methods called a setter and a getter. The setter method lets you store data in the variable, and the getter method lets you read data from the variable. To avoid making you write these two separate methods yourself, Xcode lets you use the @synthesize command, which duplicates the features of the setter and getter methods without making you write out the ugly details.

-(IBAction)goodBye:(id)sender
{
     message.stringValue = @"Good-bye";
}

This Action method (defined by the IBAction keyword) holds only a single line of code between the curly brackets. This line of code simply stores the string "Good-bye" in a message variable. The message variable is an Outlet to a user interface object, so it holds the actual string in a property called the stringValue.

Save this file by choosing File

Connecting the User Interface

At this point, all you've done is write Objective-C code in the header (.h) and implementation (.m) files. However, your user interface has no idea that all of this newly added Objective-C code even exists. To fix this problem, you'll need to "connect" your Outlets and Actions.

Connecting an Outlet to a user interface means selecting a variable name and dragging the mouse to connect a line between the variable name and a user interface object to display the data.

Connecting an Action to a user interface means selecting the name of an Action method and dragging the mouse to connect a line between the Action method name and a user interface object, such as a push button object.

To connect Actions and Outlets to your user interface, you need to follow these steps:

1. Double-click the MainMenu.xib file stored in the Resources folder in the Xcode window. The Interface Builder windows appear.

   Right-click the Test Program App Delegate blue cube icon inside the MainMenu.xib window. A heads-up display window appears, as shown in Figure 3-7.

   

   Figure 3-7. Right-clicking an icon displays a window.

2. Move the mouse pointer over the little circle that appears to the right of the message (under the Outlets heading) at the top of the window. Drag the mouse over the Label object on the user interface, and release the mouse button, as shown in Figure 3-8.

   

   Figure 3-8. Dragging from the Outlet circle to the user interface connects the message variable to the Label object.

3. Move the mouse pointer over the little circle that appears to the right of the goodBye method name (under the Received Actions heading). Drag the mouse over the push button object on the user interface, and release the mouse button, as shown in Figure 3-9.

Figure 3-9. Dragging from the Actions circle to the user interface connects the Action method to the push button object.

After you have connected your user interface to your Objective-C code (Outlets and Actions), save your program by choosing File

Then switch back to Xcode, and click the Build and Run button or choose Build

The previous sample program showed how to respond to an Action (the user clicking the push button) and how to display data through an Outlet (displaying text inside the label object). The next step in designing a user interfaces is to learn how to retrieve information from the user.

Displaying the message "Good-bye" in the label every time you click the push button isn't very flexible. Whenever you write code that has data written directly in its instructions, that's referred to as hard-coding, which means the code can only do the same thing over and over again until you change the code.

Hard-coding isn't necessarily bad, but it limits the versatility of your program. A better solution is to make your code work with any type of data. In this example, you'll be adding a text field to your user interface. When the user clicks the push button, the text from the text field will appear in the label (instead of repetitively displaying "good-bye" in the label each time).

You can complete this next sample program in several ways. First, you can draw a text field on your user interface, go back and define an Outlet for that text field in Objective-C, and then go back to your user interface and connect the text field on the user interface to the Outlet you defined in Objective-C code. Constantly switching back and forth between your user interface and your Objective-C code might seem cumbersome, so a second way is to focus on one task at a time by planning ahead.

Any time you need to either display or retrieve data, you need an Outlet so you can declare an Outlet in your Objective-C code. Then you can view your user interface, add a text field, and connect the text field to your newly created Outlet.

Either method works; it all depends on how you like to work. The three basic steps are as follows:

To create an Outlet, you need to edit the Objective-C code by following these steps:

After you declared your Outlet in both the header (.h) and implementation (.m) files, you'll need to modify your user interface.

After you have connected the text field on the user interface to your Objective-C code and saved your program, switch back to Xcode, click the Build and Run button, or choose Build

In this chapter, you learned how to create a simple "Hello, world!" program that displays text. Initially, you learned how to use the NSLog command to display text, although the NSLog command merely sends data to a special Debugger Console window, not to the program's user interface. Although you won't be using the NSLog command to interact with the user, you can use the NSLog command to help test your program.

With each succeeding version of the sample program, you gradually learned how to create and display data on your program's user interface. First, your program's user interface gets stored as a .xib file in the Resources folder. Larger, more complicated programs may have several .xib files to create a more sophisticated user interface, but this sample program just uses a single .xib file because it only needs a simple user interface.

Your user interface consists of pull-down menus and windows. To design the items that appear on the window, you need to click the Window icon to view the window in the Xcode window.

Next, you need to open the Object Library window and drag objects (such as labels, buttons, or text fields) onto the window of your user interface. Later, you'll learn how to precisely align user interface objects, but for now, you just need to know how to drag items from the Object Library window and place them on the user interface window.

To customize the appearance of some user interface objects, you can double-click the text they display. This lets you edit the existing text or replace it with new text altogether.

After designing your user interface, the last step is to link your user interface to your Objective-C code. For each object on your user interface that needs to either display data or retrieve data that the user typed in, you'll need to create an Outlet variable. For each Outlet variable, you'll need to write Objective-C code in the header (.h) file and the implementation (.m) file.

In the header (.h) file, you'll need to declare a variable and then declare a variable as an Outlet property. In the implementation (.m) file, you'll need to use the @synthesize command to allow other parts of your program to store and retrieve data from that variable.

For each user interface object that provides a command to the user, you'll need to create an Action method that contains one or more instructions that tell your program what to do when the user gives a command, such as clicking a push button. You need to declare the name of your Action method in the header (.h) file and then write the actual method code in the implementation (.m) file.

Finally, you'll need to right-click the icon that represents the files where you wrote and stored your Outlet and Action code. This displays a window that lets you drag to a user interface object and connect the user interface object to a specific Outlet or Action.

Although you created only a simple program and modified it, you can already see the basic steps needed to create any Mac program using Xcode. Mac programming is a combination of writing Objective-C code and designing your user interface.