@staticmethod
def Get():
    return wx.GetApp()

def GetComCtl32Version(*args, **kwargs):
    """
    GetComCtl32Version() -> int
    Returns 400, 470, 471, etc. for comctl32.dll 4.00, 4.70, 4.71 or 0 if
    it wasn't found at all.  Raises an exception on non-Windows platforms.
    """
    return _core_.PyApp_GetComCtl32Version(*args, **kwargs)

def GetMacAboutMenuItemId(*args, **kwargs):
    """GetMacAboutMenuItemId() -> long"""
    return _core_.PyApp_GetMacAboutMenuItemId(*args, **kwargs)

def GetMacExitMenuItemId(*args, **kwargs):
    """GetMacExitMenuItemId() -> long"""
    return _core_.PyApp_GetMacExitMenuItemId(*args, **kwargs)

def GetMacHelpMenuTitleName(*args, **kwargs):
    """GetMacHelpMenuTitleName() -> String"""
    return _core_.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)

def GetMacPreferencesMenuItemId(*args, **kwargs):
    """GetMacPreferencesMenuItemId() -> long"""
    return _core_.PyApp_GetMacPreferencesMenuItemId(*args, **kwargs)

def GetMacSupportPCMenuShortcuts(*args, **kwargs):
    """GetMacSupportPCMenuShortcuts() -> bool"""
    return _core_.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)

def GetShell32Version(*args, **kwargs):
    """
    GetShell32Version() -> int
    Returns 400, 470, 471, etc. for shell32.dll 4.00, 4.70, 4.71 or 0 if
    it wasn't found at all.  Raises an exception on non-Windows platforms.
    """
    return _core_.PyApp_GetShell32Version(*args, **kwargs)

def GetTraitsIfExists(*args, **kwargs):
    """
    GetTraitsIfExists() -> wxAppTraits
    This function provides safer access to traits object than
    wx.GetApp().GetTraits() during startup or termination when the global
    application object itself may be unavailable.
    """
    return _core_.PyApp_GetTraitsIfExists(*args, **kwargs)

def IsDisplayAvailable(*args, **kwargs):
    """
    IsDisplayAvailable() -> bool
    Tests if it is possible to create a GUI in the current environment.
    This will mean different things on the different platforms.
       * On X Windows systems this function will return ``False`` if it is
         not able to open a connection to the X server, which can happen
         if $DISPLAY is not set, or is not set correctly.
       * On Mac OS X a ``False`` return value will mean that wx is not
         able to access the window manager, which can happen if logged in
         remotely or if running from the normal version of python instead
         of the framework version, (i.e., pythonw.)
       * On MS Windows...
    """
    return _core_.PyApp_IsDisplayAvailable(*args, **kwargs)

def IsMainLoopRunning(*args, **kwargs):
    """
    IsMainLoopRunning() -> bool
    Returns True if we're running the main loop, i.e. if the events can
    currently be dispatched.
    """
    return _core_.PyApp_IsMainLoopRunning(*args, **kwargs)

def SetMacAboutMenuItemId(*args, **kwargs):
    """SetMacAboutMenuItemId(long val)"""
    return _core_.PyApp_SetMacAboutMenuItemId(*args, **kwargs)

def SetMacExitMenuItemId(*args, **kwargs):
    """SetMacExitMenuItemId(long val)"""
    return _core_.PyApp_SetMacExitMenuItemId(*args, **kwargs)

def SetMacHelpMenuTitleName(*args, **kwargs):
    """SetMacHelpMenuTitleName(String val)"""
    return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)

def SetMacPreferencesMenuItemId(*args, **kwargs):
    """SetMacPreferencesMenuItemId(long val)"""
    return _core_.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)

def SetMacSupportPCMenuShortcuts(*args, **kwargs):
    """SetMacSupportPCMenuShortcuts(bool val)"""
    return _core_.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)

