//

 //  GraphicsUtils.m

 //  MYUtilities

 //

 //  Copyright 2008 Jens Alfke. All rights reserved.

 //

 #import "GraphicsUtils.h"

 #import "FileUtils.h"

 #import <ApplicationServices/ApplicationServices.h>

 @implementation NSImage (MYUtilities)

 - (NSBitmapImageRep*) my_bitmapRep

 {

     NSSize max = {0,0};

     NSBitmapImageRep *bestRep = nil;

     for( NSImageRep *rep in self.representations )

         if( [rep isKindOfClass: [NSBitmapImageRep class]] ) {

             NSSize size = [rep size];

             if( size.width > max.width || size.height > max.height ) {

                 bestRep = (NSBitmapImageRep*)rep;

                 max = size;

             }

         }

     if( ! bestRep ) {

         NSImage *tiffImage = [[NSImage alloc] initWithData:[self TIFFRepresentation]];

         bestRep = [[tiffImage representations] objectAtIndex:0];

         [tiffImage autorelease];

     }

     return bestRep;

 }

 - (NSSize) my_sizeOfLargestRep

 {

     NSArray *reps = [self representations];

     NSSize max = {0,0};

     int i;

     for( i=[reps count]-1; i>=0; i-- ) {

         NSImageRep *rep = [reps objectAtIndex: i];

         NSSize size = [rep size];

         if( size.width > max.width || size.height > max.height ) {

             max = size;

         }

     }

     return max;

 }

 - (NSImage*) my_shrunkToFitIn: (NSSize) maxSize

 {

     NSSize size = self.size;

     float scale = MIN( maxSize.width/size.width, maxSize.height/size.height );

     if( scale >= 1.0 )

         return self;

     NSSize newSize = {roundf(size.width*scale), roundf(size.height*scale)};

     NSImage *newImage = [[NSImage alloc] initWithSize: newSize];

     [newImage lockFocus];

     NSGraphicsContext *context = [NSGraphicsContext currentContext];

     [context saveGraphicsState];

     [context setImageInterpolation: NSImageInterpolationHigh];

     [self drawInRect: NSMakeRect(0,0,newSize.width,newSize.height)

             fromRect: NSMakeRect(0,0,size.width,size.height)

            operation: NSCompositeCopy fraction: 1.0f];

     [context restoreGraphicsState];

     [newImage unlockFocus];

     return [newImage autorelease];

 }

 - (NSData*) my_JPEGData

 {

     return [self my_dataInFormat: NSJPEGFileType quality: 0.75f];

 }

 - (NSData*) my_dataInFormat: (NSBitmapImageFileType)format quality: (float)quality

 {

     NSBitmapImageRep *rep = self.my_bitmapRep;

     NSDictionary *props = [NSDictionary dictionaryWithObjectsAndKeys:

                            [NSNumber numberWithFloat: quality], NSImageCompressionFactor, nil];

     return [rep representationUsingType: format properties: props];

 }

 #if 0

 // Adapted from Apple's CocoaCreateMovie sample

 // <http://developer.apple.com/samplecode/Sample_Code/QuickTime/Basics/CocoaCreateMovie/MyController.m.htm>

 static void CopyNSImageRepToGWorld(NSBitmapImageRep *imageRepresentation, GWorldPtr gWorldPtr)

 {

     PixMapHandle  pixMapHandle;

     unsigned char*   pixBaseAddr;

     // Lock the pixels

     pixMapHandle = GetGWorldPixMap(gWorldPtr);

     LockPixels (pixMapHandle);

     pixBaseAddr = (unsigned char*) GetPixBaseAddr(pixMapHandle);

     const unsigned char* bitMapDataPtr = [imageRepresentation bitmapData];

     if ((bitMapDataPtr != nil) && (pixBaseAddr != nil))

     {

         int i,j;

         int pixmapRowBytes = GetPixRowBytes(pixMapHandle);

         NSSize imageSize = [imageRepresentation size];

         for (i=0; i< imageSize.height; i++)

         {

             const unsigned char *src = bitMapDataPtr + i * [imageRepresentation bytesPerRow];

             unsigned char *dst = pixBaseAddr + i * pixmapRowBytes;

             for (j = 0; j < imageSize.width; j++)

             {

                 *dst++ = 0;  // X - our src is 24-bit only

                 *dst++ = *src++; // Red component

                 *dst++ = *src++; // Green component

                 *dst++ = *src++; // Blue component

             }

         }

     }

     UnlockPixels(pixMapHandle);

 }

 - (NSData*) my_PICTData

 {

     // Locate the bitmap image rep:

     NSBitmapImageRep *rep;

     NSEnumerator *e = [[self representations] objectEnumerator];

     while( (rep=[e nextObject]) != nil ) {

         if( [rep isKindOfClass: [NSBitmapImageRep class]] )

             break;

     }

     if( ! rep ) {

         Warn(@"No bitmap image rep in image");

         return nil;

     }

     // Copy the image data into a GWorld:

     Rect bounds;

     SetRect(&bounds, 0,0,[rep pixelsWide],[rep pixelsHigh]);    

     GWorldPtr gworld;

     OSStatus err = NewGWorld(&gworld, 32, &bounds, NULL, NULL, 0);

     if( err ) {

         Warn(@"NewGWorld failed with err %i",err);

         return nil;

     }

     CopyNSImageRepToGWorld(rep,gworld);

     // Draw the GWorld into a PicHandle:

     CGrafPtr oldPort;

     GDHandle oldDevice;

     GetGWorld(&oldPort,&oldDevice);

     SetGWorld(gworld,NULL);

     ClipRect(&bounds);

     PicHandle pic = OpenPicture(&bounds);

     CopyBits(GetPortBitMapForCopyBits(gworld),

              GetPortBitMapForCopyBits(gworld),

              &bounds,&bounds,srcCopy,NULL);

     ClosePicture();

     err = QDError();

     SetGWorld(oldPort,oldDevice);

     DisposeGWorld(gworld);

     if( err ) {

         Warn(@"Couldn't convert to PICT: error %i",err);

         return nil;

     }

     // Copy the PicHandle into an NSData:

     HLock((Handle)pic);

     //Test to put PICT on clipboard:

     /*ScrapRef scrap;

     GetCurrentScrap(&scrap);

     ClearScrap(&scrap);

     PutScrapFlavor(scrap,'PICT',0,GetHandleSize((Handle)pic),*pic);*/

     NSData *data = [NSData dataWithBytes: *pic length: GetHandleSize((Handle)pic)];

     DisposeHandle((Handle)pic);

     Log(@"Converted image to %i bytes of PICT data",[data length]);

     return data;

 }

 #endif

 @end

 @implementation NSBezierPath (MYUtilities)

 + (NSBezierPath*) my_bezierPathWithRoundRect: (NSRect)rect radius: (float)radius

 {

     radius = MIN(radius, floorf(rect.size.width/2));

     float x0 = NSMinX(rect), y0 = NSMinY(rect),

           x1 = NSMaxX(rect), y1 = NSMaxY(rect);

     NSBezierPath *path = [NSBezierPath bezierPath];

     [path moveToPoint: NSMakePoint(x0+radius,y0)];

     [path appendBezierPathWithArcFromPoint: NSMakePoint(x1,y0)

                                    toPoint: NSMakePoint(x1,y1) radius: radius];

     [path appendBezierPathWithArcFromPoint: NSMakePoint(x1,y1)

                                    toPoint: NSMakePoint(x0,y1) radius: radius];

     [path appendBezierPathWithArcFromPoint: NSMakePoint(x0,y1)

                                    toPoint: NSMakePoint(x0,y0) radius: radius];

     [path appendBezierPathWithArcFromPoint: NSMakePoint(x0,y0)

                                    toPoint: NSMakePoint(x1,y0) radius: radius];

     [path closePath];

     return path;

 }

 @end

 NSArray* OpenWindowsWithDelegateClass( Class klass )

 {

     NSMutableArray *windows = $marray();

     for( NSWindow *window in [NSApp windows] ) {

         id delegate = window.delegate;

         if( (window.isVisible || window.isMiniaturized) && (klass==nil || [delegate isKindOfClass: klass]) ) 

             [windows addObject: window];

     }

     return windows;

 }    

 NSRect PinRect( NSRect r, NSRect container )

 {

     // Push r's origin inside container, and limit its size to the container's:

     r = NSMakeRect(MAX(r.origin.x, container.origin.x),

                    MAX(r.origin.y, container.origin.y),

                    MIN(r.size.width, container.size.width),

                    MIN(r.size.height, container.size.height));

     // Push r's outside edges into the container:

     r.origin.x -= MAX(0, NSMaxX(r)-NSMaxX(container));

     r.origin.y -= MAX(0, NSMaxY(r)-NSMaxY(container));

     return r;

 }

 OSStatus LoadFontsFromBundle( NSBundle *bundle )

 {

     NSString *fontsPath = [[bundle resourcePath] stringByAppendingPathComponent:@"Fonts"];

     if( fontsPath )

         return LoadFontsFromPath(fontsPath);

     else

         return fnfErr;

 }

 OSStatus LoadFontsFromPath( NSString* path )

 {

     // Tip of the hat to Buddy Kurz!

     FSRef fsRef;

     OSStatus err = PathToFSRef(path,&fsRef);

     if (err==noErr)

         err = ATSFontActivateFromFileReference(&fsRef,

                                                kATSFontContextLocal,

                                                kATSFontFormatUnspecified,

                                                NULL,

                                                kATSOptionFlagsDefault,

                                                NULL

                                                );

     if( err ) Warn(@"LoadFontsFromPath: Error %i for %@",err,path);

     return err;

 }