X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ec873c943d71f0d5f13e3398557071448cda6c23..a4027e74873007e3430af3bd77019bcab76f6c04:/wxPython/src/_core_ex.py diff --git a/wxPython/src/_core_ex.py b/wxPython/src/_core_ex.py deleted file mode 100644 index bd9ecf759e..0000000000 --- a/wxPython/src/_core_ex.py +++ /dev/null @@ -1,322 +0,0 @@ -#---------------------------------------------------------------------------- - -# Use Python's bool constants if available, make some if not -try: - True -except NameError: - __builtins__.True = 1==1 - __builtins__.False = 1==0 - def bool(value): return not not value - __builtins__.bool = bool - - - -# workarounds for bad wxRTTI names -__wxPyPtrTypeMap['wxGauge95'] = 'wxGauge' -__wxPyPtrTypeMap['wxSlider95'] = 'wxSlider' -__wxPyPtrTypeMap['wxStatusBar95'] = 'wxStatusBar' - - -#---------------------------------------------------------------------------- -# Load version numbers from __version__... Ensure that major and minor -# versions are the same for both wxPython and wxWidgets. - -from __version__ import * -__version__ = VERSION_STRING - -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/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 - -#---------------------------------------------------------------------------- - -class PyDeadObjectError(AttributeError): - pass - -class _wxPyDeadObject(object): - """ - Instances of wx objects that are OOR capable will have their __class__ - changed to this class when the C++ object is deleted. This should help - prevent crashes due to referencing a bogus C++ pointer. - """ - reprStr = "wxPython wrapper for DELETED %s object! (The C++ object no longer exists.)" - attrStr = "The C++ part of the %s object has been deleted, attribute access no longer allowed." - - def __repr__(self): - if not hasattr(self, "_name"): - self._name = "[unknown]" - return self.reprStr % self._name - - def __getattr__(self, *args): - if not hasattr(self, "_name"): - self._name = "[unknown]" - raise PyDeadObjectError(self.attrStr % self._name) - - def __nonzero__(self): - return 0 - - - -class PyUnbornObjectError(AttributeError): - pass - -class _wxPyUnbornObject(object): - """ - 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 - exception will be raised if they are used before the C++ instance - is ready. - """ - - reprStr = "wxPython wrapper for UNBORN object! (The C++ object is not initialized yet.)" - attrStr = "The C++ part of this object has not been initialized, attribute access not allowed." - - def __repr__(self): - #if not hasattr(self, "_name"): - # self._name = "[unknown]" - return self.reprStr #% self._name - - def __getattr__(self, *args): - #if not hasattr(self, "_name"): - # self._name = "[unknown]" - raise PyUnbornObjectError(self.attrStr) # % self._name ) - - def __nonzero__(self): - return 0 - - -#---------------------------------------------------------------------------- - -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. Any extra positional or - keyword args are passed on to the callable when it is called. - - :see: `wx.CallLater` - """ - app = wx.GetApp() - assert app is not None, 'No wx.App created yet' - - 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(app._CallAfterId) - evt.callable = callable - evt.args = args - evt.kw = kw - wx.PostEvent(app, evt) - -#---------------------------------------------------------------------------- - - -class CallLater: - """ - 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. - - 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.CallLater - object. - - :see: `wx.CallAfter` - """ - def __init__(self, millis, callable, *args, **kwargs): - self.millis = millis - self.callable = callable - self.SetArgs(*args, **kwargs) - self.runCount = 0 - self.running = False - self.hasRun = False - self.result = None - self.timer = None - self.Start() - - def __del__(self): - self.Stop() - - - def Start(self, millis=None, *args, **kwargs): - """ - (Re)start the timer - """ - self.hasRun = False - if millis is not None: - self.millis = millis - if args or kwargs: - self.SetArgs(*args, **kwargs) - self.Stop() - self.timer = wx.PyTimer(self.Notify) - self.timer.Start(self.millis, wx.TIMER_ONE_SHOT) - self.running = True - Restart = Start - - - def Stop(self): - """ - Stop and destroy the timer. - """ - if self.timer is not None: - self.timer.Stop() - self.timer = None - - - def GetInterval(self): - if self.timer is not None: - return self.timer.GetInterval() - else: - return 0 - - - def IsRunning(self): - return self.timer is not None and self.timer.IsRunning() - - - def SetArgs(self, *args, **kwargs): - """ - (Re)set the args passed to the callable object. This is - useful in conjunction with Restart if you want to schedule a - new call to the same callable object but with different - parameters. - """ - self.args = args - self.kwargs = kwargs - - - def HasRun(self): - return self.hasRun - - def GetResult(self): - return self.result - - def Notify(self): - """ - The timer has expired so call the callable. - """ - if self.callable and getattr(self.callable, 'im_self', True): - self.runCount += 1 - self.running = False - self.result = self.callable(*self.args, **self.kwargs) - self.hasRun = True - if not self.running: - # 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 -# of the docs by filtering out the zillions of constants, EVT objects, -# and etc that don't make much sense by themselves, but are instead -# documented (or will be) as part of the classes/functions/methods -# where they should be used. - -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 * - -#---------------------------------------------------------------------------- -#----------------------------------------------------------------------------