]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/msw/bitmap.h
Applied patch [ 1586964 ] Getting the PID of the process executed by wxProcess::Open()
[wxWidgets.git] / include / wx / msw / bitmap.h
... / ...
CommitLineData
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#include "wx/msw/gdiimage.h"
16#include "wx/palette.h"
17
18class WXDLLEXPORT wxBitmap;
19class WXDLLEXPORT wxBitmapHandler;
20class WXDLLEXPORT wxBitmapRefData;
21class WXDLLEXPORT wxControl;
22class WXDLLEXPORT wxCursor;
23class WXDLLEXPORT wxDC;
24#if wxUSE_WXDIB
25class WXDLLEXPORT wxDIB;
26#endif
27class WXDLLEXPORT wxIcon;
28class WXDLLEXPORT wxImage;
29class WXDLLEXPORT wxMask;
30class WXDLLEXPORT wxPalette;
31class WXDLLEXPORT wxPixelDataBase;
32
33// ----------------------------------------------------------------------------
34// wxBitmap: a mono or colour bitmap
35// ----------------------------------------------------------------------------
36
37class WXDLLEXPORT wxBitmap : public wxGDIImage
38{
39public:
40 // default ctor creates an invalid bitmap, you must Create() it later
41 wxBitmap() { }
42
43 // Initialize with raw data
44 wxBitmap(const char bits[], int width, int height, int depth = 1);
45
46 // Initialize with XPM data
47 wxBitmap(const char* const* data);
48#if defined(__BORLANDC__) || (defined (__GNUC__) && __GNUC__ < 3)
49 // needed for Borland 5.5
50 wxBitmap(char** data)
51 {
52 *this = wxBitmap(wx_const_cast(const char* const*, data));
53 }
54#endif
55
56 // Load a file or resource
57 wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE);
58
59 // New constructor for generalised creation from data
60 wxBitmap(const void* data, long type, int width, int height, int depth = 1);
61
62 // Create a new, uninitialized bitmap of the given size and depth (if it
63 // is omitted, will create a bitmap compatible with the display)
64 //
65 // NB: this ctor will create a DIB for 24 and 32bpp bitmaps, use ctor
66 // taking a DC argument if you want to force using DDB in this case
67 wxBitmap(int width, int height, int depth = -1);
68
69 // Create a bitmap compatible with the given DC
70 wxBitmap(int width, int height, const wxDC& dc);
71
72#if wxUSE_IMAGE
73 // Convert from wxImage
74 wxBitmap(const wxImage& image, int depth = -1)
75 { (void)CreateFromImage(image, depth); }
76
77 // Create a DDB compatible with the given DC from wxImage
78 wxBitmap(const wxImage& image, const wxDC& dc)
79 { (void)CreateFromImage(image, dc); }
80#endif // wxUSE_IMAGE
81
82 // we must have this, otherwise icons are silently copied into bitmaps using
83 // the copy ctor but the resulting bitmap is invalid!
84 wxBitmap(const wxIcon& icon) { CopyFromIcon(icon); }
85
86 wxBitmap& operator=(const wxIcon& icon)
87 {
88 (void)CopyFromIcon(icon);
89
90 return *this;
91 }
92
93 wxBitmap& operator=(const wxCursor& cursor)
94 {
95 (void)CopyFromCursor(cursor);
96
97 return *this;
98 }
99
100 virtual ~wxBitmap();
101
102#if wxUSE_IMAGE
103 wxImage ConvertToImage() const;
104#endif // wxUSE_IMAGE
105
106 // get the given part of bitmap
107 wxBitmap GetSubBitmap( const wxRect& rect ) const;
108
109 // copies the contents and mask of the given (colour) icon to the bitmap
110 bool CopyFromIcon(const wxIcon& icon);
111
112 // copies the contents and mask of the given cursor to the bitmap
113 bool CopyFromCursor(const wxCursor& cursor);
114
115#if wxUSE_WXDIB
116 // copies from a device independent bitmap
117 bool CopyFromDIB(const wxDIB& dib);
118#endif
119
120 virtual bool Create(int width, int height, int depth = -1);
121 virtual bool Create(int width, int height, const wxDC& dc);
122 virtual bool Create(const void* data, long type, int width, int height, int depth = 1);
123 virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
124 virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
125
126 wxBitmapRefData *GetBitmapData() const
127 { return (wxBitmapRefData *)m_refData; }
128
129 // raw bitmap access support functions
130 void *GetRawData(wxPixelDataBase& data, int bpp);
131 void UngetRawData(wxPixelDataBase& data);
132
133#if wxUSE_PALETTE
134 wxPalette* GetPalette() const;
135 void SetPalette(const wxPalette& palette);
136#endif // wxUSE_PALETTE
137
138 wxMask *GetMask() const;
139 wxBitmap GetMaskBitmap() const;
140 void SetMask(wxMask *mask);
141
142 bool operator==(const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
143 bool operator!=(const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
144
145 // these functions are internal and shouldn't be used, they risk to
146 // disappear in the future
147 bool HasAlpha() const;
148 void UseAlpha();
149
150#if WXWIN_COMPATIBILITY_2_4
151 // these functions do nothing and are only there for backwards
152 // compatibility
153 wxDEPRECATED( int GetQuality() const );
154 wxDEPRECATED( void SetQuality(int quality) );
155#endif // WXWIN_COMPATIBILITY_2_4
156
157 // implementation only from now on
158 // -------------------------------
159
160public:
161 void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
162 WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
163
164#ifdef __WXDEBUG__
165 void SetSelectedInto(wxDC *dc);
166 wxDC *GetSelectedInto() const;
167#endif // __WXDEBUG__
168
169protected:
170 virtual wxGDIImageRefData *CreateData() const;
171 virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
172
173 // creates an uninitialized bitmap, called from Create()s above
174 bool DoCreate(int w, int h, int depth, WXHDC hdc);
175
176#if wxUSE_IMAGE
177 // creates the bitmap from wxImage, supposed to be called from ctor
178 bool CreateFromImage(const wxImage& image, int depth);
179
180 // creates a DDB from wxImage, supposed to be called from ctor
181 bool CreateFromImage(const wxImage& image, const wxDC& dc);
182
183 // common part of the 2 methods above (hdc may be 0)
184 bool CreateFromImage(const wxImage& image, int depth, WXHDC hdc);
185#endif // wxUSE_IMAGE
186
187private:
188 // common part of CopyFromIcon/CopyFromCursor for Win32
189 bool CopyFromIconOrCursor(const wxGDIImage& icon);
190
191
192 DECLARE_DYNAMIC_CLASS(wxBitmap)
193};
194
195// ----------------------------------------------------------------------------
196// wxMask: a mono bitmap used for drawing bitmaps transparently.
197// ----------------------------------------------------------------------------
198
199class WXDLLEXPORT wxMask : public wxObject
200{
201public:
202 wxMask();
203
204 // Construct a mask from a bitmap and a colour indicating the transparent
205 // area
206 wxMask(const wxBitmap& bitmap, const wxColour& colour);
207
208 // Construct a mask from a bitmap and a palette index indicating the
209 // transparent area
210 wxMask(const wxBitmap& bitmap, int paletteIndex);
211
212 // Construct a mask from a mono bitmap (copies the bitmap).
213 wxMask(const wxBitmap& bitmap);
214
215 // construct a mask from the givne bitmap handle
216 wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }
217
218 virtual ~wxMask();
219
220 bool Create(const wxBitmap& bitmap, const wxColour& colour);
221 bool Create(const wxBitmap& bitmap, int paletteIndex);
222 bool Create(const wxBitmap& bitmap);
223
224 // Implementation
225 WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
226 void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
227
228protected:
229 WXHBITMAP m_maskBitmap;
230
231 DECLARE_DYNAMIC_CLASS(wxMask)
232};
233
234// ----------------------------------------------------------------------------
235// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
236// ----------------------------------------------------------------------------
237
238class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
239{
240public:
241 wxBitmapHandler() { }
242 wxBitmapHandler(const wxString& name, const wxString& ext, long type)
243 : wxGDIImageHandler(name, ext, type)
244 {
245 }
246
247 // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
248 // old class which worked only with bitmaps
249 virtual bool Create(wxBitmap *bitmap,
250 const void* data,
251 long flags,
252 int width, int height, int depth = 1);
253 virtual bool LoadFile(wxBitmap *bitmap,
254 const wxString& name,
255 long flags,
256 int desiredWidth, int desiredHeight);
257 virtual bool SaveFile(wxBitmap *bitmap,
258 const wxString& name,
259 int type,
260 const wxPalette *palette = NULL);
261
262 virtual bool Create(wxGDIImage *image,
263 const void* data,
264 long flags,
265 int width, int height, int depth = 1);
266 virtual bool Load(wxGDIImage *image,
267 const wxString& name,
268 long flags,
269 int desiredWidth, int desiredHeight);
270 virtual bool Save(wxGDIImage *image,
271 const wxString& name,
272 int type);
273
274private:
275 DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
276};
277
278#endif
279 // _WX_BITMAP_H_