| 1 | /////////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: wx/bitmap.h |
| 3 | // Purpose: wxBitmap class interface |
| 4 | // Author: Vaclav Slavik |
| 5 | // Modified by: |
| 6 | // Created: 22.04.01 |
| 7 | // RCS-ID: $Id$ |
| 8 | // Copyright: (c) wxWidgets team |
| 9 | // Licence: wxWindows licence |
| 10 | /////////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | #ifndef _WX_BITMAP_H_BASE_ |
| 13 | #define _WX_BITMAP_H_BASE_ |
| 14 | |
| 15 | // ---------------------------------------------------------------------------- |
| 16 | // headers |
| 17 | // ---------------------------------------------------------------------------- |
| 18 | |
| 19 | #include "wx/string.h" |
| 20 | #include "wx/gdicmn.h" // for wxBitmapType |
| 21 | #include "wx/colour.h" |
| 22 | |
| 23 | class WXDLLIMPEXP_FWD_CORE wxBitmap; |
| 24 | class WXDLLIMPEXP_FWD_CORE wxBitmapHandler; |
| 25 | class WXDLLIMPEXP_FWD_CORE wxIcon; |
| 26 | class WXDLLIMPEXP_FWD_CORE wxImage; |
| 27 | class WXDLLIMPEXP_FWD_CORE wxMask; |
| 28 | class WXDLLIMPEXP_FWD_CORE wxPalette; |
| 29 | |
| 30 | // ---------------------------------------------------------------------------- |
| 31 | // wxVariant support |
| 32 | // ---------------------------------------------------------------------------- |
| 33 | |
| 34 | #if wxUSE_VARIANT |
| 35 | #include "wx/variant.h" |
| 36 | DECLARE_VARIANT_OBJECT_EXPORTED(wxBitmap,WXDLLIMPEXP_CORE) |
| 37 | #endif |
| 38 | |
| 39 | // ---------------------------------------------------------------------------- |
| 40 | // wxMask represents the transparent area of the bitmap |
| 41 | // ---------------------------------------------------------------------------- |
| 42 | |
| 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 |
| 49 | bool Create(const wxBitmap& bitmap, const wxColour& colour); |
| 50 | |
| 51 | #if wxUSE_PALETTE |
| 52 | // create the mask from bitmap pixels with the given palette index |
| 53 | bool Create(const wxBitmap& bitmap, int paletteIndex); |
| 54 | #endif // wxUSE_PALETTE |
| 55 | |
| 56 | // create the mask from the given mono bitmap |
| 57 | bool Create(const wxBitmap& bitmap); |
| 58 | |
| 59 | protected: |
| 60 | // this function is called from Create() to free the existing mask data |
| 61 | virtual void FreeData() = 0; |
| 62 | |
| 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 |
| 66 | virtual bool InitFromColour(const wxBitmap& bitmap, |
| 67 | const wxColour& colour) = 0; |
| 68 | virtual bool InitFromMonoBitmap(const wxBitmap& bitmap) = 0; |
| 69 | }; |
| 70 | |
| 71 | #if defined(__WXMGL__) || \ |
| 72 | defined(__WXDFB__) || \ |
| 73 | defined(__WXMAC__) || \ |
| 74 | defined(__WXGTK__) || \ |
| 75 | defined(__WXCOCOA__) || \ |
| 76 | defined(__WXMOTIF__) || \ |
| 77 | defined(__WXX11__) |
| 78 | #define wxUSE_BITMAP_BASE 1 |
| 79 | #else |
| 80 | #define wxUSE_BITMAP_BASE 0 |
| 81 | #endif |
| 82 | |
| 83 | // a more readable way to tell |
| 84 | #define wxBITMAP_SCREEN_DEPTH (-1) |
| 85 | |
| 86 | |
| 87 | // All ports except wxMSW,wxOS2,wxPalmOS use wxBitmapHandler and wxBitmapBase as base class |
| 88 | // for wxBitmapHandler; wxMSW,wxOS2,wxPalmOS use wxGDIImageHandler as base class |
| 89 | // since it allows some code reuse there. |
| 90 | #if wxUSE_BITMAP_BASE |
| 91 | |
| 92 | // ---------------------------------------------------------------------------- |
| 93 | // wxBitmapHandler: class which knows how to create/load/save bitmaps in |
| 94 | // different formats |
| 95 | // ---------------------------------------------------------------------------- |
| 96 | |
| 97 | class WXDLLIMPEXP_CORE wxBitmapHandler : public wxObject |
| 98 | { |
| 99 | public: |
| 100 | wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; } |
| 101 | virtual ~wxBitmapHandler() { } |
| 102 | |
| 103 | // NOTE: the following functions should be pure virtuals, but they aren't |
| 104 | // because otherwise almost all ports would have to implement |
| 105 | // them as "return false"... |
| 106 | |
| 107 | virtual bool Create(wxBitmap *WXUNUSED(bitmap), const void* WXUNUSED(data), |
| 108 | wxBitmapType WXUNUSED(type), int WXUNUSED(width), int WXUNUSED(height), |
| 109 | int WXUNUSED(depth) = 1) |
| 110 | { return false; } |
| 111 | |
| 112 | virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), |
| 113 | wxBitmapType WXUNUSED(type), int WXUNUSED(desiredWidth), |
| 114 | int WXUNUSED(desiredHeight)) |
| 115 | { return false; } |
| 116 | |
| 117 | virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), |
| 118 | wxBitmapType WXUNUSED(type), const wxPalette *WXUNUSED(palette) = NULL) const |
| 119 | { return false; } |
| 120 | |
| 121 | void SetName(const wxString& name) { m_name = name; } |
| 122 | void SetExtension(const wxString& ext) { m_extension = ext; } |
| 123 | void SetType(wxBitmapType type) { m_type = type; } |
| 124 | const wxString& GetName() const { return m_name; } |
| 125 | const wxString& GetExtension() const { return m_extension; } |
| 126 | wxBitmapType GetType() const { return m_type; } |
| 127 | |
| 128 | private: |
| 129 | wxString m_name; |
| 130 | wxString m_extension; |
| 131 | wxBitmapType m_type; |
| 132 | |
| 133 | DECLARE_ABSTRACT_CLASS(wxBitmapHandler) |
| 134 | }; |
| 135 | |
| 136 | |
| 137 | // ---------------------------------------------------------------------------- |
| 138 | // wxBitmap: class which represents platform-dependent bitmap (unlike wxImage) |
| 139 | // ---------------------------------------------------------------------------- |
| 140 | |
| 141 | class WXDLLIMPEXP_CORE wxBitmapBase : public wxGDIObject |
| 142 | { |
| 143 | public: |
| 144 | /* |
| 145 | Derived class must implement these: |
| 146 | |
| 147 | wxBitmap(); |
| 148 | wxBitmap(const wxBitmap& bmp); |
| 149 | wxBitmap(const char bits[], int width, int height, int depth = 1); |
| 150 | wxBitmap(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH); |
| 151 | wxBitmap(const char* const* bits); |
| 152 | wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM); |
| 153 | wxBitmap(const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH); |
| 154 | |
| 155 | static void InitStandardHandlers(); |
| 156 | */ |
| 157 | |
| 158 | virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH) = 0; |
| 159 | |
| 160 | virtual int GetHeight() const = 0; |
| 161 | virtual int GetWidth() const = 0; |
| 162 | virtual int GetDepth() const = 0; |
| 163 | |
| 164 | #if wxUSE_IMAGE |
| 165 | virtual wxImage ConvertToImage() const = 0; |
| 166 | #endif // wxUSE_IMAGE |
| 167 | |
| 168 | virtual wxMask *GetMask() const = 0; |
| 169 | virtual void SetMask(wxMask *mask) = 0; |
| 170 | |
| 171 | virtual wxBitmap GetSubBitmap(const wxRect& rect) const = 0; |
| 172 | |
| 173 | virtual bool SaveFile(const wxString &name, wxBitmapType type, |
| 174 | const wxPalette *palette = (wxPalette *)NULL) const = 0; |
| 175 | virtual bool LoadFile(const wxString &name, wxBitmapType type) = 0; |
| 176 | |
| 177 | /* |
| 178 | If raw bitmap access is supported (see wx/rawbmp.h), the following |
| 179 | methods should be implemented: |
| 180 | |
| 181 | virtual bool GetRawData(wxRawBitmapData *data) = 0; |
| 182 | virtual void UngetRawData(wxRawBitmapData *data) = 0; |
| 183 | */ |
| 184 | |
| 185 | #if wxUSE_PALETTE |
| 186 | virtual wxPalette *GetPalette() const = 0; |
| 187 | virtual void SetPalette(const wxPalette& palette) = 0; |
| 188 | #endif // wxUSE_PALETTE |
| 189 | |
| 190 | // copies the contents and mask of the given (colour) icon to the bitmap |
| 191 | virtual bool CopyFromIcon(const wxIcon& icon) = 0; |
| 192 | |
| 193 | // implementation: |
| 194 | virtual void SetHeight(int height) = 0; |
| 195 | virtual void SetWidth(int width) = 0; |
| 196 | virtual void SetDepth(int depth) = 0; |
| 197 | |
| 198 | // Format handling |
| 199 | static inline wxList& GetHandlers() { return sm_handlers; } |
| 200 | static void AddHandler(wxBitmapHandler *handler); |
| 201 | static void InsertHandler(wxBitmapHandler *handler); |
| 202 | static bool RemoveHandler(const wxString& name); |
| 203 | static wxBitmapHandler *FindHandler(const wxString& name); |
| 204 | static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType); |
| 205 | static wxBitmapHandler *FindHandler(wxBitmapType bitmapType); |
| 206 | |
| 207 | //static void InitStandardHandlers(); |
| 208 | // (wxBitmap must implement this one) |
| 209 | |
| 210 | static void CleanUpHandlers(); |
| 211 | |
| 212 | // this method is only used by the generic implementation of wxMask |
| 213 | // currently but could be useful elsewhere in the future: it can be |
| 214 | // overridden to quantize the colour to correspond to bitmap colour depth |
| 215 | // if necessary; default implementation simply returns the colour as is |
| 216 | virtual wxColour QuantizeColour(const wxColour& colour) const |
| 217 | { |
| 218 | return colour; |
| 219 | } |
| 220 | |
| 221 | protected: |
| 222 | static wxList sm_handlers; |
| 223 | |
| 224 | DECLARE_ABSTRACT_CLASS(wxBitmapBase) |
| 225 | }; |
| 226 | |
| 227 | #endif // wxUSE_BITMAP_BASE |
| 228 | |
| 229 | |
| 230 | // the wxBITMAP_DEFAULT_TYPE constant defines the default argument value |
| 231 | // for wxBitmap's ctor and wxBitmap::LoadFile() functions. |
| 232 | #if defined(__WXPALMOS__) |
| 233 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE |
| 234 | #include "wx/palmos/bitmap.h" |
| 235 | #elif defined(__WXMSW__) |
| 236 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE |
| 237 | #include "wx/msw/bitmap.h" |
| 238 | #elif defined(__WXMOTIF__) |
| 239 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM |
| 240 | #include "wx/x11/bitmap.h" |
| 241 | #elif defined(__WXGTK20__) |
| 242 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM |
| 243 | #include "wx/gtk/bitmap.h" |
| 244 | #elif defined(__WXGTK__) |
| 245 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM |
| 246 | #include "wx/gtk1/bitmap.h" |
| 247 | #elif defined(__WXX11__) |
| 248 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM |
| 249 | #include "wx/x11/bitmap.h" |
| 250 | #elif defined(__WXMGL__) |
| 251 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_RESOURCE |
| 252 | #include "wx/mgl/bitmap.h" |
| 253 | #elif defined(__WXDFB__) |
| 254 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_RESOURCE |
| 255 | #include "wx/dfb/bitmap.h" |
| 256 | #elif defined(__WXMAC__) |
| 257 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_PICT_RESOURCE |
| 258 | #include "wx/osx/bitmap.h" |
| 259 | #elif defined(__WXCOCOA__) |
| 260 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE |
| 261 | #include "wx/cocoa/bitmap.h" |
| 262 | #elif defined(__WXPM__) |
| 263 | #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE |
| 264 | #include "wx/os2/bitmap.h" |
| 265 | #endif |
| 266 | |
| 267 | // we must include generic mask.h after wxBitmap definition |
| 268 | #if defined(__WXMGL__) || defined(__WXDFB__) |
| 269 | #define wxUSE_GENERIC_MASK 1 |
| 270 | #else |
| 271 | #define wxUSE_GENERIC_MASK 0 |
| 272 | #endif |
| 273 | |
| 274 | #if wxUSE_GENERIC_MASK |
| 275 | #include "wx/generic/mask.h" |
| 276 | #endif |
| 277 | |
| 278 | #endif // _WX_BITMAP_H_BASE_ |