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