include/wx/os2/bitmap.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/os2/bitmap.h
   3 // Purpose:     wxBitmap class
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     11/28/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_BITMAP_H_
  13 #define _WX_BITMAP_H_
  14
  15 #include "wx/os2/private.h"
  16 #include "wx/os2/gdiimage.h"
  17 #include "wx/gdicmn.h"
  18 #include "wx/palette.h"
  19
  20 class WXDLLEXPORT wxDC;
  21 class WXDLLEXPORT wxControl;
  22 class WXDLLEXPORT wxBitmap;
  23 class WXDLLEXPORT wxBitmapHandler;
  24 class WXDLLEXPORT wxIcon;
  25 class WXDLLEXPORT wxMask;
  26 class WXDLLEXPORT wxCursor;
  27 class WXDLLEXPORT wxControl;
  28 class WXDLLEXPORT wxImage;
  29
  30 // ----------------------------------------------------------------------------
  31 // Bitmap data
  32 //
  33 // NB: this class is private, but declared here to make it possible inline
  34 //     wxBitmap functions accessing it
  35 // ----------------------------------------------------------------------------
  36
  37 class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
  38 {
  39 public:
  40     wxBitmapRefData();
  41     virtual ~wxBitmapRefData() { Free(); }
  42
  43     virtual void Free();
  44
  45 public:
  46     int                             m_nNumColors;
  47     wxPalette                       m_vBitmapPalette;
  48     int                             m_nQuality;
  49
  50     // OS2-specific
  51     // ------------
  52
  53     wxDC*                           m_pSelectedInto;
  54
  55     //
  56     // Optional mask for transparent drawing
  57     //
  58     wxMask*                         m_pBitmapMask;
  59 }; // end of CLASS wxBitmapRefData
  60
  61 // ----------------------------------------------------------------------------
  62 // wxBitmap: a mono or colour bitmap
  63 // ----------------------------------------------------------------------------
  64
  65 class WXDLLEXPORT wxBitmap : public wxGDIImage
  66 {
  67 public:
  68     // default ctor creates an invalid bitmap, you must Create() it later
  69     wxBitmap() { Init(); }
  70
  71     // Copy constructors
  72     inline wxBitmap(const wxBitmap& rBitmap)
  73       { Init(); Ref(rBitmap); SetHandle(rBitmap.GetHandle()); }
  74
  75     // Initialize with raw data
  76     wxBitmap( const char bits[]
  77              ,int        nWidth
  78              ,int        nHeight
  79              ,int        nDepth = 1
  80             );
  81
  82     // Initialize with XPM data
  83     wxBitmap(const char** ppData) { CreateFromXpm(ppData); }
  84     wxBitmap(char** ppData) { CreateFromXpm((const char**)ppData); }
  85
  86     // Load a resource
  87     wxBitmap( int             nId
  88              ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
  89             );
  90
  91     // For compatiability with other ports, under OS/2 does same as default ctor
  92     inline wxBitmap( const wxString& WXUNUSED(rFilename)
  93                     ,long            WXUNUSED(lType)
  94                    )
  95     { Init(); }
  96     // New constructor for generalised creation from data
  97     wxBitmap( void* pData
  98              ,long  lType
  99              ,int   nWidth
 100              ,int   nHeight
 101              ,int   nDepth = 1
 102             );
 103
 104     // If depth is omitted, will create a bitmap compatible with the display
 105     wxBitmap( int nWidth, int nHeight, int nDepth = -1 );
 106
 107     wxBitmap( const wxImage& image, int depth = -1 )
 108                          { (void)CreateFromImage(image, depth); }
 109
 110     // we must have this, otherwise icons are silently copied into bitmaps using
 111     // the copy ctor but the resulting bitmap is invalid!
 112     inline wxBitmap(const wxIcon& rIcon)
 113       { Init(); CopyFromIcon(rIcon); }
 114
 115     wxBitmap& operator=(const wxBitmap& rBitmap)
 116     {
 117         if ( m_refData != rBitmap.m_refData )
 118             Ref(rBitmap);
 119         return(*this);
 120     }
 121
 122     wxBitmap& operator=(const wxIcon& rIcon)
 123     {
 124         (void)CopyFromIcon(rIcon);
 125
 126         return(*this);
 127     }
 128
 129     wxBitmap& operator=(const wxCursor& rCursor)
 130     {
 131         (void)CopyFromCursor(rCursor);
 132         return (*this);
 133     }
 134
 135     virtual ~wxBitmap();
 136
 137     wxImage ConvertToImage() const;
 138
 139     // get the given part of bitmap
 140     wxBitmap GetSubBitmap(const wxRect& rRect) const;
 141
 142     // copies the contents and mask of the given (colour) icon to the bitmap
 143     bool CopyFromIcon(const wxIcon& rIcon);
 144
 145     // copies the contents and mask of the given cursor to the bitmap
 146     bool CopyFromCursor(const wxCursor& rCursor);
 147
 148     virtual bool Create( int nWidth
 149                         ,int nHeight
 150                         ,int nDepth = -1
 151                        );
 152     virtual bool Create( void* pData
 153                         ,long  lType
 154                         ,int   nWidth
 155                         ,int   nHeight
 156                         ,int   nDepth = 1
 157                        );
 158     virtual bool LoadFile( int             nId
 159                           ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
 160                          );
 161     virtual bool LoadFile( const wxString& rName
 162                           ,long            lType = wxBITMAP_TYPE_XPM
 163                          );
 164     virtual bool SaveFile( const wxString&  rName
 165                           ,int              lType
 166                           ,const wxPalette* pCmap = NULL
 167                          );
 168
 169     inline wxBitmapRefData* GetBitmapData() const
 170       { return (wxBitmapRefData *)m_refData; }
 171
 172     inline int GetQuality() const
 173       { return (GetBitmapData() ? GetBitmapData()->m_nQuality : 0); }
 174
 175     void SetQuality(int nQ);
 176
 177     wxPalette* GetPalette() const
 178       { return (GetBitmapData() ? (& GetBitmapData()->m_vBitmapPalette) : (wxPalette*) NULL); }
 179
 180     void       SetPalette(const wxPalette& rPalette);
 181
 182     inline wxMask* GetMask() const
 183       { return (GetBitmapData() ? GetBitmapData()->m_pBitmapMask : (wxMask*) NULL); }
 184
 185     void SetMask(wxMask* pMask) ;
 186
 187     inline bool operator==(const wxBitmap& rBitmap) const
 188       { return m_refData == rBitmap.m_refData; }
 189
 190     inline bool operator!=(const wxBitmap& rBitmap) const
 191       { return m_refData != rBitmap.m_refData; }
 192
 193     // Implementation
 194 public:
 195     inline void SetHBITMAP(WXHBITMAP hBmp)
 196       { SetHandle((WXHANDLE)hBmp); }
 197
 198     inline WXHBITMAP GetHBITMAP() const
 199       { return (WXHBITMAP)GetHandle(); }
 200
 201     inline void  SetSelectedInto(wxDC* pDc)
 202       { if (GetBitmapData()) GetBitmapData()->m_pSelectedInto = pDc; }
 203
 204     inline wxDC* GetSelectedInto() const
 205       { return (GetBitmapData() ? GetBitmapData()->m_pSelectedInto : (wxDC*) NULL); }
 206
 207     inline bool IsMono(void) const { return m_bIsMono; }
 208
 209     // An OS/2 version that probably doesn't do anything like the msw version
 210     wxBitmap GetBitmapForDC(wxDC& rDc) const;
 211
 212 protected:
 213     // common part of all ctors
 214     void Init();
 215
 216     inline virtual wxGDIImageRefData* CreateData() const
 217         { return new wxBitmapRefData; }
 218
 219     // creates the bitmap from XPM data, supposed to be called from ctor
 220     bool CreateFromXpm(const char** ppData);
 221     bool CreateFromImage(const wxImage& image, int depth);
 222
 223 private:
 224     bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
 225
 226     bool                            m_bIsMono;
 227     DECLARE_DYNAMIC_CLASS(wxBitmap)
 228 }; // end of CLASS wxBitmap
 229
 230 // ----------------------------------------------------------------------------
 231 // wxMask: a mono bitmap used for drawing bitmaps transparently.
 232 // ----------------------------------------------------------------------------
 233
 234 class WXDLLEXPORT wxMask : public wxObject
 235 {
 236 public:
 237     wxMask();
 238
 239     // Construct a mask from a bitmap and a colour indicating the transparent
 240     // area
 241     wxMask( const wxBitmap& rBitmap
 242            ,const wxColour& rColour
 243           );
 244
 245     // Construct a mask from a bitmap and a palette index indicating the
 246     // transparent area
 247     wxMask( const wxBitmap& rBitmap
 248            ,int             nPaletteIndex
 249           );
 250
 251     // Construct a mask from a mono bitmap (copies the bitmap).
 252     wxMask(const wxBitmap& rBitmap);
 253
 254     // construct a mask from the givne bitmap handle
 255     wxMask(WXHBITMAP hBmp)
 256       { m_hMaskBitmap = hBmp; }
 257
 258     virtual ~wxMask();
 259
 260     bool Create( const wxBitmap& bitmap
 261                 ,const wxColour& rColour
 262                );
 263     bool Create( const wxBitmap& rBitmap
 264                 ,int             nPaletteIndex
 265                );
 266     bool Create(const wxBitmap& rBitmap);
 267
 268     // Implementation
 269     WXHBITMAP GetMaskBitmap() const
 270       { return m_hMaskBitmap; }
 271     void SetMaskBitmap(WXHBITMAP hBmp)
 272       { m_hMaskBitmap = hBmp; }
 273
 274 protected:
 275     WXHBITMAP                       m_hMaskBitmap;
 276     DECLARE_DYNAMIC_CLASS(wxMask)
 277 }; // end of CLASS wxMask
 278
 279 // ----------------------------------------------------------------------------
 280 // wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
 281 // ----------------------------------------------------------------------------
 282
 283 class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
 284 {
 285 public:
 286     inline wxBitmapHandler()
 287       { m_lType = wxBITMAP_TYPE_INVALID; }
 288
 289     inline wxBitmapHandler( const wxString& rName
 290                     ,const wxString& rExt
 291                     ,long            lType
 292                    )
 293                    : wxGDIImageHandler( rName
 294                                        ,rExt
 295                                        ,lType)
 296     {
 297     }
 298
 299     // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
 300     // old class which worked only with bitmaps
 301     virtual bool Create( wxBitmap* pBitmap
 302                         ,void*     pData
 303                         ,long      lFlags
 304                         ,int       nWidth
 305                         ,int       nHeight
 306                         ,int       nDepth = 1
 307                        );
 308     virtual bool LoadFile( wxBitmap*       pBitmap
 309                           ,int             nId
 310                           ,long            lFlags
 311                           ,int             nDesiredWidth
 312                           ,int             nDesiredHeight
 313                          );
 314     virtual bool LoadFile( wxBitmap*       pBitmap
 315                           ,const wxString& rName
 316                           ,long            lFlags
 317                           ,int             nDesiredWidth
 318                           ,int             nDesiredHeight
 319                          );
 320     virtual bool SaveFile( wxBitmap*        pBitmap
 321                           ,const wxString&  rName
 322                           ,int              lType
 323                           ,const wxPalette* pPalette = NULL
 324                          );
 325
 326     virtual bool Create( wxGDIImage* pImage
 327                         ,void*       pData
 328                         ,long        lFlags
 329                         ,int         nWidth
 330                         ,int         nHeight
 331                         ,int         nDepth = 1
 332                        );
 333     virtual bool Load( wxGDIImage*     pImage
 334                       ,int             nId
 335                       ,long            lFlags
 336                       ,int             nDesiredWidth
 337                       ,int             nDesiredHeight
 338                      );
 339     virtual bool Save( wxGDIImage*     pImage
 340                       ,const wxString& rName
 341                       ,int             lType
 342                      );
 343 private:
 344     inline virtual bool Load( wxGDIImage*     WXUNUSED(pImage)
 345                              ,const wxString& WXUNUSED(rName)
 346                              ,HPS             WXUNUSED(hPs)
 347                              ,long            WXUNUSED(lFlags)
 348                              ,int             WXUNUSED(nDesiredWidth)
 349                              ,int             WXUNUSED(nDesiredHeight)
 350                             )
 351     { return false; }
 352     DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
 353 }; // end of CLASS wxBitmapHandler
 354
 355 #endif
 356   // _WX_BITMAP_H_