added wxListView class: this is going to be a wxListCtrl with human (inter)face

[wxWidgets.git] / src / mac / bitmap.cpp

diff --git a/src/mac/bitmap.cpp b/src/mac/bitmap.cpp
index 5d2b9fa638534fd3948b2ee7ab75379782e97ee5..409d2fb3a82799c6abd6f96ac07250f56c689dc7 100644 (file)
--- a/src/mac/bitmap.cpp
+++ b/src/mac/bitmap.cpp
@@ -10,30 +10,23 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__

+#pragma implementation "bitmapbase.h"

 #pragma implementation "bitmap.h"
 #endif
 
 #pragma implementation "bitmap.h"
 #endif
 

-#include "wx/wx.h"
-#include "wx/setup.h"
-#include "wx/utils.h"
-#include "wx/palette.h"
+#include "wx/defs.h"
+

 #include "wx/bitmap.h"
 #include "wx/icon.h"
 #include "wx/log.h"
 #include "wx/image.h"
 #include "wx/bitmap.h"
 #include "wx/icon.h"
 #include "wx/log.h"
 #include "wx/image.h"

-
-extern "C" 
-{
-#ifdef __UNIX__
-    #include "xpm/xpm.h"
-#else
-       #include "xpm.h"
-#endif
-} ;
+#include "wx/xpmdecod.h"

 
 #if !USE_SHARED_LIBRARIES
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 
 #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
 
 #ifdef __UNIX__
 #endif
 
 #ifdef __UNIX__


@@ -200,9 +193,10 @@ wxBitmapRefData::wxBitmapRefData()
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;

-               m_hBitmap = NULL ;
-               m_hPict = NULL ;
-               m_bitmapType = kMacBitmapTypeUnknownType ;
+    m_hBitmap = NULL ;
+    m_hPict = NULL ;
+    m_hIcon = NULL ;
+    m_bitmapType = kMacBitmapTypeUnknownType ;

 }
 
 wxBitmapRefData::~wxBitmapRefData()
 }
 
 wxBitmapRefData::~wxBitmapRefData()


@@ -227,6 +221,13 @@ wxBitmapRefData::~wxBitmapRefData()
                                }
                        }
                        break ;
                                }
                        }
                        break ;

+               case kMacBitmapTypeIcon :
+               if ( m_hIcon )
+               {
+                       DisposeCIcon( m_hIcon ) ;
+                       m_hIcon = NULL ;
+               }
+               

                default :
                        // unkown type ?
                        break ;
                default :
                        // unkown type ?
                        break ;


@@ -239,7 +240,13 @@ wxBitmapRefData::~wxBitmapRefData()
   }
 }
 
   }
 }
 

-wxList wxBitmap::sm_handlers;
+wxList wxBitmapBase::sm_handlers;
+
+
+bool wxBitmap::CopyFromIcon(const wxIcon& icon)
+{
+    Ref(icon) ;
+}

 
 wxBitmap::wxBitmap()
 {
 
 wxBitmap::wxBitmap()
 {


@@ -265,55 +272,54 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits
     M_BITMAPDATA->m_numColors = 0;
     if ( no_bits == 1 )
     {
     M_BITMAPDATA->m_numColors = 0;
     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 ) ;
+        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 ;
+        CGrafPtr       origPort ;
+        GDHandle       origDevice ;

        
        

-       GetGWorld( &origPort , &origDevice ) ;
-       SetGWorld( M_BITMAPDATA->m_hBitmap , NULL ) ;
-       LockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;
+        GetGWorld( &origPort , &origDevice ) ;
+        SetGWorld( M_BITMAPDATA->m_hBitmap , NULL ) ;
+        LockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;

        
        

-       // bits is a char array
+        // 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);
-       }
+        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 } 
-       } ;
+        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 )
-           {
-               int index = x / 8 ;
-               int bit = x % 8 ;
-               int mask = 1 << bit ;
-               if ( linestart[index] & mask )
-               {
-                   SetCPixel( x , y , &colors[1] ) ;
-               }
-               else
-               {
-                   SetCPixel( x , y , &colors[0] ) ;
-               }
-           }
-           
-       }
-       UnlockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;
+        for ( int y = 0 ; y < the_height ; ++y , linestart += linesize )
+        {
+            for ( int x = 0 ; x < the_width ; ++x )
+            {
+                int index = x / 8 ;
+                int bit = x % 8 ;
+                int mask = 1 << bit ;
+                if ( linestart[index] & mask )
+                {
+                    SetCPixel( x , y , &colors[1] ) ;
+                }
+                else
+                {
+                    SetCPixel( x , y , &colors[0] ) ;
+                }
+            }
+        }
+        UnlockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;

        
        

