include/wx/msw/bitmap.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/msw/bitmap.h
   3 // Purpose:     wxBitmap class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   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/msw/gdiimage.h"
  20 #include "wx/gdicmn.h"
  21 #include "wx/palette.h"
  22
  23 class WXDLLEXPORT wxDC;
  24 class WXDLLEXPORT wxControl;
  25 class WXDLLEXPORT wxBitmap;
  26 class WXDLLEXPORT wxBitmapHandler;
  27 class WXDLLEXPORT wxBitmapRefData;
  28 class WXDLLEXPORT wxIcon;
  29 class WXDLLEXPORT wxMask;
  30 class WXDLLEXPORT wxCursor;
  31 class WXDLLEXPORT wxControl;
  32 class WXDLLEXPORT wxImage;
  33 class WXDLLEXPORT wxPalette;
  34
  35 // ----------------------------------------------------------------------------
  36 // wxBitmap: a mono or colour bitmap
  37 // ----------------------------------------------------------------------------
  38
  39 class WXDLLEXPORT wxBitmap : public wxGDIImage
  40 {
  41 public:
  42     // default ctor creates an invalid bitmap, you must Create() it later
  43     wxBitmap() { Init(); }
  44
  45     // Copy constructors
  46     wxBitmap(const wxBitmap& bitmap) { Init(); Ref(bitmap); }
  47
  48     // Initialize with raw data
  49     wxBitmap(const char bits[], int width, int height, int depth = 1);
  50
  51     // Initialize with XPM data
  52     wxBitmap(const char **data) { CreateFromXpm(data); }
  53     wxBitmap(char **data) { CreateFromXpm((const char **)data); }
  54
  55     // Load a file or resource
  56     wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE);
  57
  58     // New constructor for generalised creation from data
  59     wxBitmap(void *data, long type, int width, int height, int depth = 1);
  60
  61     // If depth is omitted, will create a bitmap compatible with the display
  62     wxBitmap(int width, int height, int depth = -1);
  63
  64 #if wxUSE_IMAGE
  65     // Convert from wxImage:
  66     wxBitmap(const wxImage& image, int depth = -1)
  67         { (void)CreateFromImage(image, depth); }
  68 #endif // wxUSE_IMAGE
  69
  70     // we must have this, otherwise icons are silently copied into bitmaps using
  71     // the copy ctor but the resulting bitmap is invalid!
  72     wxBitmap(const wxIcon& icon) { Init(); CopyFromIcon(icon); }
  73
  74     wxBitmap& operator=(const wxBitmap& bitmap)
  75     {
  76         if ( m_refData != bitmap.m_refData )
  77             Ref(bitmap);
  78         return *this;
  79     }
  80
  81     wxBitmap& operator=(const wxIcon& icon)
  82     {
  83         (void)CopyFromIcon(icon);
  84
  85         return *this;
  86     }
  87
  88     wxBitmap& operator=(const wxCursor& cursor)
  89     {
  90         (void)CopyFromCursor(cursor);
  91
  92         return *this;
  93     }
  94
  95     virtual ~wxBitmap();
  96
  97 #if wxUSE_IMAGE
  98     wxImage ConvertToImage() const;
  99 #endif // wxUSE_IMAGE
 100
 101     // get the given part of bitmap
 102     wxBitmap GetSubBitmap( const wxRect& rect ) const;
 103
 104     // copies the contents and mask of the given (colour) icon to the bitmap
 105     bool CopyFromIcon(const wxIcon& icon);
 106
 107     // copies the contents and mask of the given cursor to the bitmap
 108     bool CopyFromCursor(const wxCursor& cursor);
 109
 110     virtual bool Create(int width, int height, int depth = -1);
 111     virtual bool Create(void *data, long type, int width, int height, int depth = 1);
 112     virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
 113     virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
 114
 115     wxBitmapRefData *GetBitmapData() const
 116         { return (wxBitmapRefData *)m_refData; }
 117
 118 #if wxUSE_PALETTE
 119     wxPalette* GetPalette() const;
 120     void SetPalette(const wxPalette& palette);
 121 #endif // wxUSE_PALETTE
 122
 123     wxMask *GetMask() const;
 124     void SetMask(wxMask *mask) ;
 125
 126     bool operator==(const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
 127     bool operator!=(const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
 128
 129 #if wxUSE_DIB_FOR_BITMAP
 130     // returns TRUE if this bitmap is a DIB (otherwise it's a DDB)
 131     bool IsDIB() const;
 132 #endif // wxUSE_DIB_FOR_BITMAP
 133
 134 #if WXWIN_COMPATIBILITY_2_4
 135     // these functions do nothing and are only there for backwards
 136     // compatibility
 137     wxDEPRECATED( int GetQuality() const );
 138     wxDEPRECATED( void SetQuality(int quality) );
 139 #endif // WXWIN_COMPATIBILITY_2_4
 140
 141 #if WXWIN_COMPATIBILITY_2
 142     void SetOk(bool isOk);
 143 #endif // WXWIN_COMPATIBILITY_2
 144
 145 #if wxUSE_PALETTE
 146 #if WXWIN_COMPATIBILITY
 147     wxPalette *GetColourMap() const { return GetPalette(); }
 148     void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
 149 #endif // WXWIN_COMPATIBILITY
 150 #endif // wxUSE_PALETTE
 151
 152     // Implementation
 153 public:
 154     void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
 155     WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
 156
 157     void SetSelectedInto(wxDC *dc);
 158     wxDC *GetSelectedInto() const;
 159
 160     // Creates a bitmap that matches the device context's depth, from an
 161     // arbitray bitmap. At present, the original bitmap must have an associated
 162     // palette. (TODO: use a default palette if no palette exists.) This
 163     // function is necessary for you to Blit an arbitrary bitmap (which may
 164     // have the wrong depth). wxDC::SelectObject will compare the depth of the
 165     // bitmap with the DC's depth, and create a new bitmap if the depths
 166     // differ. Eventually we should perhaps make this a public API function so
 167     // that an app can efficiently produce bitmaps of the correct depth. The
 168     // Windows solution is to use SetDibBits to blit an arbotrary DIB directly
 169     // to a DC, but this is too Windows-specific, hence this solution of
 170     // quietly converting the wxBitmap. Contributed by Frederic Villeneuve
 171     // <frederic.villeneuve@natinst.com>
 172     wxBitmap GetBitmapForDC(wxDC& dc) const;
 173
 174 protected:
 175     // common part of all ctors
 176     void Init();
 177
 178     virtual wxGDIImageRefData *CreateData() const;
 179
 180     // creates the bitmap from XPM data, supposed to be called from ctor
 181     bool CreateFromXpm(const char **bits);
 182
 183 #if wxUSE_IMAGE
 184     // creates the bitmap from wxImage, supposed to be called from ctor
 185     bool CreateFromImage(const wxImage& image, int depth);
 186 #endif // wxUSE_IMAGE
 187
 188 #if wxUSE_DIB_FOR_BITMAP
 189     void *CreateDIB(int width, int height, int depth);
 190
 191     void CopyDIBLine(void* src, void* dest, int count) const;
 192 #endif // wxUSE_DIB_FOR_BITMAP
 193
 194 private:
 195 #ifdef __WIN32__
 196     // common part of CopyFromIcon/CopyFromCursor for Win32
 197     bool CopyFromIconOrCursor(const wxGDIImage& icon);
 198 #endif // __WIN32__
 199
 200     DECLARE_DYNAMIC_CLASS(wxBitmap)
 201 };
 202
 203 // ----------------------------------------------------------------------------
 204 // wxMask: a mono bitmap used for drawing bitmaps transparently.
 205 // ----------------------------------------------------------------------------
 206
 207 class WXDLLEXPORT wxMask : public wxObject
 208 {
 209 public:
 210     wxMask();
 211
 212     // Construct a mask from a bitmap and a colour indicating the transparent
 213     // area
 214     wxMask(const wxBitmap& bitmap, const wxColour& colour);
 215
 216     // Construct a mask from a bitmap and a palette index indicating the
 217     // transparent area
 218     wxMask(const wxBitmap& bitmap, int paletteIndex);
 219
 220     // Construct a mask from a mono bitmap (copies the bitmap).
 221     wxMask(const wxBitmap& bitmap);
 222
 223     // construct a mask from the givne bitmap handle
 224     wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }
 225
 226     virtual ~wxMask();
 227
 228     bool Create(const wxBitmap& bitmap, const wxColour& colour);
 229     bool Create(const wxBitmap& bitmap, int paletteIndex);
 230     bool Create(const wxBitmap& bitmap);
 231
 232     // Implementation
 233     WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
 234     void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
 235
 236 protected:
 237     WXHBITMAP m_maskBitmap;
 238
 239     DECLARE_DYNAMIC_CLASS(wxMask)
 240 };
 241
 242 // ----------------------------------------------------------------------------
 243 // wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
 244 // ----------------------------------------------------------------------------
 245
 246 class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
 247 {
 248 public:
 249     wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; }
 250     wxBitmapHandler(const wxString& name, const wxString& ext, long type)
 251         : wxGDIImageHandler(name, ext, type)
 252     {
 253     }
 254
 255     // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
 256     // old class which worked only with bitmaps
 257     virtual bool Create(wxBitmap *bitmap,
 258                         void *data,
 259                         long flags,
 260                         int width, int height, int depth = 1);
 261     virtual bool LoadFile(wxBitmap *bitmap,
 262                           const wxString& name,
 263                           long flags,
 264                           int desiredWidth, int desiredHeight);
 265     virtual bool SaveFile(wxBitmap *bitmap,
 266                           const wxString& name,
 267                           int type,
 268                           const wxPalette *palette = NULL);
 269
 270     virtual bool Create(wxGDIImage *image,
 271                         void *data,
 272                         long flags,
 273                         int width, int height, int depth = 1);
 274     virtual bool Load(wxGDIImage *image,
 275                       const wxString& name,
 276                       long flags,
 277                       int desiredWidth, int desiredHeight);
 278     virtual bool Save(wxGDIImage *image,
 279                       const wxString& name,
 280                       int type);
 281
 282 private:
 283     DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
 284 };
 285
 286 #endif
 287   // _WX_BITMAP_H_