Create project in Xcode using single window application template and name it as MapViewSample. Before proceeding further we need to add mapKit and coreLocation frameworks to the application bundle. I am not digging into the details of adding the frameworks into the project because it is quite common in all applications. Now open ViewController.xib file, add a map view outlet and connect it with the associated outlet in .h file. Open ViewController.h file, import MapKit framework into it and also modify it as follows.

Now compile and run the code, you will get the following screenshot.

To make the round shaped corners for the map view we need to import the QuartzCore/CALayer.h header in ViewController.m file and also add the following code in viewDidLoad method of this class to get the desired effect.

Now run the code to see the proper corner radius effect. To add the annotations to this map view, we need to take a new class with subclass of NSObject and name it as MapAnnotation. Open MapAnnotation.h file and change it according to the following code.

Now open MapAnnotation.m file and include the below code.

Now import the MapAnnotation class in ViewController.m file, add the initiateStaticAnnotations method in it and call this method from viewDidLoad method of this class. Implement initiateStaticAnnotations method in the following way.

In this method I have taken 4 locations/annotations. To show these annotations in the respected places, we need to implement map view delegate method for annotations in the ViewController.m as follows.

Now build and run the code, you will see the two annotations. After tapping on one annotation you will get the following screen. Drag the map view to the left side to see the remaining two annotations and its views.

1. Create a new observer to listen for the notification (event) to happen.
2. Post the notification when our event happens.
3. Remove the observer when we no longer need it.

From apple documentation, NSNotification objects encapsulate information so that it can be broadcast to other objects by an NSNotificationCenter object. An NSNotification object (referred to as a notification) contains a name, an object, and an optional dictionary. The name is a tag identifying the notification. The object is any object that the poster of the notification wants to send to observers of that notification (typically, it is the object that posted the notification). The dictionary stores other related objects, if any. NSNotification objects are immutable objects.

NSNotificationCenter object (or simply, notification centre) provides a mechanism for broadcasting information within a program. An NSNotificationCenter object is essentially a notification dispatch table. Objects register with a notification centre to receive notifications (NSNotification objects) using the addObserver:selector:name:object: or addObserverForName:object:queue:usingBlock: methods. Each invocation of this method specifies a set of notifications. Therefore, objects may register as observers of different notification sets by calling these methods several times.

Each running Cocoa program has a default notification centre. You typically don’t create your own. An NSNotificationCenter object can deliver notifications only within a single program. If you want to post a notification to other processes or receive notifications from other processes, use an instance of NSDistributedNotificationCenter. We can create a notification object with either of the following class methods

Here first method Returns a new notification object with a specified name and object. Name is the new notification name and object is the object for new notification. And the second method returns a notification object with a specified name, object, and user information. The user information dictionary for the new notification. May be nil. However, you don’t usually create your own notifications directly. The NSNotificationCenter methods will take care of that. Following methods explain the basis of observing the notification.

As per the documentation this method adds an entry to the receiver’s dispatch table with an observer, a notification selector and optional criteria: notification name and sender. Second method adds an entry to the receiver’s dispatch table with a notification queue and a block to add to the queue, and optional criteria: notification name and sender. The parameter “block” will be executed when notification is successfully posted. If a given notification triggers more than one observer block, the blocks may all be executed concurrently with respect to one another (but on their given queue or on the current thread).The following example shows how you can register to receive locale change notifications.

I will explain the above methods with the help of example. First Launch Xcode and click File > New > Project. Select an iOS Single View Application and click “Next”. Name your product “Notifications” and enter a name for your Company Identifier, such as “com.companyName.notifications.” Choose the iPhone device family and click “Next.” Choose a location to store your project and click “Create.” Open ViewController.h file, modify it as follows.

In the same way change the ViewController.m file as follows.

There are four important parts of the NSNotificationCenter method addObserver:selector:name:object:. The argument for addObserver: is the object that wants to know when a certain notification happens. The argument for selector: is the method that gets called when the notification happens. The argument for name: is the title of the notification the observer wants to know about; it must be unique. The final piece of the method is object:. Its argument is the object attached to the notification and is often nil depending on the context of the notification.

There are three important parts of the NSNotificationCenter method postNotificationName:object:userInfo:. The argument for postNotificationName: is the title of the notification that was registered in the previous addObserver:selector:name:object: method. The argument for object:, again, is the object posting the notification and in this case is nil. The argument foruserInfo is an NSDictionary that can be used to send additional information with the notification.userInfo can be nil, but in this instance we want to know the orientation of the device. In order to send it with the notification the information is packaged inside a dictionary. Now compile and run the code, the UIButton will hide after tapping on it, because button hide notification will fire.

Start Xcode, select “Create a new Xcode project,” and click Next. Choose the Empty Application template, click Next, and name the project TabBar. Select options as shown here:

Click Next, choose a location to save the project, and click Create.

Once the project has been created, add two images to the project using any available drawing software. I’ve created these images using Gimp (a free vector drawing application). These images should be 30 x 30 pixels, and for best effect should be drawn in black on a transparent background. You can either create your own or use these:

When you save these images, rename them first.png and second.png. If you are using some other format than .png for your images, make sure to adjust the extension in the code.

Add two new UIViewController classes to the project by selecting File | New > File… Name them FirstViewController and SecondViewController; make sure that they both are subclasses of UIViewController, and allow .xib files to be created for both as shown:

Open the .xib files for these view controllers, and drag a UINavigationBar to the top of each. Title the first bar “First View” and the second “Second View.” This step is not strictly necessary, but will give a nice title to each of our view controllers.

Now open the AppDelegate.h file, and add two properties for the view controllers, as well as one for the UITabBarController as shown:

All the set up for the application will be done in the AppDelegate.m file, in the application: didFinishLaunchingWithOptions: method. Here is the listing:

After synthesizing the properties we just created, we first instantiate the two view controllers, each with a nib name of nil (meaning to use the .xib file we created for each controller), and a bundle of nil (meaning to use this application’s bundle). A title is set for each view controller; this title will appear in the tab (in the tab bar) for each controller. Next, we set the image for each controller as it will appear on the tab bar. These are the images we created earlier; make sure that they have been added to the project.

Now that the view controllers are instantiated, with titles and images for each, we need a tab bar controller to put them on. We instantiate one, then add the view controllers to the UITabBarController’s viewControllers array, using the class method arrayWithObjects (from NSArray). Finally, we add the tab bar’s view to the main application window as a subview and make the main window key and visible.

Here is the application running:

Notice that iOS has taken the black on transparent images we provided and applied color to them in a stylistic manner.

UITabBarController should always be used as the top level controller for an application. A view controller inside a tab bar can be of any type, even a navigation controller. But we should not place a tab bar controller inside a navigation controller. This is because tab bars are meant to be on the screen (for access by the user) throughout the life of the application.

Here we have converted the content of web_text.txt into NSString using initWithContentsOfFile method. Now compile and run the code, web_text.txt file loaded into text view as follows.

Don’t hit Web view bar button because we have not implemented the corresponding action method. Our requirement is to populate the HTML content of web_text.txt into web view using UIWebView outlet in some other controller. Add the new controller named WebViewController by right clicking on project file and select new file option.

Open WebViewController.xib file, add UIWebView outlet and connect it with the corresponding object in WebViewController class. WebViewController.h file will look like this.

Add the following line of code in initWithNibName method of WebViewController.m file.

Now it is require to load web view with HTML text from web_text.txt file. This can be done by adding the following code.

Now we need to connect WebViewController with ViewController class. For that add the following code at the end of ViewController.m file.

Build and run the code, observe that the same text you will see in text view will populate in web view with different colour and fonts after tapping web view button.

Create a new project in Xcode using single view application template and name it as ToolbarAnimation. Now open ViewController.xib file, add UILable, UITextfield and UIToolbar outlets and also connect them with the associated objects in ViewController class. .xib file look like this

Build and run the code you will see the following screens.

