X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/00360d4699d23a01c1c62d5d1c128bd9739a239d..05fd1c9e8e20e959f894ecc300ee40232de38377:/wxPython/src/mac/gdi.py?ds=sidebyside diff --git a/wxPython/src/mac/gdi.py b/wxPython/src/mac/gdi.py index 292e3e7a57..cfeb50db23 100644 --- a/wxPython/src/mac/gdi.py +++ b/wxPython/src/mac/gdi.py @@ -1,1353 +1,3347 @@ # This file was created automatically by SWIG. -import gdic +# Don't modify this file, modify the SWIG interface instead. -from misc import * -class wxGDIObjectPtr(wxObjectPtr): - def __init__(self,this): +import _gdi + +import core +wx = core +#--------------------------------------------------------------------------- + +class GDIObject(core.Object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxGDIObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> GDIObject""" + newobj = _gdi.new_GDIObject(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_GDIObject): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def GetVisible(*args, **kwargs): + """GetVisible() -> bool""" + return _gdi.GDIObject_GetVisible(*args, **kwargs) + + def SetVisible(*args, **kwargs): + """SetVisible(bool visible)""" + return _gdi.GDIObject_SetVisible(*args, **kwargs) + + def IsNull(*args, **kwargs): + """IsNull() -> bool""" + return _gdi.GDIObject_IsNull(*args, **kwargs) + + +class GDIObjectPtr(GDIObject): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxGDIObject(self) - def GetVisible(self, *_args, **_kwargs): - val = apply(gdic.wxGDIObject_GetVisible,(self,) + _args, _kwargs) - return val - def SetVisible(self, *_args, **_kwargs): - val = apply(gdic.wxGDIObject_SetVisible,(self,) + _args, _kwargs) - return val - def IsNull(self, *_args, **_kwargs): - val = apply(gdic.wxGDIObject_IsNull,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = GDIObject +_gdi.GDIObject_swigregister(GDIObjectPtr) + +#--------------------------------------------------------------------------- + +class Colour(core.Object): def __repr__(self): - return "" % (self.this,) -class wxGDIObject(wxGDIObjectPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxGDIObject,_args,_kwargs) + return "<%s.%s; proxy of C++ wxColour instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(unsigned char red=0, unsigned char green=0, unsigned char blue=0) -> Colour""" + newobj = _gdi.new_Colour(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Colour): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Red(*args, **kwargs): + """Red() -> unsigned char""" + return _gdi.Colour_Red(*args, **kwargs) + + def Green(*args, **kwargs): + """Green() -> unsigned char""" + return _gdi.Colour_Green(*args, **kwargs) + + def Blue(*args, **kwargs): + """Blue() -> unsigned char""" + return _gdi.Colour_Blue(*args, **kwargs) + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Colour_Ok(*args, **kwargs) + + def Set(*args, **kwargs): + """Set(unsigned char red, unsigned char green, unsigned char blue)""" + return _gdi.Colour_Set(*args, **kwargs) + + def SetRGB(*args, **kwargs): + """SetRGB(unsigned long colRGB)""" + return _gdi.Colour_SetRGB(*args, **kwargs) + def __eq__(*args, **kwargs): + """__eq__(Colour colour) -> bool""" + return _gdi.Colour___eq__(*args, **kwargs) + def __ne__(*args, **kwargs): + """__ne__(Colour colour) -> bool""" + return _gdi.Colour___ne__(*args, **kwargs) + def InitFromName(*args, **kwargs): + """InitFromName(String colourName)""" + return _gdi.Colour_InitFromName(*args, **kwargs) -class wxBitmapPtr(wxGDIObjectPtr): - def __init__(self,this): + def Get(*args, **kwargs): + """Get() -> PyObject""" + return _gdi.Colour_Get(*args, **kwargs) + + asTuple = Get + def __str__(self): return str(self.asTuple()) + def __repr__(self): return 'wx.Colour' + str(self.asTuple()) + def __nonzero__(self): return self.Ok() + __safe_for_unpickling__ = True + def __reduce__(self): return (Colour, self.Get()) + + +class ColourPtr(Colour): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxBitmap(self) - def GetPalette(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetPalette,(self,) + _args, _kwargs) - if val: val = wxPalettePtr(val) - return val - def GetMask(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetMask,(self,) + _args, _kwargs) - if val: val = wxMaskPtr(val) - return val - def LoadFile(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_LoadFile,(self,) + _args, _kwargs) - return val - def SaveFile(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_SaveFile,(self,) + _args, _kwargs) - return val - def SetMask(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_SetMask,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_Ok,(self,) + _args, _kwargs) - return val - def GetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetWidth,(self,) + _args, _kwargs) - return val - def GetHeight(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetHeight,(self,) + _args, _kwargs) - return val - def GetDepth(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetDepth,(self,) + _args, _kwargs) - return val - def SetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_SetWidth,(self,) + _args, _kwargs) - return val - def SetHeight(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_SetHeight,(self,) + _args, _kwargs) - return val - def SetDepth(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_SetDepth,(self,) + _args, _kwargs) - return val - def GetSubBitmap(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_GetSubBitmap,(self,) + _args, _kwargs) - if val: val = wxBitmapPtr(val) ; val.thisown = 1 - return val - def CopyFromIcon(self, *_args, **_kwargs): - val = apply(gdic.wxBitmap_CopyFromIcon,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Colour +_gdi.Colour_swigregister(ColourPtr) + +def NamedColour(*args, **kwargs): + """NamedColour(String colorName) -> Colour""" + val = _gdi.new_NamedColour(*args, **kwargs) + val.thisown = 1 + return val + +def ColourRGB(*args, **kwargs): + """ColourRGB(unsigned long colRGB) -> Colour""" + val = _gdi.new_ColourRGB(*args, **kwargs) + val.thisown = 1 + return val + +class Palette(GDIObject): def __repr__(self): - return "" % (self.this,) - - def __del__(self,gdic=gdic): + return "<%s.%s; proxy of C++ wxPalette instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(int n, unsigned char red, unsigned char green, unsigned char blue) -> Palette""" + newobj = _gdi.new_Palette(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Palette): + """__del__()""" try: - if self.thisown == 1 : - gdic.delete_wxBitmap(self) - except: - pass - -class wxBitmap(wxBitmapPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxBitmap,_args,_kwargs) + if self.thisown: destroy(self) + except: pass + + def GetPixel(*args, **kwargs): + """GetPixel(byte red, byte green, byte blue) -> int""" + return _gdi.Palette_GetPixel(*args, **kwargs) + + def GetRGB(*args, **kwargs): + """GetRGB(int pixel) -> (R,G,B)""" + return _gdi.Palette_GetRGB(*args, **kwargs) + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Palette_Ok(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class PalettePtr(Palette): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Palette +_gdi.Palette_swigregister(PalettePtr) + +#--------------------------------------------------------------------------- + +class Pen(GDIObject): + def __repr__(self): + return "<%s.%s; proxy of C++ wxPen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Colour colour, int width=1, int style=SOLID) -> Pen""" + newobj = _gdi.new_Pen(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Pen): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + def GetCap(*args, **kwargs): + """GetCap() -> int""" + return _gdi.Pen_GetCap(*args, **kwargs) + def GetColour(*args, **kwargs): + """GetColour() -> Colour""" + return _gdi.Pen_GetColour(*args, **kwargs) + def GetJoin(*args, **kwargs): + """GetJoin() -> int""" + return _gdi.Pen_GetJoin(*args, **kwargs) -class wxMaskPtr(wxObjectPtr): - def __init__(self,this): + def GetStyle(*args, **kwargs): + """GetStyle() -> int""" + return _gdi.Pen_GetStyle(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """GetWidth() -> int""" + return _gdi.Pen_GetWidth(*args, **kwargs) + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Pen_Ok(*args, **kwargs) + + def SetCap(*args, **kwargs): + """SetCap(int cap_style)""" + return _gdi.Pen_SetCap(*args, **kwargs) + + def SetColour(*args, **kwargs): + """SetColour(Colour colour)""" + return _gdi.Pen_SetColour(*args, **kwargs) + + def SetJoin(*args, **kwargs): + """SetJoin(int join_style)""" + return _gdi.Pen_SetJoin(*args, **kwargs) + + def SetStyle(*args, **kwargs): + """SetStyle(int style)""" + return _gdi.Pen_SetStyle(*args, **kwargs) + + def SetWidth(*args, **kwargs): + """SetWidth(int width)""" + return _gdi.Pen_SetWidth(*args, **kwargs) + + def SetDashes(*args, **kwargs): + """SetDashes(int dashes, wxDash dashes_array)""" + return _gdi.Pen_SetDashes(*args, **kwargs) + + def GetDashes(*args, **kwargs): + """GetDashes() -> PyObject""" + return _gdi.Pen_GetDashes(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class PenPtr(Pen): + def __init__(self, this): self.this = this - self.thisown = 0 - def Destroy(self, *_args, **_kwargs): - val = apply(gdic.wxMask_Destroy,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Pen +_gdi.Pen_swigregister(PenPtr) + +class PyPen(Pen): def __repr__(self): - return "" % (self.this,) -class wxMask(wxMaskPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxMask,_args,_kwargs) + return "<%s.%s; proxy of C++ wxPyPen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Colour colour, int width=1, int style=SOLID) -> PyPen""" + newobj = _gdi.new_PyPen(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_PyPen): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + def SetDashes(*args, **kwargs): + """SetDashes(int dashes, wxDash dashes_array)""" + return _gdi.PyPen_SetDashes(*args, **kwargs) +class PyPenPtr(PyPen): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = PyPen +_gdi.PyPen_swigregister(PyPenPtr) + +Pen = PyPen +#--------------------------------------------------------------------------- + +class Brush(GDIObject): + """ + A brush is a drawing tool for filling in areas. It is used for painting the + background of rectangles, ellipses, etc. It has a colour and a style. + """ + def __repr__(self): + return "<%s.%s; proxy of C++ wxBrush instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """ + __init__(Colour colour, int style=SOLID) -> Brush + + Constructs a brush from a colour object and style. + """ + newobj = _gdi.new_Brush(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Brush): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def SetColour(*args, **kwargs): + """SetColour(Colour col)""" + return _gdi.Brush_SetColour(*args, **kwargs) + + def SetStyle(*args, **kwargs): + """SetStyle(int style)""" + return _gdi.Brush_SetStyle(*args, **kwargs) + + def SetStipple(*args, **kwargs): + """SetStipple(Bitmap stipple)""" + return _gdi.Brush_SetStipple(*args, **kwargs) + + def GetColour(*args, **kwargs): + """GetColour() -> Colour""" + return _gdi.Brush_GetColour(*args, **kwargs) -class wxIconPtr(wxGDIObjectPtr): - def __init__(self,this): + def GetStyle(*args, **kwargs): + """GetStyle() -> int""" + return _gdi.Brush_GetStyle(*args, **kwargs) + + def GetStipple(*args, **kwargs): + """GetStipple() -> Bitmap""" + return _gdi.Brush_GetStipple(*args, **kwargs) + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Brush_Ok(*args, **kwargs) + + def GetMacTheme(*args, **kwargs): + """GetMacTheme() -> short""" + return _gdi.Brush_GetMacTheme(*args, **kwargs) + + def SetMacTheme(*args, **kwargs): + """SetMacTheme(short macThemeBrush)""" + return _gdi.Brush_SetMacTheme(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class BrushPtr(Brush): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxIcon(self) - def LoadFile(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_LoadFile,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_Ok,(self,) + _args, _kwargs) - return val - def GetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_GetWidth,(self,) + _args, _kwargs) - return val - def GetHeight(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_GetHeight,(self,) + _args, _kwargs) - return val - def GetDepth(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_GetDepth,(self,) + _args, _kwargs) - return val - def SetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_SetWidth,(self,) + _args, _kwargs) - return val - def SetHeight(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_SetHeight,(self,) + _args, _kwargs) - return val - def SetDepth(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_SetDepth,(self,) + _args, _kwargs) - return val - def CopyFromBitmap(self, *_args, **_kwargs): - val = apply(gdic.wxIcon_CopyFromBitmap,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Brush +_gdi.Brush_swigregister(BrushPtr) + +class Bitmap(GDIObject): def __repr__(self): - return "" % (self.this,) - - def __del__(self,gdic=gdic): + return "<%s.%s; proxy of C++ wxBitmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """ + __init__(String name, int type=BITMAP_TYPE_ANY) -> Bitmap + + Loads a bitmap from a file. + """ + newobj = _gdi.new_Bitmap(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Bitmap): + """__del__()""" try: - if self.thisown == 1 : - gdic.delete_wxIcon(self) - except: - pass - -class wxIcon(wxIconPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxIcon,_args,_kwargs) + if self.thisown: destroy(self) + except: pass + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Bitmap_Ok(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """ + GetWidth() -> int + + Gets the width of the bitmap in pixels. + """ + return _gdi.Bitmap_GetWidth(*args, **kwargs) + + def GetHeight(*args, **kwargs): + """ + GetHeight() -> int + + Gets the height of the bitmap in pixels. + """ + return _gdi.Bitmap_GetHeight(*args, **kwargs) + + def GetDepth(*args, **kwargs): + """ + GetDepth() -> int + + Gets the colour depth of the bitmap. A value of 1 indicates a + monochrome bitmap. + """ + return _gdi.Bitmap_GetDepth(*args, **kwargs) + + def ConvertToImage(*args, **kwargs): + """ + ConvertToImage() -> Image + + Creates a platform-independent image from a platform-dependent bitmap. This + preserves mask information so that bitmaps and images can be converted back + and forth without loss in that respect. + """ + return _gdi.Bitmap_ConvertToImage(*args, **kwargs) + + def GetMask(*args, **kwargs): + """ + GetMask() -> Mask + + Gets the associated mask (if any) which may have been loaded from a file + or explpicitly set for the bitmap. + """ + return _gdi.Bitmap_GetMask(*args, **kwargs) + + def SetMask(*args, **kwargs): + """ + SetMask(Mask mask) + + Sets the mask for this bitmap. + """ + return _gdi.Bitmap_SetMask(*args, **kwargs) + + def SetMaskColour(*args, **kwargs): + """ + SetMaskColour(Colour colour) + + Create a Mask based on a specified colour in the Bitmap. + """ + return _gdi.Bitmap_SetMaskColour(*args, **kwargs) + + def GetSubBitmap(*args, **kwargs): + """ + GetSubBitmap(Rect rect) -> Bitmap + + Returns a sub bitmap of the current one as long as the rect belongs entirely + to the bitmap. This function preserves bit depth and mask information. + """ + return _gdi.Bitmap_GetSubBitmap(*args, **kwargs) + + def SaveFile(*args, **kwargs): + """ + SaveFile(String name, int type, Palette palette=(wxPalette *) NULL) -> bool + + Saves a bitmap in the named file. + """ + return _gdi.Bitmap_SaveFile(*args, **kwargs) + + def LoadFile(*args, **kwargs): + """ + LoadFile(String name, int type) -> bool + + Loads a bitmap from a file + """ + return _gdi.Bitmap_LoadFile(*args, **kwargs) + + def CopyFromIcon(*args, **kwargs): + """CopyFromIcon(Icon icon) -> bool""" + return _gdi.Bitmap_CopyFromIcon(*args, **kwargs) + + def SetHeight(*args, **kwargs): + """ + SetHeight(int height) + + Set the height property (does not affect the bitmap data). + """ + return _gdi.Bitmap_SetHeight(*args, **kwargs) + + def SetWidth(*args, **kwargs): + """ + SetWidth(int width) + + Set the width property (does not affect the bitmap data). + """ + return _gdi.Bitmap_SetWidth(*args, **kwargs) + + def SetDepth(*args, **kwargs): + """ + SetDepth(int depth) + + Set the depth property (does not affect the bitmap data). + """ + return _gdi.Bitmap_SetDepth(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class BitmapPtr(Bitmap): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Bitmap +_gdi.Bitmap_swigregister(BitmapPtr) + +def EmptyBitmap(*args, **kwargs): + """ + EmptyBitmap(int width, int height, int depth=-1) -> Bitmap + + Creates a new bitmap of the given size. A depth of -1 indicates the depth of + the current screen or visual. Some platforms only support 1 for monochrome and + -1 for the current colour setting. + """ + val = _gdi.new_EmptyBitmap(*args, **kwargs) + val.thisown = 1 + return val + +def BitmapFromIcon(*args, **kwargs): + """ + BitmapFromIcon(Icon icon) -> Bitmap + + Create a new bitmap from an Icon object. + """ + val = _gdi.new_BitmapFromIcon(*args, **kwargs) + val.thisown = 1 + return val + +def BitmapFromImage(*args, **kwargs): + """ + BitmapFromImage(Image image, int depth=-1) -> Bitmap + + Creates bitmap object from the image. This has to be done to actually display + an image as you cannot draw an image directly on a window. The resulting + bitmap will use the provided colour depth (or that of the current system if + depth is -1) which entails that a colour reduction has to take place. + """ + val = _gdi.new_BitmapFromImage(*args, **kwargs) + val.thisown = 1 + return val + +def BitmapFromXPMData(*args, **kwargs): + """ + BitmapFromXPMData(PyObject listOfStrings) -> Bitmap + + Construct a Bitmap from a list of strings formatted as XPM data. + """ + val = _gdi.new_BitmapFromXPMData(*args, **kwargs) + val.thisown = 1 + return val + +def BitmapFromBits(*args, **kwargs): + """ + BitmapFromBits(PyObject bits, int width, int height, int depth=1) -> Bitmap + + Creates a bitmap from an array of bits. You should only use this function for + monochrome bitmaps (depth 1) in portable programs: in this case the bits + parameter should contain an XBM image. For other bit depths, the behaviour is + platform dependent. + """ + val = _gdi.new_BitmapFromBits(*args, **kwargs) + val.thisown = 1 + return val + +class Mask(core.Object): + """ + This class encapsulates a monochrome mask bitmap, where the masked area is + black and the unmasked area is white. When associated with a bitmap and drawn + in a device context, the unmasked area of the bitmap will be drawn, and the + masked area will not be drawn. + """ + def __repr__(self): + return "<%s.%s; proxy of C++ wxMask instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """ + __init__(Bitmap bitmap) -> Mask + + Constructs a mask from a monochrome bitmap. + """ + newobj = _gdi.new_Mask(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + +class MaskPtr(Mask): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Mask +_gdi.Mask_swigregister(MaskPtr) + +def MaskColour(*args, **kwargs): + """ + MaskColour(Bitmap bitmap, Colour colour) -> Mask + + Constructs a mask from a bitmap and a colour in that bitmap that indicates the + background. + """ + val = _gdi.new_MaskColour(*args, **kwargs) + val.thisown = 1 + return val + +class Icon(GDIObject): + def __repr__(self): + return "<%s.%s; proxy of C++ wxIcon instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(String name, long flags, int desiredWidth=-1, int desiredHeight=-1) -> Icon""" + newobj = _gdi.new_Icon(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Icon): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Icon_Ok(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """GetWidth() -> int""" + return _gdi.Icon_GetWidth(*args, **kwargs) + def GetHeight(*args, **kwargs): + """GetHeight() -> int""" + return _gdi.Icon_GetHeight(*args, **kwargs) + def GetDepth(*args, **kwargs): + """GetDepth() -> int""" + return _gdi.Icon_GetDepth(*args, **kwargs) + def SetWidth(*args, **kwargs): + """SetWidth(int w)""" + return _gdi.Icon_SetWidth(*args, **kwargs) -class wxCursorPtr(wxGDIObjectPtr): - def __init__(self,this): + def SetHeight(*args, **kwargs): + """SetHeight(int h)""" + return _gdi.Icon_SetHeight(*args, **kwargs) + + def SetDepth(*args, **kwargs): + """SetDepth(int d)""" + return _gdi.Icon_SetDepth(*args, **kwargs) + + def CopyFromBitmap(*args, **kwargs): + """CopyFromBitmap(Bitmap bmp)""" + return _gdi.Icon_CopyFromBitmap(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class IconPtr(Icon): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxCursor(self) - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxCursor_Ok,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Icon +_gdi.Icon_swigregister(IconPtr) + +def EmptyIcon(*args, **kwargs): + """EmptyIcon() -> Icon""" + val = _gdi.new_EmptyIcon(*args, **kwargs) + val.thisown = 1 + return val + +def IconFromLocation(*args, **kwargs): + """IconFromLocation(IconLocation loc) -> Icon""" + val = _gdi.new_IconFromLocation(*args, **kwargs) + val.thisown = 1 + return val + +def IconFromBitmap(*args, **kwargs): + """IconFromBitmap(Bitmap bmp) -> Icon""" + val = _gdi.new_IconFromBitmap(*args, **kwargs) + val.thisown = 1 + return val + +def IconFromXPMData(*args, **kwargs): + """IconFromXPMData(PyObject listOfStrings) -> Icon""" + val = _gdi.new_IconFromXPMData(*args, **kwargs) + val.thisown = 1 + return val + +class IconLocation(object): def __repr__(self): - return "" % (self.this,) -class wxCursor(wxCursorPtr): - def __init__(self,this): + return "<%s.%s; proxy of C++ wxIconLocation instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(String filename=&wxPyEmptyString, int num=0) -> IconLocation""" + newobj = _gdi.new_IconLocation(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_IconLocation): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def IsOk(*args, **kwargs): + """IsOk() -> bool""" + return _gdi.IconLocation_IsOk(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + def SetFileName(*args, **kwargs): + """SetFileName(String filename)""" + return _gdi.IconLocation_SetFileName(*args, **kwargs) + + def GetFileName(*args, **kwargs): + """GetFileName() -> String""" + return _gdi.IconLocation_GetFileName(*args, **kwargs) + + def SetIndex(*args, **kwargs): + """SetIndex(int num)""" + return _gdi.IconLocation_SetIndex(*args, **kwargs) + + def GetIndex(*args, **kwargs): + """GetIndex() -> int""" + return _gdi.IconLocation_GetIndex(*args, **kwargs) + + +class IconLocationPtr(IconLocation): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = IconLocation +_gdi.IconLocation_swigregister(IconLocationPtr) +class IconBundle(object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxIconBundle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> IconBundle""" + newobj = _gdi.new_IconBundle(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_IconBundle): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def AddIcon(*args, **kwargs): + """AddIcon(Icon icon)""" + return _gdi.IconBundle_AddIcon(*args, **kwargs) + def AddIconFromFile(*args, **kwargs): + """AddIconFromFile(String file, long type)""" + return _gdi.IconBundle_AddIconFromFile(*args, **kwargs) + def GetIcon(*args, **kwargs): + """GetIcon(Size size) -> Icon""" + return _gdi.IconBundle_GetIcon(*args, **kwargs) -class wxNativeFontInfoPtr : - def __init__(self,this): + +class IconBundlePtr(IconBundle): + def __init__(self, this): self.this = this - self.thisown = 0 - def FromString(self, *_args, **_kwargs): - val = apply(gdic.wxNativeFontInfo_FromString,(self,) + _args, _kwargs) - return val - def ToString(self, *_args, **_kwargs): - val = apply(gdic.wxNativeFontInfo_ToString,(self,) + _args, _kwargs) - return val - def __str__(self, *_args, **_kwargs): - val = apply(gdic.wxNativeFontInfo___str__,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = IconBundle +_gdi.IconBundle_swigregister(IconBundlePtr) + +def IconBundleFromFile(*args, **kwargs): + """IconBundleFromFile(String file, long type) -> IconBundle""" + val = _gdi.new_IconBundleFromFile(*args, **kwargs) + val.thisown = 1 + return val + +def IconBundleFromIcon(*args, **kwargs): + """IconBundleFromIcon(Icon icon) -> IconBundle""" + val = _gdi.new_IconBundleFromIcon(*args, **kwargs) + val.thisown = 1 + return val + +class Cursor(GDIObject): def __repr__(self): - return "" % (self.this,) -class wxNativeFontInfo(wxNativeFontInfoPtr): - def __init__(self,this): + return "<%s.%s; proxy of C++ wxCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(String cursorName, long flags, int hotSpotX=0, int hotSpotY=0) -> Cursor""" + newobj = _gdi.new_Cursor(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Cursor): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Cursor_Ok(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + +class CursorPtr(Cursor): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Cursor +_gdi.Cursor_swigregister(CursorPtr) + +def StockCursor(*args, **kwargs): + """StockCursor(int id) -> Cursor""" + val = _gdi.new_StockCursor(*args, **kwargs) + val.thisown = 1 + return val + +def CursorFromImage(*args, **kwargs): + """CursorFromImage(Image image) -> Cursor""" + val = _gdi.new_CursorFromImage(*args, **kwargs) + val.thisown = 1 + return val + +def CursorFromBits(*args, **kwargs): + """ + CursorFromBits(PyObject bits, int width, int height, int hotSpotX=-1, + int hotSpotY=-1, PyObject maskBits=0) -> Cursor + """ + val = _gdi.new_CursorFromBits(*args, **kwargs) + val.thisown = 1 + return val + +#--------------------------------------------------------------------------- + +OutRegion = _gdi.OutRegion +PartRegion = _gdi.PartRegion +InRegion = _gdi.InRegion +class Region(GDIObject): + def __repr__(self): + return "<%s.%s; proxy of C++ wxRegion instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(int x=0, int y=0, int width=0, int height=0) -> Region""" + newobj = _gdi.new_Region(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Region): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Clear(*args, **kwargs): + """Clear()""" + return _gdi.Region_Clear(*args, **kwargs) + + def Contains(*args, **kwargs): + """Contains(int x, int y) -> int""" + return _gdi.Region_Contains(*args, **kwargs) + + def ContainsPoint(*args, **kwargs): + """ContainsPoint(Point pt) -> int""" + return _gdi.Region_ContainsPoint(*args, **kwargs) + + def ContainsRect(*args, **kwargs): + """ContainsRect(Rect rect) -> int""" + return _gdi.Region_ContainsRect(*args, **kwargs) + + def ContainsRectDim(*args, **kwargs): + """ContainsRectDim(int x, int y, int w, int h) -> int""" + return _gdi.Region_ContainsRectDim(*args, **kwargs) + + def GetBox(*args, **kwargs): + """GetBox() -> Rect""" + return _gdi.Region_GetBox(*args, **kwargs) + + def Intersect(*args, **kwargs): + """Intersect(int x, int y, int width, int height) -> bool""" + return _gdi.Region_Intersect(*args, **kwargs) + + def IntersectRect(*args, **kwargs): + """IntersectRect(Rect rect) -> bool""" + return _gdi.Region_IntersectRect(*args, **kwargs) + + def IntersectRegion(*args, **kwargs): + """IntersectRegion(Region region) -> bool""" + return _gdi.Region_IntersectRegion(*args, **kwargs) + + def IsEmpty(*args, **kwargs): + """IsEmpty() -> bool""" + return _gdi.Region_IsEmpty(*args, **kwargs) + + def Union(*args, **kwargs): + """Union(int x, int y, int width, int height) -> bool""" + return _gdi.Region_Union(*args, **kwargs) + def UnionRect(*args, **kwargs): + """UnionRect(Rect rect) -> bool""" + return _gdi.Region_UnionRect(*args, **kwargs) + def UnionRegion(*args, **kwargs): + """UnionRegion(Region region) -> bool""" + return _gdi.Region_UnionRegion(*args, **kwargs) + def Subtract(*args, **kwargs): + """Subtract(int x, int y, int width, int height) -> bool""" + return _gdi.Region_Subtract(*args, **kwargs) -class wxFontMapperPtr : - def __init__(self,this): + def SubtractRect(*args, **kwargs): + """SubtractRect(Rect rect) -> bool""" + return _gdi.Region_SubtractRect(*args, **kwargs) + + def SubtractRegion(*args, **kwargs): + """SubtractRegion(Region region) -> bool""" + return _gdi.Region_SubtractRegion(*args, **kwargs) + + def Xor(*args, **kwargs): + """Xor(int x, int y, int width, int height) -> bool""" + return _gdi.Region_Xor(*args, **kwargs) + + def XorRect(*args, **kwargs): + """XorRect(Rect rect) -> bool""" + return _gdi.Region_XorRect(*args, **kwargs) + + def XorRegion(*args, **kwargs): + """XorRegion(Region region) -> bool""" + return _gdi.Region_XorRegion(*args, **kwargs) + + def ConvertToBitmap(*args, **kwargs): + """ConvertToBitmap() -> Bitmap""" + return _gdi.Region_ConvertToBitmap(*args, **kwargs) + + def UnionBitmap(*args, **kwargs): + """UnionBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> bool""" + return _gdi.Region_UnionBitmap(*args, **kwargs) + + +class RegionPtr(Region): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxFontMapper(self) - def GetAltForEncoding(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_GetAltForEncoding,(self,) + _args, _kwargs) - return val - def IsEncodingAvailable(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_IsEncodingAvailable,(self,) + _args, _kwargs) - return val - def CharsetToEncoding(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_CharsetToEncoding,(self,) + _args, _kwargs) - return val - def SetDialogParent(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_SetDialogParent,(self,) + _args, _kwargs) - return val - def SetDialogTitle(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_SetDialogTitle,(self,) + _args, _kwargs) - return val - def SetConfig(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_SetConfig,(self,) + _args, _kwargs) - return val - def SetConfigPath(self, *_args, **_kwargs): - val = apply(gdic.wxFontMapper_SetConfigPath,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Region +_gdi.Region_swigregister(RegionPtr) + +def RegionFromBitmap(*args, **kwargs): + """RegionFromBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> Region""" + val = _gdi.new_RegionFromBitmap(*args, **kwargs) + val.thisown = 1 + return val + +def RegionFromPoints(*args, **kwargs): + """RegionFromPoints(int points, Point points_array, int fillStyle=WINDING_RULE) -> Region""" + val = _gdi.new_RegionFromPoints(*args, **kwargs) + val.thisown = 1 + return val + +class RegionIterator(core.Object): def __repr__(self): - return "" % (self.this,) -class wxFontMapper(wxFontMapperPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxFontMapper,_args,_kwargs) + return "<%s.%s; proxy of C++ wxRegionIterator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Region region) -> RegionIterator""" + newobj = _gdi.new_RegionIterator(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_RegionIterator): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def GetX(*args, **kwargs): + """GetX() -> int""" + return _gdi.RegionIterator_GetX(*args, **kwargs) + + def GetY(*args, **kwargs): + """GetY() -> int""" + return _gdi.RegionIterator_GetY(*args, **kwargs) + + def GetW(*args, **kwargs): + """GetW() -> int""" + return _gdi.RegionIterator_GetW(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """GetWidth() -> int""" + return _gdi.RegionIterator_GetWidth(*args, **kwargs) + + def GetH(*args, **kwargs): + """GetH() -> int""" + return _gdi.RegionIterator_GetH(*args, **kwargs) + def GetHeight(*args, **kwargs): + """GetHeight() -> int""" + return _gdi.RegionIterator_GetHeight(*args, **kwargs) + def GetRect(*args, **kwargs): + """GetRect() -> Rect""" + return _gdi.RegionIterator_GetRect(*args, **kwargs) + def HaveRects(*args, **kwargs): + """HaveRects() -> bool""" + return _gdi.RegionIterator_HaveRects(*args, **kwargs) -class wxFontPtr(wxGDIObjectPtr): - def __init__(self,this): + def Reset(*args, **kwargs): + """Reset()""" + return _gdi.RegionIterator_Reset(*args, **kwargs) + + def Next(*args, **kwargs): + """Next()""" + return _gdi.RegionIterator_Next(*args, **kwargs) + + def __nonzero__(*args, **kwargs): + """__nonzero__() -> bool""" + return _gdi.RegionIterator___nonzero__(*args, **kwargs) + + +class RegionIteratorPtr(RegionIterator): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxFont(self) - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxFont_Ok,(self,) + _args, _kwargs) - return val - def GetPointSize(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetPointSize,(self,) + _args, _kwargs) - return val - def GetFamily(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetFamily,(self,) + _args, _kwargs) - return val - def GetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetStyle,(self,) + _args, _kwargs) - return val - def GetWeight(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetWeight,(self,) + _args, _kwargs) - return val - def GetUnderlined(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetUnderlined,(self,) + _args, _kwargs) - return val - def GetFaceName(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetFaceName,(self,) + _args, _kwargs) - return val - def GetEncoding(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetEncoding,(self,) + _args, _kwargs) - return val - def GetNativeFontInfo(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetNativeFontInfo,(self,) + _args, _kwargs) - if val: val = wxNativeFontInfoPtr(val) - return val - def SetPointSize(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetPointSize,(self,) + _args, _kwargs) - return val - def SetFamily(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetFamily,(self,) + _args, _kwargs) - return val - def SetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetStyle,(self,) + _args, _kwargs) - return val - def SetWeight(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetWeight,(self,) + _args, _kwargs) - return val - def SetFaceName(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetFaceName,(self,) + _args, _kwargs) - return val - def SetUnderlined(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetUnderlined,(self,) + _args, _kwargs) - return val - def SetEncoding(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetEncoding,(self,) + _args, _kwargs) - return val - def SetNativeFontInfo(self, *_args, **_kwargs): - val = apply(gdic.wxFont_SetNativeFontInfo,(self,) + _args, _kwargs) - return val - def GetFamilyString(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetFamilyString,(self,) + _args, _kwargs) - return val - def GetStyleString(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetStyleString,(self,) + _args, _kwargs) - return val - def GetWeightString(self, *_args, **_kwargs): - val = apply(gdic.wxFont_GetWeightString,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = RegionIterator +_gdi.RegionIterator_swigregister(RegionIteratorPtr) + +#--------------------------------------------------------------------------- + +FONTFAMILY_DEFAULT = _gdi.FONTFAMILY_DEFAULT +FONTFAMILY_DECORATIVE = _gdi.FONTFAMILY_DECORATIVE +FONTFAMILY_ROMAN = _gdi.FONTFAMILY_ROMAN +FONTFAMILY_SCRIPT = _gdi.FONTFAMILY_SCRIPT +FONTFAMILY_SWISS = _gdi.FONTFAMILY_SWISS +FONTFAMILY_MODERN = _gdi.FONTFAMILY_MODERN +FONTFAMILY_TELETYPE = _gdi.FONTFAMILY_TELETYPE +FONTFAMILY_MAX = _gdi.FONTFAMILY_MAX +FONTFAMILY_UNKNOWN = _gdi.FONTFAMILY_UNKNOWN +FONTSTYLE_NORMAL = _gdi.FONTSTYLE_NORMAL +FONTSTYLE_ITALIC = _gdi.FONTSTYLE_ITALIC +FONTSTYLE_SLANT = _gdi.FONTSTYLE_SLANT +FONTSTYLE_MAX = _gdi.FONTSTYLE_MAX +FONTWEIGHT_NORMAL = _gdi.FONTWEIGHT_NORMAL +FONTWEIGHT_LIGHT = _gdi.FONTWEIGHT_LIGHT +FONTWEIGHT_BOLD = _gdi.FONTWEIGHT_BOLD +FONTWEIGHT_MAX = _gdi.FONTWEIGHT_MAX +FONTFLAG_DEFAULT = _gdi.FONTFLAG_DEFAULT +FONTFLAG_ITALIC = _gdi.FONTFLAG_ITALIC +FONTFLAG_SLANT = _gdi.FONTFLAG_SLANT +FONTFLAG_LIGHT = _gdi.FONTFLAG_LIGHT +FONTFLAG_BOLD = _gdi.FONTFLAG_BOLD +FONTFLAG_ANTIALIASED = _gdi.FONTFLAG_ANTIALIASED +FONTFLAG_NOT_ANTIALIASED = _gdi.FONTFLAG_NOT_ANTIALIASED +FONTFLAG_UNDERLINED = _gdi.FONTFLAG_UNDERLINED +FONTFLAG_STRIKETHROUGH = _gdi.FONTFLAG_STRIKETHROUGH +FONTFLAG_MASK = _gdi.FONTFLAG_MASK +FONTENCODING_SYSTEM = _gdi.FONTENCODING_SYSTEM +FONTENCODING_DEFAULT = _gdi.FONTENCODING_DEFAULT +FONTENCODING_ISO8859_1 = _gdi.FONTENCODING_ISO8859_1 +FONTENCODING_ISO8859_2 = _gdi.FONTENCODING_ISO8859_2 +FONTENCODING_ISO8859_3 = _gdi.FONTENCODING_ISO8859_3 +FONTENCODING_ISO8859_4 = _gdi.FONTENCODING_ISO8859_4 +FONTENCODING_ISO8859_5 = _gdi.FONTENCODING_ISO8859_5 +FONTENCODING_ISO8859_6 = _gdi.FONTENCODING_ISO8859_6 +FONTENCODING_ISO8859_7 = _gdi.FONTENCODING_ISO8859_7 +FONTENCODING_ISO8859_8 = _gdi.FONTENCODING_ISO8859_8 +FONTENCODING_ISO8859_9 = _gdi.FONTENCODING_ISO8859_9 +FONTENCODING_ISO8859_10 = _gdi.FONTENCODING_ISO8859_10 +FONTENCODING_ISO8859_11 = _gdi.FONTENCODING_ISO8859_11 +FONTENCODING_ISO8859_12 = _gdi.FONTENCODING_ISO8859_12 +FONTENCODING_ISO8859_13 = _gdi.FONTENCODING_ISO8859_13 +FONTENCODING_ISO8859_14 = _gdi.FONTENCODING_ISO8859_14 +FONTENCODING_ISO8859_15 = _gdi.FONTENCODING_ISO8859_15 +FONTENCODING_ISO8859_MAX = _gdi.FONTENCODING_ISO8859_MAX +FONTENCODING_KOI8 = _gdi.FONTENCODING_KOI8 +FONTENCODING_ALTERNATIVE = _gdi.FONTENCODING_ALTERNATIVE +FONTENCODING_BULGARIAN = _gdi.FONTENCODING_BULGARIAN +FONTENCODING_CP437 = _gdi.FONTENCODING_CP437 +FONTENCODING_CP850 = _gdi.FONTENCODING_CP850 +FONTENCODING_CP852 = _gdi.FONTENCODING_CP852 +FONTENCODING_CP855 = _gdi.FONTENCODING_CP855 +FONTENCODING_CP866 = _gdi.FONTENCODING_CP866 +FONTENCODING_CP874 = _gdi.FONTENCODING_CP874 +FONTENCODING_CP932 = _gdi.FONTENCODING_CP932 +FONTENCODING_CP936 = _gdi.FONTENCODING_CP936 +FONTENCODING_CP949 = _gdi.FONTENCODING_CP949 +FONTENCODING_CP950 = _gdi.FONTENCODING_CP950 +FONTENCODING_CP1250 = _gdi.FONTENCODING_CP1250 +FONTENCODING_CP1251 = _gdi.FONTENCODING_CP1251 +FONTENCODING_CP1252 = _gdi.FONTENCODING_CP1252 +FONTENCODING_CP1253 = _gdi.FONTENCODING_CP1253 +FONTENCODING_CP1254 = _gdi.FONTENCODING_CP1254 +FONTENCODING_CP1255 = _gdi.FONTENCODING_CP1255 +FONTENCODING_CP1256 = _gdi.FONTENCODING_CP1256 +FONTENCODING_CP1257 = _gdi.FONTENCODING_CP1257 +FONTENCODING_CP12_MAX = _gdi.FONTENCODING_CP12_MAX +FONTENCODING_UTF7 = _gdi.FONTENCODING_UTF7 +FONTENCODING_UTF8 = _gdi.FONTENCODING_UTF8 +FONTENCODING_EUC_JP = _gdi.FONTENCODING_EUC_JP +FONTENCODING_UTF16BE = _gdi.FONTENCODING_UTF16BE +FONTENCODING_UTF16LE = _gdi.FONTENCODING_UTF16LE +FONTENCODING_UTF32BE = _gdi.FONTENCODING_UTF32BE +FONTENCODING_UTF32LE = _gdi.FONTENCODING_UTF32LE +FONTENCODING_MAX = _gdi.FONTENCODING_MAX +FONTENCODING_UTF16 = _gdi.FONTENCODING_UTF16 +FONTENCODING_UTF32 = _gdi.FONTENCODING_UTF32 +FONTENCODING_UNICODE = _gdi.FONTENCODING_UNICODE +FONTENCODING_GB2312 = _gdi.FONTENCODING_GB2312 +FONTENCODING_BIG5 = _gdi.FONTENCODING_BIG5 +FONTENCODING_SHIFT_JIS = _gdi.FONTENCODING_SHIFT_JIS +#--------------------------------------------------------------------------- + +class NativeFontInfo(object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxNativeFontInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> NativeFontInfo""" + newobj = _gdi.new_NativeFontInfo(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_NativeFontInfo): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Init(*args, **kwargs): + """Init()""" + return _gdi.NativeFontInfo_Init(*args, **kwargs) + + def InitFromFont(*args, **kwargs): + """InitFromFont(Font font)""" + return _gdi.NativeFontInfo_InitFromFont(*args, **kwargs) + + def GetPointSize(*args, **kwargs): + """GetPointSize() -> int""" + return _gdi.NativeFontInfo_GetPointSize(*args, **kwargs) + + def GetStyle(*args, **kwargs): + """GetStyle() -> int""" + return _gdi.NativeFontInfo_GetStyle(*args, **kwargs) + + def GetWeight(*args, **kwargs): + """GetWeight() -> int""" + return _gdi.NativeFontInfo_GetWeight(*args, **kwargs) + + def GetUnderlined(*args, **kwargs): + """GetUnderlined() -> bool""" + return _gdi.NativeFontInfo_GetUnderlined(*args, **kwargs) + + def GetFaceName(*args, **kwargs): + """GetFaceName() -> String""" + return _gdi.NativeFontInfo_GetFaceName(*args, **kwargs) + + def GetFamily(*args, **kwargs): + """GetFamily() -> int""" + return _gdi.NativeFontInfo_GetFamily(*args, **kwargs) + + def GetEncoding(*args, **kwargs): + """GetEncoding() -> int""" + return _gdi.NativeFontInfo_GetEncoding(*args, **kwargs) + + def SetPointSize(*args, **kwargs): + """SetPointSize(int pointsize)""" + return _gdi.NativeFontInfo_SetPointSize(*args, **kwargs) + + def SetStyle(*args, **kwargs): + """SetStyle(int style)""" + return _gdi.NativeFontInfo_SetStyle(*args, **kwargs) + + def SetWeight(*args, **kwargs): + """SetWeight(int weight)""" + return _gdi.NativeFontInfo_SetWeight(*args, **kwargs) + + def SetUnderlined(*args, **kwargs): + """SetUnderlined(bool underlined)""" + return _gdi.NativeFontInfo_SetUnderlined(*args, **kwargs) + + def SetFaceName(*args, **kwargs): + """SetFaceName(String facename)""" + return _gdi.NativeFontInfo_SetFaceName(*args, **kwargs) + + def SetFamily(*args, **kwargs): + """SetFamily(int family)""" + return _gdi.NativeFontInfo_SetFamily(*args, **kwargs) + + def SetEncoding(*args, **kwargs): + """SetEncoding(int encoding)""" + return _gdi.NativeFontInfo_SetEncoding(*args, **kwargs) + + def FromString(*args, **kwargs): + """FromString(String s) -> bool""" + return _gdi.NativeFontInfo_FromString(*args, **kwargs) + + def ToString(*args, **kwargs): + """ToString() -> String""" + return _gdi.NativeFontInfo_ToString(*args, **kwargs) + + def __str__(*args, **kwargs): + """__str__() -> String""" + return _gdi.NativeFontInfo___str__(*args, **kwargs) + + def FromUserString(*args, **kwargs): + """FromUserString(String s) -> bool""" + return _gdi.NativeFontInfo_FromUserString(*args, **kwargs) + + def ToUserString(*args, **kwargs): + """ToUserString() -> String""" + return _gdi.NativeFontInfo_ToUserString(*args, **kwargs) + + +class NativeFontInfoPtr(NativeFontInfo): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = NativeFontInfo +_gdi.NativeFontInfo_swigregister(NativeFontInfoPtr) + +class NativeEncodingInfo(object): def __repr__(self): - return "" % (self.this,) -class wxFont(wxFontPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxFont,_args,_kwargs) + return "<%s.%s; proxy of C++ wxNativeEncodingInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + facename = property(_gdi.NativeEncodingInfo_facename_get, _gdi.NativeEncodingInfo_facename_set) + encoding = property(_gdi.NativeEncodingInfo_encoding_get, _gdi.NativeEncodingInfo_encoding_set) + def __init__(self, *args, **kwargs): + """__init__() -> NativeEncodingInfo""" + newobj = _gdi.new_NativeEncodingInfo(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_NativeEncodingInfo): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def FromString(*args, **kwargs): + """FromString(String s) -> bool""" + return _gdi.NativeEncodingInfo_FromString(*args, **kwargs) + + def ToString(*args, **kwargs): + """ToString() -> String""" + return _gdi.NativeEncodingInfo_ToString(*args, **kwargs) + + +class NativeEncodingInfoPtr(NativeEncodingInfo): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = NativeEncodingInfo +_gdi.NativeEncodingInfo_swigregister(NativeEncodingInfoPtr) +def GetNativeFontEncoding(*args, **kwargs): + """GetNativeFontEncoding(int encoding) -> NativeEncodingInfo""" + return _gdi.GetNativeFontEncoding(*args, **kwargs) + +def TestFontEncoding(*args, **kwargs): + """TestFontEncoding(NativeEncodingInfo info) -> bool""" + return _gdi.TestFontEncoding(*args, **kwargs) +#--------------------------------------------------------------------------- + +class FontMapper(object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxFontMapper instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> FontMapper""" + newobj = _gdi.new_FontMapper(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_FontMapper): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Get(*args, **kwargs): + """FontMapper.Get() -> FontMapper""" + return _gdi.FontMapper_Get(*args, **kwargs) + + Get = staticmethod(Get) + def Set(*args, **kwargs): + """FontMapper.Set(FontMapper mapper) -> FontMapper""" + return _gdi.FontMapper_Set(*args, **kwargs) + + Set = staticmethod(Set) + def CharsetToEncoding(*args, **kwargs): + """CharsetToEncoding(String charset, bool interactive=True) -> int""" + return _gdi.FontMapper_CharsetToEncoding(*args, **kwargs) + + def GetSupportedEncodingsCount(*args, **kwargs): + """FontMapper.GetSupportedEncodingsCount() -> size_t""" + return _gdi.FontMapper_GetSupportedEncodingsCount(*args, **kwargs) + + GetSupportedEncodingsCount = staticmethod(GetSupportedEncodingsCount) + def GetEncoding(*args, **kwargs): + """FontMapper.GetEncoding(size_t n) -> int""" + return _gdi.FontMapper_GetEncoding(*args, **kwargs) + + GetEncoding = staticmethod(GetEncoding) + def GetEncodingName(*args, **kwargs): + """FontMapper.GetEncodingName(int encoding) -> String""" + return _gdi.FontMapper_GetEncodingName(*args, **kwargs) + + GetEncodingName = staticmethod(GetEncodingName) + def GetEncodingDescription(*args, **kwargs): + """FontMapper.GetEncodingDescription(int encoding) -> String""" + return _gdi.FontMapper_GetEncodingDescription(*args, **kwargs) + + GetEncodingDescription = staticmethod(GetEncodingDescription) + def SetConfig(*args, **kwargs): + """SetConfig(ConfigBase config)""" + return _gdi.FontMapper_SetConfig(*args, **kwargs) + + def SetConfigPath(*args, **kwargs): + """SetConfigPath(String prefix)""" + return _gdi.FontMapper_SetConfigPath(*args, **kwargs) + + def GetDefaultConfigPath(*args, **kwargs): + """FontMapper.GetDefaultConfigPath() -> String""" + return _gdi.FontMapper_GetDefaultConfigPath(*args, **kwargs) + + GetDefaultConfigPath = staticmethod(GetDefaultConfigPath) + def GetAltForEncoding(*args, **kwargs): + """GetAltForEncoding(int encoding, String facename=EmptyString, bool interactive=True) -> PyObject""" + return _gdi.FontMapper_GetAltForEncoding(*args, **kwargs) + + def IsEncodingAvailable(*args, **kwargs): + """IsEncodingAvailable(int encoding, String facename=EmptyString) -> bool""" + return _gdi.FontMapper_IsEncodingAvailable(*args, **kwargs) + + def SetDialogParent(*args, **kwargs): + """SetDialogParent(Window parent)""" + return _gdi.FontMapper_SetDialogParent(*args, **kwargs) + + def SetDialogTitle(*args, **kwargs): + """SetDialogTitle(String title)""" + return _gdi.FontMapper_SetDialogTitle(*args, **kwargs) + + +class FontMapperPtr(FontMapper): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = FontMapper +_gdi.FontMapper_swigregister(FontMapperPtr) + +def FontMapper_Get(*args, **kwargs): + """FontMapper_Get() -> FontMapper""" + return _gdi.FontMapper_Get(*args, **kwargs) + +def FontMapper_Set(*args, **kwargs): + """FontMapper_Set(FontMapper mapper) -> FontMapper""" + return _gdi.FontMapper_Set(*args, **kwargs) + +def FontMapper_GetSupportedEncodingsCount(*args, **kwargs): + """FontMapper_GetSupportedEncodingsCount() -> size_t""" + return _gdi.FontMapper_GetSupportedEncodingsCount(*args, **kwargs) + +def FontMapper_GetEncoding(*args, **kwargs): + """FontMapper_GetEncoding(size_t n) -> int""" + return _gdi.FontMapper_GetEncoding(*args, **kwargs) + +def FontMapper_GetEncodingName(*args, **kwargs): + """FontMapper_GetEncodingName(int encoding) -> String""" + return _gdi.FontMapper_GetEncodingName(*args, **kwargs) + +def FontMapper_GetEncodingDescription(*args, **kwargs): + """FontMapper_GetEncodingDescription(int encoding) -> String""" + return _gdi.FontMapper_GetEncodingDescription(*args, **kwargs) + +def FontMapper_GetDefaultConfigPath(*args, **kwargs): + """FontMapper_GetDefaultConfigPath() -> String""" + return _gdi.FontMapper_GetDefaultConfigPath(*args, **kwargs) + +#--------------------------------------------------------------------------- + +class Font(GDIObject): + def __repr__(self): + return "<%s.%s; proxy of C++ wxFont instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """ + __init__(int pointSize, int family, int style, int weight, bool underline=False, + String face=EmptyString, + int encoding=FONTENCODING_DEFAULT) -> Font + """ + newobj = _gdi.new_Font(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Font): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.Font_Ok(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + def __eq__(*args, **kwargs): + """__eq__(Font font) -> bool""" + return _gdi.Font___eq__(*args, **kwargs) + + def __ne__(*args, **kwargs): + """__ne__(Font font) -> bool""" + return _gdi.Font___ne__(*args, **kwargs) + + def GetPointSize(*args, **kwargs): + """GetPointSize() -> int""" + return _gdi.Font_GetPointSize(*args, **kwargs) + + def GetFamily(*args, **kwargs): + """GetFamily() -> int""" + return _gdi.Font_GetFamily(*args, **kwargs) + + def GetStyle(*args, **kwargs): + """GetStyle() -> int""" + return _gdi.Font_GetStyle(*args, **kwargs) + + def GetWeight(*args, **kwargs): + """GetWeight() -> int""" + return _gdi.Font_GetWeight(*args, **kwargs) + + def GetUnderlined(*args, **kwargs): + """GetUnderlined() -> bool""" + return _gdi.Font_GetUnderlined(*args, **kwargs) + + def GetFaceName(*args, **kwargs): + """GetFaceName() -> String""" + return _gdi.Font_GetFaceName(*args, **kwargs) + + def GetEncoding(*args, **kwargs): + """GetEncoding() -> int""" + return _gdi.Font_GetEncoding(*args, **kwargs) + + def GetNativeFontInfo(*args, **kwargs): + """GetNativeFontInfo() -> NativeFontInfo""" + return _gdi.Font_GetNativeFontInfo(*args, **kwargs) + + def IsFixedWidth(*args, **kwargs): + """IsFixedWidth() -> bool""" + return _gdi.Font_IsFixedWidth(*args, **kwargs) + + def GetNativeFontInfoDesc(*args, **kwargs): + """GetNativeFontInfoDesc() -> String""" + return _gdi.Font_GetNativeFontInfoDesc(*args, **kwargs) + + def GetNativeFontInfoUserDesc(*args, **kwargs): + """GetNativeFontInfoUserDesc() -> String""" + return _gdi.Font_GetNativeFontInfoUserDesc(*args, **kwargs) + + def SetPointSize(*args, **kwargs): + """SetPointSize(int pointSize)""" + return _gdi.Font_SetPointSize(*args, **kwargs) + + def SetFamily(*args, **kwargs): + """SetFamily(int family)""" + return _gdi.Font_SetFamily(*args, **kwargs) + + def SetStyle(*args, **kwargs): + """SetStyle(int style)""" + return _gdi.Font_SetStyle(*args, **kwargs) + + def SetWeight(*args, **kwargs): + """SetWeight(int weight)""" + return _gdi.Font_SetWeight(*args, **kwargs) + + def SetFaceName(*args, **kwargs): + """SetFaceName(String faceName)""" + return _gdi.Font_SetFaceName(*args, **kwargs) + + def SetUnderlined(*args, **kwargs): + """SetUnderlined(bool underlined)""" + return _gdi.Font_SetUnderlined(*args, **kwargs) + + def SetEncoding(*args, **kwargs): + """SetEncoding(int encoding)""" + return _gdi.Font_SetEncoding(*args, **kwargs) + + def SetNativeFontInfo(*args, **kwargs): + """SetNativeFontInfo(NativeFontInfo info)""" + return _gdi.Font_SetNativeFontInfo(*args, **kwargs) + + def SetNativeFontInfoFromString(*args, **kwargs): + """SetNativeFontInfoFromString(String info)""" + return _gdi.Font_SetNativeFontInfoFromString(*args, **kwargs) + + def SetNativeFontInfoUserDesc(*args, **kwargs): + """SetNativeFontInfoUserDesc(String info)""" + return _gdi.Font_SetNativeFontInfoUserDesc(*args, **kwargs) + + def GetFamilyString(*args, **kwargs): + """GetFamilyString() -> String""" + return _gdi.Font_GetFamilyString(*args, **kwargs) + + def GetStyleString(*args, **kwargs): + """GetStyleString() -> String""" + return _gdi.Font_GetStyleString(*args, **kwargs) + + def GetWeightString(*args, **kwargs): + """GetWeightString() -> String""" + return _gdi.Font_GetWeightString(*args, **kwargs) + + def SetNoAntiAliasing(*args, **kwargs): + """SetNoAntiAliasing(bool no=True)""" + return _gdi.Font_SetNoAntiAliasing(*args, **kwargs) + + def GetNoAntiAliasing(*args, **kwargs): + """GetNoAntiAliasing() -> bool""" + return _gdi.Font_GetNoAntiAliasing(*args, **kwargs) + + def GetDefaultEncoding(*args, **kwargs): + """Font.GetDefaultEncoding() -> int""" + return _gdi.Font_GetDefaultEncoding(*args, **kwargs) + + GetDefaultEncoding = staticmethod(GetDefaultEncoding) + def SetDefaultEncoding(*args, **kwargs): + """Font.SetDefaultEncoding(int encoding)""" + return _gdi.Font_SetDefaultEncoding(*args, **kwargs) + + SetDefaultEncoding = staticmethod(SetDefaultEncoding) + +class FontPtr(Font): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Font +_gdi.Font_swigregister(FontPtr) + +def FontFromNativeInfo(*args, **kwargs): + """FontFromNativeInfo(NativeFontInfo info) -> Font""" + val = _gdi.new_FontFromNativeInfo(*args, **kwargs) + val.thisown = 1 + return val + +def FontFromNativeInfoString(*args, **kwargs): + """FontFromNativeInfoString(String info) -> Font""" + val = _gdi.new_FontFromNativeInfoString(*args, **kwargs) + val.thisown = 1 + return val -def wxFontFromNativeInfo(*_args,**_kwargs): - val = wxFontPtr(apply(gdic.new_wxFontFromNativeInfo,_args,_kwargs)) +def Font2(*args, **kwargs): + """ + Font2(int pointSize, int family, int flags=FONTFLAG_DEFAULT, + String face=EmptyString, int encoding=FONTENCODING_DEFAULT) -> Font + """ + val = _gdi.new_Font2(*args, **kwargs) val.thisown = 1 return val +def Font_GetDefaultEncoding(*args, **kwargs): + """Font_GetDefaultEncoding() -> int""" + return _gdi.Font_GetDefaultEncoding(*args, **kwargs) -class wxFontListPtr(wxObjectPtr): - def __init__(self,this): +def Font_SetDefaultEncoding(*args, **kwargs): + """Font_SetDefaultEncoding(int encoding)""" + return _gdi.Font_SetDefaultEncoding(*args, **kwargs) + +#--------------------------------------------------------------------------- + +class FontEnumerator(object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxPyFontEnumerator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> FontEnumerator""" + newobj = _gdi.new_FontEnumerator(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + self._setCallbackInfo(self, FontEnumerator, 0) + + def __del__(self, destroy=_gdi.delete_FontEnumerator): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def _setCallbackInfo(*args, **kwargs): + """_setCallbackInfo(PyObject self, PyObject _class, bool incref)""" + return _gdi.FontEnumerator__setCallbackInfo(*args, **kwargs) + + def EnumerateFacenames(*args, **kwargs): + """EnumerateFacenames(int encoding=FONTENCODING_SYSTEM, bool fixedWidthOnly=False) -> bool""" + return _gdi.FontEnumerator_EnumerateFacenames(*args, **kwargs) + + def EnumerateEncodings(*args, **kwargs): + """EnumerateEncodings(String facename=EmptyString) -> bool""" + return _gdi.FontEnumerator_EnumerateEncodings(*args, **kwargs) + + def GetEncodings(*args, **kwargs): + """GetEncodings() -> PyObject""" + return _gdi.FontEnumerator_GetEncodings(*args, **kwargs) + + def GetFacenames(*args, **kwargs): + """GetFacenames() -> PyObject""" + return _gdi.FontEnumerator_GetFacenames(*args, **kwargs) + + +class FontEnumeratorPtr(FontEnumerator): + def __init__(self, this): self.this = this - self.thisown = 0 - def AddFont(self, *_args, **_kwargs): - val = apply(gdic.wxFontList_AddFont,(self,) + _args, _kwargs) - return val - def FindOrCreateFont(self, *_args, **_kwargs): - val = apply(gdic.wxFontList_FindOrCreateFont,(self,) + _args, _kwargs) - if val: val = wxFontPtr(val) - return val - def RemoveFont(self, *_args, **_kwargs): - val = apply(gdic.wxFontList_RemoveFont,(self,) + _args, _kwargs) - return val - def GetCount(self, *_args, **_kwargs): - val = apply(gdic.wxFontList_GetCount,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = FontEnumerator +_gdi.FontEnumerator_swigregister(FontEnumeratorPtr) + +#--------------------------------------------------------------------------- + +LANGUAGE_DEFAULT = _gdi.LANGUAGE_DEFAULT +LANGUAGE_UNKNOWN = _gdi.LANGUAGE_UNKNOWN +LANGUAGE_ABKHAZIAN = _gdi.LANGUAGE_ABKHAZIAN +LANGUAGE_AFAR = _gdi.LANGUAGE_AFAR +LANGUAGE_AFRIKAANS = _gdi.LANGUAGE_AFRIKAANS +LANGUAGE_ALBANIAN = _gdi.LANGUAGE_ALBANIAN +LANGUAGE_AMHARIC = _gdi.LANGUAGE_AMHARIC +LANGUAGE_ARABIC = _gdi.LANGUAGE_ARABIC +LANGUAGE_ARABIC_ALGERIA = _gdi.LANGUAGE_ARABIC_ALGERIA +LANGUAGE_ARABIC_BAHRAIN = _gdi.LANGUAGE_ARABIC_BAHRAIN +LANGUAGE_ARABIC_EGYPT = _gdi.LANGUAGE_ARABIC_EGYPT +LANGUAGE_ARABIC_IRAQ = _gdi.LANGUAGE_ARABIC_IRAQ +LANGUAGE_ARABIC_JORDAN = _gdi.LANGUAGE_ARABIC_JORDAN +LANGUAGE_ARABIC_KUWAIT = _gdi.LANGUAGE_ARABIC_KUWAIT +LANGUAGE_ARABIC_LEBANON = _gdi.LANGUAGE_ARABIC_LEBANON +LANGUAGE_ARABIC_LIBYA = _gdi.LANGUAGE_ARABIC_LIBYA +LANGUAGE_ARABIC_MOROCCO = _gdi.LANGUAGE_ARABIC_MOROCCO +LANGUAGE_ARABIC_OMAN = _gdi.LANGUAGE_ARABIC_OMAN +LANGUAGE_ARABIC_QATAR = _gdi.LANGUAGE_ARABIC_QATAR +LANGUAGE_ARABIC_SAUDI_ARABIA = _gdi.LANGUAGE_ARABIC_SAUDI_ARABIA +LANGUAGE_ARABIC_SUDAN = _gdi.LANGUAGE_ARABIC_SUDAN +LANGUAGE_ARABIC_SYRIA = _gdi.LANGUAGE_ARABIC_SYRIA +LANGUAGE_ARABIC_TUNISIA = _gdi.LANGUAGE_ARABIC_TUNISIA +LANGUAGE_ARABIC_UAE = _gdi.LANGUAGE_ARABIC_UAE +LANGUAGE_ARABIC_YEMEN = _gdi.LANGUAGE_ARABIC_YEMEN +LANGUAGE_ARMENIAN = _gdi.LANGUAGE_ARMENIAN +LANGUAGE_ASSAMESE = _gdi.LANGUAGE_ASSAMESE +LANGUAGE_AYMARA = _gdi.LANGUAGE_AYMARA +LANGUAGE_AZERI = _gdi.LANGUAGE_AZERI +LANGUAGE_AZERI_CYRILLIC = _gdi.LANGUAGE_AZERI_CYRILLIC +LANGUAGE_AZERI_LATIN = _gdi.LANGUAGE_AZERI_LATIN +LANGUAGE_BASHKIR = _gdi.LANGUAGE_BASHKIR +LANGUAGE_BASQUE = _gdi.LANGUAGE_BASQUE +LANGUAGE_BELARUSIAN = _gdi.LANGUAGE_BELARUSIAN +LANGUAGE_BENGALI = _gdi.LANGUAGE_BENGALI +LANGUAGE_BHUTANI = _gdi.LANGUAGE_BHUTANI +LANGUAGE_BIHARI = _gdi.LANGUAGE_BIHARI +LANGUAGE_BISLAMA = _gdi.LANGUAGE_BISLAMA +LANGUAGE_BRETON = _gdi.LANGUAGE_BRETON +LANGUAGE_BULGARIAN = _gdi.LANGUAGE_BULGARIAN +LANGUAGE_BURMESE = _gdi.LANGUAGE_BURMESE +LANGUAGE_CAMBODIAN = _gdi.LANGUAGE_CAMBODIAN +LANGUAGE_CATALAN = _gdi.LANGUAGE_CATALAN +LANGUAGE_CHINESE = _gdi.LANGUAGE_CHINESE +LANGUAGE_CHINESE_SIMPLIFIED = _gdi.LANGUAGE_CHINESE_SIMPLIFIED +LANGUAGE_CHINESE_TRADITIONAL = _gdi.LANGUAGE_CHINESE_TRADITIONAL +LANGUAGE_CHINESE_HONGKONG = _gdi.LANGUAGE_CHINESE_HONGKONG +LANGUAGE_CHINESE_MACAU = _gdi.LANGUAGE_CHINESE_MACAU +LANGUAGE_CHINESE_SINGAPORE = _gdi.LANGUAGE_CHINESE_SINGAPORE +LANGUAGE_CHINESE_TAIWAN = _gdi.LANGUAGE_CHINESE_TAIWAN +LANGUAGE_CORSICAN = _gdi.LANGUAGE_CORSICAN +LANGUAGE_CROATIAN = _gdi.LANGUAGE_CROATIAN +LANGUAGE_CZECH = _gdi.LANGUAGE_CZECH +LANGUAGE_DANISH = _gdi.LANGUAGE_DANISH +LANGUAGE_DUTCH = _gdi.LANGUAGE_DUTCH +LANGUAGE_DUTCH_BELGIAN = _gdi.LANGUAGE_DUTCH_BELGIAN +LANGUAGE_ENGLISH = _gdi.LANGUAGE_ENGLISH +LANGUAGE_ENGLISH_UK = _gdi.LANGUAGE_ENGLISH_UK +LANGUAGE_ENGLISH_US = _gdi.LANGUAGE_ENGLISH_US +LANGUAGE_ENGLISH_AUSTRALIA = _gdi.LANGUAGE_ENGLISH_AUSTRALIA +LANGUAGE_ENGLISH_BELIZE = _gdi.LANGUAGE_ENGLISH_BELIZE +LANGUAGE_ENGLISH_BOTSWANA = _gdi.LANGUAGE_ENGLISH_BOTSWANA +LANGUAGE_ENGLISH_CANADA = _gdi.LANGUAGE_ENGLISH_CANADA +LANGUAGE_ENGLISH_CARIBBEAN = _gdi.LANGUAGE_ENGLISH_CARIBBEAN +LANGUAGE_ENGLISH_DENMARK = _gdi.LANGUAGE_ENGLISH_DENMARK +LANGUAGE_ENGLISH_EIRE = _gdi.LANGUAGE_ENGLISH_EIRE +LANGUAGE_ENGLISH_JAMAICA = _gdi.LANGUAGE_ENGLISH_JAMAICA +LANGUAGE_ENGLISH_NEW_ZEALAND = _gdi.LANGUAGE_ENGLISH_NEW_ZEALAND +LANGUAGE_ENGLISH_PHILIPPINES = _gdi.LANGUAGE_ENGLISH_PHILIPPINES +LANGUAGE_ENGLISH_SOUTH_AFRICA = _gdi.LANGUAGE_ENGLISH_SOUTH_AFRICA +LANGUAGE_ENGLISH_TRINIDAD = _gdi.LANGUAGE_ENGLISH_TRINIDAD +LANGUAGE_ENGLISH_ZIMBABWE = _gdi.LANGUAGE_ENGLISH_ZIMBABWE +LANGUAGE_ESPERANTO = _gdi.LANGUAGE_ESPERANTO +LANGUAGE_ESTONIAN = _gdi.LANGUAGE_ESTONIAN +LANGUAGE_FAEROESE = _gdi.LANGUAGE_FAEROESE +LANGUAGE_FARSI = _gdi.LANGUAGE_FARSI +LANGUAGE_FIJI = _gdi.LANGUAGE_FIJI +LANGUAGE_FINNISH = _gdi.LANGUAGE_FINNISH +LANGUAGE_FRENCH = _gdi.LANGUAGE_FRENCH +LANGUAGE_FRENCH_BELGIAN = _gdi.LANGUAGE_FRENCH_BELGIAN +LANGUAGE_FRENCH_CANADIAN = _gdi.LANGUAGE_FRENCH_CANADIAN +LANGUAGE_FRENCH_LUXEMBOURG = _gdi.LANGUAGE_FRENCH_LUXEMBOURG +LANGUAGE_FRENCH_MONACO = _gdi.LANGUAGE_FRENCH_MONACO +LANGUAGE_FRENCH_SWISS = _gdi.LANGUAGE_FRENCH_SWISS +LANGUAGE_FRISIAN = _gdi.LANGUAGE_FRISIAN +LANGUAGE_GALICIAN = _gdi.LANGUAGE_GALICIAN +LANGUAGE_GEORGIAN = _gdi.LANGUAGE_GEORGIAN +LANGUAGE_GERMAN = _gdi.LANGUAGE_GERMAN +LANGUAGE_GERMAN_AUSTRIAN = _gdi.LANGUAGE_GERMAN_AUSTRIAN +LANGUAGE_GERMAN_BELGIUM = _gdi.LANGUAGE_GERMAN_BELGIUM +LANGUAGE_GERMAN_LIECHTENSTEIN = _gdi.LANGUAGE_GERMAN_LIECHTENSTEIN +LANGUAGE_GERMAN_LUXEMBOURG = _gdi.LANGUAGE_GERMAN_LUXEMBOURG +LANGUAGE_GERMAN_SWISS = _gdi.LANGUAGE_GERMAN_SWISS +LANGUAGE_GREEK = _gdi.LANGUAGE_GREEK +LANGUAGE_GREENLANDIC = _gdi.LANGUAGE_GREENLANDIC +LANGUAGE_GUARANI = _gdi.LANGUAGE_GUARANI +LANGUAGE_GUJARATI = _gdi.LANGUAGE_GUJARATI +LANGUAGE_HAUSA = _gdi.LANGUAGE_HAUSA +LANGUAGE_HEBREW = _gdi.LANGUAGE_HEBREW +LANGUAGE_HINDI = _gdi.LANGUAGE_HINDI +LANGUAGE_HUNGARIAN = _gdi.LANGUAGE_HUNGARIAN +LANGUAGE_ICELANDIC = _gdi.LANGUAGE_ICELANDIC +LANGUAGE_INDONESIAN = _gdi.LANGUAGE_INDONESIAN +LANGUAGE_INTERLINGUA = _gdi.LANGUAGE_INTERLINGUA +LANGUAGE_INTERLINGUE = _gdi.LANGUAGE_INTERLINGUE +LANGUAGE_INUKTITUT = _gdi.LANGUAGE_INUKTITUT +LANGUAGE_INUPIAK = _gdi.LANGUAGE_INUPIAK +LANGUAGE_IRISH = _gdi.LANGUAGE_IRISH +LANGUAGE_ITALIAN = _gdi.LANGUAGE_ITALIAN +LANGUAGE_ITALIAN_SWISS = _gdi.LANGUAGE_ITALIAN_SWISS +LANGUAGE_JAPANESE = _gdi.LANGUAGE_JAPANESE +LANGUAGE_JAVANESE = _gdi.LANGUAGE_JAVANESE +LANGUAGE_KANNADA = _gdi.LANGUAGE_KANNADA +LANGUAGE_KASHMIRI = _gdi.LANGUAGE_KASHMIRI +LANGUAGE_KASHMIRI_INDIA = _gdi.LANGUAGE_KASHMIRI_INDIA +LANGUAGE_KAZAKH = _gdi.LANGUAGE_KAZAKH +LANGUAGE_KERNEWEK = _gdi.LANGUAGE_KERNEWEK +LANGUAGE_KINYARWANDA = _gdi.LANGUAGE_KINYARWANDA +LANGUAGE_KIRGHIZ = _gdi.LANGUAGE_KIRGHIZ +LANGUAGE_KIRUNDI = _gdi.LANGUAGE_KIRUNDI +LANGUAGE_KONKANI = _gdi.LANGUAGE_KONKANI +LANGUAGE_KOREAN = _gdi.LANGUAGE_KOREAN +LANGUAGE_KURDISH = _gdi.LANGUAGE_KURDISH +LANGUAGE_LAOTHIAN = _gdi.LANGUAGE_LAOTHIAN +LANGUAGE_LATIN = _gdi.LANGUAGE_LATIN +LANGUAGE_LATVIAN = _gdi.LANGUAGE_LATVIAN +LANGUAGE_LINGALA = _gdi.LANGUAGE_LINGALA +LANGUAGE_LITHUANIAN = _gdi.LANGUAGE_LITHUANIAN +LANGUAGE_MACEDONIAN = _gdi.LANGUAGE_MACEDONIAN +LANGUAGE_MALAGASY = _gdi.LANGUAGE_MALAGASY +LANGUAGE_MALAY = _gdi.LANGUAGE_MALAY +LANGUAGE_MALAYALAM = _gdi.LANGUAGE_MALAYALAM +LANGUAGE_MALAY_BRUNEI_DARUSSALAM = _gdi.LANGUAGE_MALAY_BRUNEI_DARUSSALAM +LANGUAGE_MALAY_MALAYSIA = _gdi.LANGUAGE_MALAY_MALAYSIA +LANGUAGE_MALTESE = _gdi.LANGUAGE_MALTESE +LANGUAGE_MANIPURI = _gdi.LANGUAGE_MANIPURI +LANGUAGE_MAORI = _gdi.LANGUAGE_MAORI +LANGUAGE_MARATHI = _gdi.LANGUAGE_MARATHI +LANGUAGE_MOLDAVIAN = _gdi.LANGUAGE_MOLDAVIAN +LANGUAGE_MONGOLIAN = _gdi.LANGUAGE_MONGOLIAN +LANGUAGE_NAURU = _gdi.LANGUAGE_NAURU +LANGUAGE_NEPALI = _gdi.LANGUAGE_NEPALI +LANGUAGE_NEPALI_INDIA = _gdi.LANGUAGE_NEPALI_INDIA +LANGUAGE_NORWEGIAN_BOKMAL = _gdi.LANGUAGE_NORWEGIAN_BOKMAL +LANGUAGE_NORWEGIAN_NYNORSK = _gdi.LANGUAGE_NORWEGIAN_NYNORSK +LANGUAGE_OCCITAN = _gdi.LANGUAGE_OCCITAN +LANGUAGE_ORIYA = _gdi.LANGUAGE_ORIYA +LANGUAGE_OROMO = _gdi.LANGUAGE_OROMO +LANGUAGE_PASHTO = _gdi.LANGUAGE_PASHTO +LANGUAGE_POLISH = _gdi.LANGUAGE_POLISH +LANGUAGE_PORTUGUESE = _gdi.LANGUAGE_PORTUGUESE +LANGUAGE_PORTUGUESE_BRAZILIAN = _gdi.LANGUAGE_PORTUGUESE_BRAZILIAN +LANGUAGE_PUNJABI = _gdi.LANGUAGE_PUNJABI +LANGUAGE_QUECHUA = _gdi.LANGUAGE_QUECHUA +LANGUAGE_RHAETO_ROMANCE = _gdi.LANGUAGE_RHAETO_ROMANCE +LANGUAGE_ROMANIAN = _gdi.LANGUAGE_ROMANIAN +LANGUAGE_RUSSIAN = _gdi.LANGUAGE_RUSSIAN +LANGUAGE_RUSSIAN_UKRAINE = _gdi.LANGUAGE_RUSSIAN_UKRAINE +LANGUAGE_SAMOAN = _gdi.LANGUAGE_SAMOAN +LANGUAGE_SANGHO = _gdi.LANGUAGE_SANGHO +LANGUAGE_SANSKRIT = _gdi.LANGUAGE_SANSKRIT +LANGUAGE_SCOTS_GAELIC = _gdi.LANGUAGE_SCOTS_GAELIC +LANGUAGE_SERBIAN = _gdi.LANGUAGE_SERBIAN +LANGUAGE_SERBIAN_CYRILLIC = _gdi.LANGUAGE_SERBIAN_CYRILLIC +LANGUAGE_SERBIAN_LATIN = _gdi.LANGUAGE_SERBIAN_LATIN +LANGUAGE_SERBO_CROATIAN = _gdi.LANGUAGE_SERBO_CROATIAN +LANGUAGE_SESOTHO = _gdi.LANGUAGE_SESOTHO +LANGUAGE_SETSWANA = _gdi.LANGUAGE_SETSWANA +LANGUAGE_SHONA = _gdi.LANGUAGE_SHONA +LANGUAGE_SINDHI = _gdi.LANGUAGE_SINDHI +LANGUAGE_SINHALESE = _gdi.LANGUAGE_SINHALESE +LANGUAGE_SISWATI = _gdi.LANGUAGE_SISWATI +LANGUAGE_SLOVAK = _gdi.LANGUAGE_SLOVAK +LANGUAGE_SLOVENIAN = _gdi.LANGUAGE_SLOVENIAN +LANGUAGE_SOMALI = _gdi.LANGUAGE_SOMALI +LANGUAGE_SPANISH = _gdi.LANGUAGE_SPANISH +LANGUAGE_SPANISH_ARGENTINA = _gdi.LANGUAGE_SPANISH_ARGENTINA +LANGUAGE_SPANISH_BOLIVIA = _gdi.LANGUAGE_SPANISH_BOLIVIA +LANGUAGE_SPANISH_CHILE = _gdi.LANGUAGE_SPANISH_CHILE +LANGUAGE_SPANISH_COLOMBIA = _gdi.LANGUAGE_SPANISH_COLOMBIA +LANGUAGE_SPANISH_COSTA_RICA = _gdi.LANGUAGE_SPANISH_COSTA_RICA +LANGUAGE_SPANISH_DOMINICAN_REPUBLIC = _gdi.LANGUAGE_SPANISH_DOMINICAN_REPUBLIC +LANGUAGE_SPANISH_ECUADOR = _gdi.LANGUAGE_SPANISH_ECUADOR +LANGUAGE_SPANISH_EL_SALVADOR = _gdi.LANGUAGE_SPANISH_EL_SALVADOR +LANGUAGE_SPANISH_GUATEMALA = _gdi.LANGUAGE_SPANISH_GUATEMALA +LANGUAGE_SPANISH_HONDURAS = _gdi.LANGUAGE_SPANISH_HONDURAS +LANGUAGE_SPANISH_MEXICAN = _gdi.LANGUAGE_SPANISH_MEXICAN +LANGUAGE_SPANISH_MODERN = _gdi.LANGUAGE_SPANISH_MODERN +LANGUAGE_SPANISH_NICARAGUA = _gdi.LANGUAGE_SPANISH_NICARAGUA +LANGUAGE_SPANISH_PANAMA = _gdi.LANGUAGE_SPANISH_PANAMA +LANGUAGE_SPANISH_PARAGUAY = _gdi.LANGUAGE_SPANISH_PARAGUAY +LANGUAGE_SPANISH_PERU = _gdi.LANGUAGE_SPANISH_PERU +LANGUAGE_SPANISH_PUERTO_RICO = _gdi.LANGUAGE_SPANISH_PUERTO_RICO +LANGUAGE_SPANISH_URUGUAY = _gdi.LANGUAGE_SPANISH_URUGUAY +LANGUAGE_SPANISH_US = _gdi.LANGUAGE_SPANISH_US +LANGUAGE_SPANISH_VENEZUELA = _gdi.LANGUAGE_SPANISH_VENEZUELA +LANGUAGE_SUNDANESE = _gdi.LANGUAGE_SUNDANESE +LANGUAGE_SWAHILI = _gdi.LANGUAGE_SWAHILI +LANGUAGE_SWEDISH = _gdi.LANGUAGE_SWEDISH +LANGUAGE_SWEDISH_FINLAND = _gdi.LANGUAGE_SWEDISH_FINLAND +LANGUAGE_TAGALOG = _gdi.LANGUAGE_TAGALOG +LANGUAGE_TAJIK = _gdi.LANGUAGE_TAJIK +LANGUAGE_TAMIL = _gdi.LANGUAGE_TAMIL +LANGUAGE_TATAR = _gdi.LANGUAGE_TATAR +LANGUAGE_TELUGU = _gdi.LANGUAGE_TELUGU +LANGUAGE_THAI = _gdi.LANGUAGE_THAI +LANGUAGE_TIBETAN = _gdi.LANGUAGE_TIBETAN +LANGUAGE_TIGRINYA = _gdi.LANGUAGE_TIGRINYA +LANGUAGE_TONGA = _gdi.LANGUAGE_TONGA +LANGUAGE_TSONGA = _gdi.LANGUAGE_TSONGA +LANGUAGE_TURKISH = _gdi.LANGUAGE_TURKISH +LANGUAGE_TURKMEN = _gdi.LANGUAGE_TURKMEN +LANGUAGE_TWI = _gdi.LANGUAGE_TWI +LANGUAGE_UIGHUR = _gdi.LANGUAGE_UIGHUR +LANGUAGE_UKRAINIAN = _gdi.LANGUAGE_UKRAINIAN +LANGUAGE_URDU = _gdi.LANGUAGE_URDU +LANGUAGE_URDU_INDIA = _gdi.LANGUAGE_URDU_INDIA +LANGUAGE_URDU_PAKISTAN = _gdi.LANGUAGE_URDU_PAKISTAN +LANGUAGE_UZBEK = _gdi.LANGUAGE_UZBEK +LANGUAGE_UZBEK_CYRILLIC = _gdi.LANGUAGE_UZBEK_CYRILLIC +LANGUAGE_UZBEK_LATIN = _gdi.LANGUAGE_UZBEK_LATIN +LANGUAGE_VIETNAMESE = _gdi.LANGUAGE_VIETNAMESE +LANGUAGE_VOLAPUK = _gdi.LANGUAGE_VOLAPUK +LANGUAGE_WELSH = _gdi.LANGUAGE_WELSH +LANGUAGE_WOLOF = _gdi.LANGUAGE_WOLOF +LANGUAGE_XHOSA = _gdi.LANGUAGE_XHOSA +LANGUAGE_YIDDISH = _gdi.LANGUAGE_YIDDISH +LANGUAGE_YORUBA = _gdi.LANGUAGE_YORUBA +LANGUAGE_ZHUANG = _gdi.LANGUAGE_ZHUANG +LANGUAGE_ZULU = _gdi.LANGUAGE_ZULU +LANGUAGE_USER_DEFINED = _gdi.LANGUAGE_USER_DEFINED +class LanguageInfo(object): + def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): - return "" % (self.this,) -class wxFontList(wxFontListPtr): - def __init__(self,this): + return "<%s.%s; proxy of C++ wxLanguageInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + Language = property(_gdi.LanguageInfo_Language_get, _gdi.LanguageInfo_Language_set) + CanonicalName = property(_gdi.LanguageInfo_CanonicalName_get, _gdi.LanguageInfo_CanonicalName_set) + Description = property(_gdi.LanguageInfo_Description_get, _gdi.LanguageInfo_Description_set) + +class LanguageInfoPtr(LanguageInfo): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = LanguageInfo +_gdi.LanguageInfo_swigregister(LanguageInfoPtr) + +LOCALE_CAT_NUMBER = _gdi.LOCALE_CAT_NUMBER +LOCALE_CAT_DATE = _gdi.LOCALE_CAT_DATE +LOCALE_CAT_MONEY = _gdi.LOCALE_CAT_MONEY +LOCALE_CAT_MAX = _gdi.LOCALE_CAT_MAX +LOCALE_THOUSANDS_SEP = _gdi.LOCALE_THOUSANDS_SEP +LOCALE_DECIMAL_POINT = _gdi.LOCALE_DECIMAL_POINT +LOCALE_LOAD_DEFAULT = _gdi.LOCALE_LOAD_DEFAULT +LOCALE_CONV_ENCODING = _gdi.LOCALE_CONV_ENCODING +class Locale(object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxLocale instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> Locale""" + newobj = _gdi.new_Locale(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_Locale): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Init1(*args, **kwargs): + """ + Init1(String szName, String szShort=EmptyString, String szLocale=EmptyString, + bool bLoadDefault=True, + bool bConvertEncoding=False) -> bool + """ + return _gdi.Locale_Init1(*args, **kwargs) + + def Init2(*args, **kwargs): + """Init2(int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> bool""" + return _gdi.Locale_Init2(*args, **kwargs) + + def Init(self, *_args, **_kwargs): + if type(_args[0]) in [type(''), type(u'')]: + val = self.Init1(*_args, **_kwargs) + else: + val = self.Init2(*_args, **_kwargs) + return val + + def GetSystemLanguage(*args, **kwargs): + """Locale.GetSystemLanguage() -> int""" + return _gdi.Locale_GetSystemLanguage(*args, **kwargs) + + GetSystemLanguage = staticmethod(GetSystemLanguage) + def GetSystemEncoding(*args, **kwargs): + """Locale.GetSystemEncoding() -> int""" + return _gdi.Locale_GetSystemEncoding(*args, **kwargs) + + GetSystemEncoding = staticmethod(GetSystemEncoding) + def GetSystemEncodingName(*args, **kwargs): + """Locale.GetSystemEncodingName() -> String""" + return _gdi.Locale_GetSystemEncodingName(*args, **kwargs) + + GetSystemEncodingName = staticmethod(GetSystemEncodingName) + def IsOk(*args, **kwargs): + """IsOk() -> bool""" + return _gdi.Locale_IsOk(*args, **kwargs) + + def __nonzero__(self): return self.IsOk() + def GetLocale(*args, **kwargs): + """GetLocale() -> String""" + return _gdi.Locale_GetLocale(*args, **kwargs) + + def GetLanguage(*args, **kwargs): + """GetLanguage() -> int""" + return _gdi.Locale_GetLanguage(*args, **kwargs) + + def GetSysName(*args, **kwargs): + """GetSysName() -> String""" + return _gdi.Locale_GetSysName(*args, **kwargs) + + def GetCanonicalName(*args, **kwargs): + """GetCanonicalName() -> String""" + return _gdi.Locale_GetCanonicalName(*args, **kwargs) + + def AddCatalogLookupPathPrefix(*args, **kwargs): + """Locale.AddCatalogLookupPathPrefix(String prefix)""" + return _gdi.Locale_AddCatalogLookupPathPrefix(*args, **kwargs) + + AddCatalogLookupPathPrefix = staticmethod(AddCatalogLookupPathPrefix) + def AddCatalog(*args, **kwargs): + """AddCatalog(String szDomain) -> bool""" + return _gdi.Locale_AddCatalog(*args, **kwargs) + + def IsLoaded(*args, **kwargs): + """IsLoaded(String szDomain) -> bool""" + return _gdi.Locale_IsLoaded(*args, **kwargs) + + def GetLanguageInfo(*args, **kwargs): + """Locale.GetLanguageInfo(int lang) -> LanguageInfo""" + return _gdi.Locale_GetLanguageInfo(*args, **kwargs) + + GetLanguageInfo = staticmethod(GetLanguageInfo) + def GetLanguageName(*args, **kwargs): + """Locale.GetLanguageName(int lang) -> String""" + return _gdi.Locale_GetLanguageName(*args, **kwargs) + + GetLanguageName = staticmethod(GetLanguageName) + def FindLanguageInfo(*args, **kwargs): + """Locale.FindLanguageInfo(String locale) -> LanguageInfo""" + return _gdi.Locale_FindLanguageInfo(*args, **kwargs) + + FindLanguageInfo = staticmethod(FindLanguageInfo) + def AddLanguage(*args, **kwargs): + """Locale.AddLanguage(LanguageInfo info)""" + return _gdi.Locale_AddLanguage(*args, **kwargs) + + AddLanguage = staticmethod(AddLanguage) + def GetString(*args, **kwargs): + """GetString(String szOrigString, String szDomain=EmptyString) -> String""" + return _gdi.Locale_GetString(*args, **kwargs) + + def GetName(*args, **kwargs): + """GetName() -> String""" + return _gdi.Locale_GetName(*args, **kwargs) + + +class LocalePtr(Locale): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Locale +_gdi.Locale_swigregister(LocalePtr) + +def Locale_GetSystemLanguage(*args, **kwargs): + """Locale_GetSystemLanguage() -> int""" + return _gdi.Locale_GetSystemLanguage(*args, **kwargs) + +def Locale_GetSystemEncoding(*args, **kwargs): + """Locale_GetSystemEncoding() -> int""" + return _gdi.Locale_GetSystemEncoding(*args, **kwargs) + +def Locale_GetSystemEncodingName(*args, **kwargs): + """Locale_GetSystemEncodingName() -> String""" + return _gdi.Locale_GetSystemEncodingName(*args, **kwargs) + +def Locale_AddCatalogLookupPathPrefix(*args, **kwargs): + """Locale_AddCatalogLookupPathPrefix(String prefix)""" + return _gdi.Locale_AddCatalogLookupPathPrefix(*args, **kwargs) + +def Locale_GetLanguageInfo(*args, **kwargs): + """Locale_GetLanguageInfo(int lang) -> LanguageInfo""" + return _gdi.Locale_GetLanguageInfo(*args, **kwargs) + +def Locale_GetLanguageName(*args, **kwargs): + """Locale_GetLanguageName(int lang) -> String""" + return _gdi.Locale_GetLanguageName(*args, **kwargs) + +def Locale_FindLanguageInfo(*args, **kwargs): + """Locale_FindLanguageInfo(String locale) -> LanguageInfo""" + return _gdi.Locale_FindLanguageInfo(*args, **kwargs) + +def Locale_AddLanguage(*args, **kwargs): + """Locale_AddLanguage(LanguageInfo info)""" + return _gdi.Locale_AddLanguage(*args, **kwargs) + + +def GetLocale(*args, **kwargs): + """GetLocale() -> Locale""" + return _gdi.GetLocale(*args, **kwargs) +#--------------------------------------------------------------------------- + +CONVERT_STRICT = _gdi.CONVERT_STRICT +CONVERT_SUBSTITUTE = _gdi.CONVERT_SUBSTITUTE +PLATFORM_CURRENT = _gdi.PLATFORM_CURRENT +PLATFORM_UNIX = _gdi.PLATFORM_UNIX +PLATFORM_WINDOWS = _gdi.PLATFORM_WINDOWS +PLATFORM_OS2 = _gdi.PLATFORM_OS2 +PLATFORM_MAC = _gdi.PLATFORM_MAC +class EncodingConverter(core.Object): + def __repr__(self): + return "<%s.%s; proxy of C++ wxEncodingConverter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> EncodingConverter""" + newobj = _gdi.new_EncodingConverter(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_EncodingConverter): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def Init(*args, **kwargs): + """Init(int input_enc, int output_enc, int method=CONVERT_STRICT) -> bool""" + return _gdi.EncodingConverter_Init(*args, **kwargs) + def Convert(*args, **kwargs): + """Convert(String input) -> String""" + return _gdi.EncodingConverter_Convert(*args, **kwargs) + def GetPlatformEquivalents(*args, **kwargs): + """EncodingConverter.GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray""" + return _gdi.EncodingConverter_GetPlatformEquivalents(*args, **kwargs) + GetPlatformEquivalents = staticmethod(GetPlatformEquivalents) + def GetAllEquivalents(*args, **kwargs): + """EncodingConverter.GetAllEquivalents(int enc) -> wxFontEncodingArray""" + return _gdi.EncodingConverter_GetAllEquivalents(*args, **kwargs) -class wxColourPtr(wxObjectPtr): - def __init__(self,this): + GetAllEquivalents = staticmethod(GetAllEquivalents) + def CanConvert(*args, **kwargs): + """EncodingConverter.CanConvert(int encIn, int encOut) -> bool""" + return _gdi.EncodingConverter_CanConvert(*args, **kwargs) + + CanConvert = staticmethod(CanConvert) + def __nonzero__(self): return self.IsOk() + +class EncodingConverterPtr(EncodingConverter): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxColour(self) - def Red(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Red,(self,) + _args, _kwargs) - return val - def Green(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Green,(self,) + _args, _kwargs) - return val - def Blue(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Blue,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Ok,(self,) + _args, _kwargs) - return val - def Set(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Set,(self,) + _args, _kwargs) - return val - def Get(self, *_args, **_kwargs): - val = apply(gdic.wxColour_Get,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = EncodingConverter +_gdi.EncodingConverter_swigregister(EncodingConverterPtr) + +def GetTranslation(*args): + """ + GetTranslation(String sz) -> String + GetTranslation(String sz1, String sz2, size_t n) -> String + """ + return _gdi.GetTranslation(*args) + +def EncodingConverter_GetPlatformEquivalents(*args, **kwargs): + """EncodingConverter_GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray""" + return _gdi.EncodingConverter_GetPlatformEquivalents(*args, **kwargs) + +def EncodingConverter_GetAllEquivalents(*args, **kwargs): + """EncodingConverter_GetAllEquivalents(int enc) -> wxFontEncodingArray""" + return _gdi.EncodingConverter_GetAllEquivalents(*args, **kwargs) + +def EncodingConverter_CanConvert(*args, **kwargs): + """EncodingConverter_CanConvert(int encIn, int encOut) -> bool""" + return _gdi.EncodingConverter_CanConvert(*args, **kwargs) + +#---------------------------------------------------------------------------- +# wxGTK sets the locale when initialized. Doing this at the Python +# level should set it up to match what GTK is doing at the C level. +if wx.Platform == "__WXGTK__": + try: + import locale + locale.setlocale(locale.LC_ALL, "") + except: + pass + +# On MSW add the directory where the wxWindows catalogs were installed +# to the default catalog path. +if wx.Platform == "__WXMSW__": + import os + localedir = os.path.join(os.path.split(__file__)[0], "locale") + Locale_AddCatalogLookupPathPrefix(localedir) + del os + +#---------------------------------------------------------------------------- + +#--------------------------------------------------------------------------- + +class DC(core.Object): + def __init__(self): raise RuntimeError, "No constructor defined" + def __repr__(self): + return "<%s.%s; proxy of C++ wxDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __del__(self, destroy=_gdi.delete_DC): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + + def BeginDrawing(*args, **kwargs): + """BeginDrawing()""" + return _gdi.DC_BeginDrawing(*args, **kwargs) + + def EndDrawing(*args, **kwargs): + """EndDrawing()""" + return _gdi.DC_EndDrawing(*args, **kwargs) + + def FloodFillXY(*args, **kwargs): + """FloodFillXY(int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool""" + return _gdi.DC_FloodFillXY(*args, **kwargs) + + def FloodFill(*args, **kwargs): + """FloodFill(Point pt, Colour col, int style=FLOOD_SURFACE) -> bool""" + return _gdi.DC_FloodFill(*args, **kwargs) + + def GetPixelXY(*args, **kwargs): + """GetPixelXY(int x, int y) -> Colour""" + return _gdi.DC_GetPixelXY(*args, **kwargs) + + def GetPixel(*args, **kwargs): + """GetPixel(Point pt) -> Colour""" + return _gdi.DC_GetPixel(*args, **kwargs) + + def DrawLineXY(*args, **kwargs): + """DrawLineXY(int x1, int y1, int x2, int y2)""" + return _gdi.DC_DrawLineXY(*args, **kwargs) + + def DrawLine(*args, **kwargs): + """DrawLine(Point pt1, Point pt2)""" + return _gdi.DC_DrawLine(*args, **kwargs) + + def CrossHairXY(*args, **kwargs): + """CrossHairXY(int x, int y)""" + return _gdi.DC_CrossHairXY(*args, **kwargs) + + def CrossHair(*args, **kwargs): + """CrossHair(Point pt)""" + return _gdi.DC_CrossHair(*args, **kwargs) + + def DrawArcXY(*args, **kwargs): + """DrawArcXY(int x1, int y1, int x2, int y2, int xc, int yc)""" + return _gdi.DC_DrawArcXY(*args, **kwargs) + + def DrawArc(*args, **kwargs): + """DrawArc(Point pt1, Point pt2, Point centre)""" + return _gdi.DC_DrawArc(*args, **kwargs) + + def DrawCheckMarkXY(*args, **kwargs): + """DrawCheckMarkXY(int x, int y, int width, int height)""" + return _gdi.DC_DrawCheckMarkXY(*args, **kwargs) + + def DrawCheckMark(*args, **kwargs): + """DrawCheckMark(Rect rect)""" + return _gdi.DC_DrawCheckMark(*args, **kwargs) + + def DrawEllipticArcXY(*args, **kwargs): + """DrawEllipticArcXY(int x, int y, int w, int h, double sa, double ea)""" + return _gdi.DC_DrawEllipticArcXY(*args, **kwargs) + + def DrawEllipticArc(*args, **kwargs): + """DrawEllipticArc(Point pt, Size sz, double sa, double ea)""" + return _gdi.DC_DrawEllipticArc(*args, **kwargs) + + def DrawPointXY(*args, **kwargs): + """DrawPointXY(int x, int y)""" + return _gdi.DC_DrawPointXY(*args, **kwargs) + + def DrawPoint(*args, **kwargs): + """DrawPoint(Point pt)""" + return _gdi.DC_DrawPoint(*args, **kwargs) + + def DrawRectangleXY(*args, **kwargs): + """DrawRectangleXY(int x, int y, int width, int height)""" + return _gdi.DC_DrawRectangleXY(*args, **kwargs) + + def DrawRectangle(*args, **kwargs): + """DrawRectangle(Point pt, Size sz)""" + return _gdi.DC_DrawRectangle(*args, **kwargs) + + def DrawRectangleRect(*args, **kwargs): + """DrawRectangleRect(Rect rect)""" + return _gdi.DC_DrawRectangleRect(*args, **kwargs) + + def DrawRoundedRectangleXY(*args, **kwargs): + """DrawRoundedRectangleXY(int x, int y, int width, int height, double radius)""" + return _gdi.DC_DrawRoundedRectangleXY(*args, **kwargs) + + def DrawRoundedRectangle(*args, **kwargs): + """DrawRoundedRectangle(Point pt, Size sz, double radius)""" + return _gdi.DC_DrawRoundedRectangle(*args, **kwargs) + + def DrawRoundedRectangleRect(*args, **kwargs): + """DrawRoundedRectangleRect(Rect r, double radius)""" + return _gdi.DC_DrawRoundedRectangleRect(*args, **kwargs) + + def DrawCircleXY(*args, **kwargs): + """DrawCircleXY(int x, int y, int radius)""" + return _gdi.DC_DrawCircleXY(*args, **kwargs) + + def DrawCircle(*args, **kwargs): + """DrawCircle(Point pt, int radius)""" + return _gdi.DC_DrawCircle(*args, **kwargs) + + def DrawEllipseXY(*args, **kwargs): + """DrawEllipseXY(int x, int y, int width, int height)""" + return _gdi.DC_DrawEllipseXY(*args, **kwargs) + + def DrawEllipse(*args, **kwargs): + """DrawEllipse(Point pt, Size sz)""" + return _gdi.DC_DrawEllipse(*args, **kwargs) + + def DrawEllipseRect(*args, **kwargs): + """DrawEllipseRect(Rect rect)""" + return _gdi.DC_DrawEllipseRect(*args, **kwargs) + + def DrawIconXY(*args, **kwargs): + """DrawIconXY(Icon icon, int x, int y)""" + return _gdi.DC_DrawIconXY(*args, **kwargs) + + def DrawIcon(*args, **kwargs): + """DrawIcon(Icon icon, Point pt)""" + return _gdi.DC_DrawIcon(*args, **kwargs) + + def DrawBitmapXY(*args, **kwargs): + """DrawBitmapXY(Bitmap bmp, int x, int y, bool useMask=False)""" + return _gdi.DC_DrawBitmapXY(*args, **kwargs) + + def DrawBitmap(*args, **kwargs): + """DrawBitmap(Bitmap bmp, Point pt, bool useMask=False)""" + return _gdi.DC_DrawBitmap(*args, **kwargs) + + def DrawTextXY(*args, **kwargs): + """DrawTextXY(String text, int x, int y)""" + return _gdi.DC_DrawTextXY(*args, **kwargs) + + def DrawText(*args, **kwargs): + """DrawText(String text, Point pt)""" + return _gdi.DC_DrawText(*args, **kwargs) + + def DrawRotatedTextXY(*args, **kwargs): + """DrawRotatedTextXY(String text, int x, int y, double angle)""" + return _gdi.DC_DrawRotatedTextXY(*args, **kwargs) + + def DrawRotatedText(*args, **kwargs): + """DrawRotatedText(String text, Point pt, double angle)""" + return _gdi.DC_DrawRotatedText(*args, **kwargs) + + def BlitXY(*args, **kwargs): + """ + BlitXY(int xdest, int ydest, int width, int height, DC source, + int xsrc, int ysrc, int rop=COPY, bool useMask=False, + int xsrcMask=-1, int ysrcMask=-1) -> bool + """ + return _gdi.DC_BlitXY(*args, **kwargs) + + def Blit(*args, **kwargs): + """ + Blit(Point destPt, Size sz, DC source, Point srcPt, int rop=COPY, + bool useMask=False, Point srcPtMask=DefaultPosition) -> bool + """ + return _gdi.DC_Blit(*args, **kwargs) + + def DrawLines(*args, **kwargs): + """DrawLines(int points, Point points_array, int xoffset=0, int yoffset=0)""" + return _gdi.DC_DrawLines(*args, **kwargs) + + def DrawPolygon(*args, **kwargs): + """ + DrawPolygon(int points, Point points_array, int xoffset=0, int yoffset=0, + int fillStyle=ODDEVEN_RULE) + """ + return _gdi.DC_DrawPolygon(*args, **kwargs) + + def DrawLabel(*args, **kwargs): + """ + DrawLabel(String text, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP, + int indexAccel=-1) + """ + return _gdi.DC_DrawLabel(*args, **kwargs) + + def DrawImageLabel(*args, **kwargs): + """ + DrawImageLabel(String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP, + int indexAccel=-1) -> Rect + """ + return _gdi.DC_DrawImageLabel(*args, **kwargs) + + def DrawSpline(*args, **kwargs): + """DrawSpline(int points, Point points_array)""" + return _gdi.DC_DrawSpline(*args, **kwargs) + + def Clear(*args, **kwargs): + """Clear()""" + return _gdi.DC_Clear(*args, **kwargs) + + def StartDoc(*args, **kwargs): + """StartDoc(String message) -> bool""" + return _gdi.DC_StartDoc(*args, **kwargs) + + def EndDoc(*args, **kwargs): + """EndDoc()""" + return _gdi.DC_EndDoc(*args, **kwargs) + + def StartPage(*args, **kwargs): + """StartPage()""" + return _gdi.DC_StartPage(*args, **kwargs) + + def EndPage(*args, **kwargs): + """EndPage()""" + return _gdi.DC_EndPage(*args, **kwargs) + + def SetFont(*args, **kwargs): + """SetFont(Font font)""" + return _gdi.DC_SetFont(*args, **kwargs) + + def SetPen(*args, **kwargs): + """SetPen(Pen pen)""" + return _gdi.DC_SetPen(*args, **kwargs) + + def SetBrush(*args, **kwargs): + """SetBrush(Brush brush)""" + return _gdi.DC_SetBrush(*args, **kwargs) + + def SetBackground(*args, **kwargs): + """SetBackground(Brush brush)""" + return _gdi.DC_SetBackground(*args, **kwargs) + + def SetBackgroundMode(*args, **kwargs): + """SetBackgroundMode(int mode)""" + return _gdi.DC_SetBackgroundMode(*args, **kwargs) + + def SetPalette(*args, **kwargs): + """SetPalette(Palette palette)""" + return _gdi.DC_SetPalette(*args, **kwargs) + + def SetClippingRegionXY(*args, **kwargs): + """SetClippingRegionXY(int x, int y, int width, int height)""" + return _gdi.DC_SetClippingRegionXY(*args, **kwargs) + + def SetClippingRegion(*args, **kwargs): + """SetClippingRegion(Point pt, Size sz)""" + return _gdi.DC_SetClippingRegion(*args, **kwargs) + + def SetClippingRect(*args, **kwargs): + """SetClippingRect(Rect rect)""" + return _gdi.DC_SetClippingRect(*args, **kwargs) + + def SetClippingRegionAsRegion(*args, **kwargs): + """SetClippingRegionAsRegion(Region region)""" + return _gdi.DC_SetClippingRegionAsRegion(*args, **kwargs) + + def DestroyClippingRegion(*args, **kwargs): + """DestroyClippingRegion()""" + return _gdi.DC_DestroyClippingRegion(*args, **kwargs) + + def GetClippingBox(*args, **kwargs): + """GetClippingBox() -> (x, y, width, height)""" + return _gdi.DC_GetClippingBox(*args, **kwargs) + + def GetClippingRect(*args, **kwargs): + """GetClippingRect() -> Rect""" + return _gdi.DC_GetClippingRect(*args, **kwargs) + + def GetCharHeight(*args, **kwargs): + """GetCharHeight() -> int""" + return _gdi.DC_GetCharHeight(*args, **kwargs) + + def GetCharWidth(*args, **kwargs): + """GetCharWidth() -> int""" + return _gdi.DC_GetCharWidth(*args, **kwargs) + + def GetTextExtent(*args, **kwargs): + """ + GetTextExtent(wxString string) -> (width, height) + + Get the width and height of the text using the current font. + Only works for single line strings. + """ + return _gdi.DC_GetTextExtent(*args, **kwargs) + + def GetFullTextExtent(*args, **kwargs): + """ + GetFullTextExtent(wxString string, Font font=None) -> + (width, height, descent, externalLeading) + + Get the width, height, decent and leading of the text using the current or specified font. + Only works for single line strings. + """ + return _gdi.DC_GetFullTextExtent(*args, **kwargs) + + def GetMultiLineTextExtent(*args, **kwargs): + """ + GetMultiLineTextExtent(wxString string, Font font=None) -> + (width, height, descent, externalLeading) + + Get the width, height, decent and leading of the text using the current or specified font. + Works for single as well as multi-line strings. + """ + return _gdi.DC_GetMultiLineTextExtent(*args, **kwargs) + + def GetSize(*args, **kwargs): + """ + GetSize() -> Size + + Get the DC size in device units. + """ + return _gdi.DC_GetSize(*args, **kwargs) + + def GetSizeTuple(*args, **kwargs): + """ + GetSizeTuple() -> (width, height) + + Get the DC size in device units. + """ + return _gdi.DC_GetSizeTuple(*args, **kwargs) + + def GetSizeMM(*args, **kwargs): + """ + GetSizeMM() -> Size + + Get the DC size in milimeters. + """ + return _gdi.DC_GetSizeMM(*args, **kwargs) + + def GetSizeMMTuple(*args, **kwargs): + """ + GetSizeMMTuple() -> (width, height) + + Get the DC size in milimeters. + """ + return _gdi.DC_GetSizeMMTuple(*args, **kwargs) + + def DeviceToLogicalX(*args, **kwargs): + """DeviceToLogicalX(int x) -> int""" + return _gdi.DC_DeviceToLogicalX(*args, **kwargs) + + def DeviceToLogicalY(*args, **kwargs): + """DeviceToLogicalY(int y) -> int""" + return _gdi.DC_DeviceToLogicalY(*args, **kwargs) + + def DeviceToLogicalXRel(*args, **kwargs): + """DeviceToLogicalXRel(int x) -> int""" + return _gdi.DC_DeviceToLogicalXRel(*args, **kwargs) + + def DeviceToLogicalYRel(*args, **kwargs): + """DeviceToLogicalYRel(int y) -> int""" + return _gdi.DC_DeviceToLogicalYRel(*args, **kwargs) + + def LogicalToDeviceX(*args, **kwargs): + """LogicalToDeviceX(int x) -> int""" + return _gdi.DC_LogicalToDeviceX(*args, **kwargs) + + def LogicalToDeviceY(*args, **kwargs): + """LogicalToDeviceY(int y) -> int""" + return _gdi.DC_LogicalToDeviceY(*args, **kwargs) + + def LogicalToDeviceXRel(*args, **kwargs): + """LogicalToDeviceXRel(int x) -> int""" + return _gdi.DC_LogicalToDeviceXRel(*args, **kwargs) + + def LogicalToDeviceYRel(*args, **kwargs): + """LogicalToDeviceYRel(int y) -> int""" + return _gdi.DC_LogicalToDeviceYRel(*args, **kwargs) + + def CanDrawBitmap(*args, **kwargs): + """CanDrawBitmap() -> bool""" + return _gdi.DC_CanDrawBitmap(*args, **kwargs) + + def CanGetTextExtent(*args, **kwargs): + """CanGetTextExtent() -> bool""" + return _gdi.DC_CanGetTextExtent(*args, **kwargs) + + def GetDepth(*args, **kwargs): + """GetDepth() -> int""" + return _gdi.DC_GetDepth(*args, **kwargs) + + def GetPPI(*args, **kwargs): + """GetPPI() -> Size""" + return _gdi.DC_GetPPI(*args, **kwargs) + + def Ok(*args, **kwargs): + """Ok() -> bool""" + return _gdi.DC_Ok(*args, **kwargs) + + def GetBackgroundMode(*args, **kwargs): + """GetBackgroundMode() -> int""" + return _gdi.DC_GetBackgroundMode(*args, **kwargs) + + def GetBackground(*args, **kwargs): + """GetBackground() -> Brush""" + return _gdi.DC_GetBackground(*args, **kwargs) + + def GetBrush(*args, **kwargs): + """GetBrush() -> Brush""" + return _gdi.DC_GetBrush(*args, **kwargs) + + def GetFont(*args, **kwargs): + """GetFont() -> Font""" + return _gdi.DC_GetFont(*args, **kwargs) + + def GetPen(*args, **kwargs): + """GetPen() -> Pen""" + return _gdi.DC_GetPen(*args, **kwargs) + + def GetTextBackground(*args, **kwargs): + """GetTextBackground() -> Colour""" + return _gdi.DC_GetTextBackground(*args, **kwargs) + + def GetTextForeground(*args, **kwargs): + """GetTextForeground() -> Colour""" + return _gdi.DC_GetTextForeground(*args, **kwargs) + + def SetTextForeground(*args, **kwargs): + """SetTextForeground(Colour colour)""" + return _gdi.DC_SetTextForeground(*args, **kwargs) + + def SetTextBackground(*args, **kwargs): + """SetTextBackground(Colour colour)""" + return _gdi.DC_SetTextBackground(*args, **kwargs) + + def GetMapMode(*args, **kwargs): + """GetMapMode() -> int""" + return _gdi.DC_GetMapMode(*args, **kwargs) + + def SetMapMode(*args, **kwargs): + """SetMapMode(int mode)""" + return _gdi.DC_SetMapMode(*args, **kwargs) + + def GetUserScale(*args, **kwargs): + """GetUserScale() -> (xScale, yScale)""" + return _gdi.DC_GetUserScale(*args, **kwargs) + + def SetUserScale(*args, **kwargs): + """SetUserScale(double x, double y)""" + return _gdi.DC_SetUserScale(*args, **kwargs) + + def GetLogicalScale(*args, **kwargs): + """GetLogicalScale() -> (xScale, yScale)""" + return _gdi.DC_GetLogicalScale(*args, **kwargs) + + def SetLogicalScale(*args, **kwargs): + """SetLogicalScale(double x, double y)""" + return _gdi.DC_SetLogicalScale(*args, **kwargs) + + def GetLogicalOrigin(*args, **kwargs): + """GetLogicalOrigin() -> Point""" + return _gdi.DC_GetLogicalOrigin(*args, **kwargs) + + def GetLogicalOriginTuple(*args, **kwargs): + """GetLogicalOriginTuple() -> (x,y)""" + return _gdi.DC_GetLogicalOriginTuple(*args, **kwargs) + + def SetLogicalOrigin(*args, **kwargs): + """SetLogicalOrigin(int x, int y)""" + return _gdi.DC_SetLogicalOrigin(*args, **kwargs) + + def GetDeviceOrigin(*args, **kwargs): + """GetDeviceOrigin() -> Point""" + return _gdi.DC_GetDeviceOrigin(*args, **kwargs) + + def GetDeviceOriginTuple(*args, **kwargs): + """GetDeviceOriginTuple() -> (x,y)""" + return _gdi.DC_GetDeviceOriginTuple(*args, **kwargs) + + def SetDeviceOrigin(*args, **kwargs): + """SetDeviceOrigin(int x, int y)""" + return _gdi.DC_SetDeviceOrigin(*args, **kwargs) + + def SetAxisOrientation(*args, **kwargs): + """SetAxisOrientation(bool xLeftRight, bool yBottomUp)""" + return _gdi.DC_SetAxisOrientation(*args, **kwargs) + + def GetLogicalFunction(*args, **kwargs): + """GetLogicalFunction() -> int""" + return _gdi.DC_GetLogicalFunction(*args, **kwargs) + + def SetLogicalFunction(*args, **kwargs): + """SetLogicalFunction(int function)""" + return _gdi.DC_SetLogicalFunction(*args, **kwargs) + + def SetOptimization(*args, **kwargs): + """SetOptimization(bool opt)""" + return _gdi.DC_SetOptimization(*args, **kwargs) + + def GetOptimization(*args, **kwargs): + """GetOptimization() -> bool""" + return _gdi.DC_GetOptimization(*args, **kwargs) + + def CalcBoundingBox(*args, **kwargs): + """CalcBoundingBox(int x, int y)""" + return _gdi.DC_CalcBoundingBox(*args, **kwargs) + + def ResetBoundingBox(*args, **kwargs): + """ResetBoundingBox()""" + return _gdi.DC_ResetBoundingBox(*args, **kwargs) + + def MinX(*args, **kwargs): + """MinX() -> int""" + return _gdi.DC_MinX(*args, **kwargs) + + def MaxX(*args, **kwargs): + """MaxX() -> int""" + return _gdi.DC_MaxX(*args, **kwargs) + + def MinY(*args, **kwargs): + """MinY() -> int""" + return _gdi.DC_MinY(*args, **kwargs) + + def MaxY(*args, **kwargs): + """MaxY() -> int""" + return _gdi.DC_MaxY(*args, **kwargs) + + def GetBoundingBox(*args, **kwargs): + """GetBoundingBox() -> (x1,y1, x2,y2)""" + return _gdi.DC_GetBoundingBox(*args, **kwargs) + + def __nonzero__(self): return self.Ok() + def _DrawPointList(*args, **kwargs): + """_DrawPointList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" + return _gdi.DC__DrawPointList(*args, **kwargs) + + def _DrawLineList(*args, **kwargs): + """_DrawLineList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" + return _gdi.DC__DrawLineList(*args, **kwargs) + + def _DrawRectangleList(*args, **kwargs): + """_DrawRectangleList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" + return _gdi.DC__DrawRectangleList(*args, **kwargs) + + def _DrawEllipseList(*args, **kwargs): + """_DrawEllipseList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" + return _gdi.DC__DrawEllipseList(*args, **kwargs) + + def _DrawPolygonList(*args, **kwargs): + """_DrawPolygonList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" + return _gdi.DC__DrawPolygonList(*args, **kwargs) + + def _DrawTextList(*args, **kwargs): + """ + _DrawTextList(PyObject textList, PyObject pyPoints, PyObject foregroundList, + PyObject backgroundList) -> PyObject + """ + return _gdi.DC__DrawTextList(*args, **kwargs) + + def DrawPointList(self, points, pens=None): + if pens is None: + pens = [] + elif isinstance(pens, wx.Pen): + pens = [pens] + elif len(pens) != len(points): + raise ValueError('points and pens must have same length') + return self._DrawPointList(points, pens, []) + + + def DrawLineList(self, lines, pens=None): + if pens is None: + pens = [] + elif isinstance(pens, wx.Pen): + pens = [pens] + elif len(pens) != len(lines): + raise ValueError('lines and pens must have same length') + return self._DrawLineList(lines, pens, []) + + + def DrawRectangleList(self, rectangles, pens=None, brushes=None): + if pens is None: + pens = [] + elif isinstance(pens, wx.Pen): + pens = [pens] + elif len(pens) != len(rectangles): + raise ValueError('rectangles and pens must have same length') + if brushes is None: + brushes = [] + elif isinstance(brushes, wx.Brush): + 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, wx.Pen): + pens = [pens] + elif len(pens) != len(ellipses): + raise ValueError('ellipses and pens must have same length') + if brushes is None: + brushes = [] + elif isinstance(brushes, wx.Brush): + 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): + + + if pens is None: + pens = [] + elif isinstance(pens, wx.Pen): + pens = [pens] + elif len(pens) != len(polygons): + raise ValueError('polygons and pens must have same length') + if brushes is None: + brushes = [] + elif isinstance(brushes, wx.Brush): + 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): + + + + 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, wx.Colour): + foregrounds = [foregrounds] + elif len(foregrounds) != len(coords): + raise ValueError('foregrounds and coords must have same length') + if backgrounds is None: + backgrounds = [] + elif isinstance(backgrounds, wx.Colour): + backgrounds = [backgrounds] + elif len(backgrounds) != len(coords): + raise ValueError('backgrounds and coords must have same length') + return self._DrawTextList(textList, coords, foregrounds, backgrounds) + + +class DCPtr(DC): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = DC +_gdi.DC_swigregister(DCPtr) + +#--------------------------------------------------------------------------- + +class MemoryDC(DC): def __repr__(self): - return "" % (self.this,) - asTuple = Get - def __str__(self): return str(self.asTuple()) - def __repr__(self): return str(self.asTuple()) -class wxColour(wxColourPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxColour,_args,_kwargs) + return "<%s.%s; proxy of C++ wxMemoryDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> MemoryDC""" + newobj = _gdi.new_MemoryDC(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def SelectObject(*args, **kwargs): + """SelectObject(Bitmap bitmap)""" + return _gdi.MemoryDC_SelectObject(*args, **kwargs) +class MemoryDCPtr(MemoryDC): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = MemoryDC +_gdi.MemoryDC_swigregister(MemoryDCPtr) +def MemoryDCFromDC(*args, **kwargs): + """MemoryDCFromDC(DC oldDC) -> MemoryDC""" + val = _gdi.new_MemoryDCFromDC(*args, **kwargs) + val.thisown = 1 + return val -class wxColourDatabasePtr(wxObjectPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def FindColour(self, *_args, **_kwargs): - val = apply(gdic.wxColourDatabase_FindColour,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) - return val - def FindName(self, *_args, **_kwargs): - val = apply(gdic.wxColourDatabase_FindName,(self,) + _args, _kwargs) - return val - def Append(self, *_args, **_kwargs): - val = apply(gdic.wxColourDatabase_Append,(self,) + _args, _kwargs) - return val - def __repr__(self): - return "" % (self.this,) -class wxColourDatabase(wxColourDatabasePtr): - def __init__(self,this): - self.this = this +#--------------------------------------------------------------------------- +class BufferedDC(MemoryDC): + def __repr__(self): + return "<%s.%s; proxy of C++ wxBufferedDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(DC dc, Bitmap buffer) -> BufferedDC""" + newobj = _gdi.new_BufferedDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + self._dc = args[0] # save a ref so the other dc will not be deleted before self + def UnMask(*args, **kwargs): + """UnMask()""" + return _gdi.BufferedDC_UnMask(*args, **kwargs) -class wxPenPtr(wxGDIObjectPtr): - def __init__(self,this): +class BufferedDCPtr(BufferedDC): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxPen(self) - def GetCap(self, *_args, **_kwargs): - val = apply(gdic.wxPen_GetCap,(self,) + _args, _kwargs) - return val - def GetColour(self, *_args, **_kwargs): - val = apply(gdic.wxPen_GetColour,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) ; val.thisown = 1 - return val - def GetJoin(self, *_args, **_kwargs): - val = apply(gdic.wxPen_GetJoin,(self,) + _args, _kwargs) - return val - def GetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxPen_GetStyle,(self,) + _args, _kwargs) - return val - def GetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxPen_GetWidth,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxPen_Ok,(self,) + _args, _kwargs) - return val - def SetCap(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetCap,(self,) + _args, _kwargs) - return val - def SetColour(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetColour,(self,) + _args, _kwargs) - return val - def SetJoin(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetJoin,(self,) + _args, _kwargs) - return val - def SetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetStyle,(self,) + _args, _kwargs) - return val - def SetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetWidth,(self,) + _args, _kwargs) - return val - def SetDashes(self, *_args, **_kwargs): - val = apply(gdic.wxPen_SetDashes,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = BufferedDC +_gdi.BufferedDC_swigregister(BufferedDCPtr) + +def BufferedDCInternalBuffer(*args, **kwargs): + """BufferedDCInternalBuffer(DC dc, Size area) -> BufferedDC""" + val = _gdi.new_BufferedDCInternalBuffer(*args, **kwargs) + val.thisown = 1 + val._dc = args[0] # save a ref so the other dc will not be deleted before self + return val + +class BufferedPaintDC(BufferedDC): def __repr__(self): - return "" % (self.this,) -class wxPen(wxPenPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxPen,_args,_kwargs) + return "<%s.%s; proxy of C++ wxBufferedPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Window window, Bitmap buffer=NullBitmap) -> BufferedPaintDC""" + newobj = _gdi.new_BufferedPaintDC(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown +class BufferedPaintDCPtr(BufferedPaintDC): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = BufferedPaintDC +_gdi.BufferedPaintDC_swigregister(BufferedPaintDCPtr) +#--------------------------------------------------------------------------- - -class wxPyPenPtr(wxPenPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxPyPen(self) - def SetDashes(self, *_args, **_kwargs): - val = apply(gdic.wxPyPen_SetDashes,(self,) + _args, _kwargs) - return val +class ScreenDC(DC): def __repr__(self): - return "" % (self.this,) -class wxPyPen(wxPyPenPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxPyPen,_args,_kwargs) + return "<%s.%s; proxy of C++ wxScreenDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> ScreenDC""" + newobj = _gdi.new_ScreenDC(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def StartDrawingOnTopWin(*args, **kwargs): + """StartDrawingOnTopWin(Window window) -> bool""" + return _gdi.ScreenDC_StartDrawingOnTopWin(*args, **kwargs) + def StartDrawingOnTop(*args, **kwargs): + """StartDrawingOnTop(Rect rect=None) -> bool""" + return _gdi.ScreenDC_StartDrawingOnTop(*args, **kwargs) + def EndDrawingOnTop(*args, **kwargs): + """EndDrawingOnTop() -> bool""" + return _gdi.ScreenDC_EndDrawingOnTop(*args, **kwargs) -class wxPenListPtr(wxObjectPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def AddPen(self, *_args, **_kwargs): - val = apply(gdic.wxPenList_AddPen,(self,) + _args, _kwargs) - return val - def FindOrCreatePen(self, *_args, **_kwargs): - val = apply(gdic.wxPenList_FindOrCreatePen,(self,) + _args, _kwargs) - if val: val = wxPenPtr(val) - return val - def RemovePen(self, *_args, **_kwargs): - val = apply(gdic.wxPenList_RemovePen,(self,) + _args, _kwargs) - return val - def GetCount(self, *_args, **_kwargs): - val = apply(gdic.wxPenList_GetCount,(self,) + _args, _kwargs) - return val - def __repr__(self): - return "" % (self.this,) -class wxPenList(wxPenListPtr): - def __init__(self,this): +class ScreenDCPtr(ScreenDC): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = ScreenDC +_gdi.ScreenDC_swigregister(ScreenDCPtr) +#--------------------------------------------------------------------------- +class ClientDC(DC): + def __repr__(self): + return "<%s.%s; proxy of C++ wxClientDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Window win) -> ClientDC""" + newobj = _gdi.new_ClientDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown - -class wxBrushPtr(wxGDIObjectPtr): - def __init__(self,this): +class ClientDCPtr(ClientDC): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxBrush(self) - def GetColour(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_GetColour,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) ; val.thisown = 1 - return val - def GetStipple(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_GetStipple,(self,) + _args, _kwargs) - if val: val = wxBitmapPtr(val) - return val - def GetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_GetStyle,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_Ok,(self,) + _args, _kwargs) - return val - def SetColour(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_SetColour,(self,) + _args, _kwargs) - return val - def SetStipple(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_SetStipple,(self,) + _args, _kwargs) - return val - def SetStyle(self, *_args, **_kwargs): - val = apply(gdic.wxBrush_SetStyle,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = ClientDC +_gdi.ClientDC_swigregister(ClientDCPtr) + +#--------------------------------------------------------------------------- + +class PaintDC(DC): def __repr__(self): - return "" % (self.this,) -class wxBrush(wxBrushPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxBrush,_args,_kwargs) + return "<%s.%s; proxy of C++ wxPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Window win) -> PaintDC""" + newobj = _gdi.new_PaintDC(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown +class PaintDCPtr(PaintDC): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = PaintDC +_gdi.PaintDC_swigregister(PaintDCPtr) +#--------------------------------------------------------------------------- +class WindowDC(DC): + def __repr__(self): + return "<%s.%s; proxy of C++ wxWindowDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(Window win) -> WindowDC""" + newobj = _gdi.new_WindowDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown -class wxBrushListPtr(wxObjectPtr): - def __init__(self,this): +class WindowDCPtr(WindowDC): + def __init__(self, this): self.this = this - self.thisown = 0 - def AddBrush(self, *_args, **_kwargs): - val = apply(gdic.wxBrushList_AddBrush,(self,) + _args, _kwargs) - return val - def FindOrCreateBrush(self, *_args, **_kwargs): - val = apply(gdic.wxBrushList_FindOrCreateBrush,(self,) + _args, _kwargs) - if val: val = wxBrushPtr(val) - return val - def RemoveBrush(self, *_args, **_kwargs): - val = apply(gdic.wxBrushList_RemoveBrush,(self,) + _args, _kwargs) - return val - def GetCount(self, *_args, **_kwargs): - val = apply(gdic.wxBrushList_GetCount,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = WindowDC +_gdi.WindowDC_swigregister(WindowDCPtr) + +#--------------------------------------------------------------------------- + +class MirrorDC(DC): def __repr__(self): - return "" % (self.this,) -class wxBrushList(wxBrushListPtr): - def __init__(self,this): + return "<%s.%s; proxy of C++ wxMirrorDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(DC dc, bool mirror) -> MirrorDC""" + newobj = _gdi.new_MirrorDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + +class MirrorDCPtr(MirrorDC): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = MirrorDC +_gdi.MirrorDC_swigregister(MirrorDCPtr) +#--------------------------------------------------------------------------- +class PostScriptDC(DC): + def __repr__(self): + return "<%s.%s; proxy of C++ wxPostScriptDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(wxPrintData printData) -> PostScriptDC""" + newobj = _gdi.new_PostScriptDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def GetPrintData(*args, **kwargs): + """GetPrintData() -> wxPrintData""" + return _gdi.PostScriptDC_GetPrintData(*args, **kwargs) + def SetPrintData(*args, **kwargs): + """SetPrintData(wxPrintData data)""" + return _gdi.PostScriptDC_SetPrintData(*args, **kwargs) -class wxDCPtr(wxObjectPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxDC(self) - def BeginDrawing(self, *_args, **_kwargs): - val = apply(gdic.wxDC_BeginDrawing,(self,) + _args, _kwargs) - return val - def Blit(self, *_args, **_kwargs): - val = apply(gdic.wxDC_Blit,(self,) + _args, _kwargs) - return val - def Clear(self, *_args, **_kwargs): - val = apply(gdic.wxDC_Clear,(self,) + _args, _kwargs) - return val - def CrossHair(self, *_args, **_kwargs): - val = apply(gdic.wxDC_CrossHair,(self,) + _args, _kwargs) - return val - def DestroyClippingRegion(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DestroyClippingRegion,(self,) + _args, _kwargs) - return val - def DeviceToLogicalX(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DeviceToLogicalX,(self,) + _args, _kwargs) - return val - def DeviceToLogicalXRel(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DeviceToLogicalXRel,(self,) + _args, _kwargs) - return val - def DeviceToLogicalY(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DeviceToLogicalY,(self,) + _args, _kwargs) - return val - def DeviceToLogicalYRel(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DeviceToLogicalYRel,(self,) + _args, _kwargs) - return val - def DrawArc(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawArc,(self,) + _args, _kwargs) - return val - def DrawCircle(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawCircle,(self,) + _args, _kwargs) - return val - def DrawEllipse(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawEllipse,(self,) + _args, _kwargs) - return val - def DrawEllipticArc(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawEllipticArc,(self,) + _args, _kwargs) - return val - def DrawIcon(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawIcon,(self,) + _args, _kwargs) - return val - def DrawLine(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawLine,(self,) + _args, _kwargs) - return val - def DrawLines(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawLines,(self,) + _args, _kwargs) - return val - def DrawPolygon(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawPolygon,(self,) + _args, _kwargs) - return val - def DrawPoint(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawPoint,(self,) + _args, _kwargs) - return val - def DrawRectangle(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawRectangle,(self,) + _args, _kwargs) - return val - def DrawRotatedText(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawRotatedText,(self,) + _args, _kwargs) - return val - def DrawRoundedRectangle(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawRoundedRectangle,(self,) + _args, _kwargs) - return val - def DrawSpline(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawSpline,(self,) + _args, _kwargs) - return val - def DrawText(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawText,(self,) + _args, _kwargs) - return val - def EndDoc(self, *_args, **_kwargs): - val = apply(gdic.wxDC_EndDoc,(self,) + _args, _kwargs) - return val - def EndDrawing(self, *_args, **_kwargs): - val = apply(gdic.wxDC_EndDrawing,(self,) + _args, _kwargs) - return val - def EndPage(self, *_args, **_kwargs): - val = apply(gdic.wxDC_EndPage,(self,) + _args, _kwargs) - return val - def FloodFill(self, *_args, **_kwargs): - val = apply(gdic.wxDC_FloodFill,(self,) + _args, _kwargs) - return val - def GetBackground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetBackground,(self,) + _args, _kwargs) - if val: val = wxBrushPtr(val) ; val.thisown = 1 - return val - def GetBrush(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetBrush,(self,) + _args, _kwargs) - if val: val = wxBrushPtr(val) ; val.thisown = 1 - return val - def GetCharHeight(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetCharHeight,(self,) + _args, _kwargs) - return val - def GetCharWidth(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetCharWidth,(self,) + _args, _kwargs) - return val - def GetClippingBox(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetClippingBox,(self,) + _args, _kwargs) - return val - def GetFont(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetFont,(self,) + _args, _kwargs) - if val: val = wxFontPtr(val) ; val.thisown = 1 - return val - def GetLogicalFunction(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetLogicalFunction,(self,) + _args, _kwargs) - return val - def GetLogicalScale(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetLogicalScale,(self,) + _args, _kwargs) - return val - def GetMapMode(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetMapMode,(self,) + _args, _kwargs) - return val - def GetOptimization(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetOptimization,(self,) + _args, _kwargs) - return val - def GetPen(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetPen,(self,) + _args, _kwargs) - if val: val = wxPenPtr(val) ; val.thisown = 1 - return val - def GetPixel(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetPixel,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) ; val.thisown = 1 - return val - def GetSizeTuple(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetSizeTuple,(self,) + _args, _kwargs) - return val - def GetSize(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetSize,(self,) + _args, _kwargs) - if val: val = wxSizePtr(val) ; val.thisown = 1 - return val - def GetSizeMM(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetSizeMM,(self,) + _args, _kwargs) - if val: val = wxSizePtr(val) ; val.thisown = 1 - return val - def GetTextBackground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetTextBackground,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) ; val.thisown = 1 - return val - def GetTextExtent(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetTextExtent,(self,) + _args, _kwargs) - return val - def GetFullTextExtent(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetFullTextExtent,(self,) + _args, _kwargs) - return val - def GetTextForeground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetTextForeground,(self,) + _args, _kwargs) - if val: val = wxColourPtr(val) ; val.thisown = 1 - return val - def GetUserScale(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetUserScale,(self,) + _args, _kwargs) - return val - def LogicalToDeviceX(self, *_args, **_kwargs): - val = apply(gdic.wxDC_LogicalToDeviceX,(self,) + _args, _kwargs) - return val - def LogicalToDeviceXRel(self, *_args, **_kwargs): - val = apply(gdic.wxDC_LogicalToDeviceXRel,(self,) + _args, _kwargs) - return val - def LogicalToDeviceY(self, *_args, **_kwargs): - val = apply(gdic.wxDC_LogicalToDeviceY,(self,) + _args, _kwargs) - return val - def LogicalToDeviceYRel(self, *_args, **_kwargs): - val = apply(gdic.wxDC_LogicalToDeviceYRel,(self,) + _args, _kwargs) - return val - def MaxX(self, *_args, **_kwargs): - val = apply(gdic.wxDC_MaxX,(self,) + _args, _kwargs) - return val - def MaxY(self, *_args, **_kwargs): - val = apply(gdic.wxDC_MaxY,(self,) + _args, _kwargs) - return val - def MinX(self, *_args, **_kwargs): - val = apply(gdic.wxDC_MinX,(self,) + _args, _kwargs) - return val - def MinY(self, *_args, **_kwargs): - val = apply(gdic.wxDC_MinY,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxDC_Ok,(self,) + _args, _kwargs) - return val - def SetDeviceOrigin(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetDeviceOrigin,(self,) + _args, _kwargs) - return val - def SetBackground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetBackground,(self,) + _args, _kwargs) - return val - def SetBackgroundMode(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetBackgroundMode,(self,) + _args, _kwargs) - return val - def SetClippingRegion(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetClippingRegion,(self,) + _args, _kwargs) - return val - def SetClippingRegionAsRegion(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetClippingRegionAsRegion,(self,) + _args, _kwargs) - return val - def SetPalette(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetPalette,(self,) + _args, _kwargs) - return val - def SetBrush(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetBrush,(self,) + _args, _kwargs) - return val - def SetFont(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetFont,(self,) + _args, _kwargs) - return val - def SetLogicalFunction(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetLogicalFunction,(self,) + _args, _kwargs) - return val - def SetLogicalScale(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetLogicalScale,(self,) + _args, _kwargs) - return val - def SetMapMode(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetMapMode,(self,) + _args, _kwargs) - return val - def SetOptimization(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetOptimization,(self,) + _args, _kwargs) - return val - def SetPen(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetPen,(self,) + _args, _kwargs) - return val - def SetTextBackground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetTextBackground,(self,) + _args, _kwargs) - return val - def SetTextForeground(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetTextForeground,(self,) + _args, _kwargs) - return val - def SetUserScale(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetUserScale,(self,) + _args, _kwargs) - return val - def StartDoc(self, *_args, **_kwargs): - val = apply(gdic.wxDC_StartDoc,(self,) + _args, _kwargs) - return val - def StartPage(self, *_args, **_kwargs): - val = apply(gdic.wxDC_StartPage,(self,) + _args, _kwargs) - return val - def DrawBitmap(self, *_args, **_kwargs): - val = apply(gdic.wxDC_DrawBitmap,(self,) + _args, _kwargs) - return val - def CanDrawBitmap(self, *_args, **_kwargs): - val = apply(gdic.wxDC_CanDrawBitmap,(self,) + _args, _kwargs) - return val - def CanGetTextExtent(self, *_args, **_kwargs): - val = apply(gdic.wxDC_CanGetTextExtent,(self,) + _args, _kwargs) - return val - def GetDepth(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetDepth,(self,) + _args, _kwargs) - return val - def GetPPI(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetPPI,(self,) + _args, _kwargs) - if val: val = wxSizePtr(val) ; val.thisown = 1 - return val - def GetLogicalOrigin(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetLogicalOrigin,(self,) + _args, _kwargs) - return val - def SetLogicalOrigin(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetLogicalOrigin,(self,) + _args, _kwargs) - return val - def GetDeviceOrigin(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetDeviceOrigin,(self,) + _args, _kwargs) - return val - def SetAxisOrientation(self, *_args, **_kwargs): - val = apply(gdic.wxDC_SetAxisOrientation,(self,) + _args, _kwargs) - return val - def CalcBoundingBox(self, *_args, **_kwargs): - val = apply(gdic.wxDC_CalcBoundingBox,(self,) + _args, _kwargs) - return val - def ResetBoundingBox(self, *_args, **_kwargs): - val = apply(gdic.wxDC_ResetBoundingBox,(self,) + _args, _kwargs) - return val - def GetBoundingBox(self, *_args, **_kwargs): - val = apply(gdic.wxDC_GetBoundingBox,(self,) + _args, _kwargs) - return val - def _DrawPointList(self, *_args, **_kwargs): - val = apply(gdic.wxDC__DrawPointList,(self,) + _args, _kwargs) - return val - def _DrawLineList(self, *_args, **_kwargs): - val = apply(gdic.wxDC__DrawLineList,(self,) + _args, _kwargs) - return val - def __repr__(self): - return "" % (self.this,) - - def DrawPointList(self, points, pens=None): - if pens is None: - pens = [] - elif isinstance(pens, wxPenPtr): - pens = [pens] - elif len(pens) != len(points): - raise ValueError('points and pens must have same length') - return self._DrawPointList(points, pens) + def SetResolution(*args, **kwargs): + """PostScriptDC.SetResolution(int ppi)""" + return _gdi.PostScriptDC_SetResolution(*args, **kwargs) - def DrawLineList(self, lines, pens=None): - if pens is None: - pens = [] - elif isinstance(pens, wxPenPtr): - pens = [pens] - elif len(pens) != len(lines): - raise ValueError('lines and pens must have same length') - return self._DrawLineList(lines, pens) + SetResolution = staticmethod(SetResolution) + def GetResolution(*args, **kwargs): + """PostScriptDC.GetResolution() -> int""" + return _gdi.PostScriptDC_GetResolution(*args, **kwargs) -class wxDC(wxDCPtr): - def __init__(self,this): + GetResolution = staticmethod(GetResolution) + +class PostScriptDCPtr(PostScriptDC): + def __init__(self, this): self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = PostScriptDC +_gdi.PostScriptDC_swigregister(PostScriptDCPtr) +def PostScriptDC_SetResolution(*args, **kwargs): + """PostScriptDC_SetResolution(int ppi)""" + return _gdi.PostScriptDC_SetResolution(*args, **kwargs) +def PostScriptDC_GetResolution(*args, **kwargs): + """PostScriptDC_GetResolution() -> int""" + return _gdi.PostScriptDC_GetResolution(*args, **kwargs) +#--------------------------------------------------------------------------- -class wxMemoryDCPtr(wxDCPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def SelectObject(self, *_args, **_kwargs): - val = apply(gdic.wxMemoryDC_SelectObject,(self,) + _args, _kwargs) - return val +class MetaFile(core.Object): def __repr__(self): - return "" % (self.this,) -class wxMemoryDC(wxMemoryDCPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxMemoryDC,_args,_kwargs) + return "<%s.%s; proxy of C++ wxMetaFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(String filename=EmptyString) -> MetaFile""" + newobj = _gdi.new_MetaFile(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown - - - -class wxScreenDCPtr(wxDCPtr): - def __init__(self,this): +class MetaFilePtr(MetaFile): + def __init__(self, this): self.this = this - self.thisown = 0 - def StartDrawingOnTopWin(self, *_args, **_kwargs): - val = apply(gdic.wxScreenDC_StartDrawingOnTopWin,(self,) + _args, _kwargs) - return val - def StartDrawingOnTop(self, *_args, **_kwargs): - val = apply(gdic.wxScreenDC_StartDrawingOnTop,(self,) + _args, _kwargs) - return val - def EndDrawingOnTop(self, *_args, **_kwargs): - val = apply(gdic.wxScreenDC_EndDrawingOnTop,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = MetaFile +_gdi.MetaFile_swigregister(MetaFilePtr) + +class MetaFileDC(DC): def __repr__(self): - return "" % (self.this,) -class wxScreenDC(wxScreenDCPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxScreenDC,_args,_kwargs) + return "<%s.%s; proxy of C++ wxMetaFileDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """ + __init__(String filename=EmptyString, int width=0, int height=0, + String description=EmptyString) -> MetaFileDC + """ + newobj = _gdi.new_MetaFileDC(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown +class MetaFileDCPtr(MetaFileDC): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = MetaFileDC +_gdi.MetaFileDC_swigregister(MetaFileDCPtr) +class PrinterDC(DC): + def __repr__(self): + return "<%s.%s; proxy of C++ wxPrinterDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(wxPrintData printData) -> PrinterDC""" + newobj = _gdi.new_PrinterDC(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown - -class wxClientDCPtr(wxDCPtr): - def __init__(self,this): +class PrinterDCPtr(PrinterDC): + def __init__(self, this): self.this = this - self.thisown = 0 + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = PrinterDC +_gdi.PrinterDC_swigregister(PrinterDCPtr) + +#--------------------------------------------------------------------------- + +IMAGELIST_DRAW_NORMAL = _gdi.IMAGELIST_DRAW_NORMAL +IMAGELIST_DRAW_TRANSPARENT = _gdi.IMAGELIST_DRAW_TRANSPARENT +IMAGELIST_DRAW_SELECTED = _gdi.IMAGELIST_DRAW_SELECTED +IMAGELIST_DRAW_FOCUSED = _gdi.IMAGELIST_DRAW_FOCUSED +IMAGE_LIST_NORMAL = _gdi.IMAGE_LIST_NORMAL +IMAGE_LIST_SMALL = _gdi.IMAGE_LIST_SMALL +IMAGE_LIST_STATE = _gdi.IMAGE_LIST_STATE +class ImageList(core.Object): def __repr__(self): - return "" % (self.this,) -class wxClientDC(wxClientDCPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxClientDC,_args,_kwargs) + return "<%s.%s; proxy of C++ wxImageList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__(int width, int height, int mask=True, int initialCount=1) -> ImageList""" + newobj = _gdi.new_ImageList(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_ImageList): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + def Add(*args, **kwargs): + """Add(Bitmap bitmap, Bitmap mask=NullBitmap) -> int""" + return _gdi.ImageList_Add(*args, **kwargs) + def AddWithColourMask(*args, **kwargs): + """AddWithColourMask(Bitmap bitmap, Colour maskColour) -> int""" + return _gdi.ImageList_AddWithColourMask(*args, **kwargs) + def AddIcon(*args, **kwargs): + """AddIcon(Icon icon) -> int""" + return _gdi.ImageList_AddIcon(*args, **kwargs) -class wxPaintDCPtr(wxDCPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def __repr__(self): - return "" % (self.this,) -class wxPaintDC(wxPaintDCPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxPaintDC,_args,_kwargs) - self.thisown = 1 + def Replace(*args, **kwargs): + """Replace(int index, Bitmap bitmap) -> bool""" + return _gdi.ImageList_Replace(*args, **kwargs) + def Draw(*args, **kwargs): + """ + Draw(int index, DC dc, int x, int x, int flags=IMAGELIST_DRAW_NORMAL, + bool solidBackground=False) -> bool + """ + return _gdi.ImageList_Draw(*args, **kwargs) + def GetImageCount(*args, **kwargs): + """GetImageCount() -> int""" + return _gdi.ImageList_GetImageCount(*args, **kwargs) + def Remove(*args, **kwargs): + """Remove(int index) -> bool""" + return _gdi.ImageList_Remove(*args, **kwargs) -class wxWindowDCPtr(wxDCPtr): - def __init__(self,this): + def RemoveAll(*args, **kwargs): + """RemoveAll() -> bool""" + return _gdi.ImageList_RemoveAll(*args, **kwargs) + + def GetSize(*args, **kwargs): + """GetSize() -> (width,height)""" + return _gdi.ImageList_GetSize(*args, **kwargs) + + +class ImageListPtr(ImageList): + def __init__(self, this): self.this = this - self.thisown = 0 + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = ImageList +_gdi.ImageList_swigregister(ImageListPtr) + +#--------------------------------------------------------------------------- + +class PenList(core.Object): + def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): - return "" % (self.this,) -class wxWindowDC(wxWindowDCPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxWindowDC,_args,_kwargs) - self.thisown = 1 + return "<%s.%s; proxy of C++ wxPenList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def AddPen(*args, **kwargs): + """AddPen(Pen pen)""" + return _gdi.PenList_AddPen(*args, **kwargs) + def FindOrCreatePen(*args, **kwargs): + """FindOrCreatePen(Colour colour, int width, int style) -> Pen""" + return _gdi.PenList_FindOrCreatePen(*args, **kwargs) + def RemovePen(*args, **kwargs): + """RemovePen(Pen pen)""" + return _gdi.PenList_RemovePen(*args, **kwargs) + def GetCount(*args, **kwargs): + """GetCount() -> int""" + return _gdi.PenList_GetCount(*args, **kwargs) -class wxPalettePtr(wxGDIObjectPtr): - def __init__(self,this): + +class PenListPtr(PenList): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxPalette(self) - def GetPixel(self, *_args, **_kwargs): - val = apply(gdic.wxPalette_GetPixel,(self,) + _args, _kwargs) - return val - def GetRGB(self, *_args, **_kwargs): - val = apply(gdic.wxPalette_GetRGB,(self,) + _args, _kwargs) - return val - def Ok(self, *_args, **_kwargs): - val = apply(gdic.wxPalette_Ok,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = PenList +_gdi.PenList_swigregister(PenListPtr) + +class BrushList(core.Object): + def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): - return "" % (self.this,) -class wxPalette(wxPalettePtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxPalette,_args,_kwargs) - self.thisown = 1 + return "<%s.%s; proxy of C++ wxBrushList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def AddBrush(*args, **kwargs): + """AddBrush(Brush brush)""" + return _gdi.BrushList_AddBrush(*args, **kwargs) + def FindOrCreateBrush(*args, **kwargs): + """FindOrCreateBrush(Colour colour, int style) -> Brush""" + return _gdi.BrushList_FindOrCreateBrush(*args, **kwargs) + def RemoveBrush(*args, **kwargs): + """RemoveBrush(Brush brush)""" + return _gdi.BrushList_RemoveBrush(*args, **kwargs) + def GetCount(*args, **kwargs): + """GetCount() -> int""" + return _gdi.BrushList_GetCount(*args, **kwargs) -class wxImageListPtr(wxObjectPtr): - def __init__(self,this): + +class BrushListPtr(BrushList): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxImageList(self) - def Add(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_Add,(self,) + _args, _kwargs) - return val - def AddWithColourMask(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_AddWithColourMask,(self,) + _args, _kwargs) - return val - def AddIcon(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_AddIcon,(self,) + _args, _kwargs) - return val - def Replace(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_Replace,(self,) + _args, _kwargs) - return val - def Draw(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_Draw,(self,) + _args, _kwargs) - return val - def GetImageCount(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_GetImageCount,(self,) + _args, _kwargs) - return val - def Remove(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_Remove,(self,) + _args, _kwargs) - return val - def RemoveAll(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_RemoveAll,(self,) + _args, _kwargs) - return val - def GetSize(self, *_args, **_kwargs): - val = apply(gdic.wxImageList_GetSize,(self,) + _args, _kwargs) - return val + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = BrushList +_gdi.BrushList_swigregister(BrushListPtr) + +class ColourDatabase(core.Object): def __repr__(self): - return "" % (self.this,) -class wxImageList(wxImageListPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxImageList,_args,_kwargs) + return "<%s.%s; proxy of C++ wxColourDatabase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> ColourDatabase""" + newobj = _gdi.new_ColourDatabase(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi.delete_ColourDatabase): + """__del__()""" + try: + if self.thisown: destroy(self) + except: pass + def Find(*args, **kwargs): + """Find(String name) -> Colour""" + return _gdi.ColourDatabase_Find(*args, **kwargs) + def FindName(*args, **kwargs): + """FindName(Colour colour) -> String""" + return _gdi.ColourDatabase_FindName(*args, **kwargs) + FindColour = Find + def AddColour(*args, **kwargs): + """AddColour(String name, Colour colour)""" + return _gdi.ColourDatabase_AddColour(*args, **kwargs) -class wxRegionPtr(wxGDIObjectPtr): - def __init__(self,this): + def Append(*args, **kwargs): + """Append(String name, int red, int green, int blue)""" + return _gdi.ColourDatabase_Append(*args, **kwargs) + + +class ColourDatabasePtr(ColourDatabase): + def __init__(self, this): self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxRegion(self) - def Clear(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Clear,(self,) + _args, _kwargs) - return val - def Contains(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Contains,(self,) + _args, _kwargs) - return val - def ContainsPoint(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_ContainsPoint,(self,) + _args, _kwargs) - return val - def ContainsRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_ContainsRect,(self,) + _args, _kwargs) - return val - def ContainsRectDim(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_ContainsRectDim,(self,) + _args, _kwargs) - return val - def GetBox(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_GetBox,(self,) + _args, _kwargs) - if val: val = wxRectPtr(val) ; val.thisown = 1 - return val - def Intersect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Intersect,(self,) + _args, _kwargs) - return val - def IntersectRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_IntersectRect,(self,) + _args, _kwargs) - return val - def IntersectRegion(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_IntersectRegion,(self,) + _args, _kwargs) - return val - def IsEmpty(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_IsEmpty,(self,) + _args, _kwargs) - return val - def Union(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Union,(self,) + _args, _kwargs) - return val - def UnionRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_UnionRect,(self,) + _args, _kwargs) - return val - def UnionRegion(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_UnionRegion,(self,) + _args, _kwargs) - return val - def Subtract(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Subtract,(self,) + _args, _kwargs) - return val - def SubtractRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_SubtractRect,(self,) + _args, _kwargs) - return val - def SubtractRegion(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_SubtractRegion,(self,) + _args, _kwargs) - return val - def Xor(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_Xor,(self,) + _args, _kwargs) - return val - def XorRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_XorRect,(self,) + _args, _kwargs) - return val - def XorRegion(self, *_args, **_kwargs): - val = apply(gdic.wxRegion_XorRegion,(self,) + _args, _kwargs) - return val - def __repr__(self): - return "" % (self.this,) -class wxRegion(wxRegionPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxRegion,_args,_kwargs) - self.thisown = 1 + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = ColourDatabase +_gdi.ColourDatabase_swigregister(ColourDatabasePtr) +class FontList(core.Object): + def __init__(self): raise RuntimeError, "No constructor defined" + def __repr__(self): + return "<%s.%s; proxy of C++ wxFontList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def AddFont(*args, **kwargs): + """AddFont(Font font)""" + return _gdi.FontList_AddFont(*args, **kwargs) + + def FindOrCreateFont(*args, **kwargs): + """ + FindOrCreateFont(int point_size, int family, int style, int weight, + bool underline=False, String facename=EmptyString, + int encoding=FONTENCODING_DEFAULT) -> Font + """ + return _gdi.FontList_FindOrCreateFont(*args, **kwargs) + + def RemoveFont(*args, **kwargs): + """RemoveFont(Font font)""" + return _gdi.FontList_RemoveFont(*args, **kwargs) + + def GetCount(*args, **kwargs): + """GetCount() -> int""" + return _gdi.FontList_GetCount(*args, **kwargs) + + +class FontListPtr(FontList): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = FontList +_gdi.FontList_swigregister(FontListPtr) +#--------------------------------------------------------------------------- +#--------------------------------------------------------------------------- -class wxRegionIteratorPtr(wxObjectPtr): - def __init__(self,this): - self.this = this - self.thisown = 0 - def __del__(self,gdic=gdic): - if self.thisown == 1 : - gdic.delete_wxRegionIterator(self) - def GetX(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetX,(self,) + _args, _kwargs) - return val - def GetY(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetY,(self,) + _args, _kwargs) - return val - def GetW(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetW,(self,) + _args, _kwargs) - return val - def GetWidth(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetWidth,(self,) + _args, _kwargs) - return val - def GetH(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetH,(self,) + _args, _kwargs) - return val - def GetHeight(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetHeight,(self,) + _args, _kwargs) - return val - def GetRect(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_GetRect,(self,) + _args, _kwargs) - if val: val = wxRectPtr(val) ; val.thisown = 1 - return val - def HaveRects(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_HaveRects,(self,) + _args, _kwargs) - return val - def Reset(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_Reset,(self,) + _args, _kwargs) - return val - def Next(self, *_args, **_kwargs): - val = apply(gdic.wxRegionIterator_Next,(self,) + _args, _kwargs) - return val +class Effects(core.Object): def __repr__(self): - return "" % (self.this,) -class wxRegionIterator(wxRegionIteratorPtr): - def __init__(self,*_args,**_kwargs): - self.this = apply(gdic.new_wxRegionIterator,_args,_kwargs) + return "<%s.%s; proxy of C++ wxEffects instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def __init__(self, *args, **kwargs): + """__init__() -> Effects""" + newobj = _gdi.new_Effects(*args, **kwargs) + self.this = newobj.this self.thisown = 1 + del newobj.thisown + def GetHighlightColour(*args, **kwargs): + """GetHighlightColour() -> Colour""" + return _gdi.Effects_GetHighlightColour(*args, **kwargs) + def GetLightShadow(*args, **kwargs): + """GetLightShadow() -> Colour""" + return _gdi.Effects_GetLightShadow(*args, **kwargs) + def GetFaceColour(*args, **kwargs): + """GetFaceColour() -> Colour""" + return _gdi.Effects_GetFaceColour(*args, **kwargs) + def GetMediumShadow(*args, **kwargs): + """GetMediumShadow() -> Colour""" + return _gdi.Effects_GetMediumShadow(*args, **kwargs) + def GetDarkShadow(*args, **kwargs): + """GetDarkShadow() -> Colour""" + return _gdi.Effects_GetDarkShadow(*args, **kwargs) + def SetHighlightColour(*args, **kwargs): + """SetHighlightColour(Colour c)""" + return _gdi.Effects_SetHighlightColour(*args, **kwargs) -#-------------- FUNCTION WRAPPERS ------------------ + def SetLightShadow(*args, **kwargs): + """SetLightShadow(Colour c)""" + return _gdi.Effects_SetLightShadow(*args, **kwargs) -def wxEmptyBitmap(*_args, **_kwargs): - val = apply(gdic.wxEmptyBitmap,_args,_kwargs) - if val: val = wxBitmapPtr(val); val.thisown = 1 - return val - -def wxBitmapFromXPMData(*_args, **_kwargs): - val = apply(gdic.wxBitmapFromXPMData,_args,_kwargs) - if val: val = wxBitmapPtr(val); val.thisown = 1 - return val + def SetFaceColour(*args, **kwargs): + """SetFaceColour(Colour c)""" + return _gdi.Effects_SetFaceColour(*args, **kwargs) -def wxBitmapFromIcon(*_args, **_kwargs): - val = apply(gdic.wxBitmapFromIcon,_args,_kwargs) - if val: val = wxBitmapPtr(val); val.thisown = 1 - return val + def SetMediumShadow(*args, **kwargs): + """SetMediumShadow(Colour c)""" + return _gdi.Effects_SetMediumShadow(*args, **kwargs) -def wxBitmapFromBits(*_args, **_kwargs): - val = apply(gdic.wxBitmapFromBits,_args,_kwargs) - if val: val = wxBitmapPtr(val); val.thisown = 1 - return val + def SetDarkShadow(*args, **kwargs): + """SetDarkShadow(Colour c)""" + return _gdi.Effects_SetDarkShadow(*args, **kwargs) -def wxMaskColour(*_args, **_kwargs): - val = apply(gdic.wxMaskColour,_args,_kwargs) - if val: val = wxMaskPtr(val); val.thisown = 1 - return val + def Set(*args, **kwargs): + """ + Set(Colour highlightColour, Colour lightShadow, Colour faceColour, + Colour mediumShadow, Colour darkShadow) + """ + return _gdi.Effects_Set(*args, **kwargs) -def wxEmptyIcon(*_args, **_kwargs): - val = apply(gdic.wxEmptyIcon,_args,_kwargs) - if val: val = wxIconPtr(val); val.thisown = 1 - return val + def DrawSunkenEdge(*args, **kwargs): + """DrawSunkenEdge(DC dc, Rect rect, int borderSize=1)""" + return _gdi.Effects_DrawSunkenEdge(*args, **kwargs) -def wxIconFromXPMData(*_args, **_kwargs): - val = apply(gdic.wxIconFromXPMData,_args,_kwargs) - if val: val = wxIconPtr(val); val.thisown = 1 - return val + def TileBitmap(*args, **kwargs): + """TileBitmap(Rect rect, DC dc, Bitmap bitmap) -> bool""" + return _gdi.Effects_TileBitmap(*args, **kwargs) -def wxStockCursor(*_args, **_kwargs): - val = apply(gdic.wxStockCursor,_args,_kwargs) - if val: val = wxCursorPtr(val); val.thisown = 1 - return val -def wxNamedColour(*_args, **_kwargs): - val = apply(gdic.wxNamedColour,_args,_kwargs) - if val: val = wxColourPtr(val); val.thisown = 1 - return val +class EffectsPtr(Effects): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = Effects +_gdi.Effects_swigregister(EffectsPtr) +cvar = _gdi.cvar +NORMAL_FONT = cvar.NORMAL_FONT +SMALL_FONT = cvar.SMALL_FONT +ITALIC_FONT = cvar.ITALIC_FONT +SWISS_FONT = cvar.SWISS_FONT +RED_PEN = cvar.RED_PEN +CYAN_PEN = cvar.CYAN_PEN +GREEN_PEN = cvar.GREEN_PEN +BLACK_PEN = cvar.BLACK_PEN +WHITE_PEN = cvar.WHITE_PEN +TRANSPARENT_PEN = cvar.TRANSPARENT_PEN +BLACK_DASHED_PEN = cvar.BLACK_DASHED_PEN +GREY_PEN = cvar.GREY_PEN +MEDIUM_GREY_PEN = cvar.MEDIUM_GREY_PEN +LIGHT_GREY_PEN = cvar.LIGHT_GREY_PEN +BLUE_BRUSH = cvar.BLUE_BRUSH +GREEN_BRUSH = cvar.GREEN_BRUSH +WHITE_BRUSH = cvar.WHITE_BRUSH +BLACK_BRUSH = cvar.BLACK_BRUSH +TRANSPARENT_BRUSH = cvar.TRANSPARENT_BRUSH +CYAN_BRUSH = cvar.CYAN_BRUSH +RED_BRUSH = cvar.RED_BRUSH +GREY_BRUSH = cvar.GREY_BRUSH +MEDIUM_GREY_BRUSH = cvar.MEDIUM_GREY_BRUSH +LIGHT_GREY_BRUSH = cvar.LIGHT_GREY_BRUSH +BLACK = cvar.BLACK +WHITE = cvar.WHITE +RED = cvar.RED +BLUE = cvar.BLUE +GREEN = cvar.GREEN +CYAN = cvar.CYAN +LIGHT_GREY = cvar.LIGHT_GREY +STANDARD_CURSOR = cvar.STANDARD_CURSOR +HOURGLASS_CURSOR = cvar.HOURGLASS_CURSOR +CROSS_CURSOR = cvar.CROSS_CURSOR +NullBitmap = cvar.NullBitmap +NullIcon = cvar.NullIcon +NullCursor = cvar.NullCursor +NullPen = cvar.NullPen +NullBrush = cvar.NullBrush +NullPalette = cvar.NullPalette +NullFont = cvar.NullFont +NullColour = cvar.NullColour +TheFontList = cvar.TheFontList +ThePenList = cvar.ThePenList +TheBrushList = cvar.TheBrushList +TheColourDatabase = cvar.TheColourDatabase -def wxMemoryDCFromDC(*_args, **_kwargs): - val = apply(gdic.wxMemoryDCFromDC,_args,_kwargs) - if val: val = wxMemoryDCPtr(val); val.thisown = 1 - return val -wxFontMapper_GetEncodingName = gdic.wxFontMapper_GetEncodingName - -wxFontMapper_GetEncodingDescription = gdic.wxFontMapper_GetEncodingDescription - -wxFontMapper_GetDefaultConfigPath = gdic.wxFontMapper_GetDefaultConfigPath - -wxFont_GetDefaultEncoding = gdic.wxFont_GetDefaultEncoding - -wxFont_SetDefaultEncoding = gdic.wxFont_SetDefaultEncoding - - - -#-------------- VARIABLE WRAPPERS ------------------ - -wxFONTFAMILY_DEFAULT = gdic.wxFONTFAMILY_DEFAULT -wxFONTFAMILY_DECORATIVE = gdic.wxFONTFAMILY_DECORATIVE -wxFONTFAMILY_ROMAN = gdic.wxFONTFAMILY_ROMAN -wxFONTFAMILY_SCRIPT = gdic.wxFONTFAMILY_SCRIPT -wxFONTFAMILY_SWISS = gdic.wxFONTFAMILY_SWISS -wxFONTFAMILY_MODERN = gdic.wxFONTFAMILY_MODERN -wxFONTFAMILY_TELETYPE = gdic.wxFONTFAMILY_TELETYPE -wxFONTFAMILY_MAX = gdic.wxFONTFAMILY_MAX -wxFONTSTYLE_NORMAL = gdic.wxFONTSTYLE_NORMAL -wxFONTSTYLE_ITALIC = gdic.wxFONTSTYLE_ITALIC -wxFONTSTYLE_SLANT = gdic.wxFONTSTYLE_SLANT -wxFONTSTYLE_MAX = gdic.wxFONTSTYLE_MAX -wxFONTWEIGHT_NORMAL = gdic.wxFONTWEIGHT_NORMAL -wxFONTWEIGHT_LIGHT = gdic.wxFONTWEIGHT_LIGHT -wxFONTWEIGHT_BOLD = gdic.wxFONTWEIGHT_BOLD -wxFONTWEIGHT_MAX = gdic.wxFONTWEIGHT_MAX -wxFONTENCODING_SYSTEM = gdic.wxFONTENCODING_SYSTEM -wxFONTENCODING_DEFAULT = gdic.wxFONTENCODING_DEFAULT -wxFONTENCODING_ISO8859_1 = gdic.wxFONTENCODING_ISO8859_1 -wxFONTENCODING_ISO8859_2 = gdic.wxFONTENCODING_ISO8859_2 -wxFONTENCODING_ISO8859_3 = gdic.wxFONTENCODING_ISO8859_3 -wxFONTENCODING_ISO8859_4 = gdic.wxFONTENCODING_ISO8859_4 -wxFONTENCODING_ISO8859_5 = gdic.wxFONTENCODING_ISO8859_5 -wxFONTENCODING_ISO8859_6 = gdic.wxFONTENCODING_ISO8859_6 -wxFONTENCODING_ISO8859_7 = gdic.wxFONTENCODING_ISO8859_7 -wxFONTENCODING_ISO8859_8 = gdic.wxFONTENCODING_ISO8859_8 -wxFONTENCODING_ISO8859_9 = gdic.wxFONTENCODING_ISO8859_9 -wxFONTENCODING_ISO8859_10 = gdic.wxFONTENCODING_ISO8859_10 -wxFONTENCODING_ISO8859_11 = gdic.wxFONTENCODING_ISO8859_11 -wxFONTENCODING_ISO8859_12 = gdic.wxFONTENCODING_ISO8859_12 -wxFONTENCODING_ISO8859_13 = gdic.wxFONTENCODING_ISO8859_13 -wxFONTENCODING_ISO8859_14 = gdic.wxFONTENCODING_ISO8859_14 -wxFONTENCODING_ISO8859_15 = gdic.wxFONTENCODING_ISO8859_15 -wxFONTENCODING_ISO8859_MAX = gdic.wxFONTENCODING_ISO8859_MAX -wxFONTENCODING_KOI8 = gdic.wxFONTENCODING_KOI8 -wxFONTENCODING_ALTERNATIVE = gdic.wxFONTENCODING_ALTERNATIVE -wxFONTENCODING_BULGARIAN = gdic.wxFONTENCODING_BULGARIAN -wxFONTENCODING_CP437 = gdic.wxFONTENCODING_CP437 -wxFONTENCODING_CP850 = gdic.wxFONTENCODING_CP850 -wxFONTENCODING_CP852 = gdic.wxFONTENCODING_CP852 -wxFONTENCODING_CP855 = gdic.wxFONTENCODING_CP855 -wxFONTENCODING_CP866 = gdic.wxFONTENCODING_CP866 -wxFONTENCODING_CP874 = gdic.wxFONTENCODING_CP874 -wxFONTENCODING_CP932 = gdic.wxFONTENCODING_CP932 -wxFONTENCODING_CP936 = gdic.wxFONTENCODING_CP936 -wxFONTENCODING_CP949 = gdic.wxFONTENCODING_CP949 -wxFONTENCODING_CP950 = gdic.wxFONTENCODING_CP950 -wxFONTENCODING_CP1250 = gdic.wxFONTENCODING_CP1250 -wxFONTENCODING_CP1251 = gdic.wxFONTENCODING_CP1251 -wxFONTENCODING_CP1252 = gdic.wxFONTENCODING_CP1252 -wxFONTENCODING_CP1253 = gdic.wxFONTENCODING_CP1253 -wxFONTENCODING_CP1254 = gdic.wxFONTENCODING_CP1254 -wxFONTENCODING_CP1255 = gdic.wxFONTENCODING_CP1255 -wxFONTENCODING_CP1256 = gdic.wxFONTENCODING_CP1256 -wxFONTENCODING_CP1257 = gdic.wxFONTENCODING_CP1257 -wxFONTENCODING_CP12_MAX = gdic.wxFONTENCODING_CP12_MAX -wxFONTENCODING_UTF7 = gdic.wxFONTENCODING_UTF7 -wxFONTENCODING_UTF8 = gdic.wxFONTENCODING_UTF8 -wxFONTENCODING_UNICODE = gdic.wxFONTENCODING_UNICODE -wxFONTENCODING_MAX = gdic.wxFONTENCODING_MAX -wxIMAGELIST_DRAW_NORMAL = gdic.wxIMAGELIST_DRAW_NORMAL -wxIMAGELIST_DRAW_TRANSPARENT = gdic.wxIMAGELIST_DRAW_TRANSPARENT -wxIMAGELIST_DRAW_SELECTED = gdic.wxIMAGELIST_DRAW_SELECTED -wxIMAGELIST_DRAW_FOCUSED = gdic.wxIMAGELIST_DRAW_FOCUSED -wxIMAGE_LIST_NORMAL = gdic.wxIMAGE_LIST_NORMAL -wxIMAGE_LIST_SMALL = gdic.wxIMAGE_LIST_SMALL -wxIMAGE_LIST_STATE = gdic.wxIMAGE_LIST_STATE -wxOutRegion = gdic.wxOutRegion -wxPartRegion = gdic.wxPartRegion -wxInRegion = gdic.wxInRegion -cvar = gdic.cvar -wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT) -wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT) -wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT) -wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT) -wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN) -wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN) -wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN) -wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN) -wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN) -wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN) -wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN) -wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN) -wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN) -wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN) -wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH) -wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH) -wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH) -wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH) -wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH) -wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH) -wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH) -wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH) -wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH) -wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH) -wxBLACK = wxColourPtr(gdic.cvar.wxBLACK) -wxWHITE = wxColourPtr(gdic.cvar.wxWHITE) -wxRED = wxColourPtr(gdic.cvar.wxRED) -wxBLUE = wxColourPtr(gdic.cvar.wxBLUE) -wxGREEN = wxColourPtr(gdic.cvar.wxGREEN) -wxCYAN = wxColourPtr(gdic.cvar.wxCYAN) -wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY) -wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR) -wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR) -wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR) -wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap) -wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon) -wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor) -wxNullPen = wxPenPtr(gdic.cvar.wxNullPen) -wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush) -wxNullPalette = wxPalettePtr(gdic.cvar.wxNullPalette) -wxNullFont = wxFontPtr(gdic.cvar.wxNullFont) -wxNullColour = wxColourPtr(gdic.cvar.wxNullColour) -wxTheFontList = wxFontListPtr(gdic.cvar.wxTheFontList) -wxThePenList = wxPenListPtr(gdic.cvar.wxThePenList) -wxTheBrushList = wxBrushListPtr(gdic.cvar.wxTheBrushList) -wxTheColourDatabase = wxColourDatabasePtr(gdic.cvar.wxTheColourDatabase)