Setting up a custom delegate seems pretty straightforward. In this case we want the calling class to understand what the child is saying to it.

I’ve set up my PersonListTableViewController with a toolbar item that allows me to update my twitter status. It does so by popping up a new modal window where I type in my status and hit done to send it over to twitter. Here’s where I do that. In the main view controller I add the method that will trigger my modal window. didTapEditStatusButton:

-(void)didTapEditStatusButton
{
StatusComposeViewController *statusComposeViewController = [[StatusComposeViewController alloc] init];
statusComposeViewController.delegate = self;

[self presentModalViewController:statusComposeViewController animated:YES];
[statusComposeViewController release];
}

The first thing that happens here is the modal window is instantiated.
Next I assign the delegate of the modal window to the main view controller. This is how we get the parent to listen to the child. Or, I guess this is where we tell the child who it’s daddy is.
When this is done all we need to do is present the controller, then release.

Because it is considered “Bad Form” for a modal window to dismiss itself, I’ll use delegation to let my parent view controller PersonListTableViewController know what the child view controller (my modal window) has done.

So the first thing I need to do is create my modal view. I’m going with the suggested StatusComposeViewController. Nothing new here, I’m subclassing UIViewController.

In the class header for my new view I need to add the delegation protocol. First thing I need to remember to do is declare the delegate protocol.
@protocol StatusComposeViewControllerDelegate;

Then I create the protocol and give it a couple of optional methods:

@protocol StatusComposeViewControllerDelegate
@optional
-(void)statusViewControllerDidSetStatus:(StatusComposeViewController *)controller didSetStatus:(NSString *)text;
-(void)statusViewControllerDidCancel:(StatusComposeViewController *)controller;
@end

This essentially declares these methods for whatever controller you specify as your delegate.

Moving back into my delegate (PersonListTableViewController) I’m going to need to implement the methods I’ve defined in my modal view. For this post I’ll just do one, the statusViewControllerDidSetStatus method.

-(void)statusViewControllerDidSetStatus:(StatusComposeViewController *)controller didSetStatus:(NSString *)text
{
[TwitterHelper updateStatus:text forUsername:username withPassword:password];
[self didFinishWithModalViewController];
}

A simple method for updating twitter status. The TwitterHelper class is provided in the course files. didFinishWithModalViewController is a method I’m using for cleanup and dismissal of the modal window. (Dismiss using [self didFinishWithModalViewController]). Any view can only have one modal view up at any given time, so we don’t need to tell this method which modal view to dismiss… it will always be the current modal view.

What did I miss…

Ok in the modal view controller StatusComposeViewController I need to implement the methods I’ll use to hit the delegate methods to perform the actions that the modal view is intended for.

- (IBAction)doneButtonPressed:(id)sender{
if([self.delegate respondsToSelector:@selector(statusViewControllerDidSetStatus:didSetStatus:)]){
[self.delegate statusViewControllerDidSetStatus:self didSetStatus:textField.text];
}
}

It is important to make sure you find out weather or not the delegate has implemented the method you’re going to try to call. This is done in the first line. Then we perform the operation.

I found cell rendering to be the biggest challenge in this assignment.

The process of making this work is a bit drawn out. The first thing I need to do is calculate what my rowHeight needs to be. This is done by overriding the heightForRowAtIndexPath method in my TableViewController.

1. Grab the string that needs to fit in the cell.
2. Set its font size.
3. Create a CGSize object using my cell width (I used a static width in this case) and a max hieght of 1000 (hopefully I wouldn’t need more height than that). This is done using CGSizeMake(280, 1000);
4. Assign it a size based on the font, font size, and line break mode
5. Then return the height, with a bit of padding return size.height + 20;

Once the row height has been calculated I init my label with a CGRect that specifies the label size based on the dimensions of my cell, then I add it to the contentView of the cell.
Now in order to make the label multiline enabled I first need to specify the numberOfLines property. I’m setting it to equal 0. This means that I’ll get as many lines as needed to fit the text (I don’t know exactly why this works the way it does. I could also put it some arbitrary number, and it would still work, but the maximum number of line breaks would be limited by that number). Then I need to set the autoResizingMask property of my label to UIViewAutoresizingFlexibleHeight. Also, I have to make sure I’m using the same font and font size that I specified in the heightForRowAtIndexPath method (setFont:[UIFont systemFontOfSize:14.0]). The it’s just a matter of setting the text value, adding it to the cell and releasing it.

I was having a very hard time with this one. My problem was that I still didn’t fully understand the relationship between XCode and Interface Builder. I’m not saying I know it all now, but I think I’m closer.

I had been struggling with the seeming lack of instantiation for my controller. I couldn’t find anywhere in my generated code (i.e. code created after dragging an object into my nib file window, setting up outlets, actions, etc, and selecting File>Write Class Files) where my Controller class was being instantiated. I wanted to assume that the nib takes care of this, well, it does, or, I do. By virtue of dragging the object into my nib window and assigning a class to it I am instantiating that class (it’s all spelled out for me right there in the description of the object, I missed it initially).

This helps to allow connections to make more sense to me. Once I got past the hocus pocus of magical object instantiation, I could look at connections more simply, as just connections, not some nebulous directive to instantiate as well. This had me thinking though. I was initializing my PolygonView class in my controller’s init method. It didn’t seem in keeping with my theory that interface builder takes care of instantiation, so I pulled the polygon init code out of my controller class to see how far south things would go. My code compiled without a problem, and my app ran just as well as before, except better, because now I wasn’t wasting memory instantiating an unused object.

