bitmap and image updates

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4800 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/os2/app.h b/include/wx/os2/app.h
index 69974b6c55360406049b2a3dece9f6c8ce74c66c..effb025e8beee44fe6ab738189caef6867090baa 100644 (file)
--- a/include/wx/os2/app.h
+++ b/include/wx/os2/app.h
@@ -22,6 +22,7 @@ class WXDLLEXPORT wxKeyEvent;
 class WXDLLEXPORT wxLog;
 
 WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
 class WXDLLEXPORT wxLog;
 
 WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;

+HAB                             vHabmain;

 
 // Force an exit from main loop
 void WXDLLEXPORT wxExit(void);
 
 // Force an exit from main loop
 void WXDLLEXPORT wxExit(void);


@@ -100,7 +101,6 @@ protected:
 
     DECLARE_EVENT_TABLE()
 private:
 
     DECLARE_EVENT_TABLE()
 private:

-    HAB                             m_vHab;

     HMQ                             m_hMq;
     QMSG                            m_vMsg;
 };
     HMQ                             m_hMq;
     QMSG                            m_vMsg;
 };

diff --git a/include/wx/os2/bitmap.h b/include/wx/os2/bitmap.h
index 8ed76d060f5ff0265d689525dd7a14850d306ebf..5ad96f1a552723dfe9f7dcd62fbc0c2c1fbaac44 100644 (file)
--- a/include/wx/os2/bitmap.h
+++ b/include/wx/os2/bitmap.h
@@ -1,9 +1,9 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        bitmap.h
+// Name:        wx/os2/bitmap.h

 // Purpose:     wxBitmap class
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxBitmap class
 // Author:      David Webster
 // Modified by:

-// Created:     10/13/99
+// Created:     11/28/99

 // RCS-ID:      $Id$
 // Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 // RCS-ID:      $Id$
 // Copyright:   (c) David Webster
 // Licence:     wxWindows licence


@@ -12,196 +12,337 @@
 #ifndef _WX_BITMAP_H_
 #define _WX_BITMAP_H_
 
 #ifndef _WX_BITMAP_H_
 #define _WX_BITMAP_H_
 

-#include "wx/gdiobj.h"
+#ifdef __GNUG__
+    #pragma interface "bitmap.h"
+#endif
+
+#include "wx/os2/gdiimage.h"

 #include "wx/gdicmn.h"
 #include "wx/palette.h"
 
 #include "wx/gdicmn.h"
 #include "wx/palette.h"
 

-// Bitmap

 class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxControl;
 class WXDLLEXPORT wxBitmap;
 class WXDLLEXPORT wxBitmapHandler;
 class WXDLLEXPORT wxIcon;
 class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxControl;
 class WXDLLEXPORT wxBitmap;
 class WXDLLEXPORT wxBitmapHandler;
 class WXDLLEXPORT wxIcon;

+class WXDLLEXPORT wxMask;

 class WXDLLEXPORT wxCursor;
 class WXDLLEXPORT wxControl;
 
 class WXDLLEXPORT wxCursor;
 class WXDLLEXPORT wxControl;
 

-// A mask is a mono bitmap used for drawing bitmaps
-// transparently.
-class WXDLLEXPORT wxMask: public wxObject
-{
-  DECLARE_DYNAMIC_CLASS(wxMask)
-
-public:
-  wxMask();
-
-  // Construct a mask from a bitmap and a colour indicating
-  // the transparent area
-  wxMask(const wxBitmap& bitmap, const wxColour& colour);
-
-  // Construct a mask from a bitmap and a palette index indicating
-  // the transparent area
-  wxMask(const wxBitmap& bitmap, int paletteIndex);
-
-  // Construct a mask from a mono bitmap (copies the bitmap).
-  wxMask(const wxBitmap& bitmap);
-
-  ~wxMask();
+// ----------------------------------------------------------------------------
+// Bitmap data
+//
+// NB: this class is private, but declared here to make it possible inline
+//     wxBitmap functions accessing it
+// ----------------------------------------------------------------------------

 
 

-  bool Create(const wxBitmap& bitmap, const wxColour& colour);
-  bool Create(const wxBitmap& bitmap, int paletteIndex);
-  bool Create(const wxBitmap& bitmap);
-
-  // Implementation
-  inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
-  inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
-protected:
-  WXHBITMAP m_maskBitmap;
-};
-
-class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
+class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData

 {
 {

-    friend class WXDLLEXPORT wxBitmap;
-    friend class WXDLLEXPORT wxIcon;
-    friend class WXDLLEXPORT wxCursor;

 public:
     wxBitmapRefData();
 public:
     wxBitmapRefData();

-    ~wxBitmapRefData();
+    virtual ~wxBitmapRefData() { Free(); }
+
+    virtual void Free();

 
 public:
 
 public:

-  int           m_width;
-  int           m_height;
-  int           m_depth;
-  bool          m_ok;
-  int           m_numColors;
-  wxPalette     m_bitmapPalette;
-  int           m_quality;
-
-  WXHBITMAP     m_hBitmap;
-  wxDC *        m_selectedInto; // So bitmap knows whether it's been selected into
-
-  wxMask *      m_bitmapMask; // Optional mask
-};
+    int                             m_nNumColors;
+    wxPalette                       m_vBitmapPalette;
+    int                             m_nQuality;

 
 

-#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+    // OS2-specific
+    // ------------

 
 

-class WXDLLEXPORT wxBitmapHandler: public wxObject
-{
-  DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
-public:
-  wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; };
-
-  virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
-  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);
-
-  inline void SetName(const wxString& name) { m_name = name; }
-  inline void SetExtension(const wxString& ext) { m_extension = ext; }
-  inline void SetType(long type) { m_type = type; }
-  inline wxString GetName() const { return m_name; }
-  inline wxString GetExtension() const { return m_extension; }
-  inline long GetType() const { return m_type; }
-protected:
-  wxString  m_name;
-  wxString  m_extension;
-  long      m_type;
+    wxDC*                           m_pSelectedInto;
+    HPS                             m_hPresentationSpace;
+
+    // optional mask for transparent drawing
+    wxMask*                         m_pBitmapMask;

 };
 
 };
 

-#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
+// ----------------------------------------------------------------------------
+// wxBitmap: a mono or colour bitmap
+// ----------------------------------------------------------------------------

 
 

