I’m not a big fan of debugging from log statements, but they can occasionally be useful.

What follows is details on building a full NSLog() replacement that turns off with a single #ifdef in the header file that contains the function. You can either download the m and h file, or continue on to the extended entry for an explanation of how it works and ways to make it more useful for your particular needs.

Start with a basic Xcode Foundation Tool. This will contain a main.m file that uses NSLog to print “Hello World!”

  NSLog(@"Hello, World!");

The output will look like this:

  2009-03-23 10:57:13.619 DebugLog[11941:807] Hello, World!

Add a DebugLog.h and DebugLog.m to the file. DebugLog.h should declare a method DebugLog() that will be the replacement for NSLog()

  void DebugLog(NSString *format,...);

And DebugLog.m should contain the implementation of that function. A particular item to note is that NSLog only adds a newline to the end of the NSLog format if one is not already there. This function duplicates this feature of NSLog()

  void DebugLog(NSString *format,...) {
    va_list ap;
    va_start (ap, format);
    if (![format hasSuffix: @"\n"]) {
      format = [format stringByAppendingString: @"\n"];
    }
    NSString *body =  [[NSString alloc] initWithFormat: format arguments: ap];
    va_end (ap);
    fprintf(stderr,"%s",[body UTF8String]);
    [body release];
  }

You can download the project at this stage. If you play with the project at this point you will notice the output is different than NSLog().

  // With NSLog
  2009-03-23 11:01:32.936 DebugLog[12085:807] Hello, World!
  2009-03-23 11:01:32.938 DebugLog[12085:807] Hello, World!
  // With DebugLog
  Hello, World!
  Hello, World!

NSLog() includes the time, process name, process id and thread id as a prefix on every message. I find this excessive in most cases, but you can add it in if you wish. More on this later.

In the next version of the project, disable the function except for Debug builds. Do this by editing DebugLog.h to have an #ifdef that turns DebugLog() into a macro, and rename the function from DebugLog to _DebugLog. By using a #else we can disable DebugLog for any non DEBUG builds.

  #ifdef DEBUG
  #define DebugLog(args...) _DebugLog(args);
  #else
  #define DebugLog(x...)
  #endif
  void _DebugLog(NSString *format,...);

