First let’s get acquainted with some of the components of the copy and paste system.

UIPasteboard

Any time you copy or cut anything in iOS that content gets posted to an instance of UIPasteboard.  The pasteboard is a powerful and type agnostic way to move content from one application to another or between parts of a single application.  The pasteboard is capable of storing nearly any type of data, not just text.

UIMenuController

UIMenuController is the controller that’s displayed when you highlight text.  Like many other visual controls in iOS this one is pretty locked down.  There are several system items that are added to the menu by default, but you can certainly add your own items via UIMenuItem to do whatever you like.

UIResponderStandardEditActions

This informal protocol is conformed to by descendants of UIResponder to handle the common actions provided by UIMenuController.  UIMenuController will start looking for objects in the responder chain with the first responder moving up the hierarchy until it finds a valid target for the various messages offered by the specified action, such as copy: or cut:.  As we saw in part 1, objects responding to canPerformAction: alter the options provided by the UIMenuController.

The way these three interact isn’t entirely obvious, so we’ll build a sample application that shows placing data in an application specific pasteboard, uses a custom image view that conforms to the UIResponderStandardEditActions protocol supporting cutting and pasting, and adding some custom functionality to the UIMenuController that will appear over our control.  You can download the sample project here.

Setting up the project

We’ll start with a master-detail template.  The master view controller will contain a list of table cells with an image and some text.  The detail view will show the image displayed.  This isn’t a post about table views and interface builder, so I recommend just checking out the sample code if you’re not comfortable with the basic setup.

The custom control

Our custom control will simply be a UIImageView that implements the basic methods for cut, copy, and paste.  To get the implementation correct it’s important to think about what a user’s expectation would be for these three actions:

• copy – the image is made available to paste into other controls that can accept an image as content.
• cut – the image is made available to paste into other controls that can accept the image and the image is removed from the current control.
• paste – the displayed image is replaced with whatever image is in the clipboard.

Implementing these three methods from UIResponderStandardEditActions is actually quite simple:

- (void)copy:(id)sender
{
    UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
    [pasteboard setImage:self.image];
}

- (void)paste:(id)sender
{
    UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
    if (pasteboard.image) self.image = pasteboard.image;
}

- (void)thumb:(id)sender
{
    UIImage *thumb = [self thumbnailFromImage:self.image];
    [[UIPasteboard generalPasteboard] setImage:thumb];
}

Easy, right? The copy method will add the UIImageView’s image to the pasteboard via setImage. Conversely, paste will place the image from the pasteboard if it exists. Cut will first call copy to place the image to the pasteboard then clear out the image property.

Adding the UIMenuController

You can run this code now, however there’s no way to actually access the cut, copy, and paste methods.  We’ll have to do a couple of things to get the UIMenuController to appear and allow us to copy and paste the image content.

1. Add a long press gesture recognizer to our control.
2. On the action for gesture recognizer we’ll make our control the first responder.
3. Lastly show the menu controller.

Adding the gesture recognizer is easy.  See the code below for creating the UIMenuController:

- (void)handleLongPress:(UILongPressGestureRecognizer *)sender
{
    NSLog(@"long press");

    UIMenuController *menu = [UIMenuController sharedMenuController];
    if (![menu isMenuVisible])
    {
        [self becomeFirstResponder];
        [menu setTargetRect:self.frame inView:self.superview];
        [menu setMenuVisible:YES animated:YES];
    }
}

You’ll notice that the menu controller is a singleton, and this is the only way to instantiate one. If the menu isn’t shown already we’ll make our image view the first responder and display the menu. The critically important step is to register ourselves as the first responder. Remember that the UIMenuController looks for the protocol methods using the responder chain. No other class in our view will respond to these methods. Without setting ourselves as the first responder the UIMenuViewController won’t display at all.

Since we implement cut, copy, and paste, those are the three buttons presented in the menu controller.  At this point you can run the app and successfully copy and paste between the image views.  You can also try jumping out to Mobile Safari, long pressing an image, selecting copy and pasting it into one of your image views if you’re still skeptical.

Adding custom actions to the menu

UIMenuController exposes the menuItems property allowing you to add custom menu items.  The menu items are added after any system items and must be instances of UIMenuItem.  We’ll add a custom menu item to copy a thumbnail of the image to the pasteboard.

Creating the thumbnail is somewhat out of scope for a detailed explanation, but here’s the code below.  It takes an image and returns one-third the size of the original (source material taken from here):