def __init__(self,
             redirect=False,
             filename=None,
             useBestVisual=False,
             clearSigInt=True):
    """
    Construct a ``wx.App`` object.  
    :param redirect: Should ``sys.stdout`` and ``sys.stderr`` be
        redirected?  Defaults to False. If ``filename`` is None
        then output will be redirected to a window that pops up
        as needed.  (You can control what kind of window is created
        for the output by resetting the class variable
        ``outputWindowClass`` to a class of your choosing.)
    :param filename: The name of a file to redirect output to, if
        redirect is True.
    :param useBestVisual: Should the app try to use the best
        available visual provided by the system (only relevant on
        systems that have more than one visual.)  This parameter
        must be used instead of calling `SetUseBestVisual` later
        on because it must be set before the underlying GUI
        toolkit is initialized.
    :param clearSigInt: Should SIGINT be cleared?  This allows the
        app to terminate upon a Ctrl-C in the console like other
        GUI apps will.
    :note: You should override OnInit to do applicaition
        initialization to ensure that the system, toolkit and
        wxWidgets are fully initialized.
    """
    
    wx.PyApp.__init__(self)
    # make sure we can create a GUI
    if not self.IsDisplayAvailable():
        
        if wx.Platform == "__WXMAC__":
            msg = """This program needs access to the screen.
se run with a Framework build of python, and only when you are
ed in on the main display of your Mac."""
            
        elif wx.Platform == "__WXGTK__":
            msg ="Unable to access the X Display, is $DISPLAY set properly?"
        else:
            msg = "Unable to create GUI"
            # TODO: more description is needed for wxMSW...
        raise SystemExit(msg)
    
    # This has to be done before OnInit
    self.SetUseBestVisual(useBestVisual)
    # Set the default handler for SIGINT.  This fixes a problem
    # where if Ctrl-C is pressed in the console that started this
    # app then it will not appear to do anything, (not even send
    # KeyboardInterrupt???)  but will later segfault on exit.  By
    # setting the default handler then the app will exit, as
    # expected (depending on platform.)
    if clearSigInt:
        try:
            import signal
            signal.signal(signal.SIGINT, signal.SIG_DFL)
        except:
            pass
    # Save and redirect the stdio to a window?
    self.stdioWin = None
    self.saveStdio = (_sys.stdout, _sys.stderr)
    if redirect:
        self.RedirectStdio(filename)
    # Use Python's install prefix as the default  
    wx.StandardPaths.Get().SetInstallPrefix(_sys.prefix)
    # Until the new native control for wxMac is up to par, still use the generic one.
    wx.SystemOptions.SetOptionInt("mac.listctrl.always_use_generic", 1)
    # This finishes the initialization of wxWindows and then calls
    # the OnInit that should be present in the derived class
    self._BootstrapApp()

def AddPendingEvent(*args, **kwargs):
    """AddPendingEvent(self, Event event)"""
    return _core_.EvtHandler_AddPendingEvent(*args, **kwargs)

def AppendPendingEventHandler(*args, **kwargs):
    """AppendPendingEventHandler(self, EvtHandler toAppend)"""
    return _core_.PyApp_AppendPendingEventHandler(*args, **kwargs)