Rename the function in DebugLog.m as well.

  void _DebugLog(NSString *format,...) {

Finally, setup the build settings to include a DEBUG flag. For more deatil or for iPhone configurations, see the the post that inspired this one.

Now try building both the Debug and Release version. Run from the command line, only the Debug version will produce the debug lines

  explorer:karl/tmp/DebugLog%./build/Debug/DebugLog
  Hello, World!
  explorer:karl/tmp/DebugLog%./build/Release/DebugLog
  explorer:karl/tmp/DebugLog%

Again, you can download the project at this stage.

Now take the function from better to best. By using some preprocessor directives we can embed the name of the file and line number where the DebugLog() is called, or have it print a function or method name.

Change the macro definition and function declaration:

  #ifdef DEBUG
  #define DebugLog(args...) _DebugLog(__FILE__,__LINE__,args);
  #else
  #define DebugLog(x...)
  #endif
  void _DebugLog(const char *file, int lineNumber, NSString *format,...);

and change the fprintf() in the implementation to print the passed arguments:

  fprintf(stderr,"%s:%d %s",file,lineNumber,[body UTF8String]);

The output will now look like this:

  /Users/karl/tmp/DebugLog/main.m:15 Hello, World!

The __FILE__ is expanded to the complete path to the file, which is usually more verbose that I need. It can be trimmed down to the actual file name by using an NSString method:

  ...
  NSString *fileName=[[NSString stringWithUTF8String:file] lastPathComponent];
  fprintf(stderr,"%s:%d %s",[fileName UTF8String],lineNumber,[body UTF8String]);
  ...

This will produce this output:

  main.m 15 Hello, World!

Again, you can download the project at this stage.

Finally, here is a more tricked out version that prints the function or method name instead of the file name, and prints the name of the thread.

  explorer:karl/tmp/DebugLog%./build/Debug/DebugLog
  MainThread/main (main.m:16) Hello, World!
  MainThread/+[SampleClass debugExample] (SampleClass.m:16) A sample debug message
  MainThread/-[SampleClass debugExample] (SampleClass.m:21) Another sample debug message

The final project can be downloaded here. Stick the #import into your prefix header, and you can liberally sprinkle DebugLog commands all over your code.

The Desktop & Screen Saver module in Preferences in has an option for “Main Screen Only”, in part to make the ugly look bearable, and in part because some screen savers have a nasty habit of never being tested on multiple monitor setups and crashing when running under that configuration.

To help put an end to this, I ported WanderingPolygon, a ScreenSaver that I wrote for NeXTSTEP in 1991 to run as a true “multiple monitor” screen saver. A 3 to 9 sided polygon wanders across all your monitors, while cycling through a smooth ribbon of colors. While I have only been able to test on a dual monitor setup, it should be able to deal correctly with any arrangement of one or more monitors. I even tested it with non-contigous monitor setups.

The source for the screen saver can be downloaded as zip file (WanderingPolygon.zip). The source includes the orginal 1991 release as well. When I get a moment I’ll add it to the public SVN repository.

If you want to just download the binary module, you can download that as a zip file as well (WanderingPolygon.saver.zip)

The source was pounded out in just an hour or so, most of which was spent running through various test scenarios, so it isn’t particularly pretty, and there are no configurable options except through recompiling, but it should be easy ti figure out how to adapt this for other screen savers. In the next day or so I hope to write a more thorough technical description for those interested in developing multiple monitor savers.

If you have any questions in the mean time, you can drop me an email at karl@karlkraft.com

A fellow programmer needed to find where crontab entries were stored so I showed him this trick. If you need to know where an application is saving state you can follow this simple 3 step process.

Create a file using touch. In this example the file is called TIMESTAMP.

touch TIMESTAMP

Now go about the process of running the application. In his case he edited his crontab entries:

crontab -e

You can then find every file on your hard drive that was modified after the TIMESTAMP file with this command:

find / -newer TIMESTAMP

If you are pretty sure that the data would need to be somewhere underneath your home directory you can use this alternative:

find ~ -newer TIMESTAMP

Unfortunately there is no documentation, and when I last looked a whopping 3 google hits for the function name. This should make it number four.

If you want to draw a well or button in a view is to start with a bitmap image the same size as your view. But what to do if you want to write a reusable class that can work at any size? And how to deal with resolution independence?

NSDrawNinePartImage solves the problem. To use it you create a 3×3 matrix of images. You can either create them independently, or just draw a single image in PhotoShop and then break it apart in code.

Here is some sample code that appears in the OneMinuteEggTimer example application that is used for demonstrating the sound picker.

Start with the sample image. In this case the image in 24×24 pixels, but I’ve blown the image up to make it clearer what is going on.

The first step is to break the image into a 3×3 matrix. The corners will be drawn as is, the sides will each be tiled in one dimension, and the center will be tiled in two dimensions. You can either break it using Photoshop, or programatically when your class is first used.

The +initialize method is called the first time your view class is referenced. This is a function of the Objective-C runtime. This code will take an image named SoundPickerBackground, and break it into 9 8×8 tiles.

static NSImage *topLeftCornerImage;
static NSImage *topEdgeImage;
static NSImage *topRightCornerImage;
static NSImage *leftEdgeImage;
static NSImage *centerImage;
static NSImage *rightEdgeImage;
static NSImage *bottomLeftCornerImage;
static NSImage *bottomEdgeImage;
static NSImage *bottomRightCornerImage;

+ (void)initialize;
{
  if (baseImage) return;

  NSRect tileRect = NSMakeRect(0,0,8,8);

  baseImage = [NSImage imageNamed:@"SoundPickerBackground"];

  topLeftCornerImage = [[NSImage alloc] initWithSize:tileRect.size];
  [topLeftCornerImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(0.0,16.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [topLeftCornerImage unlockFocus];

  topEdgeImage = [[NSImage alloc] initWithSize:tileRect.size];
  [topEdgeImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(8.0,16.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [topEdgeImage unlockFocus];

  topRightCornerImage = [[NSImage alloc] initWithSize:tileRect.size];
  [topRightCornerImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(16.0,16.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [topRightCornerImage unlockFocus];

  leftEdgeImage = [[NSImage alloc] initWithSize:tileRect.size];
  [leftEdgeImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(0,8.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [leftEdgeImage unlockFocus];

  centerImage = [[NSImage alloc] initWithSize:tileRect.size];
  [centerImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(8.0,8.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [centerImage unlockFocus];

  rightEdgeImage = [[NSImage alloc] initWithSize:tileRect.size];
  [rightEdgeImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(16.0,8.0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [rightEdgeImage unlockFocus];

  bottomLeftCornerImage = [[NSImage alloc] initWithSize:tileRect.size];
  [bottomLeftCornerImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(0,0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [bottomLeftCornerImage unlockFocus];

  bottomEdgeImage = [[NSImage alloc] initWithSize:tileRect.size];
  [bottomEdgeImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(8.0,0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [bottomEdgeImage unlockFocus];

  bottomRightCornerImage = [[NSImage alloc] initWithSize:tileRect.size];
  [bottomRightCornerImage lockFocus];
  [baseImage drawInRect:tileRect
               fromRect:NSMakeRect(16.0,0,8.0,8.0)
              operation:NSCompositeCopy fraction:1.0];
  [bottomRightCornerImage unlockFocus];
}

Now when you need to draw the nine tiles, you simple call NSDrawNinePartImage in drawRect:

- (void)drawRect:(NSRect)rect;
{
  NSDrawNinePartImage([self bounds],
                      topLeftCornerImage, topEdgeImage, topRightCornerImage,
                      leftEdgeImage, centerImage, rightEdgeImage,
                      bottomLeftCornerImage, bottomEdgeImage, bottomRightCornerImage,
                      NSCompositeSourceOver, 1.0, NO);
}

Drawn as 48×48

Drawn as 128×128


// Example
NSLog(@"Starting %d",1);
// 2007-06-26 01:39:35.629 MyGreatApp[3106:813] Starting 1
QLog(@"Starting %d",1);
// Starting 1


As a bonus you can also redirect the output of QLog to a file by using setDebugOutputPath()

void setDebugOutputPath(NSString *filePath)

Note that filePath is not overwritten but rather appends new debug lines.