include/wx/msw/dib.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/msw/dib.h
   3 // Purpose:     wxDIB class representing Win32 device independent bitmaps
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     03.03.03 (replaces the old file with the same name)
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997-2003 wxWindows team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_MSW_DIB_H_
  13 #define _WX_MSW_DIB_H_
  14
  15 class WXDLLEXPORT wxBitmap;
  16 class WXDLLEXPORT wxPalette;
  17
  18 #include "wx/msw/private.h"
  19
  20 // ----------------------------------------------------------------------------
  21 // wxDIB: represents a DIB section
  22 // ----------------------------------------------------------------------------
  23
  24 class WXDLLEXPORT wxDIB
  25 {
  26 public:
  27     // ctors and such
  28     // --------------
  29
  30     // create an uninitialized DIB with the given width, height and depth (only
  31     // 24 and 32 bpp DIBs are currently supported)
  32     //
  33     // after using this ctor, GetData() and GetHandle() may be used if IsOk()
  34     // returns true
  35     wxDIB(int width, int height, int depth)
  36         { Init(); (void)Create(width, height, depth); }
  37
  38     // create a DIB from the DDB
  39     wxDIB(const wxBitmap& bmp)
  40         { Init(); (void)Create(bmp); }
  41
  42     // load a DIB from file (any depth is supoprted here unlike above)
  43     //
  44     // as above, use IsOk() to see if the bitmap was loaded successfully
  45     wxDIB(const wxString& filename)
  46         { Init(); (void)Load(filename); }
  47
  48     // same as the corresponding ctors but with return value
  49     bool Create(int width, int height, int depth);
  50     bool Create(const wxBitmap& bmp);
  51     bool Load(const wxString& filename);
  52
  53     // dtor is not virtual, this class is not meant to be used polymorphically
  54     ~wxDIB();
  55
  56
  57     // operations
  58     // ----------
  59
  60     // create a bitmap compatiblr with the given HDC (or screen by default) and
  61     // return its handle, the caller is responsible for freeing it (using
  62     // DeleteObject())
  63     HBITMAP CreateDDB(HDC hdc = 0) const;
  64
  65     // get the handle from the DIB and reset it, i.e. this object won't destroy
  66     // the DIB after this (but the caller should do it)
  67     HBITMAP Detach() { HBITMAP hbmp = m_handle; m_handle = 0; return hbmp; }
  68
  69 #if wxUSE_PALETTE
  70     // create a palette for this DIB (always a trivial/default one for 24bpp)
  71     wxPalette *CreatePalette() const;
  72 #endif // wxUSE_PALETTE
  73
  74     // save the DIB as a .BMP file to the file with the given name
  75     bool Save(const wxString& filename);
  76
  77
  78     // accessors
  79     // ---------
  80
  81     // return true if DIB was successfully created, false otherwise
  82     bool IsOk() const { return m_handle != 0; }
  83
  84     // get the bitmap size
  85     wxSize GetSize() const { DoGetObject(); return wxSize(m_width, m_height); }
  86     int GetWidth() const { DoGetObject(); return m_width; }
  87     int GetHeight() const { DoGetObject(); return m_height; }
  88
  89     // get the number of bits per pixel, or depth
  90     int GetDepth() const { DoGetObject(); return m_depth; }
  91
  92     // get the DIB handle
  93     HBITMAP GetHandle() const { return m_handle; }
  94
  95     // get raw pointer to bitmap bits, you should know what you do if you
  96     // decide to use it
  97     void *GetData() const { DoGetObject(); return m_data; }
  98
  99
 100     // HBITMAP conversion
 101     // ------------------
 102
 103     // these functions are only used by wxWindows internally right now, please
 104     // don't use them directly if possible as they're subject to change
 105
 106     // creates a DDB compatible with the given (or screen) DC from either
 107     // a plain DIB or a DIB section (in which case the last parameter must be
 108     // non NULL)
 109     static HBITMAP ConvertToBitmap(const BITMAPINFO *pbi,
 110                                    HDC hdc = 0,
 111                                    void *bits = NULL);
 112
 113     // create a plain DIB (not a DIB section) from a DDB, the caller is
 114     // responsable for freeing it using ::GlobalFree()
 115     static HGLOBAL ConvertFromBitmap(HBITMAP hbmp);
 116
 117     // creates a DIB from the given DDB or calculates the space needed by it:
 118     // if pbi is NULL, only the space is calculated, otherwise pbi is supposed
 119     // to point at BITMAPINFO of the correct size which is filled by this
 120     // function (this overload is needed for wxBitmapDataObject code in
 121     // src/msw/ole/dataobj.cpp)
 122     static size_t ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp);
 123
 124
 125     // wxImage conversion
 126     // ------------------
 127
 128 #if wxUSE_IMAGE
 129     // create a DIB from the given image, the DIB will be either 24 or 32 (if
 130     // the image has alpha channel) bpp
 131     wxDIB(const wxImage& image) { Init(); (void)Create(image); }
 132
 133     // same as the above ctor but with the return code
 134     bool Create(const wxImage& image);
 135
 136     // create wxImage having the same data as this DIB
 137     wxImage ConvertToImage() const;
 138 #endif // wxUSE_IMAGE
 139
 140
 141     // helper functions
 142     // ----------------
 143
 144     // return the size of one line in a DIB with given width and depth: the
 145     // point here is that as the scan lines need to be DWORD aligned so we may
 146     // need to add some padding
 147     static unsigned long GetLineSize(int width, int depth)
 148     {
 149         return ((width*depth + 31) & ~31) >> 3;
 150     }
 151
 152 private:
 153     // common part of all ctors
 154     void Init()
 155     {
 156         m_handle = 0;
 157
 158         m_data = NULL;
 159
 160         m_width =
 161         m_height =
 162         m_depth = 0;
 163     }
 164
 165     // free resources
 166     void Free()
 167     {
 168         if ( m_handle )
 169         {
 170             if ( !::DeleteObject(m_handle) )
 171             {
 172                 wxLogLastError(wxT("DeleteObject(hDIB)"));
 173             }
 174
 175             Init();
 176         }
 177     }
 178
 179     // the DIB section handle, 0 if invalid
 180     HBITMAP m_handle;
 181
 182     // NB: we could store only m_handle and not any of the other fields as
 183     //     we may always retrieve them from it using ::GetObject(), but we
 184     //     decide to still store them for efficiency concerns -- however if we
 185     //     don't have them from the very beginning (e.g. DIB constructed from a
 186     //     bitmap), we only retrieve them when necessary and so these fields
 187     //     should *never* be accessed directly, even from inside wxDIB code
 188
 189     // function which must be called before accessing any members and which
 190     // gets their values from m_handle, if not done yet
 191     void DoGetObject() const;
 192
 193     // pointer to DIB bits, may be NULL
 194     void *m_data;
 195
 196     // size and depth of the image
 197     int m_width,
 198         m_height,
 199         m_depth;
 200
 201
 202     // DIBs can't be copied
 203     wxDIB(const wxDIB&);
 204     wxDIB& operator=(const wxDIB&);
 205 };
 206
 207 // ----------------------------------------------------------------------------
 208 // inline functions implementation
 209 // ----------------------------------------------------------------------------
 210
 211 inline wxDIB::~wxDIB()
 212 {
 213     Free();
 214 }
 215
 216 #endif // _WX_MSW_DIB_H_
 217