Observe that, tool bar is at the bottom of the screen. Once you tapped on text field we need the tool bar to be animated with the keyboard. Here second screenshot is not showing the desired result. For this we need to register the controller with two keyboard notifications UIKeyboardWillShowNotification, UIKeyboardWillHideNotification. Before continue with notifications, we need to learn some basic things about NSNotificationCenter. As per the documentation, an NSNotificationCenter object (or simply, notification center) provides a mechanism for broadcasting information within a program. An NSNotificationCenter object is essentially a notification dispatch table. To register an object with a notification center to receive notifications we need to call addObserver:selector:name:object method. Open viewDidLoad method of ViewController.m file and register the notifications as follows.

For selector parameter we have given two selector names as keyboardWillShow: and keyboardWillHide: these selectors specifies the message the receiver sends notificationObserver to notify it of the notification posting. Hence we need to implement these two selectors such that they can perform a particular task when a notification is posted. Here when keyboard will show notification is posted, we want the tool bar to be animated on top of keyboard. This can be achieved by adding following code.

The above code establishes the synchronization between keyboard and tool bar. We can write the same code to implement the keyboardWillHide method except tool bar frame. i,e Copy the same code with the following tool bar frame.

Now add the following action method at the end of .m file and connect it with dismiss button placed in tool bar item.

Now build and run the code you will see the tool bar animation along with the keyboard. If you tap on dismiss button then tool bar will again animate along with keyboard hide animation.

If these settings do not allow the control that you need, the only other option is to change the view controller (and the view) when the orientation of the device changes. In this blog, we’ll show you how to do this. Let’s get started!

Start Xcode, select “Create a new Xcode project,” then choose the Empty Application template. Click Next, name the project “Orientation,” and choose options as shown:

Click Next, choose a location to save the project, and then click Create.

The first thing we will need to do is add a UIViewController (with a corresponding .xib). This will become the view controller for the Portrait orientation. We will then add another view controller for landscape orientation.

To add these view controllers, select File | New > File… from the menu, select the Objective – C class template, and make sure the “Subclass Of” box reads “UIViewController.” Name the first view controller “PortraitViewController” and the second “LandscapeViewController,” and for each, create a nib file for the user interface. Save each in the default location. When you are finished, the navigator should look like this:

Open PortraitViewController.xib and delete the view. Drag a new UIView object to the screen, open the Size Inspector panel and set the height of the view to 480 as shown:

(This is necessary because we cannot change the height of a template generated top level view.) Right – click the File’s Owner object, and drag from the circle to the right of the view object to the new View just created. Change the color of the view, and drag a label to the view, changing its text to “Portrait.”

In the LandscapeViewController.xib file, first delete the view as above, then drag a new UIView object to the screen. In the size inspector, change the width to 480 and the height to 320. Give this view a different background color than the portrait View, drag a label to the view, and change its text to “Landscape.” Remember to bind the new view to the view object in the File’s Owner as we did for the PortraitViewController. When finished, the two views should look like this:

Open LandscapeViewController.m and make this change to the shouldAutorotateToInterfaceOrientation: method:

This method must return YES for all supported orientations for the view controller. Here, we’re supporting both landscape orientations. Note the use of the bitwise OR operator ( | ) here.

Now open AppDelegate.h and make these changes:

We’ve imported PortraitViewController.h and set up a property named rootVC. Make these changes in the applicationDidFinishLaunching: withOptions: method of AppDelegate.m:

After synthesizing the rootVC, we instantiate it using the init method, rather than initWithNibName: bundle:. PortraitViewController will call through to super’s initWithNibName: bundle: ; we’ll see that shortly.

Now open PortraitViewController.h and make these changes:

We’ve imported LandscapeViewController, and made a property of it (landscapeVC). Make these changes to PortraitViewController.m:

(Leave the rest of the methods of the ViewController alone, just add these methods at the top, below the @implementation line). Here, we’ve overridden init to call super’s initWithNibName: bundle:, we’ve provided PortraitViewController.xib as the nib name. In the init method, we’ve also subscribed to the UIDeviceOrientationDidChangeNotification in the default notification center and provided the method “orientationChanged:” to be fired when this event occurs.

