except NameError:
__builtins__.True = 1==1
__builtins__.False = 1==0
+ def bool(value): return not not value
+ __builtins__.bool = bool
#----------------------------------------------------------------------------
# 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:
+ 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 _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
#----------------------------------------------------------------------------
-_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
# 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 *
-
-
-# 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 *
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff