reSWIGged

[wxWidgets.git] / wxPython / src / msw / misc.py

# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.

import _misc

import core
wx = core 
#---------------------------------------------------------------------------

SYS_OEM_FIXED_FONT = _misc.SYS_OEM_FIXED_FONT
SYS_ANSI_FIXED_FONT = _misc.SYS_ANSI_FIXED_FONT
SYS_ANSI_VAR_FONT = _misc.SYS_ANSI_VAR_FONT
SYS_SYSTEM_FONT = _misc.SYS_SYSTEM_FONT
SYS_DEVICE_DEFAULT_FONT = _misc.SYS_DEVICE_DEFAULT_FONT
SYS_DEFAULT_PALETTE = _misc.SYS_DEFAULT_PALETTE
SYS_SYSTEM_FIXED_FONT = _misc.SYS_SYSTEM_FIXED_FONT
SYS_DEFAULT_GUI_FONT = _misc.SYS_DEFAULT_GUI_FONT
SYS_ICONTITLE_FONT = _misc.SYS_ICONTITLE_FONT
SYS_COLOUR_SCROLLBAR = _misc.SYS_COLOUR_SCROLLBAR
SYS_COLOUR_BACKGROUND = _misc.SYS_COLOUR_BACKGROUND
SYS_COLOUR_DESKTOP = _misc.SYS_COLOUR_DESKTOP
SYS_COLOUR_ACTIVECAPTION = _misc.SYS_COLOUR_ACTIVECAPTION
SYS_COLOUR_INACTIVECAPTION = _misc.SYS_COLOUR_INACTIVECAPTION
SYS_COLOUR_MENU = _misc.SYS_COLOUR_MENU
SYS_COLOUR_WINDOW = _misc.SYS_COLOUR_WINDOW
SYS_COLOUR_WINDOWFRAME = _misc.SYS_COLOUR_WINDOWFRAME
SYS_COLOUR_MENUTEXT = _misc.SYS_COLOUR_MENUTEXT
SYS_COLOUR_WINDOWTEXT = _misc.SYS_COLOUR_WINDOWTEXT
SYS_COLOUR_CAPTIONTEXT = _misc.SYS_COLOUR_CAPTIONTEXT
SYS_COLOUR_ACTIVEBORDER = _misc.SYS_COLOUR_ACTIVEBORDER
SYS_COLOUR_INACTIVEBORDER = _misc.SYS_COLOUR_INACTIVEBORDER
SYS_COLOUR_APPWORKSPACE = _misc.SYS_COLOUR_APPWORKSPACE
SYS_COLOUR_HIGHLIGHT = _misc.SYS_COLOUR_HIGHLIGHT
SYS_COLOUR_HIGHLIGHTTEXT = _misc.SYS_COLOUR_HIGHLIGHTTEXT
SYS_COLOUR_BTNFACE = _misc.SYS_COLOUR_BTNFACE
SYS_COLOUR_3DFACE = _misc.SYS_COLOUR_3DFACE
SYS_COLOUR_BTNSHADOW = _misc.SYS_COLOUR_BTNSHADOW
SYS_COLOUR_3DSHADOW = _misc.SYS_COLOUR_3DSHADOW
SYS_COLOUR_GRAYTEXT = _misc.SYS_COLOUR_GRAYTEXT
SYS_COLOUR_BTNTEXT = _misc.SYS_COLOUR_BTNTEXT
SYS_COLOUR_INACTIVECAPTIONTEXT = _misc.SYS_COLOUR_INACTIVECAPTIONTEXT
SYS_COLOUR_BTNHIGHLIGHT = _misc.SYS_COLOUR_BTNHIGHLIGHT
SYS_COLOUR_BTNHILIGHT = _misc.SYS_COLOUR_BTNHILIGHT
SYS_COLOUR_3DHIGHLIGHT = _misc.SYS_COLOUR_3DHIGHLIGHT
SYS_COLOUR_3DHILIGHT = _misc.SYS_COLOUR_3DHILIGHT
SYS_COLOUR_3DDKSHADOW = _misc.SYS_COLOUR_3DDKSHADOW
SYS_COLOUR_3DLIGHT = _misc.SYS_COLOUR_3DLIGHT
SYS_COLOUR_INFOTEXT = _misc.SYS_COLOUR_INFOTEXT
SYS_COLOUR_INFOBK = _misc.SYS_COLOUR_INFOBK
SYS_COLOUR_LISTBOX = _misc.SYS_COLOUR_LISTBOX
SYS_COLOUR_HOTLIGHT = _misc.SYS_COLOUR_HOTLIGHT
SYS_COLOUR_GRADIENTACTIVECAPTION = _misc.SYS_COLOUR_GRADIENTACTIVECAPTION
SYS_COLOUR_GRADIENTINACTIVECAPTION = _misc.SYS_COLOUR_GRADIENTINACTIVECAPTION
SYS_COLOUR_MENUHILIGHT = _misc.SYS_COLOUR_MENUHILIGHT
SYS_COLOUR_MENUBAR = _misc.SYS_COLOUR_MENUBAR
SYS_COLOUR_MAX = _misc.SYS_COLOUR_MAX
SYS_MOUSE_BUTTONS = _misc.SYS_MOUSE_BUTTONS
SYS_BORDER_X = _misc.SYS_BORDER_X
SYS_BORDER_Y = _misc.SYS_BORDER_Y
SYS_CURSOR_X = _misc.SYS_CURSOR_X
SYS_CURSOR_Y = _misc.SYS_CURSOR_Y
SYS_DCLICK_X = _misc.SYS_DCLICK_X
SYS_DCLICK_Y = _misc.SYS_DCLICK_Y
SYS_DRAG_X = _misc.SYS_DRAG_X
SYS_DRAG_Y = _misc.SYS_DRAG_Y
SYS_EDGE_X = _misc.SYS_EDGE_X
SYS_EDGE_Y = _misc.SYS_EDGE_Y
SYS_HSCROLL_ARROW_X = _misc.SYS_HSCROLL_ARROW_X
SYS_HSCROLL_ARROW_Y = _misc.SYS_HSCROLL_ARROW_Y
SYS_HTHUMB_X = _misc.SYS_HTHUMB_X
SYS_ICON_X = _misc.SYS_ICON_X
SYS_ICON_Y = _misc.SYS_ICON_Y
SYS_ICONSPACING_X = _misc.SYS_ICONSPACING_X
SYS_ICONSPACING_Y = _misc.SYS_ICONSPACING_Y
SYS_WINDOWMIN_X = _misc.SYS_WINDOWMIN_X
SYS_WINDOWMIN_Y = _misc.SYS_WINDOWMIN_Y
SYS_SCREEN_X = _misc.SYS_SCREEN_X
SYS_SCREEN_Y = _misc.SYS_SCREEN_Y
SYS_FRAMESIZE_X = _misc.SYS_FRAMESIZE_X
SYS_FRAMESIZE_Y = _misc.SYS_FRAMESIZE_Y
SYS_SMALLICON_X = _misc.SYS_SMALLICON_X
SYS_SMALLICON_Y = _misc.SYS_SMALLICON_Y
SYS_HSCROLL_Y = _misc.SYS_HSCROLL_Y
SYS_VSCROLL_X = _misc.SYS_VSCROLL_X
SYS_VSCROLL_ARROW_X = _misc.SYS_VSCROLL_ARROW_X
SYS_VSCROLL_ARROW_Y = _misc.SYS_VSCROLL_ARROW_Y
SYS_VTHUMB_Y = _misc.SYS_VTHUMB_Y
SYS_CAPTION_Y = _misc.SYS_CAPTION_Y
SYS_MENU_Y = _misc.SYS_MENU_Y
SYS_NETWORK_PRESENT = _misc.SYS_NETWORK_PRESENT
SYS_PENWINDOWS_PRESENT = _misc.SYS_PENWINDOWS_PRESENT
SYS_SHOW_SOUNDS = _misc.SYS_SHOW_SOUNDS
SYS_SWAP_BUTTONS = _misc.SYS_SWAP_BUTTONS
SYS_CAN_DRAW_FRAME_DECORATIONS = _misc.SYS_CAN_DRAW_FRAME_DECORATIONS
SYS_CAN_ICONIZE_FRAME = _misc.SYS_CAN_ICONIZE_FRAME
SYS_SCREEN_NONE = _misc.SYS_SCREEN_NONE
SYS_SCREEN_TINY = _misc.SYS_SCREEN_TINY
SYS_SCREEN_PDA = _misc.SYS_SCREEN_PDA
SYS_SCREEN_SMALL = _misc.SYS_SCREEN_SMALL
SYS_SCREEN_DESKTOP = _misc.SYS_SCREEN_DESKTOP
class SystemSettings(object):
    GetColour = staticmethod(_misc.SystemSettings_GetColour)
    GetFont = staticmethod(_misc.SystemSettings_GetFont)
    GetMetric = staticmethod(_misc.SystemSettings_GetMetric)
    HasFeature = staticmethod(_misc.SystemSettings_HasFeature)
    GetScreenType = staticmethod(_misc.SystemSettings_GetScreenType)
    SetScreenType = staticmethod(_misc.SystemSettings_SetScreenType)
    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,)

class SystemSettingsPtr(SystemSettings):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = SystemSettings
_misc.SystemSettings_swigregister(SystemSettingsPtr)

SystemSettings_GetColour = _misc.SystemSettings_GetColour

SystemSettings_GetFont = _misc.SystemSettings_GetFont

SystemSettings_GetMetric = _misc.SystemSettings_GetMetric

SystemSettings_HasFeature = _misc.SystemSettings_HasFeature

SystemSettings_GetScreenType = _misc.SystemSettings_GetScreenType

SystemSettings_SetScreenType = _misc.SystemSettings_SetScreenType

class SystemOptions(core.Object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_SystemOptions(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    SetOption = staticmethod(_misc.SystemOptions_SetOption)
    SetOptionInt = staticmethod(_misc.SystemOptions_SetOptionInt)
    GetOption = staticmethod(_misc.SystemOptions_GetOption)
    GetOptionInt = staticmethod(_misc.SystemOptions_GetOptionInt)
    HasOption = staticmethod(_misc.SystemOptions_HasOption)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxSystemOptions instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class SystemOptionsPtr(SystemOptions):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = SystemOptions
_misc.SystemOptions_swigregister(SystemOptionsPtr)

SystemOptions_SetOption = _misc.SystemOptions_SetOption

SystemOptions_SetOptionInt = _misc.SystemOptions_SetOptionInt

SystemOptions_GetOption = _misc.SystemOptions_GetOption

SystemOptions_GetOptionInt = _misc.SystemOptions_GetOptionInt

SystemOptions_HasOption = _misc.SystemOptions_HasOption

#---------------------------------------------------------------------------


NewId = _misc.NewId

RegisterId = _misc.RegisterId

GetCurrentId = _misc.GetCurrentId

Bell = _misc.Bell

EndBusyCursor = _misc.EndBusyCursor

GetElapsedTime = _misc.GetElapsedTime

GetMousePosition = _misc.GetMousePosition

IsBusy = _misc.IsBusy

Now = _misc.Now

Shell = _misc.Shell

StartTimer = _misc.StartTimer

GetOsVersion = _misc.GetOsVersion

GetOsDescription = _misc.GetOsDescription

GetFreeMemory = _misc.GetFreeMemory
SHUTDOWN_POWEROFF = _misc.SHUTDOWN_POWEROFF
SHUTDOWN_REBOOT = _misc.SHUTDOWN_REBOOT

Shutdown = _misc.Shutdown

Sleep = _misc.Sleep

Usleep = _misc.Usleep

EnableTopLevelWindows = _misc.EnableTopLevelWindows

StripMenuCodes = _misc.StripMenuCodes

GetEmailAddress = _misc.GetEmailAddress

GetHostName = _misc.GetHostName

GetFullHostName = _misc.GetFullHostName

GetUserId = _misc.GetUserId

GetUserName = _misc.GetUserName

GetHomeDir = _misc.GetHomeDir

GetUserHome = _misc.GetUserHome

GetProcessId = _misc.GetProcessId

Trap = _misc.Trap

FileSelector = _misc.FileSelector

LoadFileSelector = _misc.LoadFileSelector

SaveFileSelector = _misc.SaveFileSelector

DirSelector = _misc.DirSelector

GetTextFromUser = _misc.GetTextFromUser

GetPasswordFromUser = _misc.GetPasswordFromUser

GetSingleChoice = _misc.GetSingleChoice

GetSingleChoiceIndex = _misc.GetSingleChoiceIndex

MessageBox = _misc.MessageBox

GetNumberFromUser = _misc.GetNumberFromUser

ColourDisplay = _misc.ColourDisplay

DisplayDepth = _misc.DisplayDepth

GetDisplayDepth = _misc.GetDisplayDepth

DisplaySize = _misc.DisplaySize

GetDisplaySize = _misc.GetDisplaySize

DisplaySizeMM = _misc.DisplaySizeMM

GetDisplaySizeMM = _misc.GetDisplaySizeMM

ClientDisplayRect = _misc.ClientDisplayRect

GetClientDisplayRect = _misc.GetClientDisplayRect

SetCursor = _misc.SetCursor

BeginBusyCursor = _misc.BeginBusyCursor

GetActiveWindow = _misc.GetActiveWindow

GenericFindWindowAtPoint = _misc.GenericFindWindowAtPoint

FindWindowAtPoint = _misc.FindWindowAtPoint

GetTopLevelParent = _misc.GetTopLevelParent

WakeUpMainThread = _misc.WakeUpMainThread

MutexGuiEnter = _misc.MutexGuiEnter

MutexGuiLeave = _misc.MutexGuiLeave
class MutexGuiLocker(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_MutexGuiLocker(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_MutexGuiLocker):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxMutexGuiLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class MutexGuiLockerPtr(MutexGuiLocker):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = MutexGuiLocker
_misc.MutexGuiLocker_swigregister(MutexGuiLockerPtr)


Thread_IsMain = _misc.Thread_IsMain
#---------------------------------------------------------------------------

class ToolTip(core.Object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_ToolTip(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def SetTip(*args, **kwargs): return _misc.ToolTip_SetTip(*args, **kwargs)
    def GetTip(*args, **kwargs): return _misc.ToolTip_GetTip(*args, **kwargs)
    def GetWindow(*args, **kwargs): return _misc.ToolTip_GetWindow(*args, **kwargs)
    Enable = staticmethod(_misc.ToolTip_Enable)
    SetDelay = staticmethod(_misc.ToolTip_SetDelay)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxToolTip instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ToolTipPtr(ToolTip):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ToolTip
_misc.ToolTip_swigregister(ToolTipPtr)

ToolTip_Enable = _misc.ToolTip_Enable

ToolTip_SetDelay = _misc.ToolTip_SetDelay

class Caret(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Caret(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Caret):
        try:
            if self.thisown: destroy(self)
        except: pass
    def IsOk(*args, **kwargs): return _misc.Caret_IsOk(*args, **kwargs)
    def IsVisible(*args, **kwargs): return _misc.Caret_IsVisible(*args, **kwargs)
    def GetPositionTuple(*args, **kwargs): return _misc.Caret_GetPositionTuple(*args, **kwargs)
    def GetPosition(*args, **kwargs): return _misc.Caret_GetPosition(*args, **kwargs)
    def GetSizeTuple(*args, **kwargs): return _misc.Caret_GetSizeTuple(*args, **kwargs)
    def GetSize(*args, **kwargs): return _misc.Caret_GetSize(*args, **kwargs)
    def GetWindow(*args, **kwargs): return _misc.Caret_GetWindow(*args, **kwargs)
    def MoveXY(*args, **kwargs): return _misc.Caret_MoveXY(*args, **kwargs)
    def Move(*args, **kwargs): return _misc.Caret_Move(*args, **kwargs)
    def SetSizeWH(*args, **kwargs): return _misc.Caret_SetSizeWH(*args, **kwargs)
    def SetSize(*args, **kwargs): return _misc.Caret_SetSize(*args, **kwargs)
    def Show(*args, **kwargs): return _misc.Caret_Show(*args, **kwargs)
    def Hide(*args, **kwargs): return _misc.Caret_Hide(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxCaret instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class CaretPtr(Caret):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Caret
_misc.Caret_swigregister(CaretPtr)


Caret_GetBlinkTime = _misc.Caret_GetBlinkTime

Caret_SetBlinkTime = _misc.Caret_SetBlinkTime
class BusyCursor(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_BusyCursor(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_BusyCursor):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxBusyCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class BusyCursorPtr(BusyCursor):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = BusyCursor
_misc.BusyCursor_swigregister(BusyCursorPtr)

class WindowDisabler(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_WindowDisabler(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_WindowDisabler):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxWindowDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class WindowDisablerPtr(WindowDisabler):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WindowDisabler
_misc.WindowDisabler_swigregister(WindowDisablerPtr)

class BusyInfo(core.Object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_BusyInfo(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_BusyInfo):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxBusyInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class BusyInfoPtr(BusyInfo):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = BusyInfo
_misc.BusyInfo_swigregister(BusyInfoPtr)

class StopWatch(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_StopWatch(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def Start(*args, **kwargs): return _misc.StopWatch_Start(*args, **kwargs)
    def Pause(*args, **kwargs): return _misc.StopWatch_Pause(*args, **kwargs)
    def Resume(*args, **kwargs): return _misc.StopWatch_Resume(*args, **kwargs)
    def Time(*args, **kwargs): return _misc.StopWatch_Time(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxStopWatch instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class StopWatchPtr(StopWatch):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = StopWatch
_misc.StopWatch_swigregister(StopWatchPtr)

class FileHistory(core.Object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileHistory(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_FileHistory):
        try:
            if self.thisown: destroy(self)
        except: pass
    def AddFileToHistory(*args, **kwargs): return _misc.FileHistory_AddFileToHistory(*args, **kwargs)
    def RemoveFileFromHistory(*args, **kwargs): return _misc.FileHistory_RemoveFileFromHistory(*args, **kwargs)
    def GetMaxFiles(*args, **kwargs): return _misc.FileHistory_GetMaxFiles(*args, **kwargs)
    def UseMenu(*args, **kwargs): return _misc.FileHistory_UseMenu(*args, **kwargs)
    def RemoveMenu(*args, **kwargs): return _misc.FileHistory_RemoveMenu(*args, **kwargs)
    def Load(*args, **kwargs): return _misc.FileHistory_Load(*args, **kwargs)
    def Save(*args, **kwargs): return _misc.FileHistory_Save(*args, **kwargs)
    def AddFilesToMenu(*args, **kwargs): return _misc.FileHistory_AddFilesToMenu(*args, **kwargs)
    def AddFilesToThisMenu(*args, **kwargs): return _misc.FileHistory_AddFilesToThisMenu(*args, **kwargs)
    def GetHistoryFile(*args, **kwargs): return _misc.FileHistory_GetHistoryFile(*args, **kwargs)
    def GetCount(*args, **kwargs): return _misc.FileHistory_GetCount(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxFileHistory instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileHistoryPtr(FileHistory):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileHistory
_misc.FileHistory_swigregister(FileHistoryPtr)

class SingleInstanceChecker(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_SingleInstanceChecker(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_SingleInstanceChecker):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Create(*args, **kwargs): return _misc.SingleInstanceChecker_Create(*args, **kwargs)
    def IsAnotherRunning(*args, **kwargs): return _misc.SingleInstanceChecker_IsAnotherRunning(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxSingleInstanceChecker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class SingleInstanceCheckerPtr(SingleInstanceChecker):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = SingleInstanceChecker
_misc.SingleInstanceChecker_swigregister(SingleInstanceCheckerPtr)

def PreSingleInstanceChecker(*args, **kwargs):
    val = _misc.new_PreSingleInstanceChecker(*args, **kwargs)
    val.thisown = 1
    return val


DrawWindowOnDC = _misc.DrawWindowOnDC
#---------------------------------------------------------------------------

class TipProvider(object):
    def __del__(self, destroy=_misc.delete_TipProvider):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetTip(*args, **kwargs): return _misc.TipProvider_GetTip(*args, **kwargs)
    def GetCurrentTip(*args, **kwargs): return _misc.TipProvider_GetCurrentTip(*args, **kwargs)
    def PreprocessTip(*args, **kwargs): return _misc.TipProvider_PreprocessTip(*args, **kwargs)
    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,)

class TipProviderPtr(TipProvider):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TipProvider
_misc.TipProvider_swigregister(TipProviderPtr)

class PyTipProvider(TipProvider):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_PyTipProvider(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def _setCallbackInfo(*args, **kwargs): return _misc.PyTipProvider__setCallbackInfo(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyTipProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class PyTipProviderPtr(PyTipProvider):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = PyTipProvider
_misc.PyTipProvider_swigregister(PyTipProviderPtr)


ShowTip = _misc.ShowTip

CreateFileTipProvider = _misc.CreateFileTipProvider
#---------------------------------------------------------------------------

TIMER_CONTINUOUS = _misc.TIMER_CONTINUOUS
TIMER_ONE_SHOT = _misc.TIMER_ONE_SHOT
wxEVT_TIMER = _misc.wxEVT_TIMER
class Timer(core.EvtHandler):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Timer(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Timer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def SetOwner(*args, **kwargs): return _misc.Timer_SetOwner(*args, **kwargs)
    def Start(*args, **kwargs): return _misc.Timer_Start(*args, **kwargs)
    def Stop(*args, **kwargs): return _misc.Timer_Stop(*args, **kwargs)
    def Notify(*args, **kwargs): return _misc.Timer_Notify(*args, **kwargs)
    def IsRunning(*args, **kwargs): return _misc.Timer_IsRunning(*args, **kwargs)
    def GetInterval(*args, **kwargs): return _misc.Timer_GetInterval(*args, **kwargs)
    def IsOneShot(*args, **kwargs): return _misc.Timer_IsOneShot(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyTimer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class TimerPtr(Timer):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Timer
_misc.Timer_swigregister(TimerPtr)

# For backwards compatibility with 2.4
class PyTimer(Timer):
    def __init__(self, notify):
        Timer.__init__(self)
        self.notify = notify

    def Notify(self):
        if self.notify:
            self.notify()


EVT_TIMER = wx.PyEventBinder( wxEVT_TIMER, 1 )
                   

class TimerEvent(core.Event):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_TimerEvent(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetInterval(*args, **kwargs): return _misc.TimerEvent_GetInterval(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxTimerEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class TimerEventPtr(TimerEvent):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TimerEvent
_misc.TimerEvent_swigregister(TimerEventPtr)

class TimerRunner(object):
    def __init__(self, *args):
        newobj = _misc.new_TimerRunner(*args)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_TimerRunner):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Start(*args, **kwargs): return _misc.TimerRunner_Start(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxTimerRunner instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class TimerRunnerPtr(TimerRunner):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TimerRunner
_misc.TimerRunner_swigregister(TimerRunnerPtr)

#---------------------------------------------------------------------------

LOG_FatalError = _misc.LOG_FatalError
LOG_Error = _misc.LOG_Error
LOG_Warning = _misc.LOG_Warning
LOG_Message = _misc.LOG_Message
LOG_Status = _misc.LOG_Status
LOG_Info = _misc.LOG_Info
LOG_Debug = _misc.LOG_Debug
LOG_Trace = _misc.LOG_Trace
LOG_Progress = _misc.LOG_Progress
LOG_User = _misc.LOG_User
LOG_Max = _misc.LOG_Max
TRACE_MemAlloc = _misc.TRACE_MemAlloc
TRACE_Messages = _misc.TRACE_Messages
TRACE_ResAlloc = _misc.TRACE_ResAlloc
TRACE_RefCount = _misc.TRACE_RefCount
TRACE_OleCalls = _misc.TRACE_OleCalls
TraceMemAlloc = _misc.TraceMemAlloc
TraceMessages = _misc.TraceMessages
TraceResAlloc = _misc.TraceResAlloc
TraceRefCount = _misc.TraceRefCount
TraceOleCalls = _misc.TraceOleCalls
class Log(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Log(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    IsEnabled = staticmethod(_misc.Log_IsEnabled)
    EnableLogging = staticmethod(_misc.Log_EnableLogging)
    OnLog = staticmethod(_misc.Log_OnLog)
    def Flush(*args, **kwargs): return _misc.Log_Flush(*args, **kwargs)
    FlushActive = staticmethod(_misc.Log_FlushActive)
    GetActiveTarget = staticmethod(_misc.Log_GetActiveTarget)
    SetActiveTarget = staticmethod(_misc.Log_SetActiveTarget)
    Suspend = staticmethod(_misc.Log_Suspend)
    Resume = staticmethod(_misc.Log_Resume)
    SetVerbose = staticmethod(_misc.Log_SetVerbose)
    SetLogLevel = staticmethod(_misc.Log_SetLogLevel)
    DontCreateOnDemand = staticmethod(_misc.Log_DontCreateOnDemand)
    SetTraceMask = staticmethod(_misc.Log_SetTraceMask)
    AddTraceMask = staticmethod(_misc.Log_AddTraceMask)
    RemoveTraceMask = staticmethod(_misc.Log_RemoveTraceMask)
    ClearTraceMasks = staticmethod(_misc.Log_ClearTraceMasks)
    GetTraceMasks = staticmethod(_misc.Log_GetTraceMasks)
    SetTimestamp = staticmethod(_misc.Log_SetTimestamp)
    GetVerbose = staticmethod(_misc.Log_GetVerbose)
    GetTraceMask = staticmethod(_misc.Log_GetTraceMask)
    IsAllowedTraceMask = staticmethod(_misc.Log_IsAllowedTraceMask)
    GetLogLevel = staticmethod(_misc.Log_GetLogLevel)
    GetTimestamp = staticmethod(_misc.Log_GetTimestamp)
    TimeStamp = staticmethod(_misc.Log_TimeStamp)
    def Destroy(*args, **kwargs): return _misc.Log_Destroy(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogPtr(Log):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Log
_misc.Log_swigregister(LogPtr)

Log_IsEnabled = _misc.Log_IsEnabled

Log_EnableLogging = _misc.Log_EnableLogging

Log_OnLog = _misc.Log_OnLog

Log_FlushActive = _misc.Log_FlushActive

Log_GetActiveTarget = _misc.Log_GetActiveTarget

Log_SetActiveTarget = _misc.Log_SetActiveTarget

Log_Suspend = _misc.Log_Suspend

Log_Resume = _misc.Log_Resume

Log_SetVerbose = _misc.Log_SetVerbose

Log_SetLogLevel = _misc.Log_SetLogLevel

Log_DontCreateOnDemand = _misc.Log_DontCreateOnDemand

Log_SetTraceMask = _misc.Log_SetTraceMask

Log_AddTraceMask = _misc.Log_AddTraceMask

Log_RemoveTraceMask = _misc.Log_RemoveTraceMask

Log_ClearTraceMasks = _misc.Log_ClearTraceMasks

Log_GetTraceMasks = _misc.Log_GetTraceMasks

Log_SetTimestamp = _misc.Log_SetTimestamp

Log_GetVerbose = _misc.Log_GetVerbose

Log_GetTraceMask = _misc.Log_GetTraceMask

Log_IsAllowedTraceMask = _misc.Log_IsAllowedTraceMask

Log_GetLogLevel = _misc.Log_GetLogLevel

Log_GetTimestamp = _misc.Log_GetTimestamp

Log_TimeStamp = _misc.Log_TimeStamp

class LogStderr(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogStderr(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogStderr instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogStderrPtr(LogStderr):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogStderr
_misc.LogStderr_swigregister(LogStderrPtr)

class LogTextCtrl(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogTextCtrl(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogTextCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogTextCtrlPtr(LogTextCtrl):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogTextCtrl
_misc.LogTextCtrl_swigregister(LogTextCtrlPtr)

class LogGui(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogGui(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogGui instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogGuiPtr(LogGui):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogGui
_misc.LogGui_swigregister(LogGuiPtr)

class LogWindow(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogWindow(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def Show(*args, **kwargs): return _misc.LogWindow_Show(*args, **kwargs)
    def GetFrame(*args, **kwargs): return _misc.LogWindow_GetFrame(*args, **kwargs)
    def GetOldLog(*args, **kwargs): return _misc.LogWindow_GetOldLog(*args, **kwargs)
    def IsPassingMessages(*args, **kwargs): return _misc.LogWindow_IsPassingMessages(*args, **kwargs)
    def PassMessages(*args, **kwargs): return _misc.LogWindow_PassMessages(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogWindowPtr(LogWindow):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogWindow
_misc.LogWindow_swigregister(LogWindowPtr)

class LogChain(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogChain(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def SetLog(*args, **kwargs): return _misc.LogChain_SetLog(*args, **kwargs)
    def PassMessages(*args, **kwargs): return _misc.LogChain_PassMessages(*args, **kwargs)
    def IsPassingMessages(*args, **kwargs): return _misc.LogChain_IsPassingMessages(*args, **kwargs)
    def GetOldLog(*args, **kwargs): return _misc.LogChain_GetOldLog(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogChain instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogChainPtr(LogChain):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogChain
_misc.LogChain_swigregister(LogChainPtr)


SysErrorCode = _misc.SysErrorCode

SysErrorMsg = _misc.SysErrorMsg

LogFatalError = _misc.LogFatalError

LogError = _misc.LogError

LogWarning = _misc.LogWarning

LogMessage = _misc.LogMessage

LogInfo = _misc.LogInfo

LogDebug = _misc.LogDebug

LogVerbose = _misc.LogVerbose

LogStatus = _misc.LogStatus

LogStatusFrame = _misc.LogStatusFrame

LogSysError = _misc.LogSysError

LogTrace = _misc.LogTrace

LogTraceMask = _misc.LogTraceMask

LogGeneric = _misc.LogGeneric

SafeShowMessage = _misc.SafeShowMessage
class LogNull(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_LogNull(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_LogNull):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxLogNull instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class LogNullPtr(LogNull):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = LogNull
_misc.LogNull_swigregister(LogNullPtr)

class PyLog(Log):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_PyLog(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, PyLog)
    def _setCallbackInfo(*args, **kwargs): return _misc.PyLog__setCallbackInfo(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyLog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class PyLogPtr(PyLog):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = PyLog
_misc.PyLog_swigregister(PyLogPtr)

#---------------------------------------------------------------------------

PROCESS_DEFAULT = _misc.PROCESS_DEFAULT
PROCESS_REDIRECT = _misc.PROCESS_REDIRECT
KILL_OK = _misc.KILL_OK
KILL_BAD_SIGNAL = _misc.KILL_BAD_SIGNAL
KILL_ACCESS_DENIED = _misc.KILL_ACCESS_DENIED
KILL_NO_PROCESS = _misc.KILL_NO_PROCESS
KILL_ERROR = _misc.KILL_ERROR
SIGNONE = _misc.SIGNONE
SIGHUP = _misc.SIGHUP
SIGINT = _misc.SIGINT
SIGQUIT = _misc.SIGQUIT
SIGILL = _misc.SIGILL
SIGTRAP = _misc.SIGTRAP
SIGABRT = _misc.SIGABRT
SIGIOT = _misc.SIGIOT
SIGEMT = _misc.SIGEMT
SIGFPE = _misc.SIGFPE
SIGKILL = _misc.SIGKILL
SIGBUS = _misc.SIGBUS
SIGSEGV = _misc.SIGSEGV
SIGSYS = _misc.SIGSYS
SIGPIPE = _misc.SIGPIPE
SIGALRM = _misc.SIGALRM
SIGTERM = _misc.SIGTERM
class Process(core.EvtHandler):
    Kill = staticmethod(_misc.Process_Kill)
    Exists = staticmethod(_misc.Process_Exists)
    Open = staticmethod(_misc.Process_Open)
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Process(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, Process)
    def _setCallbackInfo(*args, **kwargs): return _misc.Process__setCallbackInfo(*args, **kwargs)
    def base_OnTerminate(*args, **kwargs): return _misc.Process_base_OnTerminate(*args, **kwargs)
    def Redirect(*args, **kwargs): return _misc.Process_Redirect(*args, **kwargs)
    def IsRedirected(*args, **kwargs): return _misc.Process_IsRedirected(*args, **kwargs)
    def Detach(*args, **kwargs): return _misc.Process_Detach(*args, **kwargs)
    def GetInputStream(*args, **kwargs): return _misc.Process_GetInputStream(*args, **kwargs)
    def GetErrorStream(*args, **kwargs): return _misc.Process_GetErrorStream(*args, **kwargs)
    def GetOutputStream(*args, **kwargs): return _misc.Process_GetOutputStream(*args, **kwargs)
    def CloseOutput(*args, **kwargs): return _misc.Process_CloseOutput(*args, **kwargs)
    def IsInputOpened(*args, **kwargs): return _misc.Process_IsInputOpened(*args, **kwargs)
    def IsInputAvailable(*args, **kwargs): return _misc.Process_IsInputAvailable(*args, **kwargs)
    def IsErrorAvailable(*args, **kwargs): return _misc.Process_IsErrorAvailable(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyProcess instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ProcessPtr(Process):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Process
_misc.Process_swigregister(ProcessPtr)

Process_Kill = _misc.Process_Kill

Process_Exists = _misc.Process_Exists

Process_Open = _misc.Process_Open

class ProcessEvent(core.Event):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_ProcessEvent(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetPid(*args, **kwargs): return _misc.ProcessEvent_GetPid(*args, **kwargs)
    def GetExitCode(*args, **kwargs): return _misc.ProcessEvent_GetExitCode(*args, **kwargs)
    m_pid = property(_misc.ProcessEvent_m_pid_get, _misc.ProcessEvent_m_pid_set)
    m_exitcode = property(_misc.ProcessEvent_m_exitcode_get, _misc.ProcessEvent_m_exitcode_set)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxProcessEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ProcessEventPtr(ProcessEvent):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ProcessEvent
_misc.ProcessEvent_swigregister(ProcessEventPtr)

wxEVT_END_PROCESS = _misc.wxEVT_END_PROCESS
EVT_END_PROCESS = wx.PyEventBinder( wxEVT_END_PROCESS, 1 )

EXEC_ASYNC = _misc.EXEC_ASYNC
EXEC_SYNC = _misc.EXEC_SYNC
EXEC_NOHIDE = _misc.EXEC_NOHIDE
EXEC_MAKE_GROUP_LEADER = _misc.EXEC_MAKE_GROUP_LEADER

Execute = _misc.Execute
#---------------------------------------------------------------------------

JOYSTICK1 = _misc.JOYSTICK1
JOYSTICK2 = _misc.JOYSTICK2
JOY_BUTTON_ANY = _misc.JOY_BUTTON_ANY
JOY_BUTTON1 = _misc.JOY_BUTTON1
JOY_BUTTON2 = _misc.JOY_BUTTON2
JOY_BUTTON3 = _misc.JOY_BUTTON3
JOY_BUTTON4 = _misc.JOY_BUTTON4
class Joystick(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Joystick(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Joystick):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetPosition(*args, **kwargs): return _misc.Joystick_GetPosition(*args, **kwargs)
    def GetZPosition(*args, **kwargs): return _misc.Joystick_GetZPosition(*args, **kwargs)
    def GetButtonState(*args, **kwargs): return _misc.Joystick_GetButtonState(*args, **kwargs)
    def GetPOVPosition(*args, **kwargs): return _misc.Joystick_GetPOVPosition(*args, **kwargs)
    def GetPOVCTSPosition(*args, **kwargs): return _misc.Joystick_GetPOVCTSPosition(*args, **kwargs)
    def GetRudderPosition(*args, **kwargs): return _misc.Joystick_GetRudderPosition(*args, **kwargs)
    def GetUPosition(*args, **kwargs): return _misc.Joystick_GetUPosition(*args, **kwargs)
    def GetVPosition(*args, **kwargs): return _misc.Joystick_GetVPosition(*args, **kwargs)
    def GetMovementThreshold(*args, **kwargs): return _misc.Joystick_GetMovementThreshold(*args, **kwargs)
    def SetMovementThreshold(*args, **kwargs): return _misc.Joystick_SetMovementThreshold(*args, **kwargs)
    def IsOk(*args, **kwargs): return _misc.Joystick_IsOk(*args, **kwargs)
    def GetNumberJoysticks(*args, **kwargs): return _misc.Joystick_GetNumberJoysticks(*args, **kwargs)
    def GetManufacturerId(*args, **kwargs): return _misc.Joystick_GetManufacturerId(*args, **kwargs)
    def GetProductId(*args, **kwargs): return _misc.Joystick_GetProductId(*args, **kwargs)
    def GetProductName(*args, **kwargs): return _misc.Joystick_GetProductName(*args, **kwargs)
    def GetXMin(*args, **kwargs): return _misc.Joystick_GetXMin(*args, **kwargs)
    def GetYMin(*args, **kwargs): return _misc.Joystick_GetYMin(*args, **kwargs)
    def GetZMin(*args, **kwargs): return _misc.Joystick_GetZMin(*args, **kwargs)
    def GetXMax(*args, **kwargs): return _misc.Joystick_GetXMax(*args, **kwargs)
    def GetYMax(*args, **kwargs): return _misc.Joystick_GetYMax(*args, **kwargs)
    def GetZMax(*args, **kwargs): return _misc.Joystick_GetZMax(*args, **kwargs)
    def GetNumberButtons(*args, **kwargs): return _misc.Joystick_GetNumberButtons(*args, **kwargs)
    def GetNumberAxes(*args, **kwargs): return _misc.Joystick_GetNumberAxes(*args, **kwargs)
    def GetMaxButtons(*args, **kwargs): return _misc.Joystick_GetMaxButtons(*args, **kwargs)
    def GetMaxAxes(*args, **kwargs): return _misc.Joystick_GetMaxAxes(*args, **kwargs)
    def GetPollingMin(*args, **kwargs): return _misc.Joystick_GetPollingMin(*args, **kwargs)
    def GetPollingMax(*args, **kwargs): return _misc.Joystick_GetPollingMax(*args, **kwargs)
    def GetRudderMin(*args, **kwargs): return _misc.Joystick_GetRudderMin(*args, **kwargs)
    def GetRudderMax(*args, **kwargs): return _misc.Joystick_GetRudderMax(*args, **kwargs)
    def GetUMin(*args, **kwargs): return _misc.Joystick_GetUMin(*args, **kwargs)
    def GetUMax(*args, **kwargs): return _misc.Joystick_GetUMax(*args, **kwargs)
    def GetVMin(*args, **kwargs): return _misc.Joystick_GetVMin(*args, **kwargs)
    def GetVMax(*args, **kwargs): return _misc.Joystick_GetVMax(*args, **kwargs)
    def HasRudder(*args, **kwargs): return _misc.Joystick_HasRudder(*args, **kwargs)
    def HasZ(*args, **kwargs): return _misc.Joystick_HasZ(*args, **kwargs)
    def HasU(*args, **kwargs): return _misc.Joystick_HasU(*args, **kwargs)
    def HasV(*args, **kwargs): return _misc.Joystick_HasV(*args, **kwargs)
    def HasPOV(*args, **kwargs): return _misc.Joystick_HasPOV(*args, **kwargs)
    def HasPOV4Dir(*args, **kwargs): return _misc.Joystick_HasPOV4Dir(*args, **kwargs)
    def HasPOVCTS(*args, **kwargs): return _misc.Joystick_HasPOVCTS(*args, **kwargs)
    def SetCapture(*args, **kwargs): return _misc.Joystick_SetCapture(*args, **kwargs)
    def ReleaseCapture(*args, **kwargs): return _misc.Joystick_ReleaseCapture(*args, **kwargs)
    def __nonzero__(self): return self.IsOk() 
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxJoystick instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class JoystickPtr(Joystick):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Joystick
_misc.Joystick_swigregister(JoystickPtr)

wxEVT_JOY_BUTTON_DOWN = _misc.wxEVT_JOY_BUTTON_DOWN
wxEVT_JOY_BUTTON_UP = _misc.wxEVT_JOY_BUTTON_UP
wxEVT_JOY_MOVE = _misc.wxEVT_JOY_MOVE
wxEVT_JOY_ZMOVE = _misc.wxEVT_JOY_ZMOVE
class JoystickEvent(core.Event):
    m_pos = property(_misc.JoystickEvent_m_pos_get, _misc.JoystickEvent_m_pos_set)
    m_zPosition = property(_misc.JoystickEvent_m_zPosition_get, _misc.JoystickEvent_m_zPosition_set)
    m_buttonChange = property(_misc.JoystickEvent_m_buttonChange_get, _misc.JoystickEvent_m_buttonChange_set)
    m_buttonState = property(_misc.JoystickEvent_m_buttonState_get, _misc.JoystickEvent_m_buttonState_set)
    m_joyStick = property(_misc.JoystickEvent_m_joyStick_get, _misc.JoystickEvent_m_joyStick_set)
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_JoystickEvent(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetPosition(*args, **kwargs): return _misc.JoystickEvent_GetPosition(*args, **kwargs)
    def GetZPosition(*args, **kwargs): return _misc.JoystickEvent_GetZPosition(*args, **kwargs)
    def GetButtonState(*args, **kwargs): return _misc.JoystickEvent_GetButtonState(*args, **kwargs)
    def GetButtonChange(*args, **kwargs): return _misc.JoystickEvent_GetButtonChange(*args, **kwargs)
    def GetJoystick(*args, **kwargs): return _misc.JoystickEvent_GetJoystick(*args, **kwargs)
    def SetJoystick(*args, **kwargs): return _misc.JoystickEvent_SetJoystick(*args, **kwargs)
    def SetButtonState(*args, **kwargs): return _misc.JoystickEvent_SetButtonState(*args, **kwargs)
    def SetButtonChange(*args, **kwargs): return _misc.JoystickEvent_SetButtonChange(*args, **kwargs)
    def SetPosition(*args, **kwargs): return _misc.JoystickEvent_SetPosition(*args, **kwargs)
    def SetZPosition(*args, **kwargs): return _misc.JoystickEvent_SetZPosition(*args, **kwargs)
    def IsButton(*args, **kwargs): return _misc.JoystickEvent_IsButton(*args, **kwargs)
    def IsMove(*args, **kwargs): return _misc.JoystickEvent_IsMove(*args, **kwargs)
    def IsZMove(*args, **kwargs): return _misc.JoystickEvent_IsZMove(*args, **kwargs)
    def ButtonDown(*args, **kwargs): return _misc.JoystickEvent_ButtonDown(*args, **kwargs)
    def ButtonUp(*args, **kwargs): return _misc.JoystickEvent_ButtonUp(*args, **kwargs)
    def ButtonIsDown(*args, **kwargs): return _misc.JoystickEvent_ButtonIsDown(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxJoystickEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class JoystickEventPtr(JoystickEvent):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = JoystickEvent
_misc.JoystickEvent_swigregister(JoystickEventPtr)

EVT_JOY_BUTTON_DOWN = wx.PyEventBinder( wxEVT_JOY_BUTTON_DOWN )
EVT_JOY_BUTTON_UP = wx.PyEventBinder( wxEVT_JOY_BUTTON_UP )
EVT_JOY_MOVE = wx.PyEventBinder( wxEVT_JOY_MOVE )
EVT_JOY_ZMOVE = wx.PyEventBinder( wxEVT_JOY_ZMOVE )

EVT_JOYSTICK_EVENTS = wx.PyEventBinder([ wxEVT_JOY_BUTTON_DOWN,
                                        wxEVT_JOY_BUTTON_UP, 
                                        wxEVT_JOY_MOVE, 
                                        wxEVT_JOY_ZMOVE,
                                        ])


#---------------------------------------------------------------------------

class Wave(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Wave(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Wave):
        try:
            if self.thisown: destroy(self)
        except: pass
    def IsOk(*args, **kwargs): return _misc.Wave_IsOk(*args, **kwargs)
    def Play(*args, **kwargs): return _misc.Wave_Play(*args, **kwargs)
    def __nonzero__(self): return self.IsOk() 
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxWave instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class WavePtr(Wave):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Wave
_misc.Wave_swigregister(WavePtr)

def WaveData(*args, **kwargs):
    val = _misc.new_WaveData(*args, **kwargs)
    val.thisown = 1
    return val

#---------------------------------------------------------------------------

MAILCAP_STANDARD = _misc.MAILCAP_STANDARD
MAILCAP_NETSCAPE = _misc.MAILCAP_NETSCAPE
MAILCAP_KDE = _misc.MAILCAP_KDE
MAILCAP_GNOME = _misc.MAILCAP_GNOME
MAILCAP_ALL = _misc.MAILCAP_ALL
class FileTypeInfo(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileTypeInfo(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def IsValid(*args, **kwargs): return _misc.FileTypeInfo_IsValid(*args, **kwargs)
    def SetIcon(*args, **kwargs): return _misc.FileTypeInfo_SetIcon(*args, **kwargs)
    def SetShortDesc(*args, **kwargs): return _misc.FileTypeInfo_SetShortDesc(*args, **kwargs)
    def GetMimeType(*args, **kwargs): return _misc.FileTypeInfo_GetMimeType(*args, **kwargs)
    def GetOpenCommand(*args, **kwargs): return _misc.FileTypeInfo_GetOpenCommand(*args, **kwargs)
    def GetPrintCommand(*args, **kwargs): return _misc.FileTypeInfo_GetPrintCommand(*args, **kwargs)
    def GetShortDesc(*args, **kwargs): return _misc.FileTypeInfo_GetShortDesc(*args, **kwargs)
    def GetDescription(*args, **kwargs): return _misc.FileTypeInfo_GetDescription(*args, **kwargs)
    def GetExtensions(*args, **kwargs): return _misc.FileTypeInfo_GetExtensions(*args, **kwargs)
    def GetExtensionsCount(*args, **kwargs): return _misc.FileTypeInfo_GetExtensionsCount(*args, **kwargs)
    def GetIconFile(*args, **kwargs): return _misc.FileTypeInfo_GetIconFile(*args, **kwargs)
    def GetIconIndex(*args, **kwargs): return _misc.FileTypeInfo_GetIconIndex(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxFileTypeInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileTypeInfoPtr(FileTypeInfo):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileTypeInfo
_misc.FileTypeInfo_swigregister(FileTypeInfoPtr)

def FileTypeInfoSequence(*args, **kwargs):
    val = _misc.new_FileTypeInfoSequence(*args, **kwargs)
    val.thisown = 1
    return val

def NullFileTypeInfo(*args, **kwargs):
    val = _misc.new_NullFileTypeInfo(*args, **kwargs)
    val.thisown = 1
    return val

class FileType(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileType(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_FileType):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetMimeType(*args, **kwargs): return _misc.FileType_GetMimeType(*args, **kwargs)
    def GetMimeTypes(*args, **kwargs): return _misc.FileType_GetMimeTypes(*args, **kwargs)
    def GetExtensions(*args, **kwargs): return _misc.FileType_GetExtensions(*args, **kwargs)
    def GetIcon(*args, **kwargs): return _misc.FileType_GetIcon(*args, **kwargs)
    def GetIconInfo(*args, **kwargs): return _misc.FileType_GetIconInfo(*args, **kwargs)
    def GetDescription(*args, **kwargs): return _misc.FileType_GetDescription(*args, **kwargs)
    def GetOpenCommand(*args, **kwargs): return _misc.FileType_GetOpenCommand(*args, **kwargs)
    def GetPrintCommand(*args, **kwargs): return _misc.FileType_GetPrintCommand(*args, **kwargs)
    def GetAllCommands(*args, **kwargs): return _misc.FileType_GetAllCommands(*args, **kwargs)
    def SetCommand(*args, **kwargs): return _misc.FileType_SetCommand(*args, **kwargs)
    def SetDefaultIcon(*args, **kwargs): return _misc.FileType_SetDefaultIcon(*args, **kwargs)
    def Unassociate(*args, **kwargs): return _misc.FileType_Unassociate(*args, **kwargs)
    ExpandCommand = staticmethod(_misc.FileType_ExpandCommand)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxFileType instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileTypePtr(FileType):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileType
_misc.FileType_swigregister(FileTypePtr)

FileType_ExpandCommand = _misc.FileType_ExpandCommand

class MimeTypesManager(object):
    IsOfType = staticmethod(_misc.MimeTypesManager_IsOfType)
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_MimeTypesManager(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def Initialize(*args, **kwargs): return _misc.MimeTypesManager_Initialize(*args, **kwargs)
    def ClearData(*args, **kwargs): return _misc.MimeTypesManager_ClearData(*args, **kwargs)
    def GetFileTypeFromExtension(*args, **kwargs): return _misc.MimeTypesManager_GetFileTypeFromExtension(*args, **kwargs)
    def GetFileTypeFromMimeType(*args, **kwargs): return _misc.MimeTypesManager_GetFileTypeFromMimeType(*args, **kwargs)
    def ReadMailcap(*args, **kwargs): return _misc.MimeTypesManager_ReadMailcap(*args, **kwargs)
    def ReadMimeTypes(*args, **kwargs): return _misc.MimeTypesManager_ReadMimeTypes(*args, **kwargs)
    def EnumAllFileTypes(*args, **kwargs): return _misc.MimeTypesManager_EnumAllFileTypes(*args, **kwargs)
    def AddFallback(*args, **kwargs): return _misc.MimeTypesManager_AddFallback(*args, **kwargs)
    def Associate(*args, **kwargs): return _misc.MimeTypesManager_Associate(*args, **kwargs)
    def Unassociate(*args, **kwargs): return _misc.MimeTypesManager_Unassociate(*args, **kwargs)
    def __del__(self, destroy=_misc.delete_MimeTypesManager):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxMimeTypesManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class MimeTypesManagerPtr(MimeTypesManager):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = MimeTypesManager
_misc.MimeTypesManager_swigregister(MimeTypesManagerPtr)
cvar = _misc.cvar
TheMimeTypesManager = cvar.TheMimeTypesManager

MimeTypesManager_IsOfType = _misc.MimeTypesManager_IsOfType

#---------------------------------------------------------------------------

class ArtProvider(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_ArtProvider(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, ArtProvider)
    def __del__(self, destroy=_misc.delete_ArtProvider):
        try:
            if self.thisown: destroy(self)
        except: pass
    def _setCallbackInfo(*args, **kwargs): return _misc.ArtProvider__setCallbackInfo(*args, **kwargs)
    PushProvider = staticmethod(_misc.ArtProvider_PushProvider)
    PopProvider = staticmethod(_misc.ArtProvider_PopProvider)
    RemoveProvider = staticmethod(_misc.ArtProvider_RemoveProvider)
    GetBitmap = staticmethod(_misc.ArtProvider_GetBitmap)
    GetIcon = staticmethod(_misc.ArtProvider_GetIcon)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyArtProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ArtProviderPtr(ArtProvider):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ArtProvider
_misc.ArtProvider_swigregister(ArtProviderPtr)
ART_TOOLBAR = cvar.ART_TOOLBAR
ART_MENU = cvar.ART_MENU
ART_FRAME_ICON = cvar.ART_FRAME_ICON
ART_CMN_DIALOG = cvar.ART_CMN_DIALOG
ART_HELP_BROWSER = cvar.ART_HELP_BROWSER
ART_MESSAGE_BOX = cvar.ART_MESSAGE_BOX
ART_OTHER = cvar.ART_OTHER
ART_ADD_BOOKMARK = cvar.ART_ADD_BOOKMARK
ART_DEL_BOOKMARK = cvar.ART_DEL_BOOKMARK
ART_HELP_SIDE_PANEL = cvar.ART_HELP_SIDE_PANEL
ART_HELP_SETTINGS = cvar.ART_HELP_SETTINGS
ART_HELP_BOOK = cvar.ART_HELP_BOOK
ART_HELP_FOLDER = cvar.ART_HELP_FOLDER
ART_HELP_PAGE = cvar.ART_HELP_PAGE
ART_GO_BACK = cvar.ART_GO_BACK
ART_GO_FORWARD = cvar.ART_GO_FORWARD
ART_GO_UP = cvar.ART_GO_UP
ART_GO_DOWN = cvar.ART_GO_DOWN
ART_GO_TO_PARENT = cvar.ART_GO_TO_PARENT
ART_GO_HOME = cvar.ART_GO_HOME
ART_FILE_OPEN = cvar.ART_FILE_OPEN
ART_PRINT = cvar.ART_PRINT
ART_HELP = cvar.ART_HELP
ART_TIP = cvar.ART_TIP
ART_REPORT_VIEW = cvar.ART_REPORT_VIEW
ART_LIST_VIEW = cvar.ART_LIST_VIEW
ART_NEW_DIR = cvar.ART_NEW_DIR
ART_FOLDER = cvar.ART_FOLDER
ART_GO_DIR_UP = cvar.ART_GO_DIR_UP
ART_EXECUTABLE_FILE = cvar.ART_EXECUTABLE_FILE
ART_NORMAL_FILE = cvar.ART_NORMAL_FILE
ART_TICK_MARK = cvar.ART_TICK_MARK
ART_CROSS_MARK = cvar.ART_CROSS_MARK
ART_ERROR = cvar.ART_ERROR
ART_QUESTION = cvar.ART_QUESTION
ART_WARNING = cvar.ART_WARNING
ART_INFORMATION = cvar.ART_INFORMATION
ART_MISSING_IMAGE = cvar.ART_MISSING_IMAGE

ArtProvider_PushProvider = _misc.ArtProvider_PushProvider

ArtProvider_PopProvider = _misc.ArtProvider_PopProvider

ArtProvider_RemoveProvider = _misc.ArtProvider_RemoveProvider

ArtProvider_GetBitmap = _misc.ArtProvider_GetBitmap

ArtProvider_GetIcon = _misc.ArtProvider_GetIcon

#---------------------------------------------------------------------------

CONFIG_USE_LOCAL_FILE = _misc.CONFIG_USE_LOCAL_FILE
CONFIG_USE_GLOBAL_FILE = _misc.CONFIG_USE_GLOBAL_FILE
CONFIG_USE_RELATIVE_PATH = _misc.CONFIG_USE_RELATIVE_PATH
CONFIG_USE_NO_ESCAPE_CHARACTERS = _misc.CONFIG_USE_NO_ESCAPE_CHARACTERS
class ConfigBase(object):
    def __del__(self, destroy=_misc.delete_ConfigBase):
        try:
            if self.thisown: destroy(self)
        except: pass
    Type_Unknown = _misc.ConfigBase_Type_Unknown
    Type_String = _misc.ConfigBase_Type_String
    Type_Boolean = _misc.ConfigBase_Type_Boolean
    Type_Integer = _misc.ConfigBase_Type_Integer
    Type_Float = _misc.ConfigBase_Type_Float
    Set = staticmethod(_misc.ConfigBase_Set)
    Get = staticmethod(_misc.ConfigBase_Get)
    Create = staticmethod(_misc.ConfigBase_Create)
    DontCreateOnDemand = staticmethod(_misc.ConfigBase_DontCreateOnDemand)
    def SetPath(*args, **kwargs): return _misc.ConfigBase_SetPath(*args, **kwargs)
    def GetPath(*args, **kwargs): return _misc.ConfigBase_GetPath(*args, **kwargs)
    def GetFirstGroup(*args, **kwargs): return _misc.ConfigBase_GetFirstGroup(*args, **kwargs)
    def GetNextGroup(*args, **kwargs): return _misc.ConfigBase_GetNextGroup(*args, **kwargs)
    def GetFirstEntry(*args, **kwargs): return _misc.ConfigBase_GetFirstEntry(*args, **kwargs)
    def GetNextEntry(*args, **kwargs): return _misc.ConfigBase_GetNextEntry(*args, **kwargs)
    def GetNumberOfEntries(*args, **kwargs): return _misc.ConfigBase_GetNumberOfEntries(*args, **kwargs)
    def GetNumberOfGroups(*args, **kwargs): return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
    def HasGroup(*args, **kwargs): return _misc.ConfigBase_HasGroup(*args, **kwargs)
    def HasEntry(*args, **kwargs): return _misc.ConfigBase_HasEntry(*args, **kwargs)
    def Exists(*args, **kwargs): return _misc.ConfigBase_Exists(*args, **kwargs)
    def GetEntryType(*args, **kwargs): return _misc.ConfigBase_GetEntryType(*args, **kwargs)
    def Read(*args, **kwargs): return _misc.ConfigBase_Read(*args, **kwargs)
    def ReadInt(*args, **kwargs): return _misc.ConfigBase_ReadInt(*args, **kwargs)
    def ReadFloat(*args, **kwargs): return _misc.ConfigBase_ReadFloat(*args, **kwargs)
    def ReadBool(*args, **kwargs): return _misc.ConfigBase_ReadBool(*args, **kwargs)
    def Write(*args, **kwargs): return _misc.ConfigBase_Write(*args, **kwargs)
    def WriteInt(*args, **kwargs): return _misc.ConfigBase_WriteInt(*args, **kwargs)
    def WriteFloat(*args, **kwargs): return _misc.ConfigBase_WriteFloat(*args, **kwargs)
    def WriteBool(*args, **kwargs): return _misc.ConfigBase_WriteBool(*args, **kwargs)
    def Flush(*args, **kwargs): return _misc.ConfigBase_Flush(*args, **kwargs)
    def RenameEntry(*args, **kwargs): return _misc.ConfigBase_RenameEntry(*args, **kwargs)
    def RenameGroup(*args, **kwargs): return _misc.ConfigBase_RenameGroup(*args, **kwargs)
    def DeleteEntry(*args, **kwargs): return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
    def DeleteGroup(*args, **kwargs): return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
    def DeleteAll(*args, **kwargs): return _misc.ConfigBase_DeleteAll(*args, **kwargs)
    def IsExpandingEnvVars(*args, **kwargs): return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
    def SetExpandEnvVars(*args, **kwargs): return _misc.ConfigBase_SetExpandEnvVars(*args, **kwargs)
    def SetRecordDefaults(*args, **kwargs): return _misc.ConfigBase_SetRecordDefaults(*args, **kwargs)
    def IsRecordingDefaults(*args, **kwargs): return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
    def ExpandEnvVars(*args, **kwargs): return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
    def GetAppName(*args, **kwargs): return _misc.ConfigBase_GetAppName(*args, **kwargs)
    def GetVendorName(*args, **kwargs): return _misc.ConfigBase_GetVendorName(*args, **kwargs)
    def SetAppName(*args, **kwargs): return _misc.ConfigBase_SetAppName(*args, **kwargs)
    def SetVendorName(*args, **kwargs): return _misc.ConfigBase_SetVendorName(*args, **kwargs)
    def SetStyle(*args, **kwargs): return _misc.ConfigBase_SetStyle(*args, **kwargs)
    def GetStyle(*args, **kwargs): return _misc.ConfigBase_GetStyle(*args, **kwargs)
    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,)

class ConfigBasePtr(ConfigBase):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ConfigBase
_misc.ConfigBase_swigregister(ConfigBasePtr)

ConfigBase_Set = _misc.ConfigBase_Set

ConfigBase_Get = _misc.ConfigBase_Get

ConfigBase_Create = _misc.ConfigBase_Create

ConfigBase_DontCreateOnDemand = _misc.ConfigBase_DontCreateOnDemand

class ConfigPathChanger(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_ConfigPathChanger):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Name(*args, **kwargs): return _misc.ConfigPathChanger_Name(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ConfigPathChangerPtr(ConfigPathChanger):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ConfigPathChanger
_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)

class Config(ConfigBase):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Config(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Config):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ConfigPtr(Config):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Config
_misc.Config_swigregister(ConfigPtr)

class FileConfig(ConfigBase):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileConfig(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_FileConfig):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileConfigPtr(FileConfig):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileConfig
_misc.FileConfig_swigregister(FileConfigPtr)


ExpandEnvVars = _misc.ExpandEnvVars
#---------------------------------------------------------------------------

class DateTime(object):
    Local = _misc.DateTime_Local
    GMT_12 = _misc.DateTime_GMT_12
    GMT_11 = _misc.DateTime_GMT_11
    GMT_10 = _misc.DateTime_GMT_10
    GMT_9 = _misc.DateTime_GMT_9
    GMT_8 = _misc.DateTime_GMT_8
    GMT_7 = _misc.DateTime_GMT_7
    GMT_6 = _misc.DateTime_GMT_6
    GMT_5 = _misc.DateTime_GMT_5
    GMT_4 = _misc.DateTime_GMT_4
    GMT_3 = _misc.DateTime_GMT_3
    GMT_2 = _misc.DateTime_GMT_2
    GMT_1 = _misc.DateTime_GMT_1
    GMT0 = _misc.DateTime_GMT0
    GMT1 = _misc.DateTime_GMT1
    GMT2 = _misc.DateTime_GMT2
    GMT3 = _misc.DateTime_GMT3
    GMT4 = _misc.DateTime_GMT4
    GMT5 = _misc.DateTime_GMT5
    GMT6 = _misc.DateTime_GMT6
    GMT7 = _misc.DateTime_GMT7
    GMT8 = _misc.DateTime_GMT8
    GMT9 = _misc.DateTime_GMT9
    GMT10 = _misc.DateTime_GMT10
    GMT11 = _misc.DateTime_GMT11
    GMT12 = _misc.DateTime_GMT12
    WET = _misc.DateTime_WET
    WEST = _misc.DateTime_WEST
    CET = _misc.DateTime_CET
    CEST = _misc.DateTime_CEST
    EET = _misc.DateTime_EET
    EEST = _misc.DateTime_EEST
    MSK = _misc.DateTime_MSK
    MSD = _misc.DateTime_MSD
    AST = _misc.DateTime_AST
    ADT = _misc.DateTime_ADT
    EST = _misc.DateTime_EST
    EDT = _misc.DateTime_EDT
    CST = _misc.DateTime_CST
    CDT = _misc.DateTime_CDT
    MST = _misc.DateTime_MST
    MDT = _misc.DateTime_MDT
    PST = _misc.DateTime_PST
    PDT = _misc.DateTime_PDT
    HST = _misc.DateTime_HST
    AKST = _misc.DateTime_AKST
    AKDT = _misc.DateTime_AKDT
    A_WST = _misc.DateTime_A_WST
    A_CST = _misc.DateTime_A_CST
    A_EST = _misc.DateTime_A_EST
    A_ESST = _misc.DateTime_A_ESST
    UTC = _misc.DateTime_UTC
    Gregorian = _misc.DateTime_Gregorian
    Julian = _misc.DateTime_Julian
    Gr_Unknown = _misc.DateTime_Gr_Unknown
    Gr_Standard = _misc.DateTime_Gr_Standard
    Gr_Alaska = _misc.DateTime_Gr_Alaska
    Gr_Albania = _misc.DateTime_Gr_Albania
    Gr_Austria = _misc.DateTime_Gr_Austria
    Gr_Austria_Brixen = _misc.DateTime_Gr_Austria_Brixen
    Gr_Austria_Salzburg = _misc.DateTime_Gr_Austria_Salzburg
    Gr_Austria_Tyrol = _misc.DateTime_Gr_Austria_Tyrol
    Gr_Austria_Carinthia = _misc.DateTime_Gr_Austria_Carinthia
    Gr_Austria_Styria = _misc.DateTime_Gr_Austria_Styria
    Gr_Belgium = _misc.DateTime_Gr_Belgium
    Gr_Bulgaria = _misc.DateTime_Gr_Bulgaria
    Gr_Bulgaria_1 = _misc.DateTime_Gr_Bulgaria_1
    Gr_Bulgaria_2 = _misc.DateTime_Gr_Bulgaria_2
    Gr_Bulgaria_3 = _misc.DateTime_Gr_Bulgaria_3
    Gr_Canada = _misc.DateTime_Gr_Canada
    Gr_China = _misc.DateTime_Gr_China
    Gr_China_1 = _misc.DateTime_Gr_China_1
    Gr_China_2 = _misc.DateTime_Gr_China_2
    Gr_Czechoslovakia = _misc.DateTime_Gr_Czechoslovakia
    Gr_Denmark = _misc.DateTime_Gr_Denmark
    Gr_Egypt = _misc.DateTime_Gr_Egypt
    Gr_Estonia = _misc.DateTime_Gr_Estonia
    Gr_Finland = _misc.DateTime_Gr_Finland
    Gr_France = _misc.DateTime_Gr_France
    Gr_France_Alsace = _misc.DateTime_Gr_France_Alsace
    Gr_France_Lorraine = _misc.DateTime_Gr_France_Lorraine
    Gr_France_Strasbourg = _misc.DateTime_Gr_France_Strasbourg
    Gr_Germany = _misc.DateTime_Gr_Germany
    Gr_Germany_Catholic = _misc.DateTime_Gr_Germany_Catholic
    Gr_Germany_Prussia = _misc.DateTime_Gr_Germany_Prussia
    Gr_Germany_Protestant = _misc.DateTime_Gr_Germany_Protestant
    Gr_GreatBritain = _misc.DateTime_Gr_GreatBritain
    Gr_Greece = _misc.DateTime_Gr_Greece
    Gr_Hungary = _misc.DateTime_Gr_Hungary
    Gr_Ireland = _misc.DateTime_Gr_Ireland
    Gr_Italy = _misc.DateTime_Gr_Italy
    Gr_Japan = _misc.DateTime_Gr_Japan
    Gr_Japan_1 = _misc.DateTime_Gr_Japan_1
    Gr_Japan_2 = _misc.DateTime_Gr_Japan_2
    Gr_Japan_3 = _misc.DateTime_Gr_Japan_3
    Gr_Latvia = _misc.DateTime_Gr_Latvia
    Gr_Lithuania = _misc.DateTime_Gr_Lithuania
    Gr_Luxemburg = _misc.DateTime_Gr_Luxemburg
    Gr_Netherlands = _misc.DateTime_Gr_Netherlands
    Gr_Netherlands_Groningen = _misc.DateTime_Gr_Netherlands_Groningen
    Gr_Netherlands_Gelderland = _misc.DateTime_Gr_Netherlands_Gelderland
    Gr_Netherlands_Utrecht = _misc.DateTime_Gr_Netherlands_Utrecht
    Gr_Netherlands_Friesland = _misc.DateTime_Gr_Netherlands_Friesland
    Gr_Norway = _misc.DateTime_Gr_Norway
    Gr_Poland = _misc.DateTime_Gr_Poland
    Gr_Portugal = _misc.DateTime_Gr_Portugal
    Gr_Romania = _misc.DateTime_Gr_Romania
    Gr_Russia = _misc.DateTime_Gr_Russia
    Gr_Scotland = _misc.DateTime_Gr_Scotland
    Gr_Spain = _misc.DateTime_Gr_Spain
    Gr_Sweden = _misc.DateTime_Gr_Sweden
    Gr_Switzerland = _misc.DateTime_Gr_Switzerland
    Gr_Switzerland_Catholic = _misc.DateTime_Gr_Switzerland_Catholic
    Gr_Switzerland_Protestant = _misc.DateTime_Gr_Switzerland_Protestant
    Gr_Turkey = _misc.DateTime_Gr_Turkey
    Gr_USA = _misc.DateTime_Gr_USA
    Gr_Wales = _misc.DateTime_Gr_Wales
    Gr_Yugoslavia = _misc.DateTime_Gr_Yugoslavia
    Country_Unknown = _misc.DateTime_Country_Unknown
    Country_Default = _misc.DateTime_Country_Default
    Country_WesternEurope_Start = _misc.DateTime_Country_WesternEurope_Start
    Country_EEC = _misc.DateTime_Country_EEC
    France = _misc.DateTime_France
    Germany = _misc.DateTime_Germany
    UK = _misc.DateTime_UK
    Country_WesternEurope_End = _misc.DateTime_Country_WesternEurope_End
    Russia = _misc.DateTime_Russia
    USA = _misc.DateTime_USA
    Jan = _misc.DateTime_Jan
    Feb = _misc.DateTime_Feb
    Mar = _misc.DateTime_Mar
    Apr = _misc.DateTime_Apr
    May = _misc.DateTime_May
    Jun = _misc.DateTime_Jun
    Jul = _misc.DateTime_Jul
    Aug = _misc.DateTime_Aug
    Sep = _misc.DateTime_Sep
    Oct = _misc.DateTime_Oct
    Nov = _misc.DateTime_Nov
    Dec = _misc.DateTime_Dec
    Inv_Month = _misc.DateTime_Inv_Month
    Sun = _misc.DateTime_Sun
    Mon = _misc.DateTime_Mon
    Tue = _misc.DateTime_Tue
    Wed = _misc.DateTime_Wed
    Thu = _misc.DateTime_Thu
    Fri = _misc.DateTime_Fri
    Sat = _misc.DateTime_Sat
    Inv_WeekDay = _misc.DateTime_Inv_WeekDay
    Inv_Year = _misc.DateTime_Inv_Year
    Name_Full = _misc.DateTime_Name_Full
    Name_Abbr = _misc.DateTime_Name_Abbr
    Default_First = _misc.DateTime_Default_First
    Monday_First = _misc.DateTime_Monday_First
    Sunday_First = _misc.DateTime_Sunday_First
    SetCountry = staticmethod(_misc.DateTime_SetCountry)
    GetCountry = staticmethod(_misc.DateTime_GetCountry)
    IsWestEuropeanCountry = staticmethod(_misc.DateTime_IsWestEuropeanCountry)
    GetCurrentYear = staticmethod(_misc.DateTime_GetCurrentYear)
    ConvertYearToBC = staticmethod(_misc.DateTime_ConvertYearToBC)
    GetCurrentMonth = staticmethod(_misc.DateTime_GetCurrentMonth)
    IsLeapYear = staticmethod(_misc.DateTime_IsLeapYear)
    GetCentury = staticmethod(_misc.DateTime_GetCentury)
    GetNumberOfDaysinYear = staticmethod(_misc.DateTime_GetNumberOfDaysinYear)
    GetNumberOfDaysInMonth = staticmethod(_misc.DateTime_GetNumberOfDaysInMonth)
    GetMonthName = staticmethod(_misc.DateTime_GetMonthName)
    GetWeekDayName = staticmethod(_misc.DateTime_GetWeekDayName)
    GetAmPmStrings = staticmethod(_misc.DateTime_GetAmPmStrings)
    IsDSTApplicable = staticmethod(_misc.DateTime_IsDSTApplicable)
    GetBeginDST = staticmethod(_misc.DateTime_GetBeginDST)
    GetEndDST = staticmethod(_misc.DateTime_GetEndDST)
    Now = staticmethod(_misc.DateTime_Now)
    UNow = staticmethod(_misc.DateTime_UNow)
    Today = staticmethod(_misc.DateTime_Today)
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DateTime(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_DateTime):
        try:
            if self.thisown: destroy(self)
        except: pass
    def SetToCurrent(*args, **kwargs): return _misc.DateTime_SetToCurrent(*args, **kwargs)
    def SetTimeT(*args, **kwargs): return _misc.DateTime_SetTimeT(*args, **kwargs)
    def SetJDN(*args, **kwargs): return _misc.DateTime_SetJDN(*args, **kwargs)
    def SetHMS(*args, **kwargs): return _misc.DateTime_SetHMS(*args, **kwargs)
    def Set(*args, **kwargs): return _misc.DateTime_Set(*args, **kwargs)
    def ResetTime(*args, **kwargs): return _misc.DateTime_ResetTime(*args, **kwargs)
    def SetYear(*args, **kwargs): return _misc.DateTime_SetYear(*args, **kwargs)
    def SetMonth(*args, **kwargs): return _misc.DateTime_SetMonth(*args, **kwargs)
    def SetDay(*args, **kwargs): return _misc.DateTime_SetDay(*args, **kwargs)
    def SetHour(*args, **kwargs): return _misc.DateTime_SetHour(*args, **kwargs)
    def SetMinute(*args, **kwargs): return _misc.DateTime_SetMinute(*args, **kwargs)
    def SetSecond(*args, **kwargs): return _misc.DateTime_SetSecond(*args, **kwargs)
    def SetMillisecond(*args, **kwargs): return _misc.DateTime_SetMillisecond(*args, **kwargs)
    def SetToWeekDayInSameWeek(*args, **kwargs): return _misc.DateTime_SetToWeekDayInSameWeek(*args, **kwargs)
    def GetWeekDayInSameWeek(*args, **kwargs): return _misc.DateTime_GetWeekDayInSameWeek(*args, **kwargs)
    def SetToNextWeekDay(*args, **kwargs): return _misc.DateTime_SetToNextWeekDay(*args, **kwargs)
    def GetNextWeekDay(*args, **kwargs): return _misc.DateTime_GetNextWeekDay(*args, **kwargs)
    def SetToPrevWeekDay(*args, **kwargs): return _misc.DateTime_SetToPrevWeekDay(*args, **kwargs)
    def GetPrevWeekDay(*args, **kwargs): return _misc.DateTime_GetPrevWeekDay(*args, **kwargs)
    def SetToWeekDay(*args, **kwargs): return _misc.DateTime_SetToWeekDay(*args, **kwargs)
    def SetToLastWeekDay(*args, **kwargs): return _misc.DateTime_SetToLastWeekDay(*args, **kwargs)
    def GetLastWeekDay(*args, **kwargs): return _misc.DateTime_GetLastWeekDay(*args, **kwargs)
    def SetToTheWeek(*args, **kwargs): return _misc.DateTime_SetToTheWeek(*args, **kwargs)
    def GetWeek(*args, **kwargs): return _misc.DateTime_GetWeek(*args, **kwargs)
    def SetToLastMonthDay(*args, **kwargs): return _misc.DateTime_SetToLastMonthDay(*args, **kwargs)
    def GetLastMonthDay(*args, **kwargs): return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
    def SetToYearDay(*args, **kwargs): return _misc.DateTime_SetToYearDay(*args, **kwargs)
    def GetYearDay(*args, **kwargs): return _misc.DateTime_GetYearDay(*args, **kwargs)
    def GetJulianDayNumber(*args, **kwargs): return _misc.DateTime_GetJulianDayNumber(*args, **kwargs)
    def GetJDN(*args, **kwargs): return _misc.DateTime_GetJDN(*args, **kwargs)
    def GetModifiedJulianDayNumber(*args, **kwargs): return _misc.DateTime_GetModifiedJulianDayNumber(*args, **kwargs)
    def GetMJD(*args, **kwargs): return _misc.DateTime_GetMJD(*args, **kwargs)
    def GetRataDie(*args, **kwargs): return _misc.DateTime_GetRataDie(*args, **kwargs)
    def ToTimezone(*args, **kwargs): return _misc.DateTime_ToTimezone(*args, **kwargs)
    def MakeTimezone(*args, **kwargs): return _misc.DateTime_MakeTimezone(*args, **kwargs)
    def ToGMT(*args, **kwargs): return _misc.DateTime_ToGMT(*args, **kwargs)
    def MakeGMT(*args, **kwargs): return _misc.DateTime_MakeGMT(*args, **kwargs)
    def IsDST(*args, **kwargs): return _misc.DateTime_IsDST(*args, **kwargs)
    def IsValid(*args, **kwargs): return _misc.DateTime_IsValid(*args, **kwargs)
    def GetTicks(*args, **kwargs): return _misc.DateTime_GetTicks(*args, **kwargs)
    def GetYear(*args, **kwargs): return _misc.DateTime_GetYear(*args, **kwargs)
    def GetMonth(*args, **kwargs): return _misc.DateTime_GetMonth(*args, **kwargs)
    def GetDay(*args, **kwargs): return _misc.DateTime_GetDay(*args, **kwargs)
    def GetWeekDay(*args, **kwargs): return _misc.DateTime_GetWeekDay(*args, **kwargs)
    def GetHour(*args, **kwargs): return _misc.DateTime_GetHour(*args, **kwargs)
    def GetMinute(*args, **kwargs): return _misc.DateTime_GetMinute(*args, **kwargs)
    def GetSecond(*args, **kwargs): return _misc.DateTime_GetSecond(*args, **kwargs)
    def GetMillisecond(*args, **kwargs): return _misc.DateTime_GetMillisecond(*args, **kwargs)
    def GetDayOfYear(*args, **kwargs): return _misc.DateTime_GetDayOfYear(*args, **kwargs)
    def GetWeekOfYear(*args, **kwargs): return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
    def GetWeekOfMonth(*args, **kwargs): return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
    def IsWorkDay(*args, **kwargs): return _misc.DateTime_IsWorkDay(*args, **kwargs)
    def IsEqualTo(*args, **kwargs): return _misc.DateTime_IsEqualTo(*args, **kwargs)
    def IsEarlierThan(*args, **kwargs): return _misc.DateTime_IsEarlierThan(*args, **kwargs)
    def IsLaterThan(*args, **kwargs): return _misc.DateTime_IsLaterThan(*args, **kwargs)
    def IsStrictlyBetween(*args, **kwargs): return _misc.DateTime_IsStrictlyBetween(*args, **kwargs)
    def IsBetween(*args, **kwargs): return _misc.DateTime_IsBetween(*args, **kwargs)
    def IsSameDate(*args, **kwargs): return _misc.DateTime_IsSameDate(*args, **kwargs)
    def IsSameTime(*args, **kwargs): return _misc.DateTime_IsSameTime(*args, **kwargs)
    def IsEqualUpTo(*args, **kwargs): return _misc.DateTime_IsEqualUpTo(*args, **kwargs)
    def AddTS(*args, **kwargs): return _misc.DateTime_AddTS(*args, **kwargs)
    def AddDS(*args, **kwargs): return _misc.DateTime_AddDS(*args, **kwargs)
    def SubtractTS(*args, **kwargs): return _misc.DateTime_SubtractTS(*args, **kwargs)
    def SubtractDS(*args, **kwargs): return _misc.DateTime_SubtractDS(*args, **kwargs)
    def Subtract(*args, **kwargs): return _misc.DateTime_Subtract(*args, **kwargs)
    def __iadd__(*args): return _misc.DateTime___iadd__(*args)
    def __isub__(*args): return _misc.DateTime___isub__(*args)
    def __add__(*args): return _misc.DateTime___add__(*args)
    def __sub__(*args): return _misc.DateTime___sub__(*args)
    def __lt__(*args): return _misc.DateTime___lt__(*args)
    def __le__(*args): return _misc.DateTime___le__(*args)
    def __gt__(*args): return _misc.DateTime___gt__(*args)
    def __ge__(*args): return _misc.DateTime___ge__(*args)
    def __eq__(*args): return _misc.DateTime___eq__(*args)
    def __ne__(*args): return _misc.DateTime___ne__(*args)
    def ParseRfc822Date(*args, **kwargs): return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
    def ParseFormat(*args, **kwargs): return _misc.DateTime_ParseFormat(*args, **kwargs)
    def ParseDateTime(*args, **kwargs): return _misc.DateTime_ParseDateTime(*args, **kwargs)
    def ParseDate(*args, **kwargs): return _misc.DateTime_ParseDate(*args, **kwargs)
    def ParseTime(*args, **kwargs): return _misc.DateTime_ParseTime(*args, **kwargs)
    def Format(*args, **kwargs): return _misc.DateTime_Format(*args, **kwargs)
    def FormatDate(*args, **kwargs): return _misc.DateTime_FormatDate(*args, **kwargs)
    def FormatTime(*args, **kwargs): return _misc.DateTime_FormatTime(*args, **kwargs)
    def FormatISODate(*args, **kwargs): return _misc.DateTime_FormatISODate(*args, **kwargs)
    def FormatISOTime(*args, **kwargs): return _misc.DateTime_FormatISOTime(*args, **kwargs)
    def __repr__(self):
        return '<wxDateTime: \"%s\" at %s>' % ( self.Format(), self.this)
    def __str__(self):
        return self.Format()


class DateTimePtr(DateTime):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DateTime
_misc.DateTime_swigregister(DateTimePtr)

DateTime_SetCountry = _misc.DateTime_SetCountry

DateTime_GetCountry = _misc.DateTime_GetCountry

DateTime_IsWestEuropeanCountry = _misc.DateTime_IsWestEuropeanCountry

DateTime_GetCurrentYear = _misc.DateTime_GetCurrentYear

DateTime_ConvertYearToBC = _misc.DateTime_ConvertYearToBC

DateTime_GetCurrentMonth = _misc.DateTime_GetCurrentMonth

DateTime_IsLeapYear = _misc.DateTime_IsLeapYear

DateTime_GetCentury = _misc.DateTime_GetCentury

DateTime_GetNumberOfDaysinYear = _misc.DateTime_GetNumberOfDaysinYear

DateTime_GetNumberOfDaysInMonth = _misc.DateTime_GetNumberOfDaysInMonth

DateTime_GetMonthName = _misc.DateTime_GetMonthName

DateTime_GetWeekDayName = _misc.DateTime_GetWeekDayName

DateTime_GetAmPmStrings = _misc.DateTime_GetAmPmStrings

DateTime_IsDSTApplicable = _misc.DateTime_IsDSTApplicable

DateTime_GetBeginDST = _misc.DateTime_GetBeginDST

DateTime_GetEndDST = _misc.DateTime_GetEndDST

DateTime_Now = _misc.DateTime_Now

DateTime_UNow = _misc.DateTime_UNow

DateTime_Today = _misc.DateTime_Today

def DateTimeFromTimeT(*args, **kwargs):
    val = _misc.new_DateTimeFromTimeT(*args, **kwargs)
    val.thisown = 1
    return val

def DateTimeFromJDN(*args, **kwargs):
    val = _misc.new_DateTimeFromJDN(*args, **kwargs)
    val.thisown = 1
    return val

def DateTimeFromHMS(*args, **kwargs):
    val = _misc.new_DateTimeFromHMS(*args, **kwargs)
    val.thisown = 1
    return val

def DateTimeFromDMY(*args, **kwargs):
    val = _misc.new_DateTimeFromDMY(*args, **kwargs)
    val.thisown = 1
    return val

class TimeSpan(object):
    Seconds = staticmethod(_misc.TimeSpan_Seconds)
    Second = staticmethod(_misc.TimeSpan_Second)
    Minutes = staticmethod(_misc.TimeSpan_Minutes)
    Minute = staticmethod(_misc.TimeSpan_Minute)
    Hours = staticmethod(_misc.TimeSpan_Hours)
    Hour = staticmethod(_misc.TimeSpan_Hour)
    Days = staticmethod(_misc.TimeSpan_Days)
    Day = staticmethod(_misc.TimeSpan_Day)
    Weeks = staticmethod(_misc.TimeSpan_Weeks)
    Week = staticmethod(_misc.TimeSpan_Week)
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_TimeSpan(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_TimeSpan):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Add(*args, **kwargs): return _misc.TimeSpan_Add(*args, **kwargs)
    def Subtract(*args, **kwargs): return _misc.TimeSpan_Subtract(*args, **kwargs)
    def Multiply(*args, **kwargs): return _misc.TimeSpan_Multiply(*args, **kwargs)
    def Neg(*args, **kwargs): return _misc.TimeSpan_Neg(*args, **kwargs)
    def Abs(*args, **kwargs): return _misc.TimeSpan_Abs(*args, **kwargs)
    def __iadd__(*args, **kwargs): return _misc.TimeSpan___iadd__(*args, **kwargs)
    def __isub__(*args, **kwargs): return _misc.TimeSpan___isub__(*args, **kwargs)
    def __imul__(*args, **kwargs): return _misc.TimeSpan___imul__(*args, **kwargs)
    def __neg__(*args, **kwargs): return _misc.TimeSpan___neg__(*args, **kwargs)
    def __add__(*args, **kwargs): return _misc.TimeSpan___add__(*args, **kwargs)
    def __sub__(*args, **kwargs): return _misc.TimeSpan___sub__(*args, **kwargs)
    def __mul__(*args, **kwargs): return _misc.TimeSpan___mul__(*args, **kwargs)
    def __rmul__(*args, **kwargs): return _misc.TimeSpan___rmul__(*args, **kwargs)
    def __lt__(*args, **kwargs): return _misc.TimeSpan___lt__(*args, **kwargs)
    def __le__(*args, **kwargs): return _misc.TimeSpan___le__(*args, **kwargs)
    def __gt__(*args, **kwargs): return _misc.TimeSpan___gt__(*args, **kwargs)
    def __ge__(*args, **kwargs): return _misc.TimeSpan___ge__(*args, **kwargs)
    def __eq__(*args, **kwargs): return _misc.TimeSpan___eq__(*args, **kwargs)
    def __ne__(*args, **kwargs): return _misc.TimeSpan___ne__(*args, **kwargs)
    def IsNull(*args, **kwargs): return _misc.TimeSpan_IsNull(*args, **kwargs)
    def IsPositive(*args, **kwargs): return _misc.TimeSpan_IsPositive(*args, **kwargs)
    def IsNegative(*args, **kwargs): return _misc.TimeSpan_IsNegative(*args, **kwargs)
    def IsEqualTo(*args, **kwargs): return _misc.TimeSpan_IsEqualTo(*args, **kwargs)
    def IsLongerThan(*args, **kwargs): return _misc.TimeSpan_IsLongerThan(*args, **kwargs)
    def IsShorterThan(*args, **kwargs): return _misc.TimeSpan_IsShorterThan(*args, **kwargs)
    def GetWeeks(*args, **kwargs): return _misc.TimeSpan_GetWeeks(*args, **kwargs)
    def GetDays(*args, **kwargs): return _misc.TimeSpan_GetDays(*args, **kwargs)
    def GetHours(*args, **kwargs): return _misc.TimeSpan_GetHours(*args, **kwargs)
    def GetMinutes(*args, **kwargs): return _misc.TimeSpan_GetMinutes(*args, **kwargs)
    def GetSeconds(*args, **kwargs): return _misc.TimeSpan_GetSeconds(*args, **kwargs)
    def GetMilliseconds(*args, **kwargs): return _misc.TimeSpan_GetMilliseconds(*args, **kwargs)
    def Format(*args, **kwargs): return _misc.TimeSpan_Format(*args, **kwargs)
    def __repr__(self):
        return '<wxTimeSpan: \"%s\" at %s>' % ( self.Format(), self.this)
    def __str__(self):
        return self.Format()


class TimeSpanPtr(TimeSpan):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TimeSpan
_misc.TimeSpan_swigregister(TimeSpanPtr)

TimeSpan_Seconds = _misc.TimeSpan_Seconds

TimeSpan_Second = _misc.TimeSpan_Second

TimeSpan_Minutes = _misc.TimeSpan_Minutes

TimeSpan_Minute = _misc.TimeSpan_Minute

TimeSpan_Hours = _misc.TimeSpan_Hours

TimeSpan_Hour = _misc.TimeSpan_Hour

TimeSpan_Days = _misc.TimeSpan_Days

TimeSpan_Day = _misc.TimeSpan_Day

TimeSpan_Weeks = _misc.TimeSpan_Weeks

TimeSpan_Week = _misc.TimeSpan_Week

class DateSpan(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DateSpan(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_DateSpan):
        try:
            if self.thisown: destroy(self)
        except: pass
    Days = staticmethod(_misc.DateSpan_Days)
    Day = staticmethod(_misc.DateSpan_Day)
    Weeks = staticmethod(_misc.DateSpan_Weeks)
    Week = staticmethod(_misc.DateSpan_Week)
    Months = staticmethod(_misc.DateSpan_Months)
    Month = staticmethod(_misc.DateSpan_Month)
    Years = staticmethod(_misc.DateSpan_Years)
    Year = staticmethod(_misc.DateSpan_Year)
    def SetYears(*args, **kwargs): return _misc.DateSpan_SetYears(*args, **kwargs)
    def SetMonths(*args, **kwargs): return _misc.DateSpan_SetMonths(*args, **kwargs)
    def SetWeeks(*args, **kwargs): return _misc.DateSpan_SetWeeks(*args, **kwargs)
    def SetDays(*args, **kwargs): return _misc.DateSpan_SetDays(*args, **kwargs)
    def GetYears(*args, **kwargs): return _misc.DateSpan_GetYears(*args, **kwargs)
    def GetMonths(*args, **kwargs): return _misc.DateSpan_GetMonths(*args, **kwargs)
    def GetWeeks(*args, **kwargs): return _misc.DateSpan_GetWeeks(*args, **kwargs)
    def GetDays(*args, **kwargs): return _misc.DateSpan_GetDays(*args, **kwargs)
    def GetTotalDays(*args, **kwargs): return _misc.DateSpan_GetTotalDays(*args, **kwargs)
    def Add(*args, **kwargs): return _misc.DateSpan_Add(*args, **kwargs)
    def Subtract(*args, **kwargs): return _misc.DateSpan_Subtract(*args, **kwargs)
    def Neg(*args, **kwargs): return _misc.DateSpan_Neg(*args, **kwargs)
    def Multiply(*args, **kwargs): return _misc.DateSpan_Multiply(*args, **kwargs)
    def __iadd__(*args, **kwargs): return _misc.DateSpan___iadd__(*args, **kwargs)
    def __isub__(*args, **kwargs): return _misc.DateSpan___isub__(*args, **kwargs)
    def __neg__(*args, **kwargs): return _misc.DateSpan___neg__(*args, **kwargs)
    def __imul__(*args, **kwargs): return _misc.DateSpan___imul__(*args, **kwargs)
    def __add__(*args, **kwargs): return _misc.DateSpan___add__(*args, **kwargs)
    def __sub__(*args, **kwargs): return _misc.DateSpan___sub__(*args, **kwargs)
    def __mul__(*args, **kwargs): return _misc.DateSpan___mul__(*args, **kwargs)
    def __rmul__(*args, **kwargs): return _misc.DateSpan___rmul__(*args, **kwargs)
    def __eq__(*args, **kwargs): return _misc.DateSpan___eq__(*args, **kwargs)
    def __ne__(*args, **kwargs): return _misc.DateSpan___ne__(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxDateSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DateSpanPtr(DateSpan):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DateSpan
_misc.DateSpan_swigregister(DateSpanPtr)

DateSpan_Days = _misc.DateSpan_Days

DateSpan_Day = _misc.DateSpan_Day

DateSpan_Weeks = _misc.DateSpan_Weeks

DateSpan_Week = _misc.DateSpan_Week

DateSpan_Months = _misc.DateSpan_Months

DateSpan_Month = _misc.DateSpan_Month

DateSpan_Years = _misc.DateSpan_Years

DateSpan_Year = _misc.DateSpan_Year


GetLocalTime = _misc.GetLocalTime

GetUTCTime = _misc.GetUTCTime

GetCurrentTime = _misc.GetCurrentTime

GetLocalTimeMillis = _misc.GetLocalTimeMillis
#---------------------------------------------------------------------------

DF_INVALID = _misc.DF_INVALID
DF_TEXT = _misc.DF_TEXT
DF_BITMAP = _misc.DF_BITMAP
DF_METAFILE = _misc.DF_METAFILE
DF_SYLK = _misc.DF_SYLK
DF_DIF = _misc.DF_DIF
DF_TIFF = _misc.DF_TIFF
DF_OEMTEXT = _misc.DF_OEMTEXT
DF_DIB = _misc.DF_DIB
DF_PALETTE = _misc.DF_PALETTE
DF_PENDATA = _misc.DF_PENDATA
DF_RIFF = _misc.DF_RIFF
DF_WAVE = _misc.DF_WAVE
DF_UNICODETEXT = _misc.DF_UNICODETEXT
DF_ENHMETAFILE = _misc.DF_ENHMETAFILE
DF_FILENAME = _misc.DF_FILENAME
DF_LOCALE = _misc.DF_LOCALE
DF_PRIVATE = _misc.DF_PRIVATE
DF_HTML = _misc.DF_HTML
DF_MAX = _misc.DF_MAX
class DataFormat(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DataFormat(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_DataFormat):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __eq__(*args): return _misc.DataFormat___eq__(*args)
    def __ne__(*args): return _misc.DataFormat___ne__(*args)
    def SetType(*args, **kwargs): return _misc.DataFormat_SetType(*args, **kwargs)
    def GetType(*args, **kwargs): return _misc.DataFormat_GetType(*args, **kwargs)
    def GetId(*args, **kwargs): return _misc.DataFormat_GetId(*args, **kwargs)
    def SetId(*args, **kwargs): return _misc.DataFormat_SetId(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxDataFormat instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DataFormatPtr(DataFormat):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DataFormat
_misc.DataFormat_swigregister(DataFormatPtr)

def CustomDataFormat(*args, **kwargs):
    val = _misc.new_CustomDataFormat(*args, **kwargs)
    val.thisown = 1
    return val

class DataObject(object):
    Get = _misc.DataObject_Get
    Set = _misc.DataObject_Set
    Both = _misc.DataObject_Both
    def __del__(self, destroy=_misc.delete_DataObject):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetPreferredFormat(*args, **kwargs): return _misc.DataObject_GetPreferredFormat(*args, **kwargs)
    def GetFormatCount(*args, **kwargs): return _misc.DataObject_GetFormatCount(*args, **kwargs)
    def IsSupported(*args, **kwargs): return _misc.DataObject_IsSupported(*args, **kwargs)
    def GetDataSize(*args, **kwargs): return _misc.DataObject_GetDataSize(*args, **kwargs)
    def GetAllFormats(*args, **kwargs): return _misc.DataObject_GetAllFormats(*args, **kwargs)
    def GetDataHere(*args, **kwargs): return _misc.DataObject_GetDataHere(*args, **kwargs)
    def SetData(*args, **kwargs): return _misc.DataObject_SetData(*args, **kwargs)
    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,)

class DataObjectPtr(DataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DataObject
_misc.DataObject_swigregister(DataObjectPtr)
FormatInvalid = cvar.FormatInvalid

class DataObjectSimple(DataObject):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DataObjectSimple(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetFormat(*args, **kwargs): return _misc.DataObjectSimple_GetFormat(*args, **kwargs)
    def SetFormat(*args, **kwargs): return _misc.DataObjectSimple_SetFormat(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxDataObjectSimple instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DataObjectSimplePtr(DataObjectSimple):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DataObjectSimple
_misc.DataObjectSimple_swigregister(DataObjectSimplePtr)

class PyDataObjectSimple(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_PyDataObjectSimple(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, PyDataObjectSimple)
    def _setCallbackInfo(*args, **kwargs): return _misc.PyDataObjectSimple__setCallbackInfo(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyDataObjectSimple instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class PyDataObjectSimplePtr(PyDataObjectSimple):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = PyDataObjectSimple
_misc.PyDataObjectSimple_swigregister(PyDataObjectSimplePtr)

class DataObjectComposite(DataObject):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DataObjectComposite(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def Add(*args, **kwargs): 
        val = _misc.DataObjectComposite_Add(*args, **kwargs)
        args[1].thisown = 0
        return val
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxDataObjectComposite instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DataObjectCompositePtr(DataObjectComposite):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DataObjectComposite
_misc.DataObjectComposite_swigregister(DataObjectCompositePtr)

class TextDataObject(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_TextDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetTextLength(*args, **kwargs): return _misc.TextDataObject_GetTextLength(*args, **kwargs)
    def GetText(*args, **kwargs): return _misc.TextDataObject_GetText(*args, **kwargs)
    def SetText(*args, **kwargs): return _misc.TextDataObject_SetText(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class TextDataObjectPtr(TextDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TextDataObject
_misc.TextDataObject_swigregister(TextDataObjectPtr)

class PyTextDataObject(TextDataObject):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_PyTextDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, PyTextDataObject)
    def _setCallbackInfo(*args, **kwargs): return _misc.PyTextDataObject__setCallbackInfo(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class PyTextDataObjectPtr(PyTextDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = PyTextDataObject
_misc.PyTextDataObject_swigregister(PyTextDataObjectPtr)

class BitmapDataObject(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_BitmapDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetBitmap(*args, **kwargs): return _misc.BitmapDataObject_GetBitmap(*args, **kwargs)
    def SetBitmap(*args, **kwargs): return _misc.BitmapDataObject_SetBitmap(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class BitmapDataObjectPtr(BitmapDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = BitmapDataObject
_misc.BitmapDataObject_swigregister(BitmapDataObjectPtr)

class PyBitmapDataObject(BitmapDataObject):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_PyBitmapDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, PyBitmapDataObject)
    def _setCallbackInfo(*args, **kwargs): return _misc.PyBitmapDataObject__setCallbackInfo(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class PyBitmapDataObjectPtr(PyBitmapDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = PyBitmapDataObject
_misc.PyBitmapDataObject_swigregister(PyBitmapDataObjectPtr)

class FileDataObject(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetFilenames(*args, **kwargs): return _misc.FileDataObject_GetFilenames(*args, **kwargs)
    def AddFile(*args, **kwargs): return _misc.FileDataObject_AddFile(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxFileDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileDataObjectPtr(FileDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileDataObject
_misc.FileDataObject_swigregister(FileDataObjectPtr)

class CustomDataObject(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_CustomDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def TakeData(*args, **kwargs): return _misc.CustomDataObject_TakeData(*args, **kwargs)
    def SetData(*args, **kwargs): return _misc.CustomDataObject_SetData(*args, **kwargs)
    def GetSize(*args, **kwargs): return _misc.CustomDataObject_GetSize(*args, **kwargs)
    def GetData(*args, **kwargs): return _misc.CustomDataObject_GetData(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxCustomDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class CustomDataObjectPtr(CustomDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CustomDataObject
_misc.CustomDataObject_swigregister(CustomDataObjectPtr)

class URLDataObject(DataObjectComposite):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_URLDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def GetURL(*args, **kwargs): return _misc.URLDataObject_GetURL(*args, **kwargs)
    def SetURL(*args, **kwargs): return _misc.URLDataObject_SetURL(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxURLDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class URLDataObjectPtr(URLDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = URLDataObject
_misc.URLDataObject_swigregister(URLDataObjectPtr)

class MetafileDataObject(DataObjectSimple):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_MetafileDataObject(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def SetMetafile(*args, **kwargs): return _misc.MetafileDataObject_SetMetafile(*args, **kwargs)
    def GetMetafile(*args, **kwargs): return _misc.MetafileDataObject_GetMetafile(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxMetafileDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class MetafileDataObjectPtr(MetafileDataObject):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = MetafileDataObject
_misc.MetafileDataObject_swigregister(MetafileDataObjectPtr)

#---------------------------------------------------------------------------

Drag_CopyOnly = _misc.Drag_CopyOnly
Drag_AllowMove = _misc.Drag_AllowMove
Drag_DefaultMove = _misc.Drag_DefaultMove
DragError = _misc.DragError
DragNone = _misc.DragNone
DragCopy = _misc.DragCopy
DragMove = _misc.DragMove
DragLink = _misc.DragLink
DragCancel = _misc.DragCancel

IsDragResultOk = _misc.IsDragResultOk
class DropSource(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DropSource(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def _setCallbackInfo(*args, **kwargs): return _misc.DropSource__setCallbackInfo(*args, **kwargs)
    def __del__(self, destroy=_misc.delete_DropSource):
        try:
            if self.thisown: destroy(self)
        except: pass
    def SetData(*args, **kwargs): return _misc.DropSource_SetData(*args, **kwargs)
    def GetDataObject(*args, **kwargs): return _misc.DropSource_GetDataObject(*args, **kwargs)
    def SetCursor(*args, **kwargs): return _misc.DropSource_SetCursor(*args, **kwargs)
    def DoDragDrop(*args, **kwargs): return _misc.DropSource_DoDragDrop(*args, **kwargs)
    def base_GiveFeedback(*args, **kwargs): return _misc.DropSource_base_GiveFeedback(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyDropSource instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DropSourcePtr(DropSource):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DropSource
_misc.DropSource_swigregister(DropSourcePtr)

class DropTarget(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_DropTarget(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        if args: args[1].thisown = 0; self._setCallbackInfo(self, DropTarget)
    def _setCallbackInfo(*args, **kwargs): return _misc.DropTarget__setCallbackInfo(*args, **kwargs)
    def __del__(self, destroy=_misc.delete_DropTarget):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetDataObject(*args, **kwargs): return _misc.DropTarget_GetDataObject(*args, **kwargs)
    def SetDataObject(*args, **kwargs): 
        val = _misc.DropTarget_SetDataObject(*args, **kwargs)
        args[1].thisown = 0
        return val
    def base_OnEnter(*args, **kwargs): return _misc.DropTarget_base_OnEnter(*args, **kwargs)
    def base_OnDragOver(*args, **kwargs): return _misc.DropTarget_base_OnDragOver(*args, **kwargs)
    def base_OnLeave(*args, **kwargs): return _misc.DropTarget_base_OnLeave(*args, **kwargs)
    def base_OnDrop(*args, **kwargs): return _misc.DropTarget_base_OnDrop(*args, **kwargs)
    def GetData(*args, **kwargs): return _misc.DropTarget_GetData(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class DropTargetPtr(DropTarget):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = DropTarget
_misc.DropTarget_swigregister(DropTargetPtr)

PyDropTarget = DropTarget 
class TextDropTarget(DropTarget):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_TextDropTarget(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, TextDropTarget)
    def _setCallbackInfo(*args, **kwargs): return _misc.TextDropTarget__setCallbackInfo(*args, **kwargs)
    def base_OnEnter(*args, **kwargs): return _misc.TextDropTarget_base_OnEnter(*args, **kwargs)
    def base_OnDragOver(*args, **kwargs): return _misc.TextDropTarget_base_OnDragOver(*args, **kwargs)
    def base_OnLeave(*args, **kwargs): return _misc.TextDropTarget_base_OnLeave(*args, **kwargs)
    def base_OnDrop(*args, **kwargs): return _misc.TextDropTarget_base_OnDrop(*args, **kwargs)
    def base_OnData(*args, **kwargs): return _misc.TextDropTarget_base_OnData(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyTextDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class TextDropTargetPtr(TextDropTarget):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = TextDropTarget
_misc.TextDropTarget_swigregister(TextDropTargetPtr)

class FileDropTarget(DropTarget):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_FileDropTarget(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
        self._setCallbackInfo(self, FileDropTarget)
    def _setCallbackInfo(*args, **kwargs): return _misc.FileDropTarget__setCallbackInfo(*args, **kwargs)
    def base_OnEnter(*args, **kwargs): return _misc.FileDropTarget_base_OnEnter(*args, **kwargs)
    def base_OnDragOver(*args, **kwargs): return _misc.FileDropTarget_base_OnDragOver(*args, **kwargs)
    def base_OnLeave(*args, **kwargs): return _misc.FileDropTarget_base_OnLeave(*args, **kwargs)
    def base_OnDrop(*args, **kwargs): return _misc.FileDropTarget_base_OnDrop(*args, **kwargs)
    def base_OnData(*args, **kwargs): return _misc.FileDropTarget_base_OnData(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxPyFileDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class FileDropTargetPtr(FileDropTarget):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = FileDropTarget
_misc.FileDropTarget_swigregister(FileDropTargetPtr)

#---------------------------------------------------------------------------

class Clipboard(core.Object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_Clipboard(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_Clipboard):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Open(*args, **kwargs): return _misc.Clipboard_Open(*args, **kwargs)
    def Close(*args, **kwargs): return _misc.Clipboard_Close(*args, **kwargs)
    def IsOpened(*args, **kwargs): return _misc.Clipboard_IsOpened(*args, **kwargs)
    def AddData(*args, **kwargs): return _misc.Clipboard_AddData(*args, **kwargs)
    def SetData(*args, **kwargs): return _misc.Clipboard_SetData(*args, **kwargs)
    def IsSupported(*args, **kwargs): return _misc.Clipboard_IsSupported(*args, **kwargs)
    def GetData(*args, **kwargs): return _misc.Clipboard_GetData(*args, **kwargs)
    def Clear(*args, **kwargs): return _misc.Clipboard_Clear(*args, **kwargs)
    def Flush(*args, **kwargs): return _misc.Clipboard_Flush(*args, **kwargs)
    def UsePrimarySelection(*args, **kwargs): return _misc.Clipboard_UsePrimarySelection(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxClipboard instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ClipboardPtr(Clipboard):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = Clipboard
_misc.Clipboard_swigregister(ClipboardPtr)

class ClipboardLocker(object):
    def __init__(self, *args, **kwargs):
        newobj = _misc.new_ClipboardLocker(*args, **kwargs)
        self.this = newobj.this
        self.thisown = 1
        del newobj.thisown
    def __del__(self, destroy=_misc.delete_ClipboardLocker):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __nonzero__(*args, **kwargs): return _misc.ClipboardLocker___nonzero__(*args, **kwargs)
    def __repr__(self):
        return "<%s.%s; proxy of C++ wxClipboardLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)

class ClipboardLockerPtr(ClipboardLocker):
    def __init__(self, this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = ClipboardLocker
_misc.ClipboardLocker_swigregister(ClipboardLockerPtr)
TheClipboard = cvar.TheClipboard