-       SetGWorld( origPort , origDevice ) ;
+        SetGWorld( origPort , origDevice ) ;

     }
     else
     {
     }
     else
     {

-       wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
+        wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));

     }
     
     if ( wxTheBitmapList ) {
     }
     
     if ( wxTheBitmapList ) {


@@ -329,7 +335,7 @@ wxBitmap::wxBitmap(int w, int h, int d)
         wxTheBitmapList->AddBitmap(this);
 }
 
         wxTheBitmapList->AddBitmap(this);
 }
 

-wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
+wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)

 {
     (void) Create(data, type, width, height, depth);
 
 {
     (void) Create(data, type, width, height, depth);
 


@@ -337,22 +343,33 @@ wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
         wxTheBitmapList->AddBitmap(this);
 }
 
         wxTheBitmapList->AddBitmap(this);
 }
 

-wxBitmap::wxBitmap(const wxString& filename, long type)
+wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)

 {
 {

-    LoadFile(filename, (int)type);
+    LoadFile(filename, type);

 
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
 
 
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
 

-wxBitmap::wxBitmap(const char **data)
+bool wxBitmap::CreateFromXpm(const char **bits)

 {
 {

-    (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
+    wxXPMDecoder decoder;
+    wxImage img = decoder.ReadData(bits);
+    wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") )    
+    *this = wxBitmap(img);   
+    if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this);
+    return TRUE;

 }
 
 }
 

-wxBitmap::wxBitmap(char **data)
+wxBitmap::wxBitmap(const char **bits)

 {
 {

-    (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    (void) CreateFromXpm(bits);
+}
+
+wxBitmap::wxBitmap(char **bits)
+{
+    (void) CreateFromXpm((const char **)bits);

 }
 
 wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
 }
 
 wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const


@@ -456,7 +473,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_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;
 }
 
     return M_BITMAPDATA->m_ok;
 }
 


@@ -471,27 +488,34 @@ void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
 {
     M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
     M_BITMAPDATA->m_hBitmap = bmp ;
 {
     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, long type)
+bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)

 {
     UnRef();
 
 {
     UnRef();
 

-    m_refData = new wxBitmapRefData;
-

     wxBitmapHandler *handler = FindHandler(type);
 
     wxBitmapHandler *handler = FindHandler(type);
 

-    if ( handler == NULL ) {
-        wxLogWarning("no bitmap handler for type %d defined.", type);
+    if ( handler )
+    {
+       m_refData = new wxBitmapRefData;

 
 

-        return FALSE;
+        return handler->LoadFile(this, filename, type, -1, -1);

     }
     }

-
-    return handler->LoadFile(this, filename, type, -1, -1);
+    else
+    {
+        wxImage loadimage(filename, type);
+        if (loadimage.Ok()) {
+            *this = loadimage;
+            return true;
+        }
+    }
+    wxLogWarning("no bitmap handler for type %d defined.", type);
+    return false;

 }
 
 }
 

-bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
+bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)

 {
     UnRef();
 
 {
     UnRef();
 


@@ -567,7 +591,7 @@ wxBitmap::wxBitmap(const wxImage& image, int depth)
 
     // Create mask
     if ( image.HasMask() ) {
 
     // Create mask
     if ( image.HasMask() ) {

-        wxMask *mask = new wxMask( maskBitmap );
+        SetMask(new wxMask( maskBitmap ));

     }
     
     UnlockPixels( GetGWorldPixMap(GetHBITMAP()) );
     }
     
     UnlockPixels( GetGWorldPixMap(GetHBITMAP()) );


@@ -642,17 +666,24 @@ wxImage wxBitmap::ConvertToImage() const
 }
 
 
 }
 
 

-bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
+bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type,
+                        const wxPalette *palette) const

 {
     wxBitmapHandler *handler = FindHandler(type);
 
 {
     wxBitmapHandler *handler = FindHandler(type);
 

-    if ( handler == NULL ) {
-        wxLogWarning("no bitmap handler for type %d defined.", type);
-
-        return FALSE;
-  }
+    if ( handler )
+    {
+        return handler->SaveFile(this, filename, type, palette);
+    }
+    else
+    {
+        wxImage image = ConvertToImage();

 
 

-  return handler->SaveFile(this, filename, type, palette);
+        return image.SaveFile(filename, type);
+    }
+    
+    wxLogWarning("no bitmap handler for type %d defined.", type);
+    return false;

 }
 
 bool wxBitmap::Ok() const
 }
 
 bool wxBitmap::Ok() const


