In Objective-C, classes have instance and class methods. These define the behavior of a class and its instances. Sometimes, you are using a class and you really wish “it just had a method to do this cool thing I want to do.” You’re in luck. You can add methods to an existing class by creating a category for that class.
The syntax for a category is not at all scary like blocks; in fact, it’s something you’ve already used before. You will create a category for UIColor that has two new methods that an instance of UIColor will respond to. Create a new NSObject subclass. Name it UIColor+Extract.m. In UIColor+Extract.h, replace all of the code with the following:
#import <Foundation/Foundation.h> #import <UIKit/UIKit.h> @interface UIColor (Extract) - (void)extract_getRed:(float *)r green:(float *)g blue:(float *)b; - (UIColor *)extract_invertedColor; @end
Notice you used nearly the same syntax as you would if you were declaring a new class named UIColor. However, there are two differences: the area for defining the superclass has been replaced with (Extract) and there is no section for instance variables. This declaration says, “I’m adding two new methods to the UIColor class. The name of this addition is Extract, which is just a name.” Also, note that these methods are prefixed with the name of the category. Because more than one category can be added to a class, you don’t want to pollute the namespace with obvious-sounding method names.
In UIColor+Extract.m, implement these two methods by replacing all of the text in the file with the following:
#import "UIColor+Extract.h"
@implementation UIColor (Extract)
// Note that this method uses the word "get". The
// "return values" are passed as pointers and filled
// out by the method.
- (void)extract_getRed:(float *)r green:(float *)g blue:(float *)b
{
// Get the Core Graphics representation
CGColorRef cgClr = [self CGColor];
// Get each component of the color ("color channels")
const CGFloat *components = CGColorGetComponents(cgClr);
// Get the number of components
size_t componentCount = CGColorGetNumberOfComponents(cgClr);
if (componentCount == 2) {
// A grayscale color will only have two components,
// the grayscale value and the alpha channel
// Assign the values pointed to by r, g, b to
// the grayscale value
*r = components[0];
*g = components[0];
*b = components[0];
} else if (componentCount == 4) {
// A RGB color has 4 components, r, g, b
// and an alpha channel
*r = components[0];
*g = components[1];
*b = components[2];
} else {
NSLog(@"Unsupported colorspace.");
*r = *g = *b = 0;
}
}
- (UIColor *)extract_invertedColor
{
// Use method you just defined to get components of color
float r = 0, g = 0, b = 0;
[self extract_getRed:&r green:&g blue:&b];
// Return a new UIColor instance with inverted components
return [UIColor colorWithRed:1.0 - r
green:1.0 - g
blue:1.0 - b
alpha:1.0];
}
@end
Now, you can send the messages getRed:green:blue: and invertedColor to any instance of UIColor.
This approach has benefits over subclassing UIColor. First, if you had already been using UIColor in your application, you don’t have to go back and change these objects to some new subclass. More importantly, however, many methods that you don’t have control over may return UIColor instances. You would not be able to send these two new messages to those objects with a subclass.
Go back to TouchDrawView.m. At the top of this file, import the header file for this category so this file knows about these new declarations.
#import "TouchDrawView.h" #import "Line.h" #import "UIColor+Extract.h"
Now, when you send the message invertedColor to a Line’s color,
[self transformLineColorsWithBlock:^(Line *l) {
return [[l color] extract_invertedColor];
}];
the method in your category will be executed. You might want to keep this category around, it is pretty useful.
Build and run the application. Draw some lines and then shake the device. Rotate it, and the colors will invert. Rotate it again, and the colors will revert back to normal.
Categories have another use: pseudo-private methods. In Objective-C, there is no such thing as a private method. If a class implements a method, you can always send that message. However, you sometimes want the ability to at least hide methods from a user of the class. For example, a method that only gets called internally by the class and requires a certain set of conditions in order to operate properly is not something you want other objects knowing about. You could, of course, leave that method declaration out of the header file, but the compiler will give you a warning when you try to use it.
To hide method declarations and hush up the compiler about undeclared methods, you can create a category at the top of an implementation file with declarations for methods you don’t want used by other objects. A category used for this reason is called a class extension and has no name. Methods in a class extension must be implemented in the standard @implementation block of a class or the compiler will complain. Near the top of TouchDrawView.m, add the following category declaration.
@interface TouchDrawView () - (void)transformLineColorsWithBlock:(UIColor * (^)(Line *))t; - (void)colorize; @end @implementation TouchDrawView
Now, you won’t get any warnings when TouchDrawView uses one of these methods, but any other file that tries to use these methods will get a warning. (You may not have had any warnings to begin with depending on the order you implemented your methods.) Note that even though these methods aren’t visible to other files, they can still be invoked. The compiler will just complain.