LB_EXTENDED = _core_.LB_EXTENDED
LB_OWNERDRAW = _core_.LB_OWNERDRAW
LB_HSCROLL = _core_.LB_HSCROLL
-PROCESS_ENTER = _core_.PROCESS_ENTER
-PASSWORD = _core_.PASSWORD
CB_SIMPLE = _core_.CB_SIMPLE
CB_DROPDOWN = _core_.CB_DROPDOWN
CB_SORT = _core_.CB_SORT
SB_VERTICAL = _core_.SB_VERTICAL
RB_USE_CHECKBOX = _core_.RB_USE_CHECKBOX
ST_SIZEGRIP = _core_.ST_SIZEGRIP
-ST_NO_AUTORESIZE = _core_.ST_NO_AUTORESIZE
-ST_DOTS_MIDDLE = _core_.ST_DOTS_MIDDLE
-ST_DOTS_END = _core_.ST_DOTS_END
FLOOD_SURFACE = _core_.FLOOD_SURFACE
FLOOD_BORDER = _core_.FLOOD_BORDER
ODDEVEN_RULE = _core_.ODDEVEN_RULE
NO = _core_.NO
NO_DEFAULT = _core_.NO_DEFAULT
YES_DEFAULT = _core_.YES_DEFAULT
+APPLY = _core_.APPLY
+CLOSE = _core_.CLOSE
ICON_EXCLAMATION = _core_.ICON_EXCLAMATION
ICON_HAND = _core_.ICON_HAND
ICON_QUESTION = _core_.ICON_QUESTION
SHAPED = _core_.SHAPED
FIXED_MINSIZE = _core_.FIXED_MINSIZE
TILE = _core_.TILE
-ADJUST_MINSIZE = _core_.ADJUST_MINSIZE
+ADJUST_MINSIZE = 0
BORDER_DEFAULT = _core_.BORDER_DEFAULT
BORDER_NONE = _core_.BORDER_NONE
BORDER_STATIC = _core_.BORDER_STATIC
WXK_MENU = _core_.WXK_MENU
WXK_PAUSE = _core_.WXK_PAUSE
WXK_CAPITAL = _core_.WXK_CAPITAL
-WXK_PRIOR = _core_.WXK_PRIOR
-WXK_NEXT = _core_.WXK_NEXT
WXK_END = _core_.WXK_END
WXK_HOME = _core_.WXK_HOME
WXK_LEFT = _core_.WXK_LEFT
WXK_NUMPAD_UP = _core_.WXK_NUMPAD_UP
WXK_NUMPAD_RIGHT = _core_.WXK_NUMPAD_RIGHT
WXK_NUMPAD_DOWN = _core_.WXK_NUMPAD_DOWN
-WXK_NUMPAD_PRIOR = _core_.WXK_NUMPAD_PRIOR
WXK_NUMPAD_PAGEUP = _core_.WXK_NUMPAD_PAGEUP
-WXK_NUMPAD_NEXT = _core_.WXK_NUMPAD_NEXT
WXK_NUMPAD_PAGEDOWN = _core_.WXK_NUMPAD_PAGEDOWN
WXK_NUMPAD_END = _core_.WXK_NUMPAD_END
WXK_NUMPAD_BEGIN = _core_.WXK_NUMPAD_BEGIN
WXK_SPECIAL18 = _core_.WXK_SPECIAL18
WXK_SPECIAL19 = _core_.WXK_SPECIAL19
WXK_SPECIAL20 = _core_.WXK_SPECIAL20
+WXK_PRIOR = WXK_PAGEUP
+WXK_NEXT = WXK_PAGEDOWN
+WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP
+WXK_NUMPAD_NEXT = WXK_NUMPAD_PAGEDOWN
+
PAPER_NONE = _core_.PAPER_NONE
PAPER_LETTER = _core_.PAPER_LETTER
PAPER_LEGAL = _core_.PAPER_LEGAL
Deletes the C++ object this Python object is a proxy for.
"""
- val = _core_.Object_Destroy(*args, **kwargs)
- args[0].thisown = 0
- return val
+ args[0].this.own(False)
+ return _core_.Object_Destroy(*args, **kwargs)
+
+ def IsSameAs(*args, **kwargs):
+ """
+ IsSameAs(self, Object p) -> bool
+
+ For wx.Objects that use C++ reference counting internally, this method
+ can be used to determine if two objects are referencing the same data
+ object.
+ """
+ return _core_.Object_IsSameAs(*args, **kwargs)
ClassName = property(GetClassName,doc="See `GetClassName`")
_core_.Object_swigregister(Object)
BITMAP_TYPE_ICON = _core_.BITMAP_TYPE_ICON
BITMAP_TYPE_ANI = _core_.BITMAP_TYPE_ANI
BITMAP_TYPE_IFF = _core_.BITMAP_TYPE_IFF
+BITMAP_TYPE_TGA = _core_.BITMAP_TYPE_TGA
BITMAP_TYPE_MACCURSOR = _core_.BITMAP_TYPE_MACCURSOR
BITMAP_TYPE_ANY = _core_.BITMAP_TYPE_ANY
CURSOR_NONE = _core_.CURSOR_NONE
Create a w.Point2D object.
"""
_core_.Point2D_swiginit(self,_core_.new_Point2D(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Point2D
+ __del__ = lambda self : None;
def GetFloor(*args, **kwargs):
"""
GetFloor() -> (x,y)
#---------------------------------------------------------------------------
+Inside = _core_.Inside
+OutLeft = _core_.OutLeft
+OutRight = _core_.OutRight
+OutTop = _core_.OutTop
+OutBottom = _core_.OutBottom
+class Rect2D(object):
+ """
+ wx.Rect2D is a rectangle, with position and size, in a 2D coordinate system
+ with floating point component values.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, wxDouble x=0.0, wxDouble y=0.0, wxDouble w=0.0, wxDouble h=0.0) -> Rect2D
+
+ wx.Rect2D is a rectangle, with position and size, in a 2D coordinate system
+ with floating point component values.
+ """
+ _core_.Rect2D_swiginit(self,_core_.new_Rect2D(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Rect2D
+ __del__ = lambda self : None;
+ def GetPosition(*args, **kwargs):
+ """GetPosition(self) -> Point2D"""
+ return _core_.Rect2D_GetPosition(*args, **kwargs)
+
+ def GetSize(*args, **kwargs):
+ """GetSize(self) -> Size"""
+ return _core_.Rect2D_GetSize(*args, **kwargs)
+
+ def GetLeft(*args, **kwargs):
+ """GetLeft(self) -> wxDouble"""
+ return _core_.Rect2D_GetLeft(*args, **kwargs)
+
+ def SetLeft(*args, **kwargs):
+ """SetLeft(self, wxDouble n)"""
+ return _core_.Rect2D_SetLeft(*args, **kwargs)
+
+ def MoveLeftTo(*args, **kwargs):
+ """MoveLeftTo(self, wxDouble n)"""
+ return _core_.Rect2D_MoveLeftTo(*args, **kwargs)
+
+ def GetTop(*args, **kwargs):
+ """GetTop(self) -> wxDouble"""
+ return _core_.Rect2D_GetTop(*args, **kwargs)
+
+ def SetTop(*args, **kwargs):
+ """SetTop(self, wxDouble n)"""
+ return _core_.Rect2D_SetTop(*args, **kwargs)
+
+ def MoveTopTo(*args, **kwargs):
+ """MoveTopTo(self, wxDouble n)"""
+ return _core_.Rect2D_MoveTopTo(*args, **kwargs)
+
+ def GetBottom(*args, **kwargs):
+ """GetBottom(self) -> wxDouble"""
+ return _core_.Rect2D_GetBottom(*args, **kwargs)
+
+ def SetBottom(*args, **kwargs):
+ """SetBottom(self, wxDouble n)"""
+ return _core_.Rect2D_SetBottom(*args, **kwargs)
+
+ def MoveBottomTo(*args, **kwargs):
+ """MoveBottomTo(self, wxDouble n)"""
+ return _core_.Rect2D_MoveBottomTo(*args, **kwargs)
+
+ def GetRight(*args, **kwargs):
+ """GetRight(self) -> wxDouble"""
+ return _core_.Rect2D_GetRight(*args, **kwargs)
+
+ def SetRight(*args, **kwargs):
+ """SetRight(self, wxDouble n)"""
+ return _core_.Rect2D_SetRight(*args, **kwargs)
+
+ def MoveRightTo(*args, **kwargs):
+ """MoveRightTo(self, wxDouble n)"""
+ return _core_.Rect2D_MoveRightTo(*args, **kwargs)
+
+ def GetLeftTop(*args, **kwargs):
+ """GetLeftTop(self) -> Point2D"""
+ return _core_.Rect2D_GetLeftTop(*args, **kwargs)
+
+ def SetLeftTop(*args, **kwargs):
+ """SetLeftTop(self, Point2D pt)"""
+ return _core_.Rect2D_SetLeftTop(*args, **kwargs)
+
+ def MoveLeftTopTo(*args, **kwargs):
+ """MoveLeftTopTo(self, Point2D pt)"""
+ return _core_.Rect2D_MoveLeftTopTo(*args, **kwargs)
+
+ def GetLeftBottom(*args, **kwargs):
+ """GetLeftBottom(self) -> Point2D"""
+ return _core_.Rect2D_GetLeftBottom(*args, **kwargs)
+
+ def SetLeftBottom(*args, **kwargs):
+ """SetLeftBottom(self, Point2D pt)"""
+ return _core_.Rect2D_SetLeftBottom(*args, **kwargs)
+
+ def MoveLeftBottomTo(*args, **kwargs):
+ """MoveLeftBottomTo(self, Point2D pt)"""
+ return _core_.Rect2D_MoveLeftBottomTo(*args, **kwargs)
+
+ def GetRightTop(*args, **kwargs):
+ """GetRightTop(self) -> Point2D"""
+ return _core_.Rect2D_GetRightTop(*args, **kwargs)
+
+ def SetRightTop(*args, **kwargs):
+ """SetRightTop(self, Point2D pt)"""
+ return _core_.Rect2D_SetRightTop(*args, **kwargs)
+
+ def MoveRightTopTo(*args, **kwargs):
+ """MoveRightTopTo(self, Point2D pt)"""
+ return _core_.Rect2D_MoveRightTopTo(*args, **kwargs)
+
+ def GetRightBottom(*args, **kwargs):
+ """GetRightBottom(self) -> Point2D"""
+ return _core_.Rect2D_GetRightBottom(*args, **kwargs)
+
+ def SetRightBottom(*args, **kwargs):
+ """SetRightBottom(self, Point2D pt)"""
+ return _core_.Rect2D_SetRightBottom(*args, **kwargs)
+
+ def MoveRightBottomTo(*args, **kwargs):
+ """MoveRightBottomTo(self, Point2D pt)"""
+ return _core_.Rect2D_MoveRightBottomTo(*args, **kwargs)
+
+ def GetCentre(*args, **kwargs):
+ """GetCentre(self) -> Point2D"""
+ return _core_.Rect2D_GetCentre(*args, **kwargs)
+
+ def SetCentre(*args, **kwargs):
+ """SetCentre(self, Point2D pt)"""
+ return _core_.Rect2D_SetCentre(*args, **kwargs)
+
+ def MoveCentreTo(*args, **kwargs):
+ """MoveCentreTo(self, Point2D pt)"""
+ return _core_.Rect2D_MoveCentreTo(*args, **kwargs)
+
+ def GetOutcode(*args, **kwargs):
+ """GetOutcode(self, Point2D pt) -> int"""
+ return _core_.Rect2D_GetOutcode(*args, **kwargs)
+
+ def Contains(*args, **kwargs):
+ """Contains(self, Point2D pt) -> bool"""
+ return _core_.Rect2D_Contains(*args, **kwargs)
+
+ def ContainsRect(*args, **kwargs):
+ """ContainsRect(self, Rect2D rect) -> bool"""
+ return _core_.Rect2D_ContainsRect(*args, **kwargs)
+
+ def IsEmpty(*args, **kwargs):
+ """IsEmpty(self) -> bool"""
+ return _core_.Rect2D_IsEmpty(*args, **kwargs)
+
+ def HaveEqualSize(*args, **kwargs):
+ """HaveEqualSize(self, Rect2D rect) -> bool"""
+ return _core_.Rect2D_HaveEqualSize(*args, **kwargs)
+
+ def Inset(*args):
+ """
+ Inset(self, wxDouble x, wxDouble y)
+ Inset(self, wxDouble left, wxDouble top, wxDouble right, wxDouble bottom)
+ """
+ return _core_.Rect2D_Inset(*args)
+
+ def Offset(*args, **kwargs):
+ """Offset(self, Point2D pt)"""
+ return _core_.Rect2D_Offset(*args, **kwargs)
+
+ def ConstrainTo(*args, **kwargs):
+ """ConstrainTo(self, Rect2D rect)"""
+ return _core_.Rect2D_ConstrainTo(*args, **kwargs)
+
+ def Interpolate(*args, **kwargs):
+ """Interpolate(self, int widthfactor, int heightfactor) -> Point2D"""
+ return _core_.Rect2D_Interpolate(*args, **kwargs)
+
+ def Intersect(*args, **kwargs):
+ """Intersect(self, Rect2D otherRect)"""
+ return _core_.Rect2D_Intersect(*args, **kwargs)
+
+ def CreateIntersection(*args, **kwargs):
+ """CreateIntersection(self, Rect2D otherRect) -> Rect2D"""
+ return _core_.Rect2D_CreateIntersection(*args, **kwargs)
+
+ def Intersects(*args, **kwargs):
+ """Intersects(self, Rect2D rect) -> bool"""
+ return _core_.Rect2D_Intersects(*args, **kwargs)
+
+ def Union(*args, **kwargs):
+ """Union(self, Rect2D otherRect)"""
+ return _core_.Rect2D_Union(*args, **kwargs)
+
+ def CreateUnion(*args, **kwargs):
+ """CreateUnion(self, Rect2D otherRect) -> Rect2D"""
+ return _core_.Rect2D_CreateUnion(*args, **kwargs)
+
+ def Scale(*args):
+ """
+ Scale(self, wxDouble f)
+ Scale(self, int num, int denum)
+ """
+ return _core_.Rect2D_Scale(*args)
+
+ def __eq__(*args, **kwargs):
+ """
+ __eq__(self, PyObject other) -> bool
+
+ Test for equality of wx.Rect2D objects.
+ """
+ return _core_.Rect2D___eq__(*args, **kwargs)
+
+ def __ne__(*args, **kwargs):
+ """
+ __ne__(self, PyObject other) -> bool
+
+ Test for inequality of wx.Rect2D objects.
+ """
+ return _core_.Rect2D___ne__(*args, **kwargs)
+
+ x = property(_core_.Rect2D_x_get, _core_.Rect2D_x_set)
+ y = property(_core_.Rect2D_y_get, _core_.Rect2D_y_set)
+ width = property(_core_.Rect2D_width_get, _core_.Rect2D_width_set)
+ height = property(_core_.Rect2D_height_get, _core_.Rect2D_height_set)
+ def Set(*args, **kwargs):
+ """Set(self, wxDouble x=0, wxDouble y=0, wxDouble width=0, wxDouble height=0)"""
+ return _core_.Rect2D_Set(*args, **kwargs)
+
+ def Get(*args, **kwargs):
+ """
+ Get() -> (x,y, width, height)
+
+ Return x, y, width and height y properties as a tuple.
+ """
+ return _core_.Rect2D_Get(*args, **kwargs)
+
+ def __str__(self): return str(self.Get())
+ def __repr__(self): return 'wx.Rect2D'+str(self.Get())
+ def __len__(self): return len(self.Get())
+ def __getitem__(self, index): return self.Get()[index]
+ def __setitem__(self, index, val):
+ if index == 0: self.x = val
+ elif index == 1: self.y = val
+ elif index == 2: self.width = val
+ elif index == 3: self.height = val
+ else: raise IndexError
+ def __nonzero__(self): return self.Get() != (0.0, 0.0, 0.0, 0.0)
+ __safe_for_unpickling__ = True
+ def __reduce__(self): return (wx.Rect2D, self.Get())
+
+_core_.Rect2D_swigregister(Rect2D)
+
+class Position(object):
+ """Proxy of C++ Position class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """__init__(self, int row=0, int col=0) -> Position"""
+ _core_.Position_swiginit(self,_core_.new_Position(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Position
+ __del__ = lambda self : None;
+ def GetRow(*args, **kwargs):
+ """GetRow(self) -> int"""
+ return _core_.Position_GetRow(*args, **kwargs)
+
+ def GetColumn(*args, **kwargs):
+ """GetColumn(self) -> int"""
+ return _core_.Position_GetColumn(*args, **kwargs)
+
+ def GetCol(*args, **kwargs):
+ """GetCol(self) -> int"""
+ return _core_.Position_GetCol(*args, **kwargs)
+
+ def SetRow(*args, **kwargs):
+ """SetRow(self, int row)"""
+ return _core_.Position_SetRow(*args, **kwargs)
+
+ def SetColumn(*args, **kwargs):
+ """SetColumn(self, int column)"""
+ return _core_.Position_SetColumn(*args, **kwargs)
+
+ def SetCol(*args, **kwargs):
+ """SetCol(self, int column)"""
+ return _core_.Position_SetCol(*args, **kwargs)
+
+ def __eq__(*args, **kwargs):
+ """
+ __eq__(self, PyObject other) -> bool
+
+ Test for equality of wx.Position objects.
+ """
+ return _core_.Position___eq__(*args, **kwargs)
+
+ def __ne__(*args, **kwargs):
+ """
+ __ne__(self, PyObject other) -> bool
+
+ Test for inequality of wx.Position objects.
+ """
+ return _core_.Position___ne__(*args, **kwargs)
+
+ def __add__(*args):
+ """
+ __add__(self, Position p) -> Position
+ __add__(self, Size s) -> Position
+ """
+ return _core_.Position___add__(*args)
+
+ def __sub__(*args):
+ """
+ __sub__(self, Position p) -> Position
+ __sub__(self, Size s) -> Position
+ """
+ return _core_.Position___sub__(*args)
+
+ row = property(GetRow,SetRow)
+ col = property(GetCol,SetCol)
+_core_.Position_swigregister(Position)
+
+#---------------------------------------------------------------------------
+
FromStart = _core_.FromStart
FromCurrent = _core_.FromCurrent
FromEnd = _core_.FromEnd
def __init__(self, *args, **kwargs):
"""__init__(self) -> FileSystemHandler"""
_core_.FileSystemHandler_swiginit(self,_core_.new_FileSystemHandler(*args, **kwargs))
- self._setCallbackInfo(self, FileSystemHandler)
+ FileSystemHandler._setCallbackInfo(self, self, FileSystemHandler)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
Destroys the image data.
"""
- val = _core_.Image_Destroy(*args, **kwargs)
- args[0].thisown = 0
- return val
+ args[0].this.own(False)
+ return _core_.Image_Destroy(*args, **kwargs)
def Scale(*args, **kwargs):
"""
"""
return _core_.Image_LoadMimeStream(*args, **kwargs)
- def Ok(*args, **kwargs):
+ def IsOk(*args, **kwargs):
"""
- Ok(self) -> bool
+ IsOk(self) -> bool
Returns true if image data is present.
"""
- return _core_.Image_Ok(*args, **kwargs)
+ return _core_.Image_IsOk(*args, **kwargs)
+ Ok = IsOk
def GetWidth(*args, **kwargs):
"""
GetWidth(self) -> int
return _core_.Image_HSVtoRGB(*args, **kwargs)
HSVtoRGB = staticmethod(HSVtoRGB)
- def __nonzero__(self): return self.Ok()
+ def __nonzero__(self): return self.IsOk()
AlphaBuffer = property(GetAlphaBuffer,SetAlphaBuffer,doc="See `GetAlphaBuffer` and `SetAlphaBuffer`")
AlphaData = property(GetAlphaData,SetAlphaData,doc="See `GetAlphaData` and `SetAlphaData`")
Data = property(GetData,SetData,doc="See `GetData` and `SetData`")
MaskBlue = property(GetMaskBlue,doc="See `GetMaskBlue`")
MaskGreen = property(GetMaskGreen,doc="See `GetMaskGreen`")
MaskRed = property(GetMaskRed,doc="See `GetMaskRed`")
- Size = property(GetSize,doc="See `GetSize`")
Width = property(GetWidth,doc="See `GetWidth`")
_core_.Image_swigregister(Image)
"""
pass
+IMAGE_RESOLUTION_NONE = _core_.IMAGE_RESOLUTION_NONE
IMAGE_RESOLUTION_INCHES = _core_.IMAGE_RESOLUTION_INCHES
IMAGE_RESOLUTION_CM = _core_.IMAGE_RESOLUTION_CM
PNG_TYPE_COLOUR = _core_.PNG_TYPE_COLOUR
_core_.TIFFHandler_swiginit(self,_core_.new_TIFFHandler(*args, **kwargs))
_core_.TIFFHandler_swigregister(TIFFHandler)
+class TGAHandler(ImageHandler):
+ """A `wx.ImageHandler` for TGA image files."""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self) -> TGAHandler
+
+ A `wx.ImageHandler` for TGA image files.
+ """
+ _core_.TGAHandler_swiginit(self,_core_.new_TGAHandler(*args, **kwargs))
+_core_.TGAHandler_swigregister(TGAHandler)
+
QUANTIZE_INCLUDE_WINDOWS_COLOURS = _core_.QUANTIZE_INCLUDE_WINDOWS_COLOURS
QUANTIZE_FILL_DESTINATION_IMAGE = _core_.QUANTIZE_FILL_DESTINATION_IMAGE
class Quantize(object):
def _setOORInfo(*args, **kwargs):
"""_setOORInfo(self, PyObject _self, bool incref=True)"""
val = _core_.EvtHandler__setOORInfo(*args, **kwargs)
- args[0].thisown = 0
+ args[0].this.own(False)
return val
def Bind(self, event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
success += target.Disconnect(id1, id2, et)
return success != 0
+ def _getEvtType(self):
+ """
+ Make it easy to get to the default wxEventType typeID for this
+ event binder.
+ """
+ return self.evtType[0]
+
+ typeId = property(_getEvtType)
+
def __call__(self, *args):
"""
def NewEventType(*args):
"""NewEventType() -> EventType"""
return _core_.NewEventType(*args)
+wxEVT_ANY = _core_.wxEVT_ANY
wxEVT_NULL = _core_.wxEVT_NULL
wxEVT_FIRST = _core_.wxEVT_FIRST
wxEVT_USER_FIRST = _core_.wxEVT_USER_FIRST
"""
Skip(self, bool skip=True)
- Called by an event handler, it controls whether additional event
- handlers bound to this event will be called after the current event
- handler returns. Skip(false) (the default setting) will prevent
- additional event handlers from being called and control will be
- returned to the sender of the event immediately after the current
- handler has finished. Skip(True) will cause the event processing
- system to continue searching for a handler function for this event.
-
+ This method can be used inside an event handler to control whether
+ further event handlers bound to this event will be called after the
+ current one returns. Without Skip() (or equivalently if Skip(False) is
+ used), the event will not be processed any more. If Skip(True) is
+ called, the event processing system continues searching for a further
+ handler function for this event, even though it has been processed
+ already in the current handler.
"""
return _core_.Event_Skip(*args, **kwargs)
"""
A scroll event holds information about events sent from stand-alone
scrollbars and sliders. Note that scrolled windows do not send
- instnaces of this event class, but send the `wx.ScrollWinEvent`
+ instances of this event class, but send the `wx.ScrollWinEvent`
instead.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
"""
return _core_.MouseEvent_GetWheelDelta(*args, **kwargs)
+ def GetWheelAxis(*args, **kwargs):
+ """
+ GetWheelAxis(self) -> int
+
+ Gets the axis the wheel operation concerns, 0 being the y axis as on
+ most mouse wheels, 1 is the x axis for things like MightyMouse scrolls
+ or horizontal trackpad scrolling.
+ """
+ return _core_.MouseEvent_GetWheelAxis(*args, **kwargs)
+
def GetLinesPerAction(*args, **kwargs):
"""
GetLinesPerAction(self) -> int
wxEVT_DATE_CHANGED = _core_.wxEVT_DATE_CHANGED
EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
+class EventBlocker(EvtHandler):
+ """Helper class to temporarily disable event handling for a window."""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win, EventType type=wxEVT_ANY) -> EventBlocker
+
+ Helper class to temporarily disable event handling for a window.
+ """
+ _core_.EventBlocker_swiginit(self,_core_.new_EventBlocker(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_EventBlocker
+ __del__ = lambda self : None;
+ def Block(*args, **kwargs):
+ """Block(self, EventType type)"""
+ return _core_.EventBlocker_Block(*args, **kwargs)
+
+_core_.EventBlocker_swigregister(EventBlocker)
+
#---------------------------------------------------------------------------
PYAPP_ASSERT_SUPPRESS = _core_.PYAPP_ASSERT_SUPPRESS
Create a new application object, starting the bootstrap process.
"""
_core_.PyApp_swiginit(self,_core_.new_PyApp(*args, **kwargs))
- self._setCallbackInfo(self, PyApp, False)
- self._setOORInfo(self, False)
+ self._setOORInfo(self, False);PyApp._setCallbackInfo(self, self, PyApp)
__swig_destroy__ = _core_.delete_PyApp
__del__ = lambda self : None;
def _setCallbackInfo(*args, **kwargs):
- """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
+ """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref=False)"""
return _core_.PyApp__setCallbackInfo(*args, **kwargs)
def GetAppName(*args, **kwargs):
def SetUseBestVisual(*args, **kwargs):
"""
- SetUseBestVisual(self, bool flag)
+ SetUseBestVisual(self, bool flag, bool forceTrueColour=False)
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.)
:param redirect: Should ``sys.stdout`` and ``sys.stderr`` be
redirected? Defaults to True on Windows and Mac, False
- otherwise. If `filename` is None then output will be
+ otherwise. If ``filename`` is None then output will be
redirected to a window that pops up as needed. (You can
control what kind of window is created for the output by
resetting the class variable ``outputWindowClass`` to a
# Use Python's install prefix as the default
wx.StandardPaths.Get().SetInstallPrefix(_sys.prefix)
+ # Until the new native control for wxMac is up to par, still use the generic one.
+ wx.SystemOptions.SetOptionInt("mac.listctrl.always_use_generic", 1)
+
# This finishes the initialization of wxWindows and then calls
# the OnInit that should be present in the derived class
self._BootstrapApp()
destroy(self)
def Destroy(self):
+ self.this.own(False)
wx.PyApp.Destroy(self)
- self.thisown = 0
def SetTopWindow(self, frame):
"""Set the \"main\" top level window"""
_core_.AcceleratorTable_swiginit(self,_core_.new_AcceleratorTable(*args, **kwargs))
__swig_destroy__ = _core_.delete_AcceleratorTable
__del__ = lambda self : None;
- def Ok(*args, **kwargs):
- """Ok(self) -> bool"""
- return _core_.AcceleratorTable_Ok(*args, **kwargs)
+ def IsOk(*args, **kwargs):
+ """IsOk(self) -> bool"""
+ return _core_.AcceleratorTable_IsOk(*args, **kwargs)
+ Ok = IsOk
_core_.AcceleratorTable_swigregister(AcceleratorTable)
+def GetAccelFromString(label):
+ entry = AcceleratorEntry()
+ entry.FromString(label)
+ return entry
-def GetAccelFromString(*args, **kwargs):
- """GetAccelFromString(String label) -> AcceleratorEntry"""
- return _core_.GetAccelFromString(*args, **kwargs)
#---------------------------------------------------------------------------
class VisualAttributes(object):
_core_.VisualAttributes_swiginit(self,_core_.new_VisualAttributes(*args, **kwargs))
__swig_destroy__ = _core_.delete_VisualAttributes
__del__ = lambda self : None;
- font = property(_core_.VisualAttributes_font_get, _core_.VisualAttributes_font_set)
- colFg = property(_core_.VisualAttributes_colFg_get, _core_.VisualAttributes_colFg_set)
- colBg = property(_core_.VisualAttributes_colBg_get, _core_.VisualAttributes_colBg_set)
+ def _get_font(*args, **kwargs):
+ """_get_font(self) -> Font"""
+ return _core_.VisualAttributes__get_font(*args, **kwargs)
+
+ def _get_colFg(*args, **kwargs):
+ """_get_colFg(self) -> Colour"""
+ return _core_.VisualAttributes__get_colFg(*args, **kwargs)
+
+ def _get_colBg(*args, **kwargs):
+ """_get_colBg(self) -> Colour"""
+ return _core_.VisualAttributes__get_colBg(*args, **kwargs)
+
+ font = property(_get_font)
+ colFg = property(_get_colFg)
+ colBg = property(_get_colBg)
_core_.VisualAttributes_swigregister(VisualAttributes)
NullAcceleratorTable = cvar.NullAcceleratorTable
PanelNameStr = cvar.PanelNameStr
Returns True if the window has either been successfully deleted, or it
has been added to the list of windows pending real deletion.
"""
- val = _core_.Window_Destroy(*args, **kwargs)
- args[0].thisown = 0
- return val
+ args[0].this.own(False)
+ return _core_.Window_Destroy(*args, **kwargs)
def DestroyChildren(*args, **kwargs):
"""
"""
return _core_.Window_MoveXY(*args, **kwargs)
- def SetBestFittingSize(*args, **kwargs):
+ def SetInitialSize(*args, **kwargs):
"""
- SetBestFittingSize(self, Size size=DefaultSize)
+ SetInitialSize(self, Size size=DefaultSize)
A 'Smart' SetSize that will fill in default size components with the
window's *best size* values. Also set's the minsize for use with sizers.
"""
- return _core_.Window_SetBestFittingSize(*args, **kwargs)
+ return _core_.Window_SetInitialSize(*args, **kwargs)
+ SetBestFittingSize = wx._deprecated(SetInitialSize, 'Use `SetInitialSize`')
def Raise(*args, **kwargs):
"""
Raise(self)
Raises the window to the top of the window hierarchy. In current
- version of wxWidgets this works both for manage and child windows.
+ version of wxWidgets this works both for managed and child windows.
"""
return _core_.Window_Raise(*args, **kwargs)
Lower(self)
Lowers the window to the bottom of the window hierarchy. In current
- version of wxWidgets this works both for manage and child windows.
+ version of wxWidgets this works both for managed and child windows.
"""
return _core_.Window_Lower(*args, **kwargs)
"""
return _core_.Window_CacheBestSize(*args, **kwargs)
- def GetBestFittingSize(*args, **kwargs):
+ def GetEffectiveMinSize(*args, **kwargs):
"""
- GetBestFittingSize(self) -> Size
+ GetEffectiveMinSize(self) -> Size
This function will merge the window's best size into the window's
minimum size, giving priority to the min size components, and returns
the results.
"""
- return _core_.Window_GetBestFittingSize(*args, **kwargs)
+ return _core_.Window_GetEffectiveMinSize(*args, **kwargs)
- def GetAdjustedBestSize(*args, **kwargs):
- """
- GetAdjustedBestSize(self) -> Size
-
- This method is similar to GetBestSize, except in one
- thing. GetBestSize should return the minimum untruncated size of the
- window, while this method will return the largest of BestSize and any
- user specified minimum size. ie. it is the minimum size the window
- should currently be drawn at, not the minimal size it can possibly
- tolerate.
- """
- return _core_.Window_GetAdjustedBestSize(*args, **kwargs)
+ GetBestFittingSize = wx._deprecated(GetEffectiveMinSize, 'Use `GetEffectiveMinSize` instead.')
+ def GetAdjustedBestSize(self):
+ s = self.GetBestSize()
+ return wx.Size(max(s.width, self.GetMinWidth()),
+ max(s.height, self.GetMinHeight()))
+ GetAdjustedBestSize = wx._deprecated(GetAdjustedBestSize, 'Use `GetEffectiveMinSize` instead.')
def Center(*args, **kwargs):
"""
"""
return _core_.Window_GetVirtualSizeTuple(*args, **kwargs)
+ def GetWindowBorderSize(*args, **kwargs):
+ """
+ GetWindowBorderSize(self) -> Size
+
+ Return the size of the left/right and top/bottom borders.
+ """
+ return _core_.Window_GetWindowBorderSize(*args, **kwargs)
+
def GetBestVirtualSize(*args, **kwargs):
"""
GetBestVirtualSize(self) -> Size
IsEnabled(self) -> bool
Returns true if the window is enabled for input, false otherwise.
+ This method takes into account the enabled state of parent windows up
+ to the top-level window.
"""
return _core_.Window_IsEnabled(*args, **kwargs)
+ def IsThisEnabled(*args, **kwargs):
+ """
+ IsThisEnabled(self) -> bool
+
+ Returns the internal enabled state independent of the parent(s) state,
+ i.e. the state in which the window would be if all of its parents are
+ enabled. Use `IsEnabled` to get the effective window state.
+ """
+ return _core_.Window_IsThisEnabled(*args, **kwargs)
+
def IsShownOnScreen(*args, **kwargs):
"""
IsShownOnScreen(self) -> bool
"""
return _core_.Window_IsRetained(*args, **kwargs)
+ def ToggleWindowStyle(*args, **kwargs):
+ """
+ ToggleWindowStyle(self, int flag) -> bool
+
+ Turn the flag on if it had been turned off before and vice versa,
+ returns True if the flag is turned on by this function call.
+ """
+ return _core_.Window_ToggleWindowStyle(*args, **kwargs)
+
def SetExtraStyle(*args, **kwargs):
"""
SetExtraStyle(self, long exStyle)
"""
return _core_.Window_GetExtraStyle(*args, **kwargs)
+ def HasExtraStyle(*args, **kwargs):
+ """
+ HasExtraStyle(self, int exFlag) -> bool
+
+ Returns ``True`` if the given extra flag is set.
+ """
+ return _core_.Window_HasExtraStyle(*args, **kwargs)
+
def MakeModal(*args, **kwargs):
"""
MakeModal(self, bool modal=True)
"""
return _core_.Window_AcceptsFocus(*args, **kwargs)
+ def CanAcceptFocus(*args, **kwargs):
+ """
+ CanAcceptFocus(self) -> bool
+
+ Can this window have focus right now?
+ """
+ return _core_.Window_CanAcceptFocus(*args, **kwargs)
+
def AcceptsFocusFromKeyboard(*args, **kwargs):
"""
AcceptsFocusFromKeyboard(self) -> bool
"""
return _core_.Window_AcceptsFocusFromKeyboard(*args, **kwargs)
+ def CanAcceptFocusFromKeyboard(*args, **kwargs):
+ """
+ CanAcceptFocusFromKeyboard(self) -> bool
+
+ Can this window be assigned focus from keyboard right now?
+ """
+ return _core_.Window_CanAcceptFocusFromKeyboard(*args, **kwargs)
+
+ def SetCanFocus(*args, **kwargs):
+ """SetCanFocus(self, bool canFocus)"""
+ return _core_.Window_SetCanFocus(*args, **kwargs)
+
+ def NavigateIn(*args, **kwargs):
+ """
+ NavigateIn(self, int flags=NavigationKeyEvent.IsForward) -> bool
+
+ Navigates inside this window.
+ """
+ return _core_.Window_NavigateIn(*args, **kwargs)
+
def Navigate(*args, **kwargs):
"""
Navigate(self, int flags=NavigationKeyEvent.IsForward) -> bool
- Does keyboard navigation from this window to another, by sending a
- `wx.NavigationKeyEvent`.
+ Does keyboard navigation starting from this window to another. This is
+ equivalient to self.GetParent().NavigateIn().
"""
return _core_.Window_Navigate(*args, **kwargs)
"""
return _core_.Window_GetGrandParent(*args, **kwargs)
+ def GetTopLevelParent(*args, **kwargs):
+ """
+ GetTopLevelParent(self) -> Window
+
+ Returns the first frame or dialog in this window's parental hierarchy.
+ """
+ return _core_.Window_GetTopLevelParent(*args, **kwargs)
+
def IsTopLevel(*args, **kwargs):
"""
IsTopLevel(self) -> bool
Pushes this event handler onto the event handler stack for the window.
An event handler is an object that is capable of processing the events
- sent to a window. (In other words, is able to dispatch the events to
+ sent to a window. (In other words, is able to dispatch the events to a
handler function.) By default, the window is its own event handler,
but an application may wish to substitute another, for example to
allow central implementation of event-handling for a variety of
window instead of waiting for the EVT_PAINT event to happen, (normally
this would usually only happen when the flow of control returns to the
event loop.) Notice that this function doesn't refresh the window and
- does nothing if the window has been already repainted. Use Refresh
+ does nothing if the window has been already repainted. Use `Refresh`
first if you want to immediately redraw the window (or some portion of
it) unconditionally.
"""
"""
return _core_.Window_PrepareDC(*args, **kwargs)
+ def IsDoubleBuffered(*args, **kwargs):
+ """
+ IsDoubleBuffered(self) -> bool
+
+ Returns ``True`` if the window contents is double-buffered by the
+ system, i.e. if any drawing done on the window is really done on a
+ temporary backing surface and transferred to the screen all at once
+ later.
+ """
+ return _core_.Window_IsDoubleBuffered(*args, **kwargs)
+
def GetUpdateRegion(*args, **kwargs):
"""
GetUpdateRegion(self) -> Region
self.thisown = pre.thisown
pre.thisown = 0
if hasattr(self, '_setOORInfo'):
- self._setOORInfo(self)
+ try:
+ self._setOORInfo(self)
+ except TypeError:
+ pass
if hasattr(self, '_setCallbackInfo'):
- self._setCallbackInfo(self, self.__class__)
+ try:
+ self._setCallbackInfo(self, pre.__class__)
+ except TypeError:
+ pass
def SendSizeEvent(self):
self.GetEventHandler().ProcessEvent(wx.SizeEvent((-1,-1)))
AcceleratorTable = property(GetAcceleratorTable,SetAcceleratorTable,doc="See `GetAcceleratorTable` and `SetAcceleratorTable`")
- AdjustedBestSize = property(GetAdjustedBestSize,doc="See `GetAdjustedBestSize`")
AutoLayout = property(GetAutoLayout,SetAutoLayout,doc="See `GetAutoLayout` and `SetAutoLayout`")
BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
BackgroundStyle = property(GetBackgroundStyle,SetBackgroundStyle,doc="See `GetBackgroundStyle` and `SetBackgroundStyle`")
- BestFittingSize = property(GetBestFittingSize,SetBestFittingSize,doc="See `GetBestFittingSize` and `SetBestFittingSize`")
+ EffectiveMinSize = property(GetEffectiveMinSize,doc="See `GetEffectiveMinSize`")
BestSize = property(GetBestSize,doc="See `GetBestSize`")
BestVirtualSize = property(GetBestVirtualSize,doc="See `GetBestVirtualSize`")
Border = property(GetBorder,doc="See `GetBorder`")
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
ForegroundColour = property(GetForegroundColour,SetForegroundColour,doc="See `GetForegroundColour` and `SetForegroundColour`")
GrandParent = property(GetGrandParent,doc="See `GetGrandParent`")
+ TopLevelParent = property(GetTopLevelParent,doc="See `GetTopLevelParent`")
Handle = property(GetHandle,doc="See `GetHandle`")
HelpText = property(GetHelpText,SetHelpText,doc="See `GetHelpText` and `SetHelpText`")
Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
def __init__(self, *args, **kwargs):
"""__init__(self) -> PyValidator"""
_core_.PyValidator_swiginit(self,_core_.new_PyValidator(*args, **kwargs))
-
- self._setCallbackInfo(self, PyValidator, 1)
- self._setOORInfo(self)
+ self._setOORInfo(self);PyValidator._setCallbackInfo(self, self, PyValidator)
def _setCallbackInfo(*args, **kwargs):
- """_setCallbackInfo(self, PyObject self, PyObject _class, int incref=True)"""
+ """_setCallbackInfo(self, PyObject self, PyObject _class, int incref=1)"""
return _core_.PyValidator__setCallbackInfo(*args, **kwargs)
_core_.PyValidator_swigregister(PyValidator)
"""Remove(self, int id) -> MenuItem"""
return _core_.Menu_Remove(*args, **kwargs)
- def RemoveItem(*args, **kwargs):
+ def RemoveItem(self, item):
"""RemoveItem(self, MenuItem item) -> MenuItem"""
- return _core_.Menu_RemoveItem(*args, **kwargs)
+ #// The return object is always the parameter, so return that
+ #// proxy instead of the new one
+ val = _core_.Menu_RemoveItem(self, item)
+ item.this.own(val.this.own())
+ val.this.disown()
+ return item
+
def Delete(*args, **kwargs):
"""Delete(self, int id) -> bool"""
Deletes the C++ object this Python object is a proxy for.
"""
- val = _core_.Menu_Destroy(*args, **kwargs)
- args[0].thisown = 0
- return val
+ args[0].this.own(False)
+ return _core_.Menu_Destroy(*args, **kwargs)
def DestroyId(*args, **kwargs):
- """
- DestroyId(self, int id) -> bool
-
- Deletes the C++ object this Python object is a proxy for.
- """
- val = _core_.Menu_DestroyId(*args, **kwargs)
- args[0].thisown = 0
- return val
+ """DestroyId(self, int id) -> bool"""
+ return _core_.Menu_DestroyId(*args, **kwargs)
def DestroyItem(*args, **kwargs):
- """
- DestroyItem(self, MenuItem item) -> bool
-
- Deletes the C++ object this Python object is a proxy for.
- """
- val = _core_.Menu_DestroyItem(*args, **kwargs)
- args[0].thisown = 0
- return val
+ """DestroyItem(self, MenuItem item) -> bool"""
+ return _core_.Menu_DestroyItem(*args, **kwargs)
def GetMenuItemCount(*args, **kwargs):
"""GetMenuItemCount(self) -> size_t"""
self.Append(m, l)
Frame = property(GetFrame,doc="See `GetFrame`")
- Menu = property(GetMenu,doc="See `GetMenu`")
MenuCount = property(GetMenuCount,doc="See `GetMenuCount`")
Menus = property(GetMenus,SetMenus,doc="See `GetMenus` and `SetMenus`")
_core_.MenuBar_swigregister(MenuBar)
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
- __init__(self, Menu parentMenu=None, int id=ID_ANY, String text=EmptyString,
+ __init__(self, Menu parentMenu=None, int id=ID_SEPARATOR, String text=EmptyString,
String help=EmptyString, int kind=ITEM_NORMAL,
Menu subMenu=None) -> MenuItem
"""
_core_.MenuItem_swiginit(self,_core_.new_MenuItem(*args, **kwargs))
__swig_destroy__ = _core_.delete_MenuItem
__del__ = lambda self : None;
+ def Destroy(self): pass
def GetMenu(*args, **kwargs):
"""GetMenu(self) -> Menu"""
return _core_.MenuItem_GetMenu(*args, **kwargs)
"""
return _core_.Control_Command(*args, **kwargs)
+ def RemoveMnemonics(*args, **kwargs):
+ """
+ RemoveMnemonics(String str) -> String
+
+ removes the mnemonics characters
+ """
+ return _core_.Control_RemoveMnemonics(*args, **kwargs)
+
+ RemoveMnemonics = staticmethod(RemoveMnemonics)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
val = _core_.new_PreControl(*args, **kwargs)
return val
+def Control_RemoveMnemonics(*args, **kwargs):
+ """
+ Control_RemoveMnemonics(String str) -> String
+
+ removes the mnemonics characters
+ """
+ return _core_.Control_RemoveMnemonics(*args, **kwargs)
+
def Control_GetClassDefaultAttributes(*args, **kwargs):
"""
Control_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
def Insert(*args, **kwargs):
"""
- Insert(self, String item, unsigned int pos, PyObject clientData=None) -> int
+ Insert(self, String item, int pos, PyObject clientData=None) -> int
Insert an item into the control before the item at the ``pos`` index,
optionally associating some data object with the item.
def Delete(*args, **kwargs):
"""
- Delete(self, unsigned int n)
+ Delete(self, int n)
Deletes the item at the zero-based index 'n' from the control. Note
that it is an error (signalled by a `wx.PyAssertionError` exception if
def GetClientData(*args, **kwargs):
"""
- GetClientData(self, unsigned int n) -> PyObject
+ GetClientData(self, int n) -> PyObject
Returns the client data associated with the given item, (if any.)
"""
def SetClientData(*args, **kwargs):
"""
- SetClientData(self, unsigned int n, PyObject clientData)
+ SetClientData(self, int n, PyObject clientData)
Associate the given client data with the item at position n.
"""
def GetCount(*args, **kwargs):
"""
- GetCount(self) -> unsigned int
+ GetCount(self) -> int
Returns the number of items in the control.
"""
def GetString(*args, **kwargs):
"""
- GetString(self, unsigned int n) -> String
+ GetString(self, int n) -> String
Returns the label of the item with the given index.
"""
def SetString(*args, **kwargs):
"""
- SetString(self, unsigned int n, String s)
+ SetString(self, int n, String s)
Sets the label for the given item.
"""
#---------------------------------------------------------------------------
+class SizerFlags(object):
+ """
+ Normally, when you add an item to a sizer via `wx.Sizer.Add`, you have
+ to specify a lot of flags and parameters which can be unwieldy. This
+ is where wx.SizerFlags comes in: it allows you to specify all
+ parameters using the named methods instead. For example, instead of::
+
+ sizer.Add(ctrl, 0, wx.EXPAND | wx.ALL, 10)
+
+ you can now write::
+
+ sizer.AddF(ctrl, wx.SizerFlags().Expand().Border(wx.ALL, 10))
+
+ This is more readable and also allows you to create wx.SizerFlags
+ objects which can be reused for several sizer items.::
+
+ flagsExpand = wx.SizerFlags(1)
+ flagsExpand.Expand().Border(wx.ALL, 10)
+ sizer.AddF(ctrl1, flagsExpand)
+ sizer.AddF(ctrl2, flagsExpand)
+
+ Note that by specification, all methods of wx.SizerFlags return the
+ wx.SizerFlags object itself allowing chaining multiple method calls
+ like in the examples above.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, int proportion=0) -> SizerFlags
+
+ Constructs the flags object with the specified proportion.
+ """
+ _core_.SizerFlags_swiginit(self,_core_.new_SizerFlags(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_SizerFlags
+ __del__ = lambda self : None;
+ def Proportion(*args, **kwargs):
+ """
+ Proportion(self, int proportion) -> SizerFlags
+
+ Sets the item's proportion value.
+ """
+ return _core_.SizerFlags_Proportion(*args, **kwargs)
+
+ def Align(*args, **kwargs):
+ """
+ Align(self, int alignment) -> SizerFlags
+
+ Sets the item's alignment
+ """
+ return _core_.SizerFlags_Align(*args, **kwargs)
+
+ def Expand(*args, **kwargs):
+ """
+ Expand(self) -> SizerFlags
+
+ Sets the wx.EXPAND flag, which will cause the item to be expanded to
+ fill as much space as it is given by the sizer.
+ """
+ return _core_.SizerFlags_Expand(*args, **kwargs)
+
+ def Centre(*args, **kwargs):
+ """
+ Centre(self) -> SizerFlags
+
+ Same as `Center` for those with an alternate dialect of English.
+ """
+ return _core_.SizerFlags_Centre(*args, **kwargs)
+
+ def Center(*args, **kwargs):
+ """
+ Center(self) -> SizerFlags
+
+ Sets the centering alignment flags.
+ """
+ return _core_.SizerFlags_Center(*args, **kwargs)
+
+ def Left(*args, **kwargs):
+ """
+ Left(self) -> SizerFlags
+
+ Aligns the object to the left, a shortcut for calling
+ Align(wx.ALIGN_LEFT)
+ """
+ return _core_.SizerFlags_Left(*args, **kwargs)
+
+ def Right(*args, **kwargs):
+ """
+ Right(self) -> SizerFlags
+
+ Aligns the object to the right, a shortcut for calling
+ Align(wx.ALIGN_RIGHT)
+ """
+ return _core_.SizerFlags_Right(*args, **kwargs)
+
+ def Top(*args, **kwargs):
+ """
+ Top(self) -> SizerFlags
+
+ Aligns the object to the top of the available space, a shortcut for
+ calling Align(wx.ALIGN_TOP)
+ """
+ return _core_.SizerFlags_Top(*args, **kwargs)
+
+ def Bottom(*args, **kwargs):
+ """
+ Bottom(self) -> SizerFlags
+
+ Aligns the object to the bottom of the available space, a shortcut for
+ calling Align(wx.ALIGN_BOTTOM)
+ """
+ return _core_.SizerFlags_Bottom(*args, **kwargs)
+
+ def Shaped(*args, **kwargs):
+ """
+ Shaped(self) -> SizerFlags
+
+ Sets the wx.SHAPED flag.
+ """
+ return _core_.SizerFlags_Shaped(*args, **kwargs)
+
+ def FixedMinSize(*args, **kwargs):
+ """
+ FixedMinSize(self) -> SizerFlags
+
+ Sets the wx.FIXED_MINSIZE flag.
+ """
+ return _core_.SizerFlags_FixedMinSize(*args, **kwargs)
+
+ def Border(*args, **kwargs):
+ """
+ Border(self, int direction=ALL, int borderInPixels=-1) -> SizerFlags
+
+ Sets the border of the item in the direction(s) or sides given by the
+ direction parameter. If the borderInPixels value is not given then
+ the default border size (see `GetDefaultBorder`) will be used.
+ """
+ return _core_.SizerFlags_Border(*args, **kwargs)
+
+ def DoubleBorder(*args, **kwargs):
+ """
+ DoubleBorder(self, int direction=ALL) -> SizerFlags
+
+ Sets the border in the given direction to twice the default border
+ size.
+ """
+ return _core_.SizerFlags_DoubleBorder(*args, **kwargs)
+
+ def TripleBorder(*args, **kwargs):
+ """
+ TripleBorder(self, int direction=ALL) -> SizerFlags
+
+ Sets the border in the given direction to three times the default
+ border size.
+ """
+ return _core_.SizerFlags_TripleBorder(*args, **kwargs)
+
+ def HorzBorder(*args, **kwargs):
+ """
+ HorzBorder(self) -> SizerFlags
+
+ Sets the left and right borders to the default border size.
+ """
+ return _core_.SizerFlags_HorzBorder(*args, **kwargs)
+
+ def DoubleHorzBorder(*args, **kwargs):
+ """
+ DoubleHorzBorder(self) -> SizerFlags
+
+ Sets the left and right borders to twice the default border size.
+ """
+ return _core_.SizerFlags_DoubleHorzBorder(*args, **kwargs)
+
+ def GetDefaultBorder(*args, **kwargs):
+ """
+ GetDefaultBorder() -> int
+
+ Returns the default border size used by the other border methods
+ """
+ return _core_.SizerFlags_GetDefaultBorder(*args, **kwargs)
+
+ GetDefaultBorder = staticmethod(GetDefaultBorder)
+ def GetProportion(*args, **kwargs):
+ """
+ GetProportion(self) -> int
+
+ Returns the proportion value to be used in the sizer item.
+ """
+ return _core_.SizerFlags_GetProportion(*args, **kwargs)
+
+ def GetFlags(*args, **kwargs):
+ """
+ GetFlags(self) -> int
+
+ Returns the flags value to be used in the sizer item.
+ """
+ return _core_.SizerFlags_GetFlags(*args, **kwargs)
+
+ def GetBorderInPixels(*args, **kwargs):
+ """
+ GetBorderInPixels(self) -> int
+
+ Returns the border value in pixels to be used in the sizer item.
+ """
+ return _core_.SizerFlags_GetBorderInPixels(*args, **kwargs)
+
+_core_.SizerFlags_swigregister(SizerFlags)
+
+def SizerFlags_GetDefaultBorder(*args):
+ """
+ SizerFlags_GetDefaultBorder() -> int
+
+ Returns the default border size used by the other border methods
+ """
+ return _core_.SizerFlags_GetDefaultBorder(*args)
+
class SizerItem(Object):
"""
The wx.SizerItem class is used to track the position, size and other
"""
return _core_.SizerItem_GetWindow(*args, **kwargs)
- def SetWindow(*args, **kwargs):
- """
- SetWindow(self, Window window)
-
- Set the window to be managed by this sizer item.
- """
- return _core_.SizerItem_SetWindow(*args, **kwargs)
-
def GetSizer(*args, **kwargs):
"""
GetSizer(self) -> Sizer
"""
return _core_.SizerItem_GetSizer(*args, **kwargs)
+ def GetSpacer(*args, **kwargs):
+ """
+ GetSpacer(self) -> Size
+
+ Get the size of the spacer managed by this sizer item.
+ """
+ return _core_.SizerItem_GetSpacer(*args, **kwargs)
+
+ def SetWindow(*args, **kwargs):
+ """
+ SetWindow(self, Window window)
+
+ Set the window to be managed by this sizer item.
+ """
+ return _core_.SizerItem_SetWindow(*args, **kwargs)
+
def SetSizer(*args, **kwargs):
"""
SetSizer(self, Sizer sizer)
"""
return _core_.SizerItem_SetSizer(*args, **kwargs)
- def GetSpacer(*args, **kwargs):
+ def SetSpacer(*args, **kwargs):
"""
- GetSpacer(self) -> Size
+ SetSpacer(self, Size size)
- Get the size of the spacer managed by this sizer item.
+ Set the size of the spacer to be managed by this sizer item.
"""
- return _core_.SizerItem_GetSpacer(*args, **kwargs)
+ return _core_.SizerItem_SetSpacer(*args, **kwargs)
- def SetSpacer(*args, **kwargs):
+ SetWindow = wx._deprecated(SetWindow, "Use `AssignWindow` instead.")
+ SetSizer = wx._deprecated(SetSizer, "Use `AssignSizer` instead.")
+ SetSpacer = wx._deprecated(SetSpacer, "Use `AssignSpacer` instead.")
+
+ def AssignWindow(*args, **kwargs):
"""
- SetSpacer(self, Size size)
+ AssignWindow(self, Window window)
+
+ Set the window to be managed by this sizer item.
+ """
+ return _core_.SizerItem_AssignWindow(*args, **kwargs)
+
+ def AssignSizer(*args, **kwargs):
+ """
+ AssignSizer(self, Sizer sizer)
+
+ Set the subsizer to be managed by this sizer item.
+ """
+ return _core_.SizerItem_AssignSizer(*args, **kwargs)
+
+ def AssignSpacer(*args, **kwargs):
+ """
+ AssignSpacer(self, Size size)
Set the size of the spacer to be managed by this sizer item.
"""
- return _core_.SizerItem_SetSpacer(*args, **kwargs)
+ return _core_.SizerItem_AssignSpacer(*args, **kwargs)
def Show(*args, **kwargs):
"""
Ratio = property(GetRatio,SetRatio,doc="See `GetRatio` and `SetRatio`")
Rect = property(GetRect,doc="See `GetRect`")
Size = property(GetSize,doc="See `GetSize`")
- Sizer = property(GetSizer,SetSizer,doc="See `GetSizer` and `SetSizer`")
- Spacer = property(GetSpacer,SetSpacer,doc="See `GetSpacer` and `SetSpacer`")
+ Sizer = property(GetSizer,AssignSizer,doc="See `GetSizer` and `AssignSizer`")
+ Spacer = property(GetSpacer,AssignSpacer,doc="See `GetSpacer` and `AssignSpacer`")
UserData = property(GetUserData,SetUserData,doc="See `GetUserData` and `SetUserData`")
- Window = property(GetWindow,SetWindow,doc="See `GetWindow` and `SetWindow`")
+ Window = property(GetWindow,AssignWindow,doc="See `GetWindow` and `AssignWindow`")
_core_.SizerItem_swigregister(SizerItem)
def SizerItemWindow(*args, **kwargs):
"""
return _core_.Sizer_Add(*args, **kwargs)
+ def AddF(*args, **kwargs):
+ """
+ AddF(self, item, wx.SizerFlags flags) -> wx.SizerItem
+
+ Similar to `Add` but uses the `wx.SizerFlags` convenience class for
+ setting the various flags, options and borders.
+ """
+ return _core_.Sizer_AddF(*args, **kwargs)
+
def Insert(*args, **kwargs):
"""
Insert(self, int before, item, int proportion=0, int flag=0, int border=0,
"""
return _core_.Sizer_Insert(*args, **kwargs)
+ def InsertF(*args, **kwargs):
+ """
+ InsertF(self, int before, item, wx.SizerFlags flags) -> wx.SizerItem
+
+ Similar to `Insert`, but uses the `wx.SizerFlags` convenience class
+ for setting the various flags, options and borders.
+ """
+ return _core_.Sizer_InsertF(*args, **kwargs)
+
def Prepend(*args, **kwargs):
"""
Prepend(self, item, int proportion=0, int flag=0, int border=0,
"""
return _core_.Sizer_Prepend(*args, **kwargs)
+ def PrependF(*args, **kwargs):
+ """
+ PrependF(self, item, wx.SizerFlags flags) -> wx.SizerItem
+
+ Similar to `Prepend` but uses the `wx.SizerFlags` convenience class
+ for setting the various flags, options and borders.
+ """
+ return _core_.Sizer_PrependF(*args, **kwargs)
+
def Remove(*args, **kwargs):
"""
Remove(self, item) -> bool
def GetItem(*args, **kwargs):
"""
- GetItem(self, item) -> wx.SizerItem
+ GetItem(self, item, recursive=False) -> wx.SizerItem
Returns the `wx.SizerItem` which holds the *item* given. The *item*
parameter can be either a window, a sizer, or the zero-based index of
"""
if isinstance(olditem, wx.Window):
return self._ReplaceWin(olditem, item, recursive)
- elif isinstnace(olditem, wx.Sizer):
+ elif isinstance(olditem, wx.Sizer):
return self._ReplaceSizer(olditem, item, recursive)
- elif isinstnace(olditem, int):
+ elif isinstance(olditem, int):
return self._ReplaceItem(olditem, item)
else:
raise TypeError("Expected Window, Sizer, or integer for first parameter.")
class.
"""
_core_.PySizer_swiginit(self,_core_.new_PySizer(*args, **kwargs))
- self._setCallbackInfo(self, PySizer);self._setOORInfo(self)
+ self._setOORInfo(self);PySizer._setCallbackInfo(self, self, PySizer)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
"""
return _core_.BoxSizer_SetOrientation(*args, **kwargs)
+ def IsVertical(*args, **kwargs):
+ """IsVertical(self) -> bool"""
+ return _core_.BoxSizer_IsVertical(*args, **kwargs)
+
Orientation = property(GetOrientation,SetOrientation,doc="See `GetOrientation` and `SetOrientation`")
_core_.BoxSizer_swigregister(BoxSizer)
"""
return _core_.GridBagSizer_FindItem(*args)
+ def GetItem(self, item):
+ gbsi = None
+ si = wx.FlexGridSizer.GetItem(self, item)
+ if not si:
+ return None
+ if type(item) is not int:
+ gbsi = self.FindItem(item)
+ if gbsi: return gbsi
+ return si
+
def FindItemAtPosition(*args, **kwargs):
"""
FindItemAtPosition(self, GBPosition pos) -> GBSizerItem
import warnings
warnings.warn("wxPython/wxWidgets release number mismatch")
+
+def version():
+ """Returns a string containing version and port info"""
+ ctype = wx.USE_UNICODE and 'unicode' or 'ansi'
+ if wx.Platform == '__WXMSW__':
+ port = 'msw'
+ elif wx.Platform == '__WXMAC__':
+ port = 'mac'
+ elif wx.Platform == '__WXGTK__':
+ port = 'gtk'
+ if 'gtk2' in wx.PlatformInfo:
+ port = 'gtk2'
+ else:
+ port = '?'
+
+ return "%s (%s-%s)" % (wx.VERSION_STRING, port, ctype)
+
+
#----------------------------------------------------------------------------
# Set wxPython's default string<-->unicode conversion encoding from
import locale
import codecs
try:
- default = locale.getdefaultlocale()[1]
+ if hasattr(locale, 'getpreferredencoding'):
+ default = locale.getpreferredencoding()
+ else:
+ default = locale.getdefaultlocale()[1]
codecs.lookup(default)
except (ValueError, LookupError, TypeError):
default = _sys.getdefaultencoding()
method calls from non-GUI threads. Any extra positional or
keyword args are passed on to the callable when it is called.
- :see: `wx.FutureCall`
+ :see: `wx.CallLater`
"""
app = wx.GetApp()
assert app is not None, 'No wx.App created yet'
#----------------------------------------------------------------------------
-class FutureCall:
+class CallLater:
"""
A convenience class for `wx.Timer`, that calls the given callable
object once after the given amount of milliseconds, passing any
then there is no need to hold a reference to this object. It will
hold a reference to itself while the timer is running (the timer
has a reference to self.Notify) but the cycle will be broken when
- the timer completes, automatically cleaning up the wx.FutureCall
+ the timer completes, automatically cleaning up the wx.CallLater
object.
:see: `wx.CallAfter`
Result = property(GetResult)
+class FutureCall(CallLater):
+ """A compatibility alias for `CallLater`."""
+
#----------------------------------------------------------------------------
# Control which items in this module should be documented by epydoc.
# We allow only classes and functions, which will help reduce the size
projects / wxWidgets.git / blobdiff