MENU_TEAROFF = _core.MENU_TEAROFF
MB_DOCKABLE = _core.MB_DOCKABLE
NO_FULL_REPAINT_ON_RESIZE = _core.NO_FULL_REPAINT_ON_RESIZE
+FULL_REPAINT_ON_RESIZE = _core.FULL_REPAINT_ON_RESIZE
LI_HORIZONTAL = _core.LI_HORIZONTAL
LI_VERTICAL = _core.LI_VERTICAL
WS_EX_VALIDATE_RECURSIVELY = _core.WS_EX_VALIDATE_RECURSIVELY
#---------------------------------------------------------------------------
class Object(object):
- """The base class for most wx objects, although in wxPython not
-much functionality is needed nor exposed."""
+ """
+ The base class for most wx objects, although in wxPython not
+ much functionality is needed nor exposed.
+ """
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetClassName(*args, **kwargs):
- """GetClassName() -> wxString
+ """
+ GetClassName() -> String
-Returns the class name of the C++ object using wxRTTI."""
+ Returns the class name of the C++ object using wxRTTI.
+ """
return _core.Object_GetClassName(*args, **kwargs)
def Destroy(*args, **kwargs):
- """Destroy()
+ """
+ Destroy()
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Object_Destroy(*args, **kwargs)
_core.Object_swigregister(ObjectPtr)
_wxPySetDictionary = _core._wxPySetDictionary
+_wxPyFixStockObjects = _core._wxPyFixStockObjects
+
+cvar = _core.cvar
+EmptyString = cvar.EmptyString
#---------------------------------------------------------------------------
BITMAP_TYPE_INVALID = _core.BITMAP_TYPE_INVALID
BITMAP_TYPE_BMP = _core.BITMAP_TYPE_BMP
-BITMAP_TYPE_BMP_RESOURCE = _core.BITMAP_TYPE_BMP_RESOURCE
-BITMAP_TYPE_RESOURCE = _core.BITMAP_TYPE_RESOURCE
BITMAP_TYPE_ICO = _core.BITMAP_TYPE_ICO
-BITMAP_TYPE_ICO_RESOURCE = _core.BITMAP_TYPE_ICO_RESOURCE
BITMAP_TYPE_CUR = _core.BITMAP_TYPE_CUR
-BITMAP_TYPE_CUR_RESOURCE = _core.BITMAP_TYPE_CUR_RESOURCE
BITMAP_TYPE_XBM = _core.BITMAP_TYPE_XBM
BITMAP_TYPE_XBM_DATA = _core.BITMAP_TYPE_XBM_DATA
BITMAP_TYPE_XPM = _core.BITMAP_TYPE_XPM
BITMAP_TYPE_XPM_DATA = _core.BITMAP_TYPE_XPM_DATA
BITMAP_TYPE_TIF = _core.BITMAP_TYPE_TIF
-BITMAP_TYPE_TIF_RESOURCE = _core.BITMAP_TYPE_TIF_RESOURCE
BITMAP_TYPE_GIF = _core.BITMAP_TYPE_GIF
-BITMAP_TYPE_GIF_RESOURCE = _core.BITMAP_TYPE_GIF_RESOURCE
BITMAP_TYPE_PNG = _core.BITMAP_TYPE_PNG
-BITMAP_TYPE_PNG_RESOURCE = _core.BITMAP_TYPE_PNG_RESOURCE
BITMAP_TYPE_JPEG = _core.BITMAP_TYPE_JPEG
-BITMAP_TYPE_JPEG_RESOURCE = _core.BITMAP_TYPE_JPEG_RESOURCE
BITMAP_TYPE_PNM = _core.BITMAP_TYPE_PNM
-BITMAP_TYPE_PNM_RESOURCE = _core.BITMAP_TYPE_PNM_RESOURCE
BITMAP_TYPE_PCX = _core.BITMAP_TYPE_PCX
-BITMAP_TYPE_PCX_RESOURCE = _core.BITMAP_TYPE_PCX_RESOURCE
BITMAP_TYPE_PICT = _core.BITMAP_TYPE_PICT
-BITMAP_TYPE_PICT_RESOURCE = _core.BITMAP_TYPE_PICT_RESOURCE
BITMAP_TYPE_ICON = _core.BITMAP_TYPE_ICON
-BITMAP_TYPE_ICON_RESOURCE = _core.BITMAP_TYPE_ICON_RESOURCE
BITMAP_TYPE_ANI = _core.BITMAP_TYPE_ANI
BITMAP_TYPE_IFF = _core.BITMAP_TYPE_IFF
BITMAP_TYPE_MACCURSOR = _core.BITMAP_TYPE_MACCURSOR
-BITMAP_TYPE_MACCURSOR_RESOURCE = _core.BITMAP_TYPE_MACCURSOR_RESOURCE
BITMAP_TYPE_ANY = _core.BITMAP_TYPE_ANY
CURSOR_NONE = _core.CURSOR_NONE
CURSOR_ARROW = _core.CURSOR_ARROW
#---------------------------------------------------------------------------
class Size(object):
- """wx.Size is a useful data structure used to represent the size of something.
-It simply contians integer width and height proprtites. In most places in
-wxPython where a wx.Size is expected a (width,height) tuple can be used
-instead."""
+ """
+ wx.Size is a useful data structure used to represent the size of something.
+ It simply contians integer width and height proprtites. In most places in
+ wxPython where a wx.Size is expected a (width,height) tuple can be used
+ instead.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxSize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
width = property(_core.Size_width_get, _core.Size_width_set)
height = property(_core.Size_height_get, _core.Size_height_set)
+ x = width; y = height
def __init__(self, *args, **kwargs):
- """__init__(int w=0, int h=0) -> Size
+ """
+ __init__(int w=0, int h=0) -> Size
-Creates a size object."""
+ Creates a size object.
+ """
newobj = _core.new_Size(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def __eq__(*args, **kwargs):
- """__eq__(Size sz) -> bool
+ """
+ __eq__(Size sz) -> bool
-Test for equality of wx.Size objects."""
+ Test for equality of wx.Size objects.
+ """
return _core.Size___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(Size sz) -> bool
+ """
+ __ne__(Size sz) -> bool
-Test for inequality."""
+ Test for inequality.
+ """
return _core.Size___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
- """__add__(Size sz) -> Size
+ """
+ __add__(Size sz) -> Size
-Add sz's proprties to this and return the result."""
+ Add sz's proprties to this and return the result.
+ """
return _core.Size___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
- """__sub__(Size sz) -> Size
+ """
+ __sub__(Size sz) -> Size
-Subtract sz's properties from this and return the result."""
+ Subtract sz's properties from this and return the result.
+ """
return _core.Size___sub__(*args, **kwargs)
def IncTo(*args, **kwargs):
- """IncTo(Size sz)
+ """
+ IncTo(Size sz)
-Increments this object so that both of its dimensions are not less
-than the corresponding dimensions of the size."""
+ Increments this object so that both of its dimensions are not less
+ than the corresponding dimensions of the size.
+ """
return _core.Size_IncTo(*args, **kwargs)
def DecTo(*args, **kwargs):
- """DecTo(Size sz)
+ """
+ DecTo(Size sz)
-Decrements this object so that both of its dimensions are not greater
-than the corresponding dimensions of the size."""
+ Decrements this object so that both of its dimensions are not greater
+ than the corresponding dimensions of the size.
+ """
return _core.Size_DecTo(*args, **kwargs)
def Set(*args, **kwargs):
- """Set(int w, int h)
+ """
+ Set(int w, int h)
-Set both width and height."""
+ Set both width and height.
+ """
return _core.Size_Set(*args, **kwargs)
def SetWidth(*args, **kwargs):
return _core.Size_GetHeight(*args, **kwargs)
def Get(*args, **kwargs):
- """Get() -> (width,height)
+ """
+ Get() -> (width,height)
-Returns the width and height properties as a tuple."""
+ Returns the width and height properties as a tuple.
+ """
return _core.Size_Get(*args, **kwargs)
asTuple = Get
elif index == 1: self.height = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.Size, self.Get())
class SizePtr(Size):
#---------------------------------------------------------------------------
class RealPoint(object):
- """A data structure for representing a point or position with floating point x
-and y properties. In wxPython most places that expect a wx.RealPoint can also
-accept a (x,y) tuple."""
+ """
+ A data structure for representing a point or position with floating point x
+ and y properties. In wxPython most places that expect a wx.RealPoint can also
+ accept a (x,y) tuple.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxRealPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
x = property(_core.RealPoint_x_get, _core.RealPoint_x_set)
y = property(_core.RealPoint_y_get, _core.RealPoint_y_set)
def __init__(self, *args, **kwargs):
- """__init__(double x=0.0, double y=0.0) -> RealPoint
+ """
+ __init__(double x=0.0, double y=0.0) -> RealPoint
-Create a wx.RealPoint object"""
+ Create a wx.RealPoint object
+ """
newobj = _core.new_RealPoint(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def __eq__(*args, **kwargs):
- """__eq__(RealPoint pt) -> bool
+ """
+ __eq__(RealPoint pt) -> bool
-Test for equality of wx.RealPoint objects."""
+ Test for equality of wx.RealPoint objects.
+ """
return _core.RealPoint___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(RealPoint pt) -> bool
+ """
+ __ne__(RealPoint pt) -> bool
-Test for inequality of wx.RealPoint objects."""
+ Test for inequality of wx.RealPoint objects.
+ """
return _core.RealPoint___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
- """__add__(RealPoint pt) -> RealPoint
+ """
+ __add__(RealPoint pt) -> RealPoint
-Add pt's proprties to this and return the result."""
+ Add pt's proprties to this and return the result.
+ """
return _core.RealPoint___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
- """__sub__(RealPoint pt) -> RealPoint
+ """
+ __sub__(RealPoint pt) -> RealPoint
-Subtract pt's proprties from this and return the result"""
+ Subtract pt's proprties from this and return the result
+ """
return _core.RealPoint___sub__(*args, **kwargs)
def Set(*args, **kwargs):
- """Set(double x, double y)
+ """
+ Set(double x, double y)
-Set both the x and y properties"""
+ Set both the x and y properties
+ """
return _core.RealPoint_Set(*args, **kwargs)
def Get(*args, **kwargs):
- """Get() -> (x,y)
+ """
+ Get() -> (x,y)
-Return the x and y properties as a tuple. """
+ Return the x and y properties as a tuple.
+ """
return _core.RealPoint_Get(*args, **kwargs)
asTuple = Get
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0.0, 0.0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.RealPoint, self.Get())
class RealPointPtr(RealPoint):
#---------------------------------------------------------------------------
class Point(object):
- """A data structure for representing a point or position with integer x and y
-properties. Most places in wxPython that expect a wx.Point can also accept a
-(x,y) tuple."""
+ """
+ A data structure for representing a point or position with integer x and y
+ properties. Most places in wxPython that expect a wx.Point can also accept a
+ (x,y) tuple.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
x = property(_core.Point_x_get, _core.Point_x_set)
y = property(_core.Point_y_get, _core.Point_y_set)
def __init__(self, *args, **kwargs):
- """__init__(int x=0, int y=0) -> Point
+ """
+ __init__(int x=0, int y=0) -> Point
-Create a wx.Point object"""
+ Create a wx.Point object
+ """
newobj = _core.new_Point(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def __eq__(*args, **kwargs):
- """__eq__(Point pt) -> bool
+ """
+ __eq__(Point pt) -> bool
-Test for equality of wx.Point objects."""
+ Test for equality of wx.Point objects.
+ """
return _core.Point___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(Point pt) -> bool
+ """
+ __ne__(Point pt) -> bool
-Test for inequality of wx.Point objects."""
+ Test for inequality of wx.Point objects.
+ """
return _core.Point___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
- """__add__(Point pt) -> Point
+ """
+ __add__(Point pt) -> Point
-Add pt's proprties to this and return the result."""
+ Add pt's proprties to this and return the result.
+ """
return _core.Point___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
- """__sub__(Point pt) -> Point
+ """
+ __sub__(Point pt) -> Point
-Subtract pt's proprties from this and return the result"""
+ Subtract pt's proprties from this and return the result
+ """
return _core.Point___sub__(*args, **kwargs)
def __iadd__(*args, **kwargs):
- """__iadd__(Point pt) -> Point
+ """
+ __iadd__(Point pt) -> Point
-Add pt to this object."""
+ Add pt to this object.
+ """
return _core.Point___iadd__(*args, **kwargs)
def __isub__(*args, **kwargs):
- """__isub__(Point pt) -> Point
+ """
+ __isub__(Point pt) -> Point
-Subtract pt from this object."""
+ Subtract pt from this object.
+ """
return _core.Point___isub__(*args, **kwargs)
def Set(*args, **kwargs):
- """Set(long x, long y)
+ """
+ Set(long x, long y)
-Set both the x and y properties"""
+ Set both the x and y properties
+ """
return _core.Point_Set(*args, **kwargs)
def Get(*args, **kwargs):
- """Get() -> (x,y)
+ """
+ Get() -> (x,y)
-Return the x and y properties as a tuple. """
+ Return the x and y properties as a tuple.
+ """
return _core.Point_Get(*args, **kwargs)
asTuple = Get
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.Point, self.Get())
class PointPtr(Point):
#---------------------------------------------------------------------------
class Rect(object):
- """A class for representing and manipulating rectangles. It has x, y, width and
-height properties. In wxPython most palces that expect a wx.Rect can also
-accept a (x,y,width,height) tuple."""
+ """
+ A class for representing and manipulating rectangles. It has x, y, width and
+ height properties. In wxPython most palces that expect a wx.Rect can also
+ accept a (x,y,width,height) tuple.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxRect 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) -> Rect
+ """
+ __init__(int x=0, int y=0, int width=0, int height=0) -> Rect
-Create a new Rect object."""
+ Create a new Rect object.
+ """
newobj = _core.new_Rect(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
"""SetSize(Size s)"""
return _core.Rect_SetSize(*args, **kwargs)
+ def GetTopLeft(*args, **kwargs):
+ """GetTopLeft() -> Point"""
+ return _core.Rect_GetTopLeft(*args, **kwargs)
+
+ def SetTopLeft(*args, **kwargs):
+ """SetTopLeft(Point p)"""
+ return _core.Rect_SetTopLeft(*args, **kwargs)
+
+ def GetBottomRight(*args, **kwargs):
+ """GetBottomRight() -> Point"""
+ return _core.Rect_GetBottomRight(*args, **kwargs)
+
+ def SetBottomRight(*args, **kwargs):
+ """SetBottomRight(Point p)"""
+ return _core.Rect_SetBottomRight(*args, **kwargs)
+
def GetLeft(*args, **kwargs):
"""GetLeft() -> int"""
return _core.Rect_GetLeft(*args, **kwargs)
bottom = property(GetBottom, SetBottom)
def Inflate(*args, **kwargs):
- """Inflate(int dx, int dy) -> Rect
+ """
+ Inflate(int dx, int dy) -> Rect
-Increase the rectangle size by dx in x direction and dy in y direction. Both
-(or one of) parameters may be negative to decrease the rectangle size."""
+ Increase the rectangle size by dx in x direction and dy in y direction. Both
+ (or one of) parameters may be negative to decrease the rectangle size.
+ """
return _core.Rect_Inflate(*args, **kwargs)
def Deflate(*args, **kwargs):
- """Deflate(int dx, int dy) -> Rect
+ """
+ Deflate(int dx, int dy) -> Rect
-Decrease the rectangle size by dx in x direction and dy in y direction. Both
-(or one of) parameters may be negative to increase the rectngle size. This
-method is the opposite of Inflate."""
+ Decrease the rectangle size by dx in x direction and dy in y direction. Both
+ (or one of) parameters may be negative to increase the rectngle size. This
+ method is the opposite of Inflate.
+ """
return _core.Rect_Deflate(*args, **kwargs)
def OffsetXY(*args, **kwargs):
- """OffsetXY(int dx, int dy)
+ """
+ OffsetXY(int dx, int dy)
-Moves the rectangle by the specified offset. If dx is positive, the rectangle
-is moved to the right, if dy is positive, it is moved to the bottom, otherwise
-it is moved to the left or top respectively."""
+ Moves the rectangle by the specified offset. If dx is positive, the rectangle
+ is moved to the right, if dy is positive, it is moved to the bottom, otherwise
+ it is moved to the left or top respectively.
+ """
return _core.Rect_OffsetXY(*args, **kwargs)
def Offset(*args, **kwargs):
- """Offset(Point pt)
+ """
+ Offset(Point pt)
-Same as OffsetXY but uses dx,dy from Point"""
+ Same as OffsetXY but uses dx,dy from Point
+ """
return _core.Rect_Offset(*args, **kwargs)
def Intersect(*args, **kwargs):
- """Intersect(Rect rect) -> Rect
+ """
+ Intersect(Rect rect) -> Rect
-Return the intersectsion of this rectangle and rect."""
+ Return the intersectsion of this rectangle and rect.
+ """
return _core.Rect_Intersect(*args, **kwargs)
def __add__(*args, **kwargs):
- """__add__(Rect rect) -> Rect
+ """
+ __add__(Rect rect) -> Rect
-Add the properties of rect to this rectangle and return the result."""
+ Add the properties of rect to this rectangle and return the result.
+ """
return _core.Rect___add__(*args, **kwargs)
def __iadd__(*args, **kwargs):
- """__iadd__(Rect rect) -> Rect
+ """
+ __iadd__(Rect rect) -> Rect
-Add the properties of rect to this rectangle, updating this rectangle."""
+ Add the properties of rect to this rectangle, updating this rectangle.
+ """
return _core.Rect___iadd__(*args, **kwargs)
def __eq__(*args, **kwargs):
- """__eq__(Rect rect) -> bool
+ """
+ __eq__(Rect rect) -> bool
-Test for equality."""
+ Test for equality.
+ """
return _core.Rect___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(Rect rect) -> bool
+ """
+ __ne__(Rect rect) -> bool
-Test for inequality."""
+ Test for inequality.
+ """
return _core.Rect___ne__(*args, **kwargs)
def InsideXY(*args, **kwargs):
- """InsideXY(int x, int y) -> bool
+ """
+ InsideXY(int x, int y) -> bool
-Return True if the point is (not strcitly) inside the rect."""
+ Return True if the point is (not strcitly) inside the rect.
+ """
return _core.Rect_InsideXY(*args, **kwargs)
def Inside(*args, **kwargs):
- """Inside(Point pt) -> bool
+ """
+ Inside(Point pt) -> bool
-Return True if the point is (not strcitly) inside the rect."""
+ Return True if the point is (not strcitly) inside the rect.
+ """
return _core.Rect_Inside(*args, **kwargs)
def Intersects(*args, **kwargs):
- """Intersects(Rect rect) -> bool
+ """
+ Intersects(Rect rect) -> bool
-Returns True if the rectangles have a non empty intersection."""
+ Returns True if the rectangles have a non empty intersection.
+ """
return _core.Rect_Intersects(*args, **kwargs)
x = property(_core.Rect_x_get, _core.Rect_x_set)
width = property(_core.Rect_width_get, _core.Rect_width_set)
height = property(_core.Rect_height_get, _core.Rect_height_set)
def Set(*args, **kwargs):
- """Set(int x=0, int y=0, int width=0, int height=0)
+ """
+ Set(int x=0, int y=0, int width=0, int height=0)
-Set all rectangle properties."""
+ Set all rectangle properties.
+ """
return _core.Rect_Set(*args, **kwargs)
def Get(*args, **kwargs):
- """Get() -> (x,y,width,height)
+ """
+ Get() -> (x,y,width,height)
-Return the rectangle properties as a tuple."""
+ Return the rectangle properties as a tuple.
+ """
return _core.Rect_Get(*args, **kwargs)
asTuple = Get
elif index == 3: self.height = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0,0,0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.Rect, self.Get())
class RectPtr(Rect):
_core.Rect_swigregister(RectPtr)
def RectPP(*args, **kwargs):
- """RectPP(Point topLeft, Point bottomRight) -> Rect
+ """
+ RectPP(Point topLeft, Point bottomRight) -> Rect
-Create a new Rect object from Points representing two corners."""
+ Create a new Rect object from Points representing two corners.
+ """
val = _core.new_RectPP(*args, **kwargs)
val.thisown = 1
return val
def RectPS(*args, **kwargs):
- """RectPS(Point pos, Size size) -> Rect
+ """
+ RectPS(Point pos, Size size) -> Rect
-Create a new Rect from a position and size."""
+ Create a new Rect from a position and size.
+ """
val = _core.new_RectPS(*args, **kwargs)
val.thisown = 1
return val
def IntersectRect(*args, **kwargs):
- """IntersectRect(Rect r1, Rect r2) -> Rect
+ """
+ IntersectRect(Rect r1, Rect r2) -> Rect
-Calculate and return the intersection of r1 and r2."""
+ Calculate and return the intersection of r1 and r2.
+ """
return _core.IntersectRect(*args, **kwargs)
#---------------------------------------------------------------------------
def __repr__(self):
return "<%s.%s; proxy of C++ wxPoint2D instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(double x=0.0, double y=0.0) -> Point2D
+ """
+ __init__(double x=0.0, double y=0.0) -> Point2D
-Create a w.Point2D object."""
+ Create a w.Point2D object.
+ """
newobj = _core.new_Point2D(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetFloor(*args, **kwargs):
- """GetFloor() -> (x,y)
+ """
+ GetFloor() -> (x,y)
-Convert to integer"""
+ Convert to integer
+ """
return _core.Point2D_GetFloor(*args, **kwargs)
def GetRounded(*args, **kwargs):
- """GetRounded() -> (x,y)
+ """
+ GetRounded() -> (x,y)
-Convert to integer"""
+ Convert to integer
+ """
return _core.Point2D_GetRounded(*args, **kwargs)
def GetVectorLength(*args, **kwargs):
return _core.Point2D_GetCrossProduct(*args, **kwargs)
def __neg__(*args, **kwargs):
- """__neg__() -> Point2D
+ """
+ __neg__() -> Point2D
-the reflection of this point"""
+ the reflection of this point
+ """
return _core.Point2D___neg__(*args, **kwargs)
def __iadd__(*args, **kwargs):
return _core.Point2D___idiv__(*args, **kwargs)
def __eq__(*args, **kwargs):
- """__eq__(Point2D pt) -> bool
+ """
+ __eq__(Point2D pt) -> bool
-Test for equality"""
+ Test for equality
+ """
return _core.Point2D___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(Point2D pt) -> bool
+ """
+ __ne__(Point2D pt) -> bool
-Test for inequality"""
+ Test for inequality
+ """
return _core.Point2D___ne__(*args, **kwargs)
x = property(_core.Point2D_x_get, _core.Point2D_x_set)
return _core.Point2D_Set(*args, **kwargs)
def Get(*args, **kwargs):
- """Get() -> (x,y)
+ """
+ Get() -> (x,y)
-Return x and y properties as a tuple."""
+ Return x and y properties as a tuple.
+ """
return _core.Point2D_Get(*args, **kwargs)
asTuple = Get
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0.0, 0.0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
-
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.Point2D, self.Get())
class Point2DPtr(Point2D):
_core.Point2D_swigregister(Point2DPtr)
def Point2DCopy(*args, **kwargs):
- """Point2DCopy(Point2D pt) -> Point2D
+ """
+ Point2DCopy(Point2D pt) -> Point2D
-Create a w.Point2D object."""
+ Create a w.Point2D object.
+ """
val = _core.new_Point2DCopy(*args, **kwargs)
val.thisown = 1
return val
def Point2DFromPoint(*args, **kwargs):
- """Point2DFromPoint(Point pt) -> Point2D
+ """
+ Point2DFromPoint(Point pt) -> Point2D
-Create a w.Point2D object."""
+ Create a w.Point2D object.
+ """
val = _core.new_Point2DFromPoint(*args, **kwargs)
val.thisown = 1
return val
FromCurrent = _core.FromCurrent
FromEnd = _core.FromEnd
class InputStream(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyInputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.InputStream_Ungetch(*args, **kwargs)
def SeekI(*args, **kwargs):
- """SeekI(long pos, wxSeekMode mode=FromStart) -> long"""
+ """SeekI(long pos, int mode=FromStart) -> long"""
return _core.InputStream_SeekI(*args, **kwargs)
def TellI(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = InputStream
_core.InputStream_swigregister(InputStreamPtr)
-cvar = _core.cvar
DefaultPosition = cvar.DefaultPosition
DefaultSize = cvar.DefaultSize
class OutputStream(object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxOutputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
#---------------------------------------------------------------------------
class FSFile(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFSFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxInputStream stream, wxString loc, wxString mimetype,
- wxString anchor, wxDateTime modif) -> FSFile"""
+ """
+ __init__(InputStream stream, String loc, String mimetype, String anchor,
+ DateTime modif) -> FSFile
+ """
newobj = _core.new_FSFile(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def GetStream(*args, **kwargs):
- """GetStream() -> wxInputStream"""
+ """GetStream() -> InputStream"""
return _core.FSFile_GetStream(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _core.FSFile_GetMimeType(*args, **kwargs)
def GetLocation(*args, **kwargs):
- """GetLocation() -> wxString"""
+ """GetLocation() -> String"""
return _core.FSFile_GetLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
- """GetAnchor() -> wxString"""
+ """GetAnchor() -> String"""
return _core.FSFile_GetAnchor(*args, **kwargs)
def GetModificationTime(*args, **kwargs):
- """GetModificationTime() -> wxDateTime"""
+ """GetModificationTime() -> DateTime"""
return _core.FSFile_GetModificationTime(*args, **kwargs)
_core.FSFile_swigregister(FSFilePtr)
class CPPFileSystemHandler(object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
_core.CPPFileSystemHandler_swigregister(CPPFileSystemHandlerPtr)
class FileSystemHandler(CPPFileSystemHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.FileSystemHandler__setCallbackInfo(*args, **kwargs)
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.FileSystemHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.FileSystemHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.FileSystemHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.FileSystemHandler_FindNext(*args, **kwargs)
def GetProtocol(*args, **kwargs):
- """GetProtocol(wxString location) -> wxString"""
+ """GetProtocol(String location) -> String"""
return _core.FileSystemHandler_GetProtocol(*args, **kwargs)
def GetLeftLocation(*args, **kwargs):
- """GetLeftLocation(wxString location) -> wxString"""
+ """GetLeftLocation(String location) -> String"""
return _core.FileSystemHandler_GetLeftLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
- """GetAnchor(wxString location) -> wxString"""
+ """GetAnchor(String location) -> String"""
return _core.FileSystemHandler_GetAnchor(*args, **kwargs)
def GetRightLocation(*args, **kwargs):
- """GetRightLocation(wxString location) -> wxString"""
+ """GetRightLocation(String location) -> String"""
return _core.FileSystemHandler_GetRightLocation(*args, **kwargs)
def GetMimeTypeFromExt(*args, **kwargs):
- """GetMimeTypeFromExt(wxString location) -> wxString"""
+ """GetMimeTypeFromExt(String location) -> String"""
return _core.FileSystemHandler_GetMimeTypeFromExt(*args, **kwargs)
_core.FileSystemHandler_swigregister(FileSystemHandlerPtr)
class FileSystem(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileSystem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
except: pass
def ChangePathTo(*args, **kwargs):
- """ChangePathTo(wxString location, bool is_dir=False)"""
+ """ChangePathTo(String location, bool is_dir=False)"""
return _core.FileSystem_ChangePathTo(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _core.FileSystem_GetPath(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(wxString location) -> FSFile"""
+ """OpenFile(String location) -> FSFile"""
return _core.FileSystem_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.FileSystem_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.FileSystem_FindNext(*args, **kwargs)
def AddHandler(*args, **kwargs):
- """FileSystem.AddHandler(CPPFileSystemHandler handler)"""
+ """AddHandler(CPPFileSystemHandler handler)"""
return _core.FileSystem_AddHandler(*args, **kwargs)
AddHandler = staticmethod(AddHandler)
def CleanUpHandlers(*args, **kwargs):
- """FileSystem.CleanUpHandlers()"""
+ """CleanUpHandlers()"""
return _core.FileSystem_CleanUpHandlers(*args, **kwargs)
CleanUpHandlers = staticmethod(CleanUpHandlers)
def FileNameToURL(*args, **kwargs):
- """FileSystem.FileNameToURL(wxString filename) -> wxString"""
+ """FileNameToURL(String filename) -> String"""
return _core.FileSystem_FileNameToURL(*args, **kwargs)
FileNameToURL = staticmethod(FileNameToURL)
return _core.FileSystem_CleanUpHandlers(*args, **kwargs)
def FileSystem_FileNameToURL(*args, **kwargs):
- """FileSystem_FileNameToURL(wxString filename) -> wxString"""
+ """FileSystem_FileNameToURL(String filename) -> String"""
return _core.FileSystem_FileNameToURL(*args, **kwargs)
def FileSystem_URLToFileName(*args, **kwargs):
- """FileSystem_URLToFileName(wxString url) -> wxString"""
+ """FileSystem_URLToFileName(String url) -> String"""
return _core.FileSystem_URLToFileName(*args, **kwargs)
class InternetFSHandler(CPPFileSystemHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxInternetFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.InternetFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.InternetFSHandler_OpenFile(*args, **kwargs)
_core.InternetFSHandler_swigregister(InternetFSHandlerPtr)
class ZipFSHandler(CPPFileSystemHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxZipFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.ZipFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.ZipFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.ZipFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.ZipFSHandler_FindNext(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxImage(wxString filename, Image image, long type)"""
+ """__wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type)"""
return _core.__wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxBitmap(wxString filename, wxBitmap bitmap, long type)"""
+ """__wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type)"""
return _core.__wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_Data(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_Data(wxString filename, PyObject data)"""
+ """__wxMemoryFSHandler_AddFile_Data(String filename, PyObject data)"""
return _core.__wxMemoryFSHandler_AddFile_Data(*args, **kwargs)
def MemoryFSHandler_AddFile(filename, a, b=''):
if isinstance(a, wx.Image):
else: raise TypeError, 'wx.Image, wx.Bitmap or string expected'
class MemoryFSHandler(CPPFileSystemHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMemoryFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def RemoveFile(*args, **kwargs):
- """MemoryFSHandler.RemoveFile(wxString filename)"""
+ """RemoveFile(String filename)"""
return _core.MemoryFSHandler_RemoveFile(*args, **kwargs)
RemoveFile = staticmethod(RemoveFile)
AddFile = staticmethod(MemoryFSHandler_AddFile)
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.MemoryFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.MemoryFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.MemoryFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.MemoryFSHandler_FindNext(*args, **kwargs)
_core.MemoryFSHandler_swigregister(MemoryFSHandlerPtr)
def MemoryFSHandler_RemoveFile(*args, **kwargs):
- """MemoryFSHandler_RemoveFile(wxString filename)"""
+ """MemoryFSHandler_RemoveFile(String filename)"""
return _core.MemoryFSHandler_RemoveFile(*args, **kwargs)
#---------------------------------------------------------------------------
class ImageHandler(Object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _core.ImageHandler_GetName(*args, **kwargs)
def GetExtension(*args, **kwargs):
- """GetExtension() -> wxString"""
+ """GetExtension() -> String"""
return _core.ImageHandler_GetExtension(*args, **kwargs)
def GetType(*args, **kwargs):
return _core.ImageHandler_GetType(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _core.ImageHandler_GetMimeType(*args, **kwargs)
def CanRead(*args, **kwargs):
- """CanRead(wxString name) -> bool"""
+ """CanRead(String name) -> bool"""
return _core.ImageHandler_CanRead(*args, **kwargs)
def SetName(*args, **kwargs):
- """SetName(wxString name)"""
+ """SetName(String name)"""
return _core.ImageHandler_SetName(*args, **kwargs)
def SetExtension(*args, **kwargs):
- """SetExtension(wxString extension)"""
+ """SetExtension(String extension)"""
return _core.ImageHandler_SetExtension(*args, **kwargs)
def SetType(*args, **kwargs):
return _core.ImageHandler_SetType(*args, **kwargs)
def SetMimeType(*args, **kwargs):
- """SetMimeType(wxString mimetype)"""
+ """SetMimeType(String mimetype)"""
return _core.ImageHandler_SetMimeType(*args, **kwargs)
_core.ImageHandler_swigregister(ImageHandlerPtr)
class ImageHistogram(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHistogram instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def MakeKey(*args, **kwargs):
- """ImageHistogram.MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
+ """
+ MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
-Get the key in the histogram for the given RGB values"""
+ Get the key in the histogram for the given RGB values
+ """
return _core.ImageHistogram_MakeKey(*args, **kwargs)
MakeKey = staticmethod(MakeKey)
def FindFirstUnusedColour(*args, **kwargs):
- """FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
+ """
+ FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
-Find first colour that is not used in the image and has higher RGB values than
-startR, startG, startB. Returns a tuple consisting of a success flag and rgb
-values."""
+ Find first colour that is not used in the image and has higher RGB values than
+ startR, startG, startB. Returns a tuple consisting of a success flag and rgb
+ values.
+ """
return _core.ImageHistogram_FindFirstUnusedColour(*args, **kwargs)
_core.ImageHistogram_swigregister(ImageHistogramPtr)
def ImageHistogram_MakeKey(*args, **kwargs):
- """ImageHistogram_MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
+ """
+ ImageHistogram_MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
-Get the key in the histogram for the given RGB values"""
+ Get the key in the histogram for the given RGB values
+ """
return _core.ImageHistogram_MakeKey(*args, **kwargs)
class Image(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+ """__init__(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
newobj = _core.new_Image(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _core.Image_Create(*args, **kwargs)
def Destroy(*args, **kwargs):
- """Destroy()
+ """
+ Destroy()
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Image_Destroy(*args, **kwargs)
def Scale(*args, **kwargs):
return _core.Image_HasAlpha(*args, **kwargs)
def FindFirstUnusedColour(*args, **kwargs):
- """FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
+ """
+ FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
-Find first colour that is not used in the image and has higher RGB values than
-startR, startG, startB. Returns a tuple consisting of a success flag and rgb
-values."""
+ Find first colour that is not used in the image and has higher RGB values than
+ startR, startG, startB. Returns a tuple consisting of a success flag and rgb
+ values.
+ """
return _core.Image_FindFirstUnusedColour(*args, **kwargs)
def SetMaskFromImage(*args, **kwargs):
return _core.Image_SetMaskFromImage(*args, **kwargs)
def CanRead(*args, **kwargs):
- """Image.CanRead(wxString name) -> bool"""
+ """CanRead(String name) -> bool"""
return _core.Image_CanRead(*args, **kwargs)
CanRead = staticmethod(CanRead)
def GetImageCount(*args, **kwargs):
- """Image.GetImageCount(wxString name, long type=BITMAP_TYPE_ANY) -> int"""
+ """GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
return _core.Image_GetImageCount(*args, **kwargs)
GetImageCount = staticmethod(GetImageCount)
def LoadFile(*args, **kwargs):
- """LoadFile(wxString name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+ """LoadFile(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
return _core.Image_LoadFile(*args, **kwargs)
def LoadMimeFile(*args, **kwargs):
- """LoadMimeFile(wxString name, wxString mimetype, int index=-1) -> bool"""
+ """LoadMimeFile(String name, String mimetype, int index=-1) -> bool"""
return _core.Image_LoadMimeFile(*args, **kwargs)
def SaveFile(*args, **kwargs):
- """SaveFile(wxString name, int type) -> bool"""
+ """SaveFile(String name, int type) -> bool"""
return _core.Image_SaveFile(*args, **kwargs)
def SaveMimeFile(*args, **kwargs):
- """SaveMimeFile(wxString name, wxString mimetype) -> bool"""
+ """SaveMimeFile(String name, String mimetype) -> bool"""
return _core.Image_SaveMimeFile(*args, **kwargs)
def CanReadStream(*args, **kwargs):
- """Image.CanReadStream(wxInputStream stream) -> bool"""
+ """CanReadStream(InputStream stream) -> bool"""
return _core.Image_CanReadStream(*args, **kwargs)
CanReadStream = staticmethod(CanReadStream)
def LoadStream(*args, **kwargs):
- """LoadStream(wxInputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+ """LoadStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
return _core.Image_LoadStream(*args, **kwargs)
def LoadMimeStream(*args, **kwargs):
- """LoadMimeStream(wxInputStream stream, wxString mimetype, int index=-1) -> bool"""
+ """LoadMimeStream(InputStream stream, String mimetype, int index=-1) -> bool"""
return _core.Image_LoadMimeStream(*args, **kwargs)
def Ok(*args, **kwargs):
return _core.Image_HasMask(*args, **kwargs)
def Rotate(*args, **kwargs):
- """Rotate(double angle, Point centre_of_rotation, bool interpolating=True,
- Point offset_after_rotation=None) -> Image"""
+ """
+ Rotate(double angle, Point centre_of_rotation, bool interpolating=True,
+ Point offset_after_rotation=None) -> Image
+ """
return _core.Image_Rotate(*args, **kwargs)
def Rotate90(*args, **kwargs):
return _core.Image_Mirror(*args, **kwargs)
def Replace(*args, **kwargs):
- """Replace(unsigned char r1, unsigned char g1, unsigned char b1,
- unsigned char r2, unsigned char g2, unsigned char b2)"""
+ """
+ Replace(unsigned char r1, unsigned char g1, unsigned char b1,
+ unsigned char r2, unsigned char g2, unsigned char b2)
+ """
return _core.Image_Replace(*args, **kwargs)
def ConvertToMono(*args, **kwargs):
return _core.Image_ConvertToMono(*args, **kwargs)
def SetOption(*args, **kwargs):
- """SetOption(wxString name, wxString value)"""
+ """SetOption(String name, String value)"""
return _core.Image_SetOption(*args, **kwargs)
def SetOptionInt(*args, **kwargs):
- """SetOptionInt(wxString name, int value)"""
+ """SetOptionInt(String name, int value)"""
return _core.Image_SetOptionInt(*args, **kwargs)
def GetOption(*args, **kwargs):
- """GetOption(wxString name) -> wxString"""
+ """GetOption(String name) -> String"""
return _core.Image_GetOption(*args, **kwargs)
def GetOptionInt(*args, **kwargs):
- """GetOptionInt(wxString name) -> int"""
+ """GetOptionInt(String name) -> int"""
return _core.Image_GetOptionInt(*args, **kwargs)
def HasOption(*args, **kwargs):
- """HasOption(wxString name) -> bool"""
+ """HasOption(String name) -> bool"""
return _core.Image_HasOption(*args, **kwargs)
def CountColours(*args, **kwargs):
return _core.Image_ComputeHistogram(*args, **kwargs)
def AddHandler(*args, **kwargs):
- """Image.AddHandler(ImageHandler handler)"""
+ """AddHandler(ImageHandler handler)"""
return _core.Image_AddHandler(*args, **kwargs)
AddHandler = staticmethod(AddHandler)
def InsertHandler(*args, **kwargs):
- """Image.InsertHandler(ImageHandler handler)"""
+ """InsertHandler(ImageHandler handler)"""
return _core.Image_InsertHandler(*args, **kwargs)
InsertHandler = staticmethod(InsertHandler)
def RemoveHandler(*args, **kwargs):
- """Image.RemoveHandler(wxString name) -> bool"""
+ """RemoveHandler(String name) -> bool"""
return _core.Image_RemoveHandler(*args, **kwargs)
RemoveHandler = staticmethod(RemoveHandler)
def GetImageExtWildcard(*args, **kwargs):
- """Image.GetImageExtWildcard() -> wxString"""
+ """GetImageExtWildcard() -> String"""
return _core.Image_GetImageExtWildcard(*args, **kwargs)
GetImageExtWildcard = staticmethod(GetImageExtWildcard)
def ConvertToBitmap(*args, **kwargs):
- """ConvertToBitmap() -> wxBitmap"""
+ """ConvertToBitmap() -> Bitmap"""
return _core.Image_ConvertToBitmap(*args, **kwargs)
def ConvertToMonoBitmap(*args, **kwargs):
- """ConvertToMonoBitmap(unsigned char red, unsigned char green, unsigned char blue) -> wxBitmap"""
+ """ConvertToMonoBitmap(unsigned char red, unsigned char green, unsigned char blue) -> Bitmap"""
return _core.Image_ConvertToMonoBitmap(*args, **kwargs)
def __nonzero__(self): return self.Ok()
_core.Image_swigregister(ImagePtr)
def ImageFromMime(*args, **kwargs):
- """ImageFromMime(wxString name, wxString mimetype, int index=-1) -> Image"""
+ """ImageFromMime(String name, String mimetype, int index=-1) -> Image"""
val = _core.new_ImageFromMime(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStream(*args, **kwargs):
- """ImageFromStream(wxInputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+ """ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
val = _core.new_ImageFromStream(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStreamMime(*args, **kwargs):
- """ImageFromStreamMime(wxInputStream stream, wxString mimetype, int index=-1) -> Image"""
+ """ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image"""
val = _core.new_ImageFromStreamMime(*args, **kwargs)
val.thisown = 1
return val
return val
def ImageFromBitmap(*args, **kwargs):
- """ImageFromBitmap(wxBitmap bitmap) -> Image"""
+ """ImageFromBitmap(Bitmap bitmap) -> Image"""
val = _core.new_ImageFromBitmap(*args, **kwargs)
val.thisown = 1
return val
return val
def Image_CanRead(*args, **kwargs):
- """Image_CanRead(wxString name) -> bool"""
+ """Image_CanRead(String name) -> bool"""
return _core.Image_CanRead(*args, **kwargs)
def Image_GetImageCount(*args, **kwargs):
- """Image_GetImageCount(wxString name, long type=BITMAP_TYPE_ANY) -> int"""
+ """Image_GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
return _core.Image_GetImageCount(*args, **kwargs)
def Image_CanReadStream(*args, **kwargs):
- """Image_CanReadStream(wxInputStream stream) -> bool"""
+ """Image_CanReadStream(InputStream stream) -> bool"""
return _core.Image_CanReadStream(*args, **kwargs)
def Image_AddHandler(*args, **kwargs):
return _core.Image_InsertHandler(*args, **kwargs)
def Image_RemoveHandler(*args, **kwargs):
- """Image_RemoveHandler(wxString name) -> bool"""
+ """Image_RemoveHandler(String name) -> bool"""
return _core.Image_RemoveHandler(*args, **kwargs)
def Image_GetImageExtWildcard(*args, **kwargs):
- """Image_GetImageExtWildcard() -> wxString"""
+ """Image_GetImageExtWildcard() -> String"""
return _core.Image_GetImageExtWildcard(*args, **kwargs)
BMP_1BPP = _core.BMP_1BPP
BMP_1BPP_BW = _core.BMP_1BPP_BW
class BMPHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxBMPHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
IMAGE_OPTION_RESOLUTIONUNIT = cvar.IMAGE_OPTION_RESOLUTIONUNIT
class ICOHandler(BMPHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxICOHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.ICOHandler_swigregister(ICOHandlerPtr)
class CURHandler(ICOHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCURHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.CURHandler_swigregister(CURHandlerPtr)
class ANIHandler(CURHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxANIHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.ANIHandler_swigregister(ANIHandlerPtr)
class PNGHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PNGHandler_swigregister(PNGHandlerPtr)
class GIFHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGIFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.GIFHandler_swigregister(GIFHandlerPtr)
class PCXHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPCXHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PCXHandler_swigregister(PCXHandlerPtr)
class JPEGHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxJPEGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.JPEGHandler_swigregister(JPEGHandlerPtr)
class PNMHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PNMHandler_swigregister(PNMHandlerPtr)
class XPMHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxXPMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.XPMHandler_swigregister(XPMHandlerPtr)
class TIFFHandler(ImageHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxTIFFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class EvtHandler(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxEvtHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
-EVT_SPIN_UP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1)
-EVT_SPIN_DOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1)
-EVT_SPIN = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
-
EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1)
#---------------------------------------------------------------------------
class Event(Object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
#---------------------------------------------------------------------------
class PropagationDisabler(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagationDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PropagationDisabler_swigregister(PropagationDisablerPtr)
class PropagateOnce(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagateOnce instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class CommandEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.CommandEvent_GetSelection(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(wxString s)"""
+ """SetString(String s)"""
return _core.CommandEvent_SetString(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString() -> wxString"""
+ """GetString() -> String"""
return _core.CommandEvent_GetString(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""IsChecked() -> bool"""
return _core.CommandEvent_IsChecked(*args, **kwargs)
+ Checked = IsChecked
def IsSelection(*args, **kwargs):
"""IsSelection() -> bool"""
return _core.CommandEvent_IsSelection(*args, **kwargs)
#---------------------------------------------------------------------------
class NotifyEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNotifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class ScrollEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxEventType commandType=wxEVT_NULL, int winid=0, int pos=0,
- int orient=0) -> ScrollEvent"""
+ """
+ __init__(wxEventType commandType=wxEVT_NULL, int winid=0, int pos=0,
+ int orient=0) -> ScrollEvent
+ """
newobj = _core.new_ScrollEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
#---------------------------------------------------------------------------
class ScrollWinEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollWinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
MOUSE_BTN_MIDDLE = _core.MOUSE_BTN_MIDDLE
MOUSE_BTN_RIGHT = _core.MOUSE_BTN_RIGHT
class MouseEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMouseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.MouseEvent_Leaving(*args, **kwargs)
def GetPosition(*args, **kwargs):
- """GetPosition() -> Point
+ """
+ GetPosition() -> Point
-Returns the position of the mouse in window coordinates when the event happened."""
+ Returns the position of the mouse in window coordinates when the event happened.
+ """
return _core.MouseEvent_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
- """GetPositionTuple() -> (x,y)
+ """
+ GetPositionTuple() -> (x,y)
-Returns the position of the mouse in window coordinates when the event happened."""
+ Returns the position of the mouse in window coordinates when the event happened.
+ """
return _core.MouseEvent_GetPositionTuple(*args, **kwargs)
def GetLogicalPosition(*args, **kwargs):
- """GetLogicalPosition(wxDC dc) -> Point"""
+ """GetLogicalPosition(DC dc) -> Point"""
return _core.MouseEvent_GetLogicalPosition(*args, **kwargs)
def GetX(*args, **kwargs):
#---------------------------------------------------------------------------
class SetCursorEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSetCursorEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.SetCursorEvent_GetY(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor)"""
+ """SetCursor(Cursor cursor)"""
return _core.SetCursorEvent_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor() -> wxCursor"""
+ """GetCursor() -> Cursor"""
return _core.SetCursorEvent_GetCursor(*args, **kwargs)
def HasCursor(*args, **kwargs):
#---------------------------------------------------------------------------
class KeyEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.KeyEvent_GetRawKeyFlags(*args, **kwargs)
def GetPosition(*args, **kwargs):
- """GetPosition() -> Point
+ """
+ GetPosition() -> Point
-Find the position of the event."""
+ Find the position of the event.
+ """
return _core.KeyEvent_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
- """GetPositionTuple() -> (x,y)
+ """
+ GetPositionTuple() -> (x,y)
-Find the position of the event."""
+ Find the position of the event.
+ """
return _core.KeyEvent_GetPositionTuple(*args, **kwargs)
def GetX(*args, **kwargs):
#---------------------------------------------------------------------------
class SizeEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class MoveEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMoveEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class PaintEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PaintEvent_swigregister(PaintEventPtr)
class NcPaintEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNcPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class EraseEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxEraseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(int Id=0, wxDC dc=(wxDC *) NULL) -> EraseEvent"""
+ """__init__(int Id=0, DC dc=(wxDC *) NULL) -> EraseEvent"""
newobj = _core.new_EraseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetDC(*args, **kwargs):
- """GetDC() -> wxDC"""
+ """GetDC() -> DC"""
return _core.EraseEvent_GetDC(*args, **kwargs)
#---------------------------------------------------------------------------
class FocusEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class ChildFocusEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxChildFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class ActivateEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxActivateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class InitDialogEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxInitDialogEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class MenuEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class CloseEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCloseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class ShowEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxShowEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class IconizeEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxIconizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class MaximizeEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMaximizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class DropFilesEvent(Event):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxDropFilesEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
UPDATE_UI_PROCESS_ALL = _core.UPDATE_UI_PROCESS_ALL
UPDATE_UI_PROCESS_SPECIFIED = _core.UPDATE_UI_PROCESS_SPECIFIED
class UpdateUIEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxUpdateUIEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.UpdateUIEvent_GetEnabled(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _core.UpdateUIEvent_GetText(*args, **kwargs)
def GetSetText(*args, **kwargs):
return _core.UpdateUIEvent_Enable(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _core.UpdateUIEvent_SetText(*args, **kwargs)
def SetUpdateInterval(*args, **kwargs):
- """UpdateUIEvent.SetUpdateInterval(long updateInterval)"""
+ """SetUpdateInterval(long updateInterval)"""
return _core.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
SetUpdateInterval = staticmethod(SetUpdateInterval)
def GetUpdateInterval(*args, **kwargs):
- """UpdateUIEvent.GetUpdateInterval() -> long"""
+ """GetUpdateInterval() -> long"""
return _core.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
GetUpdateInterval = staticmethod(GetUpdateInterval)
def CanUpdate(*args, **kwargs):
- """UpdateUIEvent.CanUpdate(Window win) -> bool"""
+ """CanUpdate(Window win) -> bool"""
return _core.UpdateUIEvent_CanUpdate(*args, **kwargs)
CanUpdate = staticmethod(CanUpdate)
def ResetUpdateTime(*args, **kwargs):
- """UpdateUIEvent.ResetUpdateTime()"""
+ """ResetUpdateTime()"""
return _core.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
ResetUpdateTime = staticmethod(ResetUpdateTime)
def SetMode(*args, **kwargs):
- """UpdateUIEvent.SetMode(wxUpdateUIMode mode)"""
+ """SetMode(int mode)"""
return _core.UpdateUIEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """UpdateUIEvent.GetMode() -> wxUpdateUIMode"""
+ """GetMode() -> int"""
return _core.UpdateUIEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
return _core.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
def UpdateUIEvent_SetMode(*args, **kwargs):
- """UpdateUIEvent_SetMode(wxUpdateUIMode mode)"""
+ """UpdateUIEvent_SetMode(int mode)"""
return _core.UpdateUIEvent_SetMode(*args, **kwargs)
def UpdateUIEvent_GetMode(*args, **kwargs):
- """UpdateUIEvent_GetMode() -> wxUpdateUIMode"""
+ """UpdateUIEvent_GetMode() -> int"""
return _core.UpdateUIEvent_GetMode(*args, **kwargs)
#---------------------------------------------------------------------------
class SysColourChangedEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSysColourChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class MouseCaptureChangedEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMouseCaptureChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class DisplayChangedEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxDisplayChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class PaletteChangedEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPaletteChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class QueryNewPaletteEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxQueryNewPaletteEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class NavigationKeyEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNavigationKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class WindowCreateEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindowCreateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.WindowCreateEvent_swigregister(WindowCreateEventPtr)
class WindowDestroyEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindowDestroyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class ContextMenuEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxContextMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
IDLE_PROCESS_ALL = _core.IDLE_PROCESS_ALL
IDLE_PROCESS_SPECIFIED = _core.IDLE_PROCESS_SPECIFIED
class IdleEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxIdleEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.IdleEvent_MoreRequested(*args, **kwargs)
def SetMode(*args, **kwargs):
- """IdleEvent.SetMode(wxIdleMode mode)"""
+ """SetMode(int mode)"""
return _core.IdleEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """IdleEvent.GetMode() -> wxIdleMode"""
+ """GetMode() -> int"""
return _core.IdleEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
def CanSend(*args, **kwargs):
- """IdleEvent.CanSend(Window win) -> bool"""
+ """CanSend(Window win) -> bool"""
return _core.IdleEvent_CanSend(*args, **kwargs)
CanSend = staticmethod(CanSend)
_core.IdleEvent_swigregister(IdleEventPtr)
def IdleEvent_SetMode(*args, **kwargs):
- """IdleEvent_SetMode(wxIdleMode mode)"""
+ """IdleEvent_SetMode(int mode)"""
return _core.IdleEvent_SetMode(*args, **kwargs)
def IdleEvent_GetMode(*args, **kwargs):
- """IdleEvent_GetMode() -> wxIdleMode"""
+ """IdleEvent_GetMode() -> int"""
return _core.IdleEvent_GetMode(*args, **kwargs)
def IdleEvent_CanSend(*args, **kwargs):
#---------------------------------------------------------------------------
class PyEvent(Event):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.PyEvent_swigregister(PyEventPtr)
class PyCommandEvent(CommandEvent):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
PRINT_WINDOWS = _core.PRINT_WINDOWS
PRINT_POSTSCRIPT = _core.PRINT_POSTSCRIPT
class PyApp(EvtHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyApp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__() -> PyApp"""
+ """
+ __init__() -> PyApp
+
+ Create a new application object, starting the bootstrap process.
+ """
newobj = _core.new_PyApp(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _core.PyApp__setCallbackInfo(*args, **kwargs)
def GetAppName(*args, **kwargs):
- """GetAppName() -> wxString"""
+ """
+ GetAppName() -> String
+
+ Get the application name.
+ """
return _core.PyApp_GetAppName(*args, **kwargs)
def SetAppName(*args, **kwargs):
- """SetAppName(wxString name)"""
+ """
+ SetAppName(String name)
+
+ Set the application name. This value may be used automatically
+ by wx.Config and such.
+ """
return _core.PyApp_SetAppName(*args, **kwargs)
def GetClassName(*args, **kwargs):
- """GetClassName() -> wxString
+ """
+ GetClassName() -> String
-Returns the class name of the C++ object using wxRTTI."""
+ Get the application's class name.
+ """
return _core.PyApp_GetClassName(*args, **kwargs)
def SetClassName(*args, **kwargs):
- """SetClassName(wxString name)"""
+ """
+ SetClassName(String name)
+
+ Set the application's class name. This value may be used for X-resources if
+ applicable for the platform
+ """
return _core.PyApp_SetClassName(*args, **kwargs)
def GetVendorName(*args, **kwargs):
- """GetVendorName() -> wxString"""
+ """
+ GetVendorName() -> String
+
+ Get the application's vendor name.
+ """
return _core.PyApp_GetVendorName(*args, **kwargs)
def SetVendorName(*args, **kwargs):
- """SetVendorName(wxString name)"""
+ """
+ SetVendorName(String name)
+
+ Set the application's vendor name. This value may be used automatically
+ by wx.Config and such.
+ """
return _core.PyApp_SetVendorName(*args, **kwargs)
def GetTraits(*args, **kwargs):
- """GetTraits() -> wxAppTraits"""
+ """
+ GetTraits() -> wxAppTraits
+
+ Create the app traits object to which we delegate for everything which either
+ should be configurable by the user (then he can change the default behaviour
+ simply by overriding CreateTraits() and returning his own traits object) or
+ which is GUI/console dependent as then wx.AppTraits allows us to abstract the
+ differences behind the common facade
+ """
return _core.PyApp_GetTraits(*args, **kwargs)
def ProcessPendingEvents(*args, **kwargs):
- """ProcessPendingEvents()"""
+ """
+ ProcessPendingEvents()
+
+ Process all events in the Pending Events list -- it is necessary to call this
+ function to process posted events. This happens during each event loop
+ iteration.
+ """
return _core.PyApp_ProcessPendingEvents(*args, **kwargs)
def Yield(*args, **kwargs):
- """Yield(bool onlyIfNeeded=False) -> bool"""
+ """
+ Yield(bool onlyIfNeeded=False) -> bool
+
+ Process all currently pending events right now, instead of waiting until
+ return to the event loop. It is an error to call Yield() recursively unless
+ the value of onlyIfNeeded is True.
+
+ WARNING: This function is dangerous as it can lead to unexpected
+ reentrancies (i.e. when called from an event handler it
+ may result in calling the same event handler again), use
+ with _extreme_ care or, better, don't use at all!
+
+ """
return _core.PyApp_Yield(*args, **kwargs)
def WakeUpIdle(*args, **kwargs):
- """WakeUpIdle()"""
+ """
+ WakeUpIdle()
+
+ Make sure that idle events are sent again
+ """
return _core.PyApp_WakeUpIdle(*args, **kwargs)
def MainLoop(*args, **kwargs):
- """MainLoop() -> int"""
+ """
+ MainLoop() -> int
+
+ Execute the main GUI loop, the function returns when the loop ends.
+ """
return _core.PyApp_MainLoop(*args, **kwargs)
def Exit(*args, **kwargs):
- """Exit()"""
+ """
+ Exit()
+
+ Exit the main loop thus terminating the application.
+ """
return _core.PyApp_Exit(*args, **kwargs)
def ExitMainLoop(*args, **kwargs):
- """ExitMainLoop()"""
+ """
+ ExitMainLoop()
+
+ Exit the main GUI loop during the next iteration (i.e. it does not
+ stop the program immediately!)
+ """
return _core.PyApp_ExitMainLoop(*args, **kwargs)
def Pending(*args, **kwargs):
- """Pending() -> bool"""
+ """
+ Pending() -> bool
+
+ Returns True if there are unprocessed events in the event queue.
+ """
return _core.PyApp_Pending(*args, **kwargs)
def Dispatch(*args, **kwargs):
- """Dispatch() -> bool"""
+ """
+ Dispatch() -> bool
+
+ Process the first event in the event queue (blocks until an event
+ appears if there are none currently)
+ """
return _core.PyApp_Dispatch(*args, **kwargs)
def ProcessIdle(*args, **kwargs):
- """ProcessIdle() -> bool"""
+ """
+ ProcessIdle() -> bool
+
+ Called from the MainLoop when the application becomes idle and sends an
+ IdleEvent to all interested parties. Returns True is more idle events are
+ needed, False if not.
+ """
return _core.PyApp_ProcessIdle(*args, **kwargs)
def SendIdleEvents(*args, **kwargs):
- """SendIdleEvents(Window win, IdleEvent event) -> bool"""
- return _core.PyApp_SendIdleEvents(*args, **kwargs)
+ """
+ SendIdleEvents(Window win, IdleEvent event) -> bool
- def OnIdle(*args, **kwargs):
- """OnIdle(IdleEvent event)"""
- return _core.PyApp_OnIdle(*args, **kwargs)
+ Send idle event to window and all subwindows. Returns True if more idle time
+ is requested.
+ """
+ return _core.PyApp_SendIdleEvents(*args, **kwargs)
def IsActive(*args, **kwargs):
- """IsActive() -> bool"""
+ """
+ IsActive() -> bool
+
+ Return True if our app has focus.
+ """
return _core.PyApp_IsActive(*args, **kwargs)
def SetTopWindow(*args, **kwargs):
- """SetTopWindow(Window win)"""
+ """
+ SetTopWindow(Window win)
+
+ Set the "main" top level window
+ """
return _core.PyApp_SetTopWindow(*args, **kwargs)
def GetTopWindow(*args, **kwargs):
- """GetTopWindow() -> Window"""
+ """
+ GetTopWindow() -> Window
+
+ Return the "main" top level window (if it hadn't been set previously with
+ SetTopWindow(), will return just some top level window and, if there not any,
+ will return None)
+ """
return _core.PyApp_GetTopWindow(*args, **kwargs)
def SetExitOnFrameDelete(*args, **kwargs):
- """SetExitOnFrameDelete(bool flag)"""
+ """
+ SetExitOnFrameDelete(bool flag)
+
+ Control the exit behaviour: by default, the program will exit the main loop
+ (and so, usually, terminate) when the last top-level program window is
+ deleted. Beware that if you disable this behaviour (with
+ SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop() explicitly
+ from somewhere.
+
+ """
return _core.PyApp_SetExitOnFrameDelete(*args, **kwargs)
def GetExitOnFrameDelete(*args, **kwargs):
- """GetExitOnFrameDelete() -> bool"""
+ """
+ GetExitOnFrameDelete() -> bool
+
+ Get the current exit behaviour setting.
+ """
return _core.PyApp_GetExitOnFrameDelete(*args, **kwargs)
def SetUseBestVisual(*args, **kwargs):
- """SetUseBestVisual(bool flag)"""
+ """
+ SetUseBestVisual(bool flag)
+
+ Set whether the app should try to use the best available visual on systems
+ where more than one is available, (Sun, SGI, XFree86 4, etc.)
+ """
return _core.PyApp_SetUseBestVisual(*args, **kwargs)
def GetUseBestVisual(*args, **kwargs):
- """GetUseBestVisual() -> bool"""
+ """
+ GetUseBestVisual() -> bool
+
+ Get current UseBestVisual setting.
+ """
return _core.PyApp_GetUseBestVisual(*args, **kwargs)
def SetPrintMode(*args, **kwargs):
"""GetPrintMode() -> int"""
return _core.PyApp_GetPrintMode(*args, **kwargs)
- def GetAssertMode(*args, **kwargs):
- """GetAssertMode() -> int"""
- return _core.PyApp_GetAssertMode(*args, **kwargs)
-
def SetAssertMode(*args, **kwargs):
- """SetAssertMode(int mode)"""
+ """
+ SetAssertMode(int mode)
+
+ Set the OnAssert behaviour for debug and hybrid builds. The following flags
+ may be or'd together:
+
+ wx.PYAPP_ASSERT_SUPPRESS Don't do anything
+ wx.PYAPP_ASSERT_EXCEPTION Turn it into a Python exception if possible (default)
+ wx.PYAPP_ASSERT_DIALOG Display a message dialog
+ wx.PYAPP_ASSERT_LOG Write the assertion info to the wx.Log
+
+ """
return _core.PyApp_SetAssertMode(*args, **kwargs)
+ def GetAssertMode(*args, **kwargs):
+ """
+ GetAssertMode() -> int
+
+ Get the current OnAssert behaviour setting.
+ """
+ return _core.PyApp_GetAssertMode(*args, **kwargs)
+
def GetMacSupportPCMenuShortcuts(*args, **kwargs):
- """PyApp.GetMacSupportPCMenuShortcuts() -> bool"""
+ """GetMacSupportPCMenuShortcuts() -> bool"""
return _core.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
GetMacSupportPCMenuShortcuts = staticmethod(GetMacSupportPCMenuShortcuts)
def GetMacAboutMenuItemId(*args, **kwargs):
- """PyApp.GetMacAboutMenuItemId() -> long"""
+ """GetMacAboutMenuItemId() -> long"""
return _core.PyApp_GetMacAboutMenuItemId(*args, **kwargs)
GetMacAboutMenuItemId = staticmethod(GetMacAboutMenuItemId)
def GetMacPreferencesMenuItemId(*args, **kwargs):
- """PyApp.GetMacPreferencesMenuItemId() -> long"""
+ """GetMacPreferencesMenuItemId() -> long"""
return _core.PyApp_GetMacPreferencesMenuItemId(*args, **kwargs)
GetMacPreferencesMenuItemId = staticmethod(GetMacPreferencesMenuItemId)
def GetMacExitMenuItemId(*args, **kwargs):
- """PyApp.GetMacExitMenuItemId() -> long"""
+ """GetMacExitMenuItemId() -> long"""
return _core.PyApp_GetMacExitMenuItemId(*args, **kwargs)
GetMacExitMenuItemId = staticmethod(GetMacExitMenuItemId)
def GetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp.GetMacHelpMenuTitleName() -> wxString"""
+ """GetMacHelpMenuTitleName() -> String"""
return _core.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
GetMacHelpMenuTitleName = staticmethod(GetMacHelpMenuTitleName)
def SetMacSupportPCMenuShortcuts(*args, **kwargs):
- """PyApp.SetMacSupportPCMenuShortcuts(bool val)"""
+ """SetMacSupportPCMenuShortcuts(bool val)"""
return _core.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)
SetMacSupportPCMenuShortcuts = staticmethod(SetMacSupportPCMenuShortcuts)
def SetMacAboutMenuItemId(*args, **kwargs):
- """PyApp.SetMacAboutMenuItemId(long val)"""
+ """SetMacAboutMenuItemId(long val)"""
return _core.PyApp_SetMacAboutMenuItemId(*args, **kwargs)
SetMacAboutMenuItemId = staticmethod(SetMacAboutMenuItemId)
def SetMacPreferencesMenuItemId(*args, **kwargs):
- """PyApp.SetMacPreferencesMenuItemId(long val)"""
+ """SetMacPreferencesMenuItemId(long val)"""
return _core.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)
SetMacPreferencesMenuItemId = staticmethod(SetMacPreferencesMenuItemId)
def SetMacExitMenuItemId(*args, **kwargs):
- """PyApp.SetMacExitMenuItemId(long val)"""
+ """SetMacExitMenuItemId(long val)"""
return _core.PyApp_SetMacExitMenuItemId(*args, **kwargs)
SetMacExitMenuItemId = staticmethod(SetMacExitMenuItemId)
def SetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp.SetMacHelpMenuTitleName(wxString val)"""
+ """SetMacHelpMenuTitleName(String val)"""
return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
def _BootstrapApp(*args, **kwargs):
- """_BootstrapApp()"""
+ """
+ _BootstrapApp()
+
+ For internal use only
+ """
return _core.PyApp__BootstrapApp(*args, **kwargs)
def GetComCtl32Version(*args, **kwargs):
- """PyApp.GetComCtl32Version() -> int"""
+ """
+ GetComCtl32Version() -> int
+
+ Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+ wasn't found at all. Raises an exception on non-Windows platforms.
+ """
return _core.PyApp_GetComCtl32Version(*args, **kwargs)
GetComCtl32Version = staticmethod(GetComCtl32Version)
return _core.PyApp_GetMacExitMenuItemId(*args, **kwargs)
def PyApp_GetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_GetMacHelpMenuTitleName() -> wxString"""
+ """PyApp_GetMacHelpMenuTitleName() -> String"""
return _core.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs):
return _core.PyApp_SetMacExitMenuItemId(*args, **kwargs)
def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_SetMacHelpMenuTitleName(wxString val)"""
+ """PyApp_SetMacHelpMenuTitleName(String val)"""
return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_GetComCtl32Version(*args, **kwargs):
- """PyApp_GetComCtl32Version() -> int"""
+ """
+ PyApp_GetComCtl32Version() -> int
+
+ Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+ wasn't found at all. Raises an exception on non-Windows platforms.
+ """
return _core.PyApp_GetComCtl32Version(*args, **kwargs)
#---------------------------------------------------------------------------
def Exit(*args, **kwargs):
- """Exit()"""
+ """
+ Exit()
+
+ Force an exit of the application. Convenience for wx.GetApp().Exit()
+ """
return _core.Exit(*args, **kwargs)
def Yield(*args, **kwargs):
- """Yield() -> bool"""
+ """
+ Yield() -> bool
+
+ Yield to other apps/messages. Convenience for wx.GetApp().Yield()
+ """
return _core.Yield(*args, **kwargs)
def YieldIfNeeded(*args, **kwargs):
- """YieldIfNeeded() -> bool"""
+ """
+ YieldIfNeeded() -> bool
+
+ Yield to other apps/messages. Convenience for wx.GetApp().Yield(True)
+ """
return _core.YieldIfNeeded(*args, **kwargs)
def SafeYield(*args, **kwargs):
- """SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool"""
+ """
+ SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool
+
+ This function is similar to wx.Yield, except that it disables the user input
+ to all program windows before calling wx.Yield and re-enables it again
+ afterwards. If win is not None, this window will remain enabled, allowing the
+ implementation of some limited user interaction.
+
+ Returns the result of the call to wx.Yield.
+ """
return _core.SafeYield(*args, **kwargs)
def WakeUpIdle(*args, **kwargs):
- """WakeUpIdle()"""
+ """
+ WakeUpIdle()
+
+ Cause the message queue to become empty again, so idle events will be sent.
+ """
return _core.WakeUpIdle(*args, **kwargs)
def PostEvent(*args, **kwargs):
- """PostEvent(EvtHandler dest, Event event)"""
+ """
+ PostEvent(EvtHandler dest, Event event)
+
+ Send an event to a window or other wx.EvtHandler to be processed later.
+ """
return _core.PostEvent(*args, **kwargs)
def App_CleanUp(*args, **kwargs):
- """App_CleanUp()"""
+ """
+ App_CleanUp()
+
+ For internal use only, it is used to cleanup after wxWindows when Python shuts down.
+ """
return _core.App_CleanUp(*args, **kwargs)
def GetApp(*args, **kwargs):
- """GetApp() -> PyApp"""
+ """
+ GetApp() -> PyApp
+
+ Return a reference to the current wx.App object.
+ """
return _core.GetApp(*args, **kwargs)
#----------------------------------------------------------------------
class PyOnDemandOutputWindow:
+ """
+ A class that can be used for redirecting Python's stdout and
+ stderr streams. It will do nothing until something is wrriten to
+ the stream at which point it will create a Frame with a text area
+ and write the text there.
+ """
def __init__(self, title = "wxPython: stdout/stderr"):
self.frame = None
self.title = title
self.parent = None
def SetParent(self, parent):
+ """Set the window to be used as the popup Frame's parent."""
self.parent = parent
- def OnCloseWindow(self, event):
- if self.frame != None:
- self.frame.Destroy()
- self.frame = None
- self.text = None
+
+ def CreateOutputWindow(self, st):
+ self.frame = wx.Frame(self.parent, -1, self.title,
+ style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.text = wx.TextCtrl(self.frame, -1, "",
+ style = wx.TE_MULTILINE | wx.TE_READONLY)
+ self.text.AppendText(st)
+ self.frame.SetSize((450, 300))
+ self.frame.Show(True)
+ EVT_CLOSE(self.frame, self.OnCloseWindow)
+
# These methods provide the file-like output behaviour.
- def write(self, str):
- if not wx.Thread_IsMain():
- # Aquire the GUI mutex before making GUI calls. Mutex is released
- # when locker is deleted at the end of this function.
- locker = wx.MutexGuiLocker()
-
- if not self.frame:
- self.frame = wx.Frame(self.parent, -1, self.title,
- style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
- self.text = wxTextCtrl(self.frame, -1, "",
- style = wx.TE_MULTILINE | wx.TE_READONLY)
- self.frame.SetSize((450, 300))
- self.frame.Show(True)
- EVT_CLOSE(self.frame, self.OnCloseWindow)
- self.text.AppendText(str)
+ def write(self, text):
+ """
+ Create the output window if needed and write the string to it.
+ If not called in the context of the gui thread then uses
+ CallAfter to do the work there.
+ """
+ if self.frame is None:
+ if not wx.Thread_IsMain():
+ wx.CallAfter(self.CreateOutputWindow, text)
+ else:
+ self.CreateOutputWindow(text)
+ else:
+ if not wx.Thread_IsMain():
+ wx.CallAfter(self.text.AppendText, text)
+ else:
+ self.text.AppendText(text)
+
def close(self):
- if self.frame != None:
- if not wx.Thread_IsMain():
- locker = wx.MutexGuiLocker()
- self.frame.Close()
+ if self.frame is not None:
+ wx.CallAfter(self.frame.Close)
+ def OnCloseWindow(self, event):
+ if self.frame is not None:
+ self.frame.Destroy()
+ self.frame = None
+ self.text = None
+
#----------------------------------------------------------------------
-# The main application class. Derive from this and implement an OnInit
-# method that creates a frame and then calls self.SetTopWindow(frame)
_defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
class App(wx.PyApp):
+ """
+ The main application class. Derive from this and implement an OnInit
+ method that creates a frame and then calls self.SetTopWindow(frame)
+ """
outputWindowClass = PyOnDemandOutputWindow
def __init__(self, redirect=_defRedirect, filename=None, useBestVisual=False):
def SetTopWindow(self, frame):
+ """Set the \"main\" top level window"""
if self.stdioWin:
self.stdioWin.SetParent(frame)
wx.PyApp.SetTopWindow(self, frame)
def MainLoop(self):
+ """Execute the main GUI event loop"""
wx.PyApp.MainLoop(self)
self.RestoreStdio()
def RedirectStdio(self, filename):
+ """Redirect sys.stdout and sys.stderr to a file or a popup window."""
if filename:
_sys.stdout = _sys.stderr = open(filename, 'a')
else:
#----------------------------------------------------------------------------
class PySimpleApp(wx.App):
- def __init__(self, redirect=False, filename=None):
- wx.App.__init__(self, redirect, filename)
+ """
+ A simple application class. You can just create one of these and
+ then then make your top level windows later, and not have to worry
+ about OnInit."""
+
+ def __init__(self, redirect=False, filename=None, useBestVisual=False):
+ wx.App.__init__(self, redirect, filename, useBestVisual)
+
def OnInit(self):
wx.InitAllImageHandlers()
return True
+# Is anybody using this one?
class PyWidgetTester(wx.App):
def __init__(self, size = (250, 100)):
self.size = size
wx.App.__init__(self, 0)
def OnInit(self):
- self.frame = wxFrame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
+ self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
self.SetTopWindow(self.frame)
return True
#---------------------------------------------------------------------------
+class AcceleratorEntry(object):
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxAcceleratorEntry instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """__init__(int flags=0, int keyCode=0, int cmd=0, MenuItem item=None) -> AcceleratorEntry"""
+ newobj = _core.new_AcceleratorEntry(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_core.delete_AcceleratorEntry):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def Set(*args, **kwargs):
+ """Set(int flags, int keyCode, int cmd, MenuItem item=None)"""
+ return _core.AcceleratorEntry_Set(*args, **kwargs)
+
+ def SetMenuItem(*args, **kwargs):
+ """SetMenuItem(MenuItem item)"""
+ return _core.AcceleratorEntry_SetMenuItem(*args, **kwargs)
+
+ def GetMenuItem(*args, **kwargs):
+ """GetMenuItem() -> MenuItem"""
+ return _core.AcceleratorEntry_GetMenuItem(*args, **kwargs)
+
+ def GetFlags(*args, **kwargs):
+ """GetFlags() -> int"""
+ return _core.AcceleratorEntry_GetFlags(*args, **kwargs)
+
+ def GetKeyCode(*args, **kwargs):
+ """GetKeyCode() -> int"""
+ return _core.AcceleratorEntry_GetKeyCode(*args, **kwargs)
+
+ def GetCommand(*args, **kwargs):
+ """GetCommand() -> int"""
+ return _core.AcceleratorEntry_GetCommand(*args, **kwargs)
+
+
+class AcceleratorEntryPtr(AcceleratorEntry):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = AcceleratorEntry
+_core.AcceleratorEntry_swigregister(AcceleratorEntryPtr)
+
+class AcceleratorTable(Object):
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxAcceleratorTable instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(entries) -> AcceleratorTable
+
+ Construct an AcceleratorTable from a list of AcceleratorEntry items or
+ 3-tuples (flags, keyCode, cmdID)
+ """
+ newobj = _core.new_AcceleratorTable(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_core.delete_AcceleratorTable):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def Ok(*args, **kwargs):
+ """Ok() -> bool"""
+ return _core.AcceleratorTable_Ok(*args, **kwargs)
+
+
+class AcceleratorTablePtr(AcceleratorTable):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = AcceleratorTable
+_core.AcceleratorTable_swigregister(AcceleratorTablePtr)
+
+
+def GetAccelFromString(*args, **kwargs):
+ """GetAccelFromString(String label) -> AcceleratorEntry"""
+ return _core.GetAccelFromString(*args, **kwargs)
+#---------------------------------------------------------------------------
+
class Window(EvtHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> Window"""
+ """
+ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, String name=PanelNameStr) -> Window
+ """
newobj = _core.new_Window(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def Create(*args, **kwargs):
- """Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> bool"""
+ """
+ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, String name=PanelNameStr) -> bool
+ """
return _core.Window_Create(*args, **kwargs)
def Close(*args, **kwargs):
return _core.Window_Close(*args, **kwargs)
def Destroy(*args, **kwargs):
- """Destroy() -> bool
+ """
+ Destroy() -> bool
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Window_Destroy(*args, **kwargs)
def DestroyChildren(*args, **kwargs):
return _core.Window_IsBeingDeleted(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _core.Window_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _core.Window_GetTitle(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _core.Window_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.Window_GetLabel(*args, **kwargs)
def SetName(*args, **kwargs):
- """SetName(wxString name)"""
+ """SetName(String name)"""
return _core.Window_SetName(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _core.Window_GetName(*args, **kwargs)
def SetId(*args, **kwargs):
return _core.Window_GetId(*args, **kwargs)
def NewControlId(*args, **kwargs):
- """Window.NewControlId() -> int"""
+ """NewControlId() -> int"""
return _core.Window_NewControlId(*args, **kwargs)
NewControlId = staticmethod(NewControlId)
def NextControlId(*args, **kwargs):
- """Window.NextControlId(int winid) -> int"""
+ """NextControlId(int winid) -> int"""
return _core.Window_NextControlId(*args, **kwargs)
NextControlId = staticmethod(NextControlId)
def PrevControlId(*args, **kwargs):
- """Window.PrevControlId(int winid) -> int"""
+ """PrevControlId(int winid) -> int"""
return _core.Window_PrevControlId(*args, **kwargs)
PrevControlId = staticmethod(PrevControlId)
return _core.Window_SetClientRect(*args, **kwargs)
def GetPosition(*args, **kwargs):
- """GetPosition() -> Point
+ """
+ GetPosition() -> Point
-Get the window's position."""
+ Get the window's position.
+ """
return _core.Window_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
- """GetPositionTuple() -> (x,y)
+ """
+ GetPositionTuple() -> (x,y)
-Get the window's position."""
+ Get the window's position.
+ """
return _core.Window_GetPositionTuple(*args, **kwargs)
def GetSize(*args, **kwargs):
- """GetSize() -> Size
+ """
+ GetSize() -> Size
-Get the window size."""
+ Get the window size.
+ """
return _core.Window_GetSize(*args, **kwargs)
def GetSizeTuple(*args, **kwargs):
- """GetSizeTuple() -> (width, height)
+ """
+ GetSizeTuple() -> (width, height)
-Get the window size."""
+ Get the window size.
+ """
return _core.Window_GetSizeTuple(*args, **kwargs)
def GetRect(*args, **kwargs):
return _core.Window_GetRect(*args, **kwargs)
def GetClientSize(*args, **kwargs):
- """GetClientSize() -> Size
+ """
+ GetClientSize() -> Size
-Get the window's client size."""
+ Get the window's client size.
+ """
return _core.Window_GetClientSize(*args, **kwargs)
def GetClientSizeTuple(*args, **kwargs):
- """GetClientSizeTuple() -> (width, height)
+ """
+ GetClientSizeTuple() -> (width, height)
-Get the window's client size."""
+ Get the window's client size.
+ """
return _core.Window_GetClientSizeTuple(*args, **kwargs)
def GetClientAreaOrigin(*args, **kwargs):
return _core.Window_GetClientRect(*args, **kwargs)
def GetBestSize(*args, **kwargs):
- """GetBestSize() -> Size
+ """
+ GetBestSize() -> Size
-Get the size best suited for the window (in fact, minimal acceptable size
-using which it will still look "nice")"""
+ Get the size best suited for the window (in fact, minimal acceptable size
+ using which it will still look "nice")
+ """
return _core.Window_GetBestSize(*args, **kwargs)
def GetBestSizeTuple(*args, **kwargs):
- """GetBestSizeTuple() -> (width, height)
+ """
+ GetBestSizeTuple() -> (width, height)
-Get the size best suited for the window (in fact, minimal acceptable size
-using which it will still look "nice")"""
+ Get the size best suited for the window (in fact, minimal acceptable size
+ using which it will still look "nice")
+ """
return _core.Window_GetBestSizeTuple(*args, **kwargs)
def GetAdjustedBestSize(*args, **kwargs):
return _core.Window_FitInside(*args, **kwargs)
def SetSizeHints(*args, **kwargs):
- """SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1,
- int incH=-1)"""
+ """
+ SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1,
+ int incH=-1)
+ """
return _core.Window_SetSizeHints(*args, **kwargs)
def SetVirtualSizeHints(*args, **kwargs):
return _core.Window_GetMaxSize(*args, **kwargs)
def SetVirtualSize(*args, **kwargs):
- """SetVirtualSize(Size size)
+ """
+ SetVirtualSize(Size size)
-Set the the virtual size of a window. For most windows this is just the
-client area of the window, but for some like scrolled windows it is more or
-less independent of the screen window size."""
+ Set the the virtual size of a window. For most windows this is just the
+ client area of the window, but for some like scrolled windows it is more or
+ less independent of the screen window size.
+ """
return _core.Window_SetVirtualSize(*args, **kwargs)
def SetVirtualSizeWH(*args, **kwargs):
- """SetVirtualSizeWH(int w, int h)
+ """
+ SetVirtualSizeWH(int w, int h)
-Set the the virtual size of a window. For most windows this is just the
-client area of the window, but for some like scrolled windows it is more or
-less independent of the screen window size."""
+ Set the the virtual size of a window. For most windows this is just the
+ client area of the window, but for some like scrolled windows it is more or
+ less independent of the screen window size.
+ """
return _core.Window_SetVirtualSizeWH(*args, **kwargs)
def GetVirtualSize(*args, **kwargs):
- """GetVirtualSize() -> Size
+ """
+ GetVirtualSize() -> Size
-Get the the virtual size of the window. For most windows this is just
-the client area of the window, but for some like scrolled windows it is
-more or less independent of the screen window size."""
+ Get the the virtual size of the window. For most windows this is just
+ the client area of the window, but for some like scrolled windows it is
+ more or less independent of the screen window size.
+ """
return _core.Window_GetVirtualSize(*args, **kwargs)
def GetVirtualSizeTuple(*args, **kwargs):
- """GetVirtualSizeTuple() -> (width, height)
+ """
+ GetVirtualSizeTuple() -> (width, height)
-Get the the virtual size of the window. For most windows this is just
-the client area of the window, but for some like scrolled windows it is
-more or less independent of the screen window size."""
+ Get the the virtual size of the window. For most windows this is just
+ the client area of the window, but for some like scrolled windows it is
+ more or less independent of the screen window size.
+ """
return _core.Window_GetVirtualSizeTuple(*args, **kwargs)
def GetBestVirtualSize(*args, **kwargs):
return _core.Window_SetFocusFromKbd(*args, **kwargs)
def FindFocus(*args, **kwargs):
- """Window.FindFocus() -> Window"""
+ """FindFocus() -> Window"""
return _core.Window_FindFocus(*args, **kwargs)
FindFocus = staticmethod(FindFocus)
return _core.Window_FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
- """FindWindowByName(wxString name) -> Window"""
+ """FindWindowByName(String name) -> Window"""
return _core.Window_FindWindowByName(*args, **kwargs)
def GetEventHandler(*args, **kwargs):
return _core.Window_GetValidator(*args, **kwargs)
def SetAcceleratorTable(*args, **kwargs):
- """SetAcceleratorTable(wxAcceleratorTable accel)"""
+ """SetAcceleratorTable(AcceleratorTable accel)"""
return _core.Window_SetAcceleratorTable(*args, **kwargs)
def GetAcceleratorTable(*args, **kwargs):
- """GetAcceleratorTable() -> wxAcceleratorTable"""
+ """GetAcceleratorTable() -> AcceleratorTable"""
return _core.Window_GetAcceleratorTable(*args, **kwargs)
def RegisterHotKey(*args, **kwargs):
return _core.Window_ReleaseMouse(*args, **kwargs)
def GetCapture(*args, **kwargs):
- """Window.GetCapture() -> Window"""
+ """GetCapture() -> Window"""
return _core.Window_GetCapture(*args, **kwargs)
GetCapture = staticmethod(GetCapture)
return _core.Window_Thaw(*args, **kwargs)
def PrepareDC(*args, **kwargs):
- """PrepareDC(wxDC dc)"""
+ """PrepareDC(DC dc)"""
return _core.Window_PrepareDC(*args, **kwargs)
def GetUpdateRegion(*args, **kwargs):
- """GetUpdateRegion() -> wxRegion"""
+ """GetUpdateRegion() -> Region"""
return _core.Window_GetUpdateRegion(*args, **kwargs)
def GetUpdateClientRect(*args, **kwargs):
return _core.Window_isExposedRect(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colour) -> bool"""
+ """SetBackgroundColour(Colour colour) -> bool"""
return _core.Window_SetBackgroundColour(*args, **kwargs)
def SetForegroundColour(*args, **kwargs):
- """SetForegroundColour(wxColour colour) -> bool"""
+ """SetForegroundColour(Colour colour) -> bool"""
return _core.Window_SetForegroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _core.Window_GetBackgroundColour(*args, **kwargs)
def GetForegroundColour(*args, **kwargs):
- """GetForegroundColour() -> wxColour"""
+ """GetForegroundColour() -> Colour"""
return _core.Window_GetForegroundColour(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor) -> bool"""
+ """SetCursor(Cursor cursor) -> bool"""
return _core.Window_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor() -> wxCursor"""
+ """GetCursor() -> Cursor"""
return _core.Window_GetCursor(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font) -> bool"""
+ """SetFont(Font font) -> bool"""
return _core.Window_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _core.Window_GetFont(*args, **kwargs)
def SetCaret(*args, **kwargs):
- """SetCaret(wxCaret caret)"""
+ """SetCaret(Caret caret)"""
return _core.Window_SetCaret(*args, **kwargs)
def GetCaret(*args, **kwargs):
- """GetCaret() -> wxCaret"""
+ """GetCaret() -> Caret"""
return _core.Window_GetCaret(*args, **kwargs)
def GetCharHeight(*args, **kwargs):
return _core.Window_GetCharWidth(*args, **kwargs)
def GetTextExtent(*args, **kwargs):
- """GetTextExtent(wxString string) -> (width, height)
+ """
+ GetTextExtent(String string) -> (width, height)
-Get the width and height of the text using the current font."""
+ Get the width and height of the text using the current font.
+ """
return _core.Window_GetTextExtent(*args, **kwargs)
def GetFullTextExtent(*args, **kwargs):
- """GetFullTextExtent(wxString string, Font font=None) ->
- (width, height, descent, externalLeading)
+ """
+ GetFullTextExtent(String string, Font font=None) ->
+ (width, height, descent, externalLeading)
-Get the width, height, decent and leading of the text using the current or specified font."""
+ Get the width, height, decent and leading of the text using the current or specified font.
+ """
return _core.Window_GetFullTextExtent(*args, **kwargs)
def ClientToScreenXY(*args, **kwargs):
return _core.Window_ScreenToClient(*args, **kwargs)
def HitTestXY(*args, **kwargs):
- """HitTestXY(int x, int y) -> wxHitTest"""
+ """HitTestXY(int x, int y) -> int"""
return _core.Window_HitTestXY(*args, **kwargs)
def HitTest(*args, **kwargs):
- """HitTest(Point pt) -> wxHitTest"""
+ """HitTest(Point pt) -> int"""
return _core.Window_HitTest(*args, **kwargs)
def GetBorderFlags(*args, **kwargs):
- """GetBorderFlags(long flags) -> wxBorder"""
+ """GetBorderFlags(long flags) -> int"""
return _core.Window_GetBorderFlags(*args, **kwargs)
def GetBorder(*args, **kwargs):
- """GetBorder() -> wxBorder"""
+ """GetBorder() -> int"""
return _core.Window_GetBorder(*args, **kwargs)
def UpdateWindowUI(*args, **kwargs):
return _core.Window_PageDown(*args, **kwargs)
def SetHelpText(*args, **kwargs):
- """SetHelpText(wxString text)"""
+ """SetHelpText(String text)"""
return _core.Window_SetHelpText(*args, **kwargs)
def SetHelpTextForId(*args, **kwargs):
- """SetHelpTextForId(wxString text)"""
+ """SetHelpTextForId(String text)"""
return _core.Window_SetHelpTextForId(*args, **kwargs)
def GetHelpText(*args, **kwargs):
- """GetHelpText() -> wxString"""
+ """GetHelpText() -> String"""
return _core.Window_GetHelpText(*args, **kwargs)
def SetToolTipString(*args, **kwargs):
- """SetToolTipString(wxString tip)"""
+ """SetToolTipString(String tip)"""
return _core.Window_SetToolTipString(*args, **kwargs)
def SetToolTip(*args, **kwargs):
- """SetToolTip(wxToolTip tip)"""
+ """SetToolTip(ToolTip tip)"""
return _core.Window_SetToolTip(*args, **kwargs)
def GetToolTip(*args, **kwargs):
- """GetToolTip() -> wxToolTip"""
+ """GetToolTip() -> ToolTip"""
return _core.Window_GetToolTip(*args, **kwargs)
def SetDropTarget(*args, **kwargs):
- """SetDropTarget(wxDropTarget dropTarget)"""
- val = _core.Window_SetDropTarget(*args, **kwargs)
- args[1].thisown = 0
- return val
+ """SetDropTarget(PyDropTarget dropTarget)"""
+ return _core.Window_SetDropTarget(*args, **kwargs)
def GetDropTarget(*args, **kwargs):
- """GetDropTarget() -> wxDropTarget"""
+ """GetDropTarget() -> PyDropTarget"""
return _core.Window_GetDropTarget(*args, **kwargs)
def DragAcceptFiles(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Window
_core.Window_swigregister(WindowPtr)
+NullAcceleratorTable = cvar.NullAcceleratorTable
PanelNameStr = cvar.PanelNameStr
def PreWindow(*args, **kwargs):
if y is None:
return win.ConvertDialogPointToPixels(point_or_x)
else:
- return win.ConvertDialogPointToPixels(wxPoint(point_or_x, y))
+ return win.ConvertDialogPointToPixels(wx.Point(point_or_x, y))
def DLG_SZE(win, size_width, height=None):
if height is None:
return win.ConvertDialogSizeToPixels(size_width)
else:
- return win.ConvertDialogSizeToPixels(wxSize(size_width, height))
+ return win.ConvertDialogSizeToPixels(wx.Size(size_width, height))
def FindWindowById(*args, **kwargs):
return _core.FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
- """FindWindowByName(wxString name, Window parent=None) -> Window"""
+ """FindWindowByName(String name, Window parent=None) -> Window"""
return _core.FindWindowByName(*args, **kwargs)
def FindWindowByLabel(*args, **kwargs):
- """FindWindowByLabel(wxString label, Window parent=None) -> Window"""
+ """FindWindowByLabel(String label, Window parent=None) -> Window"""
return _core.FindWindowByLabel(*args, **kwargs)
def Window_FromHWND(*args, **kwargs):
#---------------------------------------------------------------------------
class Validator(EvtHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.Validator_SetWindow(*args, **kwargs)
def IsSilent(*args, **kwargs):
- """Validator.IsSilent() -> bool"""
+ """IsSilent() -> bool"""
return _core.Validator_IsSilent(*args, **kwargs)
IsSilent = staticmethod(IsSilent)
def SetBellOnError(*args, **kwargs):
- """Validator.SetBellOnError(int doIt=True)"""
+ """SetBellOnError(int doIt=True)"""
return _core.Validator_SetBellOnError(*args, **kwargs)
SetBellOnError = staticmethod(SetBellOnError)
return _core.Validator_SetBellOnError(*args, **kwargs)
class PyValidator(Validator):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class Menu(EvtHandler):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString title=wxPyEmptyString, long style=0) -> Menu"""
+ """__init__(String title=EmptyString, long style=0) -> Menu"""
newobj = _core.new_Menu(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def Append(*args, **kwargs):
- """Append(int itemid, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)"""
+ """Append(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
return _core.Menu_Append(*args, **kwargs)
def AppendSeparator(*args, **kwargs):
- """AppendSeparator()"""
+ """AppendSeparator() -> MenuItem"""
return _core.Menu_AppendSeparator(*args, **kwargs)
def AppendCheckItem(*args, **kwargs):
- """AppendCheckItem(int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """AppendCheckItem(int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_AppendCheckItem(*args, **kwargs)
def AppendRadioItem(*args, **kwargs):
- """AppendRadioItem(int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """AppendRadioItem(int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_AppendRadioItem(*args, **kwargs)
def AppendMenu(*args, **kwargs):
- """AppendMenu(int itemid, wxString text, Menu submenu, wxString help=wxPyEmptyString)"""
+ """AppendMenu(int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core.Menu_AppendMenu(*args, **kwargs)
def AppendItem(*args, **kwargs):
- """AppendItem(MenuItem item)"""
+ """AppendItem(MenuItem item) -> MenuItem"""
return _core.Menu_AppendItem(*args, **kwargs)
def Break(*args, **kwargs):
return _core.Menu_Break(*args, **kwargs)
def InsertItem(*args, **kwargs):
- """InsertItem(size_t pos, MenuItem item) -> bool"""
+ """InsertItem(size_t pos, MenuItem item) -> MenuItem"""
return _core.Menu_InsertItem(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(size_t pos, int itemid, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)"""
+ """
+ Insert(size_t pos, int id, String text, String help=EmptyString,
+ int kind=ITEM_NORMAL) -> MenuItem
+ """
return _core.Menu_Insert(*args, **kwargs)
def InsertSeparator(*args, **kwargs):
- """InsertSeparator(size_t pos)"""
+ """InsertSeparator(size_t pos) -> MenuItem"""
return _core.Menu_InsertSeparator(*args, **kwargs)
def InsertCheckItem(*args, **kwargs):
- """InsertCheckItem(size_t pos, int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """InsertCheckItem(size_t pos, int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_InsertCheckItem(*args, **kwargs)
def InsertRadioItem(*args, **kwargs):
- """InsertRadioItem(size_t pos, int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """InsertRadioItem(size_t pos, int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_InsertRadioItem(*args, **kwargs)
def InsertMenu(*args, **kwargs):
- """InsertMenu(size_t pos, int itemid, wxString text, Menu submenu,
- wxString help=wxPyEmptyString)"""
+ """InsertMenu(size_t pos, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core.Menu_InsertMenu(*args, **kwargs)
def PrependItem(*args, **kwargs):
- """PrependItem(MenuItem item)"""
+ """PrependItem(MenuItem item) -> MenuItem"""
return _core.Menu_PrependItem(*args, **kwargs)
def Prepend(*args, **kwargs):
- """Prepend(int itemid, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)"""
+ """Prepend(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
return _core.Menu_Prepend(*args, **kwargs)
def PrependSeparator(*args, **kwargs):
- """PrependSeparator()"""
+ """PrependSeparator() -> MenuItem"""
return _core.Menu_PrependSeparator(*args, **kwargs)
def PrependCheckItem(*args, **kwargs):
- """PrependCheckItem(int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """PrependCheckItem(int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_PrependCheckItem(*args, **kwargs)
def PrependRadioItem(*args, **kwargs):
- """PrependRadioItem(int itemid, wxString text, wxString help=wxPyEmptyString)"""
+ """PrependRadioItem(int id, String text, String help=EmptyString) -> MenuItem"""
return _core.Menu_PrependRadioItem(*args, **kwargs)
def PrependMenu(*args, **kwargs):
- """PrependMenu(int itemid, wxString text, Menu submenu, wxString help=wxPyEmptyString)"""
+ """PrependMenu(int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core.Menu_PrependMenu(*args, **kwargs)
def Remove(*args, **kwargs):
- """Remove(int itemid) -> MenuItem"""
+ """Remove(int id) -> MenuItem"""
return _core.Menu_Remove(*args, **kwargs)
def RemoveItem(*args, **kwargs):
return _core.Menu_RemoveItem(*args, **kwargs)
def Delete(*args, **kwargs):
- """Delete(int itemid) -> bool"""
+ """Delete(int id) -> bool"""
return _core.Menu_Delete(*args, **kwargs)
def DeleteItem(*args, **kwargs):
return _core.Menu_DeleteItem(*args, **kwargs)
def Destroy(*args, **kwargs):
- """Destroy()
+ """
+ Destroy()
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Menu_Destroy(*args, **kwargs)
def DestroyId(*args, **kwargs):
- """DestroyId(int itemid) -> bool
+ """
+ DestroyId(int id) -> bool
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Menu_DestroyId(*args, **kwargs)
def DestroyItem(*args, **kwargs):
- """DestroyItem(MenuItem item) -> bool
+ """
+ DestroyItem(MenuItem item) -> bool
-Deletes the C++ object this Python object is a proxy for."""
+ Deletes the C++ object this Python object is a proxy for.
+ """
return _core.Menu_DestroyItem(*args, **kwargs)
def GetMenuItemCount(*args, **kwargs):
return _core.Menu_GetMenuItems(*args, **kwargs)
def FindItem(*args, **kwargs):
- """FindItem(wxString item) -> int"""
+ """FindItem(String item) -> int"""
return _core.Menu_FindItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
- """FindItemById(int itemid) -> MenuItem"""
+ """FindItemById(int id) -> MenuItem"""
return _core.Menu_FindItemById(*args, **kwargs)
def FindItemByPosition(*args, **kwargs):
return _core.Menu_FindItemByPosition(*args, **kwargs)
def Enable(*args, **kwargs):
- """Enable(int itemid, bool enable)"""
+ """Enable(int id, bool enable)"""
return _core.Menu_Enable(*args, **kwargs)
def IsEnabled(*args, **kwargs):
- """IsEnabled(int itemid) -> bool"""
+ """IsEnabled(int id) -> bool"""
return _core.Menu_IsEnabled(*args, **kwargs)
def Check(*args, **kwargs):
- """Check(int itemid, bool check)"""
+ """Check(int id, bool check)"""
return _core.Menu_Check(*args, **kwargs)
def IsChecked(*args, **kwargs):
- """IsChecked(int itemid) -> bool"""
+ """IsChecked(int id) -> bool"""
return _core.Menu_IsChecked(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(int itemid, wxString label)"""
+ """SetLabel(int id, String label)"""
return _core.Menu_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel(int itemid) -> wxString"""
+ """GetLabel(int id) -> String"""
return _core.Menu_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
- """SetHelpString(int itemid, wxString helpString)"""
+ """SetHelpString(int id, String helpString)"""
return _core.Menu_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
- """GetHelpString(int itemid) -> wxString"""
+ """GetHelpString(int id) -> String"""
return _core.Menu_GetHelpString(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _core.Menu_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _core.Menu_GetTitle(*args, **kwargs)
def SetEventHandler(*args, **kwargs):
#---------------------------------------------------------------------------
class MenuBar(Window):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuBar instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self._setOORInfo(self)
def Append(*args, **kwargs):
- """Append(Menu menu, wxString title) -> bool"""
+ """Append(Menu menu, String title) -> bool"""
return _core.MenuBar_Append(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(size_t pos, Menu menu, wxString title) -> bool"""
+ """Insert(size_t pos, Menu menu, String title) -> bool"""
return _core.MenuBar_Insert(*args, **kwargs)
def GetMenuCount(*args, **kwargs):
return _core.MenuBar_GetMenu(*args, **kwargs)
def Replace(*args, **kwargs):
- """Replace(size_t pos, Menu menu, wxString title) -> Menu"""
+ """Replace(size_t pos, Menu menu, String title) -> Menu"""
return _core.MenuBar_Replace(*args, **kwargs)
def Remove(*args, **kwargs):
return _core.MenuBar_IsEnabledTop(*args, **kwargs)
def SetLabelTop(*args, **kwargs):
- """SetLabelTop(size_t pos, wxString label)"""
+ """SetLabelTop(size_t pos, String label)"""
return _core.MenuBar_SetLabelTop(*args, **kwargs)
def GetLabelTop(*args, **kwargs):
- """GetLabelTop(size_t pos) -> wxString"""
+ """GetLabelTop(size_t pos) -> String"""
return _core.MenuBar_GetLabelTop(*args, **kwargs)
def FindMenuItem(*args, **kwargs):
- """FindMenuItem(wxString menu, wxString item) -> int"""
+ """FindMenuItem(String menu, String item) -> int"""
return _core.MenuBar_FindMenuItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
- """FindItemById(int itemid) -> MenuItem"""
+ """FindItemById(int id) -> MenuItem"""
return _core.MenuBar_FindItemById(*args, **kwargs)
def FindMenu(*args, **kwargs):
- """FindMenu(wxString title) -> int"""
+ """FindMenu(String title) -> int"""
return _core.MenuBar_FindMenu(*args, **kwargs)
def Enable(*args, **kwargs):
- """Enable(int itemid, bool enable)"""
+ """Enable(int id, bool enable)"""
return _core.MenuBar_Enable(*args, **kwargs)
def Check(*args, **kwargs):
- """Check(int itemid, bool check)"""
+ """Check(int id, bool check)"""
return _core.MenuBar_Check(*args, **kwargs)
def IsChecked(*args, **kwargs):
- """IsChecked(int itemid) -> bool"""
+ """IsChecked(int id) -> bool"""
return _core.MenuBar_IsChecked(*args, **kwargs)
def IsEnabled(*args, **kwargs):
- """IsEnabled(int itemid) -> bool"""
+ """IsEnabled(int id) -> bool"""
return _core.MenuBar_IsEnabled(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(int itemid, wxString label)"""
+ """SetLabel(int id, String label)"""
return _core.MenuBar_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel(int itemid) -> wxString"""
+ """GetLabel(int id) -> String"""
return _core.MenuBar_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
- """SetHelpString(int itemid, wxString helpString)"""
+ """SetHelpString(int id, String helpString)"""
return _core.MenuBar_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
- """GetHelpString(int itemid) -> wxString"""
+ """GetHelpString(int id) -> String"""
return _core.MenuBar_GetHelpString(*args, **kwargs)
def GetFrame(*args, **kwargs):
#---------------------------------------------------------------------------
class MenuItem(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Menu parentMenu=None, int id=ID_SEPARATOR, wxString text=wxPyEmptyString,
- wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL, Menu subMenu=None) -> MenuItem"""
+ """
+ __init__(Menu parentMenu=None, int id=ID_SEPARATOR, String text=EmptyString,
+ String help=EmptyString, int kind=ITEM_NORMAL,
+ Menu subMenu=None) -> MenuItem
+ """
newobj = _core.new_MenuItem(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _core.MenuItem_SetMenu(*args, **kwargs)
def SetId(*args, **kwargs):
- """SetId(int itemid)"""
+ """SetId(int id)"""
return _core.MenuItem_SetId(*args, **kwargs)
def GetId(*args, **kwargs):
return _core.MenuItem_IsSeparator(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString str)"""
+ """SetText(String str)"""
return _core.MenuItem_SetText(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.MenuItem_GetLabel(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _core.MenuItem_GetText(*args, **kwargs)
def GetLabelFromText(*args, **kwargs):
- """MenuItem.GetLabelFromText(wxString text) -> wxString"""
+ """GetLabelFromText(String text) -> String"""
return _core.MenuItem_GetLabelFromText(*args, **kwargs)
GetLabelFromText = staticmethod(GetLabelFromText)
def GetKind(*args, **kwargs):
- """GetKind() -> wxItemKind"""
+ """GetKind() -> int"""
return _core.MenuItem_GetKind(*args, **kwargs)
def SetCheckable(*args, **kwargs):
return _core.MenuItem_Toggle(*args, **kwargs)
def SetHelp(*args, **kwargs):
- """SetHelp(wxString str)"""
+ """SetHelp(String str)"""
return _core.MenuItem_SetHelp(*args, **kwargs)
def GetHelp(*args, **kwargs):
- """GetHelp() -> wxString"""
+ """GetHelp() -> String"""
return _core.MenuItem_GetHelp(*args, **kwargs)
def GetAccel(*args, **kwargs):
- """GetAccel() -> wxAcceleratorEntry"""
+ """GetAccel() -> AcceleratorEntry"""
return _core.MenuItem_GetAccel(*args, **kwargs)
def SetAccel(*args, **kwargs):
- """SetAccel(wxAcceleratorEntry accel)"""
+ """SetAccel(AcceleratorEntry accel)"""
return _core.MenuItem_SetAccel(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _core.MenuItem_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _core.MenuItem_GetFont(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _core.MenuItem_SetTextColour(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _core.MenuItem_GetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _core.MenuItem_SetBackgroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _core.MenuItem_GetBackgroundColour(*args, **kwargs)
def SetBitmaps(*args, **kwargs):
- """SetBitmaps(wxBitmap bmpChecked, wxBitmap bmpUnchecked=wxNullBitmap)"""
+ """SetBitmaps(Bitmap bmpChecked, Bitmap bmpUnchecked=wxNullBitmap)"""
return _core.MenuItem_SetBitmaps(*args, **kwargs)
def SetDisabledBitmap(*args, **kwargs):
- """SetDisabledBitmap(wxBitmap bmpDisabled)"""
+ """SetDisabledBitmap(Bitmap bmpDisabled)"""
return _core.MenuItem_SetDisabledBitmap(*args, **kwargs)
def GetDisabledBitmap(*args, **kwargs):
- """GetDisabledBitmap() -> wxBitmap"""
+ """GetDisabledBitmap() -> Bitmap"""
return _core.MenuItem_GetDisabledBitmap(*args, **kwargs)
def SetMarginWidth(*args, **kwargs):
return _core.MenuItem_GetMarginWidth(*args, **kwargs)
def GetDefaultMarginWidth(*args, **kwargs):
- """MenuItem.GetDefaultMarginWidth() -> int"""
+ """GetDefaultMarginWidth() -> int"""
return _core.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
GetDefaultMarginWidth = staticmethod(GetDefaultMarginWidth)
return _core.MenuItem_ResetOwnerDrawn(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _core.MenuItem_SetBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _core.MenuItem_GetBitmap(*args, **kwargs)
_core.MenuItem_swigregister(MenuItemPtr)
def MenuItem_GetLabelFromText(*args, **kwargs):
- """MenuItem_GetLabelFromText(wxString text) -> wxString"""
+ """MenuItem_GetLabelFromText(String text) -> String"""
return _core.MenuItem_GetLabelFromText(*args, **kwargs)
def MenuItem_GetDefaultMarginWidth(*args, **kwargs):
#---------------------------------------------------------------------------
class Control(Window):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxControl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyControlNameStr) -> Control"""
+ """
+ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, Validator validator=DefaultValidator,
+ String name=ControlNameStr) -> Control
+ """
newobj = _core.new_Control(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def Create(*args, **kwargs):
- """Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyControlNameStr) -> bool"""
+ """
+ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, Validator validator=DefaultValidator,
+ String name=ControlNameStr) -> bool
+ """
return _core.Control_Create(*args, **kwargs)
def Command(*args, **kwargs):
return _core.Control_Command(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.Control_GetLabel(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _core.Control_SetLabel(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Control
_core.Control_swigregister(ControlPtr)
+ControlNameStr = cvar.ControlNameStr
def PreControl(*args, **kwargs):
"""PreControl() -> Control"""
#---------------------------------------------------------------------------
class ItemContainer(object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxItemContainer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Append(*args, **kwargs):
- """Append(wxString item, PyObject clientData=None) -> int"""
+ """Append(String item, PyObject clientData=None) -> int"""
return _core.ItemContainer_Append(*args, **kwargs)
def AppendItems(*args, **kwargs):
return _core.ItemContainer_AppendItems(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(wxString item, int pos, PyObject clientData=None) -> int"""
+ """Insert(String item, int pos, PyObject clientData=None) -> int"""
return _core.ItemContainer_Insert(*args, **kwargs)
def Clear(*args, **kwargs):
return _core.ItemContainer_IsEmpty(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString(int n) -> wxString"""
+ """GetString(int n) -> String"""
return _core.ItemContainer_GetString(*args, **kwargs)
def GetStrings(*args, **kwargs):
return _core.ItemContainer_GetStrings(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(int n, wxString s)"""
+ """SetString(int n, String s)"""
return _core.ItemContainer_SetString(*args, **kwargs)
def FindString(*args, **kwargs):
- """FindString(wxString s) -> int"""
+ """FindString(String s) -> int"""
return _core.ItemContainer_FindString(*args, **kwargs)
def Select(*args, **kwargs):
return _core.ItemContainer_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
- """GetStringSelection() -> wxString"""
+ """GetStringSelection() -> String"""
return _core.ItemContainer_GetStringSelection(*args, **kwargs)
def GetClientData(*args, **kwargs):
#---------------------------------------------------------------------------
class ControlWithItems(Control,ItemContainer):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxControlWithItems instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
#---------------------------------------------------------------------------
class SizerItem(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
_core.SizerItem_swigregister(SizerItemPtr)
def SizerItemSpacer(*args, **kwargs):
- """SizerItemSpacer(int width, int height, int proportion, int flag, int border,
- Object userData) -> SizerItem"""
+ """
+ SizerItemSpacer(int width, int height, int proportion, int flag, int border,
+ Object userData) -> SizerItem
+ """
val = _core.new_SizerItemSpacer(*args, **kwargs)
val.thisown = 1
return val
def SizerItemWindow(*args, **kwargs):
- """SizerItemWindow(Window window, int proportion, int flag, int border,
- Object userData) -> SizerItem"""
+ """
+ SizerItemWindow(Window window, int proportion, int flag, int border,
+ Object userData) -> SizerItem
+ """
val = _core.new_SizerItemWindow(*args, **kwargs)
val.thisown = 1
return val
def SizerItemSizer(*args, **kwargs):
- """SizerItemSizer(Sizer sizer, int proportion, int flag, int border,
- Object userData) -> SizerItem"""
+ """
+ SizerItemSizer(Sizer sizer, int proportion, int flag, int border,
+ Object userData) -> SizerItem
+ """
val = _core.new_SizerItemSizer(*args, **kwargs)
val.thisown = 1
return val
class Sizer(Object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
return _core.Sizer__setOORInfo(*args, **kwargs)
def Add(*args, **kwargs):
- """Add(PyObject item, int proportion=0, int flag=0, int border=0,
- PyObject userData=None)"""
+ """
+ Add(PyObject item, int proportion=0, int flag=0, int border=0,
+ PyObject userData=None)
+ """
return _core.Sizer_Add(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(int before, PyObject item, int proportion=0, int flag=0,
- int border=0, PyObject userData=None)"""
+ """
+ Insert(int before, PyObject item, int proportion=0, int flag=0,
+ int border=0, PyObject userData=None)
+ """
return _core.Sizer_Insert(*args, **kwargs)
def Prepend(*args, **kwargs):
- """Prepend(PyObject item, int proportion=0, int flag=0, int border=0,
- PyObject userData=None)"""
+ """
+ Prepend(PyObject item, int proportion=0, int flag=0, int border=0,
+ PyObject userData=None)
+ """
return _core.Sizer_Prepend(*args, **kwargs)
def Remove(*args, **kwargs):
childinfo = (childinfo, )
self.Add(*childinfo)
-
+ # for backwards compatibility only, please do not use in new code
AddWindow = AddSizer = AddSpacer = Add
PrependWindow = PrependSizer = PrependSpacer = Prepend
InsertWindow = InsertSizer = InsertSpacer = Insert
_core.Sizer_swigregister(SizerPtr)
class PySizer(Sizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPySizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class BoxSizer(Sizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class StaticBoxSizer(BoxSizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxStaticBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
#---------------------------------------------------------------------------
class GridSizer(Sizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
FLEX_GROWMODE_SPECIFIED = _core.FLEX_GROWMODE_SPECIFIED
FLEX_GROWMODE_ALL = _core.FLEX_GROWMODE_ALL
class FlexGridSizer(GridSizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFlexGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.FlexGridSizer_GetFlexibleDirection(*args, **kwargs)
def SetNonFlexibleGrowMode(*args, **kwargs):
- """SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode)"""
+ """SetNonFlexibleGrowMode(int mode)"""
return _core.FlexGridSizer_SetNonFlexibleGrowMode(*args, **kwargs)
def GetNonFlexibleGrowMode(*args, **kwargs):
- """GetNonFlexibleGrowMode() -> wxFlexSizerGrowMode"""
+ """GetNonFlexibleGrowMode() -> int"""
return _core.FlexGridSizer_GetNonFlexibleGrowMode(*args, **kwargs)
def GetRowHeights(*args, **kwargs):
#---------------------------------------------------------------------------
class GBPosition(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBPosition instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
elif index == 1: self.SetCol(val)
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.GBPosition, self.Get())
row = property(GetRow, SetRow)
col = property(GetCol, SetCol)
_core.GBPosition_swigregister(GBPositionPtr)
class GBSpan(object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
elif index == 1: self.SetColspan(val)
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
- def __getinitargs__(self): return ()
- def __getstate__(self): return self.Get()
- def __setstate__(self, state): self.Set(*state)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.GBSpan, self.Get())
rowspan = property(GetRowspan, SetRowspan)
colspan = property(GetColspan, SetColspan)
_core.GBSpan_swigregister(GBSpanPtr)
class GBSizerItem(SizerItem):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
return _core.GBSizerItem_SetSpan(*args, **kwargs)
def Intersects(*args):
- """Intersects(GBSizerItem other) -> bool
-Intersects(GBPosition pos, GBSpan span) -> bool"""
+ """
+ Intersects(GBSizerItem other) -> bool
+ Intersects(GBPosition pos, GBSpan span) -> bool
+ """
return _core.GBSizerItem_Intersects(*args)
def GetEndPos(*args, **kwargs):
DefaultSpan = cvar.DefaultSpan
def GBSizerItemWindow(*args, **kwargs):
- """GBSizerItemWindow(Window window, GBPosition pos, GBSpan span, int flag,
- int border, Object userData) -> GBSizerItem"""
+ """
+ GBSizerItemWindow(Window window, GBPosition pos, GBSpan span, int flag,
+ int border, Object userData) -> GBSizerItem
+ """
val = _core.new_GBSizerItemWindow(*args, **kwargs)
val.thisown = 1
return val
def GBSizerItemSizer(*args, **kwargs):
- """GBSizerItemSizer(Sizer sizer, GBPosition pos, GBSpan span, int flag,
- int border, Object userData) -> GBSizerItem"""
+ """
+ GBSizerItemSizer(Sizer sizer, GBPosition pos, GBSpan span, int flag,
+ int border, Object userData) -> GBSizerItem
+ """
val = _core.new_GBSizerItemSizer(*args, **kwargs)
val.thisown = 1
return val
def GBSizerItemSpacer(*args, **kwargs):
- """GBSizerItemSpacer(int width, int height, GBPosition pos, GBSpan span,
- int flag, int border, Object userData) -> GBSizerItem"""
+ """
+ GBSizerItemSpacer(int width, int height, GBPosition pos, GBSpan span,
+ int flag, int border, Object userData) -> GBSizerItem
+ """
val = _core.new_GBSizerItemSpacer(*args, **kwargs)
val.thisown = 1
return val
class GridBagSizer(FlexGridSizer):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridBagSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def Add(*args, **kwargs):
- """Add(PyObject item, GBPosition pos, GBSpan span=DefaultSpan,
- int flag=0, int border=0, PyObject userData=None) -> bool"""
+ """
+ Add(PyObject item, GBPosition pos, GBSpan span=DefaultSpan,
+ int flag=0, int border=0, PyObject userData=None) -> bool
+ """
return _core.GridBagSizer_Add(*args, **kwargs)
def AddItem(*args, **kwargs):
return _core.GridBagSizer_SetEmptyCellSize(*args, **kwargs)
def GetItemPosition(*args):
- """GetItemPosition(Window window) -> GBPosition
-GetItemPosition(Sizer sizer) -> GBPosition
-GetItemPosition(size_t index) -> GBPosition"""
+ """
+ GetItemPosition(Window window) -> GBPosition
+ GetItemPosition(Sizer sizer) -> GBPosition
+ GetItemPosition(size_t index) -> GBPosition
+ """
return _core.GridBagSizer_GetItemPosition(*args)
def SetItemPosition(*args):
- """SetItemPosition(Window window, GBPosition pos) -> bool
-SetItemPosition(Sizer sizer, GBPosition pos) -> bool
-SetItemPosition(size_t index, GBPosition pos) -> bool"""
+ """
+ SetItemPosition(Window window, GBPosition pos) -> bool
+ SetItemPosition(Sizer sizer, GBPosition pos) -> bool
+ SetItemPosition(size_t index, GBPosition pos) -> bool
+ """
return _core.GridBagSizer_SetItemPosition(*args)
def GetItemSpan(*args):
- """GetItemSpan(Window window) -> GBSpan
-GetItemSpan(Sizer sizer) -> GBSpan
-GetItemSpan(size_t index) -> GBSpan"""
+ """
+ GetItemSpan(Window window) -> GBSpan
+ GetItemSpan(Sizer sizer) -> GBSpan
+ GetItemSpan(size_t index) -> GBSpan
+ """
return _core.GridBagSizer_GetItemSpan(*args)
def SetItemSpan(*args):
- """SetItemSpan(Window window, GBSpan span) -> bool
-SetItemSpan(Sizer sizer, GBSpan span) -> bool
-SetItemSpan(size_t index, GBSpan span) -> bool"""
+ """
+ SetItemSpan(Window window, GBSpan span) -> bool
+ SetItemSpan(Sizer sizer, GBSpan span) -> bool
+ SetItemSpan(size_t index, GBSpan span) -> bool
+ """
return _core.GridBagSizer_SetItemSpan(*args)
def FindItem(*args):
- """FindItem(Window window) -> GBSizerItem
-FindItem(Sizer sizer) -> GBSizerItem"""
+ """
+ FindItem(Window window) -> GBSizerItem
+ FindItem(Sizer sizer) -> GBSizerItem
+ """
return _core.GridBagSizer_FindItem(*args)
def FindItemAtPosition(*args, **kwargs):
return _core.GridBagSizer_CalcMin(*args, **kwargs)
def CheckForIntersection(*args):
- """CheckForIntersection(GBSizerItem item, GBSizerItem excludeItem=None) -> bool
-CheckForIntersection(GBPosition pos, GBSpan span, GBSizerItem excludeItem=None) -> bool"""
+ """
+ CheckForIntersection(GBSizerItem item, GBSizerItem excludeItem=None) -> bool
+ CheckForIntersection(GBPosition pos, GBSpan span, GBSizerItem excludeItem=None) -> bool
+ """
return _core.GridBagSizer_CheckForIntersection(*args)
SameAs = _core.SameAs
Absolute = _core.Absolute
class IndividualLayoutConstraint(Object):
- """"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxIndividualLayoutConstraint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Set(*args, **kwargs):
- """Set(wxRelationship rel, Window otherW, wxEdge otherE, int val=0,
- int marg=wxLAYOUT_DEFAULT_MARGIN)"""
+ """Set(int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)"""
return _core.IndividualLayoutConstraint_Set(*args, **kwargs)
def LeftOf(*args, **kwargs):
return _core.IndividualLayoutConstraint_Below(*args, **kwargs)
def SameAs(*args, **kwargs):
- """SameAs(Window otherW, wxEdge edge, int marg=0)"""
+ """SameAs(Window otherW, int edge, int marg=0)"""
return _core.IndividualLayoutConstraint_SameAs(*args, **kwargs)
def PercentOf(*args, **kwargs):
- """PercentOf(Window otherW, wxEdge wh, int per)"""
+ """PercentOf(Window otherW, int wh, int per)"""
return _core.IndividualLayoutConstraint_PercentOf(*args, **kwargs)
def Absolute(*args, **kwargs):
return _core.IndividualLayoutConstraint_GetOtherWindow(*args, **kwargs)
def GetMyEdge(*args, **kwargs):
- """GetMyEdge() -> wxEdge"""
+ """GetMyEdge() -> int"""
return _core.IndividualLayoutConstraint_GetMyEdge(*args, **kwargs)
def SetEdge(*args, **kwargs):
- """SetEdge(wxEdge which)"""
+ """SetEdge(int which)"""
return _core.IndividualLayoutConstraint_SetEdge(*args, **kwargs)
def SetValue(*args, **kwargs):
return _core.IndividualLayoutConstraint_SetDone(*args, **kwargs)
def GetRelationship(*args, **kwargs):
- """GetRelationship() -> wxRelationship"""
+ """GetRelationship() -> int"""
return _core.IndividualLayoutConstraint_GetRelationship(*args, **kwargs)
def SetRelationship(*args, **kwargs):
- """SetRelationship(wxRelationship r)"""
+ """SetRelationship(int r)"""
return _core.IndividualLayoutConstraint_SetRelationship(*args, **kwargs)
def ResetIfWin(*args, **kwargs):
return _core.IndividualLayoutConstraint_SatisfyConstraint(*args, **kwargs)
def GetEdge(*args, **kwargs):
- """GetEdge(wxEdge which, Window thisWin, Window other) -> int"""
+ """GetEdge(int which, Window thisWin, Window other) -> int"""
return _core.IndividualLayoutConstraint_GetEdge(*args, **kwargs)
_core.IndividualLayoutConstraint_swigregister(IndividualLayoutConstraintPtr)
class LayoutConstraints(Object):
- """"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxLayoutConstraints instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
left = property(_core.LayoutConstraints_left_get)
self.thisown = 1
del newobj.thisown
def SatisfyConstraints(*args, **kwargs):
- """SatisfyConstraints(Window win, int OUTPUT) -> bool"""
+ """SatisfyConstraints(Window win) -> (areSatisfied, noChanges)"""
return _core.LayoutConstraints_SatisfyConstraints(*args, **kwargs)
def AreSatisfied(*args, **kwargs):
#----------------------------------------------------------------------------
-# Use Python's bool constants if available, make aliases if not
+# Use Python's bool constants if available, make some if not
try:
True
except NameError:
- True = 1==1
- False = 1==0
+ __builtins__.True = 1==1
+ __builtins__.False = 1==0
-# Backwards compaatibility
-TRUE = true = True
-FALSE = false = False
# workarounds for bad wxRTTI names
class PyDeadObjectError(AttributeError):
pass
-
class _wxPyDeadObject(object):
"""
Instances of wx objects that are OOR capable will have their __class__
reprStr = "wxPython wrapper for DELETED %s object! (The C++ object no longer exists.)"
attrStr = "The C++ part of the %s object has been deleted, attribute access no longer allowed."
- def __repr__( self ):
+ def __repr__(self):
if not hasattr(self, "_name"):
self._name = "[unknown]"
return self.reprStr % self._name
- def __getattr__( self, *args ):
+ def __getattr__(self, *args):
if not hasattr(self, "_name"):
self._name = "[unknown]"
- raise PyDeadObjectError( self.attrStr % self._name )
+ raise PyDeadObjectError(self.attrStr % self._name)
+
+ def __nonzero__(self):
+ return 0
+
+
+
+class PyUnbornObjectError(AttributeError):
+ pass
+
+class _wxPyUnbornObject(object):
+ """
+ Some stock objects are created when the wx.core module is
+ imported, but their C++ instance is not created until the wx.App
+ object is created and initialized. These object instances will
+ temporarily have their __class__ changed to this class so an
+ exception will be raised if they are used before the C++ instance
+ is ready.
+ """
+
+ reprStr = "wxPython wrapper for UNBORN object! (The C++ object is not initialized yet.)"
+ attrStr = "The C++ part of this object has not been initialized, attribute access not allowed."
+
+ def __repr__(self):
+ #if not hasattr(self, "_name"):
+ # self._name = "[unknown]"
+ return self.reprStr #% self._name
+
+ def __getattr__(self, *args):
+ #if not hasattr(self, "_name"):
+ # self._name = "[unknown]"
+ raise PyUnbornObjectError(self.attrStr) # % self._name )
def __nonzero__(self):
return 0
from controls import *
from misc import *
+
+# Fixup the stock objects since they can't be used yet. (They will be
+# restored in wx.PyApp.OnInit.)
+_core._wxPyFixStockObjects()
+
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff