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

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

2 // Name: wx/bitmap.h

3 // Purpose: wxBitmap class interface

4 // Author: Vaclav Slavik

5 // Modified by:

6 // Created: 22.04.01

7 // Copyright: (c) wxWidgets team

8 // Licence: wxWindows licence

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

11 #ifndef _WX_BITMAP_H_BASE_

12 #define _WX_BITMAP_H_BASE_

14 // ----------------------------------------------------------------------------

15 // headers

16 // ----------------------------------------------------------------------------

18 #include "wx/string.h"

19 #include "wx/gdicmn.h" // for wxBitmapType

20 #include "wx/colour.h"

21 #include "wx/image.h"

23 class WXDLLIMPEXP_FWD_CORE wxBitmap;

24 class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;

25 class WXDLLIMPEXP_FWD_CORE wxIcon;

26 class WXDLLIMPEXP_FWD_CORE wxMask;

27 class WXDLLIMPEXP_FWD_CORE wxPalette;

28 class WXDLLIMPEXP_FWD_CORE wxDC;

30 // ----------------------------------------------------------------------------

31 // wxVariant support

32 // ----------------------------------------------------------------------------

34 #if wxUSE_VARIANT

35 #include "wx/variant.h"

36 DECLARE_VARIANT_OBJECT_EXPORTED(wxBitmap,WXDLLIMPEXP_CORE)

37 #endif

39 // ----------------------------------------------------------------------------

40 // wxMask represents the transparent area of the bitmap

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

43 // TODO: all implementation of wxMask, except the generic one,

44 // do not derive from wxMaskBase,,, they should

45 class WXDLLIMPEXP_CORE wxMaskBase : public wxObject

46 {

47 public:

48 // create the mask from bitmap pixels of the given colour

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

51 #if wxUSE_PALETTE

52 // create the mask from bitmap pixels with the given palette index

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

54 #endif // wxUSE_PALETTE

56 // create the mask from the given mono bitmap

     bool Create(const wxBitmap& bitmap);

59 protected:

60 // this function is called from Create() to free the existing mask data

     virtual void FreeData() = 0;

63 // these functions must be overridden to implement the corresponding public

64 // Create() methods, they shouldn't call FreeData() as it's already called

65 // by the public wrappers

     virtual bool InitFromColour(const wxBitmap& bitmap,

                                 const wxColour& colour) = 0;

     virtual bool InitFromMonoBitmap(const wxBitmap& bitmap) = 0;

69 };

71 #if defined(__WXDFB__) || \

72 defined(__WXMAC__) || \

73 defined(__WXGTK__) || \

74 defined(__WXCOCOA__) || \

75 defined(__WXMOTIF__) || \

76 defined(__WXX11__)

77 #define wxUSE_BITMAP_BASE 1

78 #else

79 #define wxUSE_BITMAP_BASE 0

80 #endif

82 // a more readable way to tell

83 #define wxBITMAP_SCREEN_DEPTH (-1)

86 // ----------------------------------------------------------------------------

87 // wxBitmapHelpers: container for various bitmap methods common to all ports.

88 // ----------------------------------------------------------------------------

90 // Unfortunately, currently wxBitmap does not inherit from wxBitmapBase on all

91 // platforms and this is not easy to fix. So we extract at least some common

92 // methods into this class from which both wxBitmapBase (and hence wxBitmap on

93 // all platforms where it does inherit from it) and wxBitmap in wxMSW and other

94 // exceptional ports (only wxPM and old wxCocoa) inherit.

95 class WXDLLIMPEXP_CORE wxBitmapHelpers

96 {

97 public:

98 // Create a new wxBitmap from the PNG data in the given buffer.

     static wxBitmap NewFromPNGData(const void* data, size_t size);

100 };

101

102

103 // All ports except wxMSW and wxOS2 use wxBitmapHandler and wxBitmapBase as

104 // base class for wxBitmapHandler; wxMSW and wxOS2 use wxGDIImageHandler as

105 // base class since it allows some code reuse there.

106 #if wxUSE_BITMAP_BASE

107

108 // ----------------------------------------------------------------------------

109 // wxBitmapHandler: class which knows how to create/load/save bitmaps in

110 // different formats

111 // ----------------------------------------------------------------------------

112

113 class WXDLLIMPEXP_CORE wxBitmapHandler : public wxObject

114 {

115 public:

116 wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; }

117 virtual ~wxBitmapHandler() { }

118

119 // NOTE: the following functions should be pure virtuals, but they aren't

120 // because otherwise almost all ports would have to implement

121 // them as "return false"...

122

     virtual bool Create(wxBitmap *WXUNUSED(bitmap), const void* WXUNUSED(data),

                          wxBitmapType WXUNUSED(type), int WXUNUSED(width), int WXUNUSED(height),

                          int WXUNUSED(depth) = 1)

126 { return false; }

127

     virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),

                            wxBitmapType WXUNUSED(type), int WXUNUSED(desiredWidth),

130 int WXUNUSED(desiredHeight))

131 { return false; }

132

     virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),

                            wxBitmapType WXUNUSED(type), const wxPalette *WXUNUSED(palette) = NULL) const

135 { return false; }

136

     void SetName(const wxString& name)      { m_name = name; }

     void SetExtension(const wxString& ext)  { m_extension = ext; }

     void SetType(wxBitmapType type)         { m_type = type; }

     const wxString& GetName() const         { return m_name; }

     const wxString& GetExtension() const    { return m_extension; }

     wxBitmapType GetType() const            { return m_type; }

143

144 private:

145 wxString m_name;

146 wxString m_extension;

