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