]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/os2/gdiimage.h
don't draw borders for bitmap buttons with wxBORDER_NONE style
[wxWidgets.git] / include / wx / os2 / gdiimage.h
index db980074f79f51479365b7e9127ec11f0099a93e..7d96b89e9f1f51a31b1fb81ce4142ba95a056fae 100644 (file)
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        include/wx/os2/gdiimage.h
+// Name:        wx/os2/gdiimage.h
 // Purpose:     wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
 //              under OS/2
 // Author:      David Webster (adapted from msw version by Vadim Zeitlin)
@@ -7,7 +7,7 @@
 // Created:     20.11.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 David Webster
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // NB: this is a private header, it is not intended to be directly included by
 #ifndef _WX_OS2_GDIIMAGE_H_
 #define _WX_OS2_GDIIMAGE_H_
 
-#ifdef __GNUG__
-    #pragma interface "gdiimage.h"
-#endif
-
 #include "wx/gdiobj.h"          // base class
 #include "wx/gdicmn.h"          // wxBITMAP_TYPE_INVALID
 #include "wx/list.h"
 
-class WXDLLEXPORT wxGDIImageRefData;
-class WXDLLEXPORT wxGDIImageHandler;
-class WXDLLEXPORT wxGDIImage;
+class WXDLLIMPEXP_FWD_CORE wxGDIImageRefData;
+class WXDLLIMPEXP_FWD_CORE wxGDIImageHandler;
+class WXDLLIMPEXP_FWD_CORE wxGDIImage;
+
+WX_DECLARE_EXPORTED_LIST(wxGDIImageHandler, wxGDIImageHandlerList);
 
 // ----------------------------------------------------------------------------
 // wxGDIImageRefData: common data fields for all derived classes
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxGDIImageRefData : public wxGDIRefData
+class WXDLLIMPEXP_CORE wxGDIImageRefData : public wxGDIRefData
 {
 public:
     wxGDIImageRefData()
@@ -40,14 +38,15 @@ public:
         m_nWidth = m_nHeight = m_nDepth = 0;
 
         m_hHandle = 0;
-
-#if WXWIN_COMPATIBILITY_2
-        m_bOk = FALSE;
-#endif // WXWIN_COMPATIBILITY_2
     }
 
     // accessors
-    bool IsOk() const { return m_hHandle != 0; }
+    virtual bool IsOk() const
+    {
+        if (m_hHandle == 0)
+            return false;
+        return true;
+    }
 
     void SetSize( int nW
                  ,int nH
@@ -55,7 +54,7 @@ public:
         { m_nWidth = nW; m_nHeight = nH; }
 
     // free the ressources we allocated
-    virtual void Free() = 0;
+    virtual void Free() { };
 
     // for compatibility, the member fields are public
 
@@ -75,27 +74,21 @@ public:
         WXHCURSOR                   m_hCursor;
     };
 
-    // this filed is redundant and using it is error prone but keep it for
-    // backwards compatibility
-#if WXWIN_COMPATIBILITY_2
-    void SetOk() { m_bOk = m_hHandle != 0; }
-
-    bool                            m_bOk;
-#endif // WXWIN_COMPATIBILITY_2
+    unsigned int                    m_uId;
 };
 
 // ----------------------------------------------------------------------------
 // wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxGDIImageHandler : public wxObject