In orientationChanged, we detect the current device orientation, and either present the landscapeVC object as a modal view controller (if the device entered landscape orientation), or dismiss it (if the device entered portrait orientation). Note the use of the viewIsLandscape property to control the display of the proper view controller.

Now run the project. When the orientation changes, you should see the changes to the view take place:

Multiple selection of rows in UITableView are enabled by adding the following line in ViewDidLoad of ViewController.m file.

The default value of this property is set to NO. Generally this property returns a boolean value that controls whether users can select more than one cell simultaneously in editing mode. If you set to YES, check marks appear next to selected rows in editing mode. In addition, UITableView does not query for editing styles when it goes into editing mode. If you call indexPathsForSelectedRows, you can get the index paths that identify the selected rows. Now we need to allocate edit, add, cancel and delete bar buttons and its action methods. For that we need to modify the ViewDidLoad method by adding the following lines of code.

The last two lines of code indicates edit and add buttons are placed in right and left sides of navigation bar respectively. Implement the edit action method as follows.

After taping the edit button, immediately it will turn up as a cancel button. The number of rows in table view will be the length of dataArray object. Modify the cellForRowAtIndexPath method in such a way to display the content of dataArray object based on its index. Following code line will display each rows content.

Build and run the code you will see the following screenshot flow. Screenshot_1 appears as a first screen, if you tap on edit button you will see the screenshot_2 and after selecting first two rows you will see the screenshot_3.

Now we will customize the delete button text to show the number of selected rows as its text. Add the following lines of code on top of ViewController.m file.

Implement didDeselectRowAtIndexPath and didSelectRowAtIndexPath as follows.

Role of above delegate methods is to modify the text of delete button based on number selected or unselected rows. Finally we ned to implement the action methods of delete and add buttons. In delete button action method, we use UIActionSheet to populate set of options like delete selected rows or cancel the deleted action. And after that we implement UIActionSheet’s delegate method to perform delete or cancel actions by registering its delegate protocol. Delete and add action methods look like this.

Now build and run the code. You will be able to perform delete action for selected number of rows or we can delete all available rows of table view.

In ViewController.xib file drag UITableView object and connect it with the associated outlet in .h file. Also register with UITableView data source and delegate protocols. Now open ViewController.h file and modify as follows.

Open viewDidLoad method of ViewController.m file and add the below code.

Here dataArray contains string objects which we display in table view. Our purpose of this tutorial is editing table view in such a way to delete or insert rows. For that we need a bar button on top of navigation bar. Hence I added UIBarButtonItem named Edit and registered its action with addORDeleteRows method. Now we need to implement this method by adding the following lines of code.

From the above code, the property “editing” is a boolean type variable which indicates whether table view is in edit mode or not. Else part of if statement contains other variation of Edit button. i.e. after tapping edit button, table view becomes editable and our button text changed to Done. Now we need to implement the table view data source methods for number of rows and its content. Add the following code into your project.

The numberOfRowsInSection method returns one extra row if the table view is in edit mode otherwise it returns the dataArray count. In edit mode cellForRowAtIndexPath method returns an extra cell with content “Append a new row” at the end of table view. Now compile and run the code you will see the following screens in normal and edit modes.

In edit mode all the rows are preceded with “-” icon including last row. The purpose of last row is to add the new row at the end of table view. So we need to change the icon of last row. This is possible by adding editingStyleForRowAtIndexPath delegate method.

Now compile and run the code you will see the following screen.

No action will be performed if you tap either on “-” icon’s Delete button or “+” icon. To delete a row or insert a row at the end of table view we need to over write the UITableViewDataSource method commitEditingStyle as follows.

Build and run the code, now you will able to insert and delete the rows.

Open Xcode, start a new project with TabBar application template as follows.

