Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d2638b42a831a5eaebb25f4cdde220ae668df80f
wxWidgets/wxPython/src/gtk/misc.py
Robin Dunn 487febf601 reSWIGged 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24986 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2003-12-23 21:39:24 +00:00

4647 lines
164 KiB
Python
Raw Blame History

# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
import _misc
import core
wx = core
#---------------------------------------------------------------------------
SYS_OEM_FIXED_FONT = _misc.SYS_OEM_FIXED_FONT
SYS_ANSI_FIXED_FONT = _misc.SYS_ANSI_FIXED_FONT
SYS_ANSI_VAR_FONT = _misc.SYS_ANSI_VAR_FONT
SYS_SYSTEM_FONT = _misc.SYS_SYSTEM_FONT
SYS_DEVICE_DEFAULT_FONT = _misc.SYS_DEVICE_DEFAULT_FONT
SYS_DEFAULT_PALETTE = _misc.SYS_DEFAULT_PALETTE
SYS_SYSTEM_FIXED_FONT = _misc.SYS_SYSTEM_FIXED_FONT
SYS_DEFAULT_GUI_FONT = _misc.SYS_DEFAULT_GUI_FONT
SYS_ICONTITLE_FONT = _misc.SYS_ICONTITLE_FONT
SYS_COLOUR_SCROLLBAR = _misc.SYS_COLOUR_SCROLLBAR
SYS_COLOUR_BACKGROUND = _misc.SYS_COLOUR_BACKGROUND
SYS_COLOUR_DESKTOP = _misc.SYS_COLOUR_DESKTOP
SYS_COLOUR_ACTIVECAPTION = _misc.SYS_COLOUR_ACTIVECAPTION
SYS_COLOUR_INACTIVECAPTION = _misc.SYS_COLOUR_INACTIVECAPTION
SYS_COLOUR_MENU = _misc.SYS_COLOUR_MENU
SYS_COLOUR_WINDOW = _misc.SYS_COLOUR_WINDOW
SYS_COLOUR_WINDOWFRAME = _misc.SYS_COLOUR_WINDOWFRAME
SYS_COLOUR_MENUTEXT = _misc.SYS_COLOUR_MENUTEXT
SYS_COLOUR_WINDOWTEXT = _misc.SYS_COLOUR_WINDOWTEXT
SYS_COLOUR_CAPTIONTEXT = _misc.SYS_COLOUR_CAPTIONTEXT
SYS_COLOUR_ACTIVEBORDER = _misc.SYS_COLOUR_ACTIVEBORDER
SYS_COLOUR_INACTIVEBORDER = _misc.SYS_COLOUR_INACTIVEBORDER
SYS_COLOUR_APPWORKSPACE = _misc.SYS_COLOUR_APPWORKSPACE
SYS_COLOUR_HIGHLIGHT = _misc.SYS_COLOUR_HIGHLIGHT
SYS_COLOUR_HIGHLIGHTTEXT = _misc.SYS_COLOUR_HIGHLIGHTTEXT
SYS_COLOUR_BTNFACE = _misc.SYS_COLOUR_BTNFACE
SYS_COLOUR_3DFACE = _misc.SYS_COLOUR_3DFACE
SYS_COLOUR_BTNSHADOW = _misc.SYS_COLOUR_BTNSHADOW
SYS_COLOUR_3DSHADOW = _misc.SYS_COLOUR_3DSHADOW
SYS_COLOUR_GRAYTEXT = _misc.SYS_COLOUR_GRAYTEXT
SYS_COLOUR_BTNTEXT = _misc.SYS_COLOUR_BTNTEXT
SYS_COLOUR_INACTIVECAPTIONTEXT = _misc.SYS_COLOUR_INACTIVECAPTIONTEXT
SYS_COLOUR_BTNHIGHLIGHT = _misc.SYS_COLOUR_BTNHIGHLIGHT
SYS_COLOUR_BTNHILIGHT = _misc.SYS_COLOUR_BTNHILIGHT
SYS_COLOUR_3DHIGHLIGHT = _misc.SYS_COLOUR_3DHIGHLIGHT
SYS_COLOUR_3DHILIGHT = _misc.SYS_COLOUR_3DHILIGHT
SYS_COLOUR_3DDKSHADOW = _misc.SYS_COLOUR_3DDKSHADOW
SYS_COLOUR_3DLIGHT = _misc.SYS_COLOUR_3DLIGHT
SYS_COLOUR_INFOTEXT = _misc.SYS_COLOUR_INFOTEXT
SYS_COLOUR_INFOBK = _misc.SYS_COLOUR_INFOBK
SYS_COLOUR_LISTBOX = _misc.SYS_COLOUR_LISTBOX
SYS_COLOUR_HOTLIGHT = _misc.SYS_COLOUR_HOTLIGHT
SYS_COLOUR_GRADIENTACTIVECAPTION = _misc.SYS_COLOUR_GRADIENTACTIVECAPTION
SYS_COLOUR_GRADIENTINACTIVECAPTION = _misc.SYS_COLOUR_GRADIENTINACTIVECAPTION
SYS_COLOUR_MENUHILIGHT = _misc.SYS_COLOUR_MENUHILIGHT
SYS_COLOUR_MENUBAR = _misc.SYS_COLOUR_MENUBAR
SYS_COLOUR_MAX = _misc.SYS_COLOUR_MAX
SYS_MOUSE_BUTTONS = _misc.SYS_MOUSE_BUTTONS
SYS_BORDER_X = _misc.SYS_BORDER_X
SYS_BORDER_Y = _misc.SYS_BORDER_Y
SYS_CURSOR_X = _misc.SYS_CURSOR_X
SYS_CURSOR_Y = _misc.SYS_CURSOR_Y
SYS_DCLICK_X = _misc.SYS_DCLICK_X
SYS_DCLICK_Y = _misc.SYS_DCLICK_Y
SYS_DRAG_X = _misc.SYS_DRAG_X
SYS_DRAG_Y = _misc.SYS_DRAG_Y
SYS_EDGE_X = _misc.SYS_EDGE_X
SYS_EDGE_Y = _misc.SYS_EDGE_Y
SYS_HSCROLL_ARROW_X = _misc.SYS_HSCROLL_ARROW_X
SYS_HSCROLL_ARROW_Y = _misc.SYS_HSCROLL_ARROW_Y
SYS_HTHUMB_X = _misc.SYS_HTHUMB_X
SYS_ICON_X = _misc.SYS_ICON_X
SYS_ICON_Y = _misc.SYS_ICON_Y
SYS_ICONSPACING_X = _misc.SYS_ICONSPACING_X
SYS_ICONSPACING_Y = _misc.SYS_ICONSPACING_Y
SYS_WINDOWMIN_X = _misc.SYS_WINDOWMIN_X
SYS_WINDOWMIN_Y = _misc.SYS_WINDOWMIN_Y
SYS_SCREEN_X = _misc.SYS_SCREEN_X
SYS_SCREEN_Y = _misc.SYS_SCREEN_Y
SYS_FRAMESIZE_X = _misc.SYS_FRAMESIZE_X
SYS_FRAMESIZE_Y = _misc.SYS_FRAMESIZE_Y
SYS_SMALLICON_X = _misc.SYS_SMALLICON_X
SYS_SMALLICON_Y = _misc.SYS_SMALLICON_Y
SYS_HSCROLL_Y = _misc.SYS_HSCROLL_Y
SYS_VSCROLL_X = _misc.SYS_VSCROLL_X
SYS_VSCROLL_ARROW_X = _misc.SYS_VSCROLL_ARROW_X
SYS_VSCROLL_ARROW_Y = _misc.SYS_VSCROLL_ARROW_Y
SYS_VTHUMB_Y = _misc.SYS_VTHUMB_Y
SYS_CAPTION_Y = _misc.SYS_CAPTION_Y
SYS_MENU_Y = _misc.SYS_MENU_Y
SYS_NETWORK_PRESENT = _misc.SYS_NETWORK_PRESENT
SYS_PENWINDOWS_PRESENT = _misc.SYS_PENWINDOWS_PRESENT
SYS_SHOW_SOUNDS = _misc.SYS_SHOW_SOUNDS
SYS_SWAP_BUTTONS = _misc.SYS_SWAP_BUTTONS
SYS_CAN_DRAW_FRAME_DECORATIONS = _misc.SYS_CAN_DRAW_FRAME_DECORATIONS
SYS_CAN_ICONIZE_FRAME = _misc.SYS_CAN_ICONIZE_FRAME
SYS_SCREEN_NONE = _misc.SYS_SCREEN_NONE
SYS_SCREEN_TINY = _misc.SYS_SCREEN_TINY
SYS_SCREEN_PDA = _misc.SYS_SCREEN_PDA
SYS_SCREEN_SMALL = _misc.SYS_SCREEN_SMALL
SYS_SCREEN_DESKTOP = _misc.SYS_SCREEN_DESKTOP
class SystemSettings(object):
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxSystemSettings instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetColour(*args, **kwargs):
"""SystemSettings.GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
GetColour = staticmethod(GetColour)
def GetFont(*args, **kwargs):
"""SystemSettings.GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
GetFont = staticmethod(GetFont)
def GetMetric(*args, **kwargs):
"""SystemSettings.GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
GetMetric = staticmethod(GetMetric)
def HasFeature(*args, **kwargs):
"""SystemSettings.HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
HasFeature = staticmethod(HasFeature)
def GetScreenType(*args, **kwargs):
"""SystemSettings.GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
GetScreenType = staticmethod(GetScreenType)
def SetScreenType(*args, **kwargs):
"""SystemSettings.SetScreenType(int screen)"""
return _misc.SystemSettings_SetScreenType(*args, **kwargs)
SetScreenType = staticmethod(SetScreenType)
class SystemSettingsPtr(SystemSettings):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SystemSettings
_misc.SystemSettings_swigregister(SystemSettingsPtr)
def SystemSettings_GetColour(*args, **kwargs):
"""SystemSettings_GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
def SystemSettings_GetFont(*args, **kwargs):
"""SystemSettings_GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
def SystemSettings_GetMetric(*args, **kwargs):
"""SystemSettings_GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
def SystemSettings_HasFeature(*args, **kwargs):
"""SystemSettings_HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
def SystemSettings_GetScreenType(*args, **kwargs):
"""SystemSettings_GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
def SystemSettings_SetScreenType(*args, **kwargs):
"""SystemSettings_SetScreenType(int screen)"""
return _misc.SystemSettings_SetScreenType(*args, **kwargs)
class SystemOptions(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxSystemOptions instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> SystemOptions"""
newobj = _misc.new_SystemOptions(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetOption(*args, **kwargs):
"""SystemOptions.SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
SetOption = staticmethod(SetOption)
def SetOptionInt(*args, **kwargs):
"""SystemOptions.SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
SetOptionInt = staticmethod(SetOptionInt)
def GetOption(*args, **kwargs):
"""SystemOptions.GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
GetOption = staticmethod(GetOption)
def GetOptionInt(*args, **kwargs):
"""SystemOptions.GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
GetOptionInt = staticmethod(GetOptionInt)
def HasOption(*args, **kwargs):
"""SystemOptions.HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
HasOption = staticmethod(HasOption)
class SystemOptionsPtr(SystemOptions):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SystemOptions
_misc.SystemOptions_swigregister(SystemOptionsPtr)
def SystemOptions_SetOption(*args, **kwargs):
"""SystemOptions_SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
def SystemOptions_SetOptionInt(*args, **kwargs):
"""SystemOptions_SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
def SystemOptions_GetOption(*args, **kwargs):
"""SystemOptions_GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
def SystemOptions_GetOptionInt(*args, **kwargs):
"""SystemOptions_GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
def SystemOptions_HasOption(*args, **kwargs):
"""SystemOptions_HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
#---------------------------------------------------------------------------
def NewId(*args, **kwargs):
"""NewId() -> long"""
return _misc.NewId(*args, **kwargs)
def RegisterId(*args, **kwargs):
"""RegisterId(long id)"""
return _misc.RegisterId(*args, **kwargs)
def GetCurrentId(*args, **kwargs):
"""GetCurrentId() -> long"""
return _misc.GetCurrentId(*args, **kwargs)
def Bell(*args, **kwargs):
"""Bell()"""
return _misc.Bell(*args, **kwargs)
def EndBusyCursor(*args, **kwargs):
"""EndBusyCursor()"""
return _misc.EndBusyCursor(*args, **kwargs)
def GetElapsedTime(*args, **kwargs):
"""GetElapsedTime(bool resetTimer=True) -> long"""
return _misc.GetElapsedTime(*args, **kwargs)
def GetMousePosition(*args, **kwargs):
"""GetMousePosition() -> (x,y)"""
return _misc.GetMousePosition(*args, **kwargs)
def IsBusy(*args, **kwargs):
"""IsBusy() -> bool"""
return _misc.IsBusy(*args, **kwargs)
def Now(*args, **kwargs):
"""Now() -> String"""
return _misc.Now(*args, **kwargs)
def Shell(*args, **kwargs):
"""Shell(String command=EmptyString) -> bool"""
return _misc.Shell(*args, **kwargs)
def StartTimer(*args, **kwargs):
"""StartTimer()"""
return _misc.StartTimer(*args, **kwargs)
def GetOsVersion(*args, **kwargs):
"""GetOsVersion() -> (platform, major, minor)"""
return _misc.GetOsVersion(*args, **kwargs)
def GetOsDescription(*args, **kwargs):
"""GetOsDescription() -> String"""
return _misc.GetOsDescription(*args, **kwargs)
def GetFreeMemory(*args, **kwargs):
"""GetFreeMemory() -> long"""
return _misc.GetFreeMemory(*args, **kwargs)
SHUTDOWN_POWEROFF = _misc.SHUTDOWN_POWEROFF
SHUTDOWN_REBOOT = _misc.SHUTDOWN_REBOOT
def Shutdown(*args, **kwargs):
"""Shutdown(int wFlags) -> bool"""
return _misc.Shutdown(*args, **kwargs)
def Sleep(*args, **kwargs):
"""Sleep(int secs)"""
return _misc.Sleep(*args, **kwargs)
def Usleep(*args, **kwargs):
"""Usleep(unsigned long milliseconds)"""
return _misc.Usleep(*args, **kwargs)
def EnableTopLevelWindows(*args, **kwargs):
"""EnableTopLevelWindows(bool enable)"""
return _misc.EnableTopLevelWindows(*args, **kwargs)
def StripMenuCodes(*args, **kwargs):
"""StripMenuCodes(String in) -> String"""
return _misc.StripMenuCodes(*args, **kwargs)
def GetEmailAddress(*args, **kwargs):
"""GetEmailAddress() -> String"""
return _misc.GetEmailAddress(*args, **kwargs)
def GetHostName(*args, **kwargs):
"""GetHostName() -> String"""
return _misc.GetHostName(*args, **kwargs)
def GetFullHostName(*args, **kwargs):
"""GetFullHostName() -> String"""
return _misc.GetFullHostName(*args, **kwargs)
def GetUserId(*args, **kwargs):
"""GetUserId() -> String"""
return _misc.GetUserId(*args, **kwargs)
def GetUserName(*args, **kwargs):
"""GetUserName() -> String"""
return _misc.GetUserName(*args, **kwargs)
def GetHomeDir(*args, **kwargs):
"""GetHomeDir() -> String"""
return _misc.GetHomeDir(*args, **kwargs)
def GetUserHome(*args, **kwargs):
"""GetUserHome(String user=EmptyString) -> String"""
return _misc.GetUserHome(*args, **kwargs)
def GetProcessId(*args, **kwargs):
"""GetProcessId() -> unsigned long"""
return _misc.GetProcessId(*args, **kwargs)
def Trap(*args, **kwargs):
"""Trap()"""
return _misc.Trap(*args, **kwargs)
def FileSelector(*args, **kwargs):
"""
FileSelector(String message=FileSelectorPromptStr, String default_path=EmptyString,
String default_filename=EmptyString,
String default_extension=EmptyString,
String wildcard=FileSelectorDefaultWildcardStr,
int flags=0, Window parent=None, int x=-1,
int y=-1) -> String
"""
return _misc.FileSelector(*args, **kwargs)
def LoadFileSelector(*args, **kwargs):
"""
LoadFileSelector(String what, String extension, String default_name=EmptyString,
Window parent=None) -> String
"""
return _misc.LoadFileSelector(*args, **kwargs)
def SaveFileSelector(*args, **kwargs):
"""
SaveFileSelector(String what, String extension, String default_name=EmptyString,
Window parent=None) -> String
"""
return _misc.SaveFileSelector(*args, **kwargs)
def DirSelector(*args, **kwargs):
"""
DirSelector(String message=DirSelectorPromptStr, String defaultPath=EmptyString,
long style=DD_DEFAULT_STYLE,
Point pos=DefaultPosition, Window parent=None) -> String
"""
return _misc.DirSelector(*args, **kwargs)
def GetTextFromUser(*args, **kwargs):
"""
GetTextFromUser(String message, String caption=EmptyString, String default_value=EmptyString,
Window parent=None,
int x=-1, int y=-1, bool centre=True) -> String
"""
return _misc.GetTextFromUser(*args, **kwargs)
def GetPasswordFromUser(*args, **kwargs):
"""
GetPasswordFromUser(String message, String caption=EmptyString, String default_value=EmptyString,
Window parent=None) -> String
"""
return _misc.GetPasswordFromUser(*args, **kwargs)
def GetSingleChoice(*args, **kwargs):
"""
GetSingleChoice(String message, String caption, int choices, String choices_array,
Window parent=None, int x=-1,
int y=-1, bool centre=True, int width=150, int height=200) -> String
"""
return _misc.GetSingleChoice(*args, **kwargs)
def GetSingleChoiceIndex(*args, **kwargs):
"""
GetSingleChoiceIndex(String message, String caption, int choices, String choices_array,
Window parent=None, int x=-1,
int y=-1, bool centre=True, int width=150, int height=200) -> int
"""
return _misc.GetSingleChoiceIndex(*args, **kwargs)
def MessageBox(*args, **kwargs):
"""
MessageBox(String message, String caption=EmptyString, int style=wxOK|wxCENTRE,
Window parent=None, int x=-1,
int y=-1) -> int
"""
return _misc.MessageBox(*args, **kwargs)
def GetNumberFromUser(*args, **kwargs):
"""
GetNumberFromUser(String message, String prompt, String caption, long value,
long min=0, long max=100, Window parent=None,
Point pos=DefaultPosition) -> long
"""
return _misc.GetNumberFromUser(*args, **kwargs)
def ColourDisplay(*args, **kwargs):
"""ColourDisplay() -> bool"""
return _misc.ColourDisplay(*args, **kwargs)
def DisplayDepth(*args, **kwargs):
"""DisplayDepth() -> int"""
return _misc.DisplayDepth(*args, **kwargs)
def GetDisplayDepth(*args, **kwargs):
"""GetDisplayDepth() -> int"""
return _misc.GetDisplayDepth(*args, **kwargs)
def DisplaySize(*args, **kwargs):
"""DisplaySize() -> (width, height)"""
return _misc.DisplaySize(*args, **kwargs)
def GetDisplaySize(*args, **kwargs):
"""GetDisplaySize() -> Size"""
return _misc.GetDisplaySize(*args, **kwargs)
def DisplaySizeMM(*args, **kwargs):
"""DisplaySizeMM() -> (width, height)"""
return _misc.DisplaySizeMM(*args, **kwargs)
def GetDisplaySizeMM(*args, **kwargs):
"""GetDisplaySizeMM() -> Size"""
return _misc.GetDisplaySizeMM(*args, **kwargs)
def ClientDisplayRect(*args, **kwargs):
"""ClientDisplayRect() -> (x, y, width, height)"""
return _misc.ClientDisplayRect(*args, **kwargs)
def GetClientDisplayRect(*args, **kwargs):
"""GetClientDisplayRect() -> Rect"""
return _misc.GetClientDisplayRect(*args, **kwargs)
def SetCursor(*args, **kwargs):
"""SetCursor(Cursor cursor)"""
return _misc.SetCursor(*args, **kwargs)
def BeginBusyCursor(*args, **kwargs):
"""BeginBusyCursor(Cursor cursor=wxHOURGLASS_CURSOR)"""
return _misc.BeginBusyCursor(*args, **kwargs)
def GetActiveWindow(*args, **kwargs):
"""GetActiveWindow() -> Window"""
return _misc.GetActiveWindow(*args, **kwargs)
def GenericFindWindowAtPoint(*args, **kwargs):
"""GenericFindWindowAtPoint(Point pt) -> Window"""
return _misc.GenericFindWindowAtPoint(*args, **kwargs)
def FindWindowAtPoint(*args, **kwargs):
"""FindWindowAtPoint(Point pt) -> Window"""
return _misc.FindWindowAtPoint(*args, **kwargs)
def GetTopLevelParent(*args, **kwargs):
"""GetTopLevelParent(Window win) -> Window"""
return _misc.GetTopLevelParent(*args, **kwargs)
def GetKeyState(*args, **kwargs):
"""GetKeyState(int key) -> bool"""
return _misc.GetKeyState(*args, **kwargs)
def WakeUpMainThread(*args, **kwargs):
"""WakeUpMainThread()"""
return _misc.WakeUpMainThread(*args, **kwargs)
def MutexGuiEnter(*args, **kwargs):
"""MutexGuiEnter()"""
return _misc.MutexGuiEnter(*args, **kwargs)
def MutexGuiLeave(*args, **kwargs):
"""MutexGuiLeave()"""
return _misc.MutexGuiLeave(*args, **kwargs)
class MutexGuiLocker(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMutexGuiLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> MutexGuiLocker"""
newobj = _misc.new_MutexGuiLocker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_MutexGuiLocker):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class MutexGuiLockerPtr(MutexGuiLocker):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MutexGuiLocker
_misc.MutexGuiLocker_swigregister(MutexGuiLockerPtr)
cvar = _misc.cvar
FileSelectorPromptStr = cvar.FileSelectorPromptStr
FileSelectorDefaultWildcardStr = cvar.FileSelectorDefaultWildcardStr
DirSelectorPromptStr = cvar.DirSelectorPromptStr
def Thread_IsMain(*args, **kwargs):
"""Thread_IsMain() -> bool"""
return _misc.Thread_IsMain(*args, **kwargs)
#---------------------------------------------------------------------------
class ToolTip(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxToolTip instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String tip) -> ToolTip"""
newobj = _misc.new_ToolTip(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetTip(*args, **kwargs):
"""SetTip(String tip)"""
return _misc.ToolTip_SetTip(*args, **kwargs)
def GetTip(*args, **kwargs):
"""GetTip() -> String"""
return _misc.ToolTip_GetTip(*args, **kwargs)
def GetWindow(*args, **kwargs):
"""GetWindow() -> Window"""
return _misc.ToolTip_GetWindow(*args, **kwargs)
def Enable(*args, **kwargs):
"""ToolTip.Enable(bool flag)"""
return _misc.ToolTip_Enable(*args, **kwargs)
Enable = staticmethod(Enable)
def SetDelay(*args, **kwargs):
"""ToolTip.SetDelay(long milliseconds)"""
return _misc.ToolTip_SetDelay(*args, **kwargs)
SetDelay = staticmethod(SetDelay)
class ToolTipPtr(ToolTip):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ToolTip
_misc.ToolTip_swigregister(ToolTipPtr)
def ToolTip_Enable(*args, **kwargs):
"""ToolTip_Enable(bool flag)"""
return _misc.ToolTip_Enable(*args, **kwargs)
def ToolTip_SetDelay(*args, **kwargs):
"""ToolTip_SetDelay(long milliseconds)"""
return _misc.ToolTip_SetDelay(*args, **kwargs)
class Caret(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxCaret instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Window window, Size size) -> Caret"""
newobj = _misc.new_Caret(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_Caret):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def IsOk(*args, **kwargs):
"""IsOk() -> bool"""
return _misc.Caret_IsOk(*args, **kwargs)
def IsVisible(*args, **kwargs):
"""IsVisible() -> bool"""
return _misc.Caret_IsVisible(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""GetPosition() -> Point"""
return _misc.Caret_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
"""GetPositionTuple() -> (x,y)"""
return _misc.Caret_GetPositionTuple(*args, **kwargs)
def GetSize(*args, **kwargs):
"""GetSize() -> Size"""
return _misc.Caret_GetSize(*args, **kwargs)
def GetSizeTuple(*args, **kwargs):
"""GetSizeTuple() -> (width, height)"""
return _misc.Caret_GetSizeTuple(*args, **kwargs)
def GetWindow(*args, **kwargs):
"""GetWindow() -> Window"""
return _misc.Caret_GetWindow(*args, **kwargs)
def MoveXY(*args, **kwargs):
"""MoveXY(int x, int y)"""
return _misc.Caret_MoveXY(*args, **kwargs)
def Move(*args, **kwargs):
"""Move(Point pt)"""
return _misc.Caret_Move(*args, **kwargs)
def SetSizeWH(*args, **kwargs):
"""SetSizeWH(int width, int height)"""
return _misc.Caret_SetSizeWH(*args, **kwargs)
def SetSize(*args, **kwargs):
"""SetSize(Size size)"""
return _misc.Caret_SetSize(*args, **kwargs)
def Show(*args, **kwargs):
"""Show(int show=True)"""
return _misc.Caret_Show(*args, **kwargs)
def Hide(*args, **kwargs):
"""Hide()"""
return _misc.Caret_Hide(*args, **kwargs)
def __nonzero__(self): return self.IsOk()
class CaretPtr(Caret):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Caret
_misc.Caret_swigregister(CaretPtr)
def Caret_GetBlinkTime(*args, **kwargs):
"""Caret_GetBlinkTime() -> int"""
return _misc.Caret_GetBlinkTime(*args, **kwargs)
def Caret_SetBlinkTime(*args, **kwargs):
"""Caret_SetBlinkTime(int milliseconds)"""
return _misc.Caret_SetBlinkTime(*args, **kwargs)
class BusyCursor(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxBusyCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Cursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor"""
newobj = _misc.new_BusyCursor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_BusyCursor):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class BusyCursorPtr(BusyCursor):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BusyCursor
_misc.BusyCursor_swigregister(BusyCursorPtr)
class WindowDisabler(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindowDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Window winToSkip=None) -> WindowDisabler"""
newobj = _misc.new_WindowDisabler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_WindowDisabler):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class WindowDisablerPtr(WindowDisabler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = WindowDisabler
_misc.WindowDisabler_swigregister(WindowDisablerPtr)
class BusyInfo(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxBusyInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String message) -> BusyInfo"""
newobj = _misc.new_BusyInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_BusyInfo):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class BusyInfoPtr(BusyInfo):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BusyInfo
_misc.BusyInfo_swigregister(BusyInfoPtr)
class StopWatch(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxStopWatch instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> StopWatch"""
newobj = _misc.new_StopWatch(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Start(*args, **kwargs):
"""Start(long t0=0)"""
return _misc.StopWatch_Start(*args, **kwargs)
def Pause(*args, **kwargs):
"""Pause()"""
return _misc.StopWatch_Pause(*args, **kwargs)
def Resume(*args, **kwargs):
"""Resume()"""
return _misc.StopWatch_Resume(*args, **kwargs)
def Time(*args, **kwargs):
"""Time() -> long"""
return _misc.StopWatch_Time(*args, **kwargs)
class StopWatchPtr(StopWatch):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = StopWatch
_misc.StopWatch_swigregister(StopWatchPtr)
class FileHistory(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileHistory instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int maxFiles=9) -> FileHistory"""
newobj = _misc.new_FileHistory(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_FileHistory):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def AddFileToHistory(*args, **kwargs):
"""AddFileToHistory(String file)"""
return _misc.FileHistory_AddFileToHistory(*args, **kwargs)
def RemoveFileFromHistory(*args, **kwargs):
"""RemoveFileFromHistory(int i)"""
return _misc.FileHistory_RemoveFileFromHistory(*args, **kwargs)
def GetMaxFiles(*args, **kwargs):
"""GetMaxFiles() -> int"""
return _misc.FileHistory_GetMaxFiles(*args, **kwargs)
def UseMenu(*args, **kwargs):
"""UseMenu(Menu menu)"""
return _misc.FileHistory_UseMenu(*args, **kwargs)
def RemoveMenu(*args, **kwargs):
"""RemoveMenu(Menu menu)"""
return _misc.FileHistory_RemoveMenu(*args, **kwargs)
def Load(*args, **kwargs):
"""Load(ConfigBase config)"""
return _misc.FileHistory_Load(*args, **kwargs)
def Save(*args, **kwargs):
"""Save(ConfigBase config)"""
return _misc.FileHistory_Save(*args, **kwargs)
def AddFilesToMenu(*args, **kwargs):
"""AddFilesToMenu()"""
return _misc.FileHistory_AddFilesToMenu(*args, **kwargs)
def AddFilesToThisMenu(*args, **kwargs):
"""AddFilesToThisMenu(Menu menu)"""
return _misc.FileHistory_AddFilesToThisMenu(*args, **kwargs)
def GetHistoryFile(*args, **kwargs):
"""GetHistoryFile(int i) -> String"""
return _misc.FileHistory_GetHistoryFile(*args, **kwargs)
def GetCount(*args, **kwargs):
"""GetCount() -> int"""
return _misc.FileHistory_GetCount(*args, **kwargs)
class FileHistoryPtr(FileHistory):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileHistory
_misc.FileHistory_swigregister(FileHistoryPtr)
class SingleInstanceChecker(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxSingleInstanceChecker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String name, String path=EmptyString) -> SingleInstanceChecker"""
newobj = _misc.new_SingleInstanceChecker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_SingleInstanceChecker):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Create(*args, **kwargs):
"""Create(String name, String path=EmptyString) -> bool"""
return _misc.SingleInstanceChecker_Create(*args, **kwargs)
def IsAnotherRunning(*args, **kwargs):
"""IsAnotherRunning() -> bool"""
return _misc.SingleInstanceChecker_IsAnotherRunning(*args, **kwargs)
class SingleInstanceCheckerPtr(SingleInstanceChecker):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SingleInstanceChecker
_misc.SingleInstanceChecker_swigregister(SingleInstanceCheckerPtr)
def PreSingleInstanceChecker(*args, **kwargs):
"""PreSingleInstanceChecker() -> SingleInstanceChecker"""
val = _misc.new_PreSingleInstanceChecker(*args, **kwargs)
val.thisown = 1
return val
def DrawWindowOnDC(*args, **kwargs):
"""DrawWindowOnDC(Window window, DC dc, int method)"""
return _misc.DrawWindowOnDC(*args, **kwargs)
#---------------------------------------------------------------------------
class TipProvider(object):
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxTipProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __del__(self, destroy=_misc.delete_TipProvider):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def GetTip(*args, **kwargs):
"""GetTip() -> String"""
return _misc.TipProvider_GetTip(*args, **kwargs)
def GetCurrentTip(*args, **kwargs):
"""GetCurrentTip() -> size_t"""
return _misc.TipProvider_GetCurrentTip(*args, **kwargs)
def PreprocessTip(*args, **kwargs):
"""PreprocessTip(String tip) -> String"""
return _misc.TipProvider_PreprocessTip(*args, **kwargs)
class TipProviderPtr(TipProvider):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TipProvider
_misc.TipProvider_swigregister(TipProviderPtr)
class PyTipProvider(TipProvider):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyTipProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(size_t currentTip) -> PyTipProvider"""
newobj = _misc.new_PyTipProvider(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.PyTipProvider__setCallbackInfo(*args, **kwargs)
class PyTipProviderPtr(PyTipProvider):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyTipProvider
_misc.PyTipProvider_swigregister(PyTipProviderPtr)
def ShowTip(*args, **kwargs):
"""ShowTip(Window parent, TipProvider tipProvider, bool showAtStartup=True) -> bool"""
return _misc.ShowTip(*args, **kwargs)
def CreateFileTipProvider(*args, **kwargs):
"""CreateFileTipProvider(String filename, size_t currentTip) -> TipProvider"""
return _misc.CreateFileTipProvider(*args, **kwargs)
#---------------------------------------------------------------------------
TIMER_CONTINUOUS = _misc.TIMER_CONTINUOUS
TIMER_ONE_SHOT = _misc.TIMER_ONE_SHOT
wxEVT_TIMER = _misc.wxEVT_TIMER
class Timer(core.EvtHandler):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyTimer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(EvtHandler owner=None, int id=-1) -> Timer"""
newobj = _misc.new_Timer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, Timer)
def __del__(self, destroy=_misc.delete_Timer):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.Timer__setCallbackInfo(*args, **kwargs)
def SetOwner(*args, **kwargs):
"""SetOwner(EvtHandler owner, int id=-1)"""
return _misc.Timer_SetOwner(*args, **kwargs)
def Start(*args, **kwargs):
"""Start(int milliseconds=-1, bool oneShot=False) -> bool"""
return _misc.Timer_Start(*args, **kwargs)
def Stop(*args, **kwargs):
"""Stop()"""
return _misc.Timer_Stop(*args, **kwargs)
def IsRunning(*args, **kwargs):
"""IsRunning() -> bool"""
return _misc.Timer_IsRunning(*args, **kwargs)
def GetInterval(*args, **kwargs):
"""GetInterval() -> int"""
return _misc.Timer_GetInterval(*args, **kwargs)
def IsOneShot(*args, **kwargs):
"""IsOneShot() -> bool"""
return _misc.Timer_IsOneShot(*args, **kwargs)
def GetId(*args, **kwargs):
"""GetId() -> int"""
return _misc.Timer_GetId(*args, **kwargs)
class TimerPtr(Timer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Timer
_misc.Timer_swigregister(TimerPtr)
# For backwards compatibility with 2.4
class PyTimer(Timer):
def __init__(self, notify):
Timer.__init__(self)
self.notify = notify
def Notify(self):
if self.notify:
self.notify()
EVT_TIMER = wx.PyEventBinder( wxEVT_TIMER, 1 )
class TimerEvent(core.Event):
def __repr__(self):
return "<%s.%s; proxy of C++ wxTimerEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int timerid=0, int interval=0) -> TimerEvent"""
newobj = _misc.new_TimerEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetInterval(*args, **kwargs):
"""GetInterval() -> int"""
return _misc.TimerEvent_GetInterval(*args, **kwargs)
class TimerEventPtr(TimerEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TimerEvent
_misc.TimerEvent_swigregister(TimerEventPtr)
class TimerRunner(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxTimerRunner instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args):
"""
__init__(wxTimer timer) -> TimerRunner
__init__(wxTimer timer, int milli, bool oneShot=False) -> TimerRunner
"""
newobj = _misc.new_TimerRunner(*args)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_TimerRunner):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Start(*args, **kwargs):
"""Start(int milli, bool oneShot=False)"""
return _misc.TimerRunner_Start(*args, **kwargs)
class TimerRunnerPtr(TimerRunner):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TimerRunner
_misc.TimerRunner_swigregister(TimerRunnerPtr)
#---------------------------------------------------------------------------
LOG_FatalError = _misc.LOG_FatalError
LOG_Error = _misc.LOG_Error
LOG_Warning = _misc.LOG_Warning
LOG_Message = _misc.LOG_Message
LOG_Status = _misc.LOG_Status
LOG_Info = _misc.LOG_Info
LOG_Debug = _misc.LOG_Debug
LOG_Trace = _misc.LOG_Trace
LOG_Progress = _misc.LOG_Progress
LOG_User = _misc.LOG_User
LOG_Max = _misc.LOG_Max
TRACE_MemAlloc = _misc.TRACE_MemAlloc
TRACE_Messages = _misc.TRACE_Messages
TRACE_ResAlloc = _misc.TRACE_ResAlloc
TRACE_RefCount = _misc.TRACE_RefCount
TRACE_OleCalls = _misc.TRACE_OleCalls
TraceMemAlloc = _misc.TraceMemAlloc
TraceMessages = _misc.TraceMessages
TraceResAlloc = _misc.TraceResAlloc
TraceRefCount = _misc.TraceRefCount
TraceOleCalls = _misc.TraceOleCalls
class Log(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> Log"""
newobj = _misc.new_Log(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def IsEnabled(*args, **kwargs):
"""Log.IsEnabled() -> bool"""
return _misc.Log_IsEnabled(*args, **kwargs)
IsEnabled = staticmethod(IsEnabled)
def EnableLogging(*args, **kwargs):
"""Log.EnableLogging(bool doIt=True) -> bool"""
return _misc.Log_EnableLogging(*args, **kwargs)
EnableLogging = staticmethod(EnableLogging)
def OnLog(*args, **kwargs):
"""Log.OnLog(wxLogLevel level, wxChar szString, time_t t)"""
return _misc.Log_OnLog(*args, **kwargs)
OnLog = staticmethod(OnLog)
def Flush(*args, **kwargs):
"""Flush()"""
return _misc.Log_Flush(*args, **kwargs)
def FlushActive(*args, **kwargs):
"""Log.FlushActive()"""
return _misc.Log_FlushActive(*args, **kwargs)
FlushActive = staticmethod(FlushActive)
def GetActiveTarget(*args, **kwargs):
"""Log.GetActiveTarget() -> Log"""
return _misc.Log_GetActiveTarget(*args, **kwargs)
GetActiveTarget = staticmethod(GetActiveTarget)
def SetActiveTarget(*args, **kwargs):
"""Log.SetActiveTarget(Log pLogger) -> Log"""
return _misc.Log_SetActiveTarget(*args, **kwargs)
SetActiveTarget = staticmethod(SetActiveTarget)
def Suspend(*args, **kwargs):
"""Log.Suspend()"""
return _misc.Log_Suspend(*args, **kwargs)
Suspend = staticmethod(Suspend)
def Resume(*args, **kwargs):
"""Log.Resume()"""
return _misc.Log_Resume(*args, **kwargs)
Resume = staticmethod(Resume)
def SetVerbose(*args, **kwargs):
"""Log.SetVerbose(bool bVerbose=True)"""
return _misc.Log_SetVerbose(*args, **kwargs)
SetVerbose = staticmethod(SetVerbose)
def SetLogLevel(*args, **kwargs):
"""Log.SetLogLevel(wxLogLevel logLevel)"""
return _misc.Log_SetLogLevel(*args, **kwargs)
SetLogLevel = staticmethod(SetLogLevel)
def DontCreateOnDemand(*args, **kwargs):
"""Log.DontCreateOnDemand()"""
return _misc.Log_DontCreateOnDemand(*args, **kwargs)
DontCreateOnDemand = staticmethod(DontCreateOnDemand)
def SetTraceMask(*args, **kwargs):
"""Log.SetTraceMask(wxTraceMask ulMask)"""
return _misc.Log_SetTraceMask(*args, **kwargs)
SetTraceMask = staticmethod(SetTraceMask)
def AddTraceMask(*args, **kwargs):
"""Log.AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
AddTraceMask = staticmethod(AddTraceMask)
def RemoveTraceMask(*args, **kwargs):
"""Log.RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
RemoveTraceMask = staticmethod(RemoveTraceMask)
def ClearTraceMasks(*args, **kwargs):
"""Log.ClearTraceMasks()"""
return _misc.Log_ClearTraceMasks(*args, **kwargs)
ClearTraceMasks = staticmethod(ClearTraceMasks)
def GetTraceMasks(*args, **kwargs):
"""Log.GetTraceMasks() -> wxArrayString"""
return _misc.Log_GetTraceMasks(*args, **kwargs)
GetTraceMasks = staticmethod(GetTraceMasks)
def SetTimestamp(*args, **kwargs):
"""Log.SetTimestamp(wxChar ts)"""
return _misc.Log_SetTimestamp(*args, **kwargs)
SetTimestamp = staticmethod(SetTimestamp)
def GetVerbose(*args, **kwargs):
"""Log.GetVerbose() -> bool"""
return _misc.Log_GetVerbose(*args, **kwargs)
GetVerbose = staticmethod(GetVerbose)
def GetTraceMask(*args, **kwargs):
"""Log.GetTraceMask() -> wxTraceMask"""
return _misc.Log_GetTraceMask(*args, **kwargs)
GetTraceMask = staticmethod(GetTraceMask)
def IsAllowedTraceMask(*args, **kwargs):
"""Log.IsAllowedTraceMask(wxChar mask) -> bool"""
return _misc.Log_IsAllowedTraceMask(*args, **kwargs)
IsAllowedTraceMask = staticmethod(IsAllowedTraceMask)
def GetLogLevel(*args, **kwargs):
"""Log.GetLogLevel() -> wxLogLevel"""
return _misc.Log_GetLogLevel(*args, **kwargs)
GetLogLevel = staticmethod(GetLogLevel)
def GetTimestamp(*args, **kwargs):
"""Log.GetTimestamp() -> wxChar"""
return _misc.Log_GetTimestamp(*args, **kwargs)
GetTimestamp = staticmethod(GetTimestamp)
def TimeStamp(*args, **kwargs):
"""Log.TimeStamp() -> String"""
return _misc.Log_TimeStamp(*args, **kwargs)
TimeStamp = staticmethod(TimeStamp)
def Destroy(*args, **kwargs):
"""Destroy()"""
return _misc.Log_Destroy(*args, **kwargs)
class LogPtr(Log):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Log
_misc.Log_swigregister(LogPtr)
def Log_IsEnabled(*args, **kwargs):
"""Log_IsEnabled() -> bool"""
return _misc.Log_IsEnabled(*args, **kwargs)
def Log_EnableLogging(*args, **kwargs):
"""Log_EnableLogging(bool doIt=True) -> bool"""
return _misc.Log_EnableLogging(*args, **kwargs)
def Log_OnLog(*args, **kwargs):
"""Log_OnLog(wxLogLevel level, wxChar szString, time_t t)"""
return _misc.Log_OnLog(*args, **kwargs)
def Log_FlushActive(*args, **kwargs):
"""Log_FlushActive()"""
return _misc.Log_FlushActive(*args, **kwargs)
def Log_GetActiveTarget(*args, **kwargs):
"""Log_GetActiveTarget() -> Log"""
return _misc.Log_GetActiveTarget(*args, **kwargs)
def Log_SetActiveTarget(*args, **kwargs):
"""Log_SetActiveTarget(Log pLogger) -> Log"""
return _misc.Log_SetActiveTarget(*args, **kwargs)
def Log_Suspend(*args, **kwargs):
"""Log_Suspend()"""
return _misc.Log_Suspend(*args, **kwargs)
def Log_Resume(*args, **kwargs):
"""Log_Resume()"""
return _misc.Log_Resume(*args, **kwargs)
def Log_SetVerbose(*args, **kwargs):
"""Log_SetVerbose(bool bVerbose=True)"""
return _misc.Log_SetVerbose(*args, **kwargs)
def Log_SetLogLevel(*args, **kwargs):
"""Log_SetLogLevel(wxLogLevel logLevel)"""
return _misc.Log_SetLogLevel(*args, **kwargs)
def Log_DontCreateOnDemand(*args, **kwargs):
"""Log_DontCreateOnDemand()"""
return _misc.Log_DontCreateOnDemand(*args, **kwargs)
def Log_SetTraceMask(*args, **kwargs):
"""Log_SetTraceMask(wxTraceMask ulMask)"""
return _misc.Log_SetTraceMask(*args, **kwargs)
def Log_AddTraceMask(*args, **kwargs):
"""Log_AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
def Log_RemoveTraceMask(*args, **kwargs):
"""Log_RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
def Log_ClearTraceMasks(*args, **kwargs):
"""Log_ClearTraceMasks()"""
return _misc.Log_ClearTraceMasks(*args, **kwargs)
def Log_GetTraceMasks(*args, **kwargs):
"""Log_GetTraceMasks() -> wxArrayString"""
return _misc.Log_GetTraceMasks(*args, **kwargs)
def Log_SetTimestamp(*args, **kwargs):
"""Log_SetTimestamp(wxChar ts)"""
return _misc.Log_SetTimestamp(*args, **kwargs)
def Log_GetVerbose(*args, **kwargs):
"""Log_GetVerbose() -> bool"""
return _misc.Log_GetVerbose(*args, **kwargs)
def Log_GetTraceMask(*args, **kwargs):
"""Log_GetTraceMask() -> wxTraceMask"""
return _misc.Log_GetTraceMask(*args, **kwargs)
def Log_IsAllowedTraceMask(*args, **kwargs):
"""Log_IsAllowedTraceMask(wxChar mask) -> bool"""
return _misc.Log_IsAllowedTraceMask(*args, **kwargs)
def Log_GetLogLevel(*args, **kwargs):
"""Log_GetLogLevel() -> wxLogLevel"""
return _misc.Log_GetLogLevel(*args, **kwargs)
def Log_GetTimestamp(*args, **kwargs):
"""Log_GetTimestamp() -> wxChar"""
return _misc.Log_GetTimestamp(*args, **kwargs)
def Log_TimeStamp(*args, **kwargs):
"""Log_TimeStamp() -> String"""
return _misc.Log_TimeStamp(*args, **kwargs)
class LogStderr(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogStderr instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> LogStderr"""
newobj = _misc.new_LogStderr(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class LogStderrPtr(LogStderr):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogStderr
_misc.LogStderr_swigregister(LogStderrPtr)
class LogTextCtrl(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogTextCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(wxTextCtrl pTextCtrl) -> LogTextCtrl"""
newobj = _misc.new_LogTextCtrl(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class LogTextCtrlPtr(LogTextCtrl):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogTextCtrl
_misc.LogTextCtrl_swigregister(LogTextCtrlPtr)
class LogGui(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogGui instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> LogGui"""
newobj = _misc.new_LogGui(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class LogGuiPtr(LogGui):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogGui
_misc.LogGui_swigregister(LogGuiPtr)
class LogWindow(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(wxFrame pParent, String szTitle, bool bShow=True, bool bPassToOld=True) -> LogWindow"""
newobj = _misc.new_LogWindow(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Show(*args, **kwargs):
"""Show(bool bShow=True)"""
return _misc.LogWindow_Show(*args, **kwargs)
def GetFrame(*args, **kwargs):
"""GetFrame() -> wxFrame"""
return _misc.LogWindow_GetFrame(*args, **kwargs)
def GetOldLog(*args, **kwargs):
"""GetOldLog() -> Log"""
return _misc.LogWindow_GetOldLog(*args, **kwargs)
def IsPassingMessages(*args, **kwargs):
"""IsPassingMessages() -> bool"""
return _misc.LogWindow_IsPassingMessages(*args, **kwargs)
def PassMessages(*args, **kwargs):
"""PassMessages(bool bDoPass)"""
return _misc.LogWindow_PassMessages(*args, **kwargs)
class LogWindowPtr(LogWindow):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogWindow
_misc.LogWindow_swigregister(LogWindowPtr)
class LogChain(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogChain instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Log logger) -> LogChain"""
newobj = _misc.new_LogChain(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetLog(*args, **kwargs):
"""SetLog(Log logger)"""
return _misc.LogChain_SetLog(*args, **kwargs)
def PassMessages(*args, **kwargs):
"""PassMessages(bool bDoPass)"""
return _misc.LogChain_PassMessages(*args, **kwargs)
def IsPassingMessages(*args, **kwargs):
"""IsPassingMessages() -> bool"""
return _misc.LogChain_IsPassingMessages(*args, **kwargs)
def GetOldLog(*args, **kwargs):
"""GetOldLog() -> Log"""
return _misc.LogChain_GetOldLog(*args, **kwargs)
class LogChainPtr(LogChain):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogChain
_misc.LogChain_swigregister(LogChainPtr)
def SysErrorCode(*args, **kwargs):
"""SysErrorCode() -> unsigned long"""
return _misc.SysErrorCode(*args, **kwargs)
def SysErrorMsg(*args, **kwargs):
"""SysErrorMsg(unsigned long nErrCode=0) -> String"""
return _misc.SysErrorMsg(*args, **kwargs)
def LogFatalError(*args, **kwargs):
"""LogFatalError(String msg)"""
return _misc.LogFatalError(*args, **kwargs)
def LogError(*args, **kwargs):
"""LogError(String msg)"""
return _misc.LogError(*args, **kwargs)
def LogWarning(*args, **kwargs):
"""LogWarning(String msg)"""
return _misc.LogWarning(*args, **kwargs)
def LogMessage(*args, **kwargs):
"""LogMessage(String msg)"""
return _misc.LogMessage(*args, **kwargs)
def LogInfo(*args, **kwargs):
"""LogInfo(String msg)"""
return _misc.LogInfo(*args, **kwargs)
def LogDebug(*args, **kwargs):
"""LogDebug(String msg)"""
return _misc.LogDebug(*args, **kwargs)
def LogVerbose(*args, **kwargs):
"""LogVerbose(String msg)"""
return _misc.LogVerbose(*args, **kwargs)
def LogStatus(*args, **kwargs):
"""LogStatus(String msg)"""
return _misc.LogStatus(*args, **kwargs)
def LogStatusFrame(*args, **kwargs):
"""LogStatusFrame(wxFrame pFrame, String msg)"""
return _misc.LogStatusFrame(*args, **kwargs)
def LogSysError(*args, **kwargs):
"""LogSysError(String msg)"""
return _misc.LogSysError(*args, **kwargs)
def LogGeneric(*args, **kwargs):
"""LogGeneric(unsigned long level, String msg)"""
return _misc.LogGeneric(*args, **kwargs)
def SafeShowMessage(*args, **kwargs):
"""SafeShowMessage(String title, String text)"""
return _misc.SafeShowMessage(*args, **kwargs)
class LogNull(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogNull instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> LogNull"""
newobj = _misc.new_LogNull(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_LogNull):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class LogNullPtr(LogNull):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LogNull
_misc.LogNull_swigregister(LogNullPtr)
def LogTrace(*args):
"""
LogTrace(unsigned long mask, String msg)
LogTrace(String mask, String msg)
"""
return _misc.LogTrace(*args)
class PyLog(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyLog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> PyLog"""
newobj = _misc.new_PyLog(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyLog)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.PyLog__setCallbackInfo(*args, **kwargs)
class PyLogPtr(PyLog):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyLog
_misc.PyLog_swigregister(PyLogPtr)
#---------------------------------------------------------------------------
PROCESS_DEFAULT = _misc.PROCESS_DEFAULT
PROCESS_REDIRECT = _misc.PROCESS_REDIRECT
KILL_OK = _misc.KILL_OK
KILL_BAD_SIGNAL = _misc.KILL_BAD_SIGNAL
KILL_ACCESS_DENIED = _misc.KILL_ACCESS_DENIED
KILL_NO_PROCESS = _misc.KILL_NO_PROCESS
KILL_ERROR = _misc.KILL_ERROR
SIGNONE = _misc.SIGNONE
SIGHUP = _misc.SIGHUP
SIGINT = _misc.SIGINT
SIGQUIT = _misc.SIGQUIT
SIGILL = _misc.SIGILL
SIGTRAP = _misc.SIGTRAP
SIGABRT = _misc.SIGABRT
SIGIOT = _misc.SIGIOT
SIGEMT = _misc.SIGEMT
SIGFPE = _misc.SIGFPE
SIGKILL = _misc.SIGKILL
SIGBUS = _misc.SIGBUS
SIGSEGV = _misc.SIGSEGV
SIGSYS = _misc.SIGSYS
SIGPIPE = _misc.SIGPIPE
SIGALRM = _misc.SIGALRM
SIGTERM = _misc.SIGTERM
class Process(core.EvtHandler):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyProcess instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Kill(*args, **kwargs):
"""Process.Kill(int pid, int sig=SIGTERM) -> int"""
return _misc.Process_Kill(*args, **kwargs)
Kill = staticmethod(Kill)
def Exists(*args, **kwargs):
"""Process.Exists(int pid) -> bool"""
return _misc.Process_Exists(*args, **kwargs)
Exists = staticmethod(Exists)
def Open(*args, **kwargs):
"""Process.Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
return _misc.Process_Open(*args, **kwargs)
Open = staticmethod(Open)
def __init__(self, *args, **kwargs):
"""__init__(EvtHandler parent=None, int id=-1) -> Process"""
newobj = _misc.new_Process(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, Process)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.Process__setCallbackInfo(*args, **kwargs)
def base_OnTerminate(*args, **kwargs):
"""base_OnTerminate(int pid, int status)"""
return _misc.Process_base_OnTerminate(*args, **kwargs)
def Redirect(*args, **kwargs):
"""Redirect()"""
return _misc.Process_Redirect(*args, **kwargs)
def IsRedirected(*args, **kwargs):
"""IsRedirected() -> bool"""
return _misc.Process_IsRedirected(*args, **kwargs)
def Detach(*args, **kwargs):
"""Detach()"""
return _misc.Process_Detach(*args, **kwargs)
def GetInputStream(*args, **kwargs):
"""GetInputStream() -> InputStream"""
return _misc.Process_GetInputStream(*args, **kwargs)
def GetErrorStream(*args, **kwargs):
"""GetErrorStream() -> InputStream"""
return _misc.Process_GetErrorStream(*args, **kwargs)
def GetOutputStream(*args, **kwargs):
"""GetOutputStream() -> OutputStream"""
return _misc.Process_GetOutputStream(*args, **kwargs)
def CloseOutput(*args, **kwargs):
"""CloseOutput()"""
return _misc.Process_CloseOutput(*args, **kwargs)
def IsInputOpened(*args, **kwargs):
"""IsInputOpened() -> bool"""
return _misc.Process_IsInputOpened(*args, **kwargs)
def IsInputAvailable(*args, **kwargs):
"""IsInputAvailable() -> bool"""
return _misc.Process_IsInputAvailable(*args, **kwargs)
def IsErrorAvailable(*args, **kwargs):
"""IsErrorAvailable() -> bool"""
return _misc.Process_IsErrorAvailable(*args, **kwargs)
class ProcessPtr(Process):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Process
_misc.Process_swigregister(ProcessPtr)
def Process_Kill(*args, **kwargs):
"""Process_Kill(int pid, int sig=SIGTERM) -> int"""
return _misc.Process_Kill(*args, **kwargs)
def Process_Exists(*args, **kwargs):
"""Process_Exists(int pid) -> bool"""
return _misc.Process_Exists(*args, **kwargs)
def Process_Open(*args, **kwargs):
"""Process_Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
return _misc.Process_Open(*args, **kwargs)
class ProcessEvent(core.Event):
def __repr__(self):
return "<%s.%s; proxy of C++ wxProcessEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int id=0, int pid=0, int exitcode=0) -> ProcessEvent"""
newobj = _misc.new_ProcessEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetPid(*args, **kwargs):
"""GetPid() -> int"""
return _misc.ProcessEvent_GetPid(*args, **kwargs)
def GetExitCode(*args, **kwargs):
"""GetExitCode() -> int"""
return _misc.ProcessEvent_GetExitCode(*args, **kwargs)
m_pid = property(_misc.ProcessEvent_m_pid_get, _misc.ProcessEvent_m_pid_set)
m_exitcode = property(_misc.ProcessEvent_m_exitcode_get, _misc.ProcessEvent_m_exitcode_set)
class ProcessEventPtr(ProcessEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ProcessEvent
_misc.ProcessEvent_swigregister(ProcessEventPtr)
wxEVT_END_PROCESS = _misc.wxEVT_END_PROCESS
EVT_END_PROCESS = wx.PyEventBinder( wxEVT_END_PROCESS, 1 )
EXEC_ASYNC = _misc.EXEC_ASYNC
EXEC_SYNC = _misc.EXEC_SYNC
EXEC_NOHIDE = _misc.EXEC_NOHIDE
EXEC_MAKE_GROUP_LEADER = _misc.EXEC_MAKE_GROUP_LEADER
def Execute(*args, **kwargs):
"""Execute(String command, int flags=EXEC_ASYNC, Process process=None) -> long"""
return _misc.Execute(*args, **kwargs)
#---------------------------------------------------------------------------
JOYSTICK1 = _misc.JOYSTICK1
JOYSTICK2 = _misc.JOYSTICK2
JOY_BUTTON_ANY = _misc.JOY_BUTTON_ANY
JOY_BUTTON1 = _misc.JOY_BUTTON1
JOY_BUTTON2 = _misc.JOY_BUTTON2
JOY_BUTTON3 = _misc.JOY_BUTTON3
JOY_BUTTON4 = _misc.JOY_BUTTON4
class Joystick(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxJoystick instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int joystick=JOYSTICK1) -> Joystick"""
newobj = _misc.new_Joystick(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_Joystick):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def GetPosition(*args, **kwargs):
"""GetPosition() -> Point"""
return _misc.Joystick_GetPosition(*args, **kwargs)
def GetZPosition(*args, **kwargs):
"""GetZPosition() -> int"""
return _misc.Joystick_GetZPosition(*args, **kwargs)
def GetButtonState(*args, **kwargs):
"""GetButtonState() -> int"""
return _misc.Joystick_GetButtonState(*args, **kwargs)
def GetPOVPosition(*args, **kwargs):
"""GetPOVPosition() -> int"""
return _misc.Joystick_GetPOVPosition(*args, **kwargs)
def GetPOVCTSPosition(*args, **kwargs):
"""GetPOVCTSPosition() -> int"""
return _misc.Joystick_GetPOVCTSPosition(*args, **kwargs)
def GetRudderPosition(*args, **kwargs):
"""GetRudderPosition() -> int"""
return _misc.Joystick_GetRudderPosition(*args, **kwargs)
def GetUPosition(*args, **kwargs):
"""GetUPosition() -> int"""
return _misc.Joystick_GetUPosition(*args, **kwargs)
def GetVPosition(*args, **kwargs):
"""GetVPosition() -> int"""
return _misc.Joystick_GetVPosition(*args, **kwargs)
def GetMovementThreshold(*args, **kwargs):
"""GetMovementThreshold() -> int"""
return _misc.Joystick_GetMovementThreshold(*args, **kwargs)
def SetMovementThreshold(*args, **kwargs):
"""SetMovementThreshold(int threshold)"""
return _misc.Joystick_SetMovementThreshold(*args, **kwargs)
def IsOk(*args, **kwargs):
"""IsOk() -> bool"""
return _misc.Joystick_IsOk(*args, **kwargs)
def GetNumberJoysticks(*args, **kwargs):
"""GetNumberJoysticks() -> int"""
return _misc.Joystick_GetNumberJoysticks(*args, **kwargs)
def GetManufacturerId(*args, **kwargs):
"""GetManufacturerId() -> int"""
return _misc.Joystick_GetManufacturerId(*args, **kwargs)
def GetProductId(*args, **kwargs):
"""GetProductId() -> int"""
return _misc.Joystick_GetProductId(*args, **kwargs)
def GetProductName(*args, **kwargs):
"""GetProductName() -> String"""
return _misc.Joystick_GetProductName(*args, **kwargs)
def GetXMin(*args, **kwargs):
"""GetXMin() -> int"""
return _misc.Joystick_GetXMin(*args, **kwargs)
def GetYMin(*args, **kwargs):
"""GetYMin() -> int"""
return _misc.Joystick_GetYMin(*args, **kwargs)
def GetZMin(*args, **kwargs):
"""GetZMin() -> int"""
return _misc.Joystick_GetZMin(*args, **kwargs)
def GetXMax(*args, **kwargs):
"""GetXMax() -> int"""
return _misc.Joystick_GetXMax(*args, **kwargs)
def GetYMax(*args, **kwargs):
"""GetYMax() -> int"""
return _misc.Joystick_GetYMax(*args, **kwargs)
def GetZMax(*args, **kwargs):
"""GetZMax() -> int"""
return _misc.Joystick_GetZMax(*args, **kwargs)
def GetNumberButtons(*args, **kwargs):
"""GetNumberButtons() -> int"""
return _misc.Joystick_GetNumberButtons(*args, **kwargs)
def GetNumberAxes(*args, **kwargs):
"""GetNumberAxes() -> int"""
return _misc.Joystick_GetNumberAxes(*args, **kwargs)
def GetMaxButtons(*args, **kwargs):
"""GetMaxButtons() -> int"""
return _misc.Joystick_GetMaxButtons(*args, **kwargs)
def GetMaxAxes(*args, **kwargs):
"""GetMaxAxes() -> int"""
return _misc.Joystick_GetMaxAxes(*args, **kwargs)
def GetPollingMin(*args, **kwargs):
"""GetPollingMin() -> int"""
return _misc.Joystick_GetPollingMin(*args, **kwargs)
def GetPollingMax(*args, **kwargs):
"""GetPollingMax() -> int"""
return _misc.Joystick_GetPollingMax(*args, **kwargs)
def GetRudderMin(*args, **kwargs):
"""GetRudderMin() -> int"""
return _misc.Joystick_GetRudderMin(*args, **kwargs)
def GetRudderMax(*args, **kwargs):
"""GetRudderMax() -> int"""
return _misc.Joystick_GetRudderMax(*args, **kwargs)
def GetUMin(*args, **kwargs):
"""GetUMin() -> int"""
return _misc.Joystick_GetUMin(*args, **kwargs)
def GetUMax(*args, **kwargs):
"""GetUMax() -> int"""
return _misc.Joystick_GetUMax(*args, **kwargs)
def GetVMin(*args, **kwargs):
"""GetVMin() -> int"""
return _misc.Joystick_GetVMin(*args, **kwargs)
def GetVMax(*args, **kwargs):
"""GetVMax() -> int"""
return _misc.Joystick_GetVMax(*args, **kwargs)
def HasRudder(*args, **kwargs):
"""HasRudder() -> bool"""
return _misc.Joystick_HasRudder(*args, **kwargs)
def HasZ(*args, **kwargs):
"""HasZ() -> bool"""
return _misc.Joystick_HasZ(*args, **kwargs)
def HasU(*args, **kwargs):
"""HasU() -> bool"""
return _misc.Joystick_HasU(*args, **kwargs)
def HasV(*args, **kwargs):
"""HasV() -> bool"""
return _misc.Joystick_HasV(*args, **kwargs)
def HasPOV(*args, **kwargs):
"""HasPOV() -> bool"""
return _misc.Joystick_HasPOV(*args, **kwargs)
def HasPOV4Dir(*args, **kwargs):
"""HasPOV4Dir() -> bool"""
return _misc.Joystick_HasPOV4Dir(*args, **kwargs)
def HasPOVCTS(*args, **kwargs):
"""HasPOVCTS() -> bool"""
return _misc.Joystick_HasPOVCTS(*args, **kwargs)
def SetCapture(*args, **kwargs):
"""SetCapture(Window win, int pollingFreq=0) -> bool"""
return _misc.Joystick_SetCapture(*args, **kwargs)
def ReleaseCapture(*args, **kwargs):
"""ReleaseCapture() -> bool"""
return _misc.Joystick_ReleaseCapture(*args, **kwargs)
def __nonzero__(self): return self.IsOk()
class JoystickPtr(Joystick):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Joystick
_misc.Joystick_swigregister(JoystickPtr)
wxEVT_JOY_BUTTON_DOWN = _misc.wxEVT_JOY_BUTTON_DOWN
wxEVT_JOY_BUTTON_UP = _misc.wxEVT_JOY_BUTTON_UP
wxEVT_JOY_MOVE = _misc.wxEVT_JOY_MOVE
wxEVT_JOY_ZMOVE = _misc.wxEVT_JOY_ZMOVE
class JoystickEvent(core.Event):
def __repr__(self):
return "<%s.%s; proxy of C++ wxJoystickEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
m_pos = property(_misc.JoystickEvent_m_pos_get, _misc.JoystickEvent_m_pos_set)
m_zPosition = property(_misc.JoystickEvent_m_zPosition_get, _misc.JoystickEvent_m_zPosition_set)
m_buttonChange = property(_misc.JoystickEvent_m_buttonChange_get, _misc.JoystickEvent_m_buttonChange_set)
m_buttonState = property(_misc.JoystickEvent_m_buttonState_get, _misc.JoystickEvent_m_buttonState_set)
m_joyStick = property(_misc.JoystickEvent_m_joyStick_get, _misc.JoystickEvent_m_joyStick_set)
def __init__(self, *args, **kwargs):
"""
__init__(wxEventType type=wxEVT_NULL, int state=0, int joystick=JOYSTICK1,
int change=0) -> JoystickEvent
"""
newobj = _misc.new_JoystickEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetPosition(*args, **kwargs):
"""GetPosition() -> Point"""
return _misc.JoystickEvent_GetPosition(*args, **kwargs)
def GetZPosition(*args, **kwargs):
"""GetZPosition() -> int"""
return _misc.JoystickEvent_GetZPosition(*args, **kwargs)
def GetButtonState(*args, **kwargs):
"""GetButtonState() -> int"""
return _misc.JoystickEvent_GetButtonState(*args, **kwargs)
def GetButtonChange(*args, **kwargs):
"""GetButtonChange() -> int"""
return _misc.JoystickEvent_GetButtonChange(*args, **kwargs)
def GetJoystick(*args, **kwargs):
"""GetJoystick() -> int"""
return _misc.JoystickEvent_GetJoystick(*args, **kwargs)
def SetJoystick(*args, **kwargs):
"""SetJoystick(int stick)"""
return _misc.JoystickEvent_SetJoystick(*args, **kwargs)
def SetButtonState(*args, **kwargs):
"""SetButtonState(int state)"""
return _misc.JoystickEvent_SetButtonState(*args, **kwargs)
def SetButtonChange(*args, **kwargs):
"""SetButtonChange(int change)"""
return _misc.JoystickEvent_SetButtonChange(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(Point pos)"""
return _misc.JoystickEvent_SetPosition(*args, **kwargs)
def SetZPosition(*args, **kwargs):
"""SetZPosition(int zPos)"""
return _misc.JoystickEvent_SetZPosition(*args, **kwargs)
def IsButton(*args, **kwargs):
"""IsButton() -> bool"""
return _misc.JoystickEvent_IsButton(*args, **kwargs)
def IsMove(*args, **kwargs):
"""IsMove() -> bool"""
return _misc.JoystickEvent_IsMove(*args, **kwargs)
def IsZMove(*args, **kwargs):
"""IsZMove() -> bool"""
return _misc.JoystickEvent_IsZMove(*args, **kwargs)
def ButtonDown(*args, **kwargs):
"""ButtonDown(int but=JOY_BUTTON_ANY) -> bool"""
return _misc.JoystickEvent_ButtonDown(*args, **kwargs)
def ButtonUp(*args, **kwargs):
"""ButtonUp(int but=JOY_BUTTON_ANY) -> bool"""
return _misc.JoystickEvent_ButtonUp(*args, **kwargs)
def ButtonIsDown(*args, **kwargs):
"""ButtonIsDown(int but=JOY_BUTTON_ANY) -> bool"""
return _misc.JoystickEvent_ButtonIsDown(*args, **kwargs)
class JoystickEventPtr(JoystickEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = JoystickEvent
_misc.JoystickEvent_swigregister(JoystickEventPtr)
EVT_JOY_BUTTON_DOWN = wx.PyEventBinder( wxEVT_JOY_BUTTON_DOWN )
EVT_JOY_BUTTON_UP = wx.PyEventBinder( wxEVT_JOY_BUTTON_UP )
EVT_JOY_MOVE = wx.PyEventBinder( wxEVT_JOY_MOVE )
EVT_JOY_ZMOVE = wx.PyEventBinder( wxEVT_JOY_ZMOVE )
EVT_JOYSTICK_EVENTS = wx.PyEventBinder([ wxEVT_JOY_BUTTON_DOWN,
wxEVT_JOY_BUTTON_UP,
wxEVT_JOY_MOVE,
wxEVT_JOY_ZMOVE,
])
#---------------------------------------------------------------------------
class Wave(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxWave instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String fileName, bool isResource=False) -> Wave"""
newobj = _misc.new_Wave(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_Wave):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def IsOk(*args, **kwargs):
"""IsOk() -> bool"""
return _misc.Wave_IsOk(*args, **kwargs)
def Play(*args, **kwargs):
"""Play(bool async=True, bool looped=False) -> bool"""
return _misc.Wave_Play(*args, **kwargs)
def __nonzero__(self): return self.IsOk()
class WavePtr(Wave):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Wave
_misc.Wave_swigregister(WavePtr)
def WaveData(*args, **kwargs):
"""WaveData(String data) -> Wave"""
val = _misc.new_WaveData(*args, **kwargs)
val.thisown = 1
return val
#---------------------------------------------------------------------------
MAILCAP_STANDARD = _misc.MAILCAP_STANDARD
MAILCAP_NETSCAPE = _misc.MAILCAP_NETSCAPE
MAILCAP_KDE = _misc.MAILCAP_KDE
MAILCAP_GNOME = _misc.MAILCAP_GNOME
MAILCAP_ALL = _misc.MAILCAP_ALL
class FileTypeInfo(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileTypeInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String mimeType, String openCmd, String printCmd, String desc) -> FileTypeInfo"""
newobj = _misc.new_FileTypeInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def IsValid(*args, **kwargs):
"""IsValid() -> bool"""
return _misc.FileTypeInfo_IsValid(*args, **kwargs)
def SetIcon(*args, **kwargs):
"""SetIcon(String iconFile, int iconIndex=0)"""
return _misc.FileTypeInfo_SetIcon(*args, **kwargs)
def SetShortDesc(*args, **kwargs):
"""SetShortDesc(String shortDesc)"""
return _misc.FileTypeInfo_SetShortDesc(*args, **kwargs)
def GetMimeType(*args, **kwargs):
"""GetMimeType() -> String"""
return _misc.FileTypeInfo_GetMimeType(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
"""GetOpenCommand() -> String"""
return _misc.FileTypeInfo_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
"""GetPrintCommand() -> String"""
return _misc.FileTypeInfo_GetPrintCommand(*args, **kwargs)
def GetShortDesc(*args, **kwargs):
"""GetShortDesc() -> String"""
return _misc.FileTypeInfo_GetShortDesc(*args, **kwargs)
def GetDescription(*args, **kwargs):
"""GetDescription() -> String"""
return _misc.FileTypeInfo_GetDescription(*args, **kwargs)
def GetExtensions(*args, **kwargs):
"""GetExtensions() -> wxArrayString"""
return _misc.FileTypeInfo_GetExtensions(*args, **kwargs)
def GetExtensionsCount(*args, **kwargs):
"""GetExtensionsCount() -> int"""
return _misc.FileTypeInfo_GetExtensionsCount(*args, **kwargs)
def GetIconFile(*args, **kwargs):
"""GetIconFile() -> String"""
return _misc.FileTypeInfo_GetIconFile(*args, **kwargs)
def GetIconIndex(*args, **kwargs):
"""GetIconIndex() -> int"""
return _misc.FileTypeInfo_GetIconIndex(*args, **kwargs)
class FileTypeInfoPtr(FileTypeInfo):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileTypeInfo
_misc.FileTypeInfo_swigregister(FileTypeInfoPtr)
def FileTypeInfoSequence(*args, **kwargs):
"""FileTypeInfoSequence(wxArrayString sArray) -> FileTypeInfo"""
val = _misc.new_FileTypeInfoSequence(*args, **kwargs)
val.thisown = 1
return val
def NullFileTypeInfo(*args, **kwargs):
"""NullFileTypeInfo() -> FileTypeInfo"""
val = _misc.new_NullFileTypeInfo(*args, **kwargs)
val.thisown = 1
return val
class FileType(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileType instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(FileTypeInfo ftInfo) -> FileType"""
newobj = _misc.new_FileType(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_FileType):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def GetMimeType(*args, **kwargs):
"""GetMimeType() -> PyObject"""
return _misc.FileType_GetMimeType(*args, **kwargs)
def GetMimeTypes(*args, **kwargs):
"""GetMimeTypes() -> PyObject"""
return _misc.FileType_GetMimeTypes(*args, **kwargs)
def GetExtensions(*args, **kwargs):
"""GetExtensions() -> PyObject"""
return _misc.FileType_GetExtensions(*args, **kwargs)
def GetIcon(*args, **kwargs):
"""GetIcon() -> Icon"""
return _misc.FileType_GetIcon(*args, **kwargs)
def GetIconInfo(*args, **kwargs):
"""GetIconInfo() -> PyObject"""
return _misc.FileType_GetIconInfo(*args, **kwargs)
def GetDescription(*args, **kwargs):
"""GetDescription() -> PyObject"""
return _misc.FileType_GetDescription(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
"""GetOpenCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
"""GetPrintCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetPrintCommand(*args, **kwargs)
def GetAllCommands(*args, **kwargs):
"""GetAllCommands(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetAllCommands(*args, **kwargs)
def SetCommand(*args, **kwargs):
"""SetCommand(String cmd, String verb, bool overwriteprompt=True) -> bool"""
return _misc.FileType_SetCommand(*args, **kwargs)
def SetDefaultIcon(*args, **kwargs):
"""SetDefaultIcon(String cmd=EmptyString, int index=0) -> bool"""
return _misc.FileType_SetDefaultIcon(*args, **kwargs)
def Unassociate(*args, **kwargs):
"""Unassociate() -> bool"""
return _misc.FileType_Unassociate(*args, **kwargs)
def ExpandCommand(*args, **kwargs):
"""FileType.ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
return _misc.FileType_ExpandCommand(*args, **kwargs)
ExpandCommand = staticmethod(ExpandCommand)
class FileTypePtr(FileType):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileType
_misc.FileType_swigregister(FileTypePtr)
def FileType_ExpandCommand(*args, **kwargs):
"""FileType_ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
return _misc.FileType_ExpandCommand(*args, **kwargs)
class MimeTypesManager(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMimeTypesManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def IsOfType(*args, **kwargs):
"""MimeTypesManager.IsOfType(String mimeType, String wildcard) -> bool"""
return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
IsOfType = staticmethod(IsOfType)
def __init__(self, *args, **kwargs):
"""__init__() -> MimeTypesManager"""
newobj = _misc.new_MimeTypesManager(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Initialize(*args, **kwargs):
"""Initialize(int mailcapStyle=MAILCAP_ALL, String extraDir=EmptyString)"""
return _misc.MimeTypesManager_Initialize(*args, **kwargs)
def ClearData(*args, **kwargs):
"""ClearData()"""
return _misc.MimeTypesManager_ClearData(*args, **kwargs)
def GetFileTypeFromExtension(*args, **kwargs):
"""GetFileTypeFromExtension(String ext) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromExtension(*args, **kwargs)
def GetFileTypeFromMimeType(*args, **kwargs):
"""GetFileTypeFromMimeType(String mimeType) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromMimeType(*args, **kwargs)
def ReadMailcap(*args, **kwargs):
"""ReadMailcap(String filename, bool fallback=False) -> bool"""
return _misc.MimeTypesManager_ReadMailcap(*args, **kwargs)
def ReadMimeTypes(*args, **kwargs):
"""ReadMimeTypes(String filename) -> bool"""
return _misc.MimeTypesManager_ReadMimeTypes(*args, **kwargs)
def EnumAllFileTypes(*args, **kwargs):
"""EnumAllFileTypes() -> PyObject"""
return _misc.MimeTypesManager_EnumAllFileTypes(*args, **kwargs)
def AddFallback(*args, **kwargs):
"""AddFallback(FileTypeInfo ft)"""
return _misc.MimeTypesManager_AddFallback(*args, **kwargs)
def Associate(*args, **kwargs):
"""Associate(FileTypeInfo ftInfo) -> FileType"""
return _misc.MimeTypesManager_Associate(*args, **kwargs)
def Unassociate(*args, **kwargs):
"""Unassociate(FileType ft) -> bool"""
return _misc.MimeTypesManager_Unassociate(*args, **kwargs)
def __del__(self, destroy=_misc.delete_MimeTypesManager):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class MimeTypesManagerPtr(MimeTypesManager):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MimeTypesManager
_misc.MimeTypesManager_swigregister(MimeTypesManagerPtr)
TheMimeTypesManager = cvar.TheMimeTypesManager
def MimeTypesManager_IsOfType(*args, **kwargs):
"""MimeTypesManager_IsOfType(String mimeType, String wildcard) -> bool"""
return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
#---------------------------------------------------------------------------
class ArtProvider(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyArtProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> ArtProvider"""
newobj = _misc.new_ArtProvider(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, ArtProvider)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.ArtProvider__setCallbackInfo(*args, **kwargs)
def PushProvider(*args, **kwargs):
"""
ArtProvider.PushProvider(ArtProvider provider)
Add new provider to the top of providers stack.
"""
return _misc.ArtProvider_PushProvider(*args, **kwargs)
PushProvider = staticmethod(PushProvider)
def PopProvider(*args, **kwargs):
"""
ArtProvider.PopProvider() -> bool
Remove latest added provider and delete it.
"""
return _misc.ArtProvider_PopProvider(*args, **kwargs)
PopProvider = staticmethod(PopProvider)
def RemoveProvider(*args, **kwargs):
"""
ArtProvider.RemoveProvider(ArtProvider provider) -> bool
Remove provider. The provider must have been added previously!
The provider is _not_ deleted.
"""
return _misc.ArtProvider_RemoveProvider(*args, **kwargs)
RemoveProvider = staticmethod(RemoveProvider)
def GetBitmap(*args, **kwargs):
"""
ArtProvider.GetBitmap(String id, String client=ART_OTHER, Size size=DefaultSize) -> Bitmap
Query the providers for bitmap with given ID and return it. Return
wx.NullBitmap if no provider provides it.
"""
return _misc.ArtProvider_GetBitmap(*args, **kwargs)
GetBitmap = staticmethod(GetBitmap)
def GetIcon(*args, **kwargs):
"""
ArtProvider.GetIcon(String id, String client=ART_OTHER, Size size=DefaultSize) -> Icon
Query the providers for icon with given ID and return it. Return
wx.NullIcon if no provider provides it.
"""
return _misc.ArtProvider_GetIcon(*args, **kwargs)
GetIcon = staticmethod(GetIcon)
def Destroy(*args, **kwargs):
"""Destroy()"""
return _misc.ArtProvider_Destroy(*args, **kwargs)
class ArtProviderPtr(ArtProvider):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ArtProvider
_misc.ArtProvider_swigregister(ArtProviderPtr)
ART_TOOLBAR = cvar.ART_TOOLBAR
ART_MENU = cvar.ART_MENU
ART_FRAME_ICON = cvar.ART_FRAME_ICON
ART_CMN_DIALOG = cvar.ART_CMN_DIALOG
ART_HELP_BROWSER = cvar.ART_HELP_BROWSER
ART_MESSAGE_BOX = cvar.ART_MESSAGE_BOX
ART_OTHER = cvar.ART_OTHER
ART_ADD_BOOKMARK = cvar.ART_ADD_BOOKMARK
ART_DEL_BOOKMARK = cvar.ART_DEL_BOOKMARK
ART_HELP_SIDE_PANEL = cvar.ART_HELP_SIDE_PANEL
ART_HELP_SETTINGS = cvar.ART_HELP_SETTINGS
ART_HELP_BOOK = cvar.ART_HELP_BOOK
ART_HELP_FOLDER = cvar.ART_HELP_FOLDER
ART_HELP_PAGE = cvar.ART_HELP_PAGE
ART_GO_BACK = cvar.ART_GO_BACK
ART_GO_FORWARD = cvar.ART_GO_FORWARD
ART_GO_UP = cvar.ART_GO_UP
ART_GO_DOWN = cvar.ART_GO_DOWN
ART_GO_TO_PARENT = cvar.ART_GO_TO_PARENT
ART_GO_HOME = cvar.ART_GO_HOME
ART_FILE_OPEN = cvar.ART_FILE_OPEN
ART_PRINT = cvar.ART_PRINT
ART_HELP = cvar.ART_HELP
ART_TIP = cvar.ART_TIP
ART_REPORT_VIEW = cvar.ART_REPORT_VIEW
ART_LIST_VIEW = cvar.ART_LIST_VIEW
ART_NEW_DIR = cvar.ART_NEW_DIR
ART_FOLDER = cvar.ART_FOLDER
ART_GO_DIR_UP = cvar.ART_GO_DIR_UP
ART_EXECUTABLE_FILE = cvar.ART_EXECUTABLE_FILE
ART_NORMAL_FILE = cvar.ART_NORMAL_FILE
ART_TICK_MARK = cvar.ART_TICK_MARK
ART_CROSS_MARK = cvar.ART_CROSS_MARK
ART_ERROR = cvar.ART_ERROR
ART_QUESTION = cvar.ART_QUESTION
ART_WARNING = cvar.ART_WARNING
ART_INFORMATION = cvar.ART_INFORMATION
ART_MISSING_IMAGE = cvar.ART_MISSING_IMAGE
def ArtProvider_PushProvider(*args, **kwargs):
"""
ArtProvider_PushProvider(ArtProvider provider)
Add new provider to the top of providers stack.
"""
return _misc.ArtProvider_PushProvider(*args, **kwargs)
def ArtProvider_PopProvider(*args, **kwargs):
"""
ArtProvider_PopProvider() -> bool
Remove latest added provider and delete it.
"""
return _misc.ArtProvider_PopProvider(*args, **kwargs)
def ArtProvider_RemoveProvider(*args, **kwargs):
"""
ArtProvider_RemoveProvider(ArtProvider provider) -> bool
Remove provider. The provider must have been added previously!
The provider is _not_ deleted.
"""
return _misc.ArtProvider_RemoveProvider(*args, **kwargs)
def ArtProvider_GetBitmap(*args, **kwargs):
"""
ArtProvider_GetBitmap(String id, String client=ART_OTHER, Size size=DefaultSize) -> Bitmap
Query the providers for bitmap with given ID and return it. Return
wx.NullBitmap if no provider provides it.
"""
return _misc.ArtProvider_GetBitmap(*args, **kwargs)
def ArtProvider_GetIcon(*args, **kwargs):
"""
ArtProvider_GetIcon(String id, String client=ART_OTHER, Size size=DefaultSize) -> Icon
Query the providers for icon with given ID and return it. Return
wx.NullIcon if no provider provides it.
"""
return _misc.ArtProvider_GetIcon(*args, **kwargs)
#---------------------------------------------------------------------------
CONFIG_USE_LOCAL_FILE = _misc.CONFIG_USE_LOCAL_FILE
CONFIG_USE_GLOBAL_FILE = _misc.CONFIG_USE_GLOBAL_FILE
CONFIG_USE_RELATIVE_PATH = _misc.CONFIG_USE_RELATIVE_PATH
CONFIG_USE_NO_ESCAPE_CHARACTERS = _misc.CONFIG_USE_NO_ESCAPE_CHARACTERS
class ConfigBase(object):
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxConfigBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __del__(self, destroy=_misc.delete_ConfigBase):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
Type_Unknown = _misc.ConfigBase_Type_Unknown
Type_String = _misc.ConfigBase_Type_String
Type_Boolean = _misc.ConfigBase_Type_Boolean
Type_Integer = _misc.ConfigBase_Type_Integer
Type_Float = _misc.ConfigBase_Type_Float
def Set(*args, **kwargs):
"""ConfigBase.Set(ConfigBase pConfig) -> ConfigBase"""
return _misc.ConfigBase_Set(*args, **kwargs)
Set = staticmethod(Set)
def Get(*args, **kwargs):
"""ConfigBase.Get(bool createOnDemand=True) -> ConfigBase"""
return _misc.ConfigBase_Get(*args, **kwargs)
Get = staticmethod(Get)
def Create(*args, **kwargs):
"""ConfigBase.Create() -> ConfigBase"""
return _misc.ConfigBase_Create(*args, **kwargs)
Create = staticmethod(Create)
def DontCreateOnDemand(*args, **kwargs):
"""ConfigBase.DontCreateOnDemand()"""
return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
DontCreateOnDemand = staticmethod(DontCreateOnDemand)
def SetPath(*args, **kwargs):
"""SetPath(String strPath)"""
return _misc.ConfigBase_SetPath(*args, **kwargs)
def GetPath(*args, **kwargs):
"""GetPath() -> String"""
return _misc.ConfigBase_GetPath(*args, **kwargs)
def GetFirstGroup(*args, **kwargs):
"""GetFirstGroup() -> PyObject"""
return _misc.ConfigBase_GetFirstGroup(*args, **kwargs)
def GetNextGroup(*args, **kwargs):
"""GetNextGroup(long index) -> PyObject"""
return _misc.ConfigBase_GetNextGroup(*args, **kwargs)
def GetFirstEntry(*args, **kwargs):
"""GetFirstEntry() -> PyObject"""
return _misc.ConfigBase_GetFirstEntry(*args, **kwargs)
def GetNextEntry(*args, **kwargs):
"""GetNextEntry(long index) -> PyObject"""
return _misc.ConfigBase_GetNextEntry(*args, **kwargs)
def GetNumberOfEntries(*args, **kwargs):
"""GetNumberOfEntries(bool bRecursive=False) -> size_t"""
return _misc.ConfigBase_GetNumberOfEntries(*args, **kwargs)
def GetNumberOfGroups(*args, **kwargs):
"""GetNumberOfGroups(bool bRecursive=False) -> size_t"""
return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
def HasGroup(*args, **kwargs):
"""HasGroup(String strName) -> bool"""
return _misc.ConfigBase_HasGroup(*args, **kwargs)
def HasEntry(*args, **kwargs):
"""HasEntry(String strName) -> bool"""
return _misc.ConfigBase_HasEntry(*args, **kwargs)
def Exists(*args, **kwargs):
"""Exists(String strName) -> bool"""
return _misc.ConfigBase_Exists(*args, **kwargs)
def GetEntryType(*args, **kwargs):
"""GetEntryType(String name) -> int"""
return _misc.ConfigBase_GetEntryType(*args, **kwargs)
def Read(*args, **kwargs):
"""Read(String key, String defaultVal=EmptyString) -> String"""
return _misc.ConfigBase_Read(*args, **kwargs)
def ReadInt(*args, **kwargs):
"""ReadInt(String key, long defaultVal=0) -> long"""
return _misc.ConfigBase_ReadInt(*args, **kwargs)
def ReadFloat(*args, **kwargs):
"""ReadFloat(String key, double defaultVal=0.0) -> double"""
return _misc.ConfigBase_ReadFloat(*args, **kwargs)
def ReadBool(*args, **kwargs):
"""ReadBool(String key, bool defaultVal=False) -> bool"""
return _misc.ConfigBase_ReadBool(*args, **kwargs)
def Write(*args, **kwargs):
"""Write(String key, String value) -> bool"""
return _misc.ConfigBase_Write(*args, **kwargs)
def WriteInt(*args, **kwargs):
"""WriteInt(String key, long value) -> bool"""
return _misc.ConfigBase_WriteInt(*args, **kwargs)
def WriteFloat(*args, **kwargs):
"""WriteFloat(String key, double value) -> bool"""
return _misc.ConfigBase_WriteFloat(*args, **kwargs)
def WriteBool(*args, **kwargs):
"""WriteBool(String key, bool value) -> bool"""
return _misc.ConfigBase_WriteBool(*args, **kwargs)
def Flush(*args, **kwargs):
"""Flush(bool bCurrentOnly=False) -> bool"""
return _misc.ConfigBase_Flush(*args, **kwargs)
def RenameEntry(*args, **kwargs):
"""RenameEntry(String oldName, String newName) -> bool"""
return _misc.ConfigBase_RenameEntry(*args, **kwargs)
def RenameGroup(*args, **kwargs):
"""RenameGroup(String oldName, String newName) -> bool"""
return _misc.ConfigBase_RenameGroup(*args, **kwargs)
def DeleteEntry(*args, **kwargs):
"""DeleteEntry(String key, bool bDeleteGroupIfEmpty=True) -> bool"""
return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
def DeleteGroup(*args, **kwargs):
"""DeleteGroup(String key) -> bool"""
return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
def DeleteAll(*args, **kwargs):
"""DeleteAll() -> bool"""
return _misc.ConfigBase_DeleteAll(*args, **kwargs)
def IsExpandingEnvVars(*args, **kwargs):
"""IsExpandingEnvVars() -> bool"""
return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
def SetExpandEnvVars(*args, **kwargs):
"""SetExpandEnvVars(bool bDoIt=True)"""
return _misc.ConfigBase_SetExpandEnvVars(*args, **kwargs)
def SetRecordDefaults(*args, **kwargs):
"""SetRecordDefaults(bool bDoIt=True)"""
return _misc.ConfigBase_SetRecordDefaults(*args, **kwargs)
def IsRecordingDefaults(*args, **kwargs):
"""IsRecordingDefaults() -> bool"""
return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
def ExpandEnvVars(*args, **kwargs):
"""ExpandEnvVars(String str) -> String"""
return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
def GetAppName(*args, **kwargs):
"""GetAppName() -> String"""
return _misc.ConfigBase_GetAppName(*args, **kwargs)
def GetVendorName(*args, **kwargs):
"""GetVendorName() -> String"""
return _misc.ConfigBase_GetVendorName(*args, **kwargs)
def SetAppName(*args, **kwargs):
"""SetAppName(String appName)"""
return _misc.ConfigBase_SetAppName(*args, **kwargs)
def SetVendorName(*args, **kwargs):
"""SetVendorName(String vendorName)"""
return _misc.ConfigBase_SetVendorName(*args, **kwargs)
def SetStyle(*args, **kwargs):
"""SetStyle(long style)"""
return _misc.ConfigBase_SetStyle(*args, **kwargs)
def GetStyle(*args, **kwargs):
"""GetStyle() -> long"""
return _misc.ConfigBase_GetStyle(*args, **kwargs)
class ConfigBasePtr(ConfigBase):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ConfigBase
_misc.ConfigBase_swigregister(ConfigBasePtr)
def ConfigBase_Set(*args, **kwargs):
"""ConfigBase_Set(ConfigBase pConfig) -> ConfigBase"""
return _misc.ConfigBase_Set(*args, **kwargs)
def ConfigBase_Get(*args, **kwargs):
"""ConfigBase_Get(bool createOnDemand=True) -> ConfigBase"""
return _misc.ConfigBase_Get(*args, **kwargs)
def ConfigBase_Create(*args, **kwargs):
"""ConfigBase_Create() -> ConfigBase"""
return _misc.ConfigBase_Create(*args, **kwargs)
def ConfigBase_DontCreateOnDemand(*args, **kwargs):
"""ConfigBase_DontCreateOnDemand()"""
return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
class ConfigPathChanger(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(ConfigBase pContainer, String strEntry) -> ConfigPathChanger"""
newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_ConfigPathChanger):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Name(*args, **kwargs):
"""Name() -> String"""
return _misc.ConfigPathChanger_Name(*args, **kwargs)
class ConfigPathChangerPtr(ConfigPathChanger):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ConfigPathChanger
_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)
class Config(ConfigBase):
def __repr__(self):
return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(String appName=EmptyString, String vendorName=EmptyString,
String localFilename=EmptyString, String globalFilename=EmptyString,
long style=0) -> Config
"""
newobj = _misc.new_Config(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_Config):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class ConfigPtr(Config):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Config
_misc.Config_swigregister(ConfigPtr)
class FileConfig(ConfigBase):
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(String appName=EmptyString, String vendorName=EmptyString,
String localFilename=EmptyString, String globalFilename=EmptyString,
long style=0) -> FileConfig
"""
newobj = _misc.new_FileConfig(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_FileConfig):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
class FileConfigPtr(FileConfig):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileConfig
_misc.FileConfig_swigregister(FileConfigPtr)
def ExpandEnvVars(*args, **kwargs):
"""ExpandEnvVars(String sz) -> String"""
return _misc.ExpandEnvVars(*args, **kwargs)
#---------------------------------------------------------------------------
class DateTime(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDateTime instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
Local = _misc.DateTime_Local
GMT_12 = _misc.DateTime_GMT_12
GMT_11 = _misc.DateTime_GMT_11
GMT_10 = _misc.DateTime_GMT_10
GMT_9 = _misc.DateTime_GMT_9
GMT_8 = _misc.DateTime_GMT_8
GMT_7 = _misc.DateTime_GMT_7
GMT_6 = _misc.DateTime_GMT_6
GMT_5 = _misc.DateTime_GMT_5
GMT_4 = _misc.DateTime_GMT_4
GMT_3 = _misc.DateTime_GMT_3
GMT_2 = _misc.DateTime_GMT_2
GMT_1 = _misc.DateTime_GMT_1
GMT0 = _misc.DateTime_GMT0
GMT1 = _misc.DateTime_GMT1
GMT2 = _misc.DateTime_GMT2
GMT3 = _misc.DateTime_GMT3
GMT4 = _misc.DateTime_GMT4
GMT5 = _misc.DateTime_GMT5
GMT6 = _misc.DateTime_GMT6
GMT7 = _misc.DateTime_GMT7
GMT8 = _misc.DateTime_GMT8
GMT9 = _misc.DateTime_GMT9
GMT10 = _misc.DateTime_GMT10
GMT11 = _misc.DateTime_GMT11
GMT12 = _misc.DateTime_GMT12
WET = _misc.DateTime_WET
WEST = _misc.DateTime_WEST
CET = _misc.DateTime_CET
CEST = _misc.DateTime_CEST
EET = _misc.DateTime_EET
EEST = _misc.DateTime_EEST
MSK = _misc.DateTime_MSK
MSD = _misc.DateTime_MSD
AST = _misc.DateTime_AST
ADT = _misc.DateTime_ADT
EST = _misc.DateTime_EST
EDT = _misc.DateTime_EDT
CST = _misc.DateTime_CST
CDT = _misc.DateTime_CDT
MST = _misc.DateTime_MST
MDT = _misc.DateTime_MDT
PST = _misc.DateTime_PST
PDT = _misc.DateTime_PDT
HST = _misc.DateTime_HST
AKST = _misc.DateTime_AKST
AKDT = _misc.DateTime_AKDT
A_WST = _misc.DateTime_A_WST
A_CST = _misc.DateTime_A_CST
A_EST = _misc.DateTime_A_EST
A_ESST = _misc.DateTime_A_ESST
UTC = _misc.DateTime_UTC
Gregorian = _misc.DateTime_Gregorian
Julian = _misc.DateTime_Julian
Gr_Unknown = _misc.DateTime_Gr_Unknown
Gr_Standard = _misc.DateTime_Gr_Standard
Gr_Alaska = _misc.DateTime_Gr_Alaska
Gr_Albania = _misc.DateTime_Gr_Albania
Gr_Austria = _misc.DateTime_Gr_Austria
Gr_Austria_Brixen = _misc.DateTime_Gr_Austria_Brixen
Gr_Austria_Salzburg = _misc.DateTime_Gr_Austria_Salzburg
Gr_Austria_Tyrol = _misc.DateTime_Gr_Austria_Tyrol
Gr_Austria_Carinthia = _misc.DateTime_Gr_Austria_Carinthia
Gr_Austria_Styria = _misc.DateTime_Gr_Austria_Styria
Gr_Belgium = _misc.DateTime_Gr_Belgium
Gr_Bulgaria = _misc.DateTime_Gr_Bulgaria
Gr_Bulgaria_1 = _misc.DateTime_Gr_Bulgaria_1
Gr_Bulgaria_2 = _misc.DateTime_Gr_Bulgaria_2
Gr_Bulgaria_3 = _misc.DateTime_Gr_Bulgaria_3
Gr_Canada = _misc.DateTime_Gr_Canada
Gr_China = _misc.DateTime_Gr_China
Gr_China_1 = _misc.DateTime_Gr_China_1
Gr_China_2 = _misc.DateTime_Gr_China_2
Gr_Czechoslovakia = _misc.DateTime_Gr_Czechoslovakia
Gr_Denmark = _misc.DateTime_Gr_Denmark
Gr_Egypt = _misc.DateTime_Gr_Egypt
Gr_Estonia = _misc.DateTime_Gr_Estonia
Gr_Finland = _misc.DateTime_Gr_Finland
Gr_France = _misc.DateTime_Gr_France
Gr_France_Alsace = _misc.DateTime_Gr_France_Alsace
Gr_France_Lorraine = _misc.DateTime_Gr_France_Lorraine
Gr_France_Strasbourg = _misc.DateTime_Gr_France_Strasbourg
Gr_Germany = _misc.DateTime_Gr_Germany
Gr_Germany_Catholic = _misc.DateTime_Gr_Germany_Catholic
Gr_Germany_Prussia = _misc.DateTime_Gr_Germany_Prussia
Gr_Germany_Protestant = _misc.DateTime_Gr_Germany_Protestant
Gr_GreatBritain = _misc.DateTime_Gr_GreatBritain
Gr_Greece = _misc.DateTime_Gr_Greece
Gr_Hungary = _misc.DateTime_Gr_Hungary
Gr_Ireland = _misc.DateTime_Gr_Ireland
Gr_Italy = _misc.DateTime_Gr_Italy
Gr_Japan = _misc.DateTime_Gr_Japan
Gr_Japan_1 = _misc.DateTime_Gr_Japan_1
Gr_Japan_2 = _misc.DateTime_Gr_Japan_2
Gr_Japan_3 = _misc.DateTime_Gr_Japan_3
Gr_Latvia = _misc.DateTime_Gr_Latvia
Gr_Lithuania = _misc.DateTime_Gr_Lithuania
Gr_Luxemburg = _misc.DateTime_Gr_Luxemburg
Gr_Netherlands = _misc.DateTime_Gr_Netherlands
Gr_Netherlands_Groningen = _misc.DateTime_Gr_Netherlands_Groningen
Gr_Netherlands_Gelderland = _misc.DateTime_Gr_Netherlands_Gelderland
Gr_Netherlands_Utrecht = _misc.DateTime_Gr_Netherlands_Utrecht
Gr_Netherlands_Friesland = _misc.DateTime_Gr_Netherlands_Friesland
Gr_Norway = _misc.DateTime_Gr_Norway
Gr_Poland = _misc.DateTime_Gr_Poland
Gr_Portugal = _misc.DateTime_Gr_Portugal
Gr_Romania = _misc.DateTime_Gr_Romania
Gr_Russia = _misc.DateTime_Gr_Russia
Gr_Scotland = _misc.DateTime_Gr_Scotland
Gr_Spain = _misc.DateTime_Gr_Spain
Gr_Sweden = _misc.DateTime_Gr_Sweden
Gr_Switzerland = _misc.DateTime_Gr_Switzerland
Gr_Switzerland_Catholic = _misc.DateTime_Gr_Switzerland_Catholic
Gr_Switzerland_Protestant = _misc.DateTime_Gr_Switzerland_Protestant
Gr_Turkey = _misc.DateTime_Gr_Turkey
Gr_USA = _misc.DateTime_Gr_USA
Gr_Wales = _misc.DateTime_Gr_Wales
Gr_Yugoslavia = _misc.DateTime_Gr_Yugoslavia
Country_Unknown = _misc.DateTime_Country_Unknown
Country_Default = _misc.DateTime_Country_Default
Country_WesternEurope_Start = _misc.DateTime_Country_WesternEurope_Start
Country_EEC = _misc.DateTime_Country_EEC
France = _misc.DateTime_France
Germany = _misc.DateTime_Germany
UK = _misc.DateTime_UK
Country_WesternEurope_End = _misc.DateTime_Country_WesternEurope_End
Russia = _misc.DateTime_Russia
USA = _misc.DateTime_USA
Jan = _misc.DateTime_Jan
Feb = _misc.DateTime_Feb
Mar = _misc.DateTime_Mar
Apr = _misc.DateTime_Apr
May = _misc.DateTime_May
Jun = _misc.DateTime_Jun
Jul = _misc.DateTime_Jul
Aug = _misc.DateTime_Aug
Sep = _misc.DateTime_Sep
Oct = _misc.DateTime_Oct
Nov = _misc.DateTime_Nov
Dec = _misc.DateTime_Dec
Inv_Month = _misc.DateTime_Inv_Month
Sun = _misc.DateTime_Sun
Mon = _misc.DateTime_Mon
Tue = _misc.DateTime_Tue
Wed = _misc.DateTime_Wed
Thu = _misc.DateTime_Thu
Fri = _misc.DateTime_Fri
Sat = _misc.DateTime_Sat
Inv_WeekDay = _misc.DateTime_Inv_WeekDay
Inv_Year = _misc.DateTime_Inv_Year
Name_Full = _misc.DateTime_Name_Full
Name_Abbr = _misc.DateTime_Name_Abbr
Default_First = _misc.DateTime_Default_First
Monday_First = _misc.DateTime_Monday_First
Sunday_First = _misc.DateTime_Sunday_First
def SetCountry(*args, **kwargs):
"""DateTime.SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
SetCountry = staticmethod(SetCountry)
def GetCountry(*args, **kwargs):
"""DateTime.GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
GetCountry = staticmethod(GetCountry)
def IsWestEuropeanCountry(*args, **kwargs):
"""DateTime.IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
IsWestEuropeanCountry = staticmethod(IsWestEuropeanCountry)
def GetCurrentYear(*args, **kwargs):
"""DateTime.GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
GetCurrentYear = staticmethod(GetCurrentYear)
def ConvertYearToBC(*args, **kwargs):
"""DateTime.ConvertYearToBC(int year) -> int"""
return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
ConvertYearToBC = staticmethod(ConvertYearToBC)
def GetCurrentMonth(*args, **kwargs):
"""DateTime.GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
GetCurrentMonth = staticmethod(GetCurrentMonth)
def IsLeapYear(*args, **kwargs):
"""DateTime.IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
return _misc.DateTime_IsLeapYear(*args, **kwargs)
IsLeapYear = staticmethod(IsLeapYear)
def GetCentury(*args, **kwargs):
"""DateTime.GetCentury(int year=Inv_Year) -> int"""
return _misc.DateTime_GetCentury(*args, **kwargs)
GetCentury = staticmethod(GetCentury)
def GetNumberOfDaysinYear(*args, **kwargs):
"""DateTime.GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
def GetNumberOfDaysInMonth(*args, **kwargs):
"""DateTime.GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
def GetMonthName(*args, **kwargs):
"""DateTime.GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
GetMonthName = staticmethod(GetMonthName)
def GetWeekDayName(*args, **kwargs):
"""DateTime.GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
GetWeekDayName = staticmethod(GetWeekDayName)
def GetAmPmStrings(*args, **kwargs):
"""
GetAmPmStrings() -> (am, pm)
Get the AM and PM strings in the current locale (may be empty)
"""
return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
GetAmPmStrings = staticmethod(GetAmPmStrings)
def IsDSTApplicable(*args, **kwargs):
"""DateTime.IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""
return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
IsDSTApplicable = staticmethod(IsDSTApplicable)
def GetBeginDST(*args, **kwargs):
"""DateTime.GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetBeginDST(*args, **kwargs)
GetBeginDST = staticmethod(GetBeginDST)
def GetEndDST(*args, **kwargs):
"""DateTime.GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetEndDST(*args, **kwargs)
GetEndDST = staticmethod(GetEndDST)
def Now(*args, **kwargs):
"""DateTime.Now() -> DateTime"""
return _misc.DateTime_Now(*args, **kwargs)
Now = staticmethod(Now)
def UNow(*args, **kwargs):
"""DateTime.UNow() -> DateTime"""
return _misc.DateTime_UNow(*args, **kwargs)
UNow = staticmethod(UNow)
def Today(*args, **kwargs):
"""DateTime.Today() -> DateTime"""
return _misc.DateTime_Today(*args, **kwargs)
Today = staticmethod(Today)
def __init__(self, *args, **kwargs):
"""__init__() -> DateTime"""
newobj = _misc.new_DateTime(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_DateTime):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def SetToCurrent(*args, **kwargs):
"""SetToCurrent() -> DateTime"""
return _misc.DateTime_SetToCurrent(*args, **kwargs)
def SetTimeT(*args, **kwargs):
"""SetTimeT(time_t timet) -> DateTime"""
return _misc.DateTime_SetTimeT(*args, **kwargs)
def SetJDN(*args, **kwargs):
"""SetJDN(double jdn) -> DateTime"""
return _misc.DateTime_SetJDN(*args, **kwargs)
def SetHMS(*args, **kwargs):
"""SetHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
return _misc.DateTime_SetHMS(*args, **kwargs)
def Set(*args, **kwargs):
"""
Set(int day, int month=Inv_Month, int year=Inv_Year, int hour=0,
int minute=0, int second=0, int millisec=0) -> DateTime
"""
return _misc.DateTime_Set(*args, **kwargs)
def ResetTime(*args, **kwargs):
"""ResetTime() -> DateTime"""
return _misc.DateTime_ResetTime(*args, **kwargs)
def SetYear(*args, **kwargs):
"""SetYear(int year) -> DateTime"""
return _misc.DateTime_SetYear(*args, **kwargs)
def SetMonth(*args, **kwargs):
"""SetMonth(int month) -> DateTime"""
return _misc.DateTime_SetMonth(*args, **kwargs)
def SetDay(*args, **kwargs):
"""SetDay(int day) -> DateTime"""
return _misc.DateTime_SetDay(*args, **kwargs)
def SetHour(*args, **kwargs):
"""SetHour(int hour) -> DateTime"""
return _misc.DateTime_SetHour(*args, **kwargs)
def SetMinute(*args, **kwargs):
"""SetMinute(int minute) -> DateTime"""
return _misc.DateTime_SetMinute(*args, **kwargs)
def SetSecond(*args, **kwargs):
"""SetSecond(int second) -> DateTime"""
return _misc.DateTime_SetSecond(*args, **kwargs)
def SetMillisecond(*args, **kwargs):
"""SetMillisecond(int millisecond) -> DateTime"""
return _misc.DateTime_SetMillisecond(*args, **kwargs)
def SetToWeekDayInSameWeek(*args, **kwargs):
"""SetToWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_SetToWeekDayInSameWeek(*args, **kwargs)
def GetWeekDayInSameWeek(*args, **kwargs):
"""GetWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeekDayInSameWeek(*args, **kwargs)
def SetToNextWeekDay(*args, **kwargs):
"""SetToNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToNextWeekDay(*args, **kwargs)
def GetNextWeekDay(*args, **kwargs):
"""GetNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetNextWeekDay(*args, **kwargs)
def SetToPrevWeekDay(*args, **kwargs):
"""SetToPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToPrevWeekDay(*args, **kwargs)
def GetPrevWeekDay(*args, **kwargs):
"""GetPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetPrevWeekDay(*args, **kwargs)
def SetToWeekDay(*args, **kwargs):
"""SetToWeekDay(int weekday, int n=1, int month=Inv_Month, int year=Inv_Year) -> bool"""
return _misc.DateTime_SetToWeekDay(*args, **kwargs)
def SetToLastWeekDay(*args, **kwargs):
"""SetToLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> bool"""
return _misc.DateTime_SetToLastWeekDay(*args, **kwargs)
def GetLastWeekDay(*args, **kwargs):
"""GetLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_GetLastWeekDay(*args, **kwargs)
def SetToTheWeek(*args, **kwargs):
"""SetToTheWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> bool"""
return _misc.DateTime_SetToTheWeek(*args, **kwargs)
def GetWeek(*args, **kwargs):
"""GetWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeek(*args, **kwargs)
def SetToLastMonthDay(*args, **kwargs):
"""SetToLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_SetToLastMonthDay(*args, **kwargs)
def GetLastMonthDay(*args, **kwargs):
"""GetLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
def SetToYearDay(*args, **kwargs):
"""SetToYearDay(int yday) -> DateTime"""
return _misc.DateTime_SetToYearDay(*args, **kwargs)
def GetYearDay(*args, **kwargs):
"""GetYearDay(int yday) -> DateTime"""
return _misc.DateTime_GetYearDay(*args, **kwargs)
def GetJulianDayNumber(*args, **kwargs):
"""GetJulianDayNumber() -> double"""
return _misc.DateTime_GetJulianDayNumber(*args, **kwargs)
def GetJDN(*args, **kwargs):
"""GetJDN() -> double"""
return _misc.DateTime_GetJDN(*args, **kwargs)
def GetModifiedJulianDayNumber(*args, **kwargs):
"""GetModifiedJulianDayNumber() -> double"""
return _misc.DateTime_GetModifiedJulianDayNumber(*args, **kwargs)
def GetMJD(*args, **kwargs):
"""GetMJD() -> double"""
return _misc.DateTime_GetMJD(*args, **kwargs)
def GetRataDie(*args, **kwargs):
"""GetRataDie() -> double"""
return _misc.DateTime_GetRataDie(*args, **kwargs)
def ToTimezone(*args, **kwargs):
"""ToTimezone(wxDateTime::TimeZone tz, bool noDST=False) -> DateTime"""
return _misc.DateTime_ToTimezone(*args, **kwargs)
def MakeTimezone(*args, **kwargs):
"""MakeTimezone(wxDateTime::TimeZone tz, bool noDST=False) -> DateTime"""
return _misc.DateTime_MakeTimezone(*args, **kwargs)
def ToGMT(*args, **kwargs):
"""ToGMT(bool noDST=False) -> DateTime"""
return _misc.DateTime_ToGMT(*args, **kwargs)
def MakeGMT(*args, **kwargs):
"""MakeGMT(bool noDST=False) -> DateTime"""
return _misc.DateTime_MakeGMT(*args, **kwargs)
def IsDST(*args, **kwargs):
"""IsDST(int country=Country_Default) -> int"""
return _misc.DateTime_IsDST(*args, **kwargs)
def IsValid(*args, **kwargs):
"""IsValid() -> bool"""
return _misc.DateTime_IsValid(*args, **kwargs)
def GetTicks(*args, **kwargs):
"""GetTicks() -> time_t"""
return _misc.DateTime_GetTicks(*args, **kwargs)
def GetYear(*args, **kwargs):
"""GetYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetYear(*args, **kwargs)
def GetMonth(*args, **kwargs):
"""GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetMonth(*args, **kwargs)
def GetDay(*args, **kwargs):
"""GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetDay(*args, **kwargs)
def GetWeekDay(*args, **kwargs):
"""GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekDay(*args, **kwargs)
def GetHour(*args, **kwargs):
"""GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetHour(*args, **kwargs)
def GetMinute(*args, **kwargs):
"""GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetMinute(*args, **kwargs)
def GetSecond(*args, **kwargs):
"""GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetSecond(*args, **kwargs)
def GetMillisecond(*args, **kwargs):
"""GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetMillisecond(*args, **kwargs)
def GetDayOfYear(*args, **kwargs):
"""GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetDayOfYear(*args, **kwargs)
def GetWeekOfYear(*args, **kwargs):
"""GetWeekOfYear(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
def GetWeekOfMonth(*args, **kwargs):
"""GetWeekOfMonth(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
def IsWorkDay(*args, **kwargs):
"""IsWorkDay(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWorkDay(*args, **kwargs)
def IsEqualTo(*args, **kwargs):
"""IsEqualTo(DateTime datetime) -> bool"""
return _misc.DateTime_IsEqualTo(*args, **kwargs)
def IsEarlierThan(*args, **kwargs):
"""IsEarlierThan(DateTime datetime) -> bool"""
return _misc.DateTime_IsEarlierThan(*args, **kwargs)
def IsLaterThan(*args, **kwargs):
"""IsLaterThan(DateTime datetime) -> bool"""
return _misc.DateTime_IsLaterThan(*args, **kwargs)
def IsStrictlyBetween(*args, **kwargs):
"""IsStrictlyBetween(DateTime t1, DateTime t2) -> bool"""
return _misc.DateTime_IsStrictlyBetween(*args, **kwargs)
def IsBetween(*args, **kwargs):
"""IsBetween(DateTime t1, DateTime t2) -> bool"""
return _misc.DateTime_IsBetween(*args, **kwargs)
def IsSameDate(*args, **kwargs):
"""IsSameDate(DateTime dt) -> bool"""
return _misc.DateTime_IsSameDate(*args, **kwargs)
def IsSameTime(*args, **kwargs):
"""IsSameTime(DateTime dt) -> bool"""
return _misc.DateTime_IsSameTime(*args, **kwargs)
def IsEqualUpTo(*args, **kwargs):
"""IsEqualUpTo(DateTime dt, TimeSpan ts) -> bool"""
return _misc.DateTime_IsEqualUpTo(*args, **kwargs)
def AddTS(*args, **kwargs):
"""AddTS(TimeSpan diff) -> DateTime"""
return _misc.DateTime_AddTS(*args, **kwargs)
def AddDS(*args, **kwargs):
"""AddDS(DateSpan diff) -> DateTime"""
return _misc.DateTime_AddDS(*args, **kwargs)
def SubtractTS(*args, **kwargs):
"""SubtractTS(TimeSpan diff) -> DateTime"""
return _misc.DateTime_SubtractTS(*args, **kwargs)
def SubtractDS(*args, **kwargs):
"""SubtractDS(DateSpan diff) -> DateTime"""
return _misc.DateTime_SubtractDS(*args, **kwargs)
def Subtract(*args, **kwargs):
"""Subtract(DateTime dt) -> TimeSpan"""
return _misc.DateTime_Subtract(*args, **kwargs)
def __iadd__(*args):
"""
__iadd__(TimeSpan diff) -> DateTime
__iadd__(DateSpan diff) -> DateTime
"""
return _misc.DateTime___iadd__(*args)
def __isub__(*args):
"""
__isub__(TimeSpan diff) -> DateTime
__isub__(DateSpan diff) -> DateTime
"""
return _misc.DateTime___isub__(*args)
def __add__(*args):
"""
__add__(TimeSpan other) -> DateTime
__add__(DateSpan other) -> DateTime
"""
return _misc.DateTime___add__(*args)
def __sub__(*args):
"""
__sub__(DateTime other) -> TimeSpan
__sub__(TimeSpan other) -> DateTime
__sub__(DateSpan other) -> DateTime
"""
return _misc.DateTime___sub__(*args)
def __lt__(*args):
"""__lt__(DateTime other) -> bool"""
return _misc.DateTime___lt__(*args)
def __le__(*args):
"""__le__(DateTime other) -> bool"""
return _misc.DateTime___le__(*args)
def __gt__(*args):
"""__gt__(DateTime other) -> bool"""
return _misc.DateTime___gt__(*args)
def __ge__(*args):
"""__ge__(DateTime other) -> bool"""
return _misc.DateTime___ge__(*args)
def __eq__(*args):
"""__eq__(DateTime other) -> bool"""
return _misc.DateTime___eq__(*args)
def __ne__(*args):
"""__ne__(DateTime other) -> bool"""
return _misc.DateTime___ne__(*args)
def ParseRfc822Date(*args, **kwargs):
"""ParseRfc822Date(String date) -> int"""
return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
def ParseFormat(*args, **kwargs):
"""ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int"""
return _misc.DateTime_ParseFormat(*args, **kwargs)
def ParseDateTime(*args, **kwargs):
"""ParseDateTime(String datetime) -> int"""
return _misc.DateTime_ParseDateTime(*args, **kwargs)
def ParseDate(*args, **kwargs):
"""ParseDate(String date) -> int"""
return _misc.DateTime_ParseDate(*args, **kwargs)
def ParseTime(*args, **kwargs):
"""ParseTime(String time) -> int"""
return _misc.DateTime_ParseTime(*args, **kwargs)
def Format(*args, **kwargs):
"""Format(String format=DateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> String"""
return _misc.DateTime_Format(*args, **kwargs)
def FormatDate(*args, **kwargs):
"""FormatDate() -> String"""
return _misc.DateTime_FormatDate(*args, **kwargs)
def FormatTime(*args, **kwargs):
"""FormatTime() -> String"""
return _misc.DateTime_FormatTime(*args, **kwargs)
def FormatISODate(*args, **kwargs):
"""FormatISODate() -> String"""
return _misc.DateTime_FormatISODate(*args, **kwargs)
def FormatISOTime(*args, **kwargs):
"""FormatISOTime() -> String"""
return _misc.DateTime_FormatISOTime(*args, **kwargs)
def __repr__(self):
return '<wxDateTime: \"%s\" at %s>' % ( self.Format(), self.this)
def __str__(self):
return self.Format()
class DateTimePtr(DateTime):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DateTime
_misc.DateTime_swigregister(DateTimePtr)
DateFormatStr = cvar.DateFormatStr
TimeSpanFormatStr = cvar.TimeSpanFormatStr
def DateTime_SetCountry(*args, **kwargs):
"""DateTime_SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
def DateTime_GetCountry(*args, **kwargs):
"""DateTime_GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
def DateTime_IsWestEuropeanCountry(*args, **kwargs):
"""DateTime_IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
def DateTime_GetCurrentYear(*args, **kwargs):
"""DateTime_GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
def DateTime_ConvertYearToBC(*args, **kwargs):
"""DateTime_ConvertYearToBC(int year) -> int"""
return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
def DateTime_GetCurrentMonth(*args, **kwargs):
"""DateTime_GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
def DateTime_IsLeapYear(*args, **kwargs):
"""DateTime_IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
return _misc.DateTime_IsLeapYear(*args, **kwargs)
def DateTime_GetCentury(*args, **kwargs):
"""DateTime_GetCentury(int year=Inv_Year) -> int"""
return _misc.DateTime_GetCentury(*args, **kwargs)
def DateTime_GetNumberOfDaysinYear(*args, **kwargs):
"""DateTime_GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
def DateTime_GetNumberOfDaysInMonth(*args, **kwargs):
"""DateTime_GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
def DateTime_GetMonthName(*args, **kwargs):
"""DateTime_GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
def DateTime_GetWeekDayName(*args, **kwargs):
"""DateTime_GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
def DateTime_GetAmPmStrings(*args, **kwargs):
"""
GetAmPmStrings() -> (am, pm)
Get the AM and PM strings in the current locale (may be empty)
"""
return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
def DateTime_IsDSTApplicable(*args, **kwargs):
"""DateTime_IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""
return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
def DateTime_GetBeginDST(*args, **kwargs):
"""DateTime_GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetBeginDST(*args, **kwargs)
def DateTime_GetEndDST(*args, **kwargs):
"""DateTime_GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetEndDST(*args, **kwargs)
def DateTime_Now(*args, **kwargs):
"""DateTime_Now() -> DateTime"""
return _misc.DateTime_Now(*args, **kwargs)
def DateTime_UNow(*args, **kwargs):
"""DateTime_UNow() -> DateTime"""
return _misc.DateTime_UNow(*args, **kwargs)
def DateTime_Today(*args, **kwargs):
"""DateTime_Today() -> DateTime"""
return _misc.DateTime_Today(*args, **kwargs)
def DateTimeFromTimeT(*args, **kwargs):
"""DateTimeFromTimeT(time_t timet) -> DateTime"""
val = _misc.new_DateTimeFromTimeT(*args, **kwargs)
val.thisown = 1
return val
def DateTimeFromJDN(*args, **kwargs):
"""DateTimeFromJDN(double jdn) -> DateTime"""
val = _misc.new_DateTimeFromJDN(*args, **kwargs)
val.thisown = 1
return val
def DateTimeFromHMS(*args, **kwargs):
"""DateTimeFromHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
val = _misc.new_DateTimeFromHMS(*args, **kwargs)
val.thisown = 1
return val
def DateTimeFromDMY(*args, **kwargs):
"""
DateTimeFromDMY(int day, int month=Inv_Month, int year=Inv_Year, int hour=0,
int minute=0, int second=0, int millisec=0) -> DateTime
"""
val = _misc.new_DateTimeFromDMY(*args, **kwargs)
val.thisown = 1
return val
class TimeSpan(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxTimeSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Seconds(*args, **kwargs):
"""TimeSpan.Seconds(long sec) -> TimeSpan"""
return _misc.TimeSpan_Seconds(*args, **kwargs)
Seconds = staticmethod(Seconds)
def Second(*args, **kwargs):
"""TimeSpan.Second() -> TimeSpan"""
return _misc.TimeSpan_Second(*args, **kwargs)
Second = staticmethod(Second)
def Minutes(*args, **kwargs):
"""TimeSpan.Minutes(long min) -> TimeSpan"""
return _misc.TimeSpan_Minutes(*args, **kwargs)
Minutes = staticmethod(Minutes)
def Minute(*args, **kwargs):
"""TimeSpan.Minute() -> TimeSpan"""
return _misc.TimeSpan_Minute(*args, **kwargs)
Minute = staticmethod(Minute)
def Hours(*args, **kwargs):
"""TimeSpan.Hours(long hours) -> TimeSpan"""
return _misc.TimeSpan_Hours(*args, **kwargs)
Hours = staticmethod(Hours)
def Hour(*args, **kwargs):
"""TimeSpan.Hour() -> TimeSpan"""
return _misc.TimeSpan_Hour(*args, **kwargs)
Hour = staticmethod(Hour)
def Days(*args, **kwargs):
"""TimeSpan.Days(long days) -> TimeSpan"""
return _misc.TimeSpan_Days(*args, **kwargs)
Days = staticmethod(Days)
def Day(*args, **kwargs):
"""TimeSpan.Day() -> TimeSpan"""
return _misc.TimeSpan_Day(*args, **kwargs)
Day = staticmethod(Day)
def Weeks(*args, **kwargs):
"""TimeSpan.Weeks(long days) -> TimeSpan"""
return _misc.TimeSpan_Weeks(*args, **kwargs)
Weeks = staticmethod(Weeks)
def Week(*args, **kwargs):
"""TimeSpan.Week() -> TimeSpan"""
return _misc.TimeSpan_Week(*args, **kwargs)
Week = staticmethod(Week)
def __init__(self, *args, **kwargs):
"""__init__(long hours=0, long minutes=0, long seconds=0, long milliseconds=0) -> TimeSpan"""
newobj = _misc.new_TimeSpan(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_TimeSpan):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Add(*args, **kwargs):
"""Add(TimeSpan diff) -> TimeSpan"""
return _misc.TimeSpan_Add(*args, **kwargs)
def Subtract(*args, **kwargs):
"""Subtract(TimeSpan diff) -> TimeSpan"""
return _misc.TimeSpan_Subtract(*args, **kwargs)
def Multiply(*args, **kwargs):
"""Multiply(int n) -> TimeSpan"""
return _misc.TimeSpan_Multiply(*args, **kwargs)
def Neg(*args, **kwargs):
"""Neg() -> TimeSpan"""
return _misc.TimeSpan_Neg(*args, **kwargs)
def Abs(*args, **kwargs):
"""Abs() -> TimeSpan"""
return _misc.TimeSpan_Abs(*args, **kwargs)
def __iadd__(*args, **kwargs):
"""__iadd__(TimeSpan diff) -> TimeSpan"""
return _misc.TimeSpan___iadd__(*args, **kwargs)
def __isub__(*args, **kwargs):
"""__isub__(TimeSpan diff) -> TimeSpan"""
return _misc.TimeSpan___isub__(*args, **kwargs)
def __imul__(*args, **kwargs):
"""__imul__(int n) -> TimeSpan"""
return _misc.TimeSpan___imul__(*args, **kwargs)
def __neg__(*args, **kwargs):
"""__neg__() -> TimeSpan"""
return _misc.TimeSpan___neg__(*args, **kwargs)
def __add__(*args, **kwargs):
"""__add__(TimeSpan other) -> TimeSpan"""
return _misc.TimeSpan___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
"""__sub__(TimeSpan other) -> TimeSpan"""
return _misc.TimeSpan___sub__(*args, **kwargs)
def __mul__(*args, **kwargs):
"""__mul__(int n) -> TimeSpan"""
return _misc.TimeSpan___mul__(*args, **kwargs)
def __rmul__(*args, **kwargs):
"""__rmul__(int n) -> TimeSpan"""
return _misc.TimeSpan___rmul__(*args, **kwargs)
def __lt__(*args, **kwargs):
"""__lt__(TimeSpan other) -> bool"""
return _misc.TimeSpan___lt__(*args, **kwargs)
def __le__(*args, **kwargs):
"""__le__(TimeSpan other) -> bool"""
return _misc.TimeSpan___le__(*args, **kwargs)
def __gt__(*args, **kwargs):
"""__gt__(TimeSpan other) -> bool"""
return _misc.TimeSpan___gt__(*args, **kwargs)
def __ge__(*args, **kwargs):
"""__ge__(TimeSpan other) -> bool"""
return _misc.TimeSpan___ge__(*args, **kwargs)
def __eq__(*args, **kwargs):
"""__eq__(TimeSpan other) -> bool"""
return _misc.TimeSpan___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""__ne__(TimeSpan other) -> bool"""
return _misc.TimeSpan___ne__(*args, **kwargs)
def IsNull(*args, **kwargs):
"""IsNull() -> bool"""
return _misc.TimeSpan_IsNull(*args, **kwargs)
def IsPositive(*args, **kwargs):
"""IsPositive() -> bool"""
return _misc.TimeSpan_IsPositive(*args, **kwargs)
def IsNegative(*args, **kwargs):
"""IsNegative() -> bool"""
return _misc.TimeSpan_IsNegative(*args, **kwargs)
def IsEqualTo(*args, **kwargs):
"""IsEqualTo(TimeSpan ts) -> bool"""
return _misc.TimeSpan_IsEqualTo(*args, **kwargs)
def IsLongerThan(*args, **kwargs):
"""IsLongerThan(TimeSpan ts) -> bool"""
return _misc.TimeSpan_IsLongerThan(*args, **kwargs)
def IsShorterThan(*args, **kwargs):
"""IsShorterThan(TimeSpan t) -> bool"""
return _misc.TimeSpan_IsShorterThan(*args, **kwargs)
def GetWeeks(*args, **kwargs):
"""GetWeeks() -> int"""
return _misc.TimeSpan_GetWeeks(*args, **kwargs)
def GetDays(*args, **kwargs):
"""GetDays() -> int"""
return _misc.TimeSpan_GetDays(*args, **kwargs)
def GetHours(*args, **kwargs):
"""GetHours() -> int"""
return _misc.TimeSpan_GetHours(*args, **kwargs)
def GetMinutes(*args, **kwargs):
"""GetMinutes() -> int"""
return _misc.TimeSpan_GetMinutes(*args, **kwargs)
def GetSeconds(*args, **kwargs):
"""GetSeconds() -> wxLongLong"""
return _misc.TimeSpan_GetSeconds(*args, **kwargs)
def GetMilliseconds(*args, **kwargs):
"""GetMilliseconds() -> wxLongLong"""
return _misc.TimeSpan_GetMilliseconds(*args, **kwargs)
def Format(*args, **kwargs):
"""Format(String format=TimeSpanFormatStr) -> String"""
return _misc.TimeSpan_Format(*args, **kwargs)
def __repr__(self):
return '<wxTimeSpan: \"%s\" at %s>' % ( self.Format(), self.this)
def __str__(self):
return self.Format()
class TimeSpanPtr(TimeSpan):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TimeSpan
_misc.TimeSpan_swigregister(TimeSpanPtr)
def TimeSpan_Seconds(*args, **kwargs):
"""TimeSpan_Seconds(long sec) -> TimeSpan"""
return _misc.TimeSpan_Seconds(*args, **kwargs)
def TimeSpan_Second(*args, **kwargs):
"""TimeSpan_Second() -> TimeSpan"""
return _misc.TimeSpan_Second(*args, **kwargs)
def TimeSpan_Minutes(*args, **kwargs):
"""TimeSpan_Minutes(long min) -> TimeSpan"""
return _misc.TimeSpan_Minutes(*args, **kwargs)
def TimeSpan_Minute(*args, **kwargs):
"""TimeSpan_Minute() -> TimeSpan"""
return _misc.TimeSpan_Minute(*args, **kwargs)
def TimeSpan_Hours(*args, **kwargs):
"""TimeSpan_Hours(long hours) -> TimeSpan"""
return _misc.TimeSpan_Hours(*args, **kwargs)
def TimeSpan_Hour(*args, **kwargs):
"""TimeSpan_Hour() -> TimeSpan"""
return _misc.TimeSpan_Hour(*args, **kwargs)
def TimeSpan_Days(*args, **kwargs):
"""TimeSpan_Days(long days) -> TimeSpan"""
return _misc.TimeSpan_Days(*args, **kwargs)
def TimeSpan_Day(*args, **kwargs):
"""TimeSpan_Day() -> TimeSpan"""
return _misc.TimeSpan_Day(*args, **kwargs)
def TimeSpan_Weeks(*args, **kwargs):
"""TimeSpan_Weeks(long days) -> TimeSpan"""
return _misc.TimeSpan_Weeks(*args, **kwargs)
def TimeSpan_Week(*args, **kwargs):
"""TimeSpan_Week() -> TimeSpan"""
return _misc.TimeSpan_Week(*args, **kwargs)
class DateSpan(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDateSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int years=0, int months=0, int weeks=0, int days=0) -> DateSpan"""
newobj = _misc.new_DateSpan(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_DateSpan):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Days(*args, **kwargs):
"""DateSpan.Days(int days) -> DateSpan"""
return _misc.DateSpan_Days(*args, **kwargs)
Days = staticmethod(Days)
def Day(*args, **kwargs):
"""DateSpan.Day() -> DateSpan"""
return _misc.DateSpan_Day(*args, **kwargs)
Day = staticmethod(Day)
def Weeks(*args, **kwargs):
"""DateSpan.Weeks(int weeks) -> DateSpan"""
return _misc.DateSpan_Weeks(*args, **kwargs)
Weeks = staticmethod(Weeks)
def Week(*args, **kwargs):
"""DateSpan.Week() -> DateSpan"""
return _misc.DateSpan_Week(*args, **kwargs)
Week = staticmethod(Week)
def Months(*args, **kwargs):
"""DateSpan.Months(int mon) -> DateSpan"""
return _misc.DateSpan_Months(*args, **kwargs)
Months = staticmethod(Months)
def Month(*args, **kwargs):
"""DateSpan.Month() -> DateSpan"""
return _misc.DateSpan_Month(*args, **kwargs)
Month = staticmethod(Month)
def Years(*args, **kwargs):
"""DateSpan.Years(int years) -> DateSpan"""
return _misc.DateSpan_Years(*args, **kwargs)
Years = staticmethod(Years)
def Year(*args, **kwargs):
"""DateSpan.Year() -> DateSpan"""
return _misc.DateSpan_Year(*args, **kwargs)
Year = staticmethod(Year)
def SetYears(*args, **kwargs):
"""SetYears(int n) -> DateSpan"""
return _misc.DateSpan_SetYears(*args, **kwargs)
def SetMonths(*args, **kwargs):
"""SetMonths(int n) -> DateSpan"""
return _misc.DateSpan_SetMonths(*args, **kwargs)
def SetWeeks(*args, **kwargs):
"""SetWeeks(int n) -> DateSpan"""
return _misc.DateSpan_SetWeeks(*args, **kwargs)
def SetDays(*args, **kwargs):
"""SetDays(int n) -> DateSpan"""
return _misc.DateSpan_SetDays(*args, **kwargs)
def GetYears(*args, **kwargs):
"""GetYears() -> int"""
return _misc.DateSpan_GetYears(*args, **kwargs)
def GetMonths(*args, **kwargs):
"""GetMonths() -> int"""
return _misc.DateSpan_GetMonths(*args, **kwargs)
def GetWeeks(*args, **kwargs):
"""GetWeeks() -> int"""
return _misc.DateSpan_GetWeeks(*args, **kwargs)
def GetDays(*args, **kwargs):
"""GetDays() -> int"""
return _misc.DateSpan_GetDays(*args, **kwargs)
def GetTotalDays(*args, **kwargs):
"""GetTotalDays() -> int"""
return _misc.DateSpan_GetTotalDays(*args, **kwargs)
def Add(*args, **kwargs):
"""Add(DateSpan other) -> DateSpan"""
return _misc.DateSpan_Add(*args, **kwargs)
def Subtract(*args, **kwargs):
"""Subtract(DateSpan other) -> DateSpan"""
return _misc.DateSpan_Subtract(*args, **kwargs)
def Neg(*args, **kwargs):
"""Neg() -> DateSpan"""
return _misc.DateSpan_Neg(*args, **kwargs)
def Multiply(*args, **kwargs):
"""Multiply(int factor) -> DateSpan"""
return _misc.DateSpan_Multiply(*args, **kwargs)
def __iadd__(*args, **kwargs):
"""__iadd__(DateSpan other) -> DateSpan"""
return _misc.DateSpan___iadd__(*args, **kwargs)
def __isub__(*args, **kwargs):
"""__isub__(DateSpan other) -> DateSpan"""
return _misc.DateSpan___isub__(*args, **kwargs)
def __neg__(*args, **kwargs):
"""__neg__() -> DateSpan"""
return _misc.DateSpan___neg__(*args, **kwargs)
def __imul__(*args, **kwargs):
"""__imul__(int factor) -> DateSpan"""
return _misc.DateSpan___imul__(*args, **kwargs)
def __add__(*args, **kwargs):
"""__add__(DateSpan other) -> DateSpan"""
return _misc.DateSpan___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
"""__sub__(DateSpan other) -> DateSpan"""
return _misc.DateSpan___sub__(*args, **kwargs)
def __mul__(*args, **kwargs):
"""__mul__(int n) -> DateSpan"""
return _misc.DateSpan___mul__(*args, **kwargs)
def __rmul__(*args, **kwargs):
"""__rmul__(int n) -> DateSpan"""
return _misc.DateSpan___rmul__(*args, **kwargs)
def __eq__(*args, **kwargs):
"""__eq__(DateSpan other) -> bool"""
return _misc.DateSpan___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""__ne__(DateSpan other) -> bool"""
return _misc.DateSpan___ne__(*args, **kwargs)
class DateSpanPtr(DateSpan):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DateSpan
_misc.DateSpan_swigregister(DateSpanPtr)
def DateSpan_Days(*args, **kwargs):
"""DateSpan_Days(int days) -> DateSpan"""
return _misc.DateSpan_Days(*args, **kwargs)
def DateSpan_Day(*args, **kwargs):
"""DateSpan_Day() -> DateSpan"""
return _misc.DateSpan_Day(*args, **kwargs)
def DateSpan_Weeks(*args, **kwargs):
"""DateSpan_Weeks(int weeks) -> DateSpan"""
return _misc.DateSpan_Weeks(*args, **kwargs)
def DateSpan_Week(*args, **kwargs):
"""DateSpan_Week() -> DateSpan"""
return _misc.DateSpan_Week(*args, **kwargs)
def DateSpan_Months(*args, **kwargs):
"""DateSpan_Months(int mon) -> DateSpan"""
return _misc.DateSpan_Months(*args, **kwargs)
def DateSpan_Month(*args, **kwargs):
"""DateSpan_Month() -> DateSpan"""
return _misc.DateSpan_Month(*args, **kwargs)
def DateSpan_Years(*args, **kwargs):
"""DateSpan_Years(int years) -> DateSpan"""
return _misc.DateSpan_Years(*args, **kwargs)
def DateSpan_Year(*args, **kwargs):
"""DateSpan_Year() -> DateSpan"""
return _misc.DateSpan_Year(*args, **kwargs)
def GetLocalTime(*args, **kwargs):
"""GetLocalTime() -> long"""
return _misc.GetLocalTime(*args, **kwargs)
def GetUTCTime(*args, **kwargs):
"""GetUTCTime() -> long"""
return _misc.GetUTCTime(*args, **kwargs)
def GetCurrentTime(*args, **kwargs):
"""GetCurrentTime() -> long"""
return _misc.GetCurrentTime(*args, **kwargs)
def GetLocalTimeMillis(*args, **kwargs):
"""GetLocalTimeMillis() -> wxLongLong"""
return _misc.GetLocalTimeMillis(*args, **kwargs)
#---------------------------------------------------------------------------
DF_INVALID = _misc.DF_INVALID
DF_TEXT = _misc.DF_TEXT
DF_BITMAP = _misc.DF_BITMAP
DF_METAFILE = _misc.DF_METAFILE
DF_SYLK = _misc.DF_SYLK
DF_DIF = _misc.DF_DIF
DF_TIFF = _misc.DF_TIFF
DF_OEMTEXT = _misc.DF_OEMTEXT
DF_DIB = _misc.DF_DIB
DF_PALETTE = _misc.DF_PALETTE
DF_PENDATA = _misc.DF_PENDATA
DF_RIFF = _misc.DF_RIFF
DF_WAVE = _misc.DF_WAVE
DF_UNICODETEXT = _misc.DF_UNICODETEXT
DF_ENHMETAFILE = _misc.DF_ENHMETAFILE
DF_FILENAME = _misc.DF_FILENAME
DF_LOCALE = _misc.DF_LOCALE
DF_PRIVATE = _misc.DF_PRIVATE
DF_HTML = _misc.DF_HTML
DF_MAX = _misc.DF_MAX
class DataFormat(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDataFormat instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(int type) -> DataFormat"""
newobj = _misc.new_DataFormat(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_DataFormat):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def __eq__(*args):
"""
__eq__(int format) -> bool
__eq__(DataFormat format) -> bool
"""
return _misc.DataFormat___eq__(*args)
def __ne__(*args):
"""
__ne__(int format) -> bool
__ne__(DataFormat format) -> bool
"""
return _misc.DataFormat___ne__(*args)
def SetType(*args, **kwargs):
"""SetType(int format)"""
return _misc.DataFormat_SetType(*args, **kwargs)
def GetType(*args, **kwargs):
"""GetType() -> int"""
return _misc.DataFormat_GetType(*args, **kwargs)
def GetId(*args, **kwargs):
"""GetId() -> String"""
return _misc.DataFormat_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
"""SetId(String format)"""
return _misc.DataFormat_SetId(*args, **kwargs)
class DataFormatPtr(DataFormat):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DataFormat
_misc.DataFormat_swigregister(DataFormatPtr)
def CustomDataFormat(*args, **kwargs):
"""CustomDataFormat(String format) -> DataFormat"""
val = _misc.new_CustomDataFormat(*args, **kwargs)
val.thisown = 1
return val
class DataObject(object):
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
Get = _misc.DataObject_Get
Set = _misc.DataObject_Set
Both = _misc.DataObject_Both
def __del__(self, destroy=_misc.delete_DataObject):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def GetPreferredFormat(*args, **kwargs):
"""GetPreferredFormat(int dir=Get) -> DataFormat"""
return _misc.DataObject_GetPreferredFormat(*args, **kwargs)
def GetFormatCount(*args, **kwargs):
"""GetFormatCount(int dir=Get) -> size_t"""
return _misc.DataObject_GetFormatCount(*args, **kwargs)
def IsSupported(*args, **kwargs):
"""IsSupported(DataFormat format, int dir=Get) -> bool"""
return _misc.DataObject_IsSupported(*args, **kwargs)
def GetDataSize(*args, **kwargs):
"""GetDataSize(DataFormat format) -> size_t"""
return _misc.DataObject_GetDataSize(*args, **kwargs)
def GetAllFormats(*args, **kwargs):
"""GetAllFormats(DataFormat formats, int dir=Get)"""
return _misc.DataObject_GetAllFormats(*args, **kwargs)
def GetDataHere(*args, **kwargs):
"""GetDataHere(DataFormat format, void buf) -> bool"""
return _misc.DataObject_GetDataHere(*args, **kwargs)
def SetData(*args, **kwargs):
"""SetData(DataFormat format, size_t len, void buf) -> bool"""
return _misc.DataObject_SetData(*args, **kwargs)
class DataObjectPtr(DataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DataObject
_misc.DataObject_swigregister(DataObjectPtr)
FormatInvalid = cvar.FormatInvalid
class DataObjectSimple(DataObject):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDataObjectSimple instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(DataFormat format=FormatInvalid) -> DataObjectSimple"""
newobj = _misc.new_DataObjectSimple(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetFormat(*args, **kwargs):
"""GetFormat() -> DataFormat"""
return _misc.DataObjectSimple_GetFormat(*args, **kwargs)
def SetFormat(*args, **kwargs):
"""SetFormat(DataFormat format)"""
return _misc.DataObjectSimple_SetFormat(*args, **kwargs)
class DataObjectSimplePtr(DataObjectSimple):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DataObjectSimple
_misc.DataObjectSimple_swigregister(DataObjectSimplePtr)
class PyDataObjectSimple(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyDataObjectSimple instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(DataFormat format=FormatInvalid) -> PyDataObjectSimple"""
newobj = _misc.new_PyDataObjectSimple(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyDataObjectSimple)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.PyDataObjectSimple__setCallbackInfo(*args, **kwargs)
class PyDataObjectSimplePtr(PyDataObjectSimple):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyDataObjectSimple
_misc.PyDataObjectSimple_swigregister(PyDataObjectSimplePtr)
class DataObjectComposite(DataObject):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDataObjectComposite instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> DataObjectComposite"""
newobj = _misc.new_DataObjectComposite(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Add(*args, **kwargs):
"""Add(DataObjectSimple dataObject, int preferred=False)"""
val = _misc.DataObjectComposite_Add(*args, **kwargs)
args[1].thisown = 0
return val
class DataObjectCompositePtr(DataObjectComposite):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DataObjectComposite
_misc.DataObjectComposite_swigregister(DataObjectCompositePtr)
class TextDataObject(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String text=EmptyString) -> TextDataObject"""
newobj = _misc.new_TextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetTextLength(*args, **kwargs):
"""GetTextLength() -> size_t"""
return _misc.TextDataObject_GetTextLength(*args, **kwargs)
def GetText(*args, **kwargs):
"""GetText() -> String"""
return _misc.TextDataObject_GetText(*args, **kwargs)
def SetText(*args, **kwargs):
"""SetText(String text)"""
return _misc.TextDataObject_SetText(*args, **kwargs)
class TextDataObjectPtr(TextDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TextDataObject
_misc.TextDataObject_swigregister(TextDataObjectPtr)
class PyTextDataObject(TextDataObject):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(String text=EmptyString) -> PyTextDataObject"""
newobj = _misc.new_PyTextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyTextDataObject)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.PyTextDataObject__setCallbackInfo(*args, **kwargs)
class PyTextDataObjectPtr(PyTextDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyTextDataObject
_misc.PyTextDataObject_swigregister(PyTextDataObjectPtr)
class BitmapDataObject(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Bitmap bitmap=wxNullBitmap) -> BitmapDataObject"""
newobj = _misc.new_BitmapDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetBitmap(*args, **kwargs):
"""GetBitmap() -> Bitmap"""
return _misc.BitmapDataObject_GetBitmap(*args, **kwargs)
def SetBitmap(*args, **kwargs):
"""SetBitmap(Bitmap bitmap)"""
return _misc.BitmapDataObject_SetBitmap(*args, **kwargs)
class BitmapDataObjectPtr(BitmapDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BitmapDataObject
_misc.BitmapDataObject_swigregister(BitmapDataObjectPtr)
class PyBitmapDataObject(BitmapDataObject):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Bitmap bitmap=wxNullBitmap) -> PyBitmapDataObject"""
newobj = _misc.new_PyBitmapDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyBitmapDataObject)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.PyBitmapDataObject__setCallbackInfo(*args, **kwargs)
class PyBitmapDataObjectPtr(PyBitmapDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyBitmapDataObject
_misc.PyBitmapDataObject_swigregister(PyBitmapDataObjectPtr)
class FileDataObject(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> FileDataObject"""
newobj = _misc.new_FileDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetFilenames(*args, **kwargs):
"""GetFilenames() -> wxArrayString"""
return _misc.FileDataObject_GetFilenames(*args, **kwargs)
class FileDataObjectPtr(FileDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileDataObject
_misc.FileDataObject_swigregister(FileDataObjectPtr)
class CustomDataObject(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxCustomDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(DataFormat format=FormatInvalid) -> CustomDataObject"""
newobj = _misc.new_CustomDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def TakeData(*args, **kwargs):
"""TakeData(PyObject data)"""
return _misc.CustomDataObject_TakeData(*args, **kwargs)
def SetData(*args, **kwargs):
"""SetData(PyObject data) -> bool"""
return _misc.CustomDataObject_SetData(*args, **kwargs)
def GetSize(*args, **kwargs):
"""GetSize() -> size_t"""
return _misc.CustomDataObject_GetSize(*args, **kwargs)
def GetData(*args, **kwargs):
"""GetData() -> PyObject"""
return _misc.CustomDataObject_GetData(*args, **kwargs)
class CustomDataObjectPtr(CustomDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CustomDataObject
_misc.CustomDataObject_swigregister(CustomDataObjectPtr)
class URLDataObject(DataObjectComposite):
def __repr__(self):
return "<%s.%s; proxy of C++ wxURLDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> URLDataObject"""
newobj = _misc.new_URLDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetURL(*args, **kwargs):
"""GetURL() -> String"""
return _misc.URLDataObject_GetURL(*args, **kwargs)
def SetURL(*args, **kwargs):
"""SetURL(String url)"""
return _misc.URLDataObject_SetURL(*args, **kwargs)
class URLDataObjectPtr(URLDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = URLDataObject
_misc.URLDataObject_swigregister(URLDataObjectPtr)
class MetafileDataObject(DataObjectSimple):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMetafileDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> MetafileDataObject"""
newobj = _misc.new_MetafileDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class MetafileDataObjectPtr(MetafileDataObject):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MetafileDataObject
_misc.MetafileDataObject_swigregister(MetafileDataObjectPtr)
#---------------------------------------------------------------------------
Drag_CopyOnly = _misc.Drag_CopyOnly
Drag_AllowMove = _misc.Drag_AllowMove
Drag_DefaultMove = _misc.Drag_DefaultMove
DragError = _misc.DragError
DragNone = _misc.DragNone
DragCopy = _misc.DragCopy
DragMove = _misc.DragMove
DragLink = _misc.DragLink
DragCancel = _misc.DragCancel
def IsDragResultOk(*args, **kwargs):
"""IsDragResultOk(int res) -> bool"""
return _misc.IsDragResultOk(*args, **kwargs)
class DropSource(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyDropSource instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(Window win=None, Icon copy=wxNullIcon, Icon move=wxNullIcon,
Icon none=wxNullIcon) -> DropSource
"""
newobj = _misc.new_DropSource(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class, int incref)"""
return _misc.DropSource__setCallbackInfo(*args, **kwargs)
def __del__(self, destroy=_misc.delete_DropSource):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def SetData(*args, **kwargs):
"""SetData(DataObject data)"""
return _misc.DropSource_SetData(*args, **kwargs)
def GetDataObject(*args, **kwargs):
"""GetDataObject() -> DataObject"""
return _misc.DropSource_GetDataObject(*args, **kwargs)
def SetCursor(*args, **kwargs):
"""SetCursor(int res, Cursor cursor)"""
return _misc.DropSource_SetCursor(*args, **kwargs)
def DoDragDrop(*args, **kwargs):
"""DoDragDrop(int flags=Drag_CopyOnly) -> int"""
return _misc.DropSource_DoDragDrop(*args, **kwargs)
def base_GiveFeedback(*args, **kwargs):
"""base_GiveFeedback(int effect) -> bool"""
return _misc.DropSource_base_GiveFeedback(*args, **kwargs)
class DropSourcePtr(DropSource):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DropSource
_misc.DropSource_swigregister(DropSourcePtr)
class DropTarget(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""PyDropTarget(DataObject dataObject=None) -> DropTarget"""
newobj = _misc.new_PyDropTarget(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
if args: args[0].thisown = 0;
self._setCallbackInfo(self, DropTarget)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.DropTarget__setCallbackInfo(*args, **kwargs)
def __del__(self, destroy=_misc.delete_DropTarget):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def GetDataObject(*args, **kwargs):
"""GetDataObject() -> DataObject"""
return _misc.DropTarget_GetDataObject(*args, **kwargs)
def SetDataObject(*args, **kwargs):
"""SetDataObject(DataObject dataObject)"""
val = _misc.DropTarget_SetDataObject(*args, **kwargs)
args[1].thisown = 0
return val
def base_OnEnter(*args, **kwargs):
"""base_OnEnter(int x, int y, int def) -> int"""
return _misc.DropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
"""base_OnDragOver(int x, int y, int def) -> int"""
return _misc.DropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
"""base_OnLeave()"""
return _misc.DropTarget_base_OnLeave(*args, **kwargs)
def base_OnDrop(*args, **kwargs):
"""base_OnDrop(int x, int y) -> bool"""
return _misc.DropTarget_base_OnDrop(*args, **kwargs)
def GetData(*args, **kwargs):
"""GetData() -> bool"""
return _misc.DropTarget_GetData(*args, **kwargs)
class DropTargetPtr(DropTarget):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DropTarget
_misc.DropTarget_swigregister(DropTargetPtr)
PyDropTarget = DropTarget
class TextDropTarget(DropTarget):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyTextDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> TextDropTarget"""
newobj = _misc.new_TextDropTarget(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, TextDropTarget)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.TextDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
"""base_OnEnter(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
"""base_OnDragOver(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
"""base_OnLeave()"""
return _misc.TextDropTarget_base_OnLeave(*args, **kwargs)
def base_OnDrop(*args, **kwargs):
"""base_OnDrop(int x, int y) -> bool"""
return _misc.TextDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
"""base_OnData(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnData(*args, **kwargs)
class TextDropTargetPtr(TextDropTarget):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TextDropTarget
_misc.TextDropTarget_swigregister(TextDropTargetPtr)
class FileDropTarget(DropTarget):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyFileDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> FileDropTarget"""
newobj = _misc.new_FileDropTarget(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, FileDropTarget)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(PyObject self, PyObject _class)"""
return _misc.FileDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
"""base_OnEnter(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
"""base_OnDragOver(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
"""base_OnLeave()"""
return _misc.FileDropTarget_base_OnLeave(*args, **kwargs)
def base_OnDrop(*args, **kwargs):
"""base_OnDrop(int x, int y) -> bool"""
return _misc.FileDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
"""base_OnData(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnData(*args, **kwargs)
class FileDropTargetPtr(FileDropTarget):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileDropTarget
_misc.FileDropTarget_swigregister(FileDropTargetPtr)
#---------------------------------------------------------------------------
class Clipboard(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxClipboard instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__() -> Clipboard"""
newobj = _misc.new_Clipboard(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_Clipboard):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def Open(*args, **kwargs):
"""Open() -> bool"""
return _misc.Clipboard_Open(*args, **kwargs)
def Close(*args, **kwargs):
"""Close()"""
return _misc.Clipboard_Close(*args, **kwargs)
def IsOpened(*args, **kwargs):
"""IsOpened() -> bool"""
return _misc.Clipboard_IsOpened(*args, **kwargs)
def AddData(*args, **kwargs):
"""AddData(DataObject data) -> bool"""
return _misc.Clipboard_AddData(*args, **kwargs)
def SetData(*args, **kwargs):
"""SetData(DataObject data) -> bool"""
return _misc.Clipboard_SetData(*args, **kwargs)
def IsSupported(*args, **kwargs):
"""IsSupported(DataFormat format) -> bool"""
return _misc.Clipboard_IsSupported(*args, **kwargs)
def GetData(*args, **kwargs):
"""GetData(DataObject data) -> bool"""
return _misc.Clipboard_GetData(*args, **kwargs)
def Clear(*args, **kwargs):
"""Clear()"""
return _misc.Clipboard_Clear(*args, **kwargs)
def Flush(*args, **kwargs):
"""Flush() -> bool"""
return _misc.Clipboard_Flush(*args, **kwargs)
def UsePrimarySelection(*args, **kwargs):
"""UsePrimarySelection(bool primary=False)"""
return _misc.Clipboard_UsePrimarySelection(*args, **kwargs)
class ClipboardPtr(Clipboard):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Clipboard
_misc.Clipboard_swigregister(ClipboardPtr)
class ClipboardLocker(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxClipboardLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(Clipboard clipboard=None) -> ClipboardLocker"""
newobj = _misc.new_ClipboardLocker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_misc.delete_ClipboardLocker):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
def __nonzero__(*args, **kwargs):
"""__nonzero__() -> bool"""
return _misc.ClipboardLocker___nonzero__(*args, **kwargs)
class ClipboardLockerPtr(ClipboardLocker):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ClipboardLocker
_misc.ClipboardLocker_swigregister(ClipboardLockerPtr)
TheClipboard = cvar.TheClipboard
Reference in New Issue View Git Blame Copy Permalink