include/wx/os2/gdiimage.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        include/wx/os2/gdiimage.h
   3 // Purpose:     wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
   4 //              under OS/2
   5 // Author:      David Webster (adapted from msw version by Vadim Zeitlin)
   6 // Modified by:
   7 // Created:     20.11.99
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1999 David Webster
  10 // Licence:     wxWindows license
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 // NB: this is a private header, it is not intended to be directly included by
  14 //     user code (but may be included from other, public, wxWin headers
  15
  16 #ifndef _WX_OS2_GDIIMAGE_H_
  17 #define _WX_OS2_GDIIMAGE_H_
  18
  19 #ifdef __GNUG__
  20     #pragma interface "gdiimage.h"
  21 #endif
  22
  23 #include "wx/gdiobj.h"          // base class
  24 #include "wx/gdicmn.h"          // wxBITMAP_TYPE_INVALID
  25 #include "wx/list.h"
  26
  27 class WXDLLEXPORT wxGDIImageRefData;
  28 class WXDLLEXPORT wxGDIImageHandler;
  29 class WXDLLEXPORT wxGDIImage;
  30
  31 // ----------------------------------------------------------------------------
  32 // wxGDIImageRefData: common data fields for all derived classes
  33 // ----------------------------------------------------------------------------
  34
  35 class WXDLLEXPORT wxGDIImageRefData : public wxGDIRefData
  36 {
  37 public:
  38     wxGDIImageRefData()
  39     {
  40         m_nWidth = m_nHeight = m_nDepth = 0;
  41
  42         m_hHandle = 0;
  43
  44 #if WXWIN_COMPATIBILITY_2
  45         m_bOk = FALSE;
  46 #endif // WXWIN_COMPATIBILITY_2
  47     }
  48
  49     // accessors
  50     bool IsOk() const
  51     {
  52         if (m_hHandle == 0)
  53             return FALSE;
  54         return TRUE;
  55     }
  56
  57     void SetSize( int nW
  58                  ,int nH
  59                 )
  60         { m_nWidth = nW; m_nHeight = nH; }
  61
  62     // free the ressources we allocated
  63     virtual void Free() { };
  64
  65     // for compatibility, the member fields are public
  66
  67     // the size of the image
  68     int                             m_nWidth;
  69     int                             m_nHeight;
  70
  71     // the depth of the image
  72     int                             m_nDepth;
  73
  74     // the handle to it
  75     union
  76     {
  77         WXHANDLE                    m_hHandle;     // for untyped access
  78         WXHBITMAP                   m_hBitmap;
  79         WXHICON                     m_hIcon;
  80         WXHCURSOR                   m_hCursor;
  81     };
  82
  83     // this filed is redundant and using it is error prone but keep it for
  84     // backwards compatibility
  85 #if WXWIN_COMPATIBILITY_2
  86     void SetOk() { m_bOk = m_hHandle != 0; }
  87
  88     bool                            m_bOk;
  89 #endif // WXWIN_COMPATIBILITY_2
  90     UINT                            m_uId;
  91 };
  92
  93 // ----------------------------------------------------------------------------
  94 // wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
  95 // ----------------------------------------------------------------------------
  96
  97 class WXDLLEXPORT wxGDIImageHandler : public wxObject
  98 {
  99 public:
 100     // ctor
 101     wxGDIImageHandler() { m_lType = wxBITMAP_TYPE_INVALID; }
 102     wxGDIImageHandler( const wxString& rName
 103                       ,const wxString& rExt
 104                       ,long            lType
 105                      )
 106                      : m_sName(rName)
 107                      , m_sExtension(rExt)
 108     {
 109         m_lType = lType;
 110     }
 111
 112     // accessors
 113     void SetName(const wxString& rName) { m_sName = rName; }
 114     void SetExtension(const wxString& rExt) { m_sExtension = rExt; }
 115     void SetType(long lType) { m_lType = lType; }
 116
 117     wxString GetName() const { return m_sName; }
 118     wxString GetExtension() const { return m_sExtension; }
 119     long GetType() const { return m_lType; }
 120
 121     // real handler operations: to implement in derived classes
 122     virtual bool Create( wxGDIImage* pImage
 123                         ,void*       pData
 124                         ,long        lFlags
 125                         ,int         nWidth
 126                         ,int         nHeight
 127                         ,int         nDepth = 1
 128                        ) = 0;
 129     virtual bool Load( wxGDIImage*     pImage
 130                       ,const wxString& rName
 131                       ,HPS             hPs
 132                       ,long            lFlags
 133                       ,int             nDesiredWidth
 134                       ,int             nDesiredHeight
 135                      ) = 0;
 136     virtual bool Load( wxGDIImage*     pImage
 137                       ,int             nId
 138                       ,long            lFlags
 139                       ,int             nDesiredWidth
 140                       ,int             nDesiredHeight
 141                      ) = 0;
 142     virtual bool Save( wxGDIImage*     pImage
 143                       ,const wxString& rName
 144                       ,int             lType
 145                      ) = 0;
 146
 147 protected:
 148     wxString                        m_sName;
 149     wxString                        m_sExtension;
 150     long                            m_lType;
 151 }; // end of wxGDIImageHandler
 152
 153 // ----------------------------------------------------------------------------
 154 // wxGDIImage: this class supports GDI image handlers which may be registered
 155 // dynamically and will be used for loading/saving the images in the specified
 156 // format. It also falls back to wxImage if no appropriate image is found.
 157 // ----------------------------------------------------------------------------
 158
 159 class WXDLLEXPORT wxGDIImage : public wxGDIObject
 160 {
 161 public:
 162     // handlers list interface
 163     static wxList& GetHandlers() { return ms_handlers; }
 164
 165     static void AddHandler(wxGDIImageHandler* hHandler);
 166     static void InsertHandler(wxGDIImageHandler* hHandler);
 167     static bool RemoveHandler(const wxString& rName);
 168
 169     static wxGDIImageHandler* FindHandler(const wxString& rName);
 170     static wxGDIImageHandler* FindHandler(const wxString& rExtension, long lType);
 171     static wxGDIImageHandler* FindHandler(long lType);
 172
 173     static void InitStandardHandlers();
 174     static void CleanUpHandlers();
 175
 176     // access to the ref data casted to the right type
 177     wxGDIImageRefData *GetGDIImageData() const
 178         { return (wxGDIImageRefData *)m_refData; }
 179
 180     // create data if we don't have it yet
 181     void EnsureHasData() { if ( IsNull() ) m_refData = CreateData(); }
 182
 183     // accessors
 184     WXHANDLE GetHandle() const
 185     {
 186         wxGDIImageRefData*               pData;
 187
 188         pData = GetGDIImageData();
 189         if (!pData)
 190             return 0;
 191         else
 192             return pData->m_hHandle;
 193     }
 194     void SetHandle(WXHANDLE hHandle)
 195     {
 196         wxGDIImageRefData*               pData;
 197
 198         EnsureHasData();
 199         pData = GetGDIImageData();
 200         pData->m_hHandle = hHandle;
 201     }
 202
 203     bool Ok() const { return GetHandle() != 0; }
 204
 205     int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_nWidth; }
 206     int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_nHeight; }
 207     int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_nDepth; }
 208
 209     void SetWidth(int nW) { EnsureHasData(); GetGDIImageData()->m_nWidth = nW; }
 210     void SetHeight(int nH) { EnsureHasData(); GetGDIImageData()->m_nHeight = nH; }
 211     void SetDepth(int nD) { EnsureHasData(); GetGDIImageData()->m_nDepth = nD; }
 212
 213     void SetSize( int nW
 214                  ,int nH
 215                 )
 216     {
 217         EnsureHasData();
 218         GetGDIImageData()->SetSize(nW, nH);
 219     }
 220     void SetSize(const wxSize& rSize) { SetSize(rSize.x, rSize.y); }
 221
 222     UINT GetId(void) const
 223     {
 224         wxGDIImageRefData*          pData;
 225
 226         pData = GetGDIImageData();
 227         if (!pData)
 228             return 0;
 229         else
 230             return pData->m_uId;
 231     } // end of WxWinGdi_CGDIImage::GetId
 232     void SetId(UINT uId)
 233     {
 234         wxGDIImageRefData*          pData;
 235
 236         EnsureHasData();
 237         pData = GetGDIImageData();
 238         pData->m_uId = uId;
 239     }
 240     // forward some of base class virtuals to wxGDIImageRefData
 241     bool             FreeResource(bool bForce = FALSE);
 242     virtual WXHANDLE GetResourceHandle();
 243
 244 protected:
 245     // create the data for the derived class here
 246     virtual wxGDIImageRefData* CreateData() const = 0;
 247
 248     static wxList                   ms_handlers;
 249 };
 250
 251 #endif // _WX_MSW_GDIIMAGE_H_