-class WXDLLEXPORT wxBitmap: public wxGDIObject
+class WXDLLEXPORT wxBitmap : public wxGDIImage

 {
 {

-  DECLARE_DYNAMIC_CLASS(wxBitmap)
-
-  friend class WXDLLEXPORT wxBitmapHandler;
-

 public:
 public:

-  wxBitmap(); // Platform-specific
-
-  // Copy constructors
-  wxBitmap(const wxBitmap& bitmap);
-
-  // Initialize with raw data
-  wxBitmap(const char bits[], int width, int height, int depth = 1);
+    // default ctor creates an invalid bitmap, you must Create() it later
+    wxBitmap() { Init(); }
+
+    // Copy constructors
+    inline wxBitmap(const wxBitmap& rBitmap)
+      { Init(); Ref(rBitmap); }
+
+    // Initialize with raw data
+    wxBitmap( const char bits[]
+             ,int        nWidth
+             ,int        nHeight
+             ,int        nDepth = 1
+            );
+
+    // Initialize with XPM data
+    wxBitmap( char**     ppData
+             ,wxControl* pAnItem = NULL
+            );
+
+    // Load a file or resource
+    wxBitmap( const wxString& rName
+             ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
+            );
+
+    // New constructor for generalised creation from data
+    wxBitmap( void* pData
+             ,long  lType
+             ,int   nWidth
+             ,int   nHeight
+             ,int   nDepth = 1
+            );
+
+    // If depth is omitted, will create a bitmap compatible with the display
+    wxBitmap( int nWidth
+             ,int nHeight
+             ,int nDepth = -1
+            );
+
+    // we must have this, otherwise icons are silently copied into bitmaps using
+    // the copy ctor but the resulting bitmap is invalid!
+    inline wxBitmap(const wxIcon& rIcon)
+      { Init(); CopyFromIcon(rIcon); }
+
+    wxBitmap& operator=(const wxBitmap& rBitmap)
+    {
+        if ( m_refData != rBitmap.m_refData )
+            Ref(rBitmap);
+        return(*this);
+    }
+
+    wxBitmap& operator=(const wxIcon& rIcon)
+    {
+        (void)CopyFromIcon(rIcon);
+
+        return(*this);
+    }
+
+    wxBitmap& operator=(const wxCursor& rCursor)
+    {
+        (void)CopyFromCursor(rCursor);
+        return (*this);
+    }
+
+    virtual ~wxBitmap();
+
+    // copies the contents and mask of the given (colour) icon to the bitmap
+    bool CopyFromIcon(const wxIcon& rIcon);
+
+    // copies the contents and mask of the given cursor to the bitmap
+    bool CopyFromCursor(const wxCursor& rCursor);
+
+    virtual bool Create( int nWidth
+                        ,int nHeight
+                        ,int nDepth = -1
+                       );
+    virtual bool Create( void* pData
+                        ,long  lType
+                        ,int   nWidth
+                        ,int   nHeight
+                        ,int   nDepth = 1
+                       );
+    virtual bool LoadFile( const wxString& rName
+                          ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
+                         );
+    virtual bool SaveFile( const wxString&  rName
+                          ,int              lType
+                          ,const wxPalette* pCmap = NULL
+                         );
+
+    inline wxBitmapRefData* GetBitmapData() const
+      { return (wxBitmapRefData *)m_refData; }
+
+    inline int GetQuality() const
+      { return (GetBitmapData() ? GetBitmapData()->m_quality : 0); }
+
+    void SetQuality(int nQ);
+
+    wxPalette* GetPalette() const
+      { return (GetBitmapData() ? (& GetBitmapData()->m_bitmapPalette) : (wxPalette*) NULL); }
+
+    void       SetPalette(const wxPalette& rPalette);
+
+    inline wxMask* GetMask() const
+      { return (GetBitmapData() ? GetBitmapData()->m_bitmapMask : (wxMask*) NULL); }
+
+    void SetMask(wxMask* pMask) ;
+
+    inline bool operator==(const wxBitmap& rBitmap)
+      { return m_refData == rBitmap.m_refData; }
+
+    inline bool operator!=(const wxBitmap& rBitmap)
+      { return m_refData != rBitmap.m_refData; }
+
+#if WXWIN_COMPATIBILITY_2
+    void SetOk(bool bIsOk);
+#endif // WXWIN_COMPATIBILITY_2

 
 

-  // Initialize with XPM data
-  wxBitmap(char **data, wxControl *anItem = NULL);
-
-  // Load a file or resource
-  wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
+#if WXWIN_COMPATIBILITY
+    inline wxPalette* GetColourMap() const
+      { return GetPalette(); }

 
 

-  // New constructor for generalised creation from data
-  wxBitmap(void *data, long type, int width, int height, int depth = 1);
+    inline void       SetColourMap(wxPalette* pCmap)
+      { SetPalette(*pCmap); };

 
 

-  // If depth is omitted, will create a bitmap compatible with the display
-  wxBitmap(int width, int height, int depth = -1);
-  ~wxBitmap();
+#endif // WXWIN_COMPATIBILITY

 
 

-  virtual bool Create(int width, int height, int depth = -1);
-  virtual bool Create(void *data, long type, int width, int height, int depth = 1);
-  virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
-  virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
+    // Implementation
+public:
+    inline void SetHBITMAP(WXHBITMAP hHmp)
+      { SetHandle((WXHANDLE)bmp); }
+
+    inline WXHBITMAP GetHBITMAP() const
+      { return (WXHBITMAP)GetHandle(); }
+
+    inline void  SetSelectedInto(wxDC* pDc)
+      { if (GetBitmapData()) GetBitmapData()->m_selectedInto = pDc; }
+
+    inline wxDC* GetSelectedInto() const
+      { return (GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC*) NULL); }
+
+    // Creates a bitmap that matches the device context's depth, from an
+    // arbitray bitmap. At present, the original bitmap must have an associated
+    // palette. (TODO: use a default palette if no palette exists.) This
+    // function is necessary for you to Blit an arbitrary bitmap (which may
+    // have the wrong depth). wxDC::SelectObject will compare the depth of the
+    // bitmap with the DC's depth, and create a new bitmap if the depths
+    // differ. Eventually we should perhaps make this a public API function so
+    // that an app can efficiently produce bitmaps of the correct depth. The
+    // Windows solution is to use SetDibBits to blit an arbotrary DIB directly
+    // to a DC, but this is too Windows-specific, hence this solution of
+    // quietly converting the wxBitmap. Contributed by Frederic Villeneuve
+    // <frederic.villeneuve@natinst.com>
+    wxBitmap GetBitmapForDC(wxDC& rDc) const;

 
 

-  inline bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
-  inline int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
-  inline int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
-  inline int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
-  inline int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
-  void SetWidth(int w);
-  void SetHeight(int h);
-  void SetDepth(int d);
-  void SetQuality(int q);
-  void SetOk(bool isOk);
+protected:
+    // common part of all ctors
+    void Init();

 
 

-#if WXWIN_COMPATIBILITY
-  inline wxPalette *GetColourMap(void) const { return GetPalette(); }
-  void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
-#endif
-  inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
-  void SetPalette(const wxPalette& palette);
+    inline virtual wxGDIImageRefData* CreateData() const
+        { return new wxBitmapRefData; }

 
 

-  inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
-  void SetMask(wxMask *mask) ;
+private:
+    bool CopyFromIconOrCursor(const wxGDIImage& rIcon);

 
 

-  inline wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; }
+    DECLARE_DYNAMIC_CLASS(wxBitmap)
+};

 
 

-  inline bool operator == (const wxBitmap& bitmap) { return m_refData == bitmap.m_refData; }
-  inline bool operator != (const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; }
+// ----------------------------------------------------------------------------
+// wxMask: a mono bitmap used for drawing bitmaps transparently.
+// ----------------------------------------------------------------------------

 
 

-  // Format handling
-  static inline wxList& GetHandlers() { return sm_handlers; }
-  static void AddHandler(wxBitmapHandler *handler);
-  static void InsertHandler(wxBitmapHandler *handler);
-  static bool RemoveHandler(const wxString& name);
-  static wxBitmapHandler *FindHandler(const wxString& name);
-  static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType);
-  static wxBitmapHandler *FindHandler(long bitmapType);
+class WXDLLEXPORT wxMask : public wxObject
+{
+public:
+    wxMask();
+
+    // Construct a mask from a bitmap and a colour indicating the transparent
+    // area
+    wxMask( const wxBitmap& rBitmap
+           ,const wxColour& rColour
+          );
+
+    // Construct a mask from a bitmap and a palette index indicating the
+    // transparent area
+    wxMask( const wxBitmap& rBitmap
+           ,int             nPaletteIndex
+          );
+
+    // Construct a mask from a mono bitmap (copies the bitmap).
+    wxMask(const wxBitmap& rBitmap);
+
+    // construct a mask from the givne bitmap handle
+    wxMask(WXHBITMAP hBmp)
+      { m_hMaskBitmap = hBmp; }
+
+    virtual ~wxMask();
+
+    bool Create( const wxBitmap& bitmap
+                ,const wxColour& rColour
+               );
+    bool Create( const wxBitmap& rBitmap
+                ,int             nPaletteIndex
+               );
+    bool Create(const wxBitmap& rBitmap);
+
+    // Implementation
+    WXHBITMAP GetMaskBitmap() const
+      { return m_hMaskBitmap; }
+    void SetMaskBitmap(WXHBITMAP hBmp)
+      { m_hMaskBitmap = hBmp; }

 
 

-  static void InitStandardHandlers();
-  static void CleanUpHandlers();

 protected:
 protected:

-  static wxList sm_handlers;
+    WXHBITMAP                       m_hMaskBitmap;
+    DECLARE_DYNAMIC_CLASS(wxMask)
+};
+
+// ----------------------------------------------------------------------------
+// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
+// ----------------------------------------------------------------------------

 
 

-  // Implementation
+class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
+{

 public:
 public:

-  void SetHBITMAP(WXHBITMAP bmp);
-  inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
-  inline void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; }
-  inline wxDC *GetSelectedInto(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_selectedInto : (wxDC*) NULL); }
-  bool FreeResource(bool force = FALSE);
-
-  // Creates a bitmap that matches the device context's depth, from
-  // an arbitray bitmap. At present, the original bitmap must have an
-  // associated palette. (TODO: use a default palette if no palette exists.)
-  // This function is necessary for you to Blit an arbitrary bitmap (which may have
-  // the wrong depth). wxDC::SelectObject will compare the depth of the bitmap
-  // with the DC's depth, and create a new bitmap if the depths differ.
-  // Eventually we should perhaps make this a public API function so that
-  // an app can efficiently produce bitmaps of the correct depth.
-  // The Windows solution is to use SetDibBits to blit an arbotrary DIB directly to a DC, but
-  // this is too Windows-specific, hence this solution of quietly converting the wxBitmap.
-  // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
-  wxBitmap GetBitmapForDC(wxDC& dc) const;
+    inline wxBitmapHandler()
+      { m_lType = wxBITMAP_TYPE_INVALID; }
+
+    inline wxBitmapHandler( const wxString& rName
+                    ,const wxString& rExt
+                    ,long            lType
+                   )
+                   : wxGDIImageHandler( rName
+                                       ,rExt
+                                       ,lType)
+    {
+    }
+
+    // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
+    // old class which worked only with bitmaps
+    virtual bool Create( wxBitmap* pBitmap
+                        ,void*     pData
+                        ,long      lFlags
+                        ,int       nWidth
+                        ,int       nHeight
+                        ,int       nDepth = 1
+                       );
+    virtual bool LoadFile( wxBitmap*       pBitmap
+                          ,const wxString& rName
+                          ,long            lFlags
+                          ,int             nDesiredWidth
+                          ,int             nDesiredHeight
+                         );
+    virtual bool SaveFile( wxBitmap*        pBitmap
+                          ,const wxString&  rName
+                          ,int              lType
+                          ,const wxPalette* pPalette = NULL
+                         );
+
+    virtual bool Create( wxGDIImage* pImage
+                        ,void*       pData
+                        ,long        lFlags
+                        ,int         nWidth
+                        ,int         nHeight
+                        ,int         nDepth = 1
+                       );
+    virtual bool Load( wxGDIImage*     pImage
+                      ,const wxString& rName
+                      ,long            lFlags
+                      ,int             nDesiredWidth
+                      ,int             nDesiredHeight
+                     );
+    virtual bool Save(wxGDIImage*     pImage
+                      const wxString& rName
+                      int             lType
+                     );
+private:
+    DECLARE_DYNAMIC_CLASS(wxBitmapHandler)

 };
 };

+

 #endif
   // _WX_BITMAP_H_
 #endif
   // _WX_BITMAP_H_

diff --git a/include/wx/os2/icon.h b/include/wx/os2/icon.h
index 07a1f4fb5596233f3cdd8757ab537fa345697691..c6b46a110f3e34dd9091d42f9708810f6d6a01f4 100644 (file)
--- a/include/wx/os2/icon.h
+++ b/include/wx/os2/icon.h
@@ -12,91 +12,89 @@
 #ifndef _WX_ICON_H_
 #define _WX_ICON_H_
 
 #ifndef _WX_ICON_H_
 #define _WX_ICON_H_
 

-#include "wx/bitmap.h"
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// compatible (even if incorrect) behaviour by default: derive wxIcon from
+// wxBitmap
+#ifndef wxICON_IS_BITMAP
+    #define wxICON_IS_BITMAP 1
+#endif

 
 

-class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
-{
-    friend class WXDLLEXPORT wxBitmap;
-    friend class WXDLLEXPORT wxIcon;
-public:
-    wxIconRefData();
-    ~wxIconRefData();
+#if wxICON_IS_BITMAP
+    #include "wx/bitmap.h"

 
 

-public:
-    WXHICON m_hIcon;
-};
+    #define wxIconRefDataBase   wxBitmapRefData
+    #define wxIconBase          wxBitmap
+#else
+    #include "wx/os2/gdiimage.h"

 
 

-#define M_ICONDATA ((wxIconRefData *)m_refData)
-#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData())
+    #define wxIconRefDataBase   wxGDIImageRefData
+    #define wxIconBase          wxGDIImage
+#endif

 
 

-// Icon
-class WXDLLEXPORT wxIcon: public wxBitmap
+class WXDLLEXPORT wxIconRefData: public wxIconRefDataBase

 {
 {

-  DECLARE_DYNAMIC_CLASS(wxIcon)
-

 public:
 public:

-  wxIcon();
-
-  // Copy constructors
-  inline wxIcon(const wxIcon& icon) { Ref(icon); }
-
-  wxIcon(const char bits[], int width, int height);
-  wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
-    int desiredWidth = -1, int desiredHeight = -1);
-  ~wxIcon();
-
-  bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
-      int desiredWidth = -1, int desiredHeight = -1);
-
-  inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
-  inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
-  inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
+    wxIconRefData() { };
+    virtual ~wxIconRefData() { Free(); m_hIcon = NULL; }

 
 

-  void SetHICON(WXHICON ico);
-  inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
-
-  virtual bool Ok() const { return (m_refData != NULL) ; }
-private:
-  // supress virtual function hiding warning
-  virtual bool LoadFile( const wxString& name
-                        ,long type = wxBITMAP_TYPE_BMP_RESOURCE
-                       )
-   { return(wxBitmap::LoadFile(name, type)); };
-};
-
-// Example handlers. TODO: write your own handlers for relevant types.
-
-class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler
-{
-  DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
+    virtual void Free();

 public:
 public:

-  inline wxICOFileHandler()
-  {
-    m_name = "ICO icon file";
-    m_extension = "ico";
-    m_type = wxBITMAP_TYPE_ICO;
-  };
-
-  virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-      int desiredWidth = -1, int desiredHeight = -1);
+    WXHICON m_hIcon;

 };
 
 };
 

-class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler
+// ---------------------------------------------------------------------------
+// Icon
+// ---------------------------------------------------------------------------
+
+class WXDLLEXPORT wxIcon: public wxIconBase

 {
 {

-  DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)

 public:
 public:

-  inline wxICOResourceHandler()
-  {
-    m_name = "ICO resource";
-    m_extension = "ico";
-    m_type = wxBITMAP_TYPE_ICO_RESOURCE;
-  };
-
-  virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-      int desiredWidth = -1, int desiredHeight = -1);
+    wxIcon();
+
+    // Copy constructors
+    inline wxIcon(const wxIcon& icon) { Ref(icon); }
+
+    wxIcon( const char bits[]
+           ,int        nWidth
+           ,int        nHeight
+          );
+    wxIcon( const wxString& rName
+           ,long            lFlags = wxBITMAP_TYPE_ICO_RESOURCE
+           ,int             nDesiredWidth = -1
+           ,int             nDesiredHeight = -1
+          );
+    ~wxIcon();
+
+    bool LoadFile( const wxString& rName
+                  ,long            lFlags = wxBITMAP_TYPE_ICO_RESOURCE
+                  ,int             nDesiredWidth = -1
+                  ,int             nDesiredHeight = -1
+                 );
+
+    inline wxIcon& operator = (const wxIcon& rIcon)
+       { if (*this == rIcon) Ref(rIcon); return *this; }
+    inline bool operator == (const wxIcon& rIcon)
+       { return m_refData == rIcon.m_refData; }
+    inline bool operator != (const wxIcon& rIcon)
+       { return m_refData != rIcon.m_refData; }
+
+    wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
+
+    inline void SetHICON(WXHICON hIcon) { SetHandle((WXHANDLE)hIcon); }
+    inline WXHICON GetHICON() const { return (WXHICON)GetHandle(); }
+
+protected:
+    virtual wxGDIImageRefData* CreateData() const
+    {
+        return new wxIconRefData;
+    }

 
 

+private:
+    DECLARE_DYNAMIC_CLASS(wxIcon)

 };
 
 #endif
     // _WX_ICON_H_
 };
 
 #endif
     // _WX_ICON_H_

-

diff --git a/include/wx/os2/setup.h b/include/wx/os2/setup.h
index 4cadb335d5b6d6b40c44ede4c9401d53da3fc64d..5042e1dcbc7f93495ca5d4f2d52a9e54c9f9d702 100644 (file)
--- a/include/wx/os2/setup.h
+++ b/include/wx/os2/setup.h
@@ -16,6 +16,9 @@
 // global settings
 // ----------------------------------------------------------------------------
 
 // global settings
 // ----------------------------------------------------------------------------
 

+// define this to 1 if you want icons to behave as bitmaps
+#define wxICON_IS_BITMAP     0
+

 // define this to 0 when building wxBase library
 #define wxUSE_GUI            1
 
 // define this to 0 when building wxBase library
 #define wxUSE_GUI            1
 

diff --git a/include/wx/os2/setup0.h b/include/wx/os2/setup0.h
index f7afa63a33b619b59b91db2472be59e2aaae5983..36254e5f5caaac24b7a1a7dc9a9ccd77efe3261e 100644 (file)
--- a/include/wx/os2/setup0.h
+++ b/include/wx/os2/setup0.h
@@ -16,6 +16,9 @@
 // global settings
 // ----------------------------------------------------------------------------
 
 // global settings
 // ----------------------------------------------------------------------------
 

+// define this to 1 if you want icons to behave as bitmaps
+#define wxICON_IS_BITMAP     0
+

 // define this to 0 when building wxBase library
 #define wxUSE_GUI            1
 
 // define this to 0 when building wxBase library
 #define wxUSE_GUI            1
 


@@ -163,7 +166,7 @@
                                   // Some databases/ODBC drivers only allow forward scrolling cursors.
                                   // Unless you specifically want to use backward scrolling
                                   // cursors, and you know that all of the databases/ODBC drivers
                                   // Some databases/ODBC drivers only allow forward scrolling cursors.
                                   // Unless you specifically want to use backward scrolling
                                   // cursors, and you know that all of the databases/ODBC drivers

-                                  // that you will use these odbc classes with allow backward 
+                                  // that you will use these odbc classes with allow backward

                                   // scrolling cursors, this setting should remain set to 1
                                   // for maximum database/driver compatibilty
 
                                   // scrolling cursors, this setting should remain set to 1
                                   // for maximum database/driver compatibilty
 

diff --git a/include/wx/os2/statbmp.h b/include/wx/os2/statbmp.h
index 90721844b8e79a30e8469aac5b573d04a9a537ed..01ad8f183a6353663c714ff2a18535fcdfdb9a0e 100644 (file)
--- a/include/wx/os2/statbmp.h
+++ b/include/wx/os2/statbmp.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        statbmp.h
 // Purpose:     wxStaticBitmap class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        statbmp.h
 // Purpose:     wxStaticBitmap class

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     11/27/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_STATBMP_H_
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_STATBMP_H_


@@ -17,61 +17,65 @@
 #endif
 
 #include "wx/control.h"
 #endif
 
 #include "wx/control.h"

+#include "wx/icon.h"

 
 WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr;
 
 class WXDLLEXPORT wxStaticBitmap: public wxControl
 {
 
 WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr;
 
 class WXDLLEXPORT wxStaticBitmap: public wxControl
 {

-  DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
+    DECLARE_DYNAMIC_CLASS(wxStaticBitmap)

  public:
  public:

-  inline wxStaticBitmap() { }
-
-  inline wxStaticBitmap(wxWindow *parent, wxWindowID id,
-           const wxBitmap& label,
-           const wxPoint& pos = wxDefaultPosition,
-           const wxSize& size = wxDefaultSize,
-           long style = 0,
-           const wxString& name = wxStaticBitmapNameStr)
-  {
-    Create(parent, id, label, pos, size, style, name);
-  }
-
-  bool Create(wxWindow *parent, wxWindowID id,
-           const wxBitmap& label,
-           const wxPoint& pos = wxDefaultPosition,
-           const wxSize& size = wxDefaultSize,
-           long style = 0,
-           const wxString& name = wxStaticBitmapNameStr);
-
-  virtual void SetIcon(const wxIcon& icon) { SetBitmap(icon); }
-  virtual void SetBitmap(const wxBitmap& bitmap);
-
-  // assert failure is provoked by an attempt to get an icon from bitmap or
-  // vice versa
-  const wxIcon& GetIcon() const
-      { wxASSERT( m_isIcon ); return *m_image.icon; }
-  const wxBitmap& GetBitmap() const
-      { wxASSERT( !m_isIcon ); return *m_image.bitmap; }
-
-  // overriden base class virtuals
-  virtual bool AcceptsFocus() const { return FALSE; }
+    inline wxStaticBitmap() { Init(); }
+
+    inline wxStaticBitmap( wxWindow*         pParent
+                          ,wxWindowID        nId
+                          ,const wxGDIImage& rLabel
+                          ,const wxPoint&    rPos = wxDefaultPosition
+                          ,const wxSize&     rSize = wxDefaultSize
+                          ,long              lStyle = 0
+                          ,const wxString&   rName = wxStaticBitmapNameStr
+                         )
+    {
+        Create(pParent, nId, rLabel, rPos, rSize, lStyle, rName);
+    }
+
+    bool Create( wxWindow*         pParent
+                ,wxWindowID        nId
+                ,const wxGDIImage& rLabel
+                ,const wxPoint&    rPos = wxDefaultPosition
+                ,const wxSize&     rSize = wxDefaultSize
+                ,long              lStyle = 0
+                ,const wxString&   rName = wxStaticBitmapNameStr
+               );
+    inline virtual ~wxStaticBitmap() { Free(); }
+
+    virtual void SetIcon(const wxIcon& rIcon) { SetImage(rIcon); }
+    virtual void SetBitmap(const wxBitmap& rBitmap) { SetImage(rBitmap); };
+
+    // assert failure is provoked by an attempt to get an icon from bitmap or
+    // vice versa
+    const wxIcon& GetIcon() const
+      { wxASSERT( m_bIsIcon ); return *(wxIcon *)m_pImage; }
+    const wxBitmap& GetBitmap() const
+      { wxASSERT( !m_bIsIcon ); return *(wxBitmap *)m_pImage; }
+
+    // overriden base class virtuals
+    virtual bool AcceptsFocus() const { return FALSE; }

 
 protected:
 
 protected:

-  void Init() { m_isIcon = TRUE; m_image.icon = NULL; }
-  void Free();
+    virtual wxSize DoGetBestSize() const;
+
+    void Init() { m_bIsIcon = TRUE; m_pImage = NULL; }
+    void Free();

 
 

-  // TRUE if icon/bitmap is valid
-  bool ImageIsOk() const;
+    // TRUE if icon/bitmap is valid
+    bool ImageIsOk() const;

 
 

-  // we can have either an icon or a bitmap
-  bool m_isIcon;
-  union
-  {
-      wxIcon *icon;
-      wxBitmap *bitmap;
-  } m_image;
+    void SetImage(const wxGDIImage& rImage);

 
 

-  virtual wxSize DoGetBestSize() const;
+    // we can have either an icon or a bitmap
+    bool                            m_bIsIcon;
+    wxGDIImage*                     m_pImage;

 };
 
 #endif
 };
 
 #endif