@@ -755,6 +786,10 @@ void wxBitmap::SetMask(wxMask *mask)
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 

+    // Remove existing mask if there is one.
+    if (M_BITMAPDATA->m_bitmapMask)
+        delete M_BITMAPDATA->m_bitmapMask;
+

     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 


@@ -892,27 +927,27 @@ wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
     return NULL;
 }
 
     return NULL;
 }
 

-wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
+wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, wxBitmapType type)

 {
     wxNode *node = sm_handlers.First();
     while ( node )
     {
         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
         if ( handler->GetExtension() == extension &&
 {
     wxNode *node = sm_handlers.First();
     while ( node )
     {
         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
         if ( handler->GetExtension() == extension &&

-                    (bitmapType == -1 || handler->GetType() == bitmapType) )
+                    (type == -1 || handler->GetType() == type) )

             return handler;
         node = node->Next();
     }
     return NULL;
 }
 
             return handler;
         node = node->Next();
     }
     return NULL;
 }
 

-wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
+wxBitmapHandler *wxBitmap::FindHandler(wxBitmapType type)

 {
     wxNode *node = sm_handlers.First();
     while ( node )
     {
         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 {
     wxNode *node = sm_handlers.First();
     while ( node )
     {
         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();

-        if (handler->GetType() == bitmapType)
+        if (handler->GetType() == type)

             return handler;
         node = node->Next();
     }
             return handler;
         node = node->Next();
     }


@@ -1086,13 +1121,13 @@ bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width,
     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
+bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,

         int desiredWidth, int desiredHeight)
 {
     return FALSE;
 }
 
         int desiredWidth, int desiredHeight)
 {
     return FALSE;
 }
 

-bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
+bool wxBitmapHandler::SaveFile(const wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)

 {
     return FALSE;
 }
 {
     return FALSE;
 }


@@ -1151,178 +1186,9 @@ bool  wxPICTResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, lo
        return FALSE ;
 }
 
        return FALSE ;
 }
 

-/* 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)
-*/
-
-class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
-{
-  DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
-public:
-  inline wxXPMFileHandler(void)
-  {
-  m_name = "XPM bitmap file";
-  m_extension = "xpm";
-  m_type = wxBITMAP_TYPE_XPM;
-  };
-
-  virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth = -1, int desiredHeight = -1);
-  virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
-
-bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-#if USE_XPM_IN_MSW
-    XImage *ximage;
-    XpmAttributes xpmAttr;
-    HDC     dc;
-
-    M_BITMAPHANDLERDATA->m_ok = FALSE;
-    dc = CreateCompatibleDC(NULL);
-    if (dc)
-    {
-      xpmAttr.valuemask = XpmReturnPixels;
-      int errorStatus = XpmReadFileToImage(&dc, WXSTRINGCAST name, &ximage, (XImage **) NULL, &xpmAttr);
-      DeleteDC(dc);
-      if (errorStatus == XpmSuccess)
-      {
-        M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
-
-        BITMAP  bm;
-        GetObject((HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
-
-        M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
-        M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
-        M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
-        M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
-        XpmFreeAttributes(&xpmAttr);
-        XImageFree(ximage);
-
-        M_BITMAPHANDLERDATA->m_ok = TRUE;
-        return TRUE;
-      }
-      else
-      {
-        M_BITMAPHANDLERDATA->m_ok = FALSE;
-        return FALSE;
-      }
-    }
-#endif
-
-    return FALSE;
-}
-
-bool wxXPMFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
-{
-#if USE_XPM_IN_MSW
-      HDC     dc = NULL;
-
-      Visual *visual = NULL;
-      XImage  ximage;
-
-      dc = CreateCompatibleDC(NULL);
-      if (dc)
-      {
-        if (SelectObject(dc, (HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap))
-        { 
-          
-    ximage.width = M_BITMAPHANDLERDATA->m_width; 
-     ximage.height = M_BITMAPHANDLERDATA->m_height;
-    ximage.depth = M_BITMAPHANDLERDATA->m_depth; 
-     ximage.bitmap = (void *)M_BITMAPHANDLERDATA->m_hBitmap;
-    int errorStatus = XpmWriteFileFromImage(&dc, WXSTRINGCAST name,
-              &ximage, (XImage *) NULL, (XpmAttributes *) NULL);
-
-          if (dc)
-      DeleteDC(dc);
-
-    if (errorStatus == XpmSuccess)
-      return TRUE;    
-    else
-      return FALSE;
-        } else return FALSE;
-      } else return FALSE;
-#else
-  return FALSE;
-#endif
-}
-
-
-class WXDLLEXPORT wxXPMDataHandler: public wxBitmapHandler
-{
-  DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
-public:
-  inline wxXPMDataHandler(void)
-  {
-  m_name = "XPM bitmap data";
-  m_extension = "xpm";
-  m_type = wxBITMAP_TYPE_XPM_DATA;
-  };
-
-  virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
-
-bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth)
-{
-       XImage *                ximage = NULL ;
-       XImage *                xshapeimage = NULL ;
-       int                     ErrorStatus;
-       XpmAttributes   xpmAttr;
-
-    xpmAttr.valuemask = XpmReturnInfos; // get infos back
-    ErrorStatus = XpmCreateImageFromData( GetMainDevice() , (char **)data,
-         &ximage, &xshapeimage, &xpmAttr);
-
-    if (ErrorStatus == XpmSuccess)
-    {
-                       M_BITMAPHANDLERDATA->m_ok = FALSE;
-                       M_BITMAPHANDLERDATA->m_numColors = 0;
-                       M_BITMAPHANDLERDATA->m_hBitmap = ximage->gworldptr ;
-         
-                       M_BITMAPHANDLERDATA->m_width = ximage->width;
-                       M_BITMAPHANDLERDATA->m_height = ximage->height;
-                       M_BITMAPHANDLERDATA->m_depth = ximage->depth;
-                       M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
-       XpmFreeAttributes(&xpmAttr);
-           M_BITMAPHANDLERDATA->m_ok = TRUE;
-                       ximage->gworldptr = NULL ;
-                       XImageFree(ximage); // releases the malloc, but does not detroy
-                                 // the bitmap
-                       M_BITMAPHANDLERDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
-                       if ( xshapeimage != NULL )
-                       {
-                               wxMask* m = new wxMask() ;
-                               m->SetMaskBitmap( xshapeimage->gworldptr ) ;
-                               M_BITMAPHANDLERDATA->m_bitmapMask = m ;
-                       }
-                       return TRUE;
-    } 
-    else
-    {
-      M_BITMAPHANDLERDATA->m_ok = FALSE;
-      return FALSE;
-    }
-  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)
 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
 {
     DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)


@@ -1337,69 +1203,9 @@ public:
     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
           int desiredWidth, int desiredHeight);
 };
     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
           int desiredWidth, int desiredHeight);
 };