147 wxBitmapType m_type;

148

149 DECLARE_ABSTRACT_CLASS(wxBitmapHandler)

150 };

151

152 // ----------------------------------------------------------------------------

153 // wxBitmap: class which represents platform-dependent bitmap (unlike wxImage)

154 // ----------------------------------------------------------------------------

155

156 class WXDLLIMPEXP_CORE wxBitmapBase : public wxGDIObject,

157 public wxBitmapHelpers

158 {

159 public:

160 /*

161 Derived class must implement these:

162

163 wxBitmap();

164 wxBitmap(const wxBitmap& bmp);

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

166 wxBitmap(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);

167 wxBitmap(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH);

168 wxBitmap(const char* const* bits);

169 wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);

170 wxBitmap(const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH);

171

172 static void InitStandardHandlers();

173 */

174

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

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

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

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

179

     virtual int GetHeight() const = 0;

     virtual int GetWidth() const = 0;

     virtual int GetDepth() const = 0;

183

184 wxSize GetSize() const

         { return wxSize(GetWidth(), GetHeight()); }

186

187 // 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(); }

191 virtual wxSize GetScaledSize() const

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

193

194 #if wxUSE_IMAGE

     virtual wxImage ConvertToImage() const = 0;

196

197 // Convert to disabled (dimmed) bitmap.

     wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;

199 #endif // wxUSE_IMAGE

200

     virtual wxMask *GetMask() const = 0;

     virtual void SetMask(wxMask *mask) = 0;

203

     virtual wxBitmap GetSubBitmap(const wxRect& rect) const = 0;

205

     virtual bool SaveFile(const wxString &name, wxBitmapType type,

                           const wxPalette *palette = NULL) const = 0;

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

209

210 /*

211 If raw bitmap access is supported (see wx/rawbmp.h), the following

212 methods should be implemented:

213

214 virtual bool GetRawData(wxRawBitmapData *data) = 0;

215 virtual void UngetRawData(wxRawBitmapData *data) = 0;

216 */

217

218 #if wxUSE_PALETTE

     virtual wxPalette *GetPalette() const = 0;

     virtual void SetPalette(const wxPalette& palette) = 0;

221 #endif // wxUSE_PALETTE

222

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

     virtual bool CopyFromIcon(const wxIcon& icon) = 0;

225

226 // implementation:

     virtual void SetHeight(int height) = 0;

     virtual void SetWidth(int width) = 0;

     virtual void SetDepth(int depth) = 0;

230

231 // Format handling

     static inline wxList& GetHandlers() { return sm_handlers; }

     static void AddHandler(wxBitmapHandler *handler);

     static void InsertHandler(wxBitmapHandler *handler);

     static bool RemoveHandler(const wxString& name);

     static wxBitmapHandler *FindHandler(const wxString& name);

     static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType);

     static wxBitmapHandler *FindHandler(wxBitmapType bitmapType);

239

240 //static void InitStandardHandlers();

241 // (wxBitmap must implement this one)

242

243 static void CleanUpHandlers();

244

245 // this method is only used by the generic implementation of wxMask

246 // currently but could be useful elsewhere in the future: it can be

247 // overridden to quantize the colour to correspond to bitmap colour depth

248 // if necessary; default implementation simply returns the colour as is

     virtual wxColour QuantizeColour(const wxColour& colour) const

250 {

251 return colour;

252 }

253

254 protected:

255 static wxList sm_handlers;

256

257 DECLARE_ABSTRACT_CLASS(wxBitmapBase)

258 };

259

260 #endif // wxUSE_BITMAP_BASE

261

262

263 // the wxBITMAP_DEFAULT_TYPE constant defines the default argument value

264 // for wxBitmap's ctor and wxBitmap::LoadFile() functions.

265 #if defined(__WXMSW__)

266 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE

267 #include "wx/msw/bitmap.h"

268 #elif defined(__WXMOTIF__)

269 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM

270 #include "wx/x11/bitmap.h"

271 #elif defined(__WXGTK20__)

272 #ifdef __WINDOWS__

273 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE

274 #else

275 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM

276 #endif

277 #include "wx/gtk/bitmap.h"

278 #elif defined(__WXGTK__)

279 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM

280 #include "wx/gtk1/bitmap.h"

281 #elif defined(__WXX11__)

282 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM

283 #include "wx/x11/bitmap.h"

284 #elif defined(__WXDFB__)

285 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE

286 #include "wx/dfb/bitmap.h"

287 #elif defined(__WXMAC__)

288 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_PICT_RESOURCE

289 #include "wx/osx/bitmap.h"

290 #elif defined(__WXCOCOA__)

291 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE

292 #include "wx/cocoa/bitmap.h"

293 #elif defined(__WXPM__)

294 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE

295 #include "wx/os2/bitmap.h"

296 #endif

297

298 #if wxUSE_IMAGE

299 inline

300 wxBitmap

301 #if wxUSE_BITMAP_BASE

302 wxBitmapBase::

303 #else

304 wxBitmap::

305 #endif

 ConvertToDisabled(unsigned char brightness) const

307 {

     return ConvertToImage().ConvertToDisabled(brightness);

309 }

310 #endif // wxUSE_IMAGE

311

312 // we must include generic mask.h after wxBitmap definition

313 #if defined(__WXDFB__)

314 #define wxUSE_GENERIC_MASK 1

315 #else

316 #define wxUSE_GENERIC_MASK 0

317 #endif

318

319 #if wxUSE_GENERIC_MASK

320 #include "wx/generic/mask.h"

321 #endif

322

323 #endif // _WX_BITMAP_H_BASE_