git.saurik.com Git - wxWidgets.git/blob

1 /////////////////////////////////////////////////////////////////////////////

2 // Name: wx/msw/bitmap.h

3 // Purpose: wxBitmap class

4 // Author: Julian Smart

5 // Modified by:

6 // Created: 01/02/97

7 // Copyright: (c) Julian Smart

8 // Licence: wxWindows licence

9 /////////////////////////////////////////////////////////////////////////////

11 #ifndef _WX_BITMAP_H_

12 #define _WX_BITMAP_H_

14 #include "wx/msw/gdiimage.h"

15 #include "wx/math.h"

16 #include "wx/palette.h"

18 class WXDLLIMPEXP_FWD_CORE wxBitmap;

19 class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;

20 class WXDLLIMPEXP_FWD_CORE wxBitmapRefData;

21 class WXDLLIMPEXP_FWD_CORE wxControl;

22 class WXDLLIMPEXP_FWD_CORE wxCursor;

23 class WXDLLIMPEXP_FWD_CORE wxDC;

24 #if wxUSE_WXDIB

25 class WXDLLIMPEXP_FWD_CORE wxDIB;

26 #endif

27 class WXDLLIMPEXP_FWD_CORE wxIcon;

28 class WXDLLIMPEXP_FWD_CORE wxMask;

29 class WXDLLIMPEXP_FWD_CORE wxPalette;

30 class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;

32 // What kind of transparency should a bitmap copied from an icon or cursor

33 // have?

34 enum wxBitmapTransparency

35 {

36 wxBitmapTransparency_Auto, // default: copy alpha if the source has it

37 wxBitmapTransparency_None, // never create alpha

38 wxBitmapTransparency_Always // always use alpha

39 };

41 // ----------------------------------------------------------------------------

42 // wxBitmap: a mono or colour bitmap

43 // NOTE: for wxMSW we don't use the wxBitmapBase base class declared in bitmap.h!

44 // ----------------------------------------------------------------------------

46 class WXDLLIMPEXP_CORE wxBitmap : public wxGDIImage,

47 public wxBitmapHelpers

48 {

49 public:

50 // default ctor creates an invalid bitmap, you must Create() it later

51 wxBitmap() { }

53 // Initialize with raw data

     wxBitmap(const char bits[], int width, int height, int depth = 1);

56 // Initialize with XPM data

     wxBitmap(const char* const* data);

58 #ifdef wxNEEDS_CHARPP

     wxBitmap(char** data)

60 {

         *this = wxBitmap(const_cast<const char* const*>(data));

62 }

63 #endif

65 // Load a file or resource

     wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);

68 // New constructor for generalised creation from data

     wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);

71 // Create a new, uninitialized bitmap of the given size and depth (if it

72 // is omitted, will create a bitmap compatible with the display)

73 //

74 // NB: this ctor will create a DIB for 24 and 32bpp bitmaps, use ctor

75 // taking a DC argument if you want to force using DDB in this case

     wxBitmap(int width, int height, int depth = -1) { (void)Create(width, height, depth); }

     wxBitmap(const wxSize& sz, int depth = -1) { (void)Create(sz, depth); }

79 // Create a bitmap compatible with the given DC

     wxBitmap(int width, int height, const wxDC& dc);

82 #if wxUSE_IMAGE

83 // Convert from wxImage

     wxBitmap(const wxImage& image, int depth = -1)

         { (void)CreateFromImage(image, depth); }

87 // Create a DDB compatible with the given DC from wxImage

     wxBitmap(const wxImage& image, const wxDC& dc)

         { (void)CreateFromImage(image, dc); }

90 #endif // wxUSE_IMAGE

92 // we must have this, otherwise icons are silently copied into bitmaps using

93 // the copy ctor but the resulting bitmap is invalid!

     wxBitmap(const wxIcon& icon,

95 wxBitmapTransparency transp = wxBitmapTransparency_Auto)

96 {

97 CopyFromIcon(icon, transp);

98 }

     wxBitmap& operator=(const wxIcon& icon)

101 {

         (void)CopyFromIcon(icon);

103

104 return *this;

105 }

106

     wxBitmap& operator=(const wxCursor& cursor)

108 {

         (void)CopyFromCursor(cursor);

110

111 return *this;

112 }

113

114 virtual ~wxBitmap();

115

116 #if wxUSE_IMAGE

117 wxImage ConvertToImage() const;

     wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;

119 #endif // wxUSE_IMAGE

120

121 // get the given part of bitmap

     wxBitmap GetSubBitmap( const wxRect& rect ) const;

123

124 // NB: This should not be called from user code. It is for wx internal

125 // use only.

     wxBitmap GetSubBitmapOfHDC( const wxRect& rect, WXHDC hdc ) const;

127

128 // copies the contents and mask of the given (colour) icon to the bitmap

     bool CopyFromIcon(const wxIcon& icon,

130 wxBitmapTransparency transp = wxBitmapTransparency_Auto);

131

132 // copies the contents and mask of the given cursor to the bitmap

     bool CopyFromCursor(const wxCursor& cursor,

134 wxBitmapTransparency transp = wxBitmapTransparency_Auto);

135

136 #if wxUSE_WXDIB

137 // copies from a device independent bitmap

     bool CopyFromDIB(const wxDIB& dib);

139 #endif

140

     virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);

     virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH)

         { return Create(sz.GetWidth(), sz.GetHeight(), depth); }

144

     virtual bool Create(int width, int height, const wxDC& dc);

     virtual bool Create(const void* data, wxBitmapType type, int width, int height, int depth = 1);

     virtual bool CreateScaled(int w, int h, int d, double logicalScale)

         { return Create(wxRound(w*logicalScale), wxRound(h*logicalScale), d); }