-

 IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
 
 IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
 

-bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-    // TODO: load colourmap.
-  // it's probably not found
-  wxLogError("Can't load bitmap '%s' from resources! Check .rc file.", name.c_str());
-
-  return FALSE;
-}
-
-class WXDLLEXPORT wxBMPFileHandler: public wxBitmapHandler
-{
-  DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
-public:
-  inline wxBMPFileHandler(void)
-  {
-  m_name = "Windows bitmap file";
-  m_extension = "bmp";
-  m_type = wxBITMAP_TYPE_BMP;
-  };
-
-  virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-      int desiredWidth, int desiredHeight);
-  virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
-
-bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-#if USE_IMAGE_LOADING_IN_MSW
-    wxPalette *palette = NULL;
-    bool success = FALSE;
-    success = (wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0);
-    if (!success && palette)
-    {
-      delete palette;
-      palette = NULL;
-    }
-    if (palette)
-      M_BITMAPHANDLERDATA->m_bitmapPalette = *palette;
-    return success;
-#else
-  return FALSE;
-#endif
-}
-
-bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *pal)
-{
-#if USE_IMAGE_LOADING_IN_MSW
-    wxPalette *actualPalette = (wxPalette *)pal;
-    if (!actualPalette && (!M_BITMAPHANDLERDATA->m_bitmapPalette.IsNull()))
-      actualPalette = & (M_BITMAPHANDLERDATA->m_bitmapPalette);
-    return (wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0);
-#else
-  return FALSE;

 #endif
 #endif

-}
-

 
 void wxBitmap::CleanUpHandlers()
 {
 
 void wxBitmap::CleanUpHandlers()
 {


@@ -1416,10 +1222,6 @@ void wxBitmap::CleanUpHandlers()
 
 void wxBitmap::InitStandardHandlers()
 {
 
 void wxBitmap::InitStandardHandlers()
 {

-       AddHandler( new wxPICTResourceHandler ) ;
-       AddHandler( new wxICONResourceHandler ) ;
-       AddHandler(new wxXPMFileHandler);
-       AddHandler(new wxXPMDataHandler);
-       AddHandler(new wxBMPResourceHandler);
-       AddHandler(new wxBMPFileHandler);
+    AddHandler(new wxPICTResourceHandler) ;
+    AddHandler(new wxICONResourceHandler) ;

 }
 }