By default Xcode creates a tab bar with two tabs and corresponding viewControllers named FirstViewController and SecondViewController with .xib files. It also creates tab bar tabs background images named first and second with .png extension in retina and non retina mode. Delete second.png and rename first.png as tab_image.png. Because I am going to add one more custom tab such that all the three tabs will have the same background image. Now add a UIButton in first and second viewController .xib files. Build and run the code, you will get the following output.

Suppose you want to push some other view controller from First and SecondViewControllers then we need to add UINavigationController with FirstViewController, SecondViewController as their rootViewControllers. For that, open appDelegate.m file and add/modify the following lines of code.

Now run the code. You will see the navigation bar on top of two viewControllers.

If you want to navigate from First and SecondViewController to other controllers then we need to add two new viewControllers. Add new viewControllers named ImageViewController and TableViewController. Add an imageView outlet to ImageViewController.xib file and connect it with the imageView outlet in corresponding .h file. Now open TableViewController.xib file, add a tableView outlet and its dataSource, delegate protocols, also connect it with associated outlet placed in .h file. Open viewDidLoad method of ImageViewController.m file and add the following code.

Now open TableViewController.m file and add the code as follows.

Build and run the code, you will see the tab bar with two navigation controllers. Now tap the buttons placed in respected viewControllers, we will navigate to the ImageViewController and TableViewController. Now I will add a third view controller called ThirdViewController without the navigation controller. Open the appDelegate.m file and modify didFinishLaunchingWithOptions method as follows.

Open ThirdViewController.xib file and change it according to the following figure.

Now open ThirdViewController.m file and in its initWithNibName method add the following line of code.

Compile and run the code, you will see three tabs, first two with navigationControllers and last one without navigationController.

If you want more number of tabs you can add their associated controllers. According to the apple documentation, the tab bar has limited space for displaying tab items. If you add six or more custom view controllers to a tab bar controller, the tab bar controller displays only the first four items plus the standard More item on the tab bar. Tapping the More item brings up a standard interface for selecting the remaining items. The interface for the standard More item includes an Edit button that allows the user to reconfigure the tab bar. By default, the user is allowed to rearrange all items on the tab bar. If you do not want the user to modify some items, though, you can remove the appropriate view controllers from the array in the customizableViewControllers property.

Open Xcode, select “Create a new Xcode project,” and click Next. Choose the Single View Application. Click Next, then you navigate to the next screen. Fill all the fields like product name (ImagePicker), organization name and etc. In the bottom of the screen just uncheck “Use Storyboards”(As I have use the nib files in this application) and “Include Unit Tests”.

Before going further we need to add some images into iPhone simulator’s photo app. Open the iPhone simulator then open safari browser. Select any image from google images then tap the image and hold it for a while, you will see the action sheet appear as shown in the following figure.

Tap on “Save Image” option then image will be automatically saved into photos app.

Now open ViewController.xib file from our project and add a button and connect it with the IBAction in the ViewController.h file. Open the ViewController.m file and add the following code.

This method will be invoked whenever you tap on “Add Image” button. In this I use UIActionSheet to populate available options. From apple documentation UIActionSheet class present the user with a set of alternatives for how to proceed with a given task. Now compile and run the code(there may be a warning but continue executing) you will see the screen as follows.

Popup is showing three options. Now we have to write action methods for first two options. For that we have to register our ViewController with UIActionSheetDelegate protocol. Add the UIActionSheetDelegate method and implement the action methods as follow.

In the last two methods, first we check whether source type is available or not. If available then we present UIImagePickerController. By default allowsEditing property returns NO. If we set it to YES then we navigate to the next controller where we get the option to scale the selected image.
Now open AppDelegate.h and add the following line of code

In AppDelegate.m, change our ViewController to RootViewController by adding/modifying the following lines of code in “didFinishLaunchingWithOptions” method.

Now register our ViewController with UINavigationControllerDelegate, UIImagePickerControllerDelegate protocols. Because to present UIImagePickerController we need the UINavigationController delegate protocol. Implement the UIImagePickerControllerDelegate methods in ViewController.m file as follows.