diff --git a/src/os2/app.cpp b/src/os2/app.cpp
index f4f9a25d9c8b0396baf8330c7bbc70f067c6aaa2..9abb82c4ba8ab8479e1c582e45fad3c73dffea51 100644 (file)
--- a/src/os2/app.cpp
+++ b/src/os2/app.cpp
@@ -185,13 +185,14 @@ bool wxApp::RegisterWindowClasses(
   HAB                               vHab
 )
 {
   HAB                               vHab
 )
 {

-
-    if (!::WinRegisterClass( vHab
-                            ,wxFrameClassName
-                            ,(PFNWP)wxWndProc
-                            ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME
-                            ,0
-                           ))
+    APIRET                          rc;
+
+    if ((rc = ::WinRegisterClass( vHab
+                                 ,wxFrameClassName
+                                 ,(PFNWP)wxWndProc
+                                 ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME
+                                 ,0
+                                )) != 0)

     {
         wxLogLastError("RegisterClass(frame)");
 
     {
         wxLogLastError("RegisterClass(frame)");
 

diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp
index 93ea059994be3632224595570017a120bb42f7ca..872a468db57706a04851cb2bcf9349caf138fd1d 100644 (file)
--- a/src/os2/bitmap.cpp
+++ b/src/os2/bitmap.cpp
@@ -27,6 +27,9 @@
 #include "wx/os2/private.h"
 #include "wx/log.h"
 
 #include "wx/os2/private.h"
 #include "wx/log.h"
 

+//#include "wx/msw/dib.h"
+#include "wx/image.h"
+

 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------


@@ -34,343 +37,405 @@
 #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_DYNAMIC_CLASS(wxBitmapHandler, wxObject)

 #endif
 
 #endif
 

+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxBitmapRefData
+// ----------------------------------------------------------------------------
+

 wxBitmapRefData::wxBitmapRefData()
 {
 wxBitmapRefData::wxBitmapRefData()
 {

-    m_ok = FALSE;
-    m_width = 0;
-    m_height = 0;
-    m_depth = 0;
-    m_quality = 0;
-    m_hBitmap = 0 ;
-    m_selectedInto = NULL;
-    m_numColors = 0;
-    m_bitmapMask = NULL;
+    m_nQuality      = 0;
+    m_pSelectedInto = NULL;
+    m_nNumColors    = 0;
+    m_pBitmapMask   = NULL;

 }
 
 }
 

-wxBitmapRefData::~wxBitmapRefData()
+void wxBitmapRefData::Free()

 {
 {

-  if (m_selectedInto)
-  {
-    wxChar buf[200];
-    wxSprintf(buf, wxT("Bitmap was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) m_selectedInto);
-    wxFatalError(buf);
-  }
-  if (m_hBitmap)
-  {
-// TODO:    DeleteObject((HBITMAP) m_hBitmap);
-  }
-  m_hBitmap = 0 ;
+    wxASSERT_MSG( !m_pSelectedInto,
+                  wxT("deleting bitmap still selected into wxMemoryDC") );

 
 

-    if (m_bitmapMask)
-        delete m_bitmapMask;
-    m_bitmapMask = NULL;
+    if (m_hBitmap)
+    {
+        if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
+        {
+            wxLogLastError("GpiDeleteBitmap(hbitmap)");
+        }
+    }
+
+    delete m_pBitmapMask;
+    m_pBitmapMask = NULL;

 }
 
 }
 

-wxList wxBitmap::sm_handlers;
+// ----------------------------------------------------------------------------
+// wxBitmap creation
+// ----------------------------------------------------------------------------

 
 

-wxBitmap::wxBitmap()
+// this function should be called from all wxBitmap ctors
+void wxBitmap::Init()

 {
 {

-    m_refData = NULL;
+    // m_refData = NULL; done in the base class ctor

 
 

-    if ( wxTheBitmapList )
+    if (wxTheBitmapList)

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

-wxBitmap::wxBitmap(const wxBitmap& bitmap)
+bool wxBitmap::CopyFromIconOrCursor(
+  const wxGDIImage&                 rIcon
+)

 {
 {

-// TODO:
-/*
-    wxIcon *icon = wxDynamicCast(&bitmap, wxIcon);
-    if ( icon )
-    {
-        HDC hdc = ::CreateCompatibleDC(NULL);   // screen DC
-        HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc,
-                                                   icon->GetWidth(),
-                                                   icon->GetHeight());
-        ::SelectObject(hdc, hbitmap);
-        ::DrawIcon(hdc, 0, 0, (HICON)icon->GetHICON());
+    wxBitmapRefData*                pRefData = new wxBitmapRefData;

 
 

-        ::DeleteDC(hdc);
+    m_refData = pRefData;

 
 

-        SetHBITMAP((WXHBITMAP)hbitmap);
-    }
-    else
-    {
-        Ref(bitmap);
-    }
+    refData->m_width = rIcon.GetWidth();
+    refData->m_height = rIcon.GetHeight();
+    refData->m_depth = wxDisplayDepth();

 
 

-    if ( wxTheBitmapList )
-        wxTheBitmapList->AddBitmap(this);
-*/
-}
+    refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
+    // no mask???
+    refData->m_bitmapMask = new wxMask();

 
 

-wxBitmap::~wxBitmap()
-{
-    if (wxTheBitmapList)
-        wxTheBitmapList->DeleteObject(this);
+#if WXWIN_COMPATIBILITY_2
+    refData->m_ok = TRUE;
+#endif // WXWIN_COMPATIBILITY_2
+
+    return(TRUE);

 }
 
 }
 

-bool wxBitmap::FreeResource(bool WXUNUSED(force))
+bool wxBitmap::CopyFromCursor(
+  const wxCursor&                   rCursor
+)

 {
 {

-  if ( !M_BITMAPDATA )
-  return FALSE;
-
-  if (M_BITMAPDATA->m_selectedInto)
-  {
-    wxChar buf[200];
-    wxSprintf(buf, wxT("Bitmap %lX was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) this, (unsigned long) M_BITMAPDATA->m_selectedInto);
-    wxFatalError(buf);
-  }
-  if (M_BITMAPDATA->m_hBitmap)
-  {
-// TODO:    DeleteObject((HBITMAP) M_BITMAPDATA->m_hBitmap);
-  }
-  M_BITMAPDATA->m_hBitmap = 0 ;
-
-/*
-  if (M_BITMAPDATA->m_bitmapPalette)
-    delete M_BITMAPDATA->m_bitmapPalette;
-
-  M_BITMAPDATA->m_bitmapPalette = NULL ;
-*/
+    UnRef();

 
 

-  return TRUE;
+    if (!rCursor.Ok())
+        return(FALSE);
+    return CopyFromIconOrCursor(wxGDIImage)rCursor);

 }
 
 }
 

-
-wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
+bool wxBitmap::CopyFromIcon(
+  const wxIcon&                     rIcon
+)

 {
 {

-    m_refData = new wxBitmapRefData;
+    UnRef();

 
 

-    M_BITMAPDATA->m_width = the_width ;
-    M_BITMAPDATA->m_height = the_height ;
-    M_BITMAPDATA->m_depth = no_bits ;
-    M_BITMAPDATA->m_numColors = 0;
+    if (!rIcon.Ok())
+        return(FALSE);

 
 

-    /* TODO: create the bitmap from data */
+#if WXWIN_COMPATIBILITY_2
+    refData->m_ok = TRUE;
+#endif // WXWIN_COMPATIBILITY_2

 
 

-    if ( wxTheBitmapList )
-        wxTheBitmapList->AddBitmap(this);
+    return CopyFromIconOrCursor(icon);

 }
 
 }
 

-// Create from XPM data
-wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem))
+wxBitmap::~wxBitmap()

 {
 {

-  (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    if (wxTheBitmapList)
+        wxTheBitmapList->DeleteObject(this);

 }
 
 }
 

-wxBitmap::wxBitmap(int w, int h, int d)
-{
-    (void)Create(w, h, d);
+wxBitmap::wxBitmap(
+  const char                        zBits[]
+, int                               nTheWidth
+, int                               nTheHeight
+, int                               nNoBits
+)
+{
+    Init();
+
+    wxBitmapRefData*                pRefData = new wxBitmapRefData;
+    BITMAPINFOHEADER2               vHeader;
+    BITMAPINFO2                     vInfo;
+    HDC                             hDc;
+    HPS                             hPs;
+    DEVOPENSTRUCT                   vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+    SIZEL                           vSize = {0, 0};
+
+    wxAssert(vHabmain != NULL);
+
+    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+
+    vHeader.cbFix           = sizeof(vHeader);
+    vHeader.cx              = (USHORT)nTheWidth;
+    vHeader.cy              = (USHORT)nTheHeight;
+    vHeader.cPlanes         = 1L;
+    vHeader.cBitCount       = nNoBits;
+    vHeader.ulCompression   = BCA_UNCOMP;
+    vHeader.cxResolution    = 0;
+    vHeader.cyResolution    = 0;
+    vHeader.cclrUsed        = 0;
+    vHeader.cclrImportant   = 0;
+    vHeader.usUnits         = BRU_METRIC;
+    vHeader.usRecording     = BRA_BOTTOMUP;
+    vHeader.usRendering     = BRH_NOTHALFTONED;
+    vHeader.cSize1          = 0;
+    vHeader.cSize2          = 0;
+    vHeader.ulColorEncoding = 0;
+    vHeader.ulIdentifier    = 0;
+
+    vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
+    if (vhPs == 0)
+    {
+        wxLogLastError("GpiCreatePS Failure");
+    }

 
 

-    if ( wxTheBitmapList )
-        wxTheBitmapList->AddBitmap(this);
-}
+    m_refData = pRefData;

 
 

-wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
-{
-    (void) Create(data, type, width, height, depth);
+    refData->m_width = nTheWidth;
+    refData->m_height = nTheHeight;
+    refData->m_depth = nNoBits;
+    refData->m_numColors = 0;
+    refData->m_selectedInto = NULL;

 
 

-    if ( wxTheBitmapList )
-        wxTheBitmapList->AddBitmap(this);
+    HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
+    if ( !hbmp )
+    {
+        wxLogLastError("CreateBitmap");
+    }
+    SetHBITMAP((WXHBITMAP)hbmp);

 }
 
 }
 

-wxBitmap::wxBitmap(const wxString& filename, long type)
-{
-    LoadFile(filename, (int)type);
+// Create from XPM data
+wxBitmap::wxBitmap(
+  char**                            ppData
+, wxControl*                        WXUNUSED(pAnItem))
+{
+    Init();
+
+F    (void)Create( (void *)ppData
+                 ,wxBITMAP_TYPE_XPM_DATA
+                 ,0
+                 ,0
+                 ,0
+                );
+}
+
+wxBitmap::wxBitmap(
+  int                               nW
+, int                               nH
+, int                               nD
+)
+{
+    Init();
+
+    (void)Create( nW
+                 ,nH
+                 ,nD
+                );
+}
+
+wxBitmap::wxBitmap(
+  void*                             pData
+, long                              lType
+, int                               nWidth
+, int                               nHeight
+, int                               nDepth
+)
+{
+    Init();
+
+    (void)Create( pData
+                 ,lType
+                 ,nWidth
+                 ,nHeight
+                 ,nDepth
+                );
+}
+
+wxBitmap::wxBitmap(
+  const wxString&                   rFilename
+, long                              lType
+)
+{
+    Init();
+
+    LoadFile( rFilename
+             ,(int)lType
+            );
+}
+
+bool wxBitmap::Create(
+  int                               nW
+, int                               nH
+, int                               nD
+)
+{
+    HBITMAP                         hBmp;
+    BITMAPINFOHEADER2               vHeader;
+    BITMAPINFO2                     vInfo;
+    HDC                             hDc;
+    HPS                             hPs;
+    DEVOPENSTRUCT                   vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+    SIZEL                           vSize = {0, 0};
+
+    wxAssert(vHabmain != NULL);
+
+    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+
+    vHeader.cbFix           = sizeof(vHeader);
+    vHeader.cx              = (USHORT)nW;
+    vHeader.cy              = (USHORT)nH;
+    vHeader.cPlanes         = (USHORT)nD;
+    vHeader.cBitCount       = 24;
+    vHeader.ulCompression   = BCA_UNCOMP;
+    vHeader.cxResolution    = 0;
+    vHeader.cyResolution    = 0;
+    vHeader.cclrUsed        = 0;
+    vHeader.cclrImportant   = 0;
+    vHeader.usUnits         = BRU_METRIC;
+    vHeader.usRecording     = BRA_BOTTOMUP;
+    vHeader.usRendering     = BRH_NOTHALFTONED;
+    vHeader.cSize1          = 0;
+    vHeader.cSize2          = 0;
+    vHeader.ulColorEncoding = 0;
+    vHeader.ulIdentifier    = 0;
+
+    vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
+    if (vhPs == 0)
+    {
+        wxLogLastError("GpiCreatePS Failure");
+    }

 
 

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

 
 

-bool wxBitmap::Create(int w, int h, int d)
-{

     UnRef();
     UnRef();

-

     m_refData = new wxBitmapRefData;
 
     m_refData = new wxBitmapRefData;
 

-    M_BITMAPDATA->m_width = w;
-    M_BITMAPDATA->m_height = h;
-    M_BITMAPDATA->m_depth = d;
+    GetBitmapData()->m_width = nW;
+    GetBitmapData()->m_height = nH;
+    GetBitmapData()->m_depth = nD;

 
 

-    /* TODO: create new bitmap */
+    if (nD > 0)
+    {
+        hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
+        if (!hBmp)
+        {
+            wxLogLastError("CreateBitmap");
+        }
+    }
+    else
+    {
+        ScreenHDC dc;
+        hbmp = ::CreateCompatibleBitmap(dc, w, h);
+        if ( !hbmp )
+        {
+            wxLogLastError("CreateCompatibleBitmap");
+        }
+
+        GetBitmapData()->m_depth = wxDisplayDepth();
+    }
+
+    SetHBITMAP((WXHBITMAP)hbmp);

 
 

-    return M_BITMAPDATA->m_ok;
+#if WXWIN_COMPATIBILITY_2
+    GetBitmapData()->m_ok = hbmp != 0;
+#endif // WXWIN_COMPATIBILITY_2
+
+    return Ok();

 }
 
 bool wxBitmap::LoadFile(const wxString& filename, long type)
 {
     UnRef();
 
 }
 
 bool wxBitmap::LoadFile(const wxString& filename, long type)
 {
     UnRef();
 

-    m_refData = new wxBitmapRefData;
-
-    wxBitmapHandler *handler = FindHandler(type);
+    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);

 
 

-    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);

     }
     }

+    else
+    {
+        wxImage image;
+        if ( !image.LoadFile( filename, type ) || !image.Ok() )
+            return FALSE;

 
 

-    return handler->LoadFile(this, filename, type, -1, -1);
+        *this = image.ConvertToBitmap();
+
+        return TRUE;
+    }

 }
 
 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 {
     UnRef();
 
 }
 
 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 {
     UnRef();
 

-    m_refData = new wxBitmapRefData;
-
-    wxBitmapHandler *handler = FindHandler(type);
+    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);

 
 

-    if ( handler == NULL ) {
-        wxLogWarning("no bitmap handler for type %d defined.", type);
+    if ( !handler )
+    {
+        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
+                       "type %d defined."), type);

 
         return FALSE;
     }
 
 
         return FALSE;
     }
 

+    m_refData = new wxBitmapRefData;
+

     return handler->Create(this, data, type, width, height, depth);
 }
 
 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 {
     return handler->Create(this, data, type, width, height, depth);
 }
 
 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 {

-    wxBitmapHandler *handler = FindHandler(type);
-
-    if ( handler == NULL ) {
-        wxLogWarning("no bitmap handler for type %d defined.", type);
-
-        return FALSE;
-  }
-
-  return handler->SaveFile(this, filename, type, palette);
-}
-
-void wxBitmap::SetWidth(int w)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_width = w;
-}
+    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);

 
 

-void wxBitmap::SetHeight(int h)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    if ( handler )
+    {
+        return handler->SaveFile(this, filename, type, palette);
+    }
+    else
+    {
+        // FIXME what about palette? shouldn't we use it?
+        wxImage image( *this );
+        if (!image.Ok())
+            return FALSE;

 
 

-    M_BITMAPDATA->m_height = h;
+        return image.SaveFile( filename, type );
+    }

 }
 
 }
 

-void wxBitmap::SetDepth(int d)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_depth = d;
-}
+// ----------------------------------------------------------------------------
+// wxBitmap accessors
+// ----------------------------------------------------------------------------

 
 void wxBitmap::SetQuality(int q)
 {
 
 void wxBitmap::SetQuality(int q)
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    EnsureHasData();

 
 

-    M_BITMAPDATA->m_quality = q;
+    GetBitmapData()->m_quality = q;

 }
 
 }
 

+#if WXWIN_COMPATIBILITY_2

 void wxBitmap::SetOk(bool isOk)
 {
 void wxBitmap::SetOk(bool isOk)
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    EnsureHasData();

 
 

-    M_BITMAPDATA->m_ok = isOk;
+    GetBitmapData()->m_ok = isOk;

 }
 }

