/////////////////////////////////////////////////////////////////////////////
// Name: gdi.i
-// Purpose: SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
+// Purpose: SWIG interface file for wxDC, wxBrush, wxPen, etc.
//
// Author: Robin Dunn
//
#include <wx/fontenc.h>
#include <wx/fontmap.h>
#include <wx/fontutil.h>
+#include <wx/dcbuffer.h>
+#include <wx/dcmirror.h>
+#include <wx/iconbndl.h>
%}
//----------------------------------------------------------------------
// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
+%import fonts.i
+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------
%{
- static wxString wxPyEmptyStr("");
+ // Put some wx default wxChar* values into wxStrings.
+ static const wxString wxPyEmptyString(wxT(""));
%}
-
//---------------------------------------------------------------------------
class wxGDIObject : public wxObject {
//---------------------------------------------------------------------------
+
+// TODO: When the API stabalizes and is available on other platforms, add
+// wrappers for the new wxBitmap, wxRawBitmap, wxDIB stuff...
+
class wxBitmap : public wxGDIObject
{
public:
- wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP);
+ wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY);
~wxBitmap();
wxPalette* GetPalette();
wxMask* GetMask();
- bool LoadFile(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP);
+ bool LoadFile(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY);
bool SaveFile(const wxString& name, wxBitmapType type, wxPalette* palette = NULL);
void SetMask(wxMask* mask);
+ %pragma(python) addtoclass = "
+ def SetMaskColour(self, colour):
+ mask = wxMaskColour(self, colour)
+ self.SetMask(mask)
+ "
#ifdef __WXMSW__
void SetPalette(wxPalette& palette);
#endif
void SetQuality(int q);
#endif
- %pragma(python) addtoclass = "
- def __del__(self,gdic=gdic):
- try:
- if self.thisown == 1 :
- gdic.delete_wxBitmap(self)
- except:
- pass
-"
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
%new wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings);
%new wxBitmap* wxBitmapFromIcon(const wxIcon& icon);
-%new wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 );
+%new wxBitmap* wxBitmapFromBits(PyObject* bits, int width, int height, int depth = 1 );
// #ifdef __WXMSW__
// %new wxBitmap* wxBitmapFromData(PyObject* data, long type,
}
- wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 ) {
- return new wxBitmap(bits, width, height, depth);
+ wxBitmap* wxBitmapFromBits(PyObject* bits, int width, int height, int depth = 1 ) {
+ char* buf;
+ int length;
+ PyString_AsStringAndSize(bits, &buf, &length);
+ return new wxBitmap(buf, width, height, depth);
}
#endif
void CopyFromBitmap(const wxBitmap& bmp);
- %pragma(python) addtoclass = "
- def __del__(self,gdic=gdic):
- try:
- if self.thisown == 1 :
- gdic.delete_wxIcon(self)
- except:
- pass
-"
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
// Declarations of some alternate "constructors"
%new wxIcon* wxEmptyIcon();
%new wxIcon* wxIconFromXPMData(PyObject* listOfStrings);
+%new wxIcon* wxIconFromBitmap(const wxBitmap& bmp);
+%new wxIcon* wxIconFromLocation(const wxIconLocation& loc);
%{ // Implementations of some alternate "constructors"
wxIcon* wxEmptyIcon() {
delete [] cArray;
return icon;
}
+
+ wxIcon* wxIconFromBitmap(const wxBitmap& bmp) {
+ wxIcon* icon = new wxIcon();
+ icon->CopyFromBitmap(bmp);
+ return icon;
+ }
+
+ wxIcon* wxIconFromLocation(const wxIconLocation& loc) {
+ wxIcon* icon = new wxIcon(loc);
+ return icon;
+ }
%}
+
//---------------------------------------------------------------------------
-class wxCursor : public wxGDIObject
+class wxIconLocation
{
public:
+ // ctor takes the name of the file where the icon is
+ %addmethods {
+ wxIconLocation(const wxString* filename = &wxPyEmptyString, int num = 0) {
#ifdef __WXMSW__
- wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
-#endif
- ~wxCursor();
-
- // wxGDIImage methods
-#ifdef __WXMSW__
- long GetHandle();
- void SetHandle(long handle);
-#endif
- bool Ok();
-#ifdef __WXMSW__
- int GetWidth();
- int GetHeight();
- int GetDepth();
- void SetWidth(int w);
- void SetHeight(int h);
- void SetDepth(int d);
- void SetSize(const wxSize& size);
+ return new wxIconLocation(*filename, num);
+#else
+ return new wxIconLocation(*filename);
#endif
-};
-
-%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
-%{ // Alternate 'constructor'
- wxCursor* wxPyStockCursor(int id) {
- return new wxCursor(id);
+ }
}
-%}
-
-//----------------------------------------------------------------------
-
-
-enum wxFontFamily
-{
- wxFONTFAMILY_DEFAULT = wxDEFAULT,
- wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
- wxFONTFAMILY_ROMAN = wxROMAN,
- wxFONTFAMILY_SCRIPT = wxSCRIPT,
- wxFONTFAMILY_SWISS = wxSWISS,
- wxFONTFAMILY_MODERN = wxMODERN,
- wxFONTFAMILY_TELETYPE = wxTELETYPE,
- wxFONTFAMILY_MAX
-};
-// font styles
-enum wxFontStyle
-{
- wxFONTSTYLE_NORMAL = wxNORMAL,
- wxFONTSTYLE_ITALIC = wxITALIC,
- wxFONTSTYLE_SLANT = wxSLANT,
- wxFONTSTYLE_MAX
-};
+ ~wxIconLocation();
-// font weights
-enum wxFontWeight
-{
- wxFONTWEIGHT_NORMAL = wxNORMAL,
- wxFONTWEIGHT_LIGHT = wxLIGHT,
- wxFONTWEIGHT_BOLD = wxBOLD,
- wxFONTWEIGHT_MAX
-};
+ // returns true if this object is valid/initialized
+ bool IsOk() const;
-// font encodings
-enum wxFontEncoding
-{
- wxFONTENCODING_SYSTEM = -1, // system default
- wxFONTENCODING_DEFAULT, // current default encoding
-
- // ISO8859 standard defines a number of single-byte charsets
- wxFONTENCODING_ISO8859_1, // West European (Latin1)
- wxFONTENCODING_ISO8859_2, // Central and East European (Latin2)
- wxFONTENCODING_ISO8859_3, // Esperanto (Latin3)
- wxFONTENCODING_ISO8859_4, // Baltic (old) (Latin4)
- wxFONTENCODING_ISO8859_5, // Cyrillic
- wxFONTENCODING_ISO8859_6, // Arabic
- wxFONTENCODING_ISO8859_7, // Greek
- wxFONTENCODING_ISO8859_8, // Hebrew
- wxFONTENCODING_ISO8859_9, // Turkish (Latin5)
- wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6)
- wxFONTENCODING_ISO8859_11, // Thai
- wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
- // here anyhow to make all ISO8859
- // consecutive numbers
- wxFONTENCODING_ISO8859_13, // Baltic (Latin7)
- wxFONTENCODING_ISO8859_14, // Latin8
- wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro)
- wxFONTENCODING_ISO8859_MAX,
-
- // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
- wxFONTENCODING_KOI8, // we don't support any of KOI8 variants
- wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866
- wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria
-
- // what would we do without Microsoft? They have their own encodings
- // for DOS
- wxFONTENCODING_CP437, // original MS-DOS codepage
- wxFONTENCODING_CP850, // CP437 merged with Latin1
- wxFONTENCODING_CP852, // CP437 merged with Latin2
- wxFONTENCODING_CP855, // another cyrillic encoding
- wxFONTENCODING_CP866, // and another one
- // and for Windows
- wxFONTENCODING_CP874, // WinThai
- wxFONTENCODING_CP932, // Japanese (shift-JIS)
- wxFONTENCODING_CP936, // Chiniese simplified (GB)
- wxFONTENCODING_CP949, // Korean (Hangul charset)
- wxFONTENCODING_CP950, // Chinese (traditional - Big5)
- wxFONTENCODING_CP1250, // WinLatin2
- wxFONTENCODING_CP1251, // WinCyrillic
- wxFONTENCODING_CP1252, // WinLatin1
- wxFONTENCODING_CP1253, // WinGreek (8859-7)
- wxFONTENCODING_CP1254, // WinTurkish
- wxFONTENCODING_CP1255, // WinHebrew
- wxFONTENCODING_CP1256, // WinArabic
- wxFONTENCODING_CP1257, // WinBaltic (same as Latin 7)
- wxFONTENCODING_CP12_MAX,
-
- wxFONTENCODING_UTF7, // UTF-7 Unicode encoding
- wxFONTENCODING_UTF8, // UTF-8 Unicode encoding
-
- wxFONTENCODING_UNICODE, // Unicode - currently used only by
- // wxEncodingConverter class
-
- wxFONTENCODING_MAX
-};
+ // set/get the icon file name
+ void SetFileName(const wxString& filename);
+ const wxString& GetFileName() const;
-
-
-// wxNativeFontInfo is platform-specific font representation: this struct
-// should be considered as opaque font description only used by the native
-// functions, the user code can only get the objects of this type from
-// somewhere and pass it somewhere else (possibly save them somewhere using
-// ToString() and restore them using FromString())
-struct wxNativeFontInfo
-{
-#ifdef __WXGTK__
- // init the elements from an XLFD, return TRUE if ok
- bool FromXFontName(const wxString& xFontName);
-
- // generate an XLFD using the fontElements
- wxString GetXFontName() const;
+ %addmethods {
+ void SetIndex(int num) {
+#ifdef __WXMSW__
+ self->SetIndex(num);
+#else
+ // do nothing
#endif
+ }
- wxNativeFontInfo() { Init(); }
-
- // reset to the default state
- void Init();
-
-#ifndef __WXGTK__
- // accessors and modifiers for the font elements
- int GetPointSize() const;
- wxFontStyle GetStyle() const;
- wxFontWeight GetWeight() const;
- bool GetUnderlined() const;
- wxString GetFaceName() const;
- wxFontFamily GetFamily() const;
- wxFontEncoding GetEncoding() const;
-
- void SetPointSize(int pointsize);
- void SetStyle(wxFontStyle style);
- void SetWeight(wxFontWeight weight);
- void SetUnderlined(bool underlined);
- void SetFaceName(wxString facename);
- void SetFamily(wxFontFamily family);
- void SetEncoding(wxFontEncoding encoding);
+ int GetIndex() {
+#ifdef __WXMSW__
+ return self->GetIndex();
+#else
+ return -1;
#endif
-
- // it is important to be able to serialize wxNativeFontInfo objects to be
- // able to store them (in config file, for example)
- bool FromString(const wxString& s);
- wxString ToString() const;
-
- %addmethods {
- wxString __str__() {
- return self->ToString();
}
}
-
- // we also want to present the native font descriptions to the user in some
- // human-readable form (it is not platform independent neither, but can
- // hopefully be understood by the user)
- bool FromUserString(const wxString& s);
- wxString ToUserString() const;
};
-// wxFontMapper manages user-definable correspondence between logical font
-// names and the fonts present on the machine.
-//
-// The default implementations of all functions will ask the user if they are
-// not capable of finding the answer themselves and store the answer in a
-// config file (configurable via SetConfigXXX functions). This behaviour may
-// be disabled by giving the value of FALSE to "interactive" parameter.
-// However, the functions will always consult the config file to allow the
-// user-defined values override the default logic and there is no way to
-// disable this - which shouldn't be ever needed because if "interactive" was
-// never TRUE, the config file is never created anyhow.
-class wxFontMapper
-{
-public:
- wxFontMapper();
- ~wxFontMapper();
-
-
- // find an alternative for the given encoding (which is supposed to not be
- // available on this system). If successful, return TRUE and rwxFontEcoding
- // that can be used it wxFont ctor otherwise return FALSE
- //bool GetAltForEncoding(wxFontEncoding encoding,
- // wxFontEncoding *alt_encoding,
- // const wxString& facename = wxEmptyString,
- // bool interactive = TRUE);
-
-
- // Find an alternative for the given encoding (which is supposed to not be
- // available on this system). If successful, returns the encoding otherwise
- // returns None.
- %addmethods {
- PyObject* GetAltForEncoding(wxFontEncoding encoding,
- const wxString& facename = wxEmptyString,
- bool interactive = TRUE) {
- wxFontEncoding alt_enc;
- if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
- return PyInt_FromLong(alt_enc);
- else {
- Py_INCREF(Py_None);
- return Py_None;
- }
- }
- }
-
-
- // checks whether given encoding is available in given face or not.
- // If no facename is given,
- bool IsEncodingAvailable(wxFontEncoding encoding,
- const wxString& facename = wxEmptyString);
- // returns the encoding for the given charset (in the form of RFC 2046) or
- // wxFONTENCODING_SYSTEM if couldn't decode it
- wxFontEncoding CharsetToEncoding(const wxString& charset,
- bool interactive = TRUE);
-
- // return internal string identifier for the encoding (see also
- // GetEncodingDescription())
- static wxString GetEncodingName(wxFontEncoding encoding);
-
- // return user-readable string describing the given encoding
- //
- // NB: hard-coded now, but might change later (read it from config?)
- static wxString GetEncodingDescription(wxFontEncoding encoding);
+//---------------------------------------------------------------------------
- // the parent window for modal dialogs
- void SetDialogParent(wxWindow *parent);
+class wxIconBundle
+{
+public:
+ // default constructor
+ wxIconBundle();
- // the title for the dialogs (note that default is quite reasonable)
- void SetDialogTitle(const wxString& title);
+ // initializes the bundle with the icon(s) found in the file
+ %name(wxIconBundleFromFile) wxIconBundle( const wxString& file, long type );
- // functions which allow to configure the config object used: by default,
- // the global one (from wxConfigBase::Get() will be used) and the default
- // root path for the config settings is the string returned by
- // GetDefaultConfigPath()
+ // initializes the bundle with a single icon
+ %name(wxIconBundleFromIcon)wxIconBundle( const wxIcon& icon );
+ ~wxIconBundle();
- // set the config object to use (may be NULL to use default)
- void SetConfig(wxConfigBase *config);
+ // adds the icon to the collection, if the collection already
+ // contains an icon with the same width and height, it is
+ // replaced
+ void AddIcon( const wxIcon& icon );
- // set the root config path to use (should be an absolute path)
- void SetConfigPath(const wxString& prefix);
+ // adds all the icons contained in the file to the collection,
+ // if the collection already contains icons with the same
+ // width and height, they are replaced
+ %name(AddIconFromFile)void AddIcon( const wxString& file, long type );
- // return default config path
- static const wxChar *GetDefaultConfigPath();
+ // returns the icon with the given size; if no such icon exists,
+ // returns the icon with size wxSYS_ICON_[XY]; if no such icon exists,
+ // returns the first icon in the bundle
+ const wxIcon& GetIcon( const wxSize& size ) const;
};
+//---------------------------------------------------------------------------
-
-
-class wxFont : public wxGDIObject {
+class wxCursor : public wxGDIObject
+{
public:
- wxFont( int pointSize, int family, int style, int weight,
- int underline=FALSE, char* faceName = "",
- wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
-
- %name(wxFontFromNativeInfo)wxFont(const wxNativeFontInfo& info);
-
- ~wxFont();
-
- bool Ok() const;
- int GetPointSize() const;
- int GetFamily() const;
- int GetStyle() const;
- int GetWeight() const;
- bool GetUnderlined() const;
- wxString GetFaceName() const;
- wxFontEncoding GetEncoding() const;
-
- bool IsFixedWidth();
-
- wxNativeFontInfo* GetNativeFontInfo() const;
- wxString GetNativeFontInfoDesc() const;
- wxString GetNativeFontInfoUserDesc() const;
-
- void SetPointSize(int pointSize);
- void SetFamily(int family);
- void SetStyle(int style);
- void SetWeight(int weight);
- void SetFaceName(const wxString& faceName);
- void SetUnderlined(bool underlined);
- void SetEncoding(wxFontEncoding encoding);
- void SetNativeFontInfo(const wxNativeFontInfo& info);
- // void SetNativeFontInfo(const wxString& info);
- void SetNativeFontInfoUserDesc(const wxString& info);
-
- wxString GetFamilyString() const;
- wxString GetStyleString() const;
- wxString GetWeightString() const;
+ %addmethods {
+ wxCursor(const wxString* cursorName, long flags, int hotSpotX=0, int hotSpotY=0) {
+#ifdef __WXGTK__
+ wxCHECK_MSG(FALSE, NULL,
+ wxT("wxCursor constructor not implemented for wxGTK, use wxStockCursor, wxCursorFromImage, or wxCursorFromBits instead."));
+#else
+ return new wxCursor(*cursorName, flags, hotSpotX, hotSpotY);
+#endif
+ }
+ }
- static wxFontEncoding GetDefaultEncoding();
- static void SetDefaultEncoding(wxFontEncoding encoding);
+ ~wxCursor();
+ // wxGDIImage methods
+#ifdef __WXMSW__
+ long GetHandle();
+ void SetHandle(long handle);
+#endif
+ bool Ok();
+#ifdef __WXMSW__
+ int GetWidth();
+ int GetHeight();
+ int GetDepth();
+ void SetWidth(int w);
+ void SetHeight(int h);
+ void SetDepth(int d);
+ void SetSize(const wxSize& size);
+#endif
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
+%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
+%new wxCursor* wxCursorFromImage(const wxImage& image);
+%new wxCursor* wxCursorFromBits(PyObject* bits, int width, int height,
+ int hotSpotX=-1, int hotSpotY=-1,
+ PyObject* maskBits=0);
-class wxFontList : public wxObject {
-public:
-
- void AddFont(wxFont* font);
- wxFont * FindOrCreateFont(int point_size, int family, int style, int weight,
- bool underline = FALSE, const char* facename = NULL,
- wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
- void RemoveFont(wxFont *font);
+%{
+ wxCursor* wxPyStockCursor(int id) {
+ return new wxCursor(id);
+ }
- int GetCount();
-};
+ wxCursor* wxCursorFromImage(const wxImage& image) {
+ return new wxCursor(image);
+ }
+ wxCursor* wxCursorFromBits(PyObject* bits, int width, int height,
+ int hotSpotX=-1, int hotSpotY=-1,
+ PyObject* maskBits=0) {
+ char* bitsbuf;
+ char* maskbuf = NULL;
+ int length;
+ PyString_AsStringAndSize(bits, &bitsbuf, &length);
+ if (maskBits)
+ PyString_AsStringAndSize(maskBits, &maskbuf, &length);
+ return new wxCursor(bitsbuf, width, height, hotSpotX, hotSpotY, maskbuf);
+ }
+%}
//----------------------------------------------------------------------
%addmethods {
PyObject* Get() {
PyObject* rv = PyTuple_New(3);
- PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
- PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
- PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
+ int red = -1;
+ int green = -1;
+ int blue = -1;
+ if (self->Ok()) {
+ red = self->Red();
+ green = self->Green();
+ blue = self->Blue();
+ }
+ PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
+ PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
+ PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
return rv;
}
+ bool __eq__(PyObject* obj) {
+ wxColour tmp;
+ wxColour* ptr = &tmp;
+ if (obj == Py_None) return FALSE;
+ wxPyBLOCK_THREADS(bool success = wxColour_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return FALSE;
+ return *self == *ptr;
+ }
+ bool __ne__(PyObject* obj) {
+ wxColour tmp;
+ wxColour* ptr = &tmp;
+ if (obj == Py_None) return TRUE;
+ wxPyBLOCK_THREADS(bool success = wxColour_helper(obj, &ptr); PyErr_Clear());
+ if (! success) return TRUE;
+ return *self != *ptr;
+ }
}
- %pragma(python) addtoclass = "asTuple = Get"
- %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
- %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
+
+ %pragma(python) addtoclass = "asTuple = Get
+ def __str__(self): return str(self.asTuple())
+ def __repr__(self): return 'wxColour:' + str(self.asTuple())
+ def __nonzero__(self): return self.Ok()
+ def __getinitargs__(self): return ()
+ def __getstate__(self): return self.asTuple()
+ def __setstate__(self, state): self.Set(*state)
+"
};
class wxColourDatabase : public wxObject {
public:
- wxColour *FindColour(const wxString& colour);
+ wxColour *FindColour(const wxString& colour) ;
+ wxColour *FindColourNoAdd(const wxString& colour) const;
wxString FindName(const wxColour& colour) const;
%addmethods {
+ void AddColour(const wxString& name, wxColour* colour) {
+ // make a copy since the python one will be GC'd
+ wxColour* c = new wxColour(*colour);
+ self->AddColour(name, c);
+ }
+
void Append(const wxString& name, int red, int green, int blue) {
- self->Append(name.c_str(), new wxColour(red, green, blue));
+ wxColour* c = new wxColour(red, green, blue);
+ self->AddColour(name, c);
}
}
};
void SetStyle(int style);
void SetWidth(int width);
- // **** This one needs to return a list of ints (wxDash)
- //int GetDashes(wxDash **dashes);
+
void SetDashes(int LCOUNT, wxDash* choices);
+ //int GetDashes(wxDash **dashes);
+ %addmethods {
+ PyObject* GetDashes() {
+ wxDash* dashes;
+ int count = self->GetDashes(&dashes);
+ wxPyBeginBlockThreads();
+ PyObject* retval = PyList_New(0);
+ for (int x=0; x<count; x++)
+ PyList_Append(retval, PyInt_FromLong(dashes[x]));
+ wxPyEndBlockThreads();
+ return retval;
+ }
+ }
#ifdef __WXMSW__
wxBitmap* GetStipple();
void SetStipple(wxBitmap& stipple);
#endif
+
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
void SetColour(wxColour &colour);
void SetStipple(wxBitmap& bitmap);
void SetStyle(int style);
+
+#ifdef __WXMAC__
+ short GetMacTheme();
+ void SetMacTheme(short macThemeBrush);
+#endif
+
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
//----------------------------------------------------------------------
-
class wxDC : public wxObject {
public:
// wxDC(); **** abstract base class, can't instantiate.
~wxDC();
void BeginDrawing();
+
// %name(BlitXY)
- bool Blit(long xdest, long ydest,
- long width, long height,
- wxDC *source, long xsrc, long ysrc,
+ bool Blit(wxCoord xdest, wxCoord ydest,
+ wxCoord width, wxCoord height,
+ wxDC *source, wxCoord xsrc, wxCoord ysrc,
int logicalFunc = wxCOPY, int useMask = FALSE);
// bool Blit(const wxPoint& destPt, const wxSize& sz,
// wxDC *source, const wxPoint& srcPt,
// int logicalFunc = wxCOPY, int useMask = FALSE);
void Clear();
- void CrossHair(long x, long y);
+ void CrossHair(wxCoord x, wxCoord y);
void DestroyClippingRegion();
- long DeviceToLogicalX(long x);
- long DeviceToLogicalXRel(long x);
- long DeviceToLogicalY(long y);
- long DeviceToLogicalYRel(long y);
- void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
- void DrawCircle(long x, long y, long radius);
- void DrawEllipse(long x, long y, long width, long height);
- void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
- void DrawIcon(const wxIcon& icon, long x, long y);
- void DrawLine(long x1, long y1, long x2, long y2);
- void DrawLines(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0);
- void DrawPolygon(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0,
+ wxCoord DeviceToLogicalX(wxCoord x);
+ wxCoord DeviceToLogicalXRel(wxCoord x);
+ wxCoord DeviceToLogicalY(wxCoord y);
+ wxCoord DeviceToLogicalYRel(wxCoord y);
+ void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
+ void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
+ void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+ void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxCoord start, wxCoord end);
+ void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
+
+ void DrawLabel(const wxString& text, const wxRect& rect,
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+ int indexAccel = -1);
+
+ %addmethods {
+ wxRect DrawImageLabel(const wxString& text,
+ const wxBitmap& image,
+ const wxRect& rect,
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+ int indexAccel = -1) {
+ wxRect rv;
+ self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
+ return rv;
+ }
+ }
+
+ void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
+ void DrawLines(int PCOUNT, wxPoint* points, wxCoord xoffset=0, wxCoord yoffset=0);
+ void DrawPolygon(int PCOUNT, wxPoint* points, wxCoord xoffset=0, wxCoord yoffset=0,
int fill_style=wxODDEVEN_RULE);
- void DrawPoint(long x, long y);
- void DrawRectangle(long x, long y, long width, long height);
+ void DrawPoint(wxCoord x, wxCoord y);
+ void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+ %name(DrawRectangleRect)void DrawRectangle(const wxRect& rect);
void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
- void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
+ void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxCoord radius=20);
void DrawSpline(int PCOUNT, wxPoint* points);
- void DrawText(const wxString& text, long x, long y);
+ void DrawText(const wxString& text, wxCoord x, wxCoord y);
void EndDoc();
void EndDrawing();
void EndPage();
- void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
+ bool FloodFill(wxCoord x, wxCoord y, const wxColour& colour, int style=wxFLOOD_SURFACE);
wxBrush GetBackground();
wxBrush GetBrush();
- long GetCharHeight();
- long GetCharWidth();
- void GetClippingBox(long *OUTPUT, long *OUTPUT,
- long *OUTPUT, long *OUTPUT);
+ wxCoord GetCharHeight();
+ wxCoord GetCharWidth();
+ void GetClippingBox(wxCoord *OUTPUT, wxCoord *OUTPUT,
+ wxCoord *OUTPUT, wxCoord *OUTPUT);
wxFont GetFont();
int GetLogicalFunction();
void GetLogicalScale(double *OUTPUT, double *OUTPUT);
bool GetOptimization();
wxPen GetPen();
%addmethods {
- %new wxColour* GetPixel(long x, long y) {
+ %new wxColour* GetPixel(wxCoord x, wxCoord y) {
wxColour* wc = new wxColour();
self->GetPixel(x, y, wc);
return wc;
wxSize GetSize();
wxSize GetSizeMM();
wxColour GetTextBackground();
- void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
+ void GetTextExtent(const wxString& string, wxCoord *OUTPUT, wxCoord *OUTPUT);
%name(GetFullTextExtent)void GetTextExtent(const wxString& string,
- long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT,
+ wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord* OUTPUT,
const wxFont* font = NULL);
+ void GetMultiLineTextExtent(const wxString& text, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT,
+ wxFont *font = NULL);
wxColour GetTextForeground();
void GetUserScale(double *OUTPUT, double *OUTPUT);
- long LogicalToDeviceX(long x);
- long LogicalToDeviceXRel(long x);
- long LogicalToDeviceY(long y);
- long LogicalToDeviceYRel(long y);
- long MaxX();
- long MaxY();
- long MinX();
- long MinY();
+ wxCoord LogicalToDeviceX(wxCoord x);
+ wxCoord LogicalToDeviceXRel(wxCoord x);
+ wxCoord LogicalToDeviceY(wxCoord y);
+ wxCoord LogicalToDeviceYRel(wxCoord y);
+ wxCoord MaxX();
+ wxCoord MaxY();
+ wxCoord MinX();
+ wxCoord MinY();
bool Ok();
- void SetDeviceOrigin(long x, long y);
+ void SetDeviceOrigin(wxCoord x, wxCoord y);
void SetBackground(const wxBrush& brush);
void SetBackgroundMode(int mode);
- void SetClippingRegion(long x, long y, long width, long height);
+ void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
%name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
+ %name(SetClippingRect) void SetClippingRegion(const wxRect& rect);
void SetPalette(const wxPalette& colourMap);
void SetBrush(const wxBrush& brush);
void SetFont(const wxFont& font);
- void DrawBitmap(const wxBitmap& bitmap, long x, long y,
+ void DrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y,
int useMask = FALSE);
bool CanDrawBitmap();
// See below for implementation
}
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
+
#ifdef __WXMSW__
long GetHDC();
#endif
- %addmethods {
- // NOTE: These methods are VERY SIMILAR in implentation. It would be
- // nice to factor out common code and or turn them into a set of
- // template-like macros.
-
- // Draw a point for every set of coordinants in pyPoints, optionally
- // setting a new pen for each
- PyObject* _DrawPointList(PyObject* pyPoints, PyObject* pyPens) {
- bool isFastSeq = PyList_Check(pyPoints) || PyTuple_Check(pyPoints);
- bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
- int numObjs = 0;
- int numPens = 0;
- wxPen* pen;
- PyObject* obj;
- int x1, y1;
- int i = 0;
-
- if (!PySequence_Check(pyPoints)) {
- goto err0;
- }
- if (!PySequence_Check(pyPens)) {
- goto err1;
- }
- numObjs = PySequence_Length(pyPoints);
- numPens = PySequence_Length(pyPens);
-
- for (i = 0; i < numObjs; i++) {
- // Use a new pen?
- if (i < numPens) {
- if (isFastPens) {
- obj = PySequence_Fast_GET_ITEM(pyPens, i);
- }
- else {
- obj = PySequence_GetItem(pyPens, i);
- }
- if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) {
- if (!isFastPens)
- Py_DECREF(obj);
- goto err1;
- }
-
- self->SetPen(*pen);
- if (!isFastPens)
- Py_DECREF(obj);
- }
-
- // Get the point coordinants
- if (isFastSeq) {
- obj = PySequence_Fast_GET_ITEM(pyPoints, i);
- }
- else {
- obj = PySequence_GetItem(pyPoints, i);
- }
- if (! _2int_seq_helper(obj, &x1, &y1)) {
- if (!isFastPens)
- Py_DECREF(obj);
- goto err0;
- }
-
- // Now draw the point
- self->DrawPoint(x1, y1);
-
- if (!isFastSeq)
- Py_DECREF(obj);
- }
+ %addmethods { // See drawlist.cpp for impplementaion of these...
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject* _DrawPointList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+ {
+ return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
+ }
- err1:
- PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
- return NULL;
- err0:
- PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
- return NULL;
+ PyObject* _DrawLineList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+ {
+ return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
}
+ PyObject* _DrawRectangleList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+ {
+ return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
+ }
- // Draw a line for every set of coordinants in pyLines, optionally
- // setting a new pen for each
- PyObject* _DrawLineList(PyObject* pyLines, PyObject* pyPens) {
- bool isFastSeq = PyList_Check(pyLines) || PyTuple_Check(pyLines);
- bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
- int numObjs = 0;
- int numPens = 0;
- wxPen* pen;
- PyObject* obj;
- int x1, y1, x2, y2;
- int i = 0;
-
- if (!PySequence_Check(pyLines)) {
- goto err0;
- }
- if (!PySequence_Check(pyPens)) {
- goto err1;
- }
- numObjs = PySequence_Length(pyLines);
- numPens = PySequence_Length(pyPens);
-
- for (i = 0; i < numObjs; i++) {
- // Use a new pen?
- if (i < numPens) {
- if (isFastPens) {
- obj = PySequence_Fast_GET_ITEM(pyPens, i);
- }
- else {
- obj = PySequence_GetItem(pyPens, i);
- }
- if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) {
- if (!isFastPens)
- Py_DECREF(obj);
- goto err1;
- }
-
- self->SetPen(*pen);
- if (!isFastPens)
- Py_DECREF(obj);
- }
-
- // Get the line coordinants
- if (isFastSeq) {
- obj = PySequence_Fast_GET_ITEM(pyLines, i);
- }
- else {
- obj = PySequence_GetItem(pyLines, i);
- }
- if (! _4int_seq_helper(obj, &x1, &y1, &x2, &y2)) {
- if (!isFastPens)
- Py_DECREF(obj);
- goto err0;
- }
-
- // Now draw the line
- self->DrawLine(x1, y1, x2, y2);
-
- if (!isFastSeq)
- Py_DECREF(obj);
- }
+ PyObject* _DrawEllipseList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+ {
+ return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
+ }
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject* _DrawPolygonList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+ {
+ return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
+ }
- err1:
- PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
- return NULL;
- err0:
- PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x2,y2) sequences.");
- return NULL;
+ PyObject* _DrawTextList(PyObject* textList, PyObject* pyPoints,
+ PyObject* foregroundList, PyObject* backgroundList) {
+ return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
}
}
-
%pragma(python) addtoclass = "
def DrawPointList(self, points, pens=None):
if pens is None:
pens = [pens]
elif len(pens) != len(points):
raise ValueError('points and pens must have same length')
- return self._DrawPointList(points, pens)
+ return self._DrawPointList(points, pens, [])
+
def DrawLineList(self, lines, pens=None):
if pens is None:
pens = [pens]
elif len(pens) != len(lines):
raise ValueError('lines and pens must have same length')
- return self._DrawLineList(lines, pens)
+ return self._DrawLineList(lines, pens, [])
+
+
+ def DrawRectangleList(self, rectangles, pens=None, brushes=None):
+ if pens is None:
+ pens = []
+ elif isinstance(pens, wxPenPtr):
+ pens = [pens]
+ elif len(pens) != len(rectangles):
+ raise ValueError('rectangles and pens must have same length')
+ if brushes is None:
+ brushes = []
+ elif isinstance(brushes, wxBrushPtr):
+ brushes = [brushes]
+ elif len(brushes) != len(rectangles):
+ raise ValueError('rectangles and brushes must have same length')
+ return self._DrawRectangleList(rectangles, pens, brushes)
+
+
+ def DrawEllipseList(self, ellipses, pens=None, brushes=None):
+ if pens is None:
+ pens = []
+ elif isinstance(pens, wxPenPtr):
+ pens = [pens]
+ elif len(pens) != len(ellipses):
+ raise ValueError('ellipses and pens must have same length')
+ if brushes is None:
+ brushes = []
+ elif isinstance(brushes, wxBrushPtr):
+ brushes = [brushes]
+ elif len(brushes) != len(ellipses):
+ raise ValueError('ellipses and brushes must have same length')
+ return self._DrawEllipseList(ellipses, pens, brushes)
+
+
+ def DrawPolygonList(self, polygons, pens=None, brushes=None):
+ ## Note: This does not currently support fill style or offset
+ ## you can always use the non-List version if need be.
+ ## I really would like to support fill-style, however,
+ ## but wxODDEVEN_RULE does not appear to be defined at the Python level
+ ## [It's in wx.py... --Robin]
+ if pens is None:
+ pens = []
+ elif isinstance(pens, wxPenPtr):
+ pens = [pens]
+ elif len(pens) != len(polygons):
+ raise ValueError('polygons and pens must have same length')
+ if brushes is None:
+ brushes = []
+ elif isinstance(brushes, wxBrushPtr):
+ brushes = [brushes]
+ elif len(brushes) != len(polygons):
+ raise ValueError('polygons and brushes must have same length')
+ return self._DrawPolygonList(polygons, pens, brushes)
+
+
+ def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None, fonts = None):
+ ## NOTE: this does not currently support changing the font
+ ## Make sure you set Background mode to wxSolid (DC.SetBackgroundMode)
+ ## If you want backgounds to do anything.
+ if type(textList) == type(''):
+ textList = [textList]
+ elif len(textList) != len(coords):
+ raise ValueError('textlist and coords must have same length')
+ if foregrounds is None:
+ foregrounds = []
+ elif isinstance(foregrounds, wxColourPtr):
+ foregrounds = [foregrounds]
+ elif len(foregrounds) != len(coords):
+ raise ValueError('foregrounds and coords must have same length')
+ if backgrounds is None:
+ backgrounds = []
+ elif isinstance(backgrounds, wxColourPtr):
+ backgrounds = [backgrounds]
+ elif len(backgrounds) != len(coords):
+ raise ValueError('backgrounds and coords must have same length')
+ return self._DrawTextList(textList, coords, foregrounds, backgrounds)
"
%}
+//---------------------------------------------------------------------------
+
+class wxBufferedDC : public wxMemoryDC {
+public:
+ // Construct a wxBufferedDC using a user supplied buffer.
+ wxBufferedDC( wxDC *dc, const wxBitmap &buffer );
+
+ // Construct a wxBufferedDC with an internal buffer of 'area'
+ // (where area is usually something like the size of the window
+ // being buffered)
+ %name(wxBufferedDCInternalBuffer)wxBufferedDC( wxDC *dc, const wxSize &area );
+
+ // Blits the buffer to the dc, and detaches the dc from
+ // the buffer. Usually called in the dtor or by the dtor
+ // of derived classes if the BufferedDC must blit before
+ // the derived class (which may own the dc it's blitting
+ // to) is destroyed.
+ void UnMask();
+
+
+ %pragma(python) addtomethod =
+ "__init__:self._dc = _args[0] # save a ref so the other dc won't be deleted before self"
+ %pragma(python) addtomethod =
+ "wxBufferedDCInternalBuffer:val._dc = _args[0] # save a ref so the other dc won't be deleted before self"
+};
+
+
+class wxBufferedPaintDC : public wxBufferedDC
+{
+public:
+ wxBufferedPaintDC( wxWindow *window, const wxBitmap &buffer = wxNullBitmap );
+};
+
//---------------------------------------------------------------------------
class wxScreenDC : public wxDC {
//---------------------------------------------------------------------------
+class wxMirrorDC : public wxDC
+{
+public:
+ // constructs a mirror DC associated with the given real DC
+ //
+ // if mirror parameter is true, all vertical and horizontal coordinates are
+ // exchanged, otherwise this class behaves in exactly the same way as a
+ // plain DC
+ //
+ wxMirrorDC(wxDC& dc, bool mirror);
+};
+
+//---------------------------------------------------------------------------
+
#ifdef __WXMSW__
class wxMetaFile : public wxObject {
public:
- wxMetaFile(const wxString& filename = wxPyEmptyStr);
+ wxMetaFile(const wxString& filename = wxPyEmptyString);
~wxMetaFile();
bool Ok();
const wxString& GetFileName() const { return m_filename; }
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
// bool wxMakeMetaFilePlaceable(const wxString& filename,
class wxMetaFileDC : public wxDC {
public:
- wxMetaFileDC(const wxString& filename = wxPyEmptyStr,
+ wxMetaFileDC(const wxString& filename = wxPyEmptyString,
int width = 0, int height = 0,
- const wxString& description = wxPyEmptyStr);
+ const wxString& description = wxPyEmptyString);
wxMetaFile* Close();
};
int GetPixel(byte red, byte green, byte blue);
bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
bool Ok();
+
+ %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
};
//---------------------------------------------------------------------------
class wxRegion : public wxGDIObject {
public:
- wxRegion(long x=0, long y=0, long width=0, long height=0);
+ wxRegion(wxCoord x=0, wxCoord y=0, wxCoord width=0, wxCoord height=0);
+#ifndef __WXMAC__
+ %name(wxRegionFromPoints)wxRegion(int PCOUNT, wxPoint* points, int fillStyle = wxWINDING_RULE);
+#endif
+ %name(wxRegionFromBitmap)wxRegion(const wxBitmap& bmp,
+ const wxColour& transColour = wxNullColour,
+ int tolerance = 0);
~wxRegion();
+
void Clear();
- wxRegionContain Contains(long x, long y);
+#ifndef __WXMAC__
+ bool Offset(wxCoord x, wxCoord y);
+#endif
+
+ wxRegionContain Contains(wxCoord x, wxCoord y);
%name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
%name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
- %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h);
+ %name(ContainsRectDim)wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
wxRect GetBox();
- bool Intersect(long x, long y, long width, long height);
+ bool Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
%name(IntersectRect)bool Intersect(const wxRect& rect);
%name(IntersectRegion)bool Intersect(const wxRegion& region);
bool IsEmpty();
- bool Union(long x, long y, long width, long height);
+ bool Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
%name(UnionRect)bool Union(const wxRect& rect);
%name(UnionRegion)bool Union(const wxRegion& region);
- bool Subtract(long x, long y, long width, long height);
+ bool Subtract(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
%name(SubtractRect)bool Subtract(const wxRect& rect);
%name(SubtractRegion)bool Subtract(const wxRegion& region);
- bool Xor(long x, long y, long width, long height);
+ bool Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
%name(XorRect)bool Xor(const wxRect& rect);
%name(XorRegion)bool Xor(const wxRegion& region);
+
+ // Convert the region to a B&W bitmap with the white pixels being inside
+ // the region.
+ wxBitmap ConvertToBitmap();
+
+ // Use the non-transparent pixels of a wxBitmap for the region to combine
+ // with this region. If the bitmap has a mask then it will be used,
+ // otherwise the colour to be treated as transparent may be specified,
+ // along with an optional tolerance value.
+ %name(UnionBitmap)bool Union(const wxBitmap& bmp,
+ const wxColour& transColour = wxNullColour,
+ int tolerance = 0);
};
wxRegionIterator(const wxRegion& region);
~wxRegionIterator();
- long GetX();
- long GetY();
- long GetW();
- long GetWidth();
- long GetH();
- long GetHeight();
+ wxCoord GetX();
+ wxCoord GetY();
+ wxCoord GetW();
+ wxCoord GetWidth();
+ wxCoord GetH();
+ wxCoord GetHeight();
wxRect GetRect();
bool HaveRects();
void Reset();
//---------------------------------------------------------------------------
+
%readonly
%{
#if 0
%}
+// See also wxPy_ReinitStockObjects in helpers.cpp
+
extern wxFont *wxNORMAL_FONT;
extern wxFont *wxSMALL_FONT;
extern wxFont *wxITALIC_FONT;
projects / wxWidgets.git / blobdiff