Whenever we select the image, “didFinishPickingMediaWithInfo” delegate will be fired. There we can find the selected image reference using UIImagePickerControllerOriginalImage constant. If you want to upload the image to remote server or save it to the application bundle then we need to convert the image into NSData. we have already discuss the save image locally feature in one of our earlier tutorials (http://www.edumobile.org/iphone/miscellaneous/image-download-application-in-iphone/).

Suppose if you want to populate the selected image in a new controller then add the controller named ImageViewController as shown in the following figure.

Open ImageViewController.h file, add UIImageView property and initialize its bounds in associated .m file. Then add the following lines of code in “didFinishPickingMediaWithInfo” delegate of ViewController.m file.

Now compile and run the code. After selecting your options you will navigate to the photos app. If you select any image then you will navigate to the new screen where you see the selected image. If you press the “take a new photo” button in simulator, it won’t work. Because simulator is not capable of taking photos.

Open Xcode, select “Create a new Xcode project,” and click Next. Choose the Single View Application template as shown in the following figure.

Click Next, then you navigate to the next screen. Fill all the fields like product name (ImageDownload), organization name and etc. In the bottom of the screen just uncheck “Use Storyboards”(As I have use the nib files in this application) and “Include Unit Tests” as shown in the following figure.

Then click Next button.
Open the ViewController.xib file and add the required outlets as shown below.

Here UIProgressView outlet shows how much percentage of data has been downloaded. After downloading the full data, UIImageView will display the downloaded image.
Finally, connect these outlets with the reference objects in ViewController.h file. Following figure shows the required connections.

Now open the ViewController.h file and add the following code.

Here “imageData” will contains the data downloaded from server, “length” will contains the total image data length. And NSURLConnectionDelegate, NSURLConnectionDataDelegate are the delegate protocols for tracking the image data response, how much data is downloaded, and failure responses.
Now open the ViewController.m file. In viewDidLoad method, add the following lines of code.

Here we will download the image from URL http://www.raincoast.org/wp-content/uploads/S1I1596grizzlysittingattideline547-10MB.jpg For the best progress of the progress view, we have taken the image of size 10MB.

Now for responding to authentication challenges we need to implement the delegate protocols. From the following code, in “didReceiveResponse” delegate we will find the expected length of the total image data for calculating the percentage of image downloaded. This delegate will call only once for each connection. The delegate “didReceiveData” will call several times until the entire image data is downloaded. In this delegate, we append the downloaded data to “imageData” and also added the code for calculating percentage of image downloaded. “connectionDidFinishLoading” delegate will call when entire image data is downloaded. Here we handle the image display part. Implementation of delegate methods is as follows:

Now compile and run the code. You will see the accurate download progress view and downloaded image as follows:

Some applications need the local storage of data to avoid the same data to be downloaded several times. To achieve the local storage we need to save this image locally into applications document folder. “saveLocally:” method will do the local storage.

Here for each image download, we are giving a deferent name as per the epoch time. Now compile and run the code, you will see the image to be saved in applications document folder. Documents folder for your application is located in the following path /Users/startup/Library/Application Support/iPhone Simulator/6.1/Applications/3747D38D-9D04-4A58-9327-DFEE22740A81/Documents. Following screenshot shows the saved image under documents folder of the application.

Step 1: Open the Xcode, Create a new project using View Base application. Give the application
“TimeApplication”.

Step 2: Xcode automatically creates the directory structure and adds essential frameworks to it. You can explore the directory structure to check out the content of the directory.

Step 3: Expand classes and notice Interface Builder created the ViewController class for you. Expand Resources and notice the template generated a separate nib, TimeApplicationViewController.xib for the TimeApplication.

Step 4: Open the TimeApplicationViewController.h file and make the following changes:

Step 5: Double click the TimeApplicationViewController.xib file and open it to the Interface Builder. First drag the Round Rect Button and label from the library and place it to the view window. Now select the Round Rect button and bring up Connection Inspector and connect Touch Up inside to the File’s Owner icon and select ShowTime: method. Select File’s Owner icon to the label and select time. Now save the .sib file close it and go back to the Xcode.

Step 6: Open the TimeApplicationViewController.m file and make the following changes:

Step 7: Now Compile and run the application on the Simulator

You can Download SourceCode from here

Step 1: Open the Xcode, Create a new project using View Base application. Give the application
“AlertView”.

Step 2: Xcode automatically creates the directory structure and adds essential frameworks to it. You can explore the directory structure to check out the content of the directory.

Step 3: Expand classes and notice Interface Builder created the ViewController class for you. Expand Resources and notice the template generated a separate nib, AlertViewViewController.xib for the AlertView application.

Step 4: Open the AlertViewViewController.h file and make the following changes:

Step 5: Double click the AlertViewViewController.xib file and open it to the interface Builder. Drag the Textfield, Label and round rect button from the library and place it to the View window. Now connect File’s Owner icon to the TextField and select text, select the button and bring up Connection Inspector and connect Touch Up Inside to the File’s Owner icon and select AlertView: method. Now Save the .xib file, close it and go back to the Xcode.

Step 6: Open the AlertViewViewController.m file and make the following changes:

Step 7: Now Compile and run the application on the Simulator.

You can Download SourceCode from AlertView

Start up Xcode and select “Create a new Xcode project.” In the next screen, choose Empty Application,
then click next:

In the following screen, name the project EmptyApp, select the options shown. Note that even though
we are developing here for iPad, the principles involved are the same for iPhone development.

Click Next, choose a location to save the project, and click Create.

The first thing to notice about the Empty application
template is that it provides the AppDelegate class, but
nothing else. We will need to provide our own view
controller and view for the application.

In the menu, select File | New ► then File… In the next
window, choose Objective – C Class, then click Next. In
the window that results, name your new class
MainViewController, make it an instance of
UIViewController, select the checkbox next to “Targeted
for iPad,” and make sure the “With XIB for user interface” check box is unchecked. (We’re going to
create the xib file separately in this case to show how a view is connected to a view controller.) Click
Next. Choose the default location to save the files, and click Create.

Now we’ll create the actual view. Another way to add a new file to the application is to right-click in
the Project Navigator and select New File… from the popup menu. Do so now. In the resulting window,
choose “User Interface” from the list to the left under iOS, then select the Empty document as shown
here:

Click Next, and make sure the Device Family is set to “iPad.” Click Next once again, and in the Save
As text box, enter “MainView.” Click Create to save the file in the default location.

The Project Navigator panel should now appear as shown
here. Note that you may have to drag some files around in the Navigator to properly organize them. Sometimes, Xcode will crash when dragging files – this is a known issue; simply reopen Xcode and continue when this happens.

Select the xib file to open it in Interface Builder. You will see an entirely empty Window. First, select the File’s Owner object. In the Identity Inspector, choose MainViewController for the File’s Owner’s class, as shown below. This will make the MainViewController class the view controller for the view that we will be adding to this xib file.

Next, drag a UIView object from the Library to the
Interface Builder surface. Notice that the UIView
object is properly sized for the iPad device, because
we made the iPad selection in the Device Family
drop down when we created the xib file. Give the
view a nice background color.

Now right-click the File’s Owner object, and drag
from the circle to the right of the “View” item to the view itself. This makes the new UIView object the
MainViewController’s view. At this point, we’re done with Interface Builder (for now).

We need to make this view a subview of the application’s window object, so it can be displayed when
the app runs. Select the AppDelegate.h file, and make the changes shown in bold:

We’ve imported the MainViewController.h file (to obtain access to that object), and also set up a
property of type MainViewController called mainViewController. We will instantiate this object in
the .m file, then add it’s view as a subview of the window object.

Open up the AppDelegate.m file, and once again make the bolded changes. (The listing is on the next
page:)

(We’re not showing the entire file, only the portion that requires changes to be made.)

First, we synthesize the property mainViewController. Following Apple’s recommendation, we
synthesize this property with a name different from that given to it earlier, this makes it impossible to
accidentally use it as an ivar: we must access it using its getter and setter methods.

Next we instantiate mainViewController by first allocating space on the heap for an object of class
MainViewController, then calling initWithNibName: bundle: to initialize the object. In this case, we’ve
already wired up the view controller, view, and File’s Owner in Interface Builder: a value of nil for the
nib name will take the values already provided. A value of nil for the bundle parameter signals the
system to take the current application bundle.

Finally, we add the mainViewController’s view as a subview of the main application window. When
this window is made visible, the subview will be displayed on top of it.

Run the application to verify that the view is shown. At this point, the application is ready for
development to proceed along traditional lines.

When we use Nib files to represent views, the delegate class can name itself the delegate in the initWithNibName: bundle: method, or in viewDidLoad. Unfortunately, this practice does not work with storyboards. Since there is no Nib file, initWithNibName: bundle: is never called. Setting a class to be the delegate of another class in viewDidLoad relies on being able to “lazily instantiate” the other class in the delegate class, then setting its delegate property to self. This will not work because in a storyboard setting, the new class is actually instantiated during the segue itself (with modal segues). If we do instantiate the new class in viewDidLoad, it is not the same object that will be used.

So what do we do? In this blog, we’ll look at how to perform delegation with a modal view controller. Start Xcode and create a new project. Use the Single View Application template, name the project Delegation, and make sure to check the “Use Storyboards” checkbox as below:

Click Next, choose a location to save the project, and click Create. When the project has loaded, create a new UIViewController class named SecondViewController. Here is SecondViewController.h:

We’ve set up a protocol named SecondControllerDelegate to hold a single delegate method, userDidMakeChoice:. When the user selects an option in a segmented control (in the view), the SecondViewController’s choiceMade: action method will fire, calling the delegate method before dismissing the view controller (which will reveal the main view controller once again).

Let’s look at the implementation of SecondViewController.m:

After synthesizing the delegate property, we implement choiceMade:. First, we call the delegate method, then dismiss this view controller by calling dismissViewControllerAnimated: completion: (with a nil value for completion, since we don’t need any code to run after the controller is dismissed).

Open MainStoryboard.storyboard in Interface Builder by clicking on it in the navigator. Drag a new View Controller to the main view, next to the first view controller. Place a single button labeled Choose… and a UILabel above the button with the text left blank on the first view controller, then CTRL – click and drag from this button to the second view controller to create a segue. Choose Modal when prompted for a segue type.

Now place a UISegmentedControl and a label on the second view controller. When finished, the Interface Builder should look like this (the label is on the first view controller, it is not selected and therefore invisible):

Select the second view controller, and change its class to SecondViewController as shown here:

Now select the segue itself, and give it an identifier a shown:

Now we’re ready to write the code for ViewController. Here is ViewController.h:

We’ve imported SecondViewController for two reasons, to adopt its protocol, and to get its type, which will become important in a moment. The IBOutlet UILabel property “outcome” will be wired to the “textless” label on this view controller’s view.

Now, ViewController.m:

The important thing here is the prepareForSegue: sender: method, which will be called right before a segue fires. If there is only one segue in an app, there is no need to check the identifier (or even to set an identifier on the segue at all). We do so here to illustrate the more common case, in which there would be multiple segues from a single view controller, and a need to distinguish them.

The key point is the line:

segue.destinationViewController is the view controller that will be shown by the segue. We need to get that view controller so we can set its delegate property to self. But segue.destinationViewController is typed as a UIViewController, not a SecondViewController. It must be cast to the proper type so that we can get to its properties!

Now we can assign the delegate:

This allows us to respond to the protocol’s method, which simply converts the integer parameter to an English word.

To finish, we must wire up the ViewController’s label outlet to the label (the one with no text), and the SecondViewController’s choiceMade: method to the UISegmentedControl’s ValueChanged event. Note the button on the first view controller does not need an IBAction method: the segue process itself knows what to do with this button press. It calls prepareForSegue: sender: performing the code we specify, then performs the segue by displaying the SecondViewController.