My controller class keeps track of my view(s) and model(s). Within my controller I set up instance vars. I use interface builder to point them to the objects they represent.

Just to get this to sink in a bit more I played around with multiple instances of my PolygonView class. Adding a couple more poly view objects for a preview of the next and previous polygons.

I’m revisiting this assignment and I think I originally blocked out most of what the walkthrough was trying to explain. At this point there is still a whole lot for me to learn about IB, but after getting as far as assignment 8 and still being confused by IB’s role this was a good refresher.

InterfaceBuilder can write class files for you based on actions, outlets and connections you specify. Though the connections don’t ever seem to be apparent in the code (at least not in a way that I could term as meaningful). This has proven to represent the biggest challenge for me. I like to see everything that’s happening in my code.

I need this to sink in.

Let’s say I have two buttons and a label in my window, setting up a controller class goes like this:

• Drag an Object to my nib file window
• Select the object and name the class whatever I want my controller to be called
• Add some outlets that correspond with my two buttons and label, and actions as needed (so that my buttons will do something when tapped)
• Connect the controller outlets to the UI elements in the window
• Point the buttons to their respective actions like this:
  • Select the button of interest
  • in the connections inspector select whatever action I like (ex. touchUpInside)
  • Drag the action (using the connection circle to the right of the action) to my controller object in the nib window and let go
  • Select the appropriate action method in the controller (action methods will appear in a pop-up)

This is pretty much it. The walkthrough for the assignment goes into quite a bit of detail and more or less does it all for me. Just remember, create the controller object in IB and write class files from there. Link it up to the model class(es) by assigning my models to their own objects in IB, and pointing the controller at them (control+click, drag, release). This can actually be a bit deceiving. I select my controller and drag the connection over to my PolygonShape class and the polygon iVar within the controller appears in the pop-up. I would have expected the pop-up to contain vars associated with the PolygonShape class.

In this assignment we created a custom Polygon class. Goals were to:

• instantiate with a default number of sides as well as a specified number of sides.
• Increment, decrement the side count.
• Calculate the angle in degrees and radians.
• Set min and max number of sides (and restrict incremental and decremental methods from exceeding those bounds)
• Give the polygon a name (read only) that is updated when the number of sides it has changes
• play with dealloc for a hands on introduction to memory management

So, first thing I need to remember is that when synthesizing iVars the getter and setter methods are made available (even though I never see them in code). The naming convention for these is pretty standard. If I synthesize an iVar (instance variable) called “numberOfSides”, I will have gained access to the getter (numberOfSides) and setter (setNumberOfSides) methods.

Synthesizing is a convenience. It means I don’t have to write setters and getters for every little iVar I declare unless I want to do something special when setting the values.

In the case of this assignment, I actually do want to do something special when setting the number of sides for the polygon. I need to make sure that if the given number of sides is greater than max, or less than min, I don’t update, rather I throw an exception (or a suitably graceful error). So I implemented my own setter methods for these operations. I can still synthesize even if I choose to later implement my own methods. My custom methods will just override the synthesized ones.

Syntax for this has two parts. Obviously I need to declare the var in my interface

I synthesize it in my implementation file:

@synthesize numberOfSides;

Know thy self

Another thing to note is that “self” == “this” (as it would be in Actionscript, php, Java, etc…)
So, in Obj-C I’d write:

[self setMaximumNumberOfSides:12];

Where in Actionscript it would be:

this.setMaximumNumberOfSides(12);

Method Syntax

I’m also having a hard time getting the method syntax to sink in. Proper syntax is:
[receiver message:arg]
where receiver is the object, message is the method to call on that object, and arg is the argument to send.

So, I have a polygon object and I want to initialize it with a number of sides defined by me, along with min and max side constraints. Here’s what that looks like:

Polygon *poly = [[Polygon alloc] initWithSides:5 minSides:3 maxSides:12];

Now my polygon object instance “poly” has an instance method called “incrementSides” that increments to number of sides by whatever value I pass to it. If I want to add 3 sides to my polygon I’ll do this:

[poly incrementSides:3];

I made myself familiar with some Obj-c syntax here, as well as basic app structure. Things a complete novice (such as myself) should keep in mind:

NSString

To create an NSString:

To output different types within my string I need to use stringWithFormat, and the right format specifier to define that type. For example, I can’t assign an integer type as part of an NSString. The full list of specifiers is• here. Here are the specifiers I’ve most commonly used:

• %@: Objective-C object, printed as the string returned by descriptionWithLocale: if available, or description otherwise. Also works with CFTypeRef objects, returning the result of the CFCopyDescription function.
• %d, %D, %i: Signed 32-bit integer (int)
• %u, %U: Unsigned 32-bit integer (unsigned int)
• %f 64-bit floating-point number (double)

The format for using these is:

I can append a string using the aptly named stringByAppendingString :

which will output:

“The quick brown fox jumped over the lazy dog”

to the console.

NSDictionary

There are a lot of ways to get values into an NSDictionary. The API reference is a great place to look for details about that. For this assignment I used dictionaryWithObjects:forKeys

I created key objects and stuffed them into an array:

(There was some initial frustration here because I didn’t realize that when populating/creating an array this way I needed to terminate the array with a nil value so that arrayWithObjects knows that it has reached the end of the array. Not necessary with other types of instantiation)

then value objects:

…and into the Dictionary they go:

Enumerator:

(assuming obj1 – obj5 have been created…)

carve out a space for the enum:

NSEnumerator *en = [lotsOfObjects objectEnumerator];

and give it something to store the iterated object’s value in (id is a generic object type (for lack of the desire to go looking for a better description right now))

id obj = nil;

then use it: