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(wxSystemColour index) -> wxColour"""
+ """GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
GetColour = staticmethod(GetColour)
def GetFont(*args, **kwargs):
- """SystemSettings.GetFont(wxSystemFont index) -> wxFont"""
+ """GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
GetFont = staticmethod(GetFont)
def GetMetric(*args, **kwargs):
- """SystemSettings.GetMetric(wxSystemMetric index) -> int"""
+ """GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
GetMetric = staticmethod(GetMetric)
def HasFeature(*args, **kwargs):
- """SystemSettings.HasFeature(wxSystemFeature index) -> bool"""
+ """HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
HasFeature = staticmethod(HasFeature)
def GetScreenType(*args, **kwargs):
- """SystemSettings.GetScreenType() -> wxSystemScreenType"""
+ """GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
GetScreenType = staticmethod(GetScreenType)
def SetScreenType(*args, **kwargs):
- """SystemSettings.SetScreenType(wxSystemScreenType screen)"""
+ """SetScreenType(int screen)"""
return _misc.SystemSettings_SetScreenType(*args, **kwargs)
SetScreenType = staticmethod(SetScreenType)
_misc.SystemSettings_swigregister(SystemSettingsPtr)
def SystemSettings_GetColour(*args, **kwargs):
- """SystemSettings_GetColour(wxSystemColour index) -> wxColour"""
+ """SystemSettings_GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
def SystemSettings_GetFont(*args, **kwargs):
- """SystemSettings_GetFont(wxSystemFont index) -> wxFont"""
+ """SystemSettings_GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
def SystemSettings_GetMetric(*args, **kwargs):
- """SystemSettings_GetMetric(wxSystemMetric index) -> int"""
+ """SystemSettings_GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
def SystemSettings_HasFeature(*args, **kwargs):
- """SystemSettings_HasFeature(wxSystemFeature index) -> bool"""
+ """SystemSettings_HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
def SystemSettings_GetScreenType(*args, **kwargs):
- """SystemSettings_GetScreenType() -> wxSystemScreenType"""
+ """SystemSettings_GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
def SystemSettings_SetScreenType(*args, **kwargs):
- """SystemSettings_SetScreenType(wxSystemScreenType screen)"""
+ """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):
self.thisown = 1
del newobj.thisown
def SetOption(*args, **kwargs):
- """SystemOptions.SetOption(wxString name, wxString value)"""
+ """SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
SetOption = staticmethod(SetOption)
def SetOptionInt(*args, **kwargs):
- """SystemOptions.SetOptionInt(wxString name, int value)"""
+ """SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
SetOptionInt = staticmethod(SetOptionInt)
def GetOption(*args, **kwargs):
- """SystemOptions.GetOption(wxString name) -> wxString"""
+ """GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
GetOption = staticmethod(GetOption)
def GetOptionInt(*args, **kwargs):
- """SystemOptions.GetOptionInt(wxString name) -> int"""
+ """GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
GetOptionInt = staticmethod(GetOptionInt)
def HasOption(*args, **kwargs):
- """SystemOptions.HasOption(wxString name) -> bool"""
+ """HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
HasOption = staticmethod(HasOption)
_misc.SystemOptions_swigregister(SystemOptionsPtr)
def SystemOptions_SetOption(*args, **kwargs):
- """SystemOptions_SetOption(wxString name, wxString value)"""
+ """SystemOptions_SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
def SystemOptions_SetOptionInt(*args, **kwargs):
- """SystemOptions_SetOptionInt(wxString name, int value)"""
+ """SystemOptions_SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
def SystemOptions_GetOption(*args, **kwargs):
- """SystemOptions_GetOption(wxString name) -> wxString"""
+ """SystemOptions_GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
def SystemOptions_GetOptionInt(*args, **kwargs):
- """SystemOptions_GetOptionInt(wxString name) -> int"""
+ """SystemOptions_GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
def SystemOptions_HasOption(*args, **kwargs):
- """SystemOptions_HasOption(wxString name) -> bool"""
+ """SystemOptions_HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
#---------------------------------------------------------------------------
return _misc.IsBusy(*args, **kwargs)
def Now(*args, **kwargs):
- """Now() -> wxString"""
+ """Now() -> String"""
return _misc.Now(*args, **kwargs)
def Shell(*args, **kwargs):
- """Shell(wxString command=wxPyEmptyString) -> bool"""
+ """Shell(String command=EmptyString) -> bool"""
return _misc.Shell(*args, **kwargs)
def StartTimer(*args, **kwargs):
return _misc.GetOsVersion(*args, **kwargs)
def GetOsDescription(*args, **kwargs):
- """GetOsDescription() -> wxString"""
+ """GetOsDescription() -> String"""
return _misc.GetOsDescription(*args, **kwargs)
def GetFreeMemory(*args, **kwargs):
SHUTDOWN_REBOOT = _misc.SHUTDOWN_REBOOT
def Shutdown(*args, **kwargs):
- """Shutdown(wxShutdownFlags wFlags) -> bool"""
+ """Shutdown(int wFlags) -> bool"""
return _misc.Shutdown(*args, **kwargs)
def Sleep(*args, **kwargs):
return _misc.EnableTopLevelWindows(*args, **kwargs)
def StripMenuCodes(*args, **kwargs):
- """StripMenuCodes(wxString in) -> wxString"""
+ """StripMenuCodes(String in) -> String"""
return _misc.StripMenuCodes(*args, **kwargs)
def GetEmailAddress(*args, **kwargs):
- """GetEmailAddress() -> wxString"""
+ """GetEmailAddress() -> String"""
return _misc.GetEmailAddress(*args, **kwargs)
def GetHostName(*args, **kwargs):
- """GetHostName() -> wxString"""
+ """GetHostName() -> String"""
return _misc.GetHostName(*args, **kwargs)
def GetFullHostName(*args, **kwargs):
- """GetFullHostName() -> wxString"""
+ """GetFullHostName() -> String"""
return _misc.GetFullHostName(*args, **kwargs)
def GetUserId(*args, **kwargs):
- """GetUserId() -> wxString"""
+ """GetUserId() -> String"""
return _misc.GetUserId(*args, **kwargs)
def GetUserName(*args, **kwargs):
- """GetUserName() -> wxString"""
+ """GetUserName() -> String"""
return _misc.GetUserName(*args, **kwargs)
def GetHomeDir(*args, **kwargs):
- """GetHomeDir() -> wxString"""
+ """GetHomeDir() -> String"""
return _misc.GetHomeDir(*args, **kwargs)
def GetUserHome(*args, **kwargs):
- """GetUserHome(wxString user=wxPyEmptyString) -> wxString"""
+ """GetUserHome(String user=EmptyString) -> String"""
return _misc.GetUserHome(*args, **kwargs)
def GetProcessId(*args, **kwargs):
return _misc.Trap(*args, **kwargs)
def FileSelector(*args, **kwargs):
- """FileSelector(wxString message=wxPyFileSelectorPromptStr, wxString default_path=wxPyEmptyString,
- wxString default_filename=wxPyEmptyString,
- wxString default_extension=wxPyEmptyString,
- wxString wildcard=wxPyFileSelectorDefaultWildcardStr,
- int flags=0,
- Window parent=None, int x=-1, int y=-1) -> wxString"""
+ """
+ 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(wxString what, wxString extension, wxString default_name=wxPyEmptyString,
- Window parent=None) -> wxString"""
+ """
+ LoadFileSelector(String what, String extension, String default_name=EmptyString,
+ Window parent=None) -> String
+ """
return _misc.LoadFileSelector(*args, **kwargs)
def SaveFileSelector(*args, **kwargs):
- """SaveFileSelector(wxString what, wxString extension, wxString default_name=wxPyEmptyString,
- Window parent=None) -> wxString"""
+ """
+ SaveFileSelector(String what, String extension, String default_name=EmptyString,
+ Window parent=None) -> String
+ """
return _misc.SaveFileSelector(*args, **kwargs)
def DirSelector(*args, **kwargs):
- """DirSelector(wxString message=wxPyDirSelectorPromptStr, wxString defaultPath=wxPyEmptyString,
- long style=DD_DEFAULT_STYLE,
- Point pos=DefaultPosition, Window parent=None) -> wxString"""
+ """
+ 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(wxString message, wxString caption=wxPyEmptyString,
- wxString default_value=wxPyEmptyString, Window parent=None,
- int x=-1, int y=-1, bool centre=True) -> wxString"""
+ """
+ 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(wxString message, wxString caption=wxPyEmptyString,
- wxString default_value=wxPyEmptyString, Window parent=None) -> wxString"""
+ """
+ GetPasswordFromUser(String message, String caption=EmptyString, String default_value=EmptyString,
+ Window parent=None) -> String
+ """
return _misc.GetPasswordFromUser(*args, **kwargs)
def GetSingleChoice(*args, **kwargs):
- """GetSingleChoice(wxString message, wxString caption, int choices, wxString choices_array,
- Window parent=None, int x=-1,
- int y=-1, bool centre=True, int width=150,
- int height=200) -> wxString"""
+ """
+ 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(wxString message, wxString caption, int choices, wxString choices_array,
- Window parent=None, int x=-1,
- int y=-1, bool centre=True, int width=150,
- int height=200) -> int"""
+ """
+ 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(wxString message, wxString caption=wxPyEmptyString,
- int style=wxOK|wxCENTRE, Window parent=None,
- int x=-1, int y=-1) -> int"""
+ """
+ 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(wxString message, wxString prompt, wxString caption,
- long value, long min=0, long max=100, Window parent=None,
- Point pos=DefaultPosition) -> long"""
+ """
+ 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):
return _misc.GetClientDisplayRect(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor)"""
+ """SetCursor(Cursor cursor)"""
return _misc.SetCursor(*args, **kwargs)
def BeginBusyCursor(*args, **kwargs):
- """BeginBusyCursor(wxCursor cursor=wxHOURGLASS_CURSOR)"""
+ """BeginBusyCursor(Cursor cursor=wxHOURGLASS_CURSOR)"""
return _misc.BeginBusyCursor(*args, **kwargs)
def GetActiveWindow(*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)
"""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):
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):
#---------------------------------------------------------------------------
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__(wxString tip) -> ToolTip"""
+ """__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(wxString tip)"""
+ """SetTip(String tip)"""
return _misc.ToolTip_SetTip(*args, **kwargs)
def GetTip(*args, **kwargs):
- """GetTip() -> wxString"""
+ """GetTip() -> String"""
return _misc.ToolTip_GetTip(*args, **kwargs)
def GetWindow(*args, **kwargs):
return _misc.ToolTip_GetWindow(*args, **kwargs)
def Enable(*args, **kwargs):
- """ToolTip.Enable(bool flag)"""
+ """Enable(bool flag)"""
return _misc.ToolTip_Enable(*args, **kwargs)
Enable = staticmethod(Enable)
def SetDelay(*args, **kwargs):
- """ToolTip.SetDelay(long milliseconds)"""
+ """SetDelay(long milliseconds)"""
return _misc.ToolTip_SetDelay(*args, **kwargs)
SetDelay = staticmethod(SetDelay)
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):
"""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__(wxCursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor"""
+ """__init__(Cursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor"""
newobj = _misc.new_BusyCursor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_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):
_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__(wxString message) -> BusyInfo"""
+ """__init__(String message) -> BusyInfo"""
newobj = _misc.new_BusyInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_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):
_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):
except: pass
def AddFileToHistory(*args, **kwargs):
- """AddFileToHistory(wxString file)"""
+ """AddFileToHistory(String file)"""
return _misc.FileHistory_AddFileToHistory(*args, **kwargs)
def RemoveFileFromHistory(*args, **kwargs):
return _misc.FileHistory_AddFilesToThisMenu(*args, **kwargs)
def GetHistoryFile(*args, **kwargs):
- """GetHistoryFile(int i) -> wxString"""
+ """GetHistoryFile(int i) -> String"""
return _misc.FileHistory_GetHistoryFile(*args, **kwargs)
def GetCount(*args, **kwargs):
"""GetCount() -> int"""
return _misc.FileHistory_GetCount(*args, **kwargs)
+ GetNoHistoryFiles = GetCount
class FileHistoryPtr(FileHistory):
def __init__(self, this):
_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__(wxString name, wxString path=wxPyEmptyString) -> SingleInstanceChecker"""
+ """__init__(String name, String path=EmptyString) -> SingleInstanceChecker"""
newobj = _misc.new_SingleInstanceChecker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def Create(*args, **kwargs):
- """Create(wxString name, wxString path=wxPyEmptyString) -> bool"""
+ """Create(String name, String path=EmptyString) -> bool"""
return _misc.SingleInstanceChecker_Create(*args, **kwargs)
def IsAnotherRunning(*args, **kwargs):
def DrawWindowOnDC(*args, **kwargs):
- """DrawWindowOnDC(Window window, wxDC dc, int method)"""
+ """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,)
except: pass
def GetTip(*args, **kwargs):
- """GetTip() -> wxString"""
+ """GetTip() -> String"""
return _misc.TipProvider_GetTip(*args, **kwargs)
def GetCurrentTip(*args, **kwargs):
return _misc.TipProvider_GetCurrentTip(*args, **kwargs)
def PreprocessTip(*args, **kwargs):
- """PreprocessTip(wxString tip) -> wxString"""
+ """PreprocessTip(String tip) -> String"""
return _misc.TipProvider_PreprocessTip(*args, **kwargs)
_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):
return _misc.ShowTip(*args, **kwargs)
def CreateFileTipProvider(*args, **kwargs):
- """CreateFileTipProvider(wxString filename, size_t currentTip) -> TipProvider"""
+ """CreateFileTipProvider(String filename, size_t currentTip) -> TipProvider"""
return _misc.CreateFileTipProvider(*args, **kwargs)
#---------------------------------------------------------------------------
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):
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- self._setCallbackInfo(self, Timer)
+ self._setCallbackInfo(self, Timer, 0)
def __del__(self, destroy=_misc.delete_Timer):
"""__del__()"""
except: pass
def _setCallbackInfo(*args, **kwargs):
- """_setCallbackInfo(PyObject self, PyObject _class)"""
+ """_setCallbackInfo(PyObject self, PyObject _class, int incref=1)"""
return _misc.Timer__setCallbackInfo(*args, **kwargs)
def SetOwner(*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):
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):
_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"""
+ """
+ __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
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):
self.thisown = 1
del newobj.thisown
def IsEnabled(*args, **kwargs):
- """Log.IsEnabled() -> bool"""
+ """IsEnabled() -> bool"""
return _misc.Log_IsEnabled(*args, **kwargs)
IsEnabled = staticmethod(IsEnabled)
def EnableLogging(*args, **kwargs):
- """Log.EnableLogging(bool doIt=True) -> bool"""
+ """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)"""
+ """OnLog(wxLogLevel level, wxChar szString, time_t t)"""
return _misc.Log_OnLog(*args, **kwargs)
OnLog = staticmethod(OnLog)
return _misc.Log_Flush(*args, **kwargs)
def FlushActive(*args, **kwargs):
- """Log.FlushActive()"""
+ """FlushActive()"""
return _misc.Log_FlushActive(*args, **kwargs)
FlushActive = staticmethod(FlushActive)
def GetActiveTarget(*args, **kwargs):
- """Log.GetActiveTarget() -> Log"""
+ """GetActiveTarget() -> Log"""
return _misc.Log_GetActiveTarget(*args, **kwargs)
GetActiveTarget = staticmethod(GetActiveTarget)
def SetActiveTarget(*args, **kwargs):
- """Log.SetActiveTarget(Log pLogger) -> Log"""
+ """SetActiveTarget(Log pLogger) -> Log"""
return _misc.Log_SetActiveTarget(*args, **kwargs)
SetActiveTarget = staticmethod(SetActiveTarget)
def Suspend(*args, **kwargs):
- """Log.Suspend()"""
+ """Suspend()"""
return _misc.Log_Suspend(*args, **kwargs)
Suspend = staticmethod(Suspend)
def Resume(*args, **kwargs):
- """Log.Resume()"""
+ """Resume()"""
return _misc.Log_Resume(*args, **kwargs)
Resume = staticmethod(Resume)
def SetVerbose(*args, **kwargs):
- """Log.SetVerbose(bool bVerbose=True)"""
+ """SetVerbose(bool bVerbose=True)"""
return _misc.Log_SetVerbose(*args, **kwargs)
SetVerbose = staticmethod(SetVerbose)
def SetLogLevel(*args, **kwargs):
- """Log.SetLogLevel(wxLogLevel logLevel)"""
+ """SetLogLevel(wxLogLevel logLevel)"""
return _misc.Log_SetLogLevel(*args, **kwargs)
SetLogLevel = staticmethod(SetLogLevel)
def DontCreateOnDemand(*args, **kwargs):
- """Log.DontCreateOnDemand()"""
+ """DontCreateOnDemand()"""
return _misc.Log_DontCreateOnDemand(*args, **kwargs)
DontCreateOnDemand = staticmethod(DontCreateOnDemand)
def SetTraceMask(*args, **kwargs):
- """Log.SetTraceMask(wxTraceMask ulMask)"""
+ """SetTraceMask(wxTraceMask ulMask)"""
return _misc.Log_SetTraceMask(*args, **kwargs)
SetTraceMask = staticmethod(SetTraceMask)
def AddTraceMask(*args, **kwargs):
- """Log.AddTraceMask(wxString str)"""
+ """AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
AddTraceMask = staticmethod(AddTraceMask)
def RemoveTraceMask(*args, **kwargs):
- """Log.RemoveTraceMask(wxString str)"""
+ """RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
RemoveTraceMask = staticmethod(RemoveTraceMask)
def ClearTraceMasks(*args, **kwargs):
- """Log.ClearTraceMasks()"""
+ """ClearTraceMasks()"""
return _misc.Log_ClearTraceMasks(*args, **kwargs)
ClearTraceMasks = staticmethod(ClearTraceMasks)
def GetTraceMasks(*args, **kwargs):
- """Log.GetTraceMasks() -> wxArrayString"""
+ """GetTraceMasks() -> wxArrayString"""
return _misc.Log_GetTraceMasks(*args, **kwargs)
GetTraceMasks = staticmethod(GetTraceMasks)
def SetTimestamp(*args, **kwargs):
- """Log.SetTimestamp(wxChar ts)"""
+ """SetTimestamp(wxChar ts)"""
return _misc.Log_SetTimestamp(*args, **kwargs)
SetTimestamp = staticmethod(SetTimestamp)
def GetVerbose(*args, **kwargs):
- """Log.GetVerbose() -> bool"""
+ """GetVerbose() -> bool"""
return _misc.Log_GetVerbose(*args, **kwargs)
GetVerbose = staticmethod(GetVerbose)
def GetTraceMask(*args, **kwargs):
- """Log.GetTraceMask() -> wxTraceMask"""
+ """GetTraceMask() -> wxTraceMask"""
return _misc.Log_GetTraceMask(*args, **kwargs)
GetTraceMask = staticmethod(GetTraceMask)
def IsAllowedTraceMask(*args, **kwargs):
- """Log.IsAllowedTraceMask(wxChar mask) -> bool"""
+ """IsAllowedTraceMask(wxChar mask) -> bool"""
return _misc.Log_IsAllowedTraceMask(*args, **kwargs)
IsAllowedTraceMask = staticmethod(IsAllowedTraceMask)
def GetLogLevel(*args, **kwargs):
- """Log.GetLogLevel() -> wxLogLevel"""
+ """GetLogLevel() -> wxLogLevel"""
return _misc.Log_GetLogLevel(*args, **kwargs)
GetLogLevel = staticmethod(GetLogLevel)
def GetTimestamp(*args, **kwargs):
- """Log.GetTimestamp() -> wxChar"""
+ """GetTimestamp() -> wxChar"""
return _misc.Log_GetTimestamp(*args, **kwargs)
GetTimestamp = staticmethod(GetTimestamp)
def TimeStamp(*args, **kwargs):
- """Log.TimeStamp() -> wxString"""
+ """TimeStamp() -> String"""
return _misc.Log_TimeStamp(*args, **kwargs)
TimeStamp = staticmethod(TimeStamp)
return _misc.Log_SetTraceMask(*args, **kwargs)
def Log_AddTraceMask(*args, **kwargs):
- """Log_AddTraceMask(wxString str)"""
+ """Log_AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
def Log_RemoveTraceMask(*args, **kwargs):
- """Log_RemoveTraceMask(wxString str)"""
+ """Log_RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
def Log_ClearTraceMasks(*args, **kwargs):
return _misc.Log_GetTimestamp(*args, **kwargs)
def Log_TimeStamp(*args, **kwargs):
- """Log_TimeStamp() -> wxString"""
+ """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):
_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):
_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):
_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, wxString szTitle, bool bShow=True,
- bool bPassToOld=True) -> LogWindow"""
+ """__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
_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):
return _misc.SysErrorCode(*args, **kwargs)
def SysErrorMsg(*args, **kwargs):
- """SysErrorMsg(unsigned long nErrCode=0) -> wxString"""
+ """SysErrorMsg(unsigned long nErrCode=0) -> String"""
return _misc.SysErrorMsg(*args, **kwargs)
def LogFatalError(*args, **kwargs):
- """LogFatalError(wxString msg)"""
+ """LogFatalError(String msg)"""
return _misc.LogFatalError(*args, **kwargs)
def LogError(*args, **kwargs):
- """LogError(wxString msg)"""
+ """LogError(String msg)"""
return _misc.LogError(*args, **kwargs)
def LogWarning(*args, **kwargs):
- """LogWarning(wxString msg)"""
+ """LogWarning(String msg)"""
return _misc.LogWarning(*args, **kwargs)
def LogMessage(*args, **kwargs):
- """LogMessage(wxString msg)"""
+ """LogMessage(String msg)"""
return _misc.LogMessage(*args, **kwargs)
def LogInfo(*args, **kwargs):
- """LogInfo(wxString msg)"""
+ """LogInfo(String msg)"""
return _misc.LogInfo(*args, **kwargs)
def LogDebug(*args, **kwargs):
- """LogDebug(wxString msg)"""
+ """LogDebug(String msg)"""
return _misc.LogDebug(*args, **kwargs)
def LogVerbose(*args, **kwargs):
- """LogVerbose(wxString msg)"""
+ """LogVerbose(String msg)"""
return _misc.LogVerbose(*args, **kwargs)
def LogStatus(*args, **kwargs):
- """LogStatus(wxString msg)"""
+ """LogStatus(String msg)"""
return _misc.LogStatus(*args, **kwargs)
def LogStatusFrame(*args, **kwargs):
- """LogStatusFrame(wxFrame pFrame, wxString msg)"""
+ """LogStatusFrame(wxFrame pFrame, String msg)"""
return _misc.LogStatusFrame(*args, **kwargs)
def LogSysError(*args, **kwargs):
- """LogSysError(wxString msg)"""
+ """LogSysError(String msg)"""
return _misc.LogSysError(*args, **kwargs)
-def LogTrace(*args, **kwargs):
- """LogTrace(wxString msg)"""
- return _misc.LogTrace(*args, **kwargs)
-
-def LogTraceMask(*args, **kwargs):
- """LogTraceMask(wxString mask, wxString msg)"""
- return _misc.LogTraceMask(*args, **kwargs)
-
def LogGeneric(*args, **kwargs):
- """LogGeneric(unsigned long level, wxString msg)"""
+ """LogGeneric(unsigned long level, String msg)"""
return _misc.LogGeneric(*args, **kwargs)
def SafeShowMessage(*args, **kwargs):
- """SafeShowMessage(wxString title, wxString text)"""
+ """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):
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):
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, wxSignal sig=SIGTERM) -> wxKillError"""
+ """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"""
+ """Exists(int pid) -> bool"""
return _misc.Process_Exists(*args, **kwargs)
Exists = staticmethod(Exists)
def Open(*args, **kwargs):
- """Process.Open(wxString cmd, int flags=EXEC_ASYNC) -> Process"""
+ """Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
return _misc.Process_Open(*args, **kwargs)
Open = staticmethod(Open)
return _misc.Process_Detach(*args, **kwargs)
def GetInputStream(*args, **kwargs):
- """GetInputStream() -> wxInputStream"""
+ """GetInputStream() -> InputStream"""
return _misc.Process_GetInputStream(*args, **kwargs)
def GetErrorStream(*args, **kwargs):
- """GetErrorStream() -> wxInputStream"""
+ """GetErrorStream() -> InputStream"""
return _misc.Process_GetErrorStream(*args, **kwargs)
def GetOutputStream(*args, **kwargs):
_misc.Process_swigregister(ProcessPtr)
def Process_Kill(*args, **kwargs):
- """Process_Kill(int pid, wxSignal sig=SIGTERM) -> wxKillError"""
+ """Process_Kill(int pid, int sig=SIGTERM) -> int"""
return _misc.Process_Kill(*args, **kwargs)
def Process_Exists(*args, **kwargs):
return _misc.Process_Exists(*args, **kwargs)
def Process_Open(*args, **kwargs):
- """Process_Open(wxString cmd, int flags=EXEC_ASYNC) -> Process"""
+ """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):
EXEC_MAKE_GROUP_LEADER = _misc.EXEC_MAKE_GROUP_LEADER
def Execute(*args, **kwargs):
- """Execute(wxString command, int flags=EXEC_ASYNC, Process process=None) -> long"""
+ """Execute(String command, int flags=EXEC_ASYNC, Process process=None) -> long"""
return _misc.Execute(*args, **kwargs)
#---------------------------------------------------------------------------
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):
return _misc.Joystick_SetMovementThreshold(*args, **kwargs)
def IsOk(*args, **kwargs):
- """IsOk(void ??) -> bool"""
+ """IsOk() -> bool"""
return _misc.Joystick_IsOk(*args, **kwargs)
def GetNumberJoysticks(*args, **kwargs):
return _misc.Joystick_GetProductId(*args, **kwargs)
def GetProductName(*args, **kwargs):
- """GetProductName() -> wxString"""
+ """GetProductName() -> String"""
return _misc.Joystick_GetProductName(*args, **kwargs)
def GetXMin(*args, **kwargs):
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_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"""
+ """
+ __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
#---------------------------------------------------------------------------
-class Wave(object):
- """"""
+SOUND_SYNC = _misc.SOUND_SYNC
+SOUND_ASYNC = _misc.SOUND_ASYNC
+SOUND_LOOP = _misc.SOUND_LOOP
+class Sound(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__(wxString fileName, bool isResource=False) -> Wave"""
- newobj = _misc.new_Wave(*args, **kwargs)
+ return "<%s.%s; proxy of C++ wxSound instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args):
+ """
+ __init__() -> Sound
+ __init__(String fileName, bool isResource=false) -> Sound
+ __init__(int size, wxByte data) -> Sound
+ """
+ newobj = _misc.new_Sound(*args)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- def __del__(self, destroy=_misc.delete_Wave):
+ def __del__(self, destroy=_misc.delete_Sound):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
+ def Create(*args):
+ """
+ Create(String fileName, bool isResource=false) -> bool
+ Create(int size, wxByte data) -> bool
+ """
+ return _misc.Sound_Create(*args)
+
def IsOk(*args, **kwargs):
"""IsOk() -> bool"""
- return _misc.Wave_IsOk(*args, **kwargs)
+ return _misc.Sound_IsOk(*args, **kwargs)
- def Play(*args, **kwargs):
- """Play(bool async=True, bool looped=False) -> bool"""
- return _misc.Wave_Play(*args, **kwargs)
+ def Play(*args):
+ """Play(unsigned int flags=SOUND_ASYNC) -> bool"""
+ return _misc.Sound_Play(*args)
+ def PlaySound(*args):
+ """PlaySound(String filename, unsigned int flags=SOUND_ASYNC) -> bool"""
+ return _misc.Sound_PlaySound(*args)
+
+ PlaySound = staticmethod(PlaySound)
+ def Stop(*args, **kwargs):
+ """Stop()"""
+ return _misc.Sound_Stop(*args, **kwargs)
+
+ Stop = staticmethod(Stop)
def __nonzero__(self): return self.IsOk()
-class WavePtr(Wave):
+class SoundPtr(Sound):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Wave
-_misc.Wave_swigregister(WavePtr)
+ self.__class__ = Sound
+_misc.Sound_swigregister(SoundPtr)
-def WaveData(*args, **kwargs):
- """WaveData(wxString data) -> Wave"""
- val = _misc.new_WaveData(*args, **kwargs)
- val.thisown = 1
- return val
+def Sound_PlaySound(*args):
+ """Sound_PlaySound(String filename, unsigned int flags=SOUND_ASYNC) -> bool"""
+ return _misc.Sound_PlaySound(*args)
+
+def Sound_Stop(*args, **kwargs):
+ """Sound_Stop()"""
+ return _misc.Sound_Stop(*args, **kwargs)
#---------------------------------------------------------------------------
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__(wxString mimeType, wxString openCmd, wxString printCmd,
- wxString desc) -> FileTypeInfo"""
+ """__init__(String mimeType, String openCmd, String printCmd, String desc) -> FileTypeInfo"""
newobj = _misc.new_FileTypeInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.FileTypeInfo_IsValid(*args, **kwargs)
def SetIcon(*args, **kwargs):
- """SetIcon(wxString iconFile, int iconIndex=0)"""
+ """SetIcon(String iconFile, int iconIndex=0)"""
return _misc.FileTypeInfo_SetIcon(*args, **kwargs)
def SetShortDesc(*args, **kwargs):
- """SetShortDesc(wxString shortDesc)"""
+ """SetShortDesc(String shortDesc)"""
return _misc.FileTypeInfo_SetShortDesc(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _misc.FileTypeInfo_GetMimeType(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
- """GetOpenCommand() -> wxString"""
+ """GetOpenCommand() -> String"""
return _misc.FileTypeInfo_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
- """GetPrintCommand() -> wxString"""
+ """GetPrintCommand() -> String"""
return _misc.FileTypeInfo_GetPrintCommand(*args, **kwargs)
def GetShortDesc(*args, **kwargs):
- """GetShortDesc() -> wxString"""
+ """GetShortDesc() -> String"""
return _misc.FileTypeInfo_GetShortDesc(*args, **kwargs)
def GetDescription(*args, **kwargs):
- """GetDescription() -> wxString"""
+ """GetDescription() -> String"""
return _misc.FileTypeInfo_GetDescription(*args, **kwargs)
def GetExtensions(*args, **kwargs):
return _misc.FileTypeInfo_GetExtensionsCount(*args, **kwargs)
def GetIconFile(*args, **kwargs):
- """GetIconFile() -> wxString"""
+ """GetIconFile() -> String"""
return _misc.FileTypeInfo_GetIconFile(*args, **kwargs)
def GetIconIndex(*args, **kwargs):
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):
return _misc.FileType_GetExtensions(*args, **kwargs)
def GetIcon(*args, **kwargs):
- """GetIcon() -> wxIcon"""
+ """GetIcon() -> Icon"""
return _misc.FileType_GetIcon(*args, **kwargs)
def GetIconInfo(*args, **kwargs):
return _misc.FileType_GetDescription(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
- """GetOpenCommand(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetOpenCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
- """GetPrintCommand(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetPrintCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetPrintCommand(*args, **kwargs)
def GetAllCommands(*args, **kwargs):
- """GetAllCommands(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetAllCommands(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetAllCommands(*args, **kwargs)
def SetCommand(*args, **kwargs):
- """SetCommand(wxString cmd, wxString verb, bool overwriteprompt=True) -> bool"""
+ """SetCommand(String cmd, String verb, bool overwriteprompt=True) -> bool"""
return _misc.FileType_SetCommand(*args, **kwargs)
def SetDefaultIcon(*args, **kwargs):
- """SetDefaultIcon(wxString cmd=wxPyEmptyString, int index=0) -> bool"""
+ """SetDefaultIcon(String cmd=EmptyString, int index=0) -> bool"""
return _misc.FileType_SetDefaultIcon(*args, **kwargs)
def Unassociate(*args, **kwargs):
return _misc.FileType_Unassociate(*args, **kwargs)
def ExpandCommand(*args, **kwargs):
- """FileType.ExpandCommand(wxString command, wxString filename, wxString mimetype=wxPyEmptyString) -> wxString"""
+ """ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
return _misc.FileType_ExpandCommand(*args, **kwargs)
ExpandCommand = staticmethod(ExpandCommand)
_misc.FileType_swigregister(FileTypePtr)
def FileType_ExpandCommand(*args, **kwargs):
- """FileType_ExpandCommand(wxString command, wxString filename, wxString mimetype=wxPyEmptyString) -> wxString"""
+ """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(wxString mimeType, wxString wildcard) -> bool"""
+ """IsOfType(String mimeType, String wildcard) -> bool"""
return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
IsOfType = staticmethod(IsOfType)
self.thisown = 1
del newobj.thisown
def Initialize(*args, **kwargs):
- """Initialize(int mailcapStyle=MAILCAP_ALL, wxString extraDir=wxPyEmptyString)"""
+ """Initialize(int mailcapStyle=MAILCAP_ALL, String extraDir=EmptyString)"""
return _misc.MimeTypesManager_Initialize(*args, **kwargs)
def ClearData(*args, **kwargs):
return _misc.MimeTypesManager_ClearData(*args, **kwargs)
def GetFileTypeFromExtension(*args, **kwargs):
- """GetFileTypeFromExtension(wxString ext) -> FileType"""
+ """GetFileTypeFromExtension(String ext) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromExtension(*args, **kwargs)
def GetFileTypeFromMimeType(*args, **kwargs):
- """GetFileTypeFromMimeType(wxString mimeType) -> FileType"""
+ """GetFileTypeFromMimeType(String mimeType) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromMimeType(*args, **kwargs)
def ReadMailcap(*args, **kwargs):
- """ReadMailcap(wxString filename, bool fallback=False) -> bool"""
+ """ReadMailcap(String filename, bool fallback=False) -> bool"""
return _misc.MimeTypesManager_ReadMailcap(*args, **kwargs)
def ReadMimeTypes(*args, **kwargs):
- """ReadMimeTypes(wxString filename) -> bool"""
+ """ReadMimeTypes(String filename) -> bool"""
return _misc.MimeTypesManager_ReadMimeTypes(*args, **kwargs)
def EnumAllFileTypes(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MimeTypesManager
_misc.MimeTypesManager_swigregister(MimeTypesManagerPtr)
-cvar = _misc.cvar
TheMimeTypesManager = cvar.TheMimeTypesManager
def MimeTypesManager_IsOfType(*args, **kwargs):
- """MimeTypesManager_IsOfType(wxString mimeType, wxString wildcard) -> bool"""
+ """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):
return _misc.ArtProvider__setCallbackInfo(*args, **kwargs)
def PushProvider(*args, **kwargs):
- """ArtProvider.PushProvider(ArtProvider provider)"""
+ """
+ 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"""
+ """
+ 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"""
+ """
+ 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(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxBitmap"""
+ """
+ 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(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxIcon"""
+ """
+ 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):
ART_MISSING_IMAGE = cvar.ART_MISSING_IMAGE
def ArtProvider_PushProvider(*args, **kwargs):
- """ArtProvider_PushProvider(ArtProvider provider)"""
+ """
+ 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"""
+ """
+ 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"""
+ """
+ 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(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxBitmap"""
+ """
+ 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(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxIcon"""
+ """
+ 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_RELATIVE_PATH = _misc.CONFIG_USE_RELATIVE_PATH
CONFIG_USE_NO_ESCAPE_CHARACTERS = _misc.CONFIG_USE_NO_ESCAPE_CHARACTERS
class ConfigBase(object):
- """"""
+ """
+ wx.ConfigBase class defines the basic interface of all config
+ classes. It can not be used by itself (it is an abstract base
+ class) and you will always use one of its derivations: wx.Config
+ or wx.FileConfig.
+
+ wx.ConfigBase organizes the items in a tree-like structure,
+ modeled after the Unix/Dos filesystem. There are groups that act
+ like directories and entries, key/value pairs that act like
+ files. There is always one current group given by the current
+ path. As in the file system case, to specify a key in the config
+ class you must use a path to it. Config classes also support the
+ notion of the current group, which makes it possible to use
+ relative paths.
+
+ Keys are pairs "key_name = value" where value may be of string,
+ integer floating point or boolean, you can not store binary data
+ without first encoding it as a string. For performance reasons
+ items should be kept small, no more than a couple kilobytes.
+
+ """
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,)
Type_Integer = _misc.ConfigBase_Type_Integer
Type_Float = _misc.ConfigBase_Type_Float
def Set(*args, **kwargs):
- """ConfigBase.Set(ConfigBase pConfig) -> ConfigBase"""
+ """
+ Set(ConfigBase config) -> ConfigBase
+
+ Sets the global config object (the one returned by Get) and
+ returns a reference to the previous global config object.
+ """
return _misc.ConfigBase_Set(*args, **kwargs)
Set = staticmethod(Set)
def Get(*args, **kwargs):
- """ConfigBase.Get(bool createOnDemand=True) -> ConfigBase"""
+ """
+ Get(bool createOnDemand=True) -> ConfigBase
+
+ Returns the current global config object, creating one if neccessary.
+ """
return _misc.ConfigBase_Get(*args, **kwargs)
Get = staticmethod(Get)
def Create(*args, **kwargs):
- """ConfigBase.Create() -> ConfigBase"""
+ """
+ Create() -> ConfigBase
+
+ Create and return a new global config object. This function will
+ create the "best" implementation of wx.Config available for the
+ current platform.
+ """
return _misc.ConfigBase_Create(*args, **kwargs)
Create = staticmethod(Create)
def DontCreateOnDemand(*args, **kwargs):
- """ConfigBase.DontCreateOnDemand()"""
+ """
+ DontCreateOnDemand()
+
+ Should Get() try to create a new log object if there isn't a current one?
+ """
return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
DontCreateOnDemand = staticmethod(DontCreateOnDemand)
def SetPath(*args, **kwargs):
- """SetPath(wxString strPath)"""
+ """
+ SetPath(String path)
+
+ Set current path: if the first character is '/', it's the absolute path,
+ otherwise it's a relative path. '..' is supported. If the strPath
+ doesn't exist it is created.
+ """
return _misc.ConfigBase_SetPath(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """
+ GetPath() -> String
+
+ Retrieve the current path (always as absolute path)
+ """
return _misc.ConfigBase_GetPath(*args, **kwargs)
def GetFirstGroup(*args, **kwargs):
- """GetFirstGroup() -> PyObject"""
+ """
+ GetFirstGroup() -> (more, value, index)
+
+ Allows enumerating the subgroups in a config object. Returns
+ a tuple containing a flag indicating there are more items, the
+ name of the current item, and an index to pass to GetNextGroup to
+ fetch the next item.
+ """
return _misc.ConfigBase_GetFirstGroup(*args, **kwargs)
def GetNextGroup(*args, **kwargs):
- """GetNextGroup(long index) -> PyObject"""
+ """
+ GetNextGroup(long index) -> (more, value, index)
+
+ Allows enumerating the subgroups in a config object. Returns
+ a tuple containing a flag indicating there are more items, the
+ name of the current item, and an index to pass to GetNextGroup to
+ fetch the next item.
+ """
return _misc.ConfigBase_GetNextGroup(*args, **kwargs)
def GetFirstEntry(*args, **kwargs):
- """GetFirstEntry() -> PyObject"""
+ """
+ GetFirstEntry() -> (more, value, index)
+
+ Allows enumerating the entries in the current group in a config
+ object. Returns a tuple containing a flag indicating there are
+ more items, the name of the current item, and an index to pass to
+ GetNextGroup to fetch the next item.
+ """
return _misc.ConfigBase_GetFirstEntry(*args, **kwargs)
def GetNextEntry(*args, **kwargs):
- """GetNextEntry(long index) -> PyObject"""
+ """
+ GetNextEntry(long index) -> (more, value, index)
+
+ Allows enumerating the entries in the current group in a config
+ object. Returns a tuple containing a flag indicating there are
+ more items, the name of the current item, and an index to pass to
+ GetNextGroup to fetch the next item.
+ """
return _misc.ConfigBase_GetNextEntry(*args, **kwargs)
def GetNumberOfEntries(*args, **kwargs):
- """GetNumberOfEntries(bool bRecursive=False) -> size_t"""
+ """
+ GetNumberOfEntries(bool recursive=False) -> size_t
+
+ Get the number of entries in the current group, with or
+ without its subgroups.
+ """
return _misc.ConfigBase_GetNumberOfEntries(*args, **kwargs)
def GetNumberOfGroups(*args, **kwargs):
- """GetNumberOfGroups(bool bRecursive=False) -> size_t"""
+ """
+ GetNumberOfGroups(bool recursive=False) -> size_t
+
+ Get the number of subgroups in the current group, with or
+ without its subgroups.
+ """
return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
def HasGroup(*args, **kwargs):
- """HasGroup(wxString strName) -> bool"""
+ """
+ HasGroup(String name) -> bool
+
+ Returns True if the group by this name exists
+ """
return _misc.ConfigBase_HasGroup(*args, **kwargs)
def HasEntry(*args, **kwargs):
- """HasEntry(wxString strName) -> bool"""
+ """
+ HasEntry(String name) -> bool
+
+ Returns True if the entry by this name exists
+ """
return _misc.ConfigBase_HasEntry(*args, **kwargs)
def Exists(*args, **kwargs):
- """Exists(wxString strName) -> bool"""
+ """
+ Exists(String name) -> bool
+
+ Returns True if either a group or an entry with a given name exists
+ """
return _misc.ConfigBase_Exists(*args, **kwargs)
def GetEntryType(*args, **kwargs):
- """GetEntryType(wxString name) -> wxConfigBase::EntryType"""
+ """
+ GetEntryType(String name) -> int
+
+ Get the type of the entry. Returns one of the wx.Config.Type_XXX values.
+ """
return _misc.ConfigBase_GetEntryType(*args, **kwargs)
def Read(*args, **kwargs):
- """Read(wxString key, wxString defaultVal=wxPyEmptyString) -> wxString"""
+ """
+ Read(String key, String defaultVal=EmptyString) -> String
+
+ Returns the value of key if it exists, defaultVal otherwise.
+ """
return _misc.ConfigBase_Read(*args, **kwargs)
def ReadInt(*args, **kwargs):
- """ReadInt(wxString key, long defaultVal=0) -> long"""
+ """
+ ReadInt(String key, long defaultVal=0) -> long
+
+ Returns the value of key if it exists, defaultVal otherwise.
+ """
return _misc.ConfigBase_ReadInt(*args, **kwargs)
def ReadFloat(*args, **kwargs):
- """ReadFloat(wxString key, double defaultVal=0.0) -> double"""
+ """
+ ReadFloat(String key, double defaultVal=0.0) -> double
+
+ Returns the value of key if it exists, defaultVal otherwise.
+ """
return _misc.ConfigBase_ReadFloat(*args, **kwargs)
def ReadBool(*args, **kwargs):
- """ReadBool(wxString key, bool defaultVal=False) -> bool"""
+ """
+ ReadBool(String key, bool defaultVal=False) -> bool
+
+ Returns the value of key if it exists, defaultVal otherwise.
+ """
return _misc.ConfigBase_ReadBool(*args, **kwargs)
def Write(*args, **kwargs):
- """Write(wxString key, wxString value) -> bool"""
+ """
+ Write(String key, String value) -> bool
+
+ write the value (return True on success)
+ """
return _misc.ConfigBase_Write(*args, **kwargs)
def WriteInt(*args, **kwargs):
- """WriteInt(wxString key, long value) -> bool"""
+ """
+ WriteInt(String key, long value) -> bool
+
+ write the value (return True on success)
+ """
return _misc.ConfigBase_WriteInt(*args, **kwargs)
def WriteFloat(*args, **kwargs):
- """WriteFloat(wxString key, double value) -> bool"""
+ """
+ WriteFloat(String key, double value) -> bool
+
+ write the value (return True on success)
+ """
return _misc.ConfigBase_WriteFloat(*args, **kwargs)
def WriteBool(*args, **kwargs):
- """WriteBool(wxString key, bool value) -> bool"""
+ """
+ WriteBool(String key, bool value) -> bool
+
+ write the value (return True on success)
+ """
return _misc.ConfigBase_WriteBool(*args, **kwargs)
def Flush(*args, **kwargs):
- """Flush(bool bCurrentOnly=False) -> bool"""
+ """
+ Flush(bool currentOnly=False) -> bool
+
+ permanently writes all changes
+ """
return _misc.ConfigBase_Flush(*args, **kwargs)
def RenameEntry(*args, **kwargs):
- """RenameEntry(wxString oldName, wxString newName) -> bool"""
+ """
+ RenameEntry(String oldName, String newName) -> bool
+
+ Rename an entry. Returns False on failure (probably because the new
+ name is already taken by an existing entry)
+ """
return _misc.ConfigBase_RenameEntry(*args, **kwargs)
def RenameGroup(*args, **kwargs):
- """RenameGroup(wxString oldName, wxString newName) -> bool"""
+ """
+ RenameGroup(String oldName, String newName) -> bool
+
+ Rename aa group. Returns False on failure (probably because the new
+ name is already taken by an existing entry)
+ """
return _misc.ConfigBase_RenameGroup(*args, **kwargs)
def DeleteEntry(*args, **kwargs):
- """DeleteEntry(wxString key, bool bDeleteGroupIfEmpty=True) -> bool"""
+ """
+ DeleteEntry(String key, bool deleteGroupIfEmpty=True) -> bool
+
+ Deletes the specified entry and the group it belongs to if
+ it was the last key in it and the second parameter is True
+ """
return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
def DeleteGroup(*args, **kwargs):
- """DeleteGroup(wxString key) -> bool"""
+ """
+ DeleteGroup(String key) -> bool
+
+ Delete the group (with all subgroups)
+ """
return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
def DeleteAll(*args, **kwargs):
- """DeleteAll() -> bool"""
- return _misc.ConfigBase_DeleteAll(*args, **kwargs)
+ """
+ DeleteAll() -> bool
- def IsExpandingEnvVars(*args, **kwargs):
- """IsExpandingEnvVars() -> bool"""
- return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
+ Delete the whole underlying object (disk file, registry key, ...)
+ primarly intended for use by desinstallation routine.
+ """
+ return _misc.ConfigBase_DeleteAll(*args, **kwargs)
def SetExpandEnvVars(*args, **kwargs):
- """SetExpandEnvVars(bool bDoIt=True)"""
+ """
+ SetExpandEnvVars(bool doIt=True)
+
+ We can automatically expand environment variables in the config entries
+ (this option is on by default, you can turn it on/off at any time)
+ """
return _misc.ConfigBase_SetExpandEnvVars(*args, **kwargs)
+ def IsExpandingEnvVars(*args, **kwargs):
+ """
+ IsExpandingEnvVars() -> bool
+
+ Are we currently expanding environment variables?
+ """
+ return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
+
def SetRecordDefaults(*args, **kwargs):
- """SetRecordDefaults(bool bDoIt=True)"""
+ """
+ SetRecordDefaults(bool doIt=True)
+
+ Set whether the config objec should record default values.
+ """
return _misc.ConfigBase_SetRecordDefaults(*args, **kwargs)
def IsRecordingDefaults(*args, **kwargs):
- """IsRecordingDefaults() -> bool"""
+ """
+ IsRecordingDefaults() -> bool
+
+ Are we currently recording default values?
+ """
return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
def ExpandEnvVars(*args, **kwargs):
- """ExpandEnvVars(wxString str) -> wxString"""
+ """
+ ExpandEnvVars(String str) -> String
+
+ Expand any environment variables in str and return the result
+ """
return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
def GetAppName(*args, **kwargs):
- """GetAppName() -> wxString"""
+ """GetAppName() -> String"""
return _misc.ConfigBase_GetAppName(*args, **kwargs)
def GetVendorName(*args, **kwargs):
- """GetVendorName() -> wxString"""
+ """GetVendorName() -> String"""
return _misc.ConfigBase_GetVendorName(*args, **kwargs)
def SetAppName(*args, **kwargs):
- """SetAppName(wxString appName)"""
+ """SetAppName(String appName)"""
return _misc.ConfigBase_SetAppName(*args, **kwargs)
def SetVendorName(*args, **kwargs):
- """SetVendorName(wxString vendorName)"""
+ """SetVendorName(String vendorName)"""
return _misc.ConfigBase_SetVendorName(*args, **kwargs)
def SetStyle(*args, **kwargs):
_misc.ConfigBase_swigregister(ConfigBasePtr)
def ConfigBase_Set(*args, **kwargs):
- """ConfigBase_Set(ConfigBase pConfig) -> ConfigBase"""
+ """
+ ConfigBase_Set(ConfigBase config) -> ConfigBase
+
+ Sets the global config object (the one returned by Get) and
+ returns a reference to the previous global config object.
+ """
return _misc.ConfigBase_Set(*args, **kwargs)
def ConfigBase_Get(*args, **kwargs):
- """ConfigBase_Get(bool createOnDemand=True) -> ConfigBase"""
+ """
+ ConfigBase_Get(bool createOnDemand=True) -> ConfigBase
+
+ Returns the current global config object, creating one if neccessary.
+ """
return _misc.ConfigBase_Get(*args, **kwargs)
def ConfigBase_Create(*args, **kwargs):
- """ConfigBase_Create() -> ConfigBase"""
+ """
+ ConfigBase_Create() -> ConfigBase
+
+ Create and return a new global config object. This function will
+ create the "best" implementation of wx.Config available for the
+ current platform.
+ """
return _misc.ConfigBase_Create(*args, **kwargs)
def ConfigBase_DontCreateOnDemand(*args, **kwargs):
- """ConfigBase_DontCreateOnDemand()"""
+ """
+ ConfigBase_DontCreateOnDemand()
+
+ Should Get() try to create a new log object if there isn't a current one?
+ """
return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
-class ConfigPathChanger(object):
- """"""
+class Config(ConfigBase):
+ """
+ This ConfigBase-derived class will use the registry on Windows,
+ and will be a wx.FileConfig on other platforms.
+ """
def __repr__(self):
- return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(ConfigBase pContainer, wxString strEntry) -> ConfigPathChanger"""
- newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
+ """
+ __init__(String appName=EmptyString, String vendorName=EmptyString,
+ String localFilename=EmptyString, String globalFilename=EmptyString,
+ long style=wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE) -> Config
+ """
+ newobj = _misc.new_Config(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- def __del__(self, destroy=_misc.delete_ConfigPathChanger):
+ def __del__(self, destroy=_misc.delete_Config):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
- def Name(*args, **kwargs):
- """Name() -> wxString"""
- return _misc.ConfigPathChanger_Name(*args, **kwargs)
-
-class ConfigPathChangerPtr(ConfigPathChanger):
+class ConfigPtr(Config):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ConfigPathChanger
-_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)
+ self.__class__ = Config
+_misc.Config_swigregister(ConfigPtr)
-class Config(ConfigBase):
- """"""
+class FileConfig(ConfigBase):
+ """This config class will use a file for storage on all platforms."""
def __repr__(self):
- return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString appName=wxPyEmptyString, wxString vendorName=wxPyEmptyString,
- wxString localFilename=wxPyEmptyString,
- wxString globalFilename=wxPyEmptyString,
- long style=0) -> Config"""
- newobj = _misc.new_Config(*args, **kwargs)
+ """
+ __init__(String appName=EmptyString, String vendorName=EmptyString,
+ String localFilename=EmptyString, String globalFilename=EmptyString,
+ long style=wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE) -> FileConfig
+ """
+ newobj = _misc.new_FileConfig(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- def __del__(self, destroy=_misc.delete_Config):
+ def __del__(self, destroy=_misc.delete_FileConfig):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
-class ConfigPtr(Config):
+class FileConfigPtr(FileConfig):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Config
-_misc.Config_swigregister(ConfigPtr)
+ self.__class__ = FileConfig
+_misc.FileConfig_swigregister(FileConfigPtr)
-class FileConfig(ConfigBase):
- """"""
+class ConfigPathChanger(object):
+ """
+ A handy little class which changes current path to the path of
+ given entry and restores it in the destructoir: so if you declare
+ a local variable of this type, you work in the entry directory
+ and the path is automatically restored when the function returns.
+ """
def __repr__(self):
- return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString appName=wxPyEmptyString, wxString vendorName=wxPyEmptyString,
- wxString localFilename=wxPyEmptyString,
- wxString globalFilename=wxPyEmptyString,
- long style=0) -> FileConfig"""
- newobj = _misc.new_FileConfig(*args, **kwargs)
+ """__init__(ConfigBase config, String entry) -> ConfigPathChanger"""
+ newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- def __del__(self, destroy=_misc.delete_FileConfig):
+ def __del__(self, destroy=_misc.delete_ConfigPathChanger):
"""__del__()"""
try:
if self.thisown: destroy(self)
except: pass
+ def Name(*args, **kwargs):
+ """
+ Name() -> String
-class FileConfigPtr(FileConfig):
+ Get the key name
+ """
+ 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__ = FileConfig
-_misc.FileConfig_swigregister(FileConfigPtr)
+ self.__class__ = ConfigPathChanger
+_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)
def ExpandEnvVars(*args, **kwargs):
- """ExpandEnvVars(wxString sz) -> wxString"""
+ """
+ ExpandEnvVars(String sz) -> String
+
+ Replace environment variables ($SOMETHING) with their values. The
+ format is $VARNAME or ${VARNAME} where VARNAME contains
+ alphanumeric characters and '_' only. '$' must be escaped ('\$')
+ in order to be taken literally.
+ """
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
Monday_First = _misc.DateTime_Monday_First
Sunday_First = _misc.DateTime_Sunday_First
def SetCountry(*args, **kwargs):
- """DateTime.SetCountry(wxDateTime::Country country)"""
+ """SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
SetCountry = staticmethod(SetCountry)
def GetCountry(*args, **kwargs):
- """DateTime.GetCountry() -> wxDateTime::Country"""
+ """GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
GetCountry = staticmethod(GetCountry)
def IsWestEuropeanCountry(*args, **kwargs):
- """DateTime.IsWestEuropeanCountry(wxDateTime::Country country=Country_Default) -> bool"""
+ """IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
IsWestEuropeanCountry = staticmethod(IsWestEuropeanCountry)
def GetCurrentYear(*args, **kwargs):
- """DateTime.GetCurrentYear(wxDateTime::Calendar cal=Gregorian) -> int"""
+ """GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
GetCurrentYear = staticmethod(GetCurrentYear)
def ConvertYearToBC(*args, **kwargs):
- """DateTime.ConvertYearToBC(int year) -> int"""
+ """ConvertYearToBC(int year) -> int"""
return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
ConvertYearToBC = staticmethod(ConvertYearToBC)
def GetCurrentMonth(*args, **kwargs):
- """DateTime.GetCurrentMonth(wxDateTime::Calendar cal=Gregorian) -> wxDateTime::Month"""
+ """GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
GetCurrentMonth = staticmethod(GetCurrentMonth)
def IsLeapYear(*args, **kwargs):
- """DateTime.IsLeapYear(int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> bool"""
+ """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"""
+ """GetCentury(int year=Inv_Year) -> int"""
return _misc.DateTime_GetCentury(*args, **kwargs)
GetCentury = staticmethod(GetCentury)
def GetNumberOfDaysinYear(*args, **kwargs):
- """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
def GetNumberOfDaysInMonth(*args, **kwargs):
- """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """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(wxDateTime::Month month, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
GetMonthName = staticmethod(GetMonthName)
def GetWeekDayName(*args, **kwargs):
- """DateTime.GetWeekDayName(wxDateTime::WeekDay weekday, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
GetWeekDayName = staticmethod(GetWeekDayName)
def GetAmPmStrings(*args, **kwargs):
- """GetAmPmStrings() -> (am, pm)
+ """
+ GetAmPmStrings() -> (am, pm)
-Get the AM and PM strings in the current locale (may be empty)"""
+ 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, wxDateTime::Country country=Country_Default) -> bool"""
+ """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, wxDateTime::Country country=Country_Default) -> 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, wxDateTime::Country country=Country_Default) -> 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"""
+ """Now() -> DateTime"""
return _misc.DateTime_Now(*args, **kwargs)
Now = staticmethod(Now)
def UNow(*args, **kwargs):
- """DateTime.UNow() -> DateTime"""
+ """UNow() -> DateTime"""
return _misc.DateTime_UNow(*args, **kwargs)
UNow = staticmethod(UNow)
def Today(*args, **kwargs):
- """DateTime.Today() -> DateTime"""
+ """Today() -> DateTime"""
return _misc.DateTime_Today(*args, **kwargs)
Today = staticmethod(Today)
return _misc.DateTime_SetHMS(*args, **kwargs)
def Set(*args, **kwargs):
- """Set(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year,
- int hour=0, int minute=0, int second=0,
- int millisec=0) -> DateTime"""
+ """
+ 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):
return _misc.DateTime_SetYear(*args, **kwargs)
def SetMonth(*args, **kwargs):
- """SetMonth(wxDateTime::Month month) -> DateTime"""
+ """SetMonth(int month) -> DateTime"""
return _misc.DateTime_SetMonth(*args, **kwargs)
def SetDay(*args, **kwargs):
return _misc.DateTime_SetMillisecond(*args, **kwargs)
def SetToWeekDayInSameWeek(*args, **kwargs):
- """SetToWeekDayInSameWeek(wxDateTime::WeekDay weekday, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """SetToWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_SetToWeekDayInSameWeek(*args, **kwargs)
def GetWeekDayInSameWeek(*args, **kwargs):
- """GetWeekDayInSameWeek(wxDateTime::WeekDay weekday, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """GetWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeekDayInSameWeek(*args, **kwargs)
def SetToNextWeekDay(*args, **kwargs):
- """SetToNextWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """SetToNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToNextWeekDay(*args, **kwargs)
def GetNextWeekDay(*args, **kwargs):
- """GetNextWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """GetNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetNextWeekDay(*args, **kwargs)
def SetToPrevWeekDay(*args, **kwargs):
- """SetToPrevWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """SetToPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToPrevWeekDay(*args, **kwargs)
def GetPrevWeekDay(*args, **kwargs):
- """GetPrevWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """GetPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetPrevWeekDay(*args, **kwargs)
def SetToWeekDay(*args, **kwargs):
- """SetToWeekDay(wxDateTime::WeekDay weekday, int n=1, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> bool"""
+ """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(wxDateTime::WeekDay weekday, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> bool"""
+ """SetToLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> bool"""
return _misc.DateTime_SetToLastWeekDay(*args, **kwargs)
def GetLastWeekDay(*args, **kwargs):
- """GetLastWeekDay(wxDateTime::WeekDay weekday, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> DateTime"""
+ """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, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> bool"""
+ """SetToTheWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> bool"""
return _misc.DateTime_SetToTheWeek(*args, **kwargs)
def GetWeek(*args, **kwargs):
- """GetWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """GetWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeek(*args, **kwargs)
def SetToLastMonthDay(*args, **kwargs):
- """SetToLastMonthDay(wxDateTime::Month month=Inv_Month, int year=Inv_Year) -> DateTime"""
+ """SetToLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_SetToLastMonthDay(*args, **kwargs)
def GetLastMonthDay(*args, **kwargs):
- """GetLastMonthDay(wxDateTime::Month month=Inv_Month, int year=Inv_Year) -> DateTime"""
+ """GetLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
def SetToYearDay(*args, **kwargs):
return _misc.DateTime_MakeGMT(*args, **kwargs)
def IsDST(*args, **kwargs):
- """IsDST(wxDateTime::Country country=Country_Default) -> int"""
+ """IsDST(int country=Country_Default) -> int"""
return _misc.DateTime_IsDST(*args, **kwargs)
def IsValid(*args, **kwargs):
"""IsValid() -> bool"""
return _misc.DateTime_IsValid(*args, **kwargs)
+ Ok = IsValid
+ def __nonzero__(self): return self.Ok()
def GetTicks(*args, **kwargs):
"""GetTicks() -> time_t"""
return _misc.DateTime_GetTicks(*args, **kwargs)
return _misc.DateTime_GetYear(*args, **kwargs)
def GetMonth(*args, **kwargs):
- """GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime::Month"""
+ """GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetMonth(*args, **kwargs)
def GetDay(*args, **kwargs):
return _misc.DateTime_GetDay(*args, **kwargs)
def GetWeekDay(*args, **kwargs):
- """GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime::WeekDay"""
+ """GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekDay(*args, **kwargs)
def GetHour(*args, **kwargs):
return _misc.DateTime_GetDayOfYear(*args, **kwargs)
def GetWeekOfYear(*args, **kwargs):
- """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
+ """GetWeekOfYear(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
def GetWeekOfMonth(*args, **kwargs):
- """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
+ """GetWeekOfMonth(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
def IsWorkDay(*args, **kwargs):
- """IsWorkDay(wxDateTime::Country country=Country_Default) -> bool"""
+ """IsWorkDay(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWorkDay(*args, **kwargs)
def IsEqualTo(*args, **kwargs):
return _misc.DateTime_Subtract(*args, **kwargs)
def __iadd__(*args):
- """__iadd__(TimeSpan diff) -> DateTime
-__iadd__(DateSpan diff) -> DateTime"""
+ """
+ __iadd__(TimeSpan diff) -> DateTime
+ __iadd__(DateSpan diff) -> DateTime
+ """
return _misc.DateTime___iadd__(*args)
def __isub__(*args):
- """__isub__(TimeSpan diff) -> DateTime
-__isub__(DateSpan diff) -> DateTime"""
+ """
+ __isub__(TimeSpan diff) -> DateTime
+ __isub__(DateSpan diff) -> DateTime
+ """
return _misc.DateTime___isub__(*args)
def __add__(*args):
- """__add__(TimeSpan other) -> DateTime
-__add__(DateSpan other) -> DateTime"""
+ """
+ __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"""
+ """
+ __sub__(DateTime other) -> TimeSpan
+ __sub__(TimeSpan other) -> DateTime
+ __sub__(DateSpan other) -> DateTime
+ """
return _misc.DateTime___sub__(*args)
def __lt__(*args):
return _misc.DateTime___ne__(*args)
def ParseRfc822Date(*args, **kwargs):
- """ParseRfc822Date(wxString date) -> int"""
+ """ParseRfc822Date(String date) -> int"""
return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
def ParseFormat(*args, **kwargs):
- """ParseFormat(wxString date, wxString format=wxPyDateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int"""
+ """ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=DefaultDateTime) -> int"""
return _misc.DateTime_ParseFormat(*args, **kwargs)
def ParseDateTime(*args, **kwargs):
- """ParseDateTime(wxString datetime) -> int"""
+ """ParseDateTime(String datetime) -> int"""
return _misc.DateTime_ParseDateTime(*args, **kwargs)
def ParseDate(*args, **kwargs):
- """ParseDate(wxString date) -> int"""
+ """ParseDate(String date) -> int"""
return _misc.DateTime_ParseDate(*args, **kwargs)
def ParseTime(*args, **kwargs):
- """ParseTime(wxString time) -> int"""
+ """ParseTime(String time) -> int"""
return _misc.DateTime_ParseTime(*args, **kwargs)
def Format(*args, **kwargs):
- """Format(wxString format=wxPyDateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxString"""
+ """Format(String format=DateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> String"""
return _misc.DateTime_Format(*args, **kwargs)
def FormatDate(*args, **kwargs):
- """FormatDate() -> wxString"""
+ """FormatDate() -> String"""
return _misc.DateTime_FormatDate(*args, **kwargs)
def FormatTime(*args, **kwargs):
- """FormatTime() -> wxString"""
+ """FormatTime() -> String"""
return _misc.DateTime_FormatTime(*args, **kwargs)
def FormatISODate(*args, **kwargs):
- """FormatISODate() -> wxString"""
+ """FormatISODate() -> String"""
return _misc.DateTime_FormatISODate(*args, **kwargs)
def FormatISOTime(*args, **kwargs):
- """FormatISOTime() -> wxString"""
+ """FormatISOTime() -> String"""
return _misc.DateTime_FormatISOTime(*args, **kwargs)
def __repr__(self):
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(wxDateTime::Country country)"""
+ """DateTime_SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
def DateTime_GetCountry(*args, **kwargs):
- """DateTime_GetCountry() -> wxDateTime::Country"""
+ """DateTime_GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
def DateTime_IsWestEuropeanCountry(*args, **kwargs):
- """DateTime_IsWestEuropeanCountry(wxDateTime::Country country=Country_Default) -> bool"""
+ """DateTime_IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
def DateTime_GetCurrentYear(*args, **kwargs):
- """DateTime_GetCurrentYear(wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime_GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
def DateTime_ConvertYearToBC(*args, **kwargs):
return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
def DateTime_GetCurrentMonth(*args, **kwargs):
- """DateTime_GetCurrentMonth(wxDateTime::Calendar cal=Gregorian) -> wxDateTime::Month"""
+ """DateTime_GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
def DateTime_IsLeapYear(*args, **kwargs):
- """DateTime_IsLeapYear(int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> bool"""
+ """DateTime_IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
return _misc.DateTime_IsLeapYear(*args, **kwargs)
def DateTime_GetCentury(*args, **kwargs):
return _misc.DateTime_GetCentury(*args, **kwargs)
def DateTime_GetNumberOfDaysinYear(*args, **kwargs):
- """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime_GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
def DateTime_GetNumberOfDaysInMonth(*args, **kwargs):
- """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """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(wxDateTime::Month month, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime_GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
def DateTime_GetWeekDayName(*args, **kwargs):
- """DateTime_GetWeekDayName(wxDateTime::WeekDay weekday, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime_GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
def DateTime_GetAmPmStrings(*args, **kwargs):
- """GetAmPmStrings() -> (am, pm)
+ """
+ GetAmPmStrings() -> (am, pm)
-Get the AM and PM strings in the current locale (may be empty)"""
+ 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, wxDateTime::Country country=Country_Default) -> bool"""
+ """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, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """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, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """DateTime_GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetEndDST(*args, **kwargs)
def DateTime_Now(*args, **kwargs):
return val
def DateTimeFromDMY(*args, **kwargs):
- """DateTimeFromDMY(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year,
- int hour=0, int minute=0, int second=0,
- int millisec=0) -> DateTime"""
+ """
+ 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"""
+ """Seconds(long sec) -> TimeSpan"""
return _misc.TimeSpan_Seconds(*args, **kwargs)
Seconds = staticmethod(Seconds)
def Second(*args, **kwargs):
- """TimeSpan.Second() -> TimeSpan"""
+ """Second() -> TimeSpan"""
return _misc.TimeSpan_Second(*args, **kwargs)
Second = staticmethod(Second)
def Minutes(*args, **kwargs):
- """TimeSpan.Minutes(long min) -> TimeSpan"""
+ """Minutes(long min) -> TimeSpan"""
return _misc.TimeSpan_Minutes(*args, **kwargs)
Minutes = staticmethod(Minutes)
def Minute(*args, **kwargs):
- """TimeSpan.Minute() -> TimeSpan"""
+ """Minute() -> TimeSpan"""
return _misc.TimeSpan_Minute(*args, **kwargs)
Minute = staticmethod(Minute)
def Hours(*args, **kwargs):
- """TimeSpan.Hours(long hours) -> TimeSpan"""
+ """Hours(long hours) -> TimeSpan"""
return _misc.TimeSpan_Hours(*args, **kwargs)
Hours = staticmethod(Hours)
def Hour(*args, **kwargs):
- """TimeSpan.Hour() -> TimeSpan"""
+ """Hour() -> TimeSpan"""
return _misc.TimeSpan_Hour(*args, **kwargs)
Hour = staticmethod(Hour)
def Days(*args, **kwargs):
- """TimeSpan.Days(long days) -> TimeSpan"""
+ """Days(long days) -> TimeSpan"""
return _misc.TimeSpan_Days(*args, **kwargs)
Days = staticmethod(Days)
def Day(*args, **kwargs):
- """TimeSpan.Day() -> TimeSpan"""
+ """Day() -> TimeSpan"""
return _misc.TimeSpan_Day(*args, **kwargs)
Day = staticmethod(Day)
def Weeks(*args, **kwargs):
- """TimeSpan.Weeks(long days) -> TimeSpan"""
+ """Weeks(long days) -> TimeSpan"""
return _misc.TimeSpan_Weeks(*args, **kwargs)
Weeks = staticmethod(Weeks)
def Week(*args, **kwargs):
- """TimeSpan.Week() -> TimeSpan"""
+ """Week() -> TimeSpan"""
return _misc.TimeSpan_Week(*args, **kwargs)
Week = staticmethod(Week)
return _misc.TimeSpan_GetMilliseconds(*args, **kwargs)
def Format(*args, **kwargs):
- """Format(wxString format=wxPyTimeSpanFormatStr) -> wxString"""
+ """Format(String format=TimeSpanFormatStr) -> String"""
return _misc.TimeSpan_Format(*args, **kwargs)
def __repr__(self):
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):
except: pass
def Days(*args, **kwargs):
- """DateSpan.Days(int days) -> DateSpan"""
+ """Days(int days) -> DateSpan"""
return _misc.DateSpan_Days(*args, **kwargs)
Days = staticmethod(Days)
def Day(*args, **kwargs):
- """DateSpan.Day() -> DateSpan"""
+ """Day() -> DateSpan"""
return _misc.DateSpan_Day(*args, **kwargs)
Day = staticmethod(Day)
def Weeks(*args, **kwargs):
- """DateSpan.Weeks(int weeks) -> DateSpan"""
+ """Weeks(int weeks) -> DateSpan"""
return _misc.DateSpan_Weeks(*args, **kwargs)
Weeks = staticmethod(Weeks)
def Week(*args, **kwargs):
- """DateSpan.Week() -> DateSpan"""
+ """Week() -> DateSpan"""
return _misc.DateSpan_Week(*args, **kwargs)
Week = staticmethod(Week)
def Months(*args, **kwargs):
- """DateSpan.Months(int mon) -> DateSpan"""
+ """Months(int mon) -> DateSpan"""
return _misc.DateSpan_Months(*args, **kwargs)
Months = staticmethod(Months)
def Month(*args, **kwargs):
- """DateSpan.Month() -> DateSpan"""
+ """Month() -> DateSpan"""
return _misc.DateSpan_Month(*args, **kwargs)
Month = staticmethod(Month)
def Years(*args, **kwargs):
- """DateSpan.Years(int years) -> DateSpan"""
+ """Years(int years) -> DateSpan"""
return _misc.DateSpan_Years(*args, **kwargs)
Years = staticmethod(Years)
def Year(*args, **kwargs):
- """DateSpan.Year() -> DateSpan"""
+ """Year() -> DateSpan"""
return _misc.DateSpan_Year(*args, **kwargs)
Year = staticmethod(Year)
DF_HTML = _misc.DF_HTML
DF_MAX = _misc.DF_MAX
class DataFormat(object):
- """"""
+ """
+ A wx.DataFormat is an encapsulation of a platform-specific format
+ handle which is used by the system for the clipboard and drag and
+ drop operations. The applications are usually only interested in,
+ for example, pasting data from the clipboard only if the data is
+ in a format the program understands. A data format is is used to
+ uniquely identify this format.
+
+ On the system level, a data format is usually just a number
+ (CLIPFORMAT under Windows or Atom under X11, for example).
+ """
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__(wxDataFormatId type) -> DataFormat"""
+ """
+ __init__(int type) -> DataFormat
+
+ Constructs a data format object for one of the standard data
+ formats or an empty data object (use SetType or SetId later in
+ this case)
+ """
newobj = _misc.new_DataFormat(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def __eq__(*args):
- """__eq__(wxDataFormatId format) -> bool
-__eq__(DataFormat format) -> bool"""
+ """
+ __eq__(int format) -> bool
+ __eq__(DataFormat format) -> bool
+ """
return _misc.DataFormat___eq__(*args)
def __ne__(*args):
- """__ne__(wxDataFormatId format) -> bool
-__ne__(DataFormat format) -> bool"""
+ """
+ __ne__(int format) -> bool
+ __ne__(DataFormat format) -> bool
+ """
return _misc.DataFormat___ne__(*args)
def SetType(*args, **kwargs):
- """SetType(wxDataFormatId format)"""
+ """
+ SetType(int format)
+
+ Sets the format to the given value, which should be one of wx.DF_XXX constants.
+ """
return _misc.DataFormat_SetType(*args, **kwargs)
def GetType(*args, **kwargs):
- """GetType() -> wxDataFormatId"""
+ """
+ GetType() -> int
+
+ Returns the platform-specific number identifying the format.
+ """
return _misc.DataFormat_GetType(*args, **kwargs)
def GetId(*args, **kwargs):
- """GetId() -> wxString"""
+ """
+ GetId() -> String
+
+ Returns the name of a custom format (this function will fail for a standard format).
+ """
return _misc.DataFormat_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
- """SetId(wxString format)"""
+ """
+ SetId(String format)
+
+ Sets the format to be the custom format identified by the given name.
+ """
return _misc.DataFormat_SetId(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DataFormat
_misc.DataFormat_swigregister(DataFormatPtr)
+DefaultDateTime = cvar.DefaultDateTime
def CustomDataFormat(*args, **kwargs):
- """CustomDataFormat(wxString format) -> DataFormat"""
+ """
+ CustomDataFormat(String format) -> DataFormat
+
+ Constructs a data format object for a custom format identified by its name.
+ """
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,)
except: pass
def GetPreferredFormat(*args, **kwargs):
- """GetPreferredFormat(wxDataObject::Direction dir=Get) -> DataFormat"""
+ """GetPreferredFormat(int dir=Get) -> DataFormat"""
return _misc.DataObject_GetPreferredFormat(*args, **kwargs)
def GetFormatCount(*args, **kwargs):
- """GetFormatCount(wxDataObject::Direction dir=Get) -> size_t"""
+ """GetFormatCount(int dir=Get) -> size_t"""
return _misc.DataObject_GetFormatCount(*args, **kwargs)
def IsSupported(*args, **kwargs):
- """IsSupported(DataFormat format, wxDataObject::Direction dir=Get) -> bool"""
+ """IsSupported(DataFormat format, int dir=Get) -> bool"""
return _misc.DataObject_IsSupported(*args, **kwargs)
def GetDataSize(*args, **kwargs):
return _misc.DataObject_GetDataSize(*args, **kwargs)
def GetAllFormats(*args, **kwargs):
- """GetAllFormats(DataFormat formats, wxDataObject::Direction dir=Get)"""
+ """GetAllFormats(DataFormat formats, int dir=Get)"""
return _misc.DataObject_GetAllFormats(*args, **kwargs)
def GetDataHere(*args, **kwargs):
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):
_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):
_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):
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
+ return _misc.DataObjectComposite_Add(*args, **kwargs)
class DataObjectCompositePtr(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__(wxString text=wxPyEmptyString) -> TextDataObject"""
+ """__init__(String text=EmptyString) -> TextDataObject"""
newobj = _misc.new_TextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.TextDataObject_GetTextLength(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _misc.TextDataObject_GetText(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _misc.TextDataObject_SetText(*args, **kwargs)
_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__(wxString text=wxPyEmptyString) -> PyTextDataObject"""
+ """__init__(String text=EmptyString) -> PyTextDataObject"""
newobj = _misc.new_PyTextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_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__(wxBitmap bitmap=wxNullBitmap) -> BitmapDataObject"""
+ """__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() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _misc.BitmapDataObject_GetBitmap(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _misc.BitmapDataObject_SetBitmap(*args, **kwargs)
_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__(wxBitmap bitmap=wxNullBitmap) -> PyBitmapDataObject"""
+ """__init__(Bitmap bitmap=wxNullBitmap) -> PyBitmapDataObject"""
newobj = _misc.new_PyBitmapDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_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):
return _misc.FileDataObject_GetFilenames(*args, **kwargs)
def AddFile(*args, **kwargs):
- """AddFile(wxString filename)"""
+ """AddFile(String filename)"""
return _misc.FileDataObject_AddFile(*args, **kwargs)
_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):
_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):
self.thisown = 1
del newobj.thisown
def GetURL(*args, **kwargs):
- """GetURL() -> wxString"""
+ """GetURL() -> String"""
return _misc.URLDataObject_GetURL(*args, **kwargs)
def SetURL(*args, **kwargs):
- """SetURL(wxString url)"""
+ """SetURL(String url)"""
return _misc.URLDataObject_SetURL(*args, **kwargs)
_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):
DragCancel = _misc.DragCancel
def IsDragResultOk(*args, **kwargs):
- """IsDragResultOk(wxDragResult res) -> bool"""
+ """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, wxCursor copy=wxNullCursor, wxCursor move=wxNullCursor,
- wxCursor none=wxNullCursor) -> DropSource"""
+ """
+ __init__(Window win, Cursor copy=wxNullCursor, Cursor move=wxNullCursor,
+ Cursor none=wxNullCursor) -> DropSource
+ """
newobj = _misc.new_DropSource(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.DropSource_GetDataObject(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxDragResult res, wxCursor cursor)"""
+ """SetCursor(int res, Cursor cursor)"""
return _misc.DropSource_SetCursor(*args, **kwargs)
def DoDragDrop(*args, **kwargs):
- """DoDragDrop(int flags=Drag_CopyOnly) -> wxDragResult"""
+ """DoDragDrop(int flags=Drag_CopyOnly) -> int"""
return _misc.DropSource_DoDragDrop(*args, **kwargs)
def base_GiveFeedback(*args, **kwargs):
- """base_GiveFeedback(wxDragResult effect) -> bool"""
+ """base_GiveFeedback(int effect) -> bool"""
return _misc.DropSource_base_GiveFeedback(*args, **kwargs)
_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):
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- if args: args[0].thisown = 0;
self._setCallbackInfo(self, DropTarget)
def _setCallbackInfo(*args, **kwargs):
def SetDataObject(*args, **kwargs):
"""SetDataObject(DataObject dataObject)"""
- val = _misc.DropTarget_SetDataObject(*args, **kwargs)
- args[1].thisown = 0
- return val
+ return _misc.DropTarget_SetDataObject(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """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, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.DropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
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):
return _misc.TextDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """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, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
return _misc.TextDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
- """base_OnData(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnData(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnData(*args, **kwargs)
_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):
return _misc.FileDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """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, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
return _misc.FileDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
- """base_OnData(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnData(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnData(*args, **kwargs)
#---------------------------------------------------------------------------
class Clipboard(core.Object):
- """"""
+ """
+ wx.Clipboard represents the system clipboard and provides methods to copy data
+ to or paste data from it. Normally, you should only use wx.TheClipboard which
+ is a reference to a global wx.Clipboard instance.
+
+ Call wx.TheClipboard.Open to get ownership of the clipboard. If this operation
+ returns True, you now own the clipboard. Call wx.TheClipboard.SetData to put
+ data on the clipboard, or wx.TheClipboard.GetData to retrieve data from the
+ clipboard. Call wx.TheClipboard.Close to close the clipboard and relinquish
+ ownership. You should keep the clipboard open only momentarily.
+
+ """
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):
except: pass
def Open(*args, **kwargs):
- """Open() -> bool"""
+ """
+ Open() -> bool
+
+ Call this function to open the clipboard before calling SetData
+ and GetData. Call Close when you have finished with the clipboard.
+ You should keep the clipboard open for only a very short time.
+ Returns true on success.
+ """
return _misc.Clipboard_Open(*args, **kwargs)
def Close(*args, **kwargs):
- """Close()"""
+ """
+ Close()
+
+ Closes the clipboard.
+ """
return _misc.Clipboard_Close(*args, **kwargs)
def IsOpened(*args, **kwargs):
- """IsOpened() -> bool"""
+ """
+ IsOpened() -> bool
+
+ Query whether the clipboard is opened
+ """
return _misc.Clipboard_IsOpened(*args, **kwargs)
def AddData(*args, **kwargs):
- """AddData(DataObject data) -> bool"""
+ """
+ AddData(DataObject data) -> bool
+
+ Call this function to add the data object to the clipboard. You
+ may call this function repeatedly after having cleared the clipboard.
+ After this function has been called, the clipboard owns the data, so
+ do not delete the data explicitly.
+ """
return _misc.Clipboard_AddData(*args, **kwargs)
def SetData(*args, **kwargs):
- """SetData(DataObject data) -> bool"""
+ """
+ SetData(DataObject data) -> bool
+
+ Set the clipboard data, this is the same as Clear followed by AddData.
+ """
return _misc.Clipboard_SetData(*args, **kwargs)
def IsSupported(*args, **kwargs):
- """IsSupported(DataFormat format) -> bool"""
+ """
+ IsSupported(DataFormat format) -> bool
+
+ Returns True if the given format is available in the data object(s) on
+ the clipboard.
+ """
return _misc.Clipboard_IsSupported(*args, **kwargs)
def GetData(*args, **kwargs):
- """GetData(DataObject data) -> bool"""
+ """
+ GetData(DataObject data) -> bool
+
+ Call this function to fill data with data on the clipboard, if available
+ in the required format. Returns true on success.
+ """
return _misc.Clipboard_GetData(*args, **kwargs)
def Clear(*args, **kwargs):
- """Clear()"""
+ """
+ Clear()
+
+ Clears data from the clipboard object and also the system's clipboard
+ if possible.
+ """
return _misc.Clipboard_Clear(*args, **kwargs)
def Flush(*args, **kwargs):
- """Flush() -> bool"""
+ """
+ Flush() -> bool
+
+ Flushes the clipboard: this means that the data which is currently on
+ clipboard will stay available even after the application exits (possibly
+ eating memory), otherwise the clipboard will be emptied on exit.
+ Returns False if the operation is unsuccesful for any reason.
+ """
return _misc.Clipboard_Flush(*args, **kwargs)
def UsePrimarySelection(*args, **kwargs):
- """UsePrimarySelection(bool primary=False)"""
+ """
+ UsePrimarySelection(bool primary=True)
+
+ On platforms supporting it (the X11 based platforms), selects the so
+ called PRIMARY SELECTION as the clipboard as opposed to the normal
+ clipboard, if primary is True.
+ """
return _misc.Clipboard_UsePrimarySelection(*args, **kwargs)
_misc.Clipboard_swigregister(ClipboardPtr)
class ClipboardLocker(object):
- """"""
+ """
+ A helpful class for opening the clipboard and automatically closing it when
+ the locker is destroyed.
+ """
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"""
+ """
+ __init__(Clipboard clipboard=None) -> ClipboardLocker
+
+ A helpful class for opening the clipboard and automatically closing it when
+ the locker is destroyed.
+ """
newobj = _misc.new_ClipboardLocker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def __nonzero__(*args, **kwargs):
- """__nonzero__() -> bool"""
+ """
+ __nonzero__() -> bool
+
+ A ClipboardLocker instance evaluates to True if the clipboard was
+ successfully opened.
+ """
return _misc.ClipboardLocker___nonzero__(*args, **kwargs)
_misc.ClipboardLocker_swigregister(ClipboardLockerPtr)
TheClipboard = cvar.TheClipboard
+#---------------------------------------------------------------------------
+
+class VideoMode(object):
+ """A simple struct containing video mode parameters for a display"""
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxVideoMode instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(int width=0, int height=0, int depth=0, int freq=0) -> VideoMode
+
+ A simple struct containing video mode parameters for a display
+ """
+ newobj = _misc.new_VideoMode(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_misc.delete_VideoMode):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def Matches(*args, **kwargs):
+ """
+ Matches(VideoMode other) -> bool
+
+ Returns true if this mode matches the other one in the sense that
+ all non zero fields of the other mode have the same value in this
+ one (except for refresh which is allowed to have a greater value)
+ """
+ return _misc.VideoMode_Matches(*args, **kwargs)
+
+ def GetWidth(*args, **kwargs):
+ """
+ GetWidth() -> int
+
+ Returns the screen width in pixels (e.g. 640*480), 0 means
+ unspecified
+ """
+ return _misc.VideoMode_GetWidth(*args, **kwargs)
+
+ def GetHeight(*args, **kwargs):
+ """
+ GetHeight() -> int
+
+ Returns the screen width in pixels (e.g. 640*480), 0 means
+ unspecified
+ """
+ return _misc.VideoMode_GetHeight(*args, **kwargs)
+
+ def GetDepth(*args, **kwargs):
+ """
+ GetDepth() -> int
+
+ Returns the screen's bits per pixel (e.g. 32), 1 is monochrome
+ and 0 means unspecified/known
+ """
+ return _misc.VideoMode_GetDepth(*args, **kwargs)
+
+ def IsOk(*args, **kwargs):
+ """
+ IsOk() -> bool
+
+ returns true if the object has been initialized
+ """
+ return _misc.VideoMode_IsOk(*args, **kwargs)
+
+ def __nonzero__(self): return self.IsOk()
+ def __eq__(*args, **kwargs):
+ """__eq__(VideoMode other) -> bool"""
+ return _misc.VideoMode___eq__(*args, **kwargs)
+
+ def __ne__(*args, **kwargs):
+ """__ne__(VideoMode other) -> bool"""
+ return _misc.VideoMode___ne__(*args, **kwargs)
+
+ w = property(_misc.VideoMode_w_get, _misc.VideoMode_w_set)
+ h = property(_misc.VideoMode_h_get, _misc.VideoMode_h_set)
+ bpp = property(_misc.VideoMode_bpp_get, _misc.VideoMode_bpp_set)
+ refresh = property(_misc.VideoMode_refresh_get, _misc.VideoMode_refresh_set)
+
+class VideoModePtr(VideoMode):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = VideoMode
+_misc.VideoMode_swigregister(VideoModePtr)
+
+class Display(object):
+ """Represents a display/monitor attached to the system"""
+ def __repr__(self):
+ return "<%s.%s; proxy of C++ wxDisplay instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(size_t index=0) -> Display
+
+ Set up a Display instance with the specified display. The
+ displays are numbered from 0 to GetCount() - 1, 0 is always the
+ primary display and the only one which is always supported
+ """
+ newobj = _misc.new_Display(*args, **kwargs)
+ self.this = newobj.this
+ self.thisown = 1
+ del newobj.thisown
+ def __del__(self, destroy=_misc.delete_Display):
+ """__del__()"""
+ try:
+ if self.thisown: destroy(self)
+ except: pass
+
+ def GetCount(*args, **kwargs):
+ """
+ GetCount() -> size_t
+
+ Return the number of available displays.
+ """
+ return _misc.Display_GetCount(*args, **kwargs)
+
+ GetCount = staticmethod(GetCount)
+ def GetFromPoint(*args, **kwargs):
+ """
+ GetFromPoint(Point pt) -> int
+
+ Find the display where the given point lies, return wx.NOT_FOUND
+ if it doesn't belong to any display
+ """
+ return _misc.Display_GetFromPoint(*args, **kwargs)
+
+ GetFromPoint = staticmethod(GetFromPoint)
+ def GetFromWindow(*args, **kwargs):
+ """
+ GetFromWindow(Window window) -> int
+
+ Find the display where the given window lies, return wx.NOT_FOUND
+ if it is not shown at all.
+ """
+ return _misc.Display_GetFromWindow(*args, **kwargs)
+
+ GetFromWindow = staticmethod(GetFromWindow)
+ def IsOk(*args, **kwargs):
+ """
+ IsOk() -> bool
+
+ Return true if the object was initialized successfully
+ """
+ return _misc.Display_IsOk(*args, **kwargs)
+
+ def __nonzero__(self): return self.IsOk()
+ def GetGeometry(*args, **kwargs):
+ """
+ GetGeometry() -> Rect
+
+ Returns the bounding rectangle of the display whose index was
+ passed to the constructor.
+ """
+ return _misc.Display_GetGeometry(*args, **kwargs)
+
+ def GetName(*args, **kwargs):
+ """
+ GetName() -> String
+
+ Returns the display's name. A name is not available on all platforms.
+ """
+ return _misc.Display_GetName(*args, **kwargs)
+
+ def IsPrimary(*args, **kwargs):
+ """
+ IsPrimary() -> bool
+
+ Returns true if the display is the primary display. The primary
+ display is the one whose index is 0.
+ """
+ return _misc.Display_IsPrimary(*args, **kwargs)
+
+ def GetModes(*args, **kwargs):
+ """
+ GetModes(VideoMode mode=DefaultVideoMode) -> [videoMode...]
+
+ Enumerate all video modes supported by this display matching the
+ given one (in the sense of VideoMode.Match()).
+
+ As any mode matches the default value of the argument and there
+ is always at least one video mode supported by display, the
+ returned array is only empty for the default value of the
+ argument if this function is not supported at all on this
+ platform.
+ """
+ return _misc.Display_GetModes(*args, **kwargs)
+
+ def GetCurrentMode(*args, **kwargs):
+ """
+ GetCurrentMode() -> VideoMode
+
+ Get the current video mode.
+ """
+ return _misc.Display_GetCurrentMode(*args, **kwargs)
+
+ def ChangeMode(*args, **kwargs):
+ """
+ ChangeMode(VideoMode mode=DefaultVideoMode) -> bool
+
+ Change current mode, return true if succeeded, false otherwise
+ """
+ return _misc.Display_ChangeMode(*args, **kwargs)
+
+ def ResetMode(*args, **kwargs):
+ """
+ ResetMode()
+
+ Restore the default video mode (just a more readable synonym)
+ """
+ return _misc.Display_ResetMode(*args, **kwargs)
+
+
+class DisplayPtr(Display):
+ def __init__(self, this):
+ self.this = this
+ if not hasattr(self,"thisown"): self.thisown = 0
+ self.__class__ = Display
+_misc.Display_swigregister(DisplayPtr)
+DefaultVideoMode = cvar.DefaultVideoMode
+
+def Display_GetCount(*args, **kwargs):
+ """
+ Display_GetCount() -> size_t
+
+ Return the number of available displays.
+ """
+ return _misc.Display_GetCount(*args, **kwargs)
+
+def Display_GetFromPoint(*args, **kwargs):
+ """
+ Display_GetFromPoint(Point pt) -> int
+
+ Find the display where the given point lies, return wx.NOT_FOUND
+ if it doesn't belong to any display
+ """
+ return _misc.Display_GetFromPoint(*args, **kwargs)
+
+def Display_GetFromWindow(*args, **kwargs):
+ """
+ Display_GetFromWindow(Window window) -> int
+
+ Find the display where the given window lies, return wx.NOT_FOUND
+ if it is not shown at all.
+ """
+ return _misc.Display_GetFromWindow(*args, **kwargs)
+
projects / wxWidgets.git / blobdiff