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