+class WXDLLIMPEXP_CORE wxGDIImageHandler : public wxObject
 {
 public:
     // ctor
     wxGDIImageHandler() { m_lType = wxBITMAP_TYPE_INVALID; }
     wxGDIImageHandler( const wxString& rName
                       ,const wxString& rExt
-                      ,long            lType
+                      ,wxBitmapType    lType
                      )
                      : m_sName(rName)
                      , m_sExtension(rExt)
@@ -106,16 +99,16 @@ public:
     // accessors
     void SetName(const wxString& rName) { m_sName = rName; }
     void SetExtension(const wxString& rExt) { m_sExtension = rExt; }
-    void SetType(long lType) { m_lType = lType; }
+    void SetType(wxBitmapType lType) { m_lType = lType; }
 
     wxString GetName() const { return m_sName; }
     wxString GetExtension() const { return m_sExtension; }
-    long GetType() const { return m_lType; }
+    wxBitmapType GetType() const { return m_lType; }
 
     // real handler operations: to implement in derived classes
     virtual bool Create( wxGDIImage* pImage
-                        ,void*       pData
-                        ,long        lFlags
+                        ,const void* pData
+                        ,wxBitmapType lFlags
                         ,int         nWidth
                         ,int         nHeight
                         ,int         nDepth = 1
@@ -123,20 +116,26 @@ public:
     virtual bool Load( wxGDIImage*     pImage
                       ,const wxString& rName
                       ,HPS             hPs
-                      ,long            lFlags
+                      ,wxBitmapType    lFlags
                       ,int             nDesiredWidth
                       ,int             nDesiredHeight
                      ) = 0;
-    virtual bool Save( wxGDIImage*     pImage
-                      ,const wxString& rName
-                      ,int             lType
+    virtual bool Load( wxGDIImage*     pImage
+                      ,int             nId
+                      ,wxBitmapType    lFlags
+                      ,int             nDesiredWidth
+                      ,int             nDesiredHeight
                      ) = 0;
+    virtual bool Save( const wxGDIImage* pImage
+                      ,const wxString&   rName
+                      ,wxBitmapType      lType
+                     ) const = 0;
 
 protected:
     wxString                        m_sName;
     wxString                        m_sExtension;
-    long                            m_lType;
-};
+    wxBitmapType                    m_lType;
+}; // end of wxGDIImageHandler
 
 // ----------------------------------------------------------------------------
 // wxGDIImage: this class supports GDI image handlers which may be registered
@@ -144,19 +143,19 @@ protected:
 // format. It also falls back to wxImage if no appropriate image is found.
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxGDIImage : public wxGDIObject
+class WXDLLIMPEXP_CORE wxGDIImage : public wxGDIObject
 {
 public:
     // handlers list interface
-    static wxList& GetHandlers() { return ms_handlers; }
+    static wxGDIImageHandlerList& GetHandlers() { return ms_handlers; }
 
     static void AddHandler(wxGDIImageHandler* hHandler);
     static void InsertHandler(wxGDIImageHandler* hHandler);
     static bool RemoveHandler(const wxString& rName);
 
     static wxGDIImageHandler* FindHandler(const wxString& rName);
-    static wxGDIImageHandler* FindHandler(const wxString& rExtension, long lType);
-    static wxGDIImageHandler* FindHandler(long lType);
+    static wxGDIImageHandler* FindHandler(const wxString& rExtension, wxBitmapType lType);
+    static wxGDIImageHandler* FindHandler(wxBitmapType lType);
 
     static void InitStandardHandlers();
     static void CleanUpHandlers();
@@ -170,16 +169,34 @@ public:
 
     // accessors
     WXHANDLE GetHandle() const
-        { return IsNull() ? 0 : GetGDIImageData()->m_hHandle; }
+    {
+        wxGDIImageRefData*               pData;
+
+        pData = GetGDIImageData();
+        if (!pData)
+            return 0;
+        else
+            return pData->m_hHandle;
+    }
     void SetHandle(WXHANDLE hHandle)
-        { EnsureHasData(); GetGDIImageData()->m_hHandle = hHandle; }
+    {
+        wxGDIImageRefData*               pData;
 
-    bool Ok() const { return GetHandle() != 0; }
+        EnsureHasData();
+        pData = GetGDIImageData();
+        pData->m_hHandle = hHandle;
+    }
 
     int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_nWidth; }
     int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_nHeight; }
     int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_nDepth; }
 
+    wxSize GetSize() const
+    {
+        return IsNull() ? wxSize(0,0) :
+               wxSize(GetGDIImageData()->m_nWidth, GetGDIImageData()->m_nHeight);
+    }
+
     void SetWidth(int nW) { EnsureHasData(); GetGDIImageData()->m_nWidth = nW; }
     void SetHeight(int nH) { EnsureHasData(); GetGDIImageData()->m_nHeight = nH; }
     void SetDepth(int nD) { EnsureHasData(); GetGDIImageData()->m_nDepth = nD; }
@@ -193,15 +210,43 @@ public:
     }
     void SetSize(const wxSize& rSize) { SetSize(rSize.x, rSize.y); }
 
+    unsigned int GetId(void) const
+    {
+        wxGDIImageRefData*          pData;
+
+        pData = GetGDIImageData();
+        if (!pData)
+            return 0;
+        else
+            return pData->m_uId;
+    } // end of WxWinGdi_CGDIImage::GetId
+    void SetId(unsigned int uId)
+    {
+        wxGDIImageRefData*          pData;
+
+        EnsureHasData();
+        pData = GetGDIImageData();
+        pData->m_uId = uId;
+    }
     // forward some of base class virtuals to wxGDIImageRefData
-    bool             FreeResource(bool bForce = FALSE);
-    virtual WXHANDLE GetResourceHandle();
+    bool             FreeResource(bool bForce = false);
+    virtual WXHANDLE GetResourceHandle() const;
 
 protected:
     // create the data for the derived class here
     virtual wxGDIImageRefData* CreateData() const = 0;
+    virtual wxGDIRefData *CreateGDIRefData() const { return CreateData(); }
+
+    // we can't [efficiently] clone objects of this class
+    virtual wxGDIRefData *
+    CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const
+    {
+        wxFAIL_MSG( _T("must be implemented if used") );
+
+        return NULL;
+    }
 
-    static wxList                   ms_handlers;
+    static wxGDIImageHandlerList    ms_handlers;
 };
 
 #endif // _WX_MSW_GDIIMAGE_H_