- (UIImage *)thumbnailFromImage:(UIImage *)source
{
    CGSize originalSize = source.size;
    CGSize destSize = CGSizeMake(originalSize.width / 3, originalSize.height / 3);

    UIGraphicsBeginImageContext(destSize);
    [ source drawInRect:(CGRect){CGPointZero, destSize}];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

Next we need to create a method on our image view to place the thumbnail on the pasteboard:

- (void)thumb:(id)sender
{
    UIImage *thumb = [self thumbnailFromImage:self.image];
    [[UIPasteboard generalPasteboard] setImage:thumb];
}

Lastly we need to create the UIMenuItem to add to the UIMenuController. The UIMenuItem class is very simple and only takes a title and selector. Since we added the method thumb: to our image view that’s the selector we’ll reference in the menu item.

UIMenuItem *item = [[UIMenuItem alloc] initWithTitle:@"Copy Thumbnail" action:@selector(thumb:)];
menu.menuItems = @[item];

We’ll place this code right before showing the menu controller in the long press handler. You can now run the app, select “Copy Thumbnail” and you’ll see the image pasted is a thumbnail relative to the original.

Note: If you created the nib for the detail view yourself, it’s important the view mode to “center” to avoid the image view stretching the thumbnail when you paste it.

Creating an application specific pasteboard

Up until this point we’ve been using the standard general pasteboard but the SDK provides us other options as well. The only requirement for creating a new one is that the name must be unique. You might also mark a pasteboard as persistent so it will live on after your app terminates. This isn’t particularly useful for a single application but can be extremely powerful for preventing data leakage while still maintaining copy and paste functionality between a suite of apps.

We’ll define the custom pasteboard name in the application delegate’s header file. We can import that into any other file where I need the pasteboard name.

// App delegate header
extern NSString *const pasteboardIdentifier;

I’ll also initialize the pasteboard in applicationDidLoad method on the app delegate:

// app delegate implementation file
// make sure to define the extern
NSString *const pasteboardIdentifier = @"com.pzearfoss.customCopyPaste";

// ...
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    // ...
    [UIPasteboard pasteboardWithName:pasteboardIdentifier create:YES];
    // ...
}

Lastly, in my image view I’ll replace the generalPasteboard call with pasteboardWithName:create:

- (void)copy:(id)sender
{
    UIPasteboard *pasteboard = [UIPasteboard pasteboardWithName:pasteboardIdentifier create:NO];
    [pasteboard setImage:self.image];
}

- (void)paste:(id)sender
{
    UIPasteboard *pasteboard = [UIPasteboard pasteboardWithName:pasteboardIdentifier create:NO];
    if (pasteboard.image) self.image = pasteboard.image;
}

- (void)thumb:(id)sender
{
    UIImage *thumb = [self thumbnailFromImage:self.image];
    [[UIPasteboard pasteboardWithName:pasteboardIdentifier create:NO] setImage:thumb];
}

Running the application you’ll now see that you can copy and paste between image views as you could before, but if you try to copy from another app like Mobile Safari it will not paste in our app.

That concludes part 2 for implementing copy and paste, UIMenuController, and using an app specific UIPasteboard. Check out part 3 where we’ll store more complex data types in the pasteboard.

For those who are new to Photo Academy, the aim of the app is to help anyone who owns a camera to take better photos.

Photo Academy for iPad contains thousands of detailed tips on how to take the best photo in almost every situation, including the exact camera settings to use. Beginners can get up to speed quickly by following a broad range of tutorials, which cover all the different aspects of photography. The app also allows you to show off your skills in the Shoot Diary, by tracking photo shoots, sharing them with friends, and seeing where in the world you’ve taken your best photos.

For more information, please take a look at the Photo Academy for iPad website, or simply search for Photo Academy on the App Store. Alternatively, if you have any feedback or suggestions, I’d love to hear them!

Finally! Muster my Monsters is now available on the App Store for FREE as an Universal app!

Have a blast fighting in the arena of this hilarious 4-player party game. To deal with this bunch of monsters, the key is to have rapid reflexes, good intuition and master the art of bluffing. And mocking at your rivals! Muster my Monsters basic rules are similar to Rock-Paper-Scissors, but in Muster my Monsters we have ruder actions: Attack beats Mock, Mock beats Dodge and Dodge beats Attack. And this is called “balance”.

Features

