X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5b29df3fee8df15257347a9df63a390128374b03..6caa0f5cd18fe9fb39c207d5f31fa5633479a822:/wxPython/src/_core_ex.py?ds=inline diff --git a/wxPython/src/_core_ex.py b/wxPython/src/_core_ex.py index fb51c89d6f..bd9ecf759e 100644 --- a/wxPython/src/_core_ex.py +++ b/wxPython/src/_core_ex.py @@ -19,16 +19,66 @@ __wxPyPtrTypeMap['wxStatusBar95'] = 'wxStatusBar' #---------------------------------------------------------------------------- # Load version numbers from __version__... Ensure that major and minor -# versions are the same for both wxPython and wxWindows. +# versions are the same for both wxPython and wxWidgets. from __version__ import * __version__ = VERSION_STRING -assert MAJOR_VERSION == _core.MAJOR_VERSION, "wxPython/wxWindows version mismatch" -assert MINOR_VERSION == _core.MINOR_VERSION, "wxPython/wxWindows version mismatch" -if RELEASE_VERSION != _core.RELEASE_VERSION: +assert MAJOR_VERSION == _core_.MAJOR_VERSION, "wxPython/wxWidgets version mismatch" +assert MINOR_VERSION == _core_.MINOR_VERSION, "wxPython/wxWidgets version mismatch" +if RELEASE_VERSION != _core_.RELEASE_VERSION: import warnings - warnings.warn("wxPython/wxWindows release number mismatch") + warnings.warn("wxPython/wxWidgets release number mismatch") + + +def version(): + """Returns a string containing version and port info""" + ctype = wx.USE_UNICODE and 'unicode' or 'ansi' + if wx.Platform == '__WXMSW__': + port = 'msw' + elif wx.Platform == '__WXMAC__': + port = 'mac' + elif wx.Platform == '__WXGTK__': + port = 'gtk' + if 'gtk2' in wx.PlatformInfo: + port = 'gtk2' + else: + port = '?' + + return "%s (%s-%s)" % (wx.VERSION_STRING, port, ctype) + + +#---------------------------------------------------------------------------- + +# Set wxPython's default string<-->unicode conversion encoding from +# the locale, but only if Python's default hasn't been changed. (We +# assume that if the user has customized it already then that is the +# encoding we need to use as well.) +# +# The encoding selected here is used when string or unicode objects +# need to be converted in order to pass them to wxWidgets. Please be +# aware that the default encoding within the same locale may be +# slightly different on different platforms. For example, please see +# http://www.alanwood.net/demos/charsetdiffs.html for differences +# between the common latin/roman encodings. + +default = _sys.getdefaultencoding() +if default == 'ascii': + import locale + import codecs + try: + if hasattr(locale, 'getpreferredencoding'): + default = locale.getpreferredencoding() + else: + default = locale.getdefaultlocale()[1] + codecs.lookup(default) + except (ValueError, LookupError, TypeError): + default = _sys.getdefaultencoding() + del locale + del codecs +if default: + wx.SetDefaultPyEncoding(default) +del default #---------------------------------------------------------------------------- @@ -64,7 +114,7 @@ class PyUnbornObjectError(AttributeError): class _wxPyUnbornObject(object): """ - Some stock objects are created when the wx.core module is + Some stock objects are created when the wx._core module is imported, but their C++ instance is not created until the wx.App object is created and initialized. These object instances will temporarily have their __class__ changed to this class so an @@ -90,46 +140,48 @@ class _wxPyUnbornObject(object): #---------------------------------------------------------------------------- -_wxPyCallAfterId = None def CallAfter(callable, *args, **kw): """ Call the specified function after the current and pending event handlers have been completed. This is also good for making GUI - method calls from non-GUI threads. + method calls from non-GUI threads. Any extra positional or + keyword args are passed on to the callable when it is called. + + :see: `wx.CallLater` """ app = wx.GetApp() - assert app, 'No wxApp created yet' + assert app is not None, 'No wx.App created yet' - global _wxPyCallAfterId - if _wxPyCallAfterId is None: - _wxPyCallAfterId = wx.NewEventType() - app.Connect(-1, -1, _wxPyCallAfterId, - lambda event: event.callable(*event.args, **event.kw) ) + if not hasattr(app, "_CallAfterId"): + app._CallAfterId = wx.NewEventType() + app.Connect(-1, -1, app._CallAfterId, + lambda event: event.callable(*event.args, **event.kw) ) evt = wx.PyEvent() - evt.SetEventType(_wxPyCallAfterId) + evt.SetEventType(app._CallAfterId) evt.callable = callable evt.args = args evt.kw = kw wx.PostEvent(app, evt) - #---------------------------------------------------------------------------- -class FutureCall: +class CallLater: """ - A convenience class for wx.Timer, that calls the given callable + A convenience class for `wx.Timer`, that calls the given callable object once after the given amount of milliseconds, passing any positional or keyword args. The return value of the callable is - availbale after it has been run with the GetResult method. + availbale after it has been run with the `GetResult` method. If you don't need to get the return value or restart the timer then there is no need to hold a reference to this object. It will hold a reference to itself while the timer is running (the timer has a reference to self.Notify) but the cycle will be broken when - the timer completes, automatically cleaning up the wx.FutureCall + the timer completes, automatically cleaning up the wx.CallLater object. + + :see: `wx.CallAfter` """ def __init__(self, millis, callable, *args, **kwargs): self.millis = millis @@ -212,8 +264,13 @@ class FutureCall: # if it wasn't restarted, then cleanup wx.CallAfter(self.Stop) + Interval = property(GetInterval) + Result = property(GetResult) +class FutureCall(CallLater): + """A compatibility alias for `CallLater`.""" + #---------------------------------------------------------------------------- # Control which items in this module should be documented by epydoc. # We allow only classes and functions, which will help reduce the size @@ -222,29 +279,44 @@ class FutureCall: # documented (or will be) as part of the classes/functions/methods # where they should be used. -def __docfilter__(name): - import types - obj = globals().get(name, None) - if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]: - return False - if name.startswith('_') or name.endswith('Ptr') or name.startswith('EVT'): - return False - return True +class __DocFilter: + """ + A filter for epydoc that only allows non-Ptr classes and + functions, in order to reduce the clutter in the API docs. + """ + def __init__(self, globals): + self._globals = globals + + def __call__(self, name): + import types + obj = self._globals.get(name, None) + + # only document classes and function + if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]: + return False + + # skip other things that are private or will be documented as part of somethign else + if name.startswith('_') or name.startswith('EVT') or name.endswith('_swigregister') or name.endswith('Ptr') : + return False + + # skip functions that are duplicates of static functions in a class + if name.find('_') != -1: + cls = self._globals.get(name.split('_')[0], None) + methname = name.split('_')[1] + if hasattr(cls, methname) and type(getattr(cls, methname)) is types.FunctionType: + return False + + return True #---------------------------------------------------------------------------- #---------------------------------------------------------------------------- # Import other modules in this package that should show up in the # "core" wx namespace -from gdi import * -from windows import * -from controls import * -from misc import * - - -# Fixup the stock objects since they can't be used yet. (They will be -# restored in wx.PyApp.OnInit.) -_core._wxPyFixStockObjects() +from _gdi import * +from _windows import * +from _controls import * +from _misc import * #---------------------------------------------------------------------------- #----------------------------------------------------------------------------