149

     virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);

     virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const;

152

153 wxBitmapRefData *GetBitmapData() const

         { return (wxBitmapRefData *)m_refData; }

155

156 // raw bitmap access support functions

     void *GetRawData(wxPixelDataBase& data, int bpp);

     void UngetRawData(wxPixelDataBase& data);

159

160 #if wxUSE_PALETTE

     wxPalette* GetPalette() const;

     void SetPalette(const wxPalette& palette);

163 #endif // wxUSE_PALETTE

164

     wxMask *GetMask() const;

     void SetMask(wxMask *mask);

167

168 // these functions are internal and shouldn't be used, they risk to

169 // disappear in the future

     bool HasAlpha() const;

171 void UseAlpha();

172

173 // support for scaled bitmaps

     virtual double GetScaleFactor() const { return 1.0; }

     virtual double GetScaledWidth() const { return GetWidth() / GetScaleFactor(); }

     virtual double GetScaledHeight() const { return GetHeight() / GetScaleFactor(); }

177 virtual wxSize GetScaledSize() const

         { return wxSize(wxRound(GetScaledWidth()), wxRound(GetScaledHeight())); }

179

180 // implementation only from now on

181 // -------------------------------

182

183 public:

     void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }

     WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }

186

     void SetSelectedInto(wxDC *dc);

     wxDC *GetSelectedInto() const;

189

190 protected:

     virtual wxGDIImageRefData *CreateData() const;

     virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;

193

194 // creates an uninitialized bitmap, called from Create()s above

     bool DoCreate(int w, int h, int depth, WXHDC hdc);

196

197 #if wxUSE_IMAGE

198 // creates the bitmap from wxImage, supposed to be called from ctor

     bool CreateFromImage(const wxImage& image, int depth);

200

201 // creates a DDB from wxImage, supposed to be called from ctor

     bool CreateFromImage(const wxImage& image, const wxDC& dc);

203

204 // common part of the 2 methods above (hdc may be 0)

     bool CreateFromImage(const wxImage& image, int depth, WXHDC hdc);

206 #endif // wxUSE_IMAGE

207

208 private:

209 // common part of CopyFromIcon/CopyFromCursor for Win32

210 bool

     CopyFromIconOrCursor(const wxGDIImage& icon,

212 wxBitmapTransparency transp = wxBitmapTransparency_Auto);

213

214

215 DECLARE_DYNAMIC_CLASS(wxBitmap)

216 };

217

218 // ----------------------------------------------------------------------------

219 // wxMask: a mono bitmap used for drawing bitmaps transparently.

220 // ----------------------------------------------------------------------------

221

222 class WXDLLIMPEXP_CORE wxMask : public wxObject

223 {

224 public:

225 wxMask();

226

227 // Copy constructor

     wxMask(const wxMask &mask);

229

230 // Construct a mask from a bitmap and a colour indicating the transparent

231 // area

     wxMask(const wxBitmap& bitmap, const wxColour& colour);

233

234 // Construct a mask from a bitmap and a palette index indicating the

235 // transparent area

     wxMask(const wxBitmap& bitmap, int paletteIndex);

237

238 // Construct a mask from a mono bitmap (copies the bitmap).

     wxMask(const wxBitmap& bitmap);

240

241 // construct a mask from the givne bitmap handle

     wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }

243

244 virtual ~wxMask();

245

     bool Create(const wxBitmap& bitmap, const wxColour& colour);

     bool Create(const wxBitmap& bitmap, int paletteIndex);

     bool Create(const wxBitmap& bitmap);

249

250 wxBitmap GetBitmap() const;

251

252 // Implementation

     WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }

     void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }

255

256 protected:

257 WXHBITMAP m_maskBitmap;

258

259 DECLARE_DYNAMIC_CLASS(wxMask)

260 };

261

262

263 // ----------------------------------------------------------------------------

264 // wxBitmapHandler is a class which knows how to load/save bitmaps to/from file

265 // NOTE: for wxMSW we don't use the wxBitmapHandler class declared in bitmap.h!

266 // ----------------------------------------------------------------------------

267

268 class WXDLLIMPEXP_CORE wxBitmapHandler : public wxGDIImageHandler

269 {

270 public:

271 wxBitmapHandler() { }

     wxBitmapHandler(const wxString& name, const wxString& ext, wxBitmapType type)

         : wxGDIImageHandler(name, ext, type) { }

274

275 // implement wxGDIImageHandler's pure virtuals:

276

     virtual bool Create(wxGDIImage *image,

278 const void* data,

279 wxBitmapType type,

                         int width, int height, int depth = 1);

     virtual bool Load(wxGDIImage *image,

282 const wxString& name,

283 wxBitmapType type,

284 int desiredWidth, int desiredHeight);

     virtual bool Save(const wxGDIImage *image,

286 const wxString& name,

287 wxBitmapType type) const;

288

289

290 // make wxBitmapHandler compatible with the wxBitmapHandler interface

291 // declared in bitmap.h, even if it's derived from wxGDIImageHandler:

292

     virtual bool Create(wxBitmap *bitmap,

294 const void* data,

295 wxBitmapType type,

                         int width, int height, int depth = 1);

     virtual bool LoadFile(wxBitmap *bitmap,

298 const wxString& name,

299 wxBitmapType type,

300 int desiredWidth, int desiredHeight);

     virtual bool SaveFile(const wxBitmap *bitmap,

302 const wxString& name,

303 wxBitmapType type,

                           const wxPalette *palette = NULL) const;

305

306 private:

307 DECLARE_DYNAMIC_CLASS(wxBitmapHandler)

308 };

309

310 #endif

311 // _WX_BITMAP_H_