• A modern twist on the classic rock-paper-scissors game featuring funny monsters, crazy attacks and lots of different ways of mocking at your rivals!
• Solo to up to 4 players (up to 4 players on iPad and up to 2 players on iPhone & iPod Touch)
• Play versus the AI to improve your skills
• Two different game modes (Normal and WIFI) that require completely different play styles and skills
• Win battles to unlock new monsters. Every monster has its own personality!
• Power-ups
• High quality visuals with detailed characters and smooth animations
• Simple controls
• A good time with friends and family

Enjoy it! “:^]

Source: Muster my Monsters now available on the App Store! – Indie Dev Stories
Indie Dev Stories – Stories from an Independent Games Developer

I recently came across a podcast aimed at people who work from home, aptly named Home Work. I’ve really been enjoying going back over all the old episodes, and there’s some great discussion in there on all aspects of working from home. If you’re a home worker, I really recommend giving it a try, starting at the first episode.

One of the best tips I’ve picked up from Home Work so far is to consciously schedule your work day. The idea is to not only plan out what things you are going to work on that day, but also to put times against them. I’ve been giving this a try for the past few days, and by way of example, this is what my schedule looks like for today:

• 9am – 10am: write blog post
• 10am – 12.30pm: work on promotional material for an app I’m launching soon
• 12.30pm – 1pm: lunch
• 1pm – 3pm: work on bug fixes for a client app
• 3pm – 5pm: continue developing my new app idea

Once 5pm rolls around, I’ll take a look over all my current projects, decide what I’m going to work on tomorrow, and write up a schedule for myself for the next day. This only takes a few minutes, but so far it’s working out wonderfully. I don’t waste time in the morning trying to figure out my plans for that day, and I feel much more relaxed in the evening after finishing work, knowing that everything is on track, and anything that needs to be progressed has been scheduled in. I think the biggest benefit is that one particular project cannot take priority over another. So if I haven’t finished writing my blog post by 10am, I need to shelve it for the next day – 10am is the time to move on to the next project. This way everything moves along, rather than getting left behind.

At some point I think I’ll start scheduling in half an hour or so each day to take care of “stuff”, such as unexpected phone calls, emails, and so on, but so far I haven’t needed it.

And with that, it’s 10am, and time to move on to my next project. If this idea appeals to you, give it a try for a week – it’s made a big difference in my happiness and productivity.

With the development of my last game I decided I didn’t want to use Objective-C or Xcode anymore.  I wanted something fast, that I could rapidly prototype and test ideas.  Corona SDK has turned out (for me) to be that answer.  I recently gave a presentation at our local iPhone User Group spouting my enthusiasm for Corona.  We wrote a Space Invaders type game in less than an hour.  You can download the project and check it out.

Corona promises 10x faster development time.  That’s been my experience.  Is it right for everyone?  Probably not.  It’s really not geared for Enterprise type development (although the new Widgets 2.0 bring it close).  It’s really for games games games, and that it does REALLY well.  The big news is that Corona SDK is now FREE to use and publish your app to both the Android and iOS App Stores (you still have to pay Apple your $99 and Google your $25).  If you need In-App Purchases then you’ll have to fork over some money.  I happened to get in before the May 1st deadline and so I’m locked into a price guarantee for the next 2 years.

I’m looking forward once again to reviving some of the projects I had bouncing around in my head, but pushed to the back-burner because I dreaded starting yet another Xcode project.  Apple does some things really well… IDEs, back-end servers, and cloud stuff aren’t things they do too well at however.  I’d love to hear from other Corona users.  Drop me a line.

I was reading Mark Suster’s post Understanding How The Innovator’s Dilemma Affects You today and it struck me how closely my thoughts on WWDC line up with Clay Christenson’s ideas.

Not surprisingly, there has been lots of twitter and blog activity this week about Apple’s dilemma in regards to WWDC. Is it broken? Does it need fixing? Does it need replacing? Does it just need to go away?

I’m not sure what will or should happen with WWDC, but I think there is a real danger here for Apple:

• Apple is successful because they work hard at doing what is best for their customers, which turns into good things for Apple.
• Continuing to please customers with better stuff than their competitors drives them forward.
• Developers are an important component of that success, even if they are not the driving force.
• A big part of what makes Apple’s products great is their consistency of purpose, style, and use.
• WWDC and other developer focused activities play a key part in helping third party apps maintain that consistency.

Apple’s dilemma

If developers are not regularly being immersed in the Apple way of doing things, will that produce a cultural shift that erodes that consistency?

I’m sure Apple has some smart folks thinking about these things. I am hopeful that, just as with their products, they will find some new and innovative ways to solve it!

Here is a little more information about me, Doug Sjoquist, and how I came to my current place in life. Hope you have a great day!