def Bind(self, event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
    """
    Bind an event to an event handler.
    :param event: One of the EVT_* objects that specifies the
                  type of event to bind,
    :param handler: A callable object to be invoked when the
                  event is delivered to self.  Pass None to
                  disconnect an event handler.
    :param source: Sometimes the event originates from a
                  different window than self, but you still
                  want to catch it in self.  (For example, a
                  button event delivered to a frame.)  By
                  passing the source of the event, the event
                  handling system is able to differentiate
                  between the same event type from different
                  controls.
    :param id: Used to spcify the event source by ID instead
               of instance.
    :param id2: Used when it is desirable to bind a handler
                  to a range of IDs, such as with EVT_MENU_RANGE.
    """
    assert isinstance(event, wx.PyEventBinder)
    assert handler is None or callable(handler)
    assert source is None or hasattr(source, 'GetId')
    if source is not None:
        id  = source.GetId()
    event.Bind(self, id, id2, handler)              

def Connect(*args, **kwargs):
    """Connect(self, int id, int lastId, EventType eventType, PyObject func)"""
    return _core_.EvtHandler_Connect(*args, **kwargs)

def DelayPendingEventHandler(*args, **kwargs):
    """DelayPendingEventHandler(self, EvtHandler toDelay)"""
    return _core_.PyApp_DelayPendingEventHandler(*args, **kwargs)

def DeletePendingEvents(*args, **kwargs):
    """DeletePendingEvents(self)"""
    return _core_.PyApp_DeletePendingEvents(*args, **kwargs)

def Destroy(self):
    self.this.own(False)
    wx.PyApp.Destroy(self)

def Disconnect(*args, **kwargs):
    """
    Disconnect(self, int id, int lastId=-1, EventType eventType=wxEVT_NULL, 
        PyObject func=None) -> bool
    """
    return _core_.EvtHandler_Disconnect(*args, **kwargs)

def Dispatch(*args, **kwargs):
    """
    Dispatch(self) -> bool
    Process the first event in the event queue (blocks until an event
    appears if there are none currently)
    """
    return _core_.PyApp_Dispatch(*args, **kwargs)

def Exit(*args, **kwargs):
    """
    Exit(self)
    Exit the main loop thus terminating the application.
    :see: `wx.Exit`
    """
    return _core_.PyApp_Exit(*args, **kwargs)

def ExitMainLoop(*args, **kwargs):
    """
    ExitMainLoop(self)
    Exit the main GUI loop during the next iteration of the main
    loop, (i.e. it does not stop the program immediately!)
    """
    return _core_.PyApp_ExitMainLoop(*args, **kwargs)

def FilterEvent(*args, **kwargs):
    """
    FilterEvent(self, Event event) -> int
    Filters all events. `SetCallFilterEvent` controls whether or not your
    override is called.
    """
    return _core_.PyApp_FilterEvent(*args, **kwargs)

def GetAppDisplayName(*args, **kwargs):
    """
    GetAppDisplayName(self) -> String
    Get the application display name.
    """
    return _core_.PyApp_GetAppDisplayName(*args, **kwargs)

def GetAppName(*args, **kwargs):
    """
    GetAppName(self) -> String
    Get the application name.
    """
    return _core_.PyApp_GetAppName(*args, **kwargs)

def GetAssertMode(*args, **kwargs):
    """
    GetAssertMode(self) -> int
    Get the current OnAssert behaviour setting.
    """
    return _core_.PyApp_GetAssertMode(*args, **kwargs)

def GetCallFilterEvent(*args, **kwargs):
    """
    GetCallFilterEvent(self) -> bool
    Returns the state of the Call FilterEvent flag.
    """
    return _core_.PyApp_GetCallFilterEvent(*args, **kwargs)

def GetClassName(*args, **kwargs):
    """
    GetClassName(self) -> String
    Get the application's class name.
    """
    return _core_.PyApp_GetClassName(*args, **kwargs)

def GetEvtHandlerEnabled(*args, **kwargs):
    """GetEvtHandlerEnabled(self) -> bool"""
    return _core_.EvtHandler_GetEvtHandlerEnabled(*args, **kwargs)

def GetExitOnFrameDelete(*args, **kwargs):
    """
    GetExitOnFrameDelete(self) -> bool
    Get the current exit behaviour setting.
    """
    return _core_.PyApp_GetExitOnFrameDelete(*args, **kwargs)

def GetLayoutDirection(*args, **kwargs):
    """
    GetLayoutDirection(self) -> int
    Return the layout direction for the current locale.
    """
    return _core_.PyApp_GetLayoutDirection(*args, **kwargs)

def GetMainLoop(*args, **kwargs):
    """
    GetMainLoop(self) -> EventLoopBase
    Returns the main event loop instance, i.e. the event loop which is started
    by OnRun() and which dispatches all events sent from the native toolkit
    to the application (except when new event loops are temporarily set-up).
    The returned value maybe None. Put initialization code which needs a
    non-None main event loop into OnEventLoopEnter().
    """
    return _core_.PyApp_GetMainLoop(*args, **kwargs)

def GetNextHandler(*args, **kwargs):
    """GetNextHandler(self) -> EvtHandler"""
    return _core_.EvtHandler_GetNextHandler(*args, **kwargs)

def GetPreviousHandler(*args, **kwargs):
    """GetPreviousHandler(self) -> EvtHandler"""
    return _core_.EvtHandler_GetPreviousHandler(*args, **kwargs)

def GetPrintMode(*args, **kwargs):
    """GetPrintMode(self) -> int"""
    return _core_.PyApp_GetPrintMode(*args, **kwargs)

def GetTopWindow(*args, **kwargs):
    """
    GetTopWindow(self) -> Window
    Return the *main* top level window (if it hadn't been set previously
    with SetTopWindow(), will return just some top level window and, if
    there not any, will return None)
    """
    return _core_.PyApp_GetTopWindow(*args, **kwargs)

def GetTraits(*args, **kwargs):
    """
    GetTraits(self) -> wxAppTraits
    Return (and create if necessary) the app traits object to which we
    delegate for everything which either should be configurable by the
    user (then he can change the default behaviour simply by overriding
    CreateTraits() and returning his own traits object) or which is
    GUI/console dependent as then wx.AppTraits allows us to abstract the
    differences behind the common facade.
    :todo: Add support for overriding CreateAppTraits in wxPython.
    """
    return _core_.PyApp_GetTraits(*args, **kwargs)

def GetUseBestVisual(*args, **kwargs):
    """
    GetUseBestVisual(self) -> bool
    Get current UseBestVisual setting.
    """
    return _core_.PyApp_GetUseBestVisual(*args, **kwargs)

def GetVendorDisplayName(*args, **kwargs):
    """
    GetVendorDisplayName(self) -> String
    Get the vendor display name.
    """
    return _core_.PyApp_GetVendorDisplayName(*args, **kwargs)

def GetVendorName(*args, **kwargs):
    """
    GetVendorName(self) -> String
    Get the application's vendor name.
    """
    return _core_.PyApp_GetVendorName(*args, **kwargs)

def HasPendingEvents(*args, **kwargs):
    """
    HasPendingEvents(self) -> bool
    Check if there are pending events on global pending event list
    """
    return _core_.PyApp_HasPendingEvents(*args, **kwargs)

def IsActive(*args, **kwargs):
    """
    IsActive(self) -> bool
    Return True if our app has focus.
    """
    return _core_.PyApp_IsActive(*args, **kwargs)

def IsSameAs(*args, **kwargs):
    """
    IsSameAs(self, Object p) -> bool
    For wx.Objects that use C++ reference counting internally, this method
    can be used to determine if two objects are referencing the same data
    object.
    """
    return _core_.Object_IsSameAs(*args, **kwargs)

def IsScheduledForDestruction(*args, **kwargs):
    """IsScheduledForDestruction(self, Object object) -> bool"""
    return _core_.PyApp_IsScheduledForDestruction(*args, **kwargs)

def IsUnlinked(*args, **kwargs):
    """IsUnlinked(self) -> bool"""
    return _core_.EvtHandler_IsUnlinked(*args, **kwargs)

def MacHideApp(*args, **kwargs):
    """
    MacHideApp(self)
    Hide all application windows just as the user can do with the system
    Hide command.  Mac only.
    """
    return _core_.PyApp_MacHideApp(*args, **kwargs)

def MainLoop(self):
    """Execute the main GUI event loop"""
    wx.PyApp.MainLoop(self)
    self.RestoreStdio()

def OnInit(self):
    self.main =wx.Frame(None)
    dlg = EndOfDayDialog(self.main)
    try:
        if dlg.ShowModal() == wx.ID_OK:
            result = dlg.GetValue()
             # Your code
    finally:
        dlg.Destroy()
    self.main.Show()
    self.SetTopWindow(self.main)
    return True

def OnPreInit(self):
    """
    Things that must be done after _BootstrapApp has done its
    thing, but would be nice if they were already done by the time
    that OnInit is called.
    """
    wx.StockGDI._initStockObjects()

def Pending(*args, **kwargs):
    """
    Pending(self) -> bool
    Returns True if there are unprocessed events in the event queue.
    """
    return _core_.PyApp_Pending(*args, **kwargs)

def ProcessEvent(*args, **kwargs):
    """ProcessEvent(self, Event event) -> bool"""
    return _core_.EvtHandler_ProcessEvent(*args, **kwargs)

def ProcessEventLocally(*args, **kwargs):
    """ProcessEventLocally(self, Event event) -> bool"""
    return _core_.EvtHandler_ProcessEventLocally(*args, **kwargs)

def ProcessIdle(*args, **kwargs):
    """
    ProcessIdle(self) -> bool
    Called from the MainLoop when the application becomes idle (there are
    no pending events) and sends a `wx.IdleEvent` to all interested
    parties.  Returns True if more idle events are needed, False if not.
    """
    return _core_.PyApp_ProcessIdle(*args, **kwargs)

def ProcessPendingEvents(*args, **kwargs):
    """
    ProcessPendingEvents(self)
    Process all events in the Pending Events list -- it is necessary to
    call this function to process posted events. This normally happens
    during each event loop iteration.
    """
    return _core_.PyApp_ProcessPendingEvents(*args, **kwargs)

def QueueEvent(*args, **kwargs):
    """QueueEvent(self, Event event)"""
    return _core_.EvtHandler_QueueEvent(*args, **kwargs)

def RedirectStdio(self, filename=None):
    """Redirect sys.stdout and sys.stderr to a file or a popup window."""
    if filename:
        _sys.stdout = _sys.stderr = open(filename, 'a')
    else:
        self.stdioWin = self.outputWindowClass()
        _sys.stdout = _sys.stderr = self.stdioWin

def RemovePendingEventHandler(*args, **kwargs):
    """RemovePendingEventHandler(self, EvtHandler toRemove)"""
    return _core_.PyApp_RemovePendingEventHandler(*args, **kwargs)

def RestoreStdio(self):
    try:
        _sys.stdout, _sys.stderr = self.saveStdio
    except:
        pass

def ResumeProcessingOfPendingEvents(*args, **kwargs):
    """
    ResumeProcessingOfPendingEvents(self)
    Resume (after having been suspended) the processing of pending events.
    """
    return _core_.PyApp_ResumeProcessingOfPendingEvents(*args, **kwargs)

def SafeYield(*args, **kwargs):
    """SafeYield(self, Window win, bool onlyIfNeeded) -> bool"""
    return _core_.PyApp_SafeYield(*args, **kwargs)

def SafeYieldFor(*args, **kwargs):
    """SafeYieldFor(self, Window win, long eventsToProcess) -> bool"""
    return _core_.PyApp_SafeYieldFor(*args, **kwargs)

def SafelyProcessEvent(*args, **kwargs):
    """SafelyProcessEvent(self, Event event) -> bool"""
    return _core_.EvtHandler_SafelyProcessEvent(*args, **kwargs)

def ScheduleForDestruction(*args, **kwargs):
    """ScheduleForDestruction(self, Object object)"""
    return _core_.PyApp_ScheduleForDestruction(*args, **kwargs)

def SetAppDisplayName(*args, **kwargs):
    """
    SetAppDisplayName(self, String name)
    Set the application display name.  The display name is the name shown
    to the user in titles, reports, etc while the app name is used for
    paths, config, and other places the user doesn't see, for example the
    app name could be myapp while display name could be 'My App'
    """
    return _core_.PyApp_SetAppDisplayName(*args, **kwargs)

def SetAppName(*args, **kwargs):
    """
    SetAppName(self, String name)
    Set the application name. This value may be used automatically by
    `wx.Config` and such.
    """
    return _core_.PyApp_SetAppName(*args, **kwargs)

def SetAssertMode(*args, **kwargs):
    """
    SetAssertMode(self, int mode)
    Set the OnAssert behaviour for debug and hybrid builds.
    """
    return _core_.PyApp_SetAssertMode(*args, **kwargs)

def SetCallFilterEvent(*args, **kwargs):
    """
    SetCallFilterEvent(self, bool callFilterEvent=True)
    Set the Call FilterEvent flag. When set your override of FilterEvent
    will be called.  SetCallFilterEvent's purpose is to avoid any
    performance penalty when you have overriden FilterEvent, but don't
    want it to be called, and also to reduce the runtime overhead when it
    is not overridden.
    """
    return _core_.PyApp_SetCallFilterEvent(*args, **kwargs)

def SetClassName(*args, **kwargs):
    """
    SetClassName(self, String name)
    Set the application's class name. This value may be used for
    X-resources if applicable for the platform
    """
    return _core_.PyApp_SetClassName(*args, **kwargs)

def SetEvtHandlerEnabled(*args, **kwargs):
    """SetEvtHandlerEnabled(self, bool enabled)"""
    return _core_.EvtHandler_SetEvtHandlerEnabled(*args, **kwargs)

def SetExitOnFrameDelete(*args, **kwargs):
    """
    SetExitOnFrameDelete(self, bool flag)
    Control the exit behaviour: by default, the program will exit the main
    loop (and so, usually, terminate) when the last top-level program
    window is deleted.  Beware that if you disable this behaviour (with
    SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop()
    explicitly from somewhere.
    """
    return _core_.PyApp_SetExitOnFrameDelete(*args, **kwargs)

def SetNativeTheme(*args, **kwargs):
    """
    SetNativeTheme(self, String theme) -> bool
    Change the theme used by the application, return true on success.
    """
    return _core_.PyApp_SetNativeTheme(*args, **kwargs)

def SetNextHandler(*args, **kwargs):
    """SetNextHandler(self, EvtHandler handler)"""
    return _core_.EvtHandler_SetNextHandler(*args, **kwargs)

def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
    """
    Set the title, position and/or size of the output window if
    the stdio has been redirected.  This should be called before
    any output would cause the output window to be created.
    """
    if self.stdioWin:
        if title is not None:
            self.stdioWin.title = title
        if pos is not None:
            self.stdioWin.pos = pos
        if size is not None:
            self.stdioWin.size = size

def SetPreviousHandler(*args, **kwargs):
    """SetPreviousHandler(self, EvtHandler handler)"""
    return _core_.EvtHandler_SetPreviousHandler(*args, **kwargs)

def SetPrintMode(*args, **kwargs):
    """SetPrintMode(self, int mode)"""
    return _core_.PyApp_SetPrintMode(*args, **kwargs)

def SetTopWindow(self, frame):
    """Set the \"main\" top level window"""
    if self.stdioWin:
        self.stdioWin.SetParent(frame)
    wx.PyApp.SetTopWindow(self, frame)

def SetUseBestVisual(*args, **kwargs):
    """
    SetUseBestVisual(self, bool flag, bool forceTrueColour=False)
    Set whether the app should try to use the best available visual on
    systems where more than one is available, (Sun, SGI, XFree86 4, etc.)
    """
    return _core_.PyApp_SetUseBestVisual(*args, **kwargs)

def SetVendorDisplayName(*args, **kwargs):
    """
    SetVendorDisplayName(self, String name)
    Set the vendor display name.  The display name is shown in
    titles/reports/dialogs to the user, while the vendor name is used in
    some areas such as wxConfig, wxStandardPaths, etc.
    """
    return _core_.PyApp_SetVendorDisplayName(*args, **kwargs)

def SetVendorName(*args, **kwargs):
    """
    SetVendorName(self, String name)
    Set the application's vendor name. This value may be used
    automatically by `wx.Config` and such.
    """
    return _core_.PyApp_SetVendorName(*args, **kwargs)

def SuspendProcessingOfPendingEvents(*args, **kwargs):
    """
    SuspendProcessingOfPendingEvents(self)
    Temporarily suspends the processing of pending events.
    """
    return _core_.PyApp_SuspendProcessingOfPendingEvents(*args, **kwargs)

def Unbind(self, event, source=None, id=wx.ID_ANY, id2=wx.ID_ANY, handler=None):
    """
    Disconnects the event handler binding for event from self.
    Returns True if successful.
    """
    if source is not None:
        id  = source.GetId()
    return event.Unbind(self, id, id2, handler)              

def Unlink(*args, **kwargs):
    """Unlink(self)"""
    return _core_.EvtHandler_Unlink(*args, **kwargs)

def WakeUpIdle(*args, **kwargs):
    """
    WakeUpIdle(self)
    Make sure that idle events are sent again.
    :see: `wx.WakeUpIdle`
    """
    return _core_.PyApp_WakeUpIdle(*args, **kwargs)

def Yield(*args, **kwargs):
    """
    Yield(self, bool onlyIfNeeded=False) -> bool
    Process all currently pending events right now, instead of waiting
    until return to the event loop.  It is an error to call ``Yield``
    recursively unless the value of ``onlyIfNeeded`` is True.
    :warning: This function is dangerous as it can lead to unexpected
          reentrancies (i.e. when called from an event handler it may
          result in calling the same event handler again), use with
          extreme care or, better, don't use at all!
    :see: `wx.Yield`, `wx.YieldIfNeeded`, `wx.SafeYield`
    """
    return _core_.PyApp_Yield(*args, **kwargs)