X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b2680ced12cbbed16990007c5fa3ea7730700122..c9ed413ab4f5673ffff00198dc6ce1397398bda4:/src/osx/carbon/utilscocoa.mm diff --git a/src/osx/carbon/utilscocoa.mm b/src/osx/carbon/utilscocoa.mm index 4fdf07c240..49fc2247d0 100644 --- a/src/osx/carbon/utilscocoa.mm +++ b/src/osx/carbon/utilscocoa.mm @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: src/mac/carbon/utils.mm +// Name: src/osx/carbon/utils.mm // Purpose: various cocoa mixin utility functions // Author: Stefan Csomor // Modified by: @@ -21,6 +21,12 @@ #include "wx/osx/private.h" #endif +#include "wx/fontutil.h" + +#if wxOSX_USE_COCOA +#include "wx/cocoa/string.h" +#endif + #ifdef __WXMAC__ #if wxOSX_USE_CARBON @@ -44,15 +50,35 @@ wxMacAutoreleasePool::~wxMacAutoreleasePool() #endif -#if defined( __WXCOCOCA__ ) || wxOSX_USE_COCOA +#if wxOSX_USE_COCOA -CGContextRef wxMacGetContextFromCurrentNSContext() +CGContextRef wxOSXGetContextFromCurrentContext() { CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; return context; } +bool wxOSXLockFocus( WXWidget view) +{ + return [view lockFocusIfCanDraw]; +} + +void wxOSXUnlockFocus( WXWidget view) +{ + [view unlockFocus]; +} + +#endif + +#if wxOSX_USE_IPHONE + +CGContextRef wxOSXGetContextFromCurrentContext() +{ + CGContextRef context = UIGraphicsGetCurrentContext(); + return context; +} + #endif // ---------------------------------------------------------------------------- @@ -69,38 +95,317 @@ void wxMacCocoaAutorelease( void* obj ) [(NSObject*)obj autorelease]; } -void wxMacCocoaRetain( void* obj ) +void* wxMacCocoaRetain( void* obj ) { [(NSObject*)obj retain]; + return obj; } +// ---------------------------------------------------------------------------- +// NSFont Utils +// ---------------------------------------------------------------------------- + #if wxOSX_USE_COCOA +wxFont::wxFont(WX_NSFont nsfont) +{ + [nsfont retain]; + wxNativeFontInfo info; + SetNativeInfoFromNSFont(nsfont, &info); + Create(info); +} + +void wxFont::SetNativeInfoFromNSFont(WX_NSFont theFont, wxNativeFontInfo* info) +{ + if ( info->m_faceName.empty()) + { + //Get more information about the user's chosen font + NSFontTraitMask theTraits = [[NSFontManager sharedFontManager] traitsOfFont:theFont]; + int theFontWeight = [[NSFontManager sharedFontManager] weightOfFont:theFont]; + + wxFontFamily fontFamily = wxFONTFAMILY_DEFAULT; + //Set the wx font to the appropriate data + if(theTraits & NSFixedPitchFontMask) + fontFamily = wxFONTFAMILY_TELETYPE; + + wxFontStyle fontstyle = wxFONTSTYLE_NORMAL; + wxFontWeight fontweight = wxFONTWEIGHT_NORMAL; + bool underlined = false; + + int size = (int) ([theFont pointSize]+0.5); + + if ( theFontWeight >= 9 ) + fontweight = wxFONTWEIGHT_BOLD ; + else if ( theFontWeight < 5 ) + fontweight = wxFONTWEIGHT_LIGHT; + else + fontweight = wxFONTWEIGHT_NORMAL ; + + if ( theTraits & NSItalicFontMask ) + fontstyle = wxFONTSTYLE_ITALIC ; + + info->Init(size,fontFamily,fontstyle,fontweight,underlined, + wxStringWithNSString([theFont familyName]), wxFONTENCODING_DEFAULT); + + } +} + +WX_NSFont wxFont::OSXCreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info) +{ + NSFont* nsfont = nil; + switch( font ) + { + case wxOSX_SYSTEM_FONT_NORMAL: + nsfont = [NSFont systemFontOfSize:[NSFont systemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_BOLD: + nsfont = [NSFont boldSystemFontOfSize:[NSFont systemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_SMALL: + nsfont = [NSFont systemFontOfSize:[NSFont smallSystemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_SMALL_BOLD: + nsfont = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_MINI: + nsfont = [NSFont systemFontOfSize: + [NSFont systemFontSizeForControlSize:NSMiniControlSize]]; + break; + case wxOSX_SYSTEM_FONT_MINI_BOLD: + nsfont = [NSFont boldSystemFontOfSize: + [NSFont systemFontSizeForControlSize:NSMiniControlSize]]; + break; + case wxOSX_SYSTEM_FONT_LABELS: + nsfont = [NSFont labelFontOfSize:[NSFont labelFontSize]]; + break; + case wxOSX_SYSTEM_FONT_VIEWS: + nsfont = [NSFont controlContentFontOfSize:0]; + break; + default: + break; + } + [nsfont retain]; + SetNativeInfoFromNSFont(nsfont, info); + return nsfont; +} + +static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; } +static const NSAffineTransformStruct kSlantNSTransformStruct = { 1, 0, tan(DegToRad(11)), 1, 0, 0 }; + +WX_NSFont wxFont::OSXCreateNSFont(const wxNativeFontInfo* info) +{ + NSFont* nsFont; + int weight = 5; + NSFontTraitMask traits = 0; + if (info->m_weight == wxFONTWEIGHT_BOLD) + { + traits |= NSBoldFontMask; + weight = 9; + } + else if (info->m_weight == wxFONTWEIGHT_LIGHT) + weight = 3; + + if (info->m_style == wxFONTSTYLE_ITALIC || info->m_style == wxFONTSTYLE_SLANT) + traits |= NSItalicFontMask; + + nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString() + traits:traits weight:weight size:info->m_pointSize]; + + if ( nsFont == nil ) + { + NSFontTraitMask remainingTraits = traits; + nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString() + traits:0 weight:5 size:info->m_pointSize]; + if ( nsFont == nil ) + { + if ( info->m_weight == wxFONTWEIGHT_BOLD ) + { + nsFont = [NSFont boldSystemFontOfSize:info->m_pointSize]; + remainingTraits &= ~NSBoldFontMask; + } + else + nsFont = [NSFont systemFontOfSize:info->m_pointSize]; + } + + // fallback - if in doubt, let go of the bold attribute + if ( nsFont && (remainingTraits & NSItalicFontMask) ) + { + NSFont* nsFontWithTraits = nil; + if ( remainingTraits & NSBoldFontMask) + { + nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSBoldFontMask]; + if ( nsFontWithTraits == nil ) + { + nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSItalicFontMask]; + if ( nsFontWithTraits != nil ) + remainingTraits &= ~NSItalicFontMask; + } + else + { + remainingTraits &= ~NSBoldFontMask; + } + } + // the code below causes crashes, because fontDescriptorWithMatrix is not returning a valid font descriptor + // it adds a NSCTFontMatrixAttribute as well which cannot be disposed of correctly by the autorelease pool + // so at the moment we have to disable this and cannot synthesize italic fonts if they are not available on the system +#if 0 + if ( remainingTraits & NSItalicFontMask ) + { + if ( nsFontWithTraits == nil ) + nsFontWithTraits = nsFont; + + NSAffineTransform* transform = [NSAffineTransform transform]; + [transform setTransformStruct:kSlantNSTransformStruct]; + [transform scaleBy:info->m_pointSize]; + NSFontDescriptor* italicDesc = [[nsFontWithTraits fontDescriptor] fontDescriptorWithMatrix:transform]; + if ( italicDesc != nil ) + { + NSFont* f = [NSFont fontWithDescriptor:italicDesc size:(CGFloat)(info->m_pointSize)]; + if ( f != nil ) + nsFontWithTraits = f; + } + } +#endif + if ( nsFontWithTraits != nil ) + nsFont = nsFontWithTraits; + } + } + + wxASSERT_MSG(nsFont != nil,wxT("Couldn't create nsFont")) ; + wxMacCocoaRetain(nsFont); + return nsFont; +} + +#endif +#if wxOSX_USE_IPHONE + +WX_UIFont wxFont::OSXCreateUIFont(wxOSXSystemFont font, wxNativeFontInfo* info) +{ + UIFont* uifont; + switch( font ) + { + case wxOSX_SYSTEM_FONT_NORMAL: + uifont = [UIFont systemFontOfSize:[UIFont systemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_BOLD: + uifont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_MINI: + case wxOSX_SYSTEM_FONT_SMALL: + uifont = [UIFont systemFontOfSize:[UIFont smallSystemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_MINI_BOLD: + case wxOSX_SYSTEM_FONT_SMALL_BOLD: + uifont = [UIFont boldSystemFontOfSize:[UIFont smallSystemFontSize]]; + break; + case wxOSX_SYSTEM_FONT_VIEWS: + case wxOSX_SYSTEM_FONT_LABELS: + uifont = [UIFont systemFontOfSize:[UIFont labelFontSize]]; + break; + default: + break; + } + [uifont retain]; + if ( info->m_faceName.empty()) + { + wxFontStyle fontstyle = wxFONTSTYLE_NORMAL; + wxFontWeight fontweight = wxFONTWEIGHT_NORMAL; + bool underlined = false; + + int size = (int) ([uifont pointSize]+0.5); + /* + NSFontSymbolicTraits traits = [desc symbolicTraits]; + + if ( traits & NSFontBoldTrait ) + fontweight = wxFONTWEIGHT_BOLD ; + else + fontweight = wxFONTWEIGHT_NORMAL ; + if ( traits & NSFontItalicTrait ) + fontstyle = wxFONTSTYLE_ITALIC ; + */ + wxCFStringRef fontname( wxCFRetain([uifont familyName]) ); + info->Init(size,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined, + fontname.AsString(), wxFONTENCODING_DEFAULT); + + } + return uifont; +} + +WX_UIFont wxFont::OSXCreateUIFont(const wxNativeFontInfo* info) +{ + UIFont* uiFont; + uiFont = [UIFont fontWithName:wxCFStringRef(info->m_faceName).AsNSString() size:info->m_pointSize]; + wxMacCocoaRetain(uiFont); + return uiFont; +} + +#endif // ---------------------------------------------------------------------------- // NSImage Utils // ---------------------------------------------------------------------------- +#if wxOSX_USE_IPHONE + +WX_UIImage wxOSXGetUIImageFromCGImage( CGImageRef image ) +{ + UIImage *newImage = [UIImage imageWithCGImage:image]; + [newImage autorelease]; + return( newImage ); +} + +#endif + +#if wxOSX_USE_COCOA + // From "Cocoa Drawing Guide:Working with Images" -WX_NSImage CreateNSImageFromCGImage( CGImageRef image ) +WX_NSImage wxOSXGetNSImageFromCGImage( CGImageRef image ) { NSRect imageRect = NSMakeRect(0.0, 0.0, 0.0, 0.0); - + // Get the image dimensions. imageRect.size.height = CGImageGetHeight(image); imageRect.size.width = CGImageGetWidth(image); - + // Create a new image to receive the Quartz image data. - NSImage *newImage = [[NSImage alloc] initWithSize:imageRect.size]; + NSImage *newImage = [[NSImage alloc] initWithSize:imageRect.size]; [newImage lockFocus]; - + // Get the Quartz context and draw. CGContextRef imageContext = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort]; CGContextDrawImage( imageContext, *(CGRect*)&imageRect, image ); [newImage unlockFocus]; - + + /* + // Create a bitmap rep from the image... + NSBitmapImageRep *bitmapRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage]; + // Create an NSImage and add the bitmap rep to it... + NSImage *image = [[NSImage alloc] init]; + [image addRepresentation:bitmapRep]; + [bitmapRep release]; + */ + [newImage autorelease]; return( newImage ); } +CGImageRef wxOSXCreateCGImageFromNSImage( WX_NSImage nsimage ) +{ + // based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html + + NSSize imageSize = [nsimage size]; + CGColorSpaceRef genericRGB = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); + CGContextRef context = CGBitmapContextCreate(NULL, imageSize.width, imageSize.height, 8, 0, genericRGB, kCGImageAlphaPremultipliedFirst); + NSGraphicsContext *nsGraphicsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO]; + [NSGraphicsContext saveGraphicsState]; + [NSGraphicsContext setCurrentContext:nsGraphicsContext]; + [[NSColor whiteColor] setFill]; + NSRectFill(NSMakeRect(0.0, 0.0, imageSize.width, imageSize.height)); + [nsimage drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeCopy fraction:1.0]; + [NSGraphicsContext setCurrentContext:nsGraphicsContext]; + CGImageRef image = CGBitmapContextCreateImage(context); + CFRelease(context); + return image; + } + // ---------------------------------------------------------------------------- // NSCursor Utils // ---------------------------------------------------------------------------- @@ -117,40 +422,49 @@ static NSCursor* wxGetStockCursor( short sIndex ) //NSCursor takes an NSImage takes a number of Representations - here //we need only one for the raw data - NSBitmapImageRep *theRep = - [[NSBitmapImageRep alloc] - initWithBitmapDataPlanes:nil // Allocate the buffer for us :) - pixelsWide:16 - pixelsHigh:16 - bitsPerSample:1 - samplesPerPixel:2 - hasAlpha:YES // Well, more like a mask... - isPlanar:NO - colorSpaceName:NSCalibratedWhiteColorSpace // Normal B/W - 0 black 1 white - bytesPerRow:0 // I don't care - figure it out for me :) - bitsPerPixel:2]; // bitsPerSample * samplesPerPixel - - //unsigned int is better to put data in then a void* - //note that working with bitfields would be a lot better here - - //but since it breaks some compilers... - wxUint32 *data = (wxUint32 *)[theRep bitmapData]; - - //traverse through the bitmap data - for (int i = 0; i < 16; ++i) + NSBitmapImageRep *theRep = [[NSBitmapImageRep alloc] + initWithBitmapDataPlanes: NULL // Tell Cocoa to allocate the planes for us. + pixelsWide: 16 // All classic cursors are 16x16 + pixelsHigh: 16 + bitsPerSample: 1 // All classic cursors are bitmaps with bitmasks + samplesPerPixel: 2 // Sample 0:image 1:mask + hasAlpha: YES // Identify last sample as a mask + isPlanar: YES // Use a separate array for each sample + colorSpaceName: NSCalibratedWhiteColorSpace // 0.0=black 1.0=white + bytesPerRow: 2 // Rows in each plane are on 2-byte boundaries (no pad) + bitsPerPixel: 1]; // same as bitsPerSample since data is planar + + // Ensure that Cocoa allocated 2 and only 2 of the 5 possible planes + unsigned char *planes[5]; + [theRep getBitmapDataPlanes:planes]; + wxASSERT(planes[0] != NULL); + wxASSERT(planes[1] != NULL); + wxASSERT(planes[2] == NULL); + wxASSERT(planes[3] == NULL); + wxASSERT(planes[4] == NULL); + + // NOTE1: The Cursor's bits field is white=0 black=1.. thus the bitwise-not + // Why not use NSCalibratedBlackColorSpace? Because that reverses the + // sense of the alpha (mask) plane. + // NOTE2: The mask data is 0=off 1=on + // NOTE3: Cocoa asks for "premultiplied" color planes. Since we have a + // 1-bit color plane and a 1-bit alpha plane we can just do a bitwise-and + // on the two. The original cursor bitmaps have 0 (white actually) for + // any masked-off pixels. Therefore every masked-off pixel would be wrong + // since we bit-flip all of the picture bits. In practice, Cocoa doesn't + // seem to care, but we are following the documentation. + + // Fill in the color (black/white) plane + for(int i=0; i<16; ++i) { - //bit alpha bit alpha ... :D - - //Notice the = instead of |= - - //this is to avoid doing a memset earlier - data[i] = 0; - - //do the rest of those bits and alphas :) - for (int shift = 0; shift < 32; ++shift) - { - const int bit = 1 << (shift >> 1); - data[i] |= ( !!( (pCursor->mask[i] & bit) ) ) << shift; - data[i] |= ( !( (pCursor->bits[i] & bit) ) ) << ++shift; - } + planes[0][2*i ] = (~pCursor->bits[i] & pCursor->mask[i]) >> 8 & 0xff; + planes[0][2*i+1] = (~pCursor->bits[i] & pCursor->mask[i]) & 0xff; + } + // Fill in the alpha (i.e. mask) plane + for(int i=0; i<16; ++i) + { + planes[1][2*i ] = pCursor->mask[i] >> 8 & 0xff; + planes[1][2*i+1] = pCursor->mask[i] & 0xff; } //add the representation (data) to the image @@ -260,6 +574,14 @@ WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type ) cursor = wxGetStockCursor(kwxCursorRoller); break; + case wxCURSOR_OPEN_HAND: + cursor = [[NSCursor openHandCursor] retain]; + break; + + case wxCURSOR_CLOSED_HAND: + cursor = [[NSCursor closedHandCursor] retain]; + break; + case wxCURSOR_CHAR: case wxCURSOR_ARROW: case wxCURSOR_LEFT_BUTTON: @@ -276,19 +598,17 @@ WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type ) WX_NSCursor wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY ) { static BOOL firstTime = YES; - + if ( firstTime ) { // Must first call [[[NSWindow alloc] init] release] to get the NSWindow machinery set up so that NSCursor can use a window to cache the cursor image [[[NSWindow alloc] init] release]; firstTime = NO; } - - NSImage *nsImage = CreateNSImageFromCGImage( cgImageRef ); + + NSImage *nsImage = wxOSXGetNSImageFromCGImage( cgImageRef ); NSCursor *cursor = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )]; - - [nsImage release]; - + return cursor; }