]>
Commit | Line | Data |
---|---|---|
7bf85405 RD |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: gdi.i | |
3 | // Purpose: SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc. | |
4 | // | |
5 | // Author: Robin Dunn | |
6 | // | |
7 | // Created: 7/7/97 | |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) 1998 by Total Control Software | |
10 | // Licence: wxWindows license | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | ||
03e9bead RD |
14 | %module gdi |
15 | ||
16 | %{ | |
7bf85405 | 17 | #include "helpers.h" |
af309447 | 18 | #include <wx/imaglist.h> |
6d8b4f8d RD |
19 | #include <wx/fontmap.h> |
20 | #include <wx/fontenc.h> | |
21 | #include <wx/fontmap.h> | |
22 | #include <wx/fontutil.h> | |
7bf85405 RD |
23 | %} |
24 | ||
25 | //---------------------------------------------------------------------- | |
26 | ||
27 | %include typemaps.i | |
28 | %include my_typemaps.i | |
29 | ||
30 | // Import some definitions of other classes, etc. | |
31 | %import _defs.i | |
32 | %import misc.i | |
33 | ||
b68dc582 | 34 | |
7bf85405 RD |
35 | //--------------------------------------------------------------------------- |
36 | ||
9416aa89 RD |
37 | class wxGDIObject : public wxObject { |
38 | public: | |
39 | wxGDIObject(); | |
40 | ~wxGDIObject(); | |
41 | ||
42 | bool GetVisible(); | |
43 | void SetVisible( bool visible ); | |
44 | ||
45 | bool IsNull(); | |
46 | ||
47 | }; | |
6999b0d8 RD |
48 | |
49 | //--------------------------------------------------------------------------- | |
50 | ||
9416aa89 | 51 | class wxBitmap : public wxGDIObject |
5bff6bb8 | 52 | { |
7bf85405 | 53 | public: |
e6056257 | 54 | wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP); |
7bf85405 RD |
55 | ~wxBitmap(); |
56 | ||
7bf85405 RD |
57 | wxPalette* GetPalette(); |
58 | wxMask* GetMask(); | |
e6056257 RD |
59 | bool LoadFile(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP); |
60 | bool SaveFile(const wxString& name, wxBitmapType type, wxPalette* palette = NULL); | |
7bf85405 | 61 | void SetMask(wxMask* mask); |
fb5e0af0 | 62 | #ifdef __WXMSW__ |
b8b8dda7 | 63 | void SetPalette(wxPalette& palette); |
fb5e0af0 | 64 | #endif |
5bff6bb8 RD |
65 | |
66 | // wxGDIImage methods | |
67 | #ifdef __WXMSW__ | |
68 | long GetHandle(); | |
69 | void SetHandle(long handle); | |
70 | #endif | |
71 | bool Ok(); | |
72 | int GetWidth(); | |
73 | int GetHeight(); | |
74 | int GetDepth(); | |
75 | void SetWidth(int w); | |
76 | void SetHeight(int h); | |
77 | void SetDepth(int d); | |
78 | #ifdef __WXMSW__ | |
79 | void SetSize(const wxSize& size); | |
80 | #endif | |
f6bcfd97 BP |
81 | |
82 | wxBitmap GetSubBitmap( const wxRect& rect ); | |
f6bcfd97 | 83 | bool CopyFromIcon(const wxIcon& icon); |
ecc08ead | 84 | #ifdef __WXMSW__ |
f6bcfd97 BP |
85 | bool CopyFromCursor(const wxCursor& cursor); |
86 | int GetQuality(); | |
87 | void SetQuality(int q); | |
88 | #endif | |
89 | ||
90 | %pragma(python) addtoclass = " | |
91 | def __del__(self,gdic=gdic): | |
92 | try: | |
93 | if self.thisown == 1 : | |
94 | gdic.delete_wxBitmap(self) | |
95 | except: | |
96 | pass | |
97 | " | |
7bf85405 RD |
98 | }; |
99 | ||
5bff6bb8 | 100 | |
96bfd053 | 101 | // Declarations of some alternate "constructors" |
7bf85405 | 102 | %new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1); |
96bfd053 RD |
103 | %new wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings); |
104 | %new wxBitmap* wxBitmapFromIcon(const wxIcon& icon); | |
d56cebe7 | 105 | %new wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 ); |
9c039d08 | 106 | |
d56cebe7 RD |
107 | // #ifdef __WXMSW__ |
108 | // %new wxBitmap* wxBitmapFromData(PyObject* data, long type, | |
109 | // int width, int height, int depth = 1); | |
110 | // #endif | |
8bf5d46e | 111 | |
96bfd053 RD |
112 | |
113 | ||
114 | %{ // Implementations of some alternate "constructors" | |
115 | ||
7bf85405 RD |
116 | wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) { |
117 | return new wxBitmap(width, height, depth); | |
118 | } | |
119 | ||
96bfd053 RD |
120 | static char** ConvertListOfStrings(PyObject* listOfStrings) { |
121 | char** cArray = NULL; | |
122 | int count; | |
123 | ||
124 | if (!PyList_Check(listOfStrings)) { | |
125 | PyErr_SetString(PyExc_TypeError, "Expected a list of strings."); | |
126 | return NULL; | |
127 | } | |
128 | count = PyList_Size(listOfStrings); | |
129 | cArray = new char*[count]; | |
130 | ||
131 | for(int x=0; x<count; x++) { | |
132 | // TODO: Need some validation and error checking here | |
133 | cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x)); | |
134 | } | |
135 | return cArray; | |
136 | } | |
137 | ||
d56cebe7 | 138 | |
96bfd053 RD |
139 | wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings) { |
140 | char** cArray = NULL; | |
141 | wxBitmap* bmp; | |
142 | ||
143 | cArray = ConvertListOfStrings(listOfStrings); | |
144 | if (! cArray) | |
145 | return NULL; | |
146 | bmp = new wxBitmap(cArray); | |
147 | delete [] cArray; | |
148 | return bmp; | |
149 | } | |
150 | ||
151 | ||
152 | wxBitmap* wxBitmapFromIcon(const wxIcon& icon) { | |
153 | return new wxBitmap(icon); | |
154 | } | |
155 | ||
156 | ||
d56cebe7 RD |
157 | wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 ) { |
158 | return new wxBitmap(bits, width, height, depth); | |
159 | } | |
926bb76c | 160 | |
4c9993c3 | 161 | |
d56cebe7 RD |
162 | // #ifdef __WXMSW__ |
163 | // wxBitmap* wxBitmapFromData(PyObject* data, long type, | |
164 | // int width, int height, int depth = 1) { | |
165 | // if (! PyString_Check(data)) { | |
166 | // PyErr_SetString(PyExc_TypeError, "Expected string object"); | |
167 | // return NULL; | |
168 | // } | |
169 | // return new wxBitmap((void*)PyString_AsString(data), type, width, height, depth); | |
170 | // } | |
171 | // #endif | |
7bf85405 RD |
172 | %} |
173 | ||
174 | //--------------------------------------------------------------------------- | |
175 | ||
9416aa89 | 176 | class wxMask : public wxObject { |
7bf85405 RD |
177 | public: |
178 | wxMask(const wxBitmap& bitmap); | |
eb715945 | 179 | //~wxMask(); |
96bfd053 RD |
180 | |
181 | %addmethods { void Destroy() { delete self; } } | |
7bf85405 RD |
182 | }; |
183 | ||
184 | %new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour); | |
185 | %{ | |
186 | wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) { | |
187 | return new wxMask(bitmap, colour); | |
188 | } | |
189 | %} | |
190 | ||
191 | ||
192 | //--------------------------------------------------------------------------- | |
193 | ||
194 | ||
9416aa89 | 195 | class wxIcon : public wxGDIObject |
5bff6bb8 | 196 | { |
7bf85405 | 197 | public: |
fb5e0af0 RD |
198 | wxIcon(const wxString& name, long flags, |
199 | int desiredWidth = -1, int desiredHeight = -1); | |
7bf85405 RD |
200 | ~wxIcon(); |
201 | ||
6abe8375 | 202 | #ifndef __WXMAC__ |
7bf85405 | 203 | bool LoadFile(const wxString& name, long flags); |
6abe8375 | 204 | #endif |
5bff6bb8 RD |
205 | |
206 | // wxGDIImage methods | |
207 | #ifdef __WXMSW__ | |
208 | long GetHandle(); | |
209 | void SetHandle(long handle); | |
210 | #endif | |
211 | bool Ok(); | |
212 | int GetWidth(); | |
213 | int GetHeight(); | |
214 | int GetDepth(); | |
215 | void SetWidth(int w); | |
216 | void SetHeight(int h); | |
217 | void SetDepth(int d); | |
218 | #ifdef __WXMSW__ | |
219 | void SetSize(const wxSize& size); | |
220 | #endif | |
96bfd053 RD |
221 | void CopyFromBitmap(const wxBitmap& bmp); |
222 | ||
f6bcfd97 BP |
223 | %pragma(python) addtoclass = " |
224 | def __del__(self,gdic=gdic): | |
225 | try: | |
226 | if self.thisown == 1 : | |
227 | gdic.delete_wxIcon(self) | |
228 | except: | |
229 | pass | |
230 | " | |
7bf85405 RD |
231 | }; |
232 | ||
8bf5d46e | 233 | |
96bfd053 RD |
234 | // Declarations of some alternate "constructors" |
235 | %new wxIcon* wxEmptyIcon(); | |
236 | %new wxIcon* wxIconFromXPMData(PyObject* listOfStrings); | |
237 | ||
238 | %{ // Implementations of some alternate "constructors" | |
239 | wxIcon* wxEmptyIcon() { | |
240 | return new wxIcon(); | |
241 | } | |
242 | ||
243 | wxIcon* wxIconFromXPMData(PyObject* listOfStrings) { | |
244 | char** cArray = NULL; | |
245 | wxIcon* icon; | |
246 | ||
247 | cArray = ConvertListOfStrings(listOfStrings); | |
248 | if (! cArray) | |
249 | return NULL; | |
250 | icon = new wxIcon(cArray); | |
251 | delete [] cArray; | |
252 | return icon; | |
253 | } | |
254 | %} | |
255 | ||
7bf85405 RD |
256 | //--------------------------------------------------------------------------- |
257 | ||
9416aa89 | 258 | class wxCursor : public wxGDIObject |
5bff6bb8 | 259 | { |
7bf85405 | 260 | public: |
fb5e0af0 | 261 | #ifdef __WXMSW__ |
7bf85405 | 262 | wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0); |
fb5e0af0 | 263 | #endif |
7bf85405 | 264 | ~wxCursor(); |
5bff6bb8 RD |
265 | |
266 | // wxGDIImage methods | |
267 | #ifdef __WXMSW__ | |
268 | long GetHandle(); | |
269 | void SetHandle(long handle); | |
270 | #endif | |
271 | bool Ok(); | |
272 | #ifdef __WXMSW__ | |
273 | int GetWidth(); | |
274 | int GetHeight(); | |
275 | int GetDepth(); | |
276 | void SetWidth(int w); | |
277 | void SetHeight(int h); | |
278 | void SetDepth(int d); | |
279 | void SetSize(const wxSize& size); | |
280 | #endif | |
7bf85405 RD |
281 | }; |
282 | ||
9c039d08 | 283 | %name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id); |
7bf85405 | 284 | %{ // Alternate 'constructor' |
9c039d08 | 285 | wxCursor* wxPyStockCursor(int id) { |
7bf85405 RD |
286 | return new wxCursor(id); |
287 | } | |
288 | %} | |
289 | ||
290 | //---------------------------------------------------------------------- | |
291 | ||
f0261a72 | 292 | |
6d8b4f8d RD |
293 | enum wxFontFamily |
294 | { | |
295 | wxFONTFAMILY_DEFAULT = wxDEFAULT, | |
296 | wxFONTFAMILY_DECORATIVE = wxDECORATIVE, | |
297 | wxFONTFAMILY_ROMAN = wxROMAN, | |
298 | wxFONTFAMILY_SCRIPT = wxSCRIPT, | |
299 | wxFONTFAMILY_SWISS = wxSWISS, | |
300 | wxFONTFAMILY_MODERN = wxMODERN, | |
301 | wxFONTFAMILY_TELETYPE = wxTELETYPE, | |
ce914f73 RD |
302 | wxFONTFAMILY_MAX, |
303 | wxFONTFAMILY_UNKNOWN | |
6d8b4f8d RD |
304 | }; |
305 | ||
306 | // font styles | |
307 | enum wxFontStyle | |
308 | { | |
309 | wxFONTSTYLE_NORMAL = wxNORMAL, | |
310 | wxFONTSTYLE_ITALIC = wxITALIC, | |
311 | wxFONTSTYLE_SLANT = wxSLANT, | |
312 | wxFONTSTYLE_MAX | |
313 | }; | |
314 | ||
315 | // font weights | |
316 | enum wxFontWeight | |
317 | { | |
318 | wxFONTWEIGHT_NORMAL = wxNORMAL, | |
319 | wxFONTWEIGHT_LIGHT = wxLIGHT, | |
320 | wxFONTWEIGHT_BOLD = wxBOLD, | |
321 | wxFONTWEIGHT_MAX | |
322 | }; | |
323 | ||
324 | ||
325 | // font encodings | |
f0261a72 RD |
326 | enum wxFontEncoding |
327 | { | |
328 | wxFONTENCODING_SYSTEM = -1, // system default | |
329 | wxFONTENCODING_DEFAULT, // current default encoding | |
330 | ||
331 | // ISO8859 standard defines a number of single-byte charsets | |
332 | wxFONTENCODING_ISO8859_1, // West European (Latin1) | |
333 | wxFONTENCODING_ISO8859_2, // Central and East European (Latin2) | |
334 | wxFONTENCODING_ISO8859_3, // Esperanto (Latin3) | |
6d8b4f8d | 335 | wxFONTENCODING_ISO8859_4, // Baltic (old) (Latin4) |
f0261a72 RD |
336 | wxFONTENCODING_ISO8859_5, // Cyrillic |
337 | wxFONTENCODING_ISO8859_6, // Arabic | |
338 | wxFONTENCODING_ISO8859_7, // Greek | |
339 | wxFONTENCODING_ISO8859_8, // Hebrew | |
340 | wxFONTENCODING_ISO8859_9, // Turkish (Latin5) | |
341 | wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6) | |
342 | wxFONTENCODING_ISO8859_11, // Thai | |
343 | wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it | |
344 | // here anyhow to make all ISO8859 | |
345 | // consecutive numbers | |
6d8b4f8d | 346 | wxFONTENCODING_ISO8859_13, // Baltic (Latin7) |
f0261a72 RD |
347 | wxFONTENCODING_ISO8859_14, // Latin8 |
348 | wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro) | |
6d8b4f8d | 349 | wxFONTENCODING_ISO8859_MAX, |
f0261a72 RD |
350 | |
351 | // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html) | |
352 | wxFONTENCODING_KOI8, // we don't support any of KOI8 variants | |
353 | wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866 | |
354 | wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria | |
355 | ||
356 | // what would we do without Microsoft? They have their own encodings | |
357 | // for DOS | |
358 | wxFONTENCODING_CP437, // original MS-DOS codepage | |
359 | wxFONTENCODING_CP850, // CP437 merged with Latin1 | |
360 | wxFONTENCODING_CP852, // CP437 merged with Latin2 | |
361 | wxFONTENCODING_CP855, // another cyrillic encoding | |
362 | wxFONTENCODING_CP866, // and another one | |
363 | // and for Windows | |
6d8b4f8d | 364 | wxFONTENCODING_CP874, // WinThai |
98624b49 RD |
365 | wxFONTENCODING_CP932, // Japanese (shift-JIS) |
366 | wxFONTENCODING_CP936, // Chiniese simplified (GB) | |
367 | wxFONTENCODING_CP949, // Korean (Hangul charset) | |
368 | wxFONTENCODING_CP950, // Chinese (traditional - Big5) | |
f0261a72 RD |
369 | wxFONTENCODING_CP1250, // WinLatin2 |
370 | wxFONTENCODING_CP1251, // WinCyrillic | |
371 | wxFONTENCODING_CP1252, // WinLatin1 | |
6d8b4f8d RD |
372 | wxFONTENCODING_CP1253, // WinGreek (8859-7) |
373 | wxFONTENCODING_CP1254, // WinTurkish | |
374 | wxFONTENCODING_CP1255, // WinHebrew | |
375 | wxFONTENCODING_CP1256, // WinArabic | |
376 | wxFONTENCODING_CP1257, // WinBaltic (same as Latin 7) | |
377 | wxFONTENCODING_CP12_MAX, | |
378 | ||
379 | wxFONTENCODING_UTF7, // UTF-7 Unicode encoding | |
380 | wxFONTENCODING_UTF8, // UTF-8 Unicode encoding | |
381 | ||
382 | wxFONTENCODING_UNICODE, // Unicode - currently used only by | |
383 | // wxEncodingConverter class | |
f0261a72 RD |
384 | |
385 | wxFONTENCODING_MAX | |
386 | }; | |
387 | ||
0569df0f | 388 | |
6d8b4f8d RD |
389 | |
390 | // wxNativeFontInfo is platform-specific font representation: this struct | |
391 | // should be considered as opaque font description only used by the native | |
392 | // functions, the user code can only get the objects of this type from | |
393 | // somewhere and pass it somewhere else (possibly save them somewhere using | |
394 | // ToString() and restore them using FromString()) | |
395 | struct wxNativeFontInfo | |
396 | { | |
b5a5d647 RD |
397 | #ifdef __WXGTK__ |
398 | // init the elements from an XLFD, return TRUE if ok | |
399 | bool FromXFontName(const wxString& xFontName); | |
400 | ||
ce914f73 RD |
401 | // return false if we were never initialized with a valid XLFD |
402 | bool IsDefault() const; | |
403 | ||
b5a5d647 RD |
404 | // generate an XLFD using the fontElements |
405 | wxString GetXFontName() const; | |
ce914f73 RD |
406 | |
407 | // set the XFLD | |
408 | void SetXFontName(const wxString& xFontName); | |
b5a5d647 RD |
409 | #endif |
410 | ||
411 | wxNativeFontInfo() { Init(); } | |
412 | ||
413 | // reset to the default state | |
414 | void Init(); | |
415 | ||
1893b029 | 416 | #ifndef __WXGTK__ |
b5a5d647 RD |
417 | // accessors and modifiers for the font elements |
418 | int GetPointSize() const; | |
419 | wxFontStyle GetStyle() const; | |
420 | wxFontWeight GetWeight() const; | |
421 | bool GetUnderlined() const; | |
422 | wxString GetFaceName() const; | |
423 | wxFontFamily GetFamily() const; | |
424 | wxFontEncoding GetEncoding() const; | |
425 | ||
426 | void SetPointSize(int pointsize); | |
427 | void SetStyle(wxFontStyle style); | |
428 | void SetWeight(wxFontWeight weight); | |
429 | void SetUnderlined(bool underlined); | |
430 | void SetFaceName(wxString facename); | |
431 | void SetFamily(wxFontFamily family); | |
432 | void SetEncoding(wxFontEncoding encoding); | |
1893b029 | 433 | #endif |
b5a5d647 | 434 | |
6d8b4f8d RD |
435 | // it is important to be able to serialize wxNativeFontInfo objects to be |
436 | // able to store them (in config file, for example) | |
437 | bool FromString(const wxString& s); | |
438 | wxString ToString() const; | |
439 | ||
440 | %addmethods { | |
441 | wxString __str__() { | |
442 | return self->ToString(); | |
443 | } | |
444 | } | |
b5a5d647 RD |
445 | |
446 | // we also want to present the native font descriptions to the user in some | |
447 | // human-readable form (it is not platform independent neither, but can | |
448 | // hopefully be understood by the user) | |
449 | bool FromUserString(const wxString& s); | |
450 | wxString ToUserString() const; | |
6d8b4f8d RD |
451 | }; |
452 | ||
453 | ||
454 | // wxFontMapper manages user-definable correspondence between logical font | |
455 | // names and the fonts present on the machine. | |
456 | // | |
457 | // The default implementations of all functions will ask the user if they are | |
458 | // not capable of finding the answer themselves and store the answer in a | |
459 | // config file (configurable via SetConfigXXX functions). This behaviour may | |
460 | // be disabled by giving the value of FALSE to "interactive" parameter. | |
461 | // However, the functions will always consult the config file to allow the | |
462 | // user-defined values override the default logic and there is no way to | |
463 | // disable this - which shouldn't be ever needed because if "interactive" was | |
464 | // never TRUE, the config file is never created anyhow. | |
465 | class wxFontMapper | |
466 | { | |
467 | public: | |
468 | wxFontMapper(); | |
469 | ~wxFontMapper(); | |
470 | ||
471 | ||
472 | // find an alternative for the given encoding (which is supposed to not be | |
473 | // available on this system). If successful, return TRUE and rwxFontEcoding | |
474 | // that can be used it wxFont ctor otherwise return FALSE | |
475 | //bool GetAltForEncoding(wxFontEncoding encoding, | |
476 | // wxFontEncoding *alt_encoding, | |
477 | // const wxString& facename = wxEmptyString, | |
478 | // bool interactive = TRUE); | |
479 | ||
480 | ||
481 | // Find an alternative for the given encoding (which is supposed to not be | |
482 | // available on this system). If successful, returns the encoding otherwise | |
483 | // returns None. | |
484 | %addmethods { | |
485 | PyObject* GetAltForEncoding(wxFontEncoding encoding, | |
486 | const wxString& facename = wxEmptyString, | |
487 | bool interactive = TRUE) { | |
488 | wxFontEncoding alt_enc; | |
489 | if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive)) | |
490 | return PyInt_FromLong(alt_enc); | |
491 | else { | |
492 | Py_INCREF(Py_None); | |
493 | return Py_None; | |
494 | } | |
495 | } | |
496 | } | |
497 | ||
498 | ||
499 | // checks whether given encoding is available in given face or not. | |
500 | // If no facename is given, | |
501 | bool IsEncodingAvailable(wxFontEncoding encoding, | |
502 | const wxString& facename = wxEmptyString); | |
503 | ||
504 | // returns the encoding for the given charset (in the form of RFC 2046) or | |
505 | // wxFONTENCODING_SYSTEM if couldn't decode it | |
506 | wxFontEncoding CharsetToEncoding(const wxString& charset, | |
507 | bool interactive = TRUE); | |
508 | ||
509 | // return internal string identifier for the encoding (see also | |
510 | // GetEncodingDescription()) | |
511 | static wxString GetEncodingName(wxFontEncoding encoding); | |
512 | ||
513 | // return user-readable string describing the given encoding | |
514 | // | |
515 | // NB: hard-coded now, but might change later (read it from config?) | |
516 | static wxString GetEncodingDescription(wxFontEncoding encoding); | |
517 | ||
518 | // the parent window for modal dialogs | |
519 | void SetDialogParent(wxWindow *parent); | |
520 | ||
521 | // the title for the dialogs (note that default is quite reasonable) | |
522 | void SetDialogTitle(const wxString& title); | |
523 | ||
524 | // functions which allow to configure the config object used: by default, | |
525 | // the global one (from wxConfigBase::Get() will be used) and the default | |
526 | // root path for the config settings is the string returned by | |
527 | // GetDefaultConfigPath() | |
528 | ||
529 | ||
530 | // set the config object to use (may be NULL to use default) | |
531 | void SetConfig(wxConfigBase *config); | |
532 | ||
533 | // set the root config path to use (should be an absolute path) | |
534 | void SetConfigPath(const wxString& prefix); | |
535 | ||
536 | // return default config path | |
537 | static const wxChar *GetDefaultConfigPath(); | |
538 | }; | |
539 | ||
540 | ||
541 | ||
542 | ||
9416aa89 | 543 | class wxFont : public wxGDIObject { |
7bf85405 | 544 | public: |
0569df0f RD |
545 | wxFont( int pointSize, int family, int style, int weight, |
546 | int underline=FALSE, char* faceName = "", | |
547 | wxFontEncoding encoding=wxFONTENCODING_DEFAULT); | |
6d8b4f8d RD |
548 | |
549 | %name(wxFontFromNativeInfo)wxFont(const wxNativeFontInfo& info); | |
550 | ||
0569df0f | 551 | ~wxFont(); |
7bf85405 | 552 | |
6d8b4f8d RD |
553 | bool Ok() const; |
554 | int GetPointSize() const; | |
555 | int GetFamily() const; | |
556 | int GetStyle() const; | |
557 | int GetWeight() const; | |
558 | bool GetUnderlined() const; | |
559 | wxString GetFaceName() const; | |
560 | wxFontEncoding GetEncoding() const; | |
68320e40 RD |
561 | |
562 | bool IsFixedWidth(); | |
563 | ||
6d8b4f8d | 564 | wxNativeFontInfo* GetNativeFontInfo() const; |
b5a5d647 RD |
565 | wxString GetNativeFontInfoDesc() const; |
566 | wxString GetNativeFontInfoUserDesc() const; | |
6d8b4f8d | 567 | |
7bf85405 | 568 | void SetPointSize(int pointSize); |
6d8b4f8d | 569 | void SetFamily(int family); |
7bf85405 | 570 | void SetStyle(int style); |
7bf85405 | 571 | void SetWeight(int weight); |
6d8b4f8d RD |
572 | void SetFaceName(const wxString& faceName); |
573 | void SetUnderlined(bool underlined); | |
f0261a72 | 574 | void SetEncoding(wxFontEncoding encoding); |
6d8b4f8d | 575 | void SetNativeFontInfo(const wxNativeFontInfo& info); |
b5a5d647 RD |
576 | // void SetNativeFontInfo(const wxString& info); |
577 | void SetNativeFontInfoUserDesc(const wxString& info); | |
7bf85405 | 578 | |
6d8b4f8d RD |
579 | wxString GetFamilyString() const; |
580 | wxString GetStyleString() const; | |
581 | wxString GetWeightString() const; | |
f0261a72 | 582 | |
6d8b4f8d RD |
583 | static wxFontEncoding GetDefaultEncoding(); |
584 | static void SetDefaultEncoding(wxFontEncoding encoding); | |
585 | ||
586 | }; | |
f0261a72 | 587 | |
0569df0f | 588 | |
9416aa89 | 589 | class wxFontList : public wxObject { |
0569df0f RD |
590 | public: |
591 | ||
592 | void AddFont(wxFont* font); | |
593 | wxFont * FindOrCreateFont(int point_size, int family, int style, int weight, | |
594 | bool underline = FALSE, const char* facename = NULL, | |
595 | wxFontEncoding encoding = wxFONTENCODING_DEFAULT); | |
596 | void RemoveFont(wxFont *font); | |
2f4e9287 RD |
597 | |
598 | int GetCount(); | |
0569df0f RD |
599 | }; |
600 | ||
601 | ||
7bf85405 RD |
602 | //---------------------------------------------------------------------- |
603 | ||
9416aa89 | 604 | class wxColour : public wxObject { |
7bf85405 RD |
605 | public: |
606 | wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0); | |
607 | ~wxColour(); | |
608 | unsigned char Red(); | |
609 | unsigned char Green(); | |
610 | unsigned char Blue(); | |
611 | bool Ok(); | |
612 | void Set(unsigned char red, unsigned char green, unsigned char blue); | |
613 | %addmethods { | |
614 | PyObject* Get() { | |
615 | PyObject* rv = PyTuple_New(3); | |
616 | PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red())); | |
617 | PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green())); | |
618 | PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue())); | |
619 | return rv; | |
620 | } | |
621 | } | |
9b3d3bc4 RD |
622 | %pragma(python) addtoclass = "asTuple = Get" |
623 | %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())" | |
624 | %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())" | |
625 | ||
7bf85405 RD |
626 | }; |
627 | ||
628 | %new wxColour* wxNamedColour(const wxString& colorName); | |
de20db99 | 629 | |
7bf85405 RD |
630 | %{ // Alternate 'constructor' |
631 | wxColour* wxNamedColour(const wxString& colorName) { | |
632 | return new wxColour(colorName); | |
633 | } | |
634 | %} | |
635 | ||
636 | ||
7bf85405 | 637 | |
9416aa89 | 638 | class wxColourDatabase : public wxObject { |
7bf85405 | 639 | public: |
0569df0f RD |
640 | |
641 | wxColour *FindColour(const wxString& colour); | |
642 | wxString FindName(const wxColour& colour) const; | |
643 | ||
7bf85405 | 644 | %addmethods { |
0569df0f | 645 | void Append(const wxString& name, int red, int green, int blue) { |
fe40185d RD |
646 | // first see if the name is already there |
647 | wxString cName = name; | |
648 | cName.MakeUpper(); | |
649 | wxString cName2 = cName; | |
650 | if ( !cName2.Replace("GRAY", "GREY") ) | |
651 | cName2.clear(); | |
652 | ||
653 | wxNode *node = self->First(); | |
654 | while ( node ) { | |
655 | const wxChar *key = node->GetKeyString(); | |
656 | if ( cName == key || cName2 == key ) { | |
657 | wxColour* c = (wxColour *)node->Data(); | |
658 | c->Set(red, green, blue); | |
659 | return; | |
660 | } | |
661 | node = node->Next(); | |
662 | } | |
663 | ||
664 | // otherwise append the new colour | |
0569df0f | 665 | self->Append(name.c_str(), new wxColour(red, green, blue)); |
7bf85405 | 666 | } |
7bf85405 | 667 | } |
0569df0f RD |
668 | }; |
669 | ||
670 | ||
671 | //---------------------------------------------------------------------- | |
672 | ||
9416aa89 | 673 | class wxPen : public wxGDIObject { |
0569df0f RD |
674 | public: |
675 | wxPen(wxColour& colour, int width=1, int style=wxSOLID); | |
676 | ~wxPen(); | |
7bf85405 RD |
677 | |
678 | int GetCap(); | |
25832b3f | 679 | wxColour GetColour(); |
7bf85405 | 680 | |
fb5e0af0 | 681 | int GetJoin(); |
7bf85405 RD |
682 | int GetStyle(); |
683 | int GetWidth(); | |
684 | bool Ok(); | |
685 | void SetCap(int cap_style); | |
686 | void SetColour(wxColour& colour); | |
aeeb6a44 RR |
687 | void SetJoin(int join_style); |
688 | void SetStyle(int style); | |
689 | void SetWidth(int width); | |
08127323 | 690 | |
aeeb6a44 | 691 | // **** This one needs to return a list of ints (wxDash) |
ecc08ead | 692 | //int GetDashes(wxDash **dashes); |
eec92d76 | 693 | void SetDashes(int LCOUNT, wxDash* choices); |
6999b0d8 RD |
694 | |
695 | #ifdef __WXMSW__ | |
696 | wxBitmap* GetStipple(); | |
b8b8dda7 | 697 | void SetStipple(wxBitmap& stipple); |
fb5e0af0 | 698 | #endif |
7bf85405 RD |
699 | }; |
700 | ||
0569df0f | 701 | |
ecc08ead | 702 | |
05f30eec RD |
703 | |
704 | // The list of ints for the dashes needs to exist for the life of the pen | |
705 | // so we make it part of the class to save it. wxPyPen is aliased to wxPen | |
706 | // in _extras.py | |
707 | ||
ecc08ead RD |
708 | %{ |
709 | class wxPyPen : public wxPen { | |
710 | public: | |
711 | wxPyPen(wxColour& colour, int width=1, int style=wxSOLID) | |
712 | : wxPen(colour, width, style) | |
713 | { m_dash = NULL; } | |
714 | ~wxPyPen() { | |
715 | if (m_dash) | |
05f30eec | 716 | delete [] m_dash; |
ecc08ead RD |
717 | } |
718 | ||
719 | void SetDashes(int nb_dashes, const wxDash *dash) { | |
05f30eec RD |
720 | if (m_dash) |
721 | delete [] m_dash; | |
ecc08ead | 722 | m_dash = new wxDash[nb_dashes]; |
05f30eec | 723 | for (int i=0; i<nb_dashes; i++) { |
ecc08ead | 724 | m_dash[i] = dash[i]; |
05f30eec | 725 | } |
ecc08ead RD |
726 | wxPen::SetDashes(nb_dashes, m_dash); |
727 | } | |
728 | ||
729 | private: | |
730 | wxDash* m_dash; | |
731 | }; | |
732 | %} | |
733 | ||
734 | ||
ecc08ead RD |
735 | class wxPyPen : public wxPen { |
736 | public: | |
737 | wxPyPen(wxColour& colour, int width=1, int style=wxSOLID); | |
738 | ~wxPyPen(); | |
739 | ||
740 | void SetDashes(int LCOUNT, wxDash* choices); | |
741 | }; | |
742 | ||
743 | ||
744 | ||
05f30eec | 745 | |
9416aa89 | 746 | class wxPenList : public wxObject { |
0569df0f RD |
747 | public: |
748 | ||
749 | void AddPen(wxPen* pen); | |
750 | wxPen* FindOrCreatePen(const wxColour& colour, int width, int style); | |
751 | void RemovePen(wxPen* pen); | |
2f4e9287 RD |
752 | |
753 | int GetCount(); | |
0569df0f RD |
754 | }; |
755 | ||
756 | ||
757 | ||
7bf85405 RD |
758 | //---------------------------------------------------------------------- |
759 | ||
9416aa89 | 760 | class wxBrush : public wxGDIObject { |
7bf85405 | 761 | public: |
0569df0f RD |
762 | wxBrush(const wxColour& colour, int style=wxSOLID); |
763 | ~wxBrush(); | |
26b9cf27 | 764 | |
25832b3f | 765 | wxColour GetColour(); |
7bf85405 RD |
766 | wxBitmap * GetStipple(); |
767 | int GetStyle(); | |
768 | bool Ok(); | |
769 | void SetColour(wxColour &colour); | |
b8b8dda7 | 770 | void SetStipple(wxBitmap& bitmap); |
7bf85405 RD |
771 | void SetStyle(int style); |
772 | }; | |
773 | ||
0569df0f | 774 | |
6ee2116b | 775 | class wxBrushList : public wxObject { |
0569df0f RD |
776 | public: |
777 | ||
778 | void AddBrush(wxBrush *brush); | |
779 | wxBrush * FindOrCreateBrush(const wxColour& colour, int style); | |
780 | void RemoveBrush(wxBrush *brush); | |
2f4e9287 RD |
781 | |
782 | int GetCount(); | |
0569df0f RD |
783 | }; |
784 | ||
7bf85405 RD |
785 | //---------------------------------------------------------------------- |
786 | ||
787 | ||
788 | ||
9416aa89 | 789 | class wxDC : public wxObject { |
7bf85405 | 790 | public: |
fb5e0af0 | 791 | // wxDC(); **** abstract base class, can't instantiate. |
7bf85405 RD |
792 | ~wxDC(); |
793 | ||
794 | void BeginDrawing(); | |
efc5f224 RD |
795 | // %name(BlitXY) |
796 | bool Blit(long xdest, long ydest, | |
797 | long width, long height, | |
798 | wxDC *source, long xsrc, long ysrc, | |
799 | int logicalFunc = wxCOPY, int useMask = FALSE); | |
800 | // bool Blit(const wxPoint& destPt, const wxSize& sz, | |
801 | // wxDC *source, const wxPoint& srcPt, | |
802 | // int logicalFunc = wxCOPY, int useMask = FALSE); | |
803 | ||
7bf85405 RD |
804 | void Clear(); |
805 | void CrossHair(long x, long y); | |
806 | void DestroyClippingRegion(); | |
807 | long DeviceToLogicalX(long x); | |
808 | long DeviceToLogicalXRel(long x); | |
809 | long DeviceToLogicalY(long y); | |
810 | long DeviceToLogicalYRel(long y); | |
811 | void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc); | |
bb0054cd | 812 | void DrawCircle(long x, long y, long radius); |
7bf85405 RD |
813 | void DrawEllipse(long x, long y, long width, long height); |
814 | void DrawEllipticArc(long x, long y, long width, long height, long start, long end); | |
815 | void DrawIcon(const wxIcon& icon, long x, long y); | |
23bed520 RD |
816 | |
817 | void DrawLabel(const wxString& text, const wxRect& rect, | |
818 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
819 | int indexAccel = -1); | |
820 | ||
821 | %addmethods { | |
822 | wxRect DrawImageLabel(const wxString& text, | |
823 | const wxBitmap& image, | |
824 | const wxRect& rect, | |
825 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
826 | int indexAccel = -1) { | |
827 | wxRect rv; | |
828 | self->DrawLabel(text, image, rect, alignment, indexAccel, &rv); | |
829 | return rv; | |
830 | } | |
831 | } | |
832 | ||
7bf85405 | 833 | void DrawLine(long x1, long y1, long x2, long y2); |
eec92d76 RD |
834 | void DrawLines(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0); |
835 | void DrawPolygon(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0, | |
7bf85405 RD |
836 | int fill_style=wxODDEVEN_RULE); |
837 | void DrawPoint(long x, long y); | |
838 | void DrawRectangle(long x, long y, long width, long height); | |
6999b0d8 | 839 | void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle); |
7bf85405 | 840 | void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20); |
eec92d76 | 841 | void DrawSpline(int PCOUNT, wxPoint* points); |
7bf85405 RD |
842 | void DrawText(const wxString& text, long x, long y); |
843 | void EndDoc(); | |
844 | void EndDrawing(); | |
845 | void EndPage(); | |
846 | void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE); | |
c5943253 RD |
847 | wxBrush GetBackground(); |
848 | wxBrush GetBrush(); | |
7bf85405 RD |
849 | long GetCharHeight(); |
850 | long GetCharWidth(); | |
851 | void GetClippingBox(long *OUTPUT, long *OUTPUT, | |
852 | long *OUTPUT, long *OUTPUT); | |
c5943253 | 853 | wxFont GetFont(); |
7bf85405 | 854 | int GetLogicalFunction(); |
eec92d76 | 855 | void GetLogicalScale(double *OUTPUT, double *OUTPUT); |
7bf85405 RD |
856 | int GetMapMode(); |
857 | bool GetOptimization(); | |
c5943253 | 858 | wxPen GetPen(); |
fb5e0af0 RD |
859 | %addmethods { |
860 | %new wxColour* GetPixel(long x, long y) { | |
861 | wxColour* wc = new wxColour(); | |
862 | self->GetPixel(x, y, wc); | |
863 | return wc; | |
864 | } | |
865 | } | |
bb0054cd RD |
866 | %name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT); |
867 | wxSize GetSize(); | |
eec92d76 | 868 | wxSize GetSizeMM(); |
25832b3f | 869 | wxColour GetTextBackground(); |
af309447 RD |
870 | void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT); |
871 | %name(GetFullTextExtent)void GetTextExtent(const wxString& string, | |
872 | long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT, | |
873 | const wxFont* font = NULL); | |
25832b3f | 874 | wxColour GetTextForeground(); |
eec92d76 | 875 | void GetUserScale(double *OUTPUT, double *OUTPUT); |
7bf85405 RD |
876 | long LogicalToDeviceX(long x); |
877 | long LogicalToDeviceXRel(long x); | |
878 | long LogicalToDeviceY(long y); | |
879 | long LogicalToDeviceYRel(long y); | |
880 | long MaxX(); | |
881 | long MaxY(); | |
882 | long MinX(); | |
883 | long MinY(); | |
884 | bool Ok(); | |
885 | void SetDeviceOrigin(long x, long y); | |
886 | void SetBackground(const wxBrush& brush); | |
887 | void SetBackgroundMode(int mode); | |
888 | void SetClippingRegion(long x, long y, long width, long height); | |
19a97bd6 | 889 | %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region); |
7bf85405 RD |
890 | void SetPalette(const wxPalette& colourMap); |
891 | void SetBrush(const wxBrush& brush); | |
892 | void SetFont(const wxFont& font); | |
893 | void SetLogicalFunction(int function); | |
eec92d76 | 894 | void SetLogicalScale(double x, double y); |
7bf85405 RD |
895 | void SetMapMode(int mode); |
896 | void SetOptimization(bool optimize); | |
897 | void SetPen(const wxPen& pen); | |
898 | void SetTextBackground(const wxColour& colour); | |
899 | void SetTextForeground(const wxColour& colour); | |
900 | void SetUserScale(double x_scale, double y_scale); | |
901 | bool StartDoc(const wxString& message); | |
902 | void StartPage(); | |
903 | ||
904 | ||
efc5f224 RD |
905 | |
906 | void DrawBitmap(const wxBitmap& bitmap, long x, long y, | |
907 | int useMask = FALSE); | |
908 | ||
eec92d76 RD |
909 | bool CanDrawBitmap(); |
910 | bool CanGetTextExtent(); | |
911 | int GetDepth(); | |
912 | wxSize GetPPI(); | |
913 | ||
914 | void GetLogicalOrigin(int *OUTPUT, int *OUTPUT); | |
915 | void SetLogicalOrigin(int x, int y); | |
916 | void GetDeviceOrigin(int *OUTPUT, int *OUTPUT); | |
eec92d76 RD |
917 | void SetAxisOrientation(bool xLeftRight, bool yBottomUp); |
918 | ||
f6bcfd97 BP |
919 | void CalcBoundingBox(int x, int y); |
920 | void ResetBoundingBox(); | |
c7e7022c | 921 | |
9d37f964 RD |
922 | %addmethods { |
923 | void GetBoundingBox(int* OUTPUT, int* OUTPUT, int* OUTPUT, int* OUTPUT); | |
924 | // See below for implementation | |
925 | } | |
926 | ||
c7e7022c RD |
927 | #ifdef __WXMSW__ |
928 | long GetHDC(); | |
929 | #endif | |
9d37f964 RD |
930 | |
931 | ||
932 | %addmethods { | |
76e280e7 | 933 | // NOTE: These methods are VERY SIMILAR in implentation. It would be |
17c0e08c | 934 | // nice to factor out common code and or turn them into a set of |
76e280e7 RD |
935 | // template-like macros. |
936 | ||
9d37f964 RD |
937 | // Draw a point for every set of coordinants in pyPoints, optionally |
938 | // setting a new pen for each | |
939 | PyObject* _DrawPointList(PyObject* pyPoints, PyObject* pyPens) { | |
940 | bool isFastSeq = PyList_Check(pyPoints) || PyTuple_Check(pyPoints); | |
941 | bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens); | |
942 | int numObjs = 0; | |
943 | int numPens = 0; | |
944 | wxPen* pen; | |
945 | PyObject* obj; | |
946 | int x1, y1; | |
947 | int i = 0; | |
948 | ||
949 | if (!PySequence_Check(pyPoints)) { | |
950 | goto err0; | |
951 | } | |
952 | if (!PySequence_Check(pyPens)) { | |
953 | goto err1; | |
954 | } | |
955 | numObjs = PySequence_Length(pyPoints); | |
956 | numPens = PySequence_Length(pyPens); | |
957 | ||
958 | for (i = 0; i < numObjs; i++) { | |
959 | // Use a new pen? | |
960 | if (i < numPens) { | |
961 | if (isFastPens) { | |
962 | obj = PySequence_Fast_GET_ITEM(pyPens, i); | |
963 | } | |
964 | else { | |
965 | obj = PySequence_GetItem(pyPens, i); | |
966 | } | |
967 | if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) { | |
76e280e7 RD |
968 | if (!isFastPens) |
969 | Py_DECREF(obj); | |
9d37f964 RD |
970 | goto err1; |
971 | } | |
972 | ||
973 | self->SetPen(*pen); | |
974 | if (!isFastPens) | |
975 | Py_DECREF(obj); | |
976 | } | |
977 | ||
978 | // Get the point coordinants | |
979 | if (isFastSeq) { | |
980 | obj = PySequence_Fast_GET_ITEM(pyPoints, i); | |
981 | } | |
982 | else { | |
983 | obj = PySequence_GetItem(pyPoints, i); | |
984 | } | |
985 | if (! _2int_seq_helper(obj, &x1, &y1)) { | |
76e280e7 RD |
986 | if (!isFastPens) |
987 | Py_DECREF(obj); | |
9d37f964 RD |
988 | goto err0; |
989 | } | |
990 | ||
991 | // Now draw the point | |
992 | self->DrawPoint(x1, y1); | |
993 | ||
994 | if (!isFastSeq) | |
995 | Py_DECREF(obj); | |
996 | } | |
997 | ||
998 | Py_INCREF(Py_None); | |
999 | return Py_None; | |
1000 | ||
1001 | err1: | |
1002 | PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens"); | |
1003 | return NULL; | |
1004 | err0: | |
1005 | PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences."); | |
1006 | return NULL; | |
1007 | } | |
1008 | ||
1009 | ||
1010 | // Draw a line for every set of coordinants in pyLines, optionally | |
1011 | // setting a new pen for each | |
1012 | PyObject* _DrawLineList(PyObject* pyLines, PyObject* pyPens) { | |
1013 | bool isFastSeq = PyList_Check(pyLines) || PyTuple_Check(pyLines); | |
1014 | bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens); | |
1015 | int numObjs = 0; | |
1016 | int numPens = 0; | |
1017 | wxPen* pen; | |
1018 | PyObject* obj; | |
1019 | int x1, y1, x2, y2; | |
1020 | int i = 0; | |
1021 | ||
1022 | if (!PySequence_Check(pyLines)) { | |
1023 | goto err0; | |
1024 | } | |
1025 | if (!PySequence_Check(pyPens)) { | |
1026 | goto err1; | |
1027 | } | |
1028 | numObjs = PySequence_Length(pyLines); | |
1029 | numPens = PySequence_Length(pyPens); | |
1030 | ||
1031 | for (i = 0; i < numObjs; i++) { | |
1032 | // Use a new pen? | |
1033 | if (i < numPens) { | |
1034 | if (isFastPens) { | |
1035 | obj = PySequence_Fast_GET_ITEM(pyPens, i); | |
1036 | } | |
1037 | else { | |
1038 | obj = PySequence_GetItem(pyPens, i); | |
1039 | } | |
1040 | if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) { | |
76e280e7 RD |
1041 | if (!isFastPens) |
1042 | Py_DECREF(obj); | |
9d37f964 RD |
1043 | goto err1; |
1044 | } | |
1045 | ||
1046 | self->SetPen(*pen); | |
1047 | if (!isFastPens) | |
1048 | Py_DECREF(obj); | |
1049 | } | |
1050 | ||
1051 | // Get the line coordinants | |
1052 | if (isFastSeq) { | |
1053 | obj = PySequence_Fast_GET_ITEM(pyLines, i); | |
1054 | } | |
1055 | else { | |
1056 | obj = PySequence_GetItem(pyLines, i); | |
1057 | } | |
1058 | if (! _4int_seq_helper(obj, &x1, &y1, &x2, &y2)) { | |
76e280e7 RD |
1059 | if (!isFastPens) |
1060 | Py_DECREF(obj); | |
9d37f964 RD |
1061 | goto err0; |
1062 | } | |
1063 | ||
1064 | // Now draw the line | |
1065 | self->DrawLine(x1, y1, x2, y2); | |
1066 | ||
1067 | if (!isFastSeq) | |
1068 | Py_DECREF(obj); | |
1069 | } | |
1070 | ||
1071 | Py_INCREF(Py_None); | |
1072 | return Py_None; | |
1073 | ||
1074 | err1: | |
1075 | PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens"); | |
1076 | return NULL; | |
1077 | err0: | |
1078 | PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x2,y2) sequences."); | |
1079 | return NULL; | |
1080 | } | |
1081 | } | |
1082 | ||
1083 | ||
1084 | %pragma(python) addtoclass = " | |
1085 | def DrawPointList(self, points, pens=None): | |
1086 | if pens is None: | |
1087 | pens = [] | |
1088 | elif isinstance(pens, wxPenPtr): | |
1089 | pens = [pens] | |
1090 | elif len(pens) != len(points): | |
1091 | raise ValueError('points and pens must have same length') | |
1092 | return self._DrawPointList(points, pens) | |
1093 | ||
1094 | def DrawLineList(self, lines, pens=None): | |
1095 | if pens is None: | |
1096 | pens = [] | |
1097 | elif isinstance(pens, wxPenPtr): | |
1098 | pens = [pens] | |
1099 | elif len(pens) != len(lines): | |
1100 | raise ValueError('lines and pens must have same length') | |
1101 | return self._DrawLineList(lines, pens) | |
1102 | " | |
1103 | ||
1104 | ||
7bf85405 RD |
1105 | }; |
1106 | ||
1107 | ||
9d37f964 RD |
1108 | |
1109 | %{ | |
1110 | static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) { | |
1111 | *x1 = dc->MinX(); | |
1112 | *y1 = dc->MinY(); | |
1113 | *x2 = dc->MaxX(); | |
1114 | *y2 = dc->MaxY(); | |
1115 | } | |
1116 | %} | |
1117 | ||
7bf85405 RD |
1118 | //---------------------------------------------------------------------- |
1119 | ||
1120 | class wxMemoryDC : public wxDC { | |
1121 | public: | |
1122 | wxMemoryDC(); | |
1123 | ||
1124 | void SelectObject(const wxBitmap& bitmap); | |
1125 | } | |
1126 | ||
1127 | %new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC); | |
1128 | %{ // Alternate 'constructor' | |
1129 | wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) { | |
1130 | return new wxMemoryDC(oldDC); | |
1131 | } | |
1132 | %} | |
1133 | ||
1134 | ||
1135 | //--------------------------------------------------------------------------- | |
1136 | ||
1137 | class wxScreenDC : public wxDC { | |
1138 | public: | |
1139 | wxScreenDC(); | |
1140 | ||
26b9cf27 RD |
1141 | %name(StartDrawingOnTopWin) bool StartDrawingOnTop(wxWindow* window); |
1142 | bool StartDrawingOnTop(wxRect* rect = NULL); | |
7bf85405 RD |
1143 | bool EndDrawingOnTop(); |
1144 | }; | |
1145 | ||
1146 | //--------------------------------------------------------------------------- | |
1147 | ||
1148 | class wxClientDC : public wxDC { | |
1149 | public: | |
1150 | wxClientDC(wxWindow* win); | |
1151 | }; | |
1152 | ||
1153 | //--------------------------------------------------------------------------- | |
1154 | ||
1155 | class wxPaintDC : public wxDC { | |
1156 | public: | |
1157 | wxPaintDC(wxWindow* win); | |
1158 | }; | |
1159 | ||
1160 | //--------------------------------------------------------------------------- | |
1161 | ||
b639c3c5 RD |
1162 | class wxWindowDC : public wxDC { |
1163 | public: | |
1164 | wxWindowDC(wxWindow* win); | |
1165 | }; | |
b639c3c5 RD |
1166 | |
1167 | //--------------------------------------------------------------------------- | |
1168 | ||
7bf85405 | 1169 | |
d063802f | 1170 | #ifdef __WXMSW__ |
17c0e08c RD |
1171 | |
1172 | %{ | |
1173 | #include <wx/metafile.h> | |
1174 | %} | |
1175 | ||
1176 | class wxMetaFile : public wxObject { | |
1177 | public: | |
23bed520 | 1178 | wxMetaFile(const wxString& filename = wxEmptyString); |
17c0e08c RD |
1179 | ~wxMetaFile(); |
1180 | ||
1181 | bool Ok(); | |
1182 | bool SetClipboard(int width = 0, int height = 0); | |
1183 | ||
1184 | wxSize GetSize(); | |
1185 | int GetWidth(); | |
1186 | int GetHeight(); | |
1187 | ||
1188 | const wxString& GetFileName() const { return m_filename; } | |
1189 | ||
1190 | }; | |
1191 | ||
1192 | // bool wxMakeMetaFilePlaceable(const wxString& filename, | |
1193 | // int minX, int minY, int maxX, int maxY, float scale=1.0); | |
1194 | ||
1195 | ||
7bf85405 RD |
1196 | class wxMetaFileDC : public wxDC { |
1197 | public: | |
23bed520 | 1198 | wxMetaFileDC(const wxString& filename = wxEmptyString, |
17c0e08c | 1199 | int width = 0, int height = 0, |
23bed520 | 1200 | const wxString& description = wxEmptyString); |
7bf85405 RD |
1201 | wxMetaFile* Close(); |
1202 | }; | |
17c0e08c | 1203 | |
fb5e0af0 | 1204 | #endif |
7bf85405 | 1205 | |
b639c3c5 RD |
1206 | //--------------------------------------------------------------------------- |
1207 | ||
9416aa89 | 1208 | class wxPalette : public wxGDIObject { |
b639c3c5 | 1209 | public: |
eec92d76 | 1210 | wxPalette(int LCOUNT, byte* choices, byte* choices, byte* choices); |
b639c3c5 RD |
1211 | ~wxPalette(); |
1212 | ||
1213 | int GetPixel(byte red, byte green, byte blue); | |
1214 | bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT); | |
1215 | bool Ok(); | |
1216 | }; | |
1217 | ||
1218 | //--------------------------------------------------------------------------- | |
1219 | ||
af309447 RD |
1220 | enum { |
1221 | wxIMAGELIST_DRAW_NORMAL , | |
1222 | wxIMAGELIST_DRAW_TRANSPARENT, | |
1223 | wxIMAGELIST_DRAW_SELECTED, | |
1224 | wxIMAGELIST_DRAW_FOCUSED, | |
1225 | wxIMAGE_LIST_NORMAL, | |
1226 | wxIMAGE_LIST_SMALL, | |
1227 | wxIMAGE_LIST_STATE | |
1228 | }; | |
1229 | ||
9416aa89 | 1230 | class wxImageList : public wxObject { |
af309447 | 1231 | public: |
dcd38683 | 1232 | wxImageList(int width, int height, int mask=TRUE, int initialCount=1); |
af309447 RD |
1233 | ~wxImageList(); |
1234 | ||
1235 | int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); | |
1236 | %name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour); | |
1237 | %name(AddIcon)int Add(const wxIcon& icon); | |
f6bcfd97 | 1238 | #ifdef __WXMSW__ |
b57bdb5a | 1239 | bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); |
b57bdb5a | 1240 | #else |
f6bcfd97 BP |
1241 | // %name(ReplaceIcon)bool Replace(int index, const wxIcon& icon); |
1242 | // int Add(const wxBitmap& bitmap); | |
b57bdb5a RD |
1243 | bool Replace(int index, const wxBitmap& bitmap); |
1244 | #endif | |
af309447 RD |
1245 | |
1246 | bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL, | |
1247 | const bool solidBackground = FALSE); | |
1248 | ||
1249 | int GetImageCount(); | |
1250 | bool Remove(int index); | |
1251 | bool RemoveAll(); | |
f6bcfd97 | 1252 | void GetSize(int index, int& OUTPUT, int& OUTPUT); |
af309447 RD |
1253 | }; |
1254 | ||
b639c3c5 | 1255 | |
9416aa89 RD |
1256 | //--------------------------------------------------------------------------- |
1257 | // Regions, etc. | |
1258 | ||
1259 | enum wxRegionContain { | |
1260 | wxOutRegion, wxPartRegion, wxInRegion | |
1261 | }; | |
1262 | ||
1263 | ||
1264 | class wxRegion : public wxGDIObject { | |
1265 | public: | |
1266 | wxRegion(long x=0, long y=0, long width=0, long height=0); | |
1267 | ~wxRegion(); | |
1268 | ||
1269 | void Clear(); | |
d063802f | 1270 | #ifndef __WXMAC__ |
23bed520 | 1271 | bool Offset(wxCoord x, wxCoord y); |
d063802f | 1272 | #endif |
23bed520 | 1273 | |
9416aa89 RD |
1274 | wxRegionContain Contains(long x, long y); |
1275 | %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt); | |
1276 | %name(ContainsRect)wxRegionContain Contains(const wxRect& rect); | |
1277 | %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h); | |
1278 | ||
1279 | wxRect GetBox(); | |
1280 | ||
1281 | bool Intersect(long x, long y, long width, long height); | |
1282 | %name(IntersectRect)bool Intersect(const wxRect& rect); | |
1283 | %name(IntersectRegion)bool Intersect(const wxRegion& region); | |
1284 | ||
1285 | bool IsEmpty(); | |
1286 | ||
1287 | bool Union(long x, long y, long width, long height); | |
1288 | %name(UnionRect)bool Union(const wxRect& rect); | |
1289 | %name(UnionRegion)bool Union(const wxRegion& region); | |
1290 | ||
1291 | bool Subtract(long x, long y, long width, long height); | |
1292 | %name(SubtractRect)bool Subtract(const wxRect& rect); | |
1293 | %name(SubtractRegion)bool Subtract(const wxRegion& region); | |
1294 | ||
1295 | bool Xor(long x, long y, long width, long height); | |
1296 | %name(XorRect)bool Xor(const wxRect& rect); | |
1297 | %name(XorRegion)bool Xor(const wxRegion& region); | |
1298 | }; | |
1299 | ||
1300 | ||
1301 | ||
1302 | class wxRegionIterator : public wxObject { | |
1303 | public: | |
1304 | wxRegionIterator(const wxRegion& region); | |
1305 | ~wxRegionIterator(); | |
1306 | ||
1307 | long GetX(); | |
1308 | long GetY(); | |
1309 | long GetW(); | |
1310 | long GetWidth(); | |
1311 | long GetH(); | |
1312 | long GetHeight(); | |
1313 | wxRect GetRect(); | |
1314 | bool HaveRects(); | |
1315 | void Reset(); | |
1316 | ||
1317 | %addmethods { | |
1318 | void Next() { | |
1319 | (*self) ++; | |
1320 | } | |
1321 | }; | |
1322 | }; | |
1323 | ||
1324 | ||
7bf85405 RD |
1325 | //--------------------------------------------------------------------------- |
1326 | ||
c5943253 RD |
1327 | %readonly |
1328 | %{ | |
1329 | #if 0 | |
1330 | %} | |
1331 | ||
1332 | extern wxFont *wxNORMAL_FONT; | |
1333 | extern wxFont *wxSMALL_FONT; | |
1334 | extern wxFont *wxITALIC_FONT; | |
1335 | extern wxFont *wxSWISS_FONT; | |
1336 | ||
1337 | extern wxPen *wxRED_PEN; | |
1338 | extern wxPen *wxCYAN_PEN; | |
1339 | extern wxPen *wxGREEN_PEN; | |
1340 | extern wxPen *wxBLACK_PEN; | |
1341 | extern wxPen *wxWHITE_PEN; | |
1342 | extern wxPen *wxTRANSPARENT_PEN; | |
1343 | extern wxPen *wxBLACK_DASHED_PEN; | |
1344 | extern wxPen *wxGREY_PEN; | |
1345 | extern wxPen *wxMEDIUM_GREY_PEN; | |
1346 | extern wxPen *wxLIGHT_GREY_PEN; | |
1347 | ||
1348 | extern wxBrush *wxBLUE_BRUSH; | |
1349 | extern wxBrush *wxGREEN_BRUSH; | |
1350 | extern wxBrush *wxWHITE_BRUSH; | |
1351 | extern wxBrush *wxBLACK_BRUSH; | |
1352 | extern wxBrush *wxTRANSPARENT_BRUSH; | |
1353 | extern wxBrush *wxCYAN_BRUSH; | |
1354 | extern wxBrush *wxRED_BRUSH; | |
1355 | extern wxBrush *wxGREY_BRUSH; | |
1356 | extern wxBrush *wxMEDIUM_GREY_BRUSH; | |
1357 | extern wxBrush *wxLIGHT_GREY_BRUSH; | |
1358 | ||
1359 | extern wxColour *wxBLACK; | |
1360 | extern wxColour *wxWHITE; | |
1361 | extern wxColour *wxRED; | |
1362 | extern wxColour *wxBLUE; | |
1363 | extern wxColour *wxGREEN; | |
1364 | extern wxColour *wxCYAN; | |
1365 | extern wxColour *wxLIGHT_GREY; | |
1366 | ||
1367 | extern wxCursor *wxSTANDARD_CURSOR; | |
1368 | extern wxCursor *wxHOURGLASS_CURSOR; | |
1369 | extern wxCursor *wxCROSS_CURSOR; | |
1370 | ||
1371 | ||
1372 | extern wxBitmap wxNullBitmap; | |
1373 | extern wxIcon wxNullIcon; | |
1374 | extern wxCursor wxNullCursor; | |
1375 | extern wxPen wxNullPen; | |
1376 | extern wxBrush wxNullBrush; | |
1377 | extern wxPalette wxNullPalette; | |
1378 | extern wxFont wxNullFont; | |
1379 | extern wxColour wxNullColour; | |
1380 | ||
1381 | ||
1382 | extern wxFontList* wxTheFontList; | |
1383 | extern wxPenList* wxThePenList; | |
1384 | extern wxBrushList* wxTheBrushList; | |
1385 | extern wxColourDatabase* wxTheColourDatabase; | |
1386 | ||
1387 | ||
1388 | %readwrite | |
1389 | %{ | |
1390 | #endif | |
1391 | %} | |
1392 | ||
1393 | //--------------------------------------------------------------------------- | |
1394 | //--------------------------------------------------------------------------- | |
1395 |