import sys as _sys
wx = _sys.modules[__name__]
+
+#----------------------------------------------------------------------------
+
+def _deprecated(callable, msg=None):
+ """
+ Create a wrapper function that will raise a DeprecationWarning
+ before calling the callable.
+ """
+ if msg is None:
+ msg = "%s is deprecated" % callable
+ def deprecatedWrapper(*args, **kwargs):
+ import warnings
+ warnings.warn(msg, DeprecationWarning, stacklevel=2)
+ return callable(*args, **kwargs)
+ deprecatedWrapper.__doc__ = msg
+ return deprecatedWrapper
+
+
+#----------------------------------------------------------------------------
+
NOT_FOUND = _core_.NOT_FOUND
VSCROLL = _core_.VSCROLL
HSCROLL = _core_.HSCROLL
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,)
"""
SetDefaults(self, Size size)
- Combine this size with the other one replacing the default
- components of this object (i.e. equal to -1) with those of the
- other.
+ Combine this size with the other one replacing the default components
+ of this object (i.e. equal to -1) with those of the other.
"""
return _core_.Size_SetDefaults(*args, **kwargs)
"""
return _core_.Size_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Size'+str(self.Get())
def __len__(self): return len(self.Get())
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,)
"""
return _core_.RealPoint_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.RealPoint'+str(self.Get())
def __len__(self): return len(self.Get())
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,)
"""
return _core_.Point_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Point'+str(self.Get())
def __len__(self): return len(self.Get())
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,)
"""
Inflate(self, 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)
"""
Deflate(self, 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)
"""
OffsetXY(self, 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)
"""
return _core_.Rect_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Rect'+str(self.Get())
def __len__(self): return len(self.Get())
#---------------------------------------------------------------------------
class Point2D(object):
- """wx.Point2Ds represent a point or a vector in a 2d coordinate system with floating point values."""
+ """
+ wx.Point2Ds represent a point or a vector in a 2d coordinate system
+ with floating point values.
+ """
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):
self.thisown = 1
del newobj.thisown
def GetFloor(*args, **kwargs):
- """
- GetFloor() -> (x,y)
-
- Convert to integer
- """
+ """GetFloor() -> (x,y)"""
return _core_.Point2D_GetFloor(*args, **kwargs)
def GetRounded(*args, **kwargs):
- """
- GetRounded() -> (x,y)
-
- Convert to integer
- """
+ """GetRounded() -> (x,y)"""
return _core_.Point2D_GetRounded(*args, **kwargs)
def GetVectorLength(*args, **kwargs):
"""
return _core_.Point2D_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Point2D'+str(self.Get())
def __len__(self): return len(self.Get())
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(String filename) -> String"""
+ """FileNameToURL(String filename) -> String"""
return _core_.FileSystem_FileNameToURL(*args, **kwargs)
FileNameToURL = staticmethod(FileNameToURL)
self.thisown = 1
del newobj.thisown
def RemoveFile(*args, **kwargs):
- """MemoryFSHandler.RemoveFile(String filename)"""
+ """RemoveFile(String filename)"""
return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
RemoveFile = staticmethod(RemoveFile)
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
"""
MakeKey = staticmethod(MakeKey)
def FindFirstUnusedColour(*args, **kwargs):
- """
- 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.
- """
+ """FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)"""
return _core_.ImageHistogram_FindFirstUnusedColour(*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)
-
- 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.
- """
+ """FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)"""
return _core_.Image_FindFirstUnusedColour(*args, **kwargs)
def SetMaskFromImage(*args, **kwargs):
return _core_.Image_SetMaskFromImage(*args, **kwargs)
def CanRead(*args, **kwargs):
- """Image.CanRead(String name) -> bool"""
+ """CanRead(String name) -> bool"""
return _core_.Image_CanRead(*args, **kwargs)
CanRead = staticmethod(CanRead)
def GetImageCount(*args, **kwargs):
- """Image.GetImageCount(String 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)
return _core_.Image_SaveMimeFile(*args, **kwargs)
def CanReadStream(*args, **kwargs):
- """Image.CanReadStream(InputStream stream) -> bool"""
+ """CanReadStream(InputStream stream) -> bool"""
return _core_.Image_CanReadStream(*args, **kwargs)
CanReadStream = staticmethod(CanReadStream)
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(String name) -> bool"""
+ """RemoveHandler(String name) -> bool"""
return _core_.Image_RemoveHandler(*args, **kwargs)
RemoveHandler = staticmethod(RemoveHandler)
def GetImageExtWildcard(*args, **kwargs):
- """Image.GetImageExtWildcard() -> String"""
+ """GetImageExtWildcard() -> String"""
return _core_.Image_GetImageExtWildcard(*args, **kwargs)
GetImageExtWildcard = staticmethod(GetImageExtWildcard)
val.thisown = 1
return val
-def EmptyImage(*args):
- """
- EmptyImage(int width=0, int height=0, bool clear=True) -> Image
- EmptyImage(Size size, bool clear=True) -> Image
- """
- val = _core_.new_EmptyImage(*args)
+def EmptyImage(*args, **kwargs):
+ """EmptyImage(int width=0, int height=0, bool clear=True) -> Image"""
+ val = _core_.new_EmptyImage(*args, **kwargs)
val.thisown = 1
return val
"""
Bind an event to an event handler.
- event One of the EVT_* objects that specifies the
- type of event to bind,
+ :param event: One of the EVT_* objects that specifies the
+ type of event to bind,
+
+ :param handler: A callable object to be invoked when the
+ event is delivered to self. Pass None to
+ disconnect an event handler.
- handler A callable object to be invoked when the event
- is delivered to self. Pass None to disconnect an
- event handler.
+ :param source: Sometimes the event originates from a
+ different window than self, but you still
+ want to catch it in self. (For example, a
+ button event delivered to a frame.) By
+ passing the source of the event, the event
+ handling system is able to differentiate
+ between the same event type from different
+ controls.
- source Sometimes the event originates from a different window
- than self, but you still want to catch it in self. (For
- example, a button event delivered to a frame.) By
- passing the source of the event, the event handling
- system is able to differentiate between the same event
- type from different controls.
+ :param id: Used to spcify the event source by ID instead
+ of instance.
- id,id2 Used for menu IDs or for event types that require a
- range of IDs
+ :param id2: Used when it is desirable to bind a handler
+ to a range of IDs, such as with EVT_MENU_RANGE.
"""
if source is not None:
id = source.GetId()
event.Bind(self, id, id2, handler)
+ def Unbind(self, event, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
+ """
+ Disconencts the event handler binding for event from self.
+ Returns True if successful.
+ """
+ if source is not None:
+ id = source.GetId()
+ return event.Unbind(self, id, id2)
class EvtHandlerPtr(EvtHandler):
for et in self.evtType:
target.Connect(id1, id2, et, function)
+
+ def Unbind(self, target, id1, id2):
+ """Remove an event binding."""
+ success = 0
+ for et in self.evtType:
+ success += target.Disconnect(id1, id2, et)
+ return success != 0
+
def __call__(self, *args):
"""
"""
GetPosition(self) -> 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)
"""
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)
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(int mode)"""
+ """SetMode(int mode)"""
return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """UpdateUIEvent.GetMode() -> int"""
+ """GetMode() -> int"""
return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
return _core_.IdleEvent_MoreRequested(*args, **kwargs)
def SetMode(*args, **kwargs):
- """IdleEvent.SetMode(int mode)"""
+ """SetMode(int mode)"""
return _core_.IdleEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """IdleEvent.GetMode() -> int"""
+ """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)
PRINT_WINDOWS = _core_.PRINT_WINDOWS
PRINT_POSTSCRIPT = _core_.PRINT_POSTSCRIPT
class PyApp(EvtHandler):
+ """
+ The ``wx.PyApp`` class is an *implementation detail*, please use the
+ `wx.App` class (or some other derived class) instead.
+ """
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):
"""
SetAppName(self, String name)
- Set the application name. This value may be used automatically
- by wx.Config and such.
+ Set the application name. This value may be used automatically by
+ `wx.Config` and such.
"""
return _core_.PyApp_SetAppName(*args, **kwargs)
"""
SetClassName(self, String name)
- Set the application's class name. This value may be used for X-resources if
- applicable for the platform
+ 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)
"""
SetVendorName(self, String name)
- Set the application's vendor name. This value may be used automatically
- by wx.Config and such.
+ Set the application's vendor name. This value may be used
+ automatically by `wx.Config` and such.
"""
return _core_.PyApp_SetVendorName(*args, **kwargs)
"""
GetTraits(self) -> 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 (and create if necessary) 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.
+
+ :todo: Add support for overriding CreateAppTraits in wxPython.
"""
return _core_.PyApp_GetTraits(*args, **kwargs)
"""
ProcessPendingEvents(self)
- 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.
+ Process all events in the Pending Events list -- it is necessary to
+ call this function to process posted events. This normally happens
+ during each event loop iteration.
"""
return _core_.PyApp_ProcessPendingEvents(*args, **kwargs)
"""
Yield(self, 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.
+ 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!
- 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!
+ :see: `wx.Yield`, `wx.YieldIfNeeded`, `wx.SafeYield`
"""
return _core_.PyApp_Yield(*args, **kwargs)
"""
WakeUpIdle(self)
- Make sure that idle events are sent again
+ Make sure that idle events are sent again.
+ :see: `wx.WakeUpIdle`
"""
return _core_.PyApp_WakeUpIdle(*args, **kwargs)
"""
MainLoop(self) -> int
- Execute the main GUI loop, the function returns when the loop ends.
+ Execute the main GUI loop, the function doesn't normally return until
+ all top level windows have been closed and destroyed.
"""
return _core_.PyApp_MainLoop(*args, **kwargs)
Exit(self)
Exit the main loop thus terminating the application.
+ :see: `wx.Exit`
"""
return _core_.PyApp_Exit(*args, **kwargs)
"""
ExitMainLoop(self)
- Exit the main GUI loop during the next iteration (i.e. it does not
- stop the program immediately!)
+ Exit the main GUI loop during the next iteration of the main
+ loop, (i.e. it does not stop the program immediately!)
"""
return _core_.PyApp_ExitMainLoop(*args, **kwargs)
"""
ProcessIdle(self) -> 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.
+ Called from the MainLoop when the application becomes idle (there are
+ no pending events) and sends a `wx.IdleEvent` to all interested
+ parties. Returns True if more idle events are needed, False if not.
"""
return _core_.PyApp_ProcessIdle(*args, **kwargs)
"""
SendIdleEvents(self, Window win, IdleEvent event) -> bool
- Send idle event to window and all subwindows. Returns True if more idle time
- is requested.
+ Send idle event to window and all subwindows. Returns True if more
+ idle time is requested.
"""
return _core_.PyApp_SendIdleEvents(*args, **kwargs)
"""
SetTopWindow(self, Window win)
- Set the "main" top level window
+ Set the *main* top level window
"""
return _core_.PyApp_SetTopWindow(*args, **kwargs)
"""
GetTopWindow(self) -> 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 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)
"""
SetExitOnFrameDelete(self, 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.
-
+ 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)
"""
SetUseBestVisual(self, 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.)
+ 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)
"""
SetAssertMode(self, 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
-
+ Set the OnAssert behaviour for debug and hybrid builds.
"""
return _core_.PyApp_SetAssertMode(*args, **kwargs)
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() -> String"""
+ """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(String val)"""
+ """SetMacHelpMenuTitleName(String val)"""
return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
def GetComCtl32Version(*args, **kwargs):
"""
- PyApp.GetComCtl32Version() -> int
+ GetComCtl32Version() -> int
- Returns 400, 470, 471, etc. 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.
+ Returns 400, 470, 471, etc. 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)
"""
PyApp_GetComCtl32Version() -> int
- Returns 400, 470, 471, etc. 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.
+ Returns 400, 470, 471, etc. 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)
"""
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.
+ 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.
+ :Returns: the result of the call to `wx.Yield`.
"""
return _core_.SafeYield(*args, **kwargs)
"""
WakeUpIdle()
- Cause the message queue to become empty again, so idle events will be sent.
+ Cause the message queue to become empty again, so idle events will be
+ sent.
"""
return _core_.WakeUpIdle(*args, **kwargs)
"""
PostEvent(EvtHandler dest, Event event)
- Send an event to a window or other wx.EvtHandler to be processed later.
+ Send an event to a window or other wx.EvtHandler to be processed
+ later.
"""
return _core_.PostEvent(*args, **kwargs)
"""
App_CleanUp()
- For internal use only, it is used to cleanup after wxWindows when Python shuts down.
+ For internal use only, it is used to cleanup after wxWidgets when
+ Python shuts down.
"""
return _core_.App_CleanUp(*args, **kwargs)
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)
+ The ``wx.App`` class represents the application and is used to:
+
+ * bootstrap the wxPython system and initialize the underlying
+ gui toolkit
+ * set and get application-wide properties
+ * implement the windowing system main message or event loop,
+ and to dispatch events to window instances
+ * etc.
+
+ Every application must have a ``wx.App`` instance, and all
+ creation of UI objects should be delayed until after the
+ ``wx.App`` object has been created in order to ensure that the gui
+ platform and wxWidgets have been fully initialized.
+
+ Normally you would derive from this class and implement an
+ ``OnInit`` method that creates a frame and then calls
+ ``self.SetTopWindow(frame)``.
+
+ :see: `wx.PySimpleApp` for a simpler app class that can be used
+ directly.
"""
+
outputWindowClass = PyOnDemandOutputWindow
- def __init__(self, redirect=_defRedirect, filename=None, useBestVisual=False):
+ def __init__(self, redirect=_defRedirect, filename=None,
+ useBestVisual=False, clearSigInt=True):
+ """
+ Construct a ``wx.App`` object.
+
+ :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
+ 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
+ class of your choosing.)
+
+ :param filename: The name of a file to redirect output to, if
+ redirect is True.
+
+ :param useBestVisual: Should the app try to use the best
+ available visual provided by the system (only relevant on
+ systems that have more than one visual.) This parameter
+ must be used instead of calling `SetUseBestVisual` later
+ on because it must be set before the underlying GUI
+ toolkit is initialized.
+
+ :param clearSigInt: Should SIGINT be cleared? This allows the
+ app to terminate upon a Ctrl-C in the console like other
+ GUI apps will.
+
+ :note: You should override OnInit to do applicaition
+ initialization to ensure that the system, toolkit and
+ wxWidgets are fully initialized.
+ """
wx.PyApp.__init__(self)
if wx.Platform == "__WXMAC__":
not 'python', and only when you are logged in on the main display of
your Mac."""
_sys.exit(1)
+ except SystemExit:
+ raise
except:
pass
# KeyboardInterrupt???) but will later segfault on exit. By
# setting the default handler then the app will exit, as
# expected (depending on platform.)
- try:
- import signal
- signal.signal(signal.SIGINT, signal.SIG_DFL)
- except:
- pass
+ if clearSigInt:
+ try:
+ import signal
+ signal.signal(signal.SIGINT, signal.SIG_DFL)
+ except:
+ pass
# Save and redirect the stdio to a window?
self.stdioWin = None
-# change from wxPyApp_ to wxApp_
+# change from wx.PyApp_XX to wx.App_XX
App_GetMacSupportPCMenuShortcuts = _core_.PyApp_GetMacSupportPCMenuShortcuts
App_GetMacAboutMenuItemId = _core_.PyApp_GetMacAboutMenuItemId
App_GetMacPreferencesMenuItemId = _core_.PyApp_GetMacPreferencesMenuItemId
"""
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."""
+ about OnInit. For example::
+
+ app = wx.PySimpleApp()
+ frame = wx.Frame(None, title='Hello World')
+ frame.Show()
+ app.MainLoop()
- def __init__(self, redirect=False, filename=None, useBestVisual=False):
- wx.App.__init__(self, redirect, filename, useBestVisual)
+ :see: `wx.App`
+ """
+
+ def __init__(self, redirect=False, filename=None,
+ useBestVisual=False, clearSigInt=True):
+ """
+ :see: `wx.App.__init__`
+ """
+ wx.App.__init__(self, redirect, filename, useBestVisual, clearSigInt)
def OnInit(self):
wx.InitAllImageHandlers()
return True
+
# Is anybody using this one?
class PyWidgetTester(wx.App):
def __init__(self, size = (250, 100)):
self.SetTopWindow(self.frame)
return True
- def SetWidget(self, widgetClass, *args):
- w = widgetClass(self.frame, *args)
+ def SetWidget(self, widgetClass, *args, **kwargs):
+ w = widgetClass(self.frame, *args, **kwargs)
self.frame.Show(True)
#----------------------------------------------------------------------------
# DO NOT hold any other references to this object. This is how we
-# know when to cleanup system resources that wxWin is holding. When
+# know when to cleanup system resources that wxWidgets is holding. When
# the sys module is unloaded, the refcount on sys.__wxPythonCleanup
-# goes to zero and it calls the wxApp_CleanUp function.
+# goes to zero and it calls the wx.App_CleanUp function.
class __wxPyCleanup:
def __init__(self):
_sys.__wxPythonCleanup = __wxPyCleanup()
## # another possible solution, but it gets called too early...
-## if sys.version[0] == '2':
-## import atexit
-## atexit.register(_core_.wxApp_CleanUp)
-## else:
-## sys.exitfunc = _core_.wxApp_CleanUp
+## import atexit
+## atexit.register(_core_.wxApp_CleanUp)
#----------------------------------------------------------------------------
#---------------------------------------------------------------------------
class AcceleratorEntry(object):
+ """
+ A class used to define items in an `wx.AcceleratorTable`. wxPython
+ programs can choose to use wx.AcceleratorEntry objects, but using a
+ list of 3-tuple of integers (flags, keyCode, cmdID) usually works just
+ as well. See `__init__` for of the tuple values.
+
+ :see: `wx.AcceleratorTable`
+ """
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__(self, int flags=0, int keyCode=0, int cmd=0, MenuItem item=None) -> AcceleratorEntry"""
+ """
+ __init__(self, int flags=0, int keyCode=0, int cmdID=0) -> AcceleratorEntry
+
+ Construct a wx.AcceleratorEntry.
+ """
newobj = _core_.new_AcceleratorEntry(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def Set(*args, **kwargs):
- """Set(self, int flags, int keyCode, int cmd, MenuItem item=None)"""
- return _core_.AcceleratorEntry_Set(*args, **kwargs)
-
- def SetMenuItem(*args, **kwargs):
- """SetMenuItem(self, MenuItem item)"""
- return _core_.AcceleratorEntry_SetMenuItem(*args, **kwargs)
+ """
+ Set(self, int flags, int keyCode, int cmd)
- def GetMenuItem(*args, **kwargs):
- """GetMenuItem(self) -> MenuItem"""
- return _core_.AcceleratorEntry_GetMenuItem(*args, **kwargs)
+ (Re)set the attributes of a wx.AcceleratorEntry.
+ :see `__init__`
+ """
+ return _core_.AcceleratorEntry_Set(*args, **kwargs)
def GetFlags(*args, **kwargs):
- """GetFlags(self) -> int"""
+ """
+ GetFlags(self) -> int
+
+ Get the AcceleratorEntry's flags.
+ """
return _core_.AcceleratorEntry_GetFlags(*args, **kwargs)
def GetKeyCode(*args, **kwargs):
- """GetKeyCode(self) -> int"""
+ """
+ GetKeyCode(self) -> int
+
+ Get the AcceleratorEntry's keycode.
+ """
return _core_.AcceleratorEntry_GetKeyCode(*args, **kwargs)
def GetCommand(*args, **kwargs):
- """GetCommand(self) -> int"""
+ """
+ GetCommand(self) -> int
+
+ Get the AcceleratorEntry's command ID.
+ """
return _core_.AcceleratorEntry_GetCommand(*args, **kwargs)
_core_.AcceleratorEntry_swigregister(AcceleratorEntryPtr)
class AcceleratorTable(Object):
+ """
+ An accelerator table allows the application to specify a table of
+ keyboard shortcuts for menus or other commands. On Windows, menu or
+ button commands are supported; on GTK, only menu commands are
+ supported.
+ """
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)
+ Construct an AcceleratorTable from a list of `wx.AcceleratorEntry`
+ items or or of 3-tuples (flags, keyCode, cmdID)
+
+ :see: `wx.AcceleratorEntry`
"""
newobj = _core_.new_AcceleratorTable(*args, **kwargs)
self.this = newobj.this
tries to close the window. It doesn't close the window itself,
however. If force is False (the default) then the window's close
handler will be allowed to veto the destruction of the window.
-
- Usually Close is only used with the top level windows (wx.Frame and
- wx.Dialog classes) as the others are not supposed to have any special
- EVT_CLOSE logic.
-
- The close handler should check whether the window is being deleted
- forcibly, using wx.CloseEvent.GetForce, in which case it should
- destroy the window using wx.Window.Destroy.
-
- Note that calling Close does not guarantee that the window will be
- destroyed; but it provides a way to simulate a manual close of a
- window, which may or may not be implemented by destroying the
- window. The default EVT_CLOSE handler for wx.Dialog does not
- necessarily delete the dialog, since it will simply simulate an
- wxID_CANCEL event which is handled by the appropriate button event
- handler and may do anything at all.
-
- To guarantee that the window will be destroyed, call wx.Window.Destroy
- instead.
"""
return _core_.Window_Close(*args, **kwargs)
"""
DestroyChildren(self) -> bool
- Destroys all children of a window. Called automatically by the destructor.
+ Destroys all children of a window. Called automatically by the
+ destructor.
"""
return _core_.Window_DestroyChildren(*args, **kwargs)
"""
GetLabel(self) -> String
- Generic way of getting a label from any window, for
- identification purposes. The interpretation of this function
- differs from class to class. For frames and dialogs, the value
- returned is the title. For buttons or static text controls, it is
- the button text. This function can be useful for meta-programs
- such as testing tools or special-needs access programs)which
- need to identify windows by name.
+ Generic way of getting a label from any window, for identification
+ purposes. The interpretation of this function differs from class to
+ class. For frames and dialogs, the value returned is the title. For
+ buttons or static text controls, it is the button text. This function
+ can be useful for meta-programs such as testing tools or special-needs
+ access programs)which need to identify windows by name.
"""
return _core_.Window_GetLabel(*args, **kwargs)
"""
SetName(self, String name)
- Sets the window's name. The window name is used for ressource
- setting in X, it is not the same as the window title/label
+ Sets the window's name. The window name is used for ressource setting
+ in X, it is not the same as the window title/label
"""
return _core_.Window_SetName(*args, **kwargs)
"""
GetName(self) -> String
- Returns the windows name. This name is not guaranteed to be
- unique; it is up to the programmer to supply an appropriate name
- in the window constructor or via wx.Window.SetName.
+ Returns the windows name. This name is not guaranteed to be unique;
+ it is up to the programmer to supply an appropriate name in the window
+ constructor or via wx.Window.SetName.
"""
return _core_.Window_GetName(*args, **kwargs)
"""
SetWindowVariant(self, int variant)
- Sets the variant of the window/font size to use for this window,
- if the platform supports variants, for example, wxMac. Variant values are:
-
- wx.WINDOW_VARIANT_NORMAL Normal size
- wx.WINDOW_VARIANT_SMALL Smaller size (about 25 % smaller than normal)
- wx.WINDOW_VARIANT_MINI Mini size (about 33 % smaller than normal)
- wx.WINDOW_VARIANT_LARGE Large size (about 25 % larger than normal)
-
+ Sets the variant of the window/font size to use for this window, if
+ the platform supports variants, for example, wxMac.
"""
return _core_.Window_SetWindowVariant(*args, **kwargs)
def NewControlId(*args, **kwargs):
"""
- Window.NewControlId() -> int
+ NewControlId() -> int
Generate a control id for the controls which were not given one.
"""
NewControlId = staticmethod(NewControlId)
def NextControlId(*args, **kwargs):
"""
- Window.NextControlId(int winid) -> int
+ NextControlId(int winid) -> int
Get the id of the control following the one with the given
- (autogenerated) id
+ autogenerated) id
"""
return _core_.Window_NextControlId(*args, **kwargs)
NextControlId = staticmethod(NextControlId)
def PrevControlId(*args, **kwargs):
"""
- Window.PrevControlId(int winid) -> int
+ PrevControlId(int winid) -> int
Get the id of the control preceding the one with the given
- (autogenerated) id
+ autogenerated) id
"""
return _core_.Window_PrevControlId(*args, **kwargs)
GetBestSize(self) -> Size
This functions returns the best acceptable minimal size for the
- window, if applicable. For example, for a static text control, it will be
- the minimal size such that the control label is not truncated. For
- windows containing subwindows (suzh aswx.Panel), the size returned
- by this function will be the same as the size the window would have
- had after calling Fit.
+ window, if applicable. For example, for a static text control, it will
+ be the minimal size such that the control label is not truncated. For
+ windows containing subwindows (suzh aswx.Panel), the size returned by
+ this function will be the same as the size the window would have had
+ after calling Fit.
"""
return _core_.Window_GetBestSize(*args, **kwargs)
GetBestSizeTuple() -> (width, height)
This functions returns the best acceptable minimal size for the
- window, if applicable. For example, for a static text control, it will be
- the minimal size such that the control label is not truncated. For
- windows containing subwindows (suzh aswx.Panel), the size returned
- by this function will be the same as the size the window would have
- had after calling Fit.
+ window, if applicable. For example, for a static text control, it will
+ be the minimal size such that the control label is not truncated. For
+ windows containing subwindows (suzh aswx.Panel), the size returned by
+ this function will be the same as the size the window would have had
+ after calling Fit.
"""
return _core_.Window_GetBestSizeTuple(*args, **kwargs)
"""
SetWindowStyleFlag(self, long style)
- Sets the style of the window. Please note that some styles cannot
- be changed after the window creation and that Refresh() might
- need to be called after changing the others for the change to
- take place immediately.
+ Sets the style of the window. Please note that some styles cannot be
+ changed after the window creation and that Refresh() might need to be
+ called after changing the others for the change to take place
+ immediately.
"""
return _core_.Window_SetWindowStyleFlag(*args, **kwargs)
def FindFocus(*args, **kwargs):
"""
- Window.FindFocus() -> Window
+ FindFocus() -> Window
Returns the window or control that currently has the keyboard focus,
or None.
"""
GetGrandParent(self) -> Window
- Returns the parent of the parent of this window, or None if there isn't one.
+ Returns the parent of the parent of this window, or None if there
+ isn't one.
"""
return _core_.Window_GetGrandParent(*args, **kwargs)
substitute another, for example to allow central implementation of
event-handling for a variety of different window classes.
- It is usually better to use wx.Window.PushEventHandler since this sets
+ It is usually better to use `wx.Window.PushEventHandler` since this sets
up a chain of event handlers, where an event not handled by one event
handler is handed to the next one in the chain.
"""
wx.Window.PushEventHandler allows an application to set up a chain of
event handlers, where an event not handled by one event handler is
- handed to the next one in the chain. Use wx.Window.PopEventHandler to
+ handed to the next one in the chain. Use `wx.Window.PopEventHandler` to
remove the event handler.
"""
return _core_.Window_PushEventHandler(*args, **kwargs)
"""
RemoveEventHandler(self, EvtHandler handler) -> bool
- Find the given handler in the event handler chain and remove (but
- not delete) it from the event handler chain, return True if it was
- found and False otherwise (this also results in an assert failure so
- this function should only be called when the handler is supposed to
- be there.)
+ Find the given handler in the event handler chain and remove (but not
+ delete) it from the event handler chain, return True if it was found
+ and False otherwise (this also results in an assert failure so this
+ function should only be called when the handler is supposed to be
+ there.)
"""
return _core_.Window_RemoveEventHandler(*args, **kwargs)
Validate(self) -> bool
Validates the current values of the child controls using their
- validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY
- extra style flag set, the method will also call Validate() of all
- child windows. Returns false if any of the validations failed.
+ validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
+ style flag set, the method will also call Validate() of all child
+ windows. Returns false if any of the validations failed.
"""
return _core_.Window_Validate(*args, **kwargs)
"""
TransferDataToWindow(self) -> bool
- Transfers values to child controls from data areas specified by
- their validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY
- extra style flag set, the method will also call
- TransferDataToWindow() of all child windows.
+ Transfers values to child controls from data areas specified by their
+ validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
+ style flag set, the method will also call TransferDataToWindow() of
+ all child windows.
"""
return _core_.Window_TransferDataToWindow(*args, **kwargs)
"""
TransferDataFromWindow(self) -> bool
- Transfers values from child controls to data areas specified by
- their validators. Returns false if a transfer failed. If the
- window has wx.WS_EX_VALIDATE_RECURSIVELY extra style flag set, the
- method will also call TransferDataFromWindow() of all child
- windows.
+ Transfers values from child controls to data areas specified by their
+ validators. Returns false if a transfer failed. If the window has
+ wx.WS_EX_VALIDATE_RECURSIVELY extra style flag set, the method will
+ also call TransferDataFromWindow() of all child windows.
"""
return _core_.Window_TransferDataFromWindow(*args, **kwargs)
"""
InitDialog(self)
- Sends an EVT_INIT_DIALOG event, whose handler usually transfers
- data to the dialog via validators.
+ Sends an EVT_INIT_DIALOG event, whose handler usually transfers data
+ to the dialog via validators.
"""
return _core_.Window_InitDialog(*args, **kwargs)
def GetCapture(*args, **kwargs):
"""
- Window.GetCapture() -> Window
+ GetCapture() -> Window
Returns the window which currently captures the mouse or None
"""
"""
Freeze(self)
- Freezes the window or, in other words, prevents any updates from taking place
- on screen, the window is not redrawn at all. Thaw must be called to reenable
- window redrawing. Calls to Freeze/Thaw may be nested, with the actual Thaw
- being delayed until all the nesting has been undone.
+ Freezes the window or, in other words, prevents any updates from
+ taking place on screen, the window is not redrawn at all. Thaw must be
+ called to reenable window redrawing. Calls to Freeze/Thaw may be
+ nested, with the actual Thaw being delayed until all the nesting has
+ been undone.
This method is useful for visual appearance optimization (for example,
it is a good idea to use it before inserting large amount of text into
Thaw(self)
Reenables window updating after a previous call to Freeze. Calls to
- Freeze/Thaw may be nested, so Thaw must be called the same number of times
- that Freeze was before the window will be updated.
+ Freeze/Thaw may be nested, so Thaw must be called the same number of
+ times that Freeze was before the window will be updated.
"""
return _core_.Window_Thaw(*args, **kwargs)
"""
GetDefaultAttributes(self) -> VisualAttributes
- Get the default attributes for an instance of this class. This
- is useful if you want to use the same font or colour in your own
- control as in a standard control -- which is a much better idea
- than hard coding specific colours or fonts which might look
- completely out of place on the users system, especially if it
- uses themes.
+ Get the default attributes for an instance of this class. This is
+ useful if you want to use the same font or colour in your own control
+ as in a standard control -- which is a much better idea than hard
+ coding specific colours or fonts which might look completely out of
+ place on the user's system, especially if it uses themes.
"""
return _core_.Window_GetDefaultAttributes(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
- Window.GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
+ GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
- Get the default attributes for this class. This is useful if
- you want to use the same font or colour in your own control as
- in a standard control -- which is a much better idea than hard
- coding specific colours or fonts which might look completely out
- of place on the users system, especially if it uses themes.
+ Get the default attributes for this class. This is useful if you want
+ to use the same font or colour in your own control as in a standard
+ control -- which is a much better idea than hard coding specific
+ colours or fonts which might look completely out of place on the
+ user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
- ignore under other platforms. Under Mac, it will change the size of the
- returned font. See SetWindowVariant for more about this.
+ ignore under other platforms. Under Mac, it will change the size of
+ the returned font. See `wx.Window.SetWindowVariant` for more about
+ this.
"""
return _core_.Window_GetClassDefaultAttributes(*args, **kwargs)
EVT_ERASE_BACKGROUND event handler function under Windows and
automatically under GTK.
- Note that setting the background colour does not cause an immediate
+ Note that setting the background colour may not cause an immediate
refresh, so you may wish to call ClearBackground or Refresh after
calling this function.
return _core_.Window_GetCharWidth(*args, **kwargs)
def GetTextExtent(*args, **kwargs):
- """
- GetTextExtent(String string) -> (width, height)
-
- Get the width and height of the text using the current font.
- """
+ """GetTextExtent(String string) -> (width, height)"""
return _core_.Window_GetTextExtent(*args, **kwargs)
def GetFullTextExtent(*args, **kwargs):
wx.UpdateUIEvent.SetMode or wx.UpdateUIEvent.SetUpdateInterval to
limit the overhead that wxWindows incurs by sending update UI events
in idle time.
-
- The flags should be a bitlist of one or more of the following values:
-
- wx.UPDATE_UI_NONE No particular value
- wx.UPDATE_UI_RECURSE Call the function for descendants
- wx.UPDATE_UI_FROMIDLE Invoked from OnIdle
-
- If you are calling this function from an OnIdle function, make sure
- you pass the wx.UPDATE_UI_FROMIDLE flag, since this tells the window to
- only update the UI elements that need to be updated in idle time. Some
- windows update their elements only when necessary, for example when a
- menu is about to be shown. The following is an example of how to call
- UpdateWindowUI from an idle function.
-
- def OnIdle(self, evt):
- if wx.UpdateUIEvent.CanUpdate(self):
- self.UpdateWindowUI(wx.UPDATE_UI_FROMIDLE);
-
"""
return _core_.Window_UpdateWindowUI(*args, **kwargs)
def SetScrollbar(*args, **kwargs):
"""
- SetScrollbar(self, int orientation, int pos, int thumbvisible, int range,
+ SetScrollbar(self, int orientation, int position, int thumbSize, int range,
bool refresh=True)
Sets the scrollbar properties of a built-in scrollbar.
-
- orientation: Determines the scrollbar whose page size is to be
- set. May be wx.HORIZONTAL or wx.VERTICAL.
-
- position: The position of the scrollbar in scroll units.
-
- thumbSize: The size of the thumb, or visible portion of the
- scrollbar, in scroll units.
-
- range: The maximum position of the scrollbar.
-
- refresh: True to redraw the scrollbar, false otherwise.
"""
return _core_.Window_SetScrollbar(*args, **kwargs)
accordingly. Use this function to optimise your scrolling
implementations, to minimise the area that must be redrawn. Note that
it is rarely required to call this function from a user program.
-
- dx: Amount to scroll horizontally.
-
- dy: Amount to scroll vertically.
-
- rect: Rectangle to invalidate. If this is None, the whole window
- is invalidated. If you pass a rectangle corresponding to the
- area of the window exposed by the scroll, your painting
- handler can optimize painting by checking for the
- invalidated region.
"""
return _core_.Window_ScrollWindow(*args, **kwargs)
"""
ScrollPages(self, int pages) -> bool
- If the platform and window class supports it, scrolls the window by
+ If the platform and window class supports it, scrolls the window by
the given number of pages down, if pages is positive, or up if pages
is negative. Returns True if the window was scrolled, False if it was
already on top/bottom and nothing was done.
"""
InheritAttributes(self)
- This function is (or should be, in case of custom controls)
- called during window creation to intelligently set up the window
- visual attributes, that is the font and the foreground and
- background colours.
-
- By 'intelligently' the following is meant: by default, all
- windows use their own default attributes. However if some of the
- parent's attributes are explicitly changed (that is, using
- SetFont and not SetDefaultFont) and if the corresponding
- attribute hadn't been explicitly set for this window itself, then
- this window takes the same value as used by the parent. In
- addition, if the window overrides ShouldInheritColours to return
- false, the colours will not be changed no matter what and only
- the font might.
-
- This rather complicated logic is necessary in order to accomodate
- the different usage scenarius. The most common one is when all
- default attributes are used and in this case, nothing should be
- inherited as in modern GUIs different controls use different
- fonts (and colours) than their siblings so they can't inherit the
- same value from the parent. However it was also deemed desirable
- to allow to simply change the attributes of all children at once
- by just changing the font or colour of their common parent, hence
- in this case we do inherit the parents attributes.
+ This function is (or should be, in case of custom controls) called
+ during window creation to intelligently set up the window visual
+ attributes, that is the font and the foreground and background
+ colours.
+
+ By 'intelligently' the following is meant: by default, all windows use
+ their own default attributes. However if some of the parent's
+ attributes are explicitly changed (that is, using SetFont and not
+ SetDefaultFont) and if the corresponding attribute hadn't been
+ explicitly set for this window itself, then this window takes the same
+ value as used by the parent. In addition, if the window overrides
+ ShouldInheritColours to return false, the colours will not be changed
+ no matter what and only the font might.
+
+ This rather complicated logic is necessary in order to accomodate the
+ different usage scenarius. The most common one is when all default
+ attributes are used and in this case, nothing should be inherited as
+ in modern GUIs different controls use different fonts (and colours)
+ than their siblings so they can't inherit the same value from the
+ parent. However it was also deemed desirable to allow to simply change
+ the attributes of all children at once by just changing the font or
+ colour of their common parent, hence in this case we do inherit the
+ parents attributes.
+
"""
return _core_.Window_InheritAttributes(*args, **kwargs)
ShouldInheritColours(self) -> bool
Return true from here to allow the colours of this window to be
- changed by InheritAttributes, returning false forbids inheriting
- them from the parent window.
+ changed by InheritAttributes, returning false forbids inheriting them
+ from the parent window.
- The base class version returns false, but this method is
- overridden in wxControl where it returns true.
+ The base class version returns false, but this method is overridden in
+ wxControl where it returns true.
"""
return _core_.Window_ShouldInheritColours(*args, **kwargs)
Window_NextControlId(int winid) -> int
Get the id of the control following the one with the given
- (autogenerated) id
+ autogenerated) id
"""
return _core_.Window_NextControlId(*args, **kwargs)
Window_PrevControlId(int winid) -> int
Get the id of the control preceding the one with the given
- (autogenerated) id
+ autogenerated) id
"""
return _core_.Window_PrevControlId(*args, **kwargs)
"""
Window_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
- Get the default attributes for this class. This is useful if
- you want to use the same font or colour in your own control as
- in a standard control -- which is a much better idea than hard
- coding specific colours or fonts which might look completely out
- of place on the users system, especially if it uses themes.
+ Get the default attributes for this class. This is useful if you want
+ to use the same font or colour in your own control as in a standard
+ control -- which is a much better idea than hard coding specific
+ colours or fonts which might look completely out of place on the
+ user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
- ignore under other platforms. Under Mac, it will change the size of the
- returned font. See SetWindowVariant for more about this.
+ ignore under other platforms. Under Mac, it will change the size of
+ the returned font. See `wx.Window.SetWindowVariant` for more about
+ this.
"""
return _core_.Window_GetClassDefaultAttributes(*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_.MenuItem_GetText(*args, **kwargs)
def GetLabelFromText(*args, **kwargs):
- """MenuItem.GetLabelFromText(String text) -> String"""
+ """GetLabelFromText(String text) -> String"""
return _core_.MenuItem_GetLabelFromText(*args, **kwargs)
GetLabelFromText = staticmethod(GetLabelFromText)
return _core_.MenuItem_SetAccel(*args, **kwargs)
def GetDefaultMarginWidth(*args, **kwargs):
- """MenuItem.GetDefaultMarginWidth() -> int"""
+ """GetDefaultMarginWidth() -> int"""
return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
GetDefaultMarginWidth = staticmethod(GetDefaultMarginWidth)
"""
This is the base class for a control or 'widget'.
- A control is generally a small window which processes user input and/or
- displays one or more item of data.
+ A control is generally a small window which processes user input
+ and/or displays one or more item of data.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxControl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
long style=0, Validator validator=DefaultValidator,
String name=ControlNameStr) -> Control
- Create a Control. Normally you should only call this from a
- subclass' __init__ as a plain old wx.Control is not very useful.
+ Create a Control. Normally you should only call this from a subclass'
+ __init__ as a plain old wx.Control is not very useful.
"""
newobj = _core_.new_Control(*args, **kwargs)
self.this = newobj.this
"""
Command(self, CommandEvent event)
- Simulates the effect of the user issuing a command to the
- item. See wx.CommandEvent.
+ Simulates the effect of the user issuing a command to the item.
+
+ :see: `wx.CommandEvent`
+
"""
return _core_.Control_Command(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
- Control.GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
+ GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
- Get the default attributes for this class. This is useful if
- you want to use the same font or colour in your own control as
- in a standard control -- which is a much better idea than hard
- coding specific colours or fonts which might look completely out
- of place on the users system, especially if it uses themes.
+ Get the default attributes for this class. This is useful if you want
+ to use the same font or colour in your own control as in a standard
+ control -- which is a much better idea than hard coding specific
+ colours or fonts which might look completely out of place on the
+ user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
- ignore under other platforms. Under Mac, it will change the size of the
- returned font. See SetWindowVariant for more about this.
+ ignore under other platforms. Under Mac, it will change the size of
+ the returned font. See `wx.Window.SetWindowVariant` for more about
+ this.
"""
return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
"""
Control_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
- Get the default attributes for this class. This is useful if
- you want to use the same font or colour in your own control as
- in a standard control -- which is a much better idea than hard
- coding specific colours or fonts which might look completely out
- of place on the users system, especially if it uses themes.
+ Get the default attributes for this class. This is useful if you want
+ to use the same font or colour in your own control as in a standard
+ control -- which is a much better idea than hard coding specific
+ colours or fonts which might look completely out of place on the
+ user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
- ignore under other platforms. Under Mac, it will change the size of the
- returned font. See SetWindowVariant for more about this.
+ ignore under other platforms. Under Mac, it will change the size of
+ the returned font. See `wx.Window.SetWindowVariant` for more about
+ this.
"""
return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
class ItemContainer(object):
"""
wx.ItemContainer defines an interface which is implemented by all
- controls which have string subitems, each of which may be
- selected, such as wx.ListBox, wx.CheckListBox, wx.Choice and
- wx.ComboBox (which implements an extended interface deriving from
- this one)
+ controls which have string subitems, each of which may be selected,
+ such as `wx.ListBox`, `wx.CheckListBox`, `wx.Choice` as well as
+ `wx.ComboBox` which implements an extended interface deriving from
+ this one.
- It defines the methods for accessing the control's items and
- although each of the derived classes implements them differently,
- they still all conform to the same interface.
+ It defines the methods for accessing the control's items and although
+ each of the derived classes implements them differently, they still
+ all conform to the same interface.
- The items in a wx.ItemContainer have (non empty) string labels
- and, optionally, client data associated with them.
+ The items in a wx.ItemContainer have (non empty) string labels and,
+ optionally, client data associated with them.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
"""
Append(self, String item, PyObject clientData=None) -> int
- Adds the item to the control, associating the given data with the
- item if not None. The return value is the index of the newly
- added item which may be different from the last one if the
- control is sorted (e.g. has wx.LB_SORT or wx.CB_SORT style).
+ Adds the item to the control, associating the given data with the item
+ if not None. The return value is the index of the newly added item
+ which may be different from the last one if the control is sorted (e.g.
+ has wx.LB_SORT or wx.CB_SORT style).
"""
return _core_.ItemContainer_Append(*args, **kwargs)
"""
AppendItems(self, wxArrayString strings)
- Apend several items at once to the control. Notice that calling
- this method may be much faster than appending the items one by
- one if you need to add a lot of items.
+ Apend several items at once to the control. Notice that calling this
+ method may be much faster than appending the items one by one if you
+ need to add a lot of items.
"""
return _core_.ItemContainer_AppendItems(*args, **kwargs)
"""
Insert(self, String item, int pos, PyObject clientData=None) -> int
- Insert an item into the control before the item at the pos index,
+ Insert an item into the control before the item at the ``pos`` index,
optionally associating some data object with the item.
"""
return _core_.ItemContainer_Insert(*args, **kwargs)
"""
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 PyAssertionError
- exception if enabled) to remove an item with the index negative
- or greater or equal than the number of items in the control.
+ 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
+ enabled) to remove an item with the index negative or greater or equal
+ than the number of items in the control.
"""
return _core_.ItemContainer_Delete(*args, **kwargs)
FindString(self, String s) -> int
Finds an item whose label matches the given string. Returns the
- zero-based position of the item, or wx.NOT_FOUND if the string
- was not found.
+ zero-based position of the item, or ``wx.NOT_FOUND`` if the string was not
+ found.
"""
return _core_.ItemContainer_FindString(*args, **kwargs)
"""
GetSelection(self) -> int
- Returns the index of the selected item or wx.NOT_FOUND if no item is selected.
+ Returns the index of the selected item or ``wx.NOT_FOUND`` if no item
+ is selected.
"""
return _core_.ItemContainer_GetSelection(*args, **kwargs)
"""
GetStringSelection(self) -> String
- Returns the label of the selected item or an empty string if no item is selected.
+ Returns the label of the selected item or an empty string if no item
+ is selected.
"""
return _core_.ItemContainer_GetStringSelection(*args, **kwargs)
class ControlWithItems(Control,ItemContainer):
"""
- wx.ControlWithItems combines the wx.ItemContainer class with the
- wx.Control class, and is used for the base class of various
- controls that have items.
+ wx.ControlWithItems combines the ``wx.ItemContainer`` class with the
+ wx.Control class, and is used for the base class of various controls
+ that have items.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
"""Remove(self, PyObject item) -> bool"""
return _core_.Sizer_Remove(*args, **kwargs)
+ def Detach(*args, **kwargs):
+ """Detach(self, PyObject item) -> bool"""
+ return _core_.Sizer_Detach(*args, **kwargs)
+
def _SetItemMinSize(*args, **kwargs):
"""_SetItemMinSize(self, PyObject item, Size size)"""
return _core_.Sizer__SetItemMinSize(*args, **kwargs)
return _core_.Sizer_PrependItem(*args, **kwargs)
def AddMany(self, widgets):
+ """
+ AddMany is a convenience method for adding several items
+ to a sizer at one time. Simply pass it a list of tuples,
+ where each tuple consists of the parameters that you
+ would normally pass to the `Add` method.
+ """
for childinfo in widgets:
if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
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
- RemoveWindow = RemoveSizer = RemovePos = Remove
+ AddWindow = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
+ AddSizer = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
+ AddSpacer = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
+ PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
+ PrependSizer = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
+ PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
+ InsertWindow = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
+ InsertSizer = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
+ InsertSpacer = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
+ RemoveWindow = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
+ RemoveSizer = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
+ RemovePos = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
def SetItemMinSize(self, item, *args):
return _core_.Sizer_GetMinSize(*args, **kwargs)
def GetSizeTuple(self):
- return self.GetSize().asTuple()
+ return self.GetSize().Get()
def GetPositionTuple(self):
- return self.GetPosition().asTuple()
+ return self.GetPosition().Get()
def GetMinSizeTuple(self):
- return self.GetMinSize().asTuple()
+ return self.GetMinSize().Get()
def RecalcSizes(*args, **kwargs):
"""RecalcSizes(self)"""
"""Get(self) -> PyObject"""
return _core_.GBPosition_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.GBPosition'+str(self.Get())
def __len__(self): return len(self.Get())
"""Get(self) -> PyObject"""
return _core_.GBSpan_Get(*args, **kwargs)
- asTuple = Get
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.GBSpan'+str(self.Get())
def __len__(self): return len(self.Get())
Absolute = _core_.Absolute
class IndividualLayoutConstraint(Object):
"""
- Objects of this class are stored in the wx.LayoutConstraint class as one of
- eight possible constraints that a window can be involved in. You will never
- need to create an instance of wx.IndividualLayoutConstraint, rather you should
- use create a wx.LayoutContstraints instance and use the individual contstraints
+ Objects of this class are stored in the `wx.LayoutConstraints` class as
+ one of eight possible constraints that a window can be involved in.
+ You will never need to create an instance of
+ wx.IndividualLayoutConstraint, rather you should create a
+ `wx.LayoutConstraints` instance and use the individual contstraints
that it contains.
-
- Constraints are initially set to have the relationship wx.Unconstrained, which
- means that their values should be calculated by looking at known constraints.
-
- The Edge specifies the type of edge or dimension of a window.
-
- Edges
-
- wx.Left The left edge.
- wx.Top The top edge.
- wx.Right The right edge.
- wx.Bottom The bottom edge.
- wx.CentreX The x-coordinate of the centre of the window.
- wx.CentreY The y-coordinate of the centre of the window.
-
-
- The Relationship specifies the relationship that this edge or dimension has
- with another specified edge or dimension. Normally, the user doesn't use these
- directly because functions such as Below and RightOf are a convenience for
- using the more general Set function.
-
- Relationships
-
- wx.Unconstrained The edge or dimension is unconstrained
- (the default for edges.)
- wx.AsIs The edge or dimension is to be taken from the current
- window position or size (the default for dimensions.)
- wx.Above The edge should be above another edge.
- wx.Below The edge should be below another edge.
- wx.LeftOf The edge should be to the left of another edge.
- wx.RightOf The edge should be to the right of another edge.
- wx.SameAs The edge or dimension should be the same as another edge
- or dimension.
- wx.PercentOf The edge or dimension should be a percentage of another
- edge or dimension.
- wx.Absolute The edge or dimension should be a given absolute value.
-
-
"""
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(self, int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)"""
+ """
+ Set(self, int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)
+
+ Sets the properties of the constraint. Normally called by one of the
+ convenience functions such as Above, RightOf, SameAs.
+ """
return _core_.IndividualLayoutConstraint_Set(*args, **kwargs)
def LeftOf(*args, **kwargs):
"""
LeftOf(self, Window sibling, int marg=0)
- Sibling relationship
+ Constrains this edge to be to the left of the given window, with an
+ optional margin. Implicitly, this is relative to the left edge of the
+ other window.
"""
return _core_.IndividualLayoutConstraint_LeftOf(*args, **kwargs)
"""
RightOf(self, Window sibling, int marg=0)
- Sibling relationship
+ Constrains this edge to be to the right of the given window, with an
+ optional margin. Implicitly, this is relative to the right edge of the
+ other window.
"""
return _core_.IndividualLayoutConstraint_RightOf(*args, **kwargs)
"""
Above(self, Window sibling, int marg=0)
- Sibling relationship
+ Constrains this edge to be above the given window, with an optional
+ margin. Implicitly, this is relative to the top edge of the other
+ window.
"""
return _core_.IndividualLayoutConstraint_Above(*args, **kwargs)
"""
Below(self, Window sibling, int marg=0)
- Sibling relationship
+ Constrains this edge to be below the given window, with an optional
+ margin. Implicitly, this is relative to the bottom edge of the other
+ window.
"""
return _core_.IndividualLayoutConstraint_Below(*args, **kwargs)
"""
SameAs(self, Window otherW, int edge, int marg=0)
- 'Same edge' alignment
+ Constrains this edge or dimension to be to the same as the edge of the
+ given window, with an optional margin.
"""
return _core_.IndividualLayoutConstraint_SameAs(*args, **kwargs)
"""
PercentOf(self, Window otherW, int wh, int per)
- The edge is a percentage of the other window's edge
+ Constrains this edge or dimension to be to a percentage of the given
+ window, with an optional margin.
"""
return _core_.IndividualLayoutConstraint_PercentOf(*args, **kwargs)
"""
Absolute(self, int val)
- Edge has absolute value
+ Constrains this edge or dimension to be the given absolute value.
"""
return _core_.IndividualLayoutConstraint_Absolute(*args, **kwargs)
"""
Unconstrained(self)
- Dimension is unconstrained
+ Sets this edge or dimension to be unconstrained, that is, dependent on
+ other edges and dimensions from which this value can be deduced.
"""
return _core_.IndividualLayoutConstraint_Unconstrained(*args, **kwargs)
"""
AsIs(self)
- Dimension is 'as is' (use current size settings)
+ Sets this edge or constraint to be whatever the window's value is at
+ the moment. If either of the width and height constraints are *as is*,
+ the window will not be resized, but moved instead. This is important
+ when considering panel items which are intended to have a default
+ size, such as a button, which may take its size from the size of the
+ button label.
"""
return _core_.IndividualLayoutConstraint_AsIs(*args, **kwargs)
class LayoutConstraints(Object):
"""
- Note: constraints are now deprecated and you should use sizers instead.
+ **Note:** constraints are now deprecated and you should use sizers
+ instead.
- Objects of this class can be associated with a window to define its layout
- constraints, with respect to siblings or its parent.
+ Objects of this class can be associated with a window to define its
+ layout constraints, with respect to siblings or its parent.
The class consists of the following eight constraints of class
wx.IndividualLayoutConstraint, some or all of which should be accessed
* centreX: represents the horizontal centre point of the window
* centreY: represents the vertical centre point of the window
- Most constraints are initially set to have the relationship wxUnconstrained,
- which means that their values should be calculated by looking at known
- constraints. The exceptions are width and height, which are set to wxAsIs to
- ensure that if the user does not specify a constraint, the existing width and
- height will be used, to be compatible with panel items which often have take a
- default size. If the constraint is wxAsIs, the dimension will not be changed.
+ Most constraints are initially set to have the relationship
+ wxUnconstrained, which means that their values should be calculated by
+ looking at known constraints. The exceptions are width and height,
+ which are set to wxAsIs to ensure that if the user does not specify a
+ constraint, the existing width and height will be used, to be
+ compatible with panel items which often have take a default size. If
+ the constraint is ``wx.AsIs``, the dimension will not be changed.
+
+ :see: `wx.IndividualLayoutConstraint`, `wx.Window.SetConstraints`
"""
def __repr__(self):
# documented (or will be) as part of the classes/functions/methods
# where they should be used.
-def __docfilter__(name):
- import types
- obj = globals().get(name, None)
- if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]:
- return False
- if name.startswith('_') or name.endswith('Ptr') or name.startswith('EVT'):
- return False
- return True
+class __DocFilter:
+ """
+ A filter for epydoc that only allows non-Ptr classes and
+ fucntions, in order to reduce the clutter in the API docs.
+ """
+ def __init__(self, globals):
+ self._globals = globals
+
+ def __call__(self, name):
+ import types
+ obj = self._globals.get(name, None)
+ if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]:
+ return False
+ if name.startswith('_') or name.endswith('Ptr') or name.startswith('EVT'):
+ return False
+ return True
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff