X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b698c8e9bfbcf149f8ac375ea5b5ff6af9cba86a..186954b0af3ac476da74235dc6bedd47643837dc:/src/mac/carbon/bitmap.cpp diff --git a/src/mac/carbon/bitmap.cpp b/src/mac/carbon/bitmap.cpp index 409d2fb3a8..ec5d91854e 100644 --- a/src/mac/carbon/bitmap.cpp +++ b/src/mac/carbon/bitmap.cpp @@ -10,7 +10,6 @@ ///////////////////////////////////////////////////////////////////////////// #ifdef __GNUG__ -#pragma implementation "bitmapbase.h" #pragma implementation "bitmap.h" #endif @@ -22,14 +21,11 @@ #include "wx/image.h" #include "wx/xpmdecod.h" -#if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) -IMPLEMENT_ABSTRACT_CLASS(wxBitmapBase , wxGDIObject ) -IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandlerBase, wxObject ) -#endif +IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject ) -#ifdef __UNIX__ +#ifdef __DARWIN__ #include #else #include @@ -39,149 +35,258 @@ IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandlerBase, wxObject ) CTabHandle wxMacCreateColorTable( int numColors ) { - CTabHandle newColors; /* Handle to the new color table */ - - /* Allocate memory for the color table */ - newColors = (CTabHandle)NewHandleClear( sizeof (ColorTable) + - sizeof (ColorSpec) * (numColors - 1) ); - if (newColors != nil) - { - /* Initialize the fields */ - (**newColors).ctSeed = GetCTSeed(); - (**newColors).ctFlags = 0; - (**newColors).ctSize = numColors - 1; - /* Initialize the table of colors */ - } - return newColors ; + CTabHandle newColors; /* Handle to the new color table */ + + /* Allocate memory for the color table */ + newColors = (CTabHandle)NewHandleClear( sizeof (ColorTable) + + sizeof (ColorSpec) * (numColors - 1) ); + if (newColors != nil) + { + /* Initialize the fields */ + (**newColors).ctSeed = GetCTSeed(); + (**newColors).ctFlags = 0; + (**newColors).ctSize = numColors - 1; + /* Initialize the table of colors */ + } + return newColors ; } void wxMacDestroyColorTable( CTabHandle colors ) { - DisposeHandle( (Handle) colors ) ; + DisposeHandle( (Handle) colors ) ; } void wxMacSetColorTableEntry( CTabHandle newColors , int index , int red , int green , int blue ) { - (**newColors).ctTable[index].value = index; - (**newColors).ctTable[index].rgb.red = 0 ;// someRedValue; - (**newColors).ctTable[index].rgb.green = 0 ; // someGreenValue; - (**newColors).ctTable[index].rgb.blue = 0 ; // someBlueValue; + (**newColors).ctTable[index].value = index; + (**newColors).ctTable[index].rgb.red = 0 ;// someRedValue; + (**newColors).ctTable[index].rgb.green = 0 ; // someGreenValue; + (**newColors).ctTable[index].rgb.blue = 0 ; // someBlueValue; } GWorldPtr wxMacCreateGWorld( int width , int height , int depth ) { - OSErr err = noErr ; - GWorldPtr port ; - Rect rect = { 0 , 0 , height , width } ; - - if ( depth < 0 ) - { - depth = wxDisplayDepth() ; - } - - err = NewGWorld( &port , depth , &rect , NULL , NULL , 0 ) ; - if ( err == noErr ) - { - return port ; - } - return NULL ; + OSErr err = noErr ; + GWorldPtr port ; + Rect rect = { 0 , 0 , height , width } ; + + if ( depth < 0 ) + { + depth = wxDisplayDepth() ; + } + + err = NewGWorld( &port , depth , &rect , NULL , NULL , 0 ) ; + if ( err == noErr ) + { + return port ; + } + return NULL ; } void wxMacDestroyGWorld( GWorldPtr gw ) { - if ( gw ) - DisposeGWorld( gw ) ; + if ( gw ) + DisposeGWorld( gw ) ; } -PicHandle wxMacCreatePict(GWorldPtr wp, GWorldPtr mask) +#define kDefaultRes 0x00480000 /* Default resolution is 72 DPI; Fixed type */ + +OSErr SetupCIconHandlePixMap( CIconHandle icon , short depth , Rect *bounds , CTabHandle colors ) { - CGrafPtr origPort ; - GDHandle origDev ; + CTabHandle newColors; /* Color table used for the off-screen PixMap */ + Ptr offBaseAddr; /* Pointer to the off-screen pixel image */ + OSErr error; /* Returns error code */ + short bytesPerRow; /* Number of bytes per row in the PixMap */ - PicHandle pict; // this is the Picture we give back - RGBColor gray = { 0xCCCC ,0xCCCC , 0xCCCC } ; - RGBColor white = { 0xffff ,0xffff , 0xffff } ; - RGBColor black = { 0x0000 ,0x0000 , 0x0000 } ; + error = noErr; + newColors = nil; + offBaseAddr = nil; - unsigned char *maskimage = NULL ; - Rect portRect ; - GetPortBounds( wp , &portRect ) ; - int width = portRect.right - portRect.left ; - int height = portRect.bottom - portRect.top ; + bytesPerRow = ((depth * (bounds->right - bounds->left) + 31) / 32) * 4; - LockPixels( GetGWorldPixMap( wp ) ) ; - GetGWorld( &origPort , &origDev ) ; + /* Clone the clut if indexed color; allocate a dummy clut if direct color*/ + if (depth <= 8) + { + newColors = colors; + error = HandToHand((Handle *) &newColors); + } + else + { + newColors = (CTabHandle) NewHandle(sizeof(ColorTable) - + sizeof(CSpecArray)); + error = MemError(); + } + if (error == noErr) + { + /* Allocate pixel image; long integer multiplication avoids overflow */ + (**icon).iconData = NewHandle((unsigned long) bytesPerRow * (bounds->bottom - + bounds->top)); + if ((**icon).iconData != nil) + { + /* Initialize fields common to indexed and direct PixMaps */ + (**icon).iconPMap.baseAddr = 0; /* Point to image */ + (**icon).iconPMap.rowBytes = bytesPerRow | /* MSB set for PixMap */ + 0x8000; + (**icon).iconPMap.bounds = *bounds; /* Use given bounds */ + (**icon).iconPMap.pmVersion = 0; /* No special stuff */ + (**icon).iconPMap.packType = 0; /* Default PICT pack */ + (**icon).iconPMap.packSize = 0; /* Always zero in mem */ + (**icon).iconPMap.hRes = kDefaultRes; /* 72 DPI default res */ + (**icon).iconPMap.vRes = kDefaultRes; /* 72 DPI default res */ + (**icon).iconPMap.pixelSize = depth; /* Set # bits/pixel */ + + /* Initialize fields specific to indexed and direct PixMaps */ + if (depth <= 8) + { + /* PixMap is indexed */ + (**icon).iconPMap.pixelType = 0; /* Indicates indexed */ + (**icon).iconPMap.cmpCount = 1; /* Have 1 component */ + (**icon).iconPMap.cmpSize = depth; /* Component size=depth */ + (**icon).iconPMap.pmTable = newColors; /* Handle to CLUT */ + } + else + { + /* PixMap is direct */ + (**icon).iconPMap.pixelType = RGBDirect; /* Indicates direct */ + (**icon).iconPMap.cmpCount = 3; /* Have 3 components */ + if (depth == 16) + (**icon).iconPMap.cmpSize = 5; /* 5 bits/component */ + else + (**icon).iconPMap.cmpSize = 8; /* 8 bits/component */ + (**newColors).ctSeed = 3 * (**icon).iconPMap.cmpSize; + (**newColors).ctFlags = 0; + (**newColors).ctSize = 0; + (**icon).iconPMap.pmTable = newColors; + } + } + else + error = MemError(); + } + else + newColors = nil; - if ( mask ) - { - maskimage = (unsigned char*) malloc( width * height ) ; - SetGWorld( mask , NULL ) ; - LockPixels( GetGWorldPixMap( mask ) ) ; - for ( int y = 0 ; y < height ; y++ ) - { - for( int x = 0 ; x < width ; x++ ) - { - RGBColor col ; - - GetCPixel( x + portRect.left , y + portRect.top , &col ) ; - maskimage[y*width + x] = ( col.red == 0 ) ; // for monochrome masks - } - } - UnlockPixels( GetGWorldPixMap( mask ) ) ; - } + /* If no errors occured, return a handle to the new off-screen PixMap */ + if (error != noErr) + { + if (newColors != nil) + DisposeCTable(newColors); + } - SetGWorld( wp , NULL ) ; + /* Return the error code */ + return error; +} - pict = OpenPicture(&portRect); // open a picture, this disables drawing - if(!pict) - return NULL; +CIconHandle wxMacCreateCIcon(GWorldPtr image , GWorldPtr mask , short dstDepth , short iconSize ) +{ + GWorldPtr saveWorld; + GDHandle saveHandle; - if ( maskimage ) - { - RGBForeColor( &black ) ; - RGBBackColor( &white ) ; - PenMode(transparent); + GetGWorld(&saveWorld,&saveHandle); // save Graphics env state + SetGWorld(image,nil); - for ( int y = 0 ; y < height ; ++y ) - { - for( int x = 0 ; x < width ; ++x ) - { - if ( maskimage[y*width + x] ) - { - RGBColor col ; + Rect frame = { 0 , 0 , iconSize , iconSize } ; + Rect imageBounds = frame ; + GetPortBounds( image , &imageBounds ) ; - GetCPixel( x + portRect.left , y + portRect.top , &col ) ; - SetCPixel( x + portRect.left , y + portRect.top , &col ) ; - } - else { - // With transparency set this sets a blank pixel not a white one - SetCPixel( x + portRect.left , y + portRect.top , &white); - } - } - } - free( maskimage ) ; - maskimage = NULL ; - } - else - { - RGBBackColor( &gray ) ; - EraseRect(&portRect); - RGBForeColor( &black ) ; - RGBBackColor( &white ) ; - - CopyBits(GetPortBitMapForCopyBits(wp), /* src PixMap - we copy image over - * itself - */ - GetPortBitMapForCopyBits(wp), // dst PixMap - no drawing occurs - &portRect, // srcRect - it will be recorded and compressed - - &portRect, // dstRect - into the picture that is open - - srcCopy,NULL); // copyMode and no clip region - } - ClosePicture(); // We are done recording the picture - UnlockPixels( GetGWorldPixMap( wp ) ) ; - SetGWorld( origPort , origDev ) ; + int bwSize = iconSize / 8 * iconSize ; + CIconHandle icon = (CIconHandle) NewHandleClear( sizeof ( CIcon ) + 2 * bwSize) ; + HLock((Handle)icon) ; + SetupCIconHandlePixMap( icon , dstDepth , &frame,GetCTable(dstDepth)) ; + HLock( (**icon).iconData ) ; + (**icon).iconPMap.baseAddr = *(**icon).iconData ; - return pict; // return our groovy pict handle + LockPixels(GetGWorldPixMap(image)); + + CopyBits(GetPortBitMapForCopyBits(image), + (BitMapPtr)&((**icon).iconPMap), + &imageBounds, + &imageBounds, + srcCopy | ditherCopy, nil); + + + UnlockPixels(GetGWorldPixMap(image)); + HUnlock( (**icon).iconData ) ; + + (**icon).iconMask.rowBytes = iconSize / 8 ; + (**icon).iconMask.bounds = frame ; + + (**icon).iconBMap.rowBytes = iconSize / 8 ; + (**icon).iconBMap.bounds = frame ; + (**icon).iconMask.baseAddr = (char*) &(**icon).iconMaskData ; + (**icon).iconBMap.baseAddr = (char*) &(**icon).iconMaskData + bwSize ; + + if ( mask ) + { + LockPixels(GetGWorldPixMap(mask) ) ; + CopyBits(GetPortBitMapForCopyBits(mask) , + &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ; + CopyBits(GetPortBitMapForCopyBits(mask) , + &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ; + UnlockPixels(GetGWorldPixMap( mask ) ) ; + } + else + { + LockPixels(GetGWorldPixMap(image)); + CopyBits(GetPortBitMapForCopyBits(image) , + &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ; + CopyBits(GetPortBitMapForCopyBits(image) , + &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ; + UnlockPixels(GetGWorldPixMap(image)); + } + + (**icon).iconMask.baseAddr = NULL ; + (**icon).iconBMap.baseAddr = NULL ; + (**icon).iconPMap.baseAddr = NULL ; + HUnlock((Handle)icon) ; + SetGWorld(saveWorld,saveHandle); + + return icon; +} + +PicHandle wxMacCreatePict(GWorldPtr wp, GWorldPtr mask) +{ + CGrafPtr origPort ; + GDHandle origDev ; + + PicHandle pict; + + RGBColor white = { 0xffff ,0xffff , 0xffff } ; + RGBColor black = { 0x0000 ,0x0000 , 0x0000 } ; + + GetGWorld( &origPort , &origDev ) ; + + RgnHandle clipRgn = NULL ; + + if ( mask ) + { + clipRgn = NewRgn() ; + LockPixels( GetGWorldPixMap( mask ) ) ; + BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( mask ) ) ; + UnlockPixels( GetGWorldPixMap( mask ) ) ; + } + + SetGWorld( wp , NULL ) ; + Rect portRect ; + GetPortBounds( wp , &portRect ) ; + + pict = OpenPicture(&portRect); + if(pict) + { + RGBForeColor( &black ) ; + RGBBackColor( &white ) ; + + LockPixels( GetGWorldPixMap( wp ) ) ; + CopyBits(GetPortBitMapForCopyBits(wp), + GetPortBitMapForCopyBits(wp), + &portRect, + &portRect, + srcCopy,clipRgn); + UnlockPixels( GetGWorldPixMap( wp ) ) ; + ClosePicture(); + } + SetGWorld( origPort , origDev ) ; + return pict; } wxBitmapRefData::wxBitmapRefData() @@ -199,67 +304,66 @@ wxBitmapRefData::wxBitmapRefData() m_bitmapType = kMacBitmapTypeUnknownType ; } -wxBitmapRefData::~wxBitmapRefData() +// TODO move this do a public function of Bitmap Ref +static void DisposeBitmapRefData(wxBitmapRefData *data) { - switch (m_bitmapType) - { - case kMacBitmapTypePict : - { - if ( m_hPict ) - { - KillPicture( m_hPict ) ; - m_hPict = NULL ; - } - } - break ; - case kMacBitmapTypeGrafWorld : - { - if ( m_hBitmap ) - { - wxMacDestroyGWorld( m_hBitmap ) ; - m_hBitmap = NULL ; - } - } - break ; - case kMacBitmapTypeIcon : - if ( m_hIcon ) - { - DisposeCIcon( m_hIcon ) ; - m_hIcon = NULL ; - } - - default : - // unkown type ? - break ; - } - - if (m_bitmapMask) + switch (data->m_bitmapType) + { + case kMacBitmapTypePict : + { + if ( data->m_hPict ) + { + KillPicture( MAC_WXHMETAFILE( data->m_hPict ) ) ; + data->m_hPict = NULL ; + } + } + break ; + case kMacBitmapTypeGrafWorld : + { + if ( data->m_hBitmap ) + { + wxMacDestroyGWorld( MAC_WXHBITMAP(data->m_hBitmap) ) ; + data->m_hBitmap = NULL ; + } + } + break ; + case kMacBitmapTypeIcon : + if ( data->m_hIcon ) + { + DisposeCIcon( MAC_WXHICON(data->m_hIcon) ) ; + data->m_hIcon = NULL ; + } + + default : + // unkown type ? + break ; + } + + if (data->m_bitmapMask) { - delete m_bitmapMask; - m_bitmapMask = NULL; + delete data->m_bitmapMask; + data->m_bitmapMask = NULL; } } -wxList wxBitmapBase::sm_handlers; - +wxBitmapRefData::~wxBitmapRefData() +{ + DisposeBitmapRefData( this ) ; +} bool wxBitmap::CopyFromIcon(const wxIcon& icon) { Ref(icon) ; + return true; } wxBitmap::wxBitmap() { m_refData = NULL; - - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); } wxBitmap::~wxBitmap() { - if (wxTheBitmapList) - wxTheBitmapList->DeleteObject(this); } wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits) @@ -273,29 +377,29 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits if ( no_bits == 1 ) { M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ; - M_BITMAPDATA->m_hBitmap = wxMacCreateGWorld( the_width , the_height , no_bits ) ; - M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ; - - CGrafPtr origPort ; - GDHandle origDevice ; - + MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) = wxMacCreateGWorld( the_width , the_height , no_bits ) ; + M_BITMAPDATA->m_ok = (MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) != NULL ) ; + + CGrafPtr origPort ; + GDHandle origDevice ; + GetGWorld( &origPort , &origDevice ) ; - SetGWorld( M_BITMAPDATA->m_hBitmap , NULL ) ; - LockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ; - + SetGWorld( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) , NULL ) ; + LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) ) ) ; + // bits is a char array - + unsigned char* linestart = (unsigned char*) bits ; int linesize = ( the_width / (sizeof(unsigned char) * 8)) ; if ( the_width % (sizeof(unsigned char) * 8) ) { linesize += sizeof(unsigned char); } - + RGBColor colors[2] = { { 0xFFFF , 0xFFFF , 0xFFFF } , { 0, 0 , 0 } } ; - + for ( int y = 0 ; y < the_height ; ++y , linestart += linesize ) { for ( int x = 0 ; x < the_width ; ++x ) @@ -313,42 +417,29 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits } } } - UnlockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ; - + UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) ) ) ; + SetGWorld( origPort , origDevice ) ; } else { wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented")); } - - if ( wxTheBitmapList ) { - wxTheBitmapList->AddBitmap(this); - } } wxBitmap::wxBitmap(int w, int h, int d) { (void)Create(w, h, d); - - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); } wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth) { (void) Create(data, type, width, height, depth); - - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); } wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type) { LoadFile(filename, type); - - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); } bool wxBitmap::CreateFromXpm(const char **bits) @@ -358,7 +449,6 @@ bool wxBitmap::CreateFromXpm(const char **bits) wxImage img = decoder.ReadData(bits); wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") ) *this = wxBitmap(img); - if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); return TRUE; } @@ -384,7 +474,7 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const wxBitmap ret( rect.width, rect.height, GetDepth() ); wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") ); - WXHBITMAP origPort; + GWorldPtr origPort; GDHandle origDevice; GetGWorld( &origPort, &origDevice ); @@ -406,10 +496,10 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const // Copy mask if(GetMask()) { - WXHBITMAP submask, mask; + GWorldPtr submask, mask; RGBColor color; - mask = GetMask()->GetMaskBitmap(); + mask = (GWorldPtr) GetMask()->GetMaskBitmap(); submask = wxMacCreateGWorld(rect.width, rect.height, 1); LockPixels(GetGWorldPixMap(mask)); LockPixels(GetGWorldPixMap(submask)); @@ -433,11 +523,11 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const // Copy bitmap if(GetHBITMAP()) { - WXHBITMAP subbitmap, bitmap; + GWorldPtr subbitmap, bitmap; RGBColor color; - bitmap = GetHBITMAP(); - subbitmap = wxMacCreateGWorld(rect.width, rect.height, GetDepth()); + bitmap = (GWorldPtr) GetHBITMAP(); + subbitmap = (GWorldPtr) ref->m_hBitmap ; LockPixels(GetGWorldPixMap(bitmap)); LockPixels(GetGWorldPixMap(subbitmap)); @@ -453,7 +543,6 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const } UnlockPixels(GetGWorldPixMap(bitmap)); UnlockPixels(GetGWorldPixMap(subbitmap)); - ret.SetHBITMAP(subbitmap); } } SetGWorld( origPort, origDevice ); @@ -473,7 +562,7 @@ bool wxBitmap::Create(int w, int h, int d) M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ; M_BITMAPDATA->m_hBitmap = wxMacCreateGWorld( w , h , d ) ; - M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ; + M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ; return M_BITMAPDATA->m_ok; } @@ -486,9 +575,11 @@ int wxBitmap::GetBitmapType() const void wxBitmap::SetHBITMAP(WXHBITMAP bmp) { + DisposeBitmapRefData( M_BITMAPDATA ) ; + M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ; M_BITMAPDATA->m_hBitmap = bmp ; - M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ; + M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ; } bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type) @@ -499,7 +590,7 @@ bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type) if ( handler ) { - m_refData = new wxBitmapRefData; + m_refData = new wxBitmapRefData; return handler->LoadFile(this, filename, type, -1, -1); } @@ -539,63 +630,74 @@ wxBitmap::wxBitmap(const wxImage& image, int depth) m_refData = new wxBitmapRefData(); - if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this); - // width and height of the device-dependent bitmap int width = image.GetWidth(); int height = image.GetHeight(); // Create picture - Create( width , height , wxDisplayDepth() ) ; - wxBitmap maskBitmap( width, height, 1); + Create( width , height , 32 ) ; CGrafPtr origPort ; GDHandle origDevice ; - LockPixels( GetGWorldPixMap(GetHBITMAP()) ); - LockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) ); + PixMapHandle pixMap = GetGWorldPixMap((GWorldPtr)GetHBITMAP()) ; + LockPixels( pixMap ); GetGWorld( &origPort , &origDevice ) ; - SetGWorld( GetHBITMAP() , NULL ) ; + SetGWorld( (GWorldPtr) GetHBITMAP() , NULL ) ; // Render image - wxColour rgb, maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue()); - RGBColor color; - RGBColor white = { 0xffff, 0xffff, 0xffff }; - RGBColor black = { 0 , 0 , 0 }; + RGBColor colorRGB ; register unsigned char* data = image.GetData(); - - int index = 0; + char* destinationBase = GetPixBaseAddr( pixMap ); + register unsigned char* destination = (unsigned char*) destinationBase ; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { - rgb.Set(data[index++], data[index++], data[index++]); - color = rgb.GetPixel(); - SetCPixel( x , y , &color ) ; - if (image.HasMask()) - { - SetGWorld(maskBitmap.GetHBITMAP(), NULL); - if (rgb == maskcolor) { - SetCPixel(x,y, &white); - } - else { - SetCPixel(x,y, &black); - } - SetGWorld(GetHBITMAP(), NULL); - } + *destination++ = 0 ; + *destination++ = *data++ ; + *destination++ = *data++ ; + *destination++ = *data++ ; } - } // for height + destinationBase += ((**pixMap).rowBytes & 0x7fff); + destination = (unsigned char*) destinationBase ; + } + if ( image.HasMask() ) + { + data = image.GetData(); + + wxColour maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue()); + RGBColor white = { 0xffff, 0xffff, 0xffff }; + RGBColor black = { 0 , 0 , 0 }; + wxBitmap maskBitmap ; + + maskBitmap.Create( width, height, 1); + LockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) ); + SetGWorld( (GWorldPtr) maskBitmap.GetHBITMAP(), NULL); - // Create mask - if ( image.HasMask() ) { - SetMask(new wxMask( maskBitmap )); + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + if ( data[0] == image.GetMaskRed() && data[1] == image.GetMaskGreen() && data[2] == image.GetMaskBlue() ) + { + SetCPixel(x,y, &white); + } + else { + SetCPixel(x,y, &black); + } + data += 3 ; + } + } // for height + SetGWorld( (GWorldPtr) GetHBITMAP(), NULL); + SetMask(new wxMask( maskBitmap )); + UnlockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) ); } - UnlockPixels( GetGWorldPixMap(GetHBITMAP()) ); - UnlockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) ); + UnlockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP()) ); SetGWorld( origPort, origDevice ); } @@ -614,7 +716,7 @@ wxImage wxBitmap::ConvertToImage() const wxCHECK_MSG( data, wxNullImage, wxT("Could not allocate data for image") ); - WXHBITMAP origPort; + GWorldPtr origPort; GDHandle origDevice; int index; RGBColor color; @@ -624,8 +726,8 @@ wxImage wxBitmap::ConvertToImage() const wxMask *mask = GetMask(); GetGWorld( &origPort, &origDevice ); - LockPixels(GetGWorldPixMap(GetHBITMAP())); - SetGWorld( GetHBITMAP(), NULL); + LockPixels(GetGWorldPixMap( (GWorldPtr) GetHBITMAP())); + SetGWorld( (GWorldPtr) GetHBITMAP(), NULL); // Copy data into image index = 0; @@ -659,7 +761,7 @@ wxImage wxBitmap::ConvertToImage() const } // Free resources - UnlockPixels(GetGWorldPixMap(GetHBITMAP())); + UnlockPixels(GetGWorldPixMap( (GWorldPtr) GetHBITMAP())); SetGWorld(origPort, origDevice); return image; @@ -797,10 +899,10 @@ WXHBITMAP wxBitmap::GetHBITMAP() const { wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ); - return M_BITMAPDATA->m_hBitmap; + return MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap); } -PicHandle wxBitmap::GetPict() const +WXHMETAFILE wxBitmap::GetPict() const { wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ); @@ -823,16 +925,16 @@ PicHandle wxBitmap::GetPict() const wxMask *mask; Rect portRect ; - GetPortBounds( GetHBITMAP() , &portRect ) ; + GetPortBounds( (GWorldPtr) GetHBITMAP() , &portRect ) ; int width = portRect.right - portRect.left ; int height = portRect.bottom - portRect.top ; - LockPixels( GetGWorldPixMap( GetHBITMAP() ) ) ; + LockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP() ) ) ; GetGWorld( &origPort , &origDev ) ; mask = GetMask(); - SetGWorld( GetHBITMAP() , NULL ) ; + SetGWorld( (GWorldPtr) GetHBITMAP() , NULL ) ; picture = OpenPicture(&portRect); // open a picture, this disables drawing if(!picture) { @@ -841,7 +943,7 @@ PicHandle wxBitmap::GetPict() const if( mask ) { -#ifdef __UNIX__ +#ifdef __DARWIN__ RGBColor trans = white; #else RGBBackColor( &gray ); @@ -877,83 +979,21 @@ PicHandle wxBitmap::GetPict() const RGBForeColor( &black ) ; RGBBackColor( &white ) ; - CopyBits(GetPortBitMapForCopyBits(GetHBITMAP()), + CopyBits(GetPortBitMapForCopyBits( (GWorldPtr) GetHBITMAP()), // src PixMap - we copy image over itself - - GetPortBitMapForCopyBits(GetHBITMAP()), + GetPortBitMapForCopyBits( (GWorldPtr) GetHBITMAP()), // dst PixMap - no drawing occurs &portRect, // srcRect - it will be recorded and compressed - &portRect, // dstRect - into the picture that is open - srcCopy,NULL); // copyMode and no clip region } ClosePicture(); // We are done recording the picture - UnlockPixels( GetGWorldPixMap( GetHBITMAP() ) ) ; + UnlockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP() ) ) ; SetGWorld( origPort , origDev ) ; return picture; // return our groovy pict handle } -void wxBitmap::AddHandler(wxBitmapHandler *handler) -{ - sm_handlers.Append(handler); -} - -void wxBitmap::InsertHandler(wxBitmapHandler *handler) -{ - sm_handlers.Insert(handler); -} - -bool wxBitmap::RemoveHandler(const wxString& name) -{ - wxBitmapHandler *handler = FindHandler(name); - if ( handler ) - { - sm_handlers.DeleteObject(handler); - return TRUE; - } - else - return FALSE; -} - -wxBitmapHandler *wxBitmap::FindHandler(const wxString& name) -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetName() == name ) - return handler; - node = node->Next(); - } - return NULL; -} - -wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, wxBitmapType type) -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetExtension() == extension && - (type == -1 || handler->GetType() == type) ) - return handler; - node = node->Next(); - } - return NULL; -} - -wxBitmapHandler *wxBitmap::FindHandler(wxBitmapType type) -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if (handler->GetType() == type) - return handler; - node = node->Next(); - } - return NULL; -} - /* * wxMask */ @@ -988,11 +1028,11 @@ wxMask::wxMask(const wxBitmap& bitmap) wxMask::~wxMask() { - if ( m_maskBitmap ) - { - wxMacDestroyGWorld( m_maskBitmap ) ; - m_maskBitmap = NULL ; - } + if ( m_maskBitmap ) + { + wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ; + m_maskBitmap = NULL ; + } } // Create a mask from a mono bitmap (copies the bitmap). @@ -1000,7 +1040,7 @@ bool wxMask::Create(const wxBitmap& bitmap) { if ( m_maskBitmap ) { - wxMacDestroyGWorld( m_maskBitmap ) ; + wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ; m_maskBitmap = NULL ; } wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false, @@ -1015,13 +1055,13 @@ bool wxMask::Create(const wxBitmap& bitmap) m_maskBitmap = wxMacCreateGWorld(bitmap.GetWidth(), bitmap.GetHeight(), 1); Rect rect = { 0,0, bitmap.GetHeight(), bitmap.GetWidth() }; - LockPixels( GetGWorldPixMap(m_maskBitmap) ); - LockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) ); - CopyBits(GetPortBitMapForCopyBits(bitmap.GetHBITMAP()), - GetPortBitMapForCopyBits(m_maskBitmap), + LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap) ); + LockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP()) ); + CopyBits(GetPortBitMapForCopyBits( (GWorldPtr) bitmap.GetHBITMAP()), + GetPortBitMapForCopyBits( (GWorldPtr) m_maskBitmap), &rect, &rect, srcCopy, 0); - UnlockPixels( GetGWorldPixMap(m_maskBitmap) ); - UnlockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) ); + UnlockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap) ); + UnlockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP()) ); return FALSE; } @@ -1039,59 +1079,59 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex) // the transparent area bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour) { - if ( m_maskBitmap ) - { - wxMacDestroyGWorld( m_maskBitmap ) ; - m_maskBitmap = NULL ; - } - wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false, + if ( m_maskBitmap ) + { + wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ; + m_maskBitmap = NULL ; + } + wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false, wxT("Cannot create mask from this bitmap type (TODO)")); - // other types would require a temporary bitmap. not yet implemented - + // other types would require a temporary bitmap. not yet implemented + wxCHECK_MSG( bitmap.Ok(), false, wxT("Illigal bitmap")); - m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 ); - LockPixels( GetGWorldPixMap( m_maskBitmap ) ); - LockPixels( GetGWorldPixMap( bitmap.GetHBITMAP() ) ); - RGBColor maskColor = colour.GetPixel(); + m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 ); + LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap ) ); + LockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP() ) ); + RGBColor maskColor = MAC_WXCOLORREF(colour.GetPixel()); // this is not very efficient, but I can't think // of a better way of doing it - CGrafPtr origPort ; - GDHandle origDevice ; + CGrafPtr origPort ; + GDHandle origDevice ; RGBColor col; RGBColor colors[2] = { { 0xFFFF, 0xFFFF, 0xFFFF }, { 0, 0, 0 }}; - - GetGWorld( &origPort , &origDevice ) ; - for (int w = 0; w < bitmap.GetWidth(); w++) + + GetGWorld( &origPort , &origDevice ) ; + for (int w = 0; w < bitmap.GetWidth(); w++) { for (int h = 0; h < bitmap.GetHeight(); h++) - { - SetGWorld( bitmap.GetHBITMAP(), NULL ) ; - GetCPixel( w , h , &col ) ; - SetGWorld( m_maskBitmap , NULL ) ; + { + SetGWorld( (GWorldPtr) bitmap.GetHBITMAP(), NULL ) ; + GetCPixel( w , h , &col ) ; + SetGWorld( (GWorldPtr) m_maskBitmap , NULL ) ; if (col.red == maskColor.red && col.green == maskColor.green && col.blue == maskColor.blue) { - SetCPixel( w , h , &colors[0] ) ; + SetCPixel( w , h , &colors[0] ) ; } else { - SetCPixel( w , h , &colors[1] ) ; + SetCPixel( w , h , &colors[1] ) ; } } } - UnlockPixels( GetGWorldPixMap( (CGrafPtr) m_maskBitmap ) ) ; - UnlockPixels( GetGWorldPixMap( bitmap.GetHBITMAP() ) ) ; - SetGWorld( origPort , origDevice ) ; + UnlockPixels( GetGWorldPixMap( (CGrafPtr) m_maskBitmap ) ) ; + UnlockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP() ) ) ; + SetGWorld( origPort , origDevice ) ; return TRUE; } bool wxMask::PointMasked(int x, int y) { - WXHBITMAP origPort; + GWorldPtr origPort; GDHandle origDevice; RGBColor color; bool masked = true; @@ -1099,11 +1139,11 @@ bool wxMask::PointMasked(int x, int y) GetGWorld( &origPort, &origDevice); //Set port to mask and see if it masked (1) or not ( 0 ) - SetGWorld(m_maskBitmap, NULL); - LockPixels(GetGWorldPixMap(m_maskBitmap)); + SetGWorld( (GWorldPtr) m_maskBitmap, NULL); + LockPixels(GetGWorldPixMap( (GWorldPtr) m_maskBitmap)); GetCPixel(x,y, &color); masked = !(color.red == 0 && color.green == 0 && color.blue == 0); - UnlockPixels(GetGWorldPixMap(m_maskBitmap)); + UnlockPixels(GetGWorldPixMap( (GWorldPtr) m_maskBitmap)); SetGWorld( origPort, origDevice); @@ -1114,8 +1154,6 @@ bool wxMask::PointMasked(int x, int y) * wxBitmapHandler */ -IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) - bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth) { return FALSE; @@ -1155,69 +1193,35 @@ IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler, wxBitmapHandler) bool wxPICTResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags, int desiredWidth, int desiredHeight) { - Str255 theName ; - + Str255 theName ; + #if TARGET_CARBON - c2pstrcpy( (StringPtr) theName , name ) ; + c2pstrcpy( (StringPtr) theName , name ) ; #else - strcpy( (char *) theName , name ) ; - c2pstr( (char *)theName ) ; + strcpy( (char *) theName , name ) ; + c2pstr( (char *)theName ) ; #endif - - PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ; - if ( thePict ) - { - PictInfo theInfo ; - - GetPictInfo( thePict , &theInfo , 0 , 0 , systemMethod , 0 ) ; - DetachResource( (Handle) thePict ) ; - M_BITMAPHANDLERDATA->m_bitmapType = kMacBitmapTypePict ; - M_BITMAPHANDLERDATA->m_hPict = thePict ; - M_BITMAPHANDLERDATA->m_width = theInfo.sourceRect.right - theInfo.sourceRect.left ; - M_BITMAPHANDLERDATA->m_height = theInfo.sourceRect.bottom - theInfo.sourceRect.top ; - - M_BITMAPHANDLERDATA->m_depth = theInfo.depth ; - M_BITMAPHANDLERDATA->m_ok = true ; - M_BITMAPHANDLERDATA->m_numColors = theInfo.uniqueColors ; -// M_BITMAPHANDLERDATA->m_bitmapPalette; -// M_BITMAPHANDLERDATA->m_quality; - return TRUE ; - } - return FALSE ; -} - -#if 0 // The following is an example for creating a bitmap handler - -// TODO: bitmap handlers, a bit like this: -class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler -{ - DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) -public: - inline wxBMPResourceHandler() - { - m_name = "Windows bitmap resource"; - m_extension = ""; - m_type = wxBITMAP_TYPE_BMP_RESOURCE; - }; - - virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, - int desiredWidth, int desiredHeight); -}; -IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler) - -#endif - -void wxBitmap::CleanUpHandlers() -{ - wxNode *node = sm_handlers.First(); - while ( node ) + + PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ; + if ( thePict ) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - wxNode *next = node->Next(); - delete handler; - delete node; - node = next; + PictInfo theInfo ; + + GetPictInfo( thePict , &theInfo , 0 , 0 , systemMethod , 0 ) ; + DetachResource( (Handle) thePict ) ; + M_BITMAPHANDLERDATA->m_bitmapType = kMacBitmapTypePict ; + M_BITMAPHANDLERDATA->m_hPict = thePict ; + M_BITMAPHANDLERDATA->m_width = theInfo.sourceRect.right - theInfo.sourceRect.left ; + M_BITMAPHANDLERDATA->m_height = theInfo.sourceRect.bottom - theInfo.sourceRect.top ; + + M_BITMAPHANDLERDATA->m_depth = theInfo.depth ; + M_BITMAPHANDLERDATA->m_ok = true ; + M_BITMAPHANDLERDATA->m_numColors = theInfo.uniqueColors ; +// M_BITMAPHANDLERDATA->m_bitmapPalette; +// M_BITMAPHANDLERDATA->m_quality; + return TRUE ; } + return FALSE ; } void wxBitmap::InitStandardHandlers()