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