Quickies for General

---

General

• Adding a pop up menu thingie [permalink]
  On iOS, the menu you get when you long-press in a text field is called a UIMenuController, and you can pop one up for your own classes.

  First, you need to be able to become first responder, and be able to perform the actions of the menu items you want displayed. The menu controller sifts through its default set, and actions your provide and sees if any can be performed. If not, they get dropped on the floor. This assumes that the menu being shown only has "Duplicate".

  - (BOOL) canPerformAction: (SEL) action  withSender: (id) sender {
      return action == @selector(duplicate:);
  } // canPerform
  
  
  - (BOOL) canBecomeFirstResponder {
      return YES;
  } // canBecomeFirstResponer
  

  Then acquire an array of UIMenuItems (title / selector pairs), become first responder (that's important), and then figure out where you want the menu item to point to. Then show it:

      // Permanent set of items.  You might want to do something saner
     static NSArray *s_menuItems;
  
      if (s_menuItems == nil) {
          UIMenuItem *item = [[UIMenuItem alloc] initWithTitle: @"Duplicate"
                                                 action: @selector(duplicate:)];
          s_menuItems = [ @[ item ] retain];
          [item release];
      }
  
      [self becomeFirstResponder];  // important!
  
  
      // point the menu point somewhere
      CGPoint point = CGPointMake (160.0, 5.0);
      CGRect rect;
      rect.origin = point;
      rect.size = CGSizeMake (1.0, 1.0);
  
      UIMenuController *menu = [UIMenuController sharedMenuController];
      menu.menuItems = s_menuItems;
  
      [menu setTargetRect: rect  inView: self];
      [menu setMenuVisible: YES  animated: YES];
  

  If you have work to do when the menu disappears (such as deselecting a tableview cell), you can listen for UIMenuControllerWillHideMenuNotification or one of its kin.

• Binding an NSPopupButton [permalink]
  To bind an NSPopupButton:
  • Have an NSArray somewhere that you want to supply the popup
  • Make an NSArrayController in the nib file (say call it "greeble"), and binds its Value to some keypath (such as your AppDelegate.greebleArray ivar)
  • Bind the popup's Content to the array controller's arranged objects (greeble.arrangedObjects). These are the objects that are behind the popup.
  • Bind the popup's Content Values to a key path that includes a displayable string. Assuming the objets in the greebleArray array have a title property, you'd bind it to greeble.arrangedObjects.title
  • Bind the popup's Selected Object to something, such as an ivar of the type of object that's in the greebleArray. If said ivar is called selectedGreeble, you'd bind to AppDelegate's selectedGreeble.

• Configuring control-shift-D dictionary contents [permalink]
  When I go to define a word with control-shift-D, I'm not interested in wikipedia - just give me the definition.

  This system-wide behavior isn't configured in the system preferences, instead in the prefs of the Dictionary App :-| . Go to the preferences, and you get a list of a ton of stuff. Turn off Wikipedia (or turn on / off whatever you want)

• Continuous Text Field [permalink]
  Courtesy of Jens Bauer. Sometimes you'd like a text field to notify on every text change.

  @interface FSContinousTextField : NSTextField
  @end
  
  @implementation FSContinousTextField
  
  - (void) textDidChange: (NSNotification *) aNotification {
  	[[self target] performSelector:[self action] withObject:self];
  }
  
  @end

• Convert a preprocessor symbol to an NSString [permalink]
  

  #define CONVERT_SYMBOL_TO_NSSTRING_2(x) @#x
  #define CONVERT_SYMBOL_TO_NSSTRING(x) CONVERT_SYMBOL_TO_NSSTRING_2(x)
  
  NSString *version = CONVERT_SYMBOL_TO_NSSTRING (BUILD_NUMBER);
  

  (Thanks to TVL for helping me figure this one out)

• Creating a UUID [permalink]
  

  CFUUIDRef cfuuid = CFUUIDCreate (kCFAllocatorDefault);
  NSString *uuid = (NSString *)CFUUIDCreateString (kCFAllocatorDefault, cfuuid);
  CFRelease (cfuuid);

  Because a core foundation "Create" function is called, you're responsible for releasing uuid when you're done with it.

• Defaults-writing an array [permalink]
  

  % defaults write com.borkware.snongflozzle ookook -array thing1 thing2 thing3

• Discovering when exiting a sub event loop [permalink]
  [self performSelector: @selector(whatever) withObject: nil afterDelay: 0];

  The selector gets posted after a sub event loop finishes. You can use this for finding out when a live slider is done being manipulated, for instance

• Easy command-line argument handling [permalink]
  You can use NSUserDefaults to sniff your command line. So using something like this:

      NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
      gridType = [defaults objectForKey: @"gridType"];
  

  Will have the value of "flarn" whether you do something like

  % defaults write com.borkware.BorkStitch gridType flarn

  or

  % ./build/Debug/BorkStitch.app/Contents/MacOS/BorkStitch -gridType flarn

• Enabling ARC [permalink]
  Turn on ARC at the command line by feeding the compiler the -fobjc-arc flag.

• Fine-grained warning control [permalink]
  You can turn on/off particular warnings. Here is an alignment warning, but in a situation where the code actually does generate an aligned address, but the compiler can't convince itself:

  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wcast-align"
              scan = (fileinfo *) (((char *) scan) + scan->length);
  #pragma clang diagnostic pop
  

• Giving the event loop some love [permalink]
  Say you're in a callback environment in the main thread, but need to update the UI, like to update a progress meter. You can give the runloop a chance to do one flip by doing:

  void giveSomeLove ()
  {
      // give the app some love so it'll update the window
      [[NSRunLoop currentRunLoop] runUntilDate: [NSDate distantPast]];
  } // giveSomeLove

• Iterating through an NSIndexSet [permalink]
  

  unsigned index;
  for (index = [indexSet firstIndex];
        index != NSNotFound; index = [indexSet indexGreaterThanIndex: index])  {
     ...
  }
  

  (courtesy of mikeash)

• Loading a nib file [permalink]
  

  if ([NSBundle loadNibNamed: @"theNibName.nib"  owner: self]) {
      ... life is happy
  } else {
      ... couldn't load the nib
  }
  

• Make an NSValue out of an NSRect [permalink]
  

      NSRect selectionRect = ...;
      NSValue *value;
      value = [NSValue valueWithRect: selectionRect];
  

• Making a moby file out of a hierarchy [permalink]
  

  % find . -name "*.h" -print -exec cat {} \; > ~/moby-file.h
  

• Making naked memory autoreleased [permalink]
  (courtesy of Mike Ash, who fixed some errors in the previous version of this quickie)

  void *tempCopyOf(void *data, NSUInteger size)
  {
     return data ? [[NSData dataWithBytes:data length:size] mutableBytes] : NULL;
  }
  

  OBTW, these techniques will fail under GC. Here's how you'd write a working one under GC:

  void *tempCopyOf(void *data, NSUInteger size)
  {
     void *buffer = NULL;
     if( data ) {
         buffer = NSAllocateCollectable(size, 0);
         memcpy(buffer, data, size);
     }
     return buffer;
  }
  

  Unfortunately I'm not aware of a nice way that works in dual-mode code.

• Open path sheet in the Finder [permalink]
  Open a Finder window, then type command-shift-g. Works in standard file dialogs too.

• Quicktime X Player A/V controls [permalink]
  When watching pre-recorded sessions from technical conferences, I like to speed them up. Usually I can speed up things to 1.5x to 1.8x speed and still understand what's going on. I was able to speed Matt Gemmell up to 2.5x and could still understand him. Amazing. Quicktime 7 had nice A/V controls to speed up the video. You can download Quicktime 7 and use its player.

  Quicktime X's player doesn't have an A/V controls window, but you can option-click the fast-forward button to increase the speed by 0.1x. Keep clicking to go faster. Unfortunately you can't pause when sped up, so if you pause, you have to re-click to your desired speedup.

• Reading a file as an NSData [permalink]
  

      NSString *filename = @"/this/is/my/file/path";
  
      NSData *data;
      data = [NSData dataWithContentsOfFile: filename];
  

• Resetting user defaults [permalink]
  Sometimes you just want to blow away all your app's defaults and return to the factory default settings. RooSwitch is a great way to do it for your app for testing or debugging. Or if you need to do it in code:

      NSUserDefaults *defs = [NSUserDefaults standardUserDefaults];
  
      NSString *appDomain = [[NSBundle mainBundle] bundleIdentifier];
      [defs removePersistentDomainForName: appDomain];
  

• Setting iPhone status bar to black [permalink]
  In the app's info.plist, set UIStatusBarStyle to UIStatusBarStyleOpaqueBlack

• Toggling an index in an NSMutableIndexSet [permalink]
  NSUInteger index = indexPath.row; if ([_selection containsIndex: index]) [_selection removeIndex: index]; else [_selection addIndex: index];

• Turn off the Lion "autorepeat shows accent chooser" [permalink]
  I actually want my characters to autorepeat rather than seeing the accent chooser. Run this in the terminal, and restart affected apps:

  defaults write -g ApplePressAndHoldEnabled -bool false

  (thanks to Paul Kafasis)

• Turn off the Lion window animation [permalink]
  

  defaults write NSGlobalDomain NSAutomaticWindowAnimationsEnabled -bool NO

• Turning off Yosemite focus ring highlight animation [permalink]
  I'm not a fan of animations in general. I'm really not a fan of the Yosemite focus ring animation. Usually I'm already half-way through typing by the time the animation ends. Here's a way to turn it off:

  % defaults write -globalDomain NSUseAnimatedFocusRing -bool NO
  

  Thanks to @rsesek.

• Unicode characters in C strings [permalink]
  C strings (and Objective-C @"Strings") are ascii by default, so to include unicode characters, you need to escape-U them:

  printf ("\u3232_\u3232\u2122\n");
  

• Using NSInvocation [permalink]
  When you have a target and a selector, it's pretty easy to invoke the selector on the target if you're passing one or two parameters, with performSelector:, performSelector:withObject:, and so on. If you need to pass three arguments, or things that aren't objects, then you need to use NSInvocation.

  In this case, the selector being called takes two arguments, one of which is an object, the other is an NSTimeInterval. The atIndex: jazz starts with 2 so that the self parameter and the selector can be passed to the method.

    NSMethodSignature *signature = [target_ methodSignatureForSelector:selector_];
  
    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
    [invocation setSelector:selector_];
    [invocation setTarget:target_];
    [invocation setArgument:&self
                atIndex:2];
    [invocation setArgument:&lastWait_
                atIndex:3];
  
    [invocation invoke];

• Using an NSOpenPanel [permalink]
  

      NSOpenPanel *panel = [NSOpenPanel openPanel];
  
      [panel setPrompt: @"Stuff for the Choose Button"];
  
      [panel beginSheetForDirectory: nil
             file: nil
             types: [NSArray arrayWithObject: @"buf"] // or other file types
             modalForWindow: window
             modalDelegate: self
             didEndSelector: @selector(openPanelDidEnd:returnCode:contextInfo:)
             contextInfo: nil];

  and the didEndSelector implementation looks kinda like this:

  - (void) openPanelDidEnd: (NSOpenPanel *) sheet
                returnCode: (int) returnCode
               contextInfo: (void *) context
  {
      if (returnCode == NSOKButton) {
          NSArray *fileNames = [sheet filenames];
  
          NSLog (@"wooOOooot! %@", [fileNames objectAtIndex: 0]);
      }
  
  } // openPanelDidEnd

• Using an NSOpenPanel [permalink]
  Using an NSOpenPanel with blocks:

  - (IBAction) openEarthinizerDoc: (id) sender {
      NSOpenPanel *panel = [NSOpenPanel openPanel];
  
      [panel beginSheetModalForWindow: self.window
             completionHandler: ^(NSInteger result) {
              if (result == NSFileHandlingPanelOKButton) {
                  NSURL *url = [[panel URLs] objectAtIndex: 0];
                  [self openURL: url];
              }
          }];
  
  } // openEarthinizerDoc
  

• Verifying Localizable.strings [permalink]
  if there's an error in Localizable.string, your NSLocalizedString() call will not look up the strings in the file. To verify the file, do something like this:

  % pl < Localizable.strings

• show predefined preprocessor macros [permalink]
  % gcc -E -dM - </dev/null

Hacks

• A Quieter NSLog [permalink]
  

  // NSLog() writes out entirely too much stuff.  Most of the time I'm
  // not interested in the program name, process ID, and current time
  // down to the subsecond level.
  // This takes an NSString with printf-style format, and outputs it.
  // regular old printf can't be used instead because it doesn't
  // support the '%@' format option.
  
  void QuietLog (NSString *format, ...) {
    va_list argList;
    va_start (argList, format);
    NSString *message = [[[NSString alloc] initWithFormat: format
                                                arguments: argList] autorelease];
    fprintf (stderr, "%s\n", [message UTF8String]);
    va_end  (argList);
  } // QuietLog
  

• Having powerbook not wake from sleep when the lid opens [permalink]
  # pmset lidwake 0

Random

• Converting from a path to an FSRef [permalink]
  

    NSString *pathString = ... whatever ...;
  
    FSRef ref;
    status = FSPathMakeRef ((const UInt8 *)[pathString fileSystemRepresentation],
                            &ref, NULL);
  
    if (status != noErr) {
        NSLog (@"bummer.  couldn't make FSREf from path '%@'",
               pathString);
    }

• Derezzing resource files [permalink]
  I needed to derez a resource file, with the data living in the resource fork, and get editable STR and STR# entities. Here's one way to do it, with the moving pieces in bold.

  % /Developer/Tools/DeRez -useDF  ./blarg.rsrc  /Developer/SDKs/MacOSX10.4u.sdk/Developer/Headers/FlatCarbon/MacTypes.r  > oopack2

  And the reverse process is like:

  % /Developer/Tools/Rez -o blah.rsrc -useDF  /Developer/SDKs/MacOSX10.4u.sdk/Developer/Headers/FlatCarbon/MacTypes.r oopack2

• Making a Cocoa moby file [permalink]
  

  % cat /System/Library/Frameworks/Foundation.framework/Headers/*.h > ~/moby
  % cat /System/Library/Frameworks/AppKit.framework/Headers/*.h >> ~/moby
  % chmod 444 ~/moby

• Varargs in Objective-C [permalink]
  This processes a nil-terminated sequence of strings:

  - (void) snorgWaffle: (NSString *) start, ... {
  
      va_list argList;
      va_start (argList, start);
  
      NSString *string = start;
  
      while (string != nil) {
          NSLog (@"Done did saw string '%@'", string);
  
          string = va_arg (argList, NSString *);
      }
  
      va_end (argList);
  
  } // snorgWaffle

  and can be called like

  [self snorgWaffle:@"red", @"planet", @"zeitgeist", nil];

• printf'ing / NSLogging strings without a terminating zero byte [permalink]
  

    printf ("hello %.*s\n", 5, "there is no good going on");
    NSLog (@"hello %.*s\n", 5, "there is no good going on");

  results in

  hello there
  2007-05-04 09:14:15.575 printf[4914] hello there

  Similarly, something like printf ("hello %*.*s\n", 10, 5, "florgsnorgle"); will right-justify 'florg' in a field of 10 characters.

  (Thanks to TVL for this goodie)

Swift

• Accessing a class method from an instance. [permalink]
  Say you have an instance, and you want to call a class method, similar to objc where you could do something like self.class.insets.left. Use type(of: self).methodName()

  class Bargle {
      static func greeble() {
          print("Blargle greeble")
      }
  
      func oopack() {
          type(of: self).greeble()
      }
  }
  
  let bargle = Bargle()
  bargle.oopack()
  

  This will cause Blargle greeble

• Making a Data out of an array of UInt8 [permalink]
  

  var payload: [UInt8] = [0x09, 0x00, 0x07, 0x00, 0x12, 0x00, 0x64, 0x02, 0x03, 0x04,
                          0x09, 0x81, 0x12, 0x00, 0x07, 0x00, 0x32, 0x04, 0x05, 0x06,
                          0x00, 0x00, 0x00, 0x00]
  
  let bufferPointer = UnsafeBufferPointer(start: &payload, count: payload.count)
  let buffer = Data(buffer: bufferPointer)
  

• sizeof in swift [permalink]
  Say you have a struct:

  struct Thingie {
      let blah: Uint8
      let greeble: UInt8
      let splunge: UInt8
  }
  

  Get the sizeof via

  let packetLength = MemoryLayout.size
  

  That's the packed size. To account for alignment/padding, use stride.

---