+# Is anybody using this one?
+class PyWidgetTester(wx.App):
+ def __init__(self, size = (250, 100)):
+ self.size = size
+ wx.App.__init__(self, 0)
+
+ def OnInit(self):
+ self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
+ self.SetTopWindow(self.frame)
+ return True
+
+ def SetWidget(self, widgetClass, *args):
+ w = widgetClass(self.frame, *args)
+ 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
+# the sys module is unloaded, the refcount on sys.__wxPythonCleanup
+# goes to zero and it calls the wxApp_CleanUp function.
+
+class __wxPyCleanup:
+ def __init__(self):
+ self.cleanup = _core.App_CleanUp
+ def __del__(self):
+ self.cleanup()
+
+_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
+
+
+#----------------------------------------------------------------------------
+
+#---------------------------------------------------------------------------
+
+class AcceleratorEntry(object):
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxAcceleratorEntry instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """__init__(int flags=0, int keyCode=0, int cmd=0, MenuItem item=None) -> AcceleratorEntry"""
+ newobj = _core.new_AcceleratorEntry(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_core.delete_AcceleratorEntry):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def Set(*args, **kwargs):
+ """Set(int flags, int keyCode, int cmd, MenuItem item=None)"""
+ return _core.AcceleratorEntry_Set(*args, **kwargs)
+
+ def SetMenuItem(*args, **kwargs):
+ """SetMenuItem(MenuItem item)"""
+ return _core.AcceleratorEntry_SetMenuItem(*args, **kwargs)
+
+ def GetMenuItem(*args, **kwargs):
+ """GetMenuItem() -> MenuItem"""
+ return _core.AcceleratorEntry_GetMenuItem(*args, **kwargs)
+
+ def GetFlags(*args, **kwargs):
+ """GetFlags() -> int"""
+ return _core.AcceleratorEntry_GetFlags(*args, **kwargs)
+
+ def GetKeyCode(*args, **kwargs):
+ """GetKeyCode() -> int"""
+ return _core.AcceleratorEntry_GetKeyCode(*args, **kwargs)
+
+ def GetCommand(*args, **kwargs):
+ """GetCommand() -> int"""
+ return _core.AcceleratorEntry_GetCommand(*args, **kwargs)
+
+
+class AcceleratorEntryPtr(AcceleratorEntry):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = AcceleratorEntry
+_core.AcceleratorEntry_swigregister(AcceleratorEntryPtr)
+
+class AcceleratorTable(Object):
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxAcceleratorTable instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(entries) -> AcceleratorTable
+
+ Construct an AcceleratorTable from a list of AcceleratorEntry items or
+ 3-tuples (flags, keyCode, cmdID)
+ """
+ newobj = _core.new_AcceleratorTable(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_core.delete_AcceleratorTable):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def Ok(*args, **kwargs):
+ """Ok() -> bool"""
+ return _core.AcceleratorTable_Ok(*args, **kwargs)
+
+
+class AcceleratorTablePtr(AcceleratorTable):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = AcceleratorTable
+_core.AcceleratorTable_swigregister(AcceleratorTablePtr)
+
+
+def GetAccelFromString(*args, **kwargs):
+ """GetAccelFromString(String label) -> AcceleratorEntry"""
+ return _core.GetAccelFromString(*args, **kwargs)
+#---------------------------------------------------------------------------
+
+class Window(EvtHandler):
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, String name=PanelNameStr) -> Window
+ """
+ newobj = _core.new_Window(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ self._setOORInfo(self)
+
+ def Create(*args, **kwargs):
+ """
+ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
+ long style=0, String name=PanelNameStr) -> bool
+ """
+ return _core.Window_Create(*args, **kwargs)
+
+ def Close(*args, **kwargs):
+ """Close(bool force=False) -> bool"""
+ return _core.Window_Close(*args, **kwargs)
+
+ def Destroy(*args, **kwargs):
+ """
+ Destroy() -> bool
+
+ Deletes the C++ object this Python object is a proxy for.
+ """
+ return _core.Window_Destroy(*args, **kwargs)
+
+ def DestroyChildren(*args, **kwargs):
+ """DestroyChildren() -> bool"""
+ return _core.Window_DestroyChildren(*args, **kwargs)
+
+ def IsBeingDeleted(*args, **kwargs):
+ """IsBeingDeleted() -> bool"""
+ return _core.Window_IsBeingDeleted(*args, **kwargs)
+
+ def SetTitle(*args, **kwargs):
+ """SetTitle(String title)"""
+ return _core.Window_SetTitle(*args, **kwargs)
+
+ def GetTitle(*args, **kwargs):
+ """GetTitle() -> String"""
+ return _core.Window_GetTitle(*args, **kwargs)
+
+ def SetLabel(*args, **kwargs):
+ """SetLabel(String label)"""
+ return _core.Window_SetLabel(*args, **kwargs)
+
+ def GetLabel(*args, **kwargs):
+ """GetLabel() -> String"""
+ return _core.Window_GetLabel(*args, **kwargs)
+
+ def SetName(*args, **kwargs):
+ """SetName(String name)"""
+ return _core.Window_SetName(*args, **kwargs)
+
+ def GetName(*args, **kwargs):
+ """GetName() -> String"""
+ return _core.Window_GetName(*args, **kwargs)
+
+ def SetId(*args, **kwargs):
+ """SetId(int winid)"""
+ return _core.Window_SetId(*args, **kwargs)
+
+ def GetId(*args, **kwargs):
+ """GetId() -> int"""
+ return _core.Window_GetId(*args, **kwargs)
+
+ def NewControlId(*args, **kwargs):
+ """Window.NewControlId() -> int"""
+ return _core.Window_NewControlId(*args, **kwargs)
+
+ NewControlId = staticmethod(NewControlId)
+ def NextControlId(*args, **kwargs):
+ """Window.NextControlId(int winid) -> int"""
+ return _core.Window_NextControlId(*args, **kwargs)
+
+ NextControlId = staticmethod(NextControlId)
+ def PrevControlId(*args, **kwargs):
+ """Window.PrevControlId(int winid) -> int"""
+ return _core.Window_PrevControlId(*args, **kwargs)
+
+ PrevControlId = staticmethod(PrevControlId)
+ def SetSize(*args, **kwargs):
+ """SetSize(Size size)"""
+ return _core.Window_SetSize(*args, **kwargs)
+
+ def SetDimensions(*args, **kwargs):
+ """SetDimensions(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO)"""
+ return _core.Window_SetDimensions(*args, **kwargs)
+
+ def SetRect(*args, **kwargs):
+ """SetRect(Rect rect, int sizeFlags=SIZE_AUTO)"""
+ return _core.Window_SetRect(*args, **kwargs)
+
+ def SetSizeWH(*args, **kwargs):
+ """SetSizeWH(int width, int height)"""
+ return _core.Window_SetSizeWH(*args, **kwargs)
+
+ def Move(*args, **kwargs):
+ """Move(Point pt, int flags=SIZE_USE_EXISTING)"""
+ return _core.Window_Move(*args, **kwargs)
+
+ SetPosition = Move
+ def MoveXY(*args, **kwargs):
+ """MoveXY(int x, int y, int flags=SIZE_USE_EXISTING)"""
+ return _core.Window_MoveXY(*args, **kwargs)
+
+ def Raise(*args, **kwargs):
+ """Raise()"""
+ return _core.Window_Raise(*args, **kwargs)
+
+ def Lower(*args, **kwargs):
+ """Lower()"""
+ return _core.Window_Lower(*args, **kwargs)
+
+ def SetClientSize(*args, **kwargs):
+ """SetClientSize(Size size)"""
+ return _core.Window_SetClientSize(*args, **kwargs)
+
+ def SetClientSizeWH(*args, **kwargs):
+ """SetClientSizeWH(int width, int height)"""
+ return _core.Window_SetClientSizeWH(*args, **kwargs)
+
+ def SetClientRect(*args, **kwargs):
+ """SetClientRect(Rect rect)"""
+ return _core.Window_SetClientRect(*args, **kwargs)
+
+ def GetPosition(*args, **kwargs):
+ """
+ GetPosition() -> Point
+
+ Get the window's position.
+ """
+ return _core.Window_GetPosition(*args, **kwargs)
+
+ def GetPositionTuple(*args, **kwargs):
+ """
+ GetPositionTuple() -> (x,y)
+
+ Get the window's position.
+ """
+ return _core.Window_GetPositionTuple(*args, **kwargs)
+
+ def GetSize(*args, **kwargs):
+ """
+ GetSize() -> Size
+
+ Get the window size.
+ """
+ return _core.Window_GetSize(*args, **kwargs)
+
+ def GetSizeTuple(*args, **kwargs):
+ """
+ GetSizeTuple() -> (width, height)
+
+ Get the window size.
+ """
+ return _core.Window_GetSizeTuple(*args, **kwargs)
+
+ def GetRect(*args, **kwargs):
+ """GetRect() -> Rect"""
+ return _core.Window_GetRect(*args, **kwargs)
+
+ def GetClientSize(*args, **kwargs):
+ """
+ GetClientSize() -> Size
+
+ Get the window's client size.
+ """
+ return _core.Window_GetClientSize(*args, **kwargs)
+
+ def GetClientSizeTuple(*args, **kwargs):
+ """
+ GetClientSizeTuple() -> (width, height)
+
+ Get the window's client size.
+ """
+ return _core.Window_GetClientSizeTuple(*args, **kwargs)
+
+ def GetClientAreaOrigin(*args, **kwargs):
+ """GetClientAreaOrigin() -> Point"""
+ return _core.Window_GetClientAreaOrigin(*args, **kwargs)
+
+ def GetClientRect(*args, **kwargs):
+ """GetClientRect() -> Rect"""
+ return _core.Window_GetClientRect(*args, **kwargs)
+
+ def GetBestSize(*args, **kwargs):
+ """
+ GetBestSize() -> Size
+
+ Get the size best suited for the window (in fact, minimal acceptable size
+ using which it will still look "nice")
+ """
+ return _core.Window_GetBestSize(*args, **kwargs)
+
+ def GetBestSizeTuple(*args, **kwargs):
+ """
+ GetBestSizeTuple() -> (width, height)
+
+ Get the size best suited for the window (in fact, minimal acceptable size
+ using which it will still look "nice")
+ """
+ return _core.Window_GetBestSizeTuple(*args, **kwargs)
+
+ def GetAdjustedBestSize(*args, **kwargs):
+ """GetAdjustedBestSize() -> Size"""
+ return _core.Window_GetAdjustedBestSize(*args, **kwargs)
+
+ def Center(*args, **kwargs):
+ """Center(int direction=BOTH)"""
+ return _core.Window_Center(*args, **kwargs)
+
+ Centre = Center
+ def CenterOnScreen(*args, **kwargs):
+ """CenterOnScreen(int dir=BOTH)"""
+ return _core.Window_CenterOnScreen(*args, **kwargs)
+
+ CentreOnScreen = CenterOnScreen
+ def CenterOnParent(*args, **kwargs):
+ """CenterOnParent(int dir=BOTH)"""
+ return _core.Window_CenterOnParent(*args, **kwargs)
+
+ CentreOnParent = CenterOnParent
+ def Fit(*args, **kwargs):
+ """Fit()"""
+ return _core.Window_Fit(*args, **kwargs)
+
+ def FitInside(*args, **kwargs):
+ """FitInside()"""
+ return _core.Window_FitInside(*args, **kwargs)
+
+ def SetSizeHints(*args, **kwargs):
+ """
+ SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1,
+ int incH=-1)
+ """
+ return _core.Window_SetSizeHints(*args, **kwargs)
+
+ def SetVirtualSizeHints(*args, **kwargs):
+ """SetVirtualSizeHints(int minW, int minH, int maxW=-1, int maxH=-1)"""
+ return _core.Window_SetVirtualSizeHints(*args, **kwargs)
+
+ def GetMinWidth(*args, **kwargs):
+ """GetMinWidth() -> int"""
+ return _core.Window_GetMinWidth(*args, **kwargs)
+
+ def GetMinHeight(*args, **kwargs):
+ """GetMinHeight() -> int"""
+ return _core.Window_GetMinHeight(*args, **kwargs)
+
+ def GetMaxWidth(*args, **kwargs):
+ """GetMaxWidth() -> int"""
+ return _core.Window_GetMaxWidth(*args, **kwargs)
+
+ def GetMaxHeight(*args, **kwargs):
+ """GetMaxHeight() -> int"""
+ return _core.Window_GetMaxHeight(*args, **kwargs)
+
+ def GetMaxSize(*args, **kwargs):
+ """GetMaxSize() -> Size"""
+ return _core.Window_GetMaxSize(*args, **kwargs)
+
+ def SetVirtualSize(*args, **kwargs):
+ """
+ SetVirtualSize(Size size)
+
+ Set the the virtual size of a window. For most windows this is just the
+ client area of the window, but for some like scrolled windows it is more or
+ less independent of the screen window size.
+ """
+ return _core.Window_SetVirtualSize(*args, **kwargs)
+
+ def SetVirtualSizeWH(*args, **kwargs):
+ """
+ SetVirtualSizeWH(int w, int h)
+
+ Set the the virtual size of a window. For most windows this is just the
+ client area of the window, but for some like scrolled windows it is more or
+ less independent of the screen window size.
+ """
+ return _core.Window_SetVirtualSizeWH(*args, **kwargs)
+
+ def GetVirtualSize(*args, **kwargs):
+ """
+ GetVirtualSize() -> Size
+
+ Get the the virtual size of the window. For most windows this is just
+ the client area of the window, but for some like scrolled windows it is
+ more or less independent of the screen window size.
+ """
+ return _core.Window_GetVirtualSize(*args, **kwargs)
+
+ def GetVirtualSizeTuple(*args, **kwargs):
+ """
+ GetVirtualSizeTuple() -> (width, height)
+
+ Get the the virtual size of the window. For most windows this is just
+ the client area of the window, but for some like scrolled windows it is
+ more or less independent of the screen window size.
+ """
+ return _core.Window_GetVirtualSizeTuple(*args, **kwargs)
+
+ def GetBestVirtualSize(*args, **kwargs):
+ """GetBestVirtualSize() -> Size"""
+ return _core.Window_GetBestVirtualSize(*args, **kwargs)
+
+ def Show(*args, **kwargs):
+ """Show(bool show=True) -> bool"""
+ return _core.Window_Show(*args, **kwargs)
+
+ def Hide(*args, **kwargs):
+ """Hide() -> bool"""
+ return _core.Window_Hide(*args, **kwargs)
+
+ def Enable(*args, **kwargs):
+ """Enable(bool enable=True) -> bool"""
+ return _core.Window_Enable(*args, **kwargs)
+
+ def Disable(*args, **kwargs):
+ """Disable() -> bool"""
+ return _core.Window_Disable(*args, **kwargs)
+
+ def IsShown(*args, **kwargs):
+ """IsShown() -> bool"""
+ return _core.Window_IsShown(*args, **kwargs)
+
+ def IsEnabled(*args, **kwargs):
+ """IsEnabled() -> bool"""
+ return _core.Window_IsEnabled(*args, **kwargs)
+
+ def SetWindowStyleFlag(*args, **kwargs):
+ """SetWindowStyleFlag(long style)"""
+ return _core.Window_SetWindowStyleFlag(*args, **kwargs)
+
+ def GetWindowStyleFlag(*args, **kwargs):
+ """GetWindowStyleFlag() -> long"""
+ return _core.Window_GetWindowStyleFlag(*args, **kwargs)
+
+ def SetWindowStyle(*args, **kwargs):
+ """SetWindowStyle(long style)"""
+ return _core.Window_SetWindowStyle(*args, **kwargs)
+
+ def GetWindowStyle(*args, **kwargs):
+ """GetWindowStyle() -> long"""
+ return _core.Window_GetWindowStyle(*args, **kwargs)
+
+ def HasFlag(*args, **kwargs):
+ """HasFlag(int flag) -> bool"""
+ return _core.Window_HasFlag(*args, **kwargs)
+
+ def IsRetained(*args, **kwargs):
+ """IsRetained() -> bool"""
+ return _core.Window_IsRetained(*args, **kwargs)
+
+ def SetExtraStyle(*args, **kwargs):
+ """SetExtraStyle(long exStyle)"""
+ return _core.Window_SetExtraStyle(*args, **kwargs)
+
+ def GetExtraStyle(*args, **kwargs):
+ """GetExtraStyle() -> long"""
+ return _core.Window_GetExtraStyle(*args, **kwargs)
+
+ def MakeModal(*args, **kwargs):
+ """MakeModal(bool modal=True)"""
+ return _core.Window_MakeModal(*args, **kwargs)
+
+ def SetThemeEnabled(*args, **kwargs):
+ """SetThemeEnabled(bool enableTheme)"""
+ return _core.Window_SetThemeEnabled(*args, **kwargs)
+
+ def GetThemeEnabled(*args, **kwargs):
+ """GetThemeEnabled() -> bool"""
+ return _core.Window_GetThemeEnabled(*args, **kwargs)
+
+ def ShouldInheritColours(*args, **kwargs):
+ """ShouldInheritColours() -> bool"""
+ return _core.Window_ShouldInheritColours(*args, **kwargs)
+
+ def SetFocus(*args, **kwargs):
+ """SetFocus()"""
+ return _core.Window_SetFocus(*args, **kwargs)
+
+ def SetFocusFromKbd(*args, **kwargs):
+ """SetFocusFromKbd()"""
+ return _core.Window_SetFocusFromKbd(*args, **kwargs)
+
+ def FindFocus(*args, **kwargs):
+ """Window.FindFocus() -> Window"""
+ return _core.Window_FindFocus(*args, **kwargs)
+
+ FindFocus = staticmethod(FindFocus)
+ def AcceptsFocus(*args, **kwargs):
+ """AcceptsFocus() -> bool"""
+ return _core.Window_AcceptsFocus(*args, **kwargs)
+
+ def AcceptsFocusFromKeyboard(*args, **kwargs):
+ """AcceptsFocusFromKeyboard() -> bool"""
+ return _core.Window_AcceptsFocusFromKeyboard(*args, **kwargs)
+
+ def GetDefaultItem(*args, **kwargs):
+ """GetDefaultItem() -> Window"""
+ return _core.Window_GetDefaultItem(*args, **kwargs)
+
+ def SetDefaultItem(*args, **kwargs):
+ """SetDefaultItem(Window child) -> Window"""
+ return _core.Window_SetDefaultItem(*args, **kwargs)
+
+ def SetTmpDefaultItem(*args, **kwargs):
+ """SetTmpDefaultItem(Window win)"""
+ return _core.Window_SetTmpDefaultItem(*args, **kwargs)
+
+ def GetChildren(*args, **kwargs):
+ """GetChildren() -> PyObject"""
+ return _core.Window_GetChildren(*args, **kwargs)
+
+ def GetParent(*args, **kwargs):
+ """GetParent() -> Window"""
+ return _core.Window_GetParent(*args, **kwargs)
+
+ def GetGrandParent(*args, **kwargs):
+ """GetGrandParent() -> Window"""
+ return _core.Window_GetGrandParent(*args, **kwargs)
+
+ def IsTopLevel(*args, **kwargs):
+ """IsTopLevel() -> bool"""
+ return _core.Window_IsTopLevel(*args, **kwargs)
+
+ def Reparent(*args, **kwargs):
+ """Reparent(Window newParent) -> bool"""
+ return _core.Window_Reparent(*args, **kwargs)
+
+ def AddChild(*args, **kwargs):
+ """AddChild(Window child)"""
+ return _core.Window_AddChild(*args, **kwargs)
+
+ def RemoveChild(*args, **kwargs):
+ """RemoveChild(Window child)"""
+ return _core.Window_RemoveChild(*args, **kwargs)
+
+ def FindWindowById(*args, **kwargs):
+ """FindWindowById(long winid) -> Window"""
+ return _core.Window_FindWindowById(*args, **kwargs)
+
+ def FindWindowByName(*args, **kwargs):
+ """FindWindowByName(String name) -> Window"""
+ return _core.Window_FindWindowByName(*args, **kwargs)
+
+ def GetEventHandler(*args, **kwargs):
+ """GetEventHandler() -> EvtHandler"""
+ return _core.Window_GetEventHandler(*args, **kwargs)
+
+ def SetEventHandler(*args, **kwargs):
+ """SetEventHandler(EvtHandler handler)"""
+ return _core.Window_SetEventHandler(*args, **kwargs)
+
+ def PushEventHandler(*args, **kwargs):
+ """PushEventHandler(EvtHandler handler)"""
+ return _core.Window_PushEventHandler(*args, **kwargs)
+
+ def PopEventHandler(*args, **kwargs):
+ """PopEventHandler(bool deleteHandler=False) -> EvtHandler"""
+ return _core.Window_PopEventHandler(*args, **kwargs)
+
+ def RemoveEventHandler(*args, **kwargs):
+ """RemoveEventHandler(EvtHandler handler) -> bool"""
+ return _core.Window_RemoveEventHandler(*args, **kwargs)
+
+ def SetValidator(*args, **kwargs):
+ """SetValidator(Validator validator)"""
+ return _core.Window_SetValidator(*args, **kwargs)
+
+ def GetValidator(*args, **kwargs):
+ """GetValidator() -> Validator"""
+ return _core.Window_GetValidator(*args, **kwargs)
+
+ def SetAcceleratorTable(*args, **kwargs):
+ """SetAcceleratorTable(AcceleratorTable accel)"""
+ return _core.Window_SetAcceleratorTable(*args, **kwargs)
+
+ def GetAcceleratorTable(*args, **kwargs):
+ """GetAcceleratorTable() -> AcceleratorTable"""
+ return _core.Window_GetAcceleratorTable(*args, **kwargs)
+
+ def RegisterHotKey(*args, **kwargs):
+ """RegisterHotKey(int hotkeyId, int modifiers, int keycode) -> bool"""
+ return _core.Window_RegisterHotKey(*args, **kwargs)
+
+ def UnregisterHotKey(*args, **kwargs):
+ """UnregisterHotKey(int hotkeyId) -> bool"""
+ return _core.Window_UnregisterHotKey(*args, **kwargs)
+
+ def ConvertDialogPointToPixels(*args, **kwargs):
+ """ConvertDialogPointToPixels(Point pt) -> Point"""
+ return _core.Window_ConvertDialogPointToPixels(*args, **kwargs)
+
+ def ConvertDialogSizeToPixels(*args, **kwargs):
+ """ConvertDialogSizeToPixels(Size sz) -> Size"""
+ return _core.Window_ConvertDialogSizeToPixels(*args, **kwargs)
+
+ def DLG_PNT(*args, **kwargs):
+ """DLG_PNT(Point pt) -> Point"""
+ return _core.Window_DLG_PNT(*args, **kwargs)
+
+ def DLG_SZE(*args, **kwargs):
+ """DLG_SZE(Size sz) -> Size"""
+ return _core.Window_DLG_SZE(*args, **kwargs)
+
+ def ConvertPixelPointToDialog(*args, **kwargs):
+ """ConvertPixelPointToDialog(Point pt) -> Point"""
+ return _core.Window_ConvertPixelPointToDialog(*args, **kwargs)
+
+ def ConvertPixelSizeToDialog(*args, **kwargs):
+ """ConvertPixelSizeToDialog(Size sz) -> Size"""
+ return _core.Window_ConvertPixelSizeToDialog(*args, **kwargs)
+
+ def WarpPointer(*args, **kwargs):
+ """WarpPointer(int x, int y)"""
+ return _core.Window_WarpPointer(*args, **kwargs)
+
+ def CaptureMouse(*args, **kwargs):
+ """CaptureMouse()"""
+ return _core.Window_CaptureMouse(*args, **kwargs)
+
+ def ReleaseMouse(*args, **kwargs):
+ """ReleaseMouse()"""
+ return _core.Window_ReleaseMouse(*args, **kwargs)
+
+ def GetCapture(*args, **kwargs):
+ """Window.GetCapture() -> Window"""
+ return _core.Window_GetCapture(*args, **kwargs)
+
+ GetCapture = staticmethod(GetCapture)
+ def HasCapture(*args, **kwargs):
+ """HasCapture() -> bool"""
+ return _core.Window_HasCapture(*args, **kwargs)
+
+ def Refresh(*args, **kwargs):
+ """Refresh(bool eraseBackground=True, Rect rect=None)"""
+ return _core.Window_Refresh(*args, **kwargs)
+
+ def RefreshRect(*args, **kwargs):
+ """RefreshRect(Rect rect)"""
+ return _core.Window_RefreshRect(*args, **kwargs)
+
+ def Update(*args, **kwargs):
+ """Update()"""
+ return _core.Window_Update(*args, **kwargs)
+
+ def ClearBackground(*args, **kwargs):
+ """ClearBackground()"""
+ return _core.Window_ClearBackground(*args, **kwargs)
+
+ def Freeze(*args, **kwargs):
+ """Freeze()"""
+ return _core.Window_Freeze(*args, **kwargs)
+
+ def Thaw(*args, **kwargs):
+ """Thaw()"""
+ return _core.Window_Thaw(*args, **kwargs)
+
+ def PrepareDC(*args, **kwargs):
+ """PrepareDC(DC dc)"""
+ return _core.Window_PrepareDC(*args, **kwargs)
+
+ def GetUpdateRegion(*args, **kwargs):
+ """GetUpdateRegion() -> Region"""
+ return _core.Window_GetUpdateRegion(*args, **kwargs)
+
+ def GetUpdateClientRect(*args, **kwargs):
+ """GetUpdateClientRect() -> Rect"""
+ return _core.Window_GetUpdateClientRect(*args, **kwargs)
+
+ def IsExposed(*args, **kwargs):
+ """IsExposed(int x, int y, int w=1, int h=1) -> bool"""
+ return _core.Window_IsExposed(*args, **kwargs)
+
+ def IsExposedPoint(*args, **kwargs):
+ """IsExposedPoint(Point pt) -> bool"""
+ return _core.Window_IsExposedPoint(*args, **kwargs)
+
+ def isExposedRect(*args, **kwargs):
+ """isExposedRect(Rect rect) -> bool"""
+ return _core.Window_isExposedRect(*args, **kwargs)
+
+ def SetBackgroundColour(*args, **kwargs):
+ """SetBackgroundColour(Colour colour) -> bool"""
+ return _core.Window_SetBackgroundColour(*args, **kwargs)
+
+ def SetForegroundColour(*args, **kwargs):
+ """SetForegroundColour(Colour colour) -> bool"""
+ return _core.Window_SetForegroundColour(*args, **kwargs)
+
+ def GetBackgroundColour(*args, **kwargs):
+ """GetBackgroundColour() -> Colour"""
+ return _core.Window_GetBackgroundColour(*args, **kwargs)
+
+ def GetForegroundColour(*args, **kwargs):
+ """GetForegroundColour() -> Colour"""
+ return _core.Window_GetForegroundColour(*args, **kwargs)
+
+ def SetCursor(*args, **kwargs):
+ """SetCursor(Cursor cursor) -> bool"""
+ return _core.Window_SetCursor(*args, **kwargs)
+
+ def GetCursor(*args, **kwargs):
+ """GetCursor() -> Cursor"""
+ return _core.Window_GetCursor(*args, **kwargs)
+
+ def SetFont(*args, **kwargs):
+ """SetFont(Font font) -> bool"""
+ return _core.Window_SetFont(*args, **kwargs)
+
+ def GetFont(*args, **kwargs):
+ """GetFont() -> Font"""
+ return _core.Window_GetFont(*args, **kwargs)
+
+ def SetCaret(*args, **kwargs):
+ """SetCaret(Caret caret)"""
+ return _core.Window_SetCaret(*args, **kwargs)
+
+ def GetCaret(*args, **kwargs):
+ """GetCaret() -> Caret"""
+ return _core.Window_GetCaret(*args, **kwargs)
+
+ def GetCharHeight(*args, **kwargs):
+ """GetCharHeight() -> int"""
+ return _core.Window_GetCharHeight(*args, **kwargs)
+
+ def GetCharWidth(*args, **kwargs):
+ """GetCharWidth() -> int"""
+ 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.
+ """
+ return _core.Window_GetTextExtent(*args, **kwargs)
+
+ def GetFullTextExtent(*args, **kwargs):
+ """
+ GetFullTextExtent(String string, Font font=None) ->
+ (width, height, descent, externalLeading)
+
+ Get the width, height, decent and leading of the text using the current or specified font.
+ """
+ return _core.Window_GetFullTextExtent(*args, **kwargs)
+
+ def ClientToScreenXY(*args, **kwargs):
+ """ClientToScreenXY(int x, int y)"""
+ return _core.Window_ClientToScreenXY(*args, **kwargs)
+
+ def ScreenToClientXY(*args, **kwargs):
+ """ScreenToClientXY(int x, int y)"""
+ return _core.Window_ScreenToClientXY(*args, **kwargs)
+
+ def ClientToScreen(*args, **kwargs):
+ """ClientToScreen(Point pt) -> Point"""
+ return _core.Window_ClientToScreen(*args, **kwargs)
+
+ def ScreenToClient(*args, **kwargs):
+ """ScreenToClient(Point pt) -> Point"""
+ return _core.Window_ScreenToClient(*args, **kwargs)
+
+ def HitTestXY(*args, **kwargs):
+ """HitTestXY(int x, int y) -> int"""
+ return _core.Window_HitTestXY(*args, **kwargs)
+
+ def HitTest(*args, **kwargs):
+ """HitTest(Point pt) -> int"""
+ return _core.Window_HitTest(*args, **kwargs)
+
+ def GetBorderFlags(*args, **kwargs):
+ """GetBorderFlags(long flags) -> int"""
+ return _core.Window_GetBorderFlags(*args, **kwargs)
+
+ def GetBorder(*args, **kwargs):
+ """GetBorder() -> int"""
+ return _core.Window_GetBorder(*args, **kwargs)
+
+ def UpdateWindowUI(*args, **kwargs):
+ """UpdateWindowUI(long flags=UPDATE_UI_NONE)"""
+ return _core.Window_UpdateWindowUI(*args, **kwargs)
+
+ def PopupMenuXY(*args, **kwargs):
+ """PopupMenuXY(Menu menu, int x, int y) -> bool"""
+ return _core.Window_PopupMenuXY(*args, **kwargs)
+
+ def PopupMenu(*args, **kwargs):
+ """PopupMenu(Menu menu, Point pos) -> bool"""
+ return _core.Window_PopupMenu(*args, **kwargs)
projects / wxWidgets.git / blobdiff