+#endif // WXWIN_COMPATIBILITY_2

 
 void wxBitmap::SetPalette(const wxPalette& palette)
 {
 
 void wxBitmap::SetPalette(const wxPalette& palette)
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    EnsureHasData();

 
 

-    M_BITMAPDATA->m_bitmapPalette = palette ;
+    GetBitmapData()->m_bitmapPalette = palette;

 }
 
 void wxBitmap::SetMask(wxMask *mask)
 {
 }
 
 void wxBitmap::SetMask(wxMask *mask)
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_bitmapMask = mask ;
-}
-
-void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
-{
-  if (!M_BITMAPDATA)
-  m_refData = new wxBitmapRefData;
-
-  M_BITMAPDATA->m_hBitmap = bmp;
-}
-
-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;
-}
+    EnsureHasData();

 
 

-wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
-{
-    wxNode *node = sm_handlers.First();
-    while ( node )
-    {
-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        if ( handler->GetExtension() == extension &&
-                    (bitmapType == -1 || handler->GetType() == bitmapType) )
-            return handler;
-        node = node->Next();
-    }
-    return NULL;
-}
-
-wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
-{
-    wxNode *node = sm_handlers.First();
-    while ( node )
-    {
-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        if (handler->GetType() == bitmapType)
-            return handler;
-        node = node->Next();
-    }
-    return NULL;
+    GetBitmapData()->m_bitmapMask = mask;

 }
 
 // Creates a bitmap that matches the device context, from
 }
 
 // Creates a bitmap that matches the device context, from


@@ -379,29 +444,18 @@ wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 {
 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 {

-    wxBitmap        tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
-// TODO:
-/*

     wxMemoryDC      memDC;
     wxMemoryDC      memDC;

+    wxBitmap        tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());

     HPALETTE        hPal = (HPALETTE) NULL;
     LPBITMAPINFO    lpDib;
     void            *lpBits = (void*) NULL;
 
     HPALETTE        hPal = (HPALETTE) NULL;
     LPBITMAPINFO    lpDib;
     void            *lpBits = (void*) NULL;
 

-
-    wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) );
-
-    tmpBitmap.SetPalette(this->GetPalette());
-    memDC.SelectObject(tmpBitmap);
-    memDC.SetPalette(this->GetPalette());
-
-    hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
-
-    if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) )
+    if( GetPalette() && GetPalette()->Ok() )

     {
     {

-        tmpBitmap.SetPalette(* this->GetPalette());
+        tmpBitmap.SetPalette(*GetPalette());

         memDC.SelectObject(tmpBitmap);
         memDC.SelectObject(tmpBitmap);

-        memDC.SetPalette(* this->GetPalette());
-        hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
+        memDC.SetPalette(*GetPalette());
+        hPal = (HPALETTE)GetPalette()->GetHPALETTE();

     }
     else
     {
     }
     else
     {


@@ -413,26 +467,32 @@ wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
         memDC.SetPalette( palette );
     }
 
         memDC.SetPalette( palette );
     }
 

-    // set the height negative because in a DIB the order of the lines is reversed
-    createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib);
+    // set the height negative because in a DIB the order of the lines is
+    // reversed
+    if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
+    {
+        return wxNullBitmap;
+    }

 
     lpBits = malloc(lpDib->bmiHeader.biSizeImage);
 
 
     lpBits = malloc(lpDib->bmiHeader.biSizeImage);
 

-    ::GetBitmapBits((HBITMAP)GetHBITMAP(), lpDib->bmiHeader.biSizeImage, lpBits);
+    ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);

 
 

-    ::SetDIBitsToDevice((HDC) memDC.GetHDC(), 0, 0, this->GetWidth(), this->GetHeight(),
-                        0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS);
+    ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
+                        GetWidth(), GetHeight(),
+                        0, 0, 0, GetHeight(),
+                        lpBits, lpDib, DIB_RGB_COLORS);

 
     free(lpBits);
 
 
     free(lpBits);
 

-    freeDIB(lpDib);
-*/
-    return (tmpBitmap);
+    wxFreeDIB(lpDib);
+
+    return tmpBitmap;

 }
 
 }
 

-/*
- * wxMask
- */
+// ----------------------------------------------------------------------------
+// wxMask
+// ----------------------------------------------------------------------------

 
 wxMask::wxMask()
 {
 
 wxMask::wxMask()
 {


@@ -464,21 +524,57 @@ wxMask::wxMask(const wxBitmap& bitmap)
 
 wxMask::~wxMask()
 {
 
 wxMask::~wxMask()
 {

-// TODO: delete mask bitmap
+    if ( m_maskBitmap )
+        ::DeleteObject((HBITMAP) m_maskBitmap);

 }
 
 // Create a mask from a mono bitmap (copies the bitmap).
 bool wxMask::Create(const wxBitmap& bitmap)
 {
 }
 
 // Create a mask from a mono bitmap (copies the bitmap).
 bool wxMask::Create(const wxBitmap& bitmap)
 {

-// TODO
-    return FALSE;
+    if ( m_maskBitmap )
+    {
+        ::DeleteObject((HBITMAP) m_maskBitmap);
+        m_maskBitmap = 0;
+    }
+    if (!bitmap.Ok() || bitmap.GetDepth() != 1)
+    {
+        return FALSE;
+    }
+    m_maskBitmap = (WXHBITMAP) CreateBitmap(
+                                            bitmap.GetWidth(),
+                                            bitmap.GetHeight(),
+                                            1, 1, 0
+                                           );
+    HDC srcDC = CreateCompatibleDC(0);
+    SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
+    HDC destDC = CreateCompatibleDC(0);
+    SelectObject(destDC, (HBITMAP) m_maskBitmap);
+    BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
+    SelectObject(srcDC, 0);
+    DeleteDC(srcDC);
+    SelectObject(destDC, 0);
+    DeleteDC(destDC);
+    return TRUE;

 }
 
 // Create a mask from a bitmap and a palette index indicating
 // the transparent area
 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 {
 }
 
 // Create a mask from a bitmap and a palette index indicating
 // the transparent area
 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 {

-// TODO
+    if ( m_maskBitmap )
+    {
+        ::DeleteObject((HBITMAP) m_maskBitmap);
+        m_maskBitmap = 0;
+    }
+    if (bitmap.Ok() && bitmap.GetPalette()->Ok())
+    {
+        unsigned char red, green, blue;
+        if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
+        {
+            wxColour transparentColour(red, green, blue);
+            return Create(bitmap, transparentColour);
+        }
+    }

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -486,76 +582,164 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 // the transparent area
 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 {
 // the transparent area
 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 {

-// TODO
-    return FALSE;
+    if ( m_maskBitmap )
+    {
+        ::DeleteObject((HBITMAP) m_maskBitmap);
+        m_maskBitmap = 0;
+    }
+    if (!bitmap.Ok())
+    {
+        return FALSE;
+    }
+
+    // scan the bitmap for the transparent colour and set
+    // the corresponding pixels in the mask to BLACK and
+    // the rest to WHITE
+    COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
+    m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
+            bitmap.GetWidth(),
+            bitmap.GetHeight(),
+            1, 1, 0
+                                             );
+    HDC srcDC = ::CreateCompatibleDC(0);
+    ::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
+    HDC destDC = ::CreateCompatibleDC(0);
+    ::SelectObject(destDC, (HBITMAP) m_maskBitmap);
+
+    // this is not very efficient, but I can't think
+    // of a better way of doing it
+    for (int w = 0; w < bitmap.GetWidth(); w++)
+    {
+        for (int h = 0; h < bitmap.GetHeight(); h++)
+        {
+            COLORREF col = GetPixel(srcDC, w, h);
+            if (col == maskColour)
+            {
+                ::SetPixel(destDC, w, h, RGB(0, 0, 0));
+            }
+            else
+            {
+                ::SetPixel(destDC, w, h, RGB(255, 255, 255));
+            }
+        }
+    }
+    ::SelectObject(srcDC, 0);
+    ::DeleteDC(srcDC);
+    ::SelectObject(destDC, 0);
+    ::DeleteDC(destDC);
+    return TRUE;

 }
 
 }
 

-/*
- * wxBitmapHandler
- */
+// ----------------------------------------------------------------------------
+// wxBitmapHandler
+// ----------------------------------------------------------------------------

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+bool wxBitmapHandler::Create(wxGDIImage *image,
+                             void *data,
+                             long flags,
+                             int width, int height, int depth)
+{
+    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);

 
 

-bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
+    return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
+}
+
+bool wxBitmapHandler::Load(wxGDIImage *image,
+                           const wxString& name,
+                           long flags,
+                           int width, int height)
+{
+    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
+
+    return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
+}
+
+bool wxBitmapHandler::Save(wxGDIImage *image,
+                           const wxString& name,
+                           int type)
+{
+    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
+
+    return bitmap ? SaveFile(bitmap, name, type) : FALSE;
+}
+
+bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
+                             void *WXUNUSED(data),
+                             long WXUNUSED(type),
+                             int WXUNUSED(width),
+                             int WXUNUSED(height),
+                             int WXUNUSED(depth))

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

-bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
-        int desiredWidth, int desiredHeight)
+bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
+                               const wxString& WXUNUSED(name),
+                               long WXUNUSED(type),
+                               int WXUNUSED(desiredWidth),
+                               int WXUNUSED(desiredHeight))

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

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

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

-/*
- * Standard handlers
- */
+// ----------------------------------------------------------------------------
+// DIB functions
+// ----------------------------------------------------------------------------

 
 

-/* TODO: bitmap handlers, a bit like this:
-class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
+bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
+                 HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
-public:
-    inline wxBMPResourceHandler()
-    {
-        m_name = "Windows bitmap resource";
-        m_extension = "";
-        m_type = wxBITMAP_TYPE_BMP_RESOURCE;
-    };
+   unsigned long   i, headerSize;
+   LPBITMAPINFO    lpDIBheader = NULL;
+   LPPALETTEENTRY  lpPe = NULL;

 
 

-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-          int desiredWidth, int desiredHeight);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
-*/

 
 

-void wxBitmap::CleanUpHandlers()
-{
-    wxNode *node = sm_handlers.First();
-    while ( node )
-    {
-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        wxNode *next = node->Next();
-        delete handler;
-        delete node;
-        node = next;
-    }
+   // Allocate space for a DIB header
+   headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
+   lpDIBheader = (BITMAPINFO *) malloc(headerSize);
+   lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
+
+   GetPaletteEntries(hPal, 0, 256, lpPe);
+
+   memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
+
+   // Fill in the static parts of the DIB header
+   lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+   lpDIBheader->bmiHeader.biWidth = xSize;
+   lpDIBheader->bmiHeader.biHeight = ySize;
+   lpDIBheader->bmiHeader.biPlanes = 1;
+
+   // this value must be 1, 4, 8 or 24 so PixelDepth can only be
+   lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
+   lpDIBheader->bmiHeader.biCompression = BI_RGB;
+   lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
+   lpDIBheader->bmiHeader.biClrUsed = 256;
+
+
+   // Initialize the DIB palette
+   for (i = 0; i < 256; i++) {
+      lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
+      lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
+      lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
+      lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
+   }
+
+   *lpDIBHeader = lpDIBheader;
+
+   return TRUE;

 }
 
 }
 

-void wxBitmap::InitStandardHandlers()
+void wxFreeDIB(LPBITMAPINFO lpDIBHeader)

 {
 {

-/* TODO: initialize all standard bitmap or derive class handlers here.
-    AddHandler(new wxBMPResourceHandler);
-    AddHandler(new wxBMPFileHandler);
-    AddHandler(new wxXPMFileHandler);
-    AddHandler(new wxXPMDataHandler);
-    AddHandler(new wxICOResourceHandler);
-    AddHandler(new wxICOFileHandler);
-*/
+    free(lpDIBHeader);

 }
 
 }
 

+

diff --git a/src/os2/icon.cpp b/src/os2/icon.cpp
index 60614db09c32799db302b21132f5b68658c8726c..ffece6b1f3b98490e56b182e0b34f28279298318 100644 (file)
--- a/src/os2/icon.cpp
+++ b/src/os2/icon.cpp
@@ -17,12 +17,11 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include <stdio.h>
-#include "wx/setup.h"
-#include "wx/list.h"
-#include "wx/utils.h"
-#include "wx/app.h"
-#include "wx/icon.h"
+    #include "wx/defs.h"
+    #include "wx/list.h"
+    #include "wx/utils.h"
+    #include "wx/app.h"
+    #include "wx/icon.h"

 #endif
 
 #include "wx/os2/private.h"
 #endif
 
 #include "wx/os2/private.h"


@@ -31,120 +30,77 @@
 #include "wx/icon.h"
 
 #if !USE_SHARED_LIBRARIES
 #include "wx/icon.h"
 
 #if !USE_SHARED_LIBRARIES

-IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
+    IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)

 #endif
 
 #endif
 

-/*
- * Icons
- */
+// ============================================================================
+// implementation
+// ============================================================================

 
 

-wxIconRefData::wxIconRefData()
-{
-  m_hIcon = (WXHICON) NULL ;
-}
+// ----------------------------------------------------------------------------
+// wxIconRefData
+// ----------------------------------------------------------------------------

 
 

-wxIconRefData::~wxIconRefData()
+void wxIconRefData::Free()

 {
 {

-  if ( m_hIcon )
-     return;
-  // TODO  ::DestroyIcon((HICON) m_hIcon);
+    if ( m_hIcon )
+        ::DestroyIcon((HICON) m_hIcon);

 }
 
 }
 

+// ----------------------------------------------------------------------------
+// wxIcon
+// ----------------------------------------------------------------------------
+

 wxIcon::wxIcon()
 {
 }
 
 wxIcon::wxIcon()
 {
 }
 

-wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
+wxIcon::wxIcon(
+  const char                        WXUNUSED(bits)[]
+, int                               WXUNUSED(nWidth)
+, int                               WXUNUSED(nHeight)
+)

 {
 }
 
 {
 }
 

-wxIcon::wxIcon(const wxString& icon_file, long flags,
-    int desiredWidth, int desiredHeight)
-
+wxIcon::wxIcon(
+  const wxString&                   rIconFile
+, long                              lFlags
+, int                               nDesiredWidth
+, int                               nDesiredHeight
+)

 {
 {

-    LoadFile(icon_file, flags, desiredWidth, desiredHeight);
+    LoadFile( rIconFile
+             ,lFlags
+             ,nDesiredWidth
+             ,nDesiredHeight
+            );

 }
 
 wxIcon::~wxIcon()
 {
 }
 
 }
 
 wxIcon::~wxIcon()
 {
 }
 

-bool wxIcon::LoadFile(const wxString& filename, long type,
-    int desiredWidth, int desiredHeight)
-{
-  UnRef();
-
-  m_refData = new wxIconRefData;
-
-  wxBitmapHandler *handler = FindHandler(type);
-
-  if ( handler )
-    return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
-  else
-    return FALSE;
-}
-
-void wxIcon::SetHICON(WXHICON ico)
-{
-  if ( !M_ICONDATA )
-  m_refData = new wxIconRefData;
-
-  M_ICONDATA->m_hIcon = ico;
-}
-
-bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-  return FALSE;
-}
-
-bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
+bool wxIcon::LoadFile(
+  const wxString&                   rFilename
+, long                              lType
+, int                               nDesiredWidth
+, int                               nDesiredHeight
+)

 {
 {

-// TODO
-/*
-  if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
-  {
-    if (desiredWidth > -1 && desiredHeight > -1)
-    {
-        M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
-    }
+    wxGDIImageHandler*              pHandler = FindHandler(type);
+
+    UnRef();
+    m_refData = new wxIconRefData;
+
+    if (pHandler)
+        return(pHandler->Load( this
+                              ,rFilename
+                              ,lType
+                              ,nDesiredWidth
+                              ,nDesiredHeight
+                             ));

     else
     else

-    {
-      M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadIcon(wxGetInstance(), name);
-    }
-
-    ICONINFO info ;
-    if (::GetIconInfo((HICON) M_ICONHANDLERDATA->m_hIcon, &info))
-    {
-        HBITMAP ms_bitmap = info.hbmMask ;
-        if (ms_bitmap)
-        {
-            BITMAP bm;
-            ::GetObject(ms_bitmap, sizeof(BITMAP), (LPSTR) &bm);
-            M_ICONHANDLERDATA->m_width = bm.bmWidth;
-            M_ICONHANDLERDATA->m_height = bm.bmHeight;
-        }
-        if (info.hbmMask)
-            ::DeleteObject(info.hbmMask) ;
-        if (info.hbmColor)
-            ::DeleteObject(info.hbmColor) ;
-      }
-    }
-    // Override the found values with desired values
-    if (desiredWidth > -1 && desiredHeight > -1)
-    {
-       M_ICONHANDLERDATA->m_width = desiredWidth;
-       M_ICONHANDLERDATA->m_height = desiredHeight;
-    }
-
-    M_ICONHANDLERDATA->m_ok = (M_ICONHANDLERDATA->m_hIcon != 0);
-    return M_ICONHANDLERDATA->m_ok;
-  }
-  else
-*/
-    return FALSE;
+        return(FALSE);

 }
 
 }
 

diff --git a/src/os2/statbmp.cpp b/src/os2/statbmp.cpp
index bc19e866feb778aeb9c09fe1d7b54f194dfb82a8..a04f0547cd49261ceea2bfa3fe6b8e4bf0e7009c 100644 (file)
--- a/src/os2/statbmp.cpp
+++ b/src/os2/statbmp.cpp
@@ -3,7 +3,7 @@
 // Purpose:     wxStaticBitmap
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxStaticBitmap
 // Author:      David Webster
 // Modified by:

-// Created:     ??/??/98
+// Created:     11/27/99

 // RCS-ID:      $Id$
 // Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 // RCS-ID:      $Id$
 // Copyright:   (c) David Webster
 // Licence:     wxWindows licence


@@ -34,17 +34,20 @@ IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
 //  wxStaticBitmap
 // ---------------------------------------------------------------------------
 
 //  wxStaticBitmap
 // ---------------------------------------------------------------------------
 

-bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
-           const wxBitmap& bitmap,
-           const wxPoint& pos,
-           const wxSize& size,
-           long style,
-           const wxString& name)
+bool wxStaticBitmap::Create(
+  wxWindow*                         pParent
+, wxWindowID                        nId
+, const wxGDIImage&                 rBitmap
+, const wxPoint&                    rPos
+, const wxSize&                     rSize
+, long                              lStyle
+, const wxString&                   rName
+)

 {
     Init();
 
 {
     Init();
 

-    SetName(name);
-    if (parent) parent->AddChild(this);
+    SetName(rName);
+    if (pParent) parent->AddChild(this);

 
     m_backgroundColour = parent->GetBackgroundColour() ;
     m_foregroundColour = parent->GetForegroundColour() ;
 
     m_backgroundColour = parent->GetBackgroundColour() ;
     m_foregroundColour = parent->GetForegroundColour() ;


@@ -52,52 +55,55 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
     if ( id == -1 )
         m_windowId = (int)NewControlId();
     else
     if ( id == -1 )
         m_windowId = (int)NewControlId();
     else

-        m_windowId = id;
+        m_windowId = nId;

 
 

-    m_windowStyle = style;
+    m_windowStyle = lStyle;

 
 

-    int x = pos.x;
-    int y = pos.y;
-    int width = size.x;
-    int height = size.y;
+    int                             nX= pos.x;
+    int                             nY = pos.y;
+    int                             nWidth = size.x;
+    int                             nHeight = size.y;

 
 

-    m_windowStyle = style;
+    m_windowStyle = lStyle;

 
 

-    m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
+    m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));

 
     // TODO: create static bitmap control
 
     // TODO: create static bitmap control

+    const wxChar*                   zClassname = wxT("WX_STATIC");
+    int                             nWinstyle ? SS_ICON : SS_BITMAP;
+
+    m_hWnd = (WXWHND)::WinCreateWindow( pParent->GetHWND()
+                                       ,zClassname
+                                       ,wxT("")
+                                       ,nWinstyle | WS_VISIBLE
+                                       ,0,0,0,0
+                                       ,pParent->GetHWND()
+                                       ,HWND_TOP
+                                       ,m_windowId
+                                       ,NULL
+                                       ,NULL
+                                      );
+

     wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
 
     wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
 

-    SetBitmap(bitmap);
+    SetImage(rBitmap);

 
     // Subclass again for purposes of dialog editing mode
     SubclassWin(m_hWnd);
 
     // Subclass again for purposes of dialog editing mode
     SubclassWin(m_hWnd);

-

     SetFont(GetParent()->GetFont());
     SetFont(GetParent()->GetFont());

-
-    SetSize(x, y, width, height);
-
-    return FALSE;
+    SetSize(nX, nY, nWidth, nHeight);
+    return(FALSE);

 }
 
 bool wxStaticBitmap::ImageIsOk() const
 {
 }
 
 bool wxStaticBitmap::ImageIsOk() const
 {

-    if ( m_isIcon && m_image.icon )
-        return m_image.icon->Ok();
-    else if ( m_image.bitmap )
-        return m_image.bitmap->Ok();
-    else
-        return FALSE;
+    return(m_pImage ** m_pImage->Ok());

 }
 
 void wxStaticBitmap::Free()
 {
 }
 
 void wxStaticBitmap::Free()
 {

-    if ( m_isIcon )
-        delete m_image.icon;
-    else
-        delete m_image.bitmap;
-
-    m_image.icon = NULL;
+    delete m_pImage;
+    m_pImage = NULL;

 }
 
 wxSize wxStaticBitmap::DoGetBestSize() const
 }
 
 wxSize wxStaticBitmap::DoGetBestSize() const


@@ -107,22 +113,59 @@ wxSize wxStaticBitmap::DoGetBestSize() const
     return wxWindow::DoGetBestSize();
 }
 
     return wxWindow::DoGetBestSize();
 }
 

-void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
+void wxStaticBitmap::SetImage(
+  const wxGDIImage&                 rBitmap
+)

 {
     Free();
 
 {
     Free();
 

-    m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
-    if ( m_isIcon )
-        m_image.icon = new wxIcon((const wxIcon&)bitmap);
+    m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));
+    if (m_bIsIcon)
+        m_pImage = new wxIcon((const wxIcon&)rBitmap);

     else
     else

-        m_image.bitmap = new wxBitmap(bitmap);
-
-    int x, y;
-    int w, h;
-    GetPosition(&x, &y);
-    GetSize(&w, &h);
-
-    // TODO: redraw bitmap
+        m_pImage = new wxBitmap((const wxBitmap &)rBitmap);
+
+    int                             nX;
+    int                             nY;
+    int                             nW;
+    int                             nH;
+
+    GetPosition(&nX, &nY);
+    GetSize(&nW, &nHh);
+
+    ::WinSendMsg( GetHwnd()
+                 ,SM_SETHANDLE
+                 ,MPFROMHWND(m_pImage->GetHandle())
+                 ,NULL
+                );
+    if (ImageIsOk())
+    {
+        int                         nWidth = rBitmap.GetWidth();
+        int                         nHeight = rBitmap.GetHeight();
+
+        if (nWidth && nHeight)
+        {
+            nW = nWidth;
+            nW = nHeight;
+
+            ::WinSetWindowPos( GetHwnd()
+                              ,HWND_TOP
+                              ,nX
+                              ,nY
+                              ,nWidth
+                              ,nHeight
+                              ,SWP_SIZE | SWP_MOVE | SWP_SHOW
+                             );
+        }
+    }
+
+    RECTL                           vRect;
+
+    vRect.xLeft   = nW;
+    vRect.yTop    = nY;
+    vRect.xRight  = nX + nW;
+    vRect.yBottom = nY + nH;
+
+    ::WinInvalidateRect(GetHwndOf(GetParent()), &vRect, TRUE);

 }
 
 }
 

-

diff --git a/src/os2/thread.cpp b/src/os2/thread.cpp
index 04769f4cb2ae2c7ae99597d0483e89acb5bb6d60..7b4a4643c8a617688d4460990a545adc63efa511 100644 (file)
--- a/src/os2/thread.cpp
+++ b/src/os2/thread.cpp
@@ -596,68 +596,17 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
         }
 
 #if wxUSE_GUI
         }
 
 #if wxUSE_GUI

-        // we can't just wait for the thread to terminate because it might be
-        // calling some GUI functions and so it will never terminate before we
-        // process the Windows messages that result from these functions
-        ULONG                       ulrc;
-        do
-        {
-            ulrc = ::MsgWaitForMultipleObjects
-                     (
-                       1,              // number of objects to wait for
-                       &hThread,       // the objects
-                       FALSE,          // don't wait for all objects
-                       INFINITE,       // no timeout
-                       QS_ALLEVENTS    // return as soon as there are any events
-                     );
-
-            switch ( result )
-            {
-                case 0xFFFFFFFF:
-                    // error
-                    wxLogSysError(_("Can not wait for thread termination"));
-                    Kill();
-                    return wxTHREAD_KILLED;
-
-                case WAIT_OBJECT_0:
-                    // thread we're waiting for terminated
-                    break;
-
-                case WAIT_OBJECT_0 + 1:
-                    // new message arrived, process it
-                    if ( !wxTheApp->DoMessage() )
-                    {
-                        // WM_QUIT received: kill the thread
-                        Kill();
-
-                        return wxTHREAD_KILLED;
-                    }
-
-                    if ( IsMain() )
-                    {
-                        // give the thread we're waiting for chance to exit
-                        // from the GUI call it might have been in
-                        if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
-                        {
-                            wxMutexGuiLeave();
-                        }
-                    }
-
-                    break;
-
-                default:
-                    wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
-            }
-        } while ( result != WAIT_OBJECT_0 );
-#else // !wxUSE_GUI
-        // simply wait for the thread to terminate
-        //
-        // OTOH, even console apps create windows (in wxExecute, for WinSock
-        // &c), so may be use MsgWaitForMultipleObject() too here?
-        if ( WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0 )
+        // need a way to finish GUI processing before killing the thread
+        // until then we just exit
+
+        if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread())

         {
         {

-            wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
+            wxMutexGuiLeave();

         }
         }

+#else // !wxUSE_GUI
+
+        // can't wait for yourself to end under OS/2 so just quit
+

 #endif // wxUSE_GUI/!wxUSE_GUI
 
         if ( IsMain() )
 #endif // wxUSE_GUI/!wxUSE_GUI
 
         if ( IsMain() )


@@ -670,19 +619,10 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
         }
     }
 
         }
     }
 

-    if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
+    ::DosExit(0, 0);
+    // probably won't get this far, but
+    if (IsDetached())

     {
     {

-        wxLogLastError("GetExitCodeThread");
-
-        rc = (ExitCode)-1;
-    }
-
-    if ( IsDetached() )
-    {
-        // if the thread exits normally, this is done in WinThreadStart, but in
-        // this case it would have been too early because
-        // MsgWaitForMultipleObject() would fail if the therad handle was
-        // closed while we were waiting on it, so we must do it here

         delete this;
     }
 
         delete this;
     }
 


@@ -701,14 +641,19 @@ wxThreadError wxThread::Kill()
         return wxTHREAD_NOT_RUNNING;
 
     ::DosKillThread(m_internal->GetHandle());
         return wxTHREAD_NOT_RUNNING;
 
     ::DosKillThread(m_internal->GetHandle());

-    delete this;
+    m_internal->Free();
+    if (IsDetached())
+    {
+        delete this;
+    }

     return wxTHREAD_NO_ERROR;
 }
 
 void wxThread::Exit(
     return wxTHREAD_NO_ERROR;
 }
 
 void wxThread::Exit(

-  void*                             pStatus
+  ExitCode                          pStatus

 )
 {
 )
 {

+    m_internal->Free();

     delete this;
     ::DosExit(EXIT_THREAD, ULONG(pStatus));
     wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
     delete this;
     ::DosExit(EXIT_THREAD, ULONG(pStatus));
     wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));


@@ -730,11 +675,18 @@ unsigned int wxThread::GetPriority() const
     return m_internal->GetPriority();
 }
 
     return m_internal->GetPriority();
 }
 

+unsigned long wxThread::GetId() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+
+    return (unsigned long)m_internal->GetId();
+}
+

 bool wxThread::IsRunning() const
 {
     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 
 bool wxThread::IsRunning() const
 {
     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 

-    return m_internal->GetState() == STATE_RUNNING;
+    return(m_internal->GetState() == STATE_RUNNING);

 }
 
 bool wxThread::IsAlive() const
 }
 
 bool wxThread::IsAlive() const


@@ -759,11 +711,6 @@ bool wxThread::TestDestroy()
     return m_internal->GetState() == STATE_CANCELED;
 }
 
     return m_internal->GetState() == STATE_CANCELED;
 }
 

-wxThread::~wxThread()
-{
-    delete m_internal;
-}
-

 // ----------------------------------------------------------------------------
 // Automatic initialization for thread module
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Automatic initialization for thread module
 // ----------------------------------------------------------------------------