wxPython 4.3.2__cp315-cp315-win_amd64.whl

wx/include/wxPython/wxpy_api.h

@@ -0,0 +1,418 @@
+//--------------------------------------------------------------------------
+// Name:        wxpy_api.h
+// Purpose:     Some utility functions and such that can be used in other
+//              snippets of C++ code to help reduce complexity, etc.  They
+//              are all either macros, inline functions, or functions that
+//              are exported from the core extension module.
+//
+// Author:      Robin Dunn
+//
+// Created:     19-Nov-2010
+// Copyright:   (c) 2010-2020 by Total Control Software
+// Licence:     wxWindows license
+//--------------------------------------------------------------------------
+
+#ifndef _WXPY_API_H
+#define _WXPY_API_H
+
+#if defined(__APPLE__)
+    // When it's possible that we're building universal binaries with both
+    // 32-bit and 64-bit architectures then these need to be undef'ed because
+    // otherwise the values set by configure could conflict with those set
+    // based on runtime flags in Python's headers.  We also do something
+    // similar in wx/platform.h so it's okay to undef them now because they
+    // will be defined again soon.
+    #undef SIZEOF_VOID_P
+    #undef SIZEOF_LONG
+    #undef SIZEOF_SIZE_T
+#endif
+
+#if defined(__GNUC__)
+    // Turn off the warning about converting string literals to char*
+    // TODO: fix these the right way...
+    #pragma GCC diagnostic ignored "-Wwrite-strings"
+#endif
+
+#ifdef _MSC_VER
+    #pragma warning(disable:4800)
+    #pragma warning(disable:4190)
+#endif
+
+#include <wx/wx.h>
+
+//--------------------------------------------------------------------------
+// The API items that can be inline functions or macros.
+// These are made available simply by #including this header file.
+//--------------------------------------------------------------------------
+
+typedef PyGILState_STATE wxPyBlock_t;
+#define wxPyBlock_t_default PyGILState_UNLOCKED
+
+typedef unsigned char  byte;
+typedef unsigned char* buffer;
+typedef unsigned long  ulong;
+
+
+// Convert a wxString to a Python string (actually a PyUnicode object).
+// Assumes that the GIL has already been acquired.
+inline PyObject* wx2PyString(const wxString& str) {
+    return PyUnicode_FromWideChar(str.wc_str(), str.length());
+}
+
+
+// Calls from Python to wxWidgets code should be wrapped in calls to these
+// functions:
+inline PyThreadState* wxPyBeginAllowThreads() {
+    PyThreadState* saved = PyEval_SaveThread();  // Like Py_BEGIN_ALLOW_THREADS;
+    return saved;
+}
+
+inline void wxPyEndAllowThreads(PyThreadState* saved) {
+    PyEval_RestoreThread(saved);   // Like Py_END_ALLOW_THREADS;
+}
+
+
+
+
+// A macro that will help to execute simple statements wrapped in
+// StartBlock/EndBlockThreads calls
+#define wxPyBLOCK_THREADS(stmt) \
+    { wxPyThreadBlocker _blocker; stmt; }
+
+// Raise any exception with a string value  (blocking threads)
+#define wxPyErr_SetString(err, str) \
+    wxPyBLOCK_THREADS(PyErr_SetString(err, str))
+
+
+// Raise NotImplemented exceptions
+#define wxPyRaiseNotImplemented() \
+    wxPyBLOCK_THREADS( PyErr_SetNone(PyExc_NotImplementedError) )
+
+
+#define wxPyRaiseNotImplementedMsg(msg) \
+    wxPyBLOCK_THREADS( PyErr_SetString(PyExc_NotImplementedError, msg) );
+
+
+// A convenience macro for properly returning Py_None
+//#define RETURN_NONE()    { Py_INCREF(Py_None); return Py_None; }
+#define RETURN_NONE()    { wxPyBLOCK_THREADS(Py_INCREF(Py_None)); return Py_None; }
+
+
+
+
+// Macros to work around some of the differences in the Python 3 API
+#if PY_MAJOR_VERSION >= 3
+    #define wxPyInt_Check            PyLong_Check
+    #define wxPyInt_AsLong           PyLong_AsLong
+    #define wxPyInt_AS_LONG          PyLong_AS_LONG
+    #define wxPyInt_AsSize_t         PyLong_AsSize_t
+    #define wxPyInt_AsSsize_t        PyLong_AsSsize_t
+    #define wxPyInt_AsUnsignedLong   PyLong_AsUnsignedLong
+    #define wxPyInt_FromLong         PyLong_FromLong
+    #define wxPyInt_FromSize_t       PyLong_FromSize_t
+    #define wxPyInt_FromSsize_t      PyLong_FromSsize_t
+    #define wxPyInt_FromUnsignedLong PyLong_FromUnsignedLong
+    #define wxPyNumber_Int           PyNumber_Long
+#else
+    #define wxPyInt_Check            PyInt_Check
+    #define wxPyInt_AsLong           PyInt_AsLong
+    #define wxPyInt_AS_LONG          PyInt_AS_LONG
+    #define wxPyInt_AsLong           PyInt_AsLong
+    #define wxPyInt_AsSize_t(x)      static_cast<size_t>(PyInt_AsUnsignedLongLongMask(x))
+    #define wxPyInt_AsSsize_t        PyInt_AsSsize_t
+    #define wxPyInt_AsUnsignedLong   PyInt_AsUnsignedLongMask
+    #define wxPyInt_FromLong         PyInt_FromLong
+    #define wxPyInt_FromSize_t       PyInt_FromSize_t
+    #define wxPyInt_FromSsize_t      PyInt_FromSsize_t
+    #define wxPyInt_FromUnsignedLong PyInt_FromSize_t
+    #define wxPyNumber_Int           PyNumber_Int
+#endif
+
+inline
+Py_ssize_t wxPyUnicode_AsWideChar(PyObject* unicode, wchar_t* w, Py_ssize_t size)
+{
+    // GIL should already be held
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_AsWideChar(unicode, w, size);
+#else
+    return PyUnicode_AsWideChar((PyUnicodeObject*)unicode, w, size);
+#endif
+}
+
+
+
+//--------------------------------------------------------------------------
+// These are the API items whose implementation can not or should not be
+// inline functions or macros. The implementations will instead be accessed
+// via a structure of function pointers that is exported from the wx._core
+// extension module. See wxpy_api.sip for the implementations.
+//--------------------------------------------------------------------------
+
+struct wxPyAPI {
+    wxString      (*p_Py2wxString)(PyObject* source);
+    PyObject*     (*p_wxPyConstructObject)(void* ptr, const wxString& className, bool setThisOwn);
+    wxPyBlock_t   (*p_wxPyBeginBlockThreads)();
+    void          (*p_wxPyEndBlockThreads)(wxPyBlock_t blocked);
+    bool          (*p_wxPyWrappedPtr_Check)(PyObject* obj);
+    bool          (*p_wxPyConvertWrappedPtr)(PyObject* obj, void **ptr, const wxString& className);
+    bool          (*p_wxPy2int_seq_helper)(PyObject* source, int* i1, int* i2);
+    bool          (*p_wxPy4int_seq_helper)(PyObject* source, int* i1, int* i2, int* i3, int* i4);
+    bool          (*p_wxPyWrappedPtr_TypeCheck)(PyObject* obj, const wxString& className);
+    wxVariant     (*p_wxVariant_in_helper)(PyObject* obj);
+    PyObject*     (*p_wxVariant_out_helper)(const wxVariant& value);
+    bool          (*p_wxPyCheckForApp)(bool raiseException);
+    PyObject*     (*p_wxPyMakeBuffer)(void* ptr, Py_ssize_t len, bool readOnly);
+    bool          (*p_wxPyNumberSequenceCheck)(PyObject* obj, int reqLength);
+    void*         (*p_wxPyGetCppPtr)(sipSimpleWrapper* sipPyObj);
+    PyObject*     (*p_wxPyMethod_Self)(PyObject* method);
+    void          (*p_wxPyReinitializeModules)();
+
+    int           (*p_wxPyDateTime_Check)(PyObject *obj);
+    int           (*p_wxPyDate_Check)(PyObject *obj);
+    wxDateTime*   (*p_wxPyDateTime_ToWxDateTime)(PyObject *obj);
+    wxDateTime*   (*p_wxPyDate_ToWxDateTime)(PyObject *obj);
+
+    bool          (*p_wxPyCheckNumberSequence)(PyObject *obj);
+    bool          (*p_wxPyCheckStringSequence)(PyObject *obj);
+    // Always add new items here at the end.
+};
+
+
+
+inline wxPyAPI* wxPyGetAPIPtr()
+{
+    static wxPyAPI* wxPyAPIPtr = NULL;
+
+    if (wxPyAPIPtr == NULL) {
+        PyGILState_STATE state = PyGILState_Ensure();
+        wxPyAPIPtr = (wxPyAPI*)PyCapsule_Import("wx._wxPyAPI", 0);
+        // uncomment if needed for debugging
+        //if (PyErr_Occurred()) { PyErr_Print(); }
+        //wxASSERT_MSG(wxPyAPIPtr != NULL, wxT("wxPyAPIPtr is NULL!!!"));
+        PyGILState_Release(state);
+    }
+
+    return wxPyAPIPtr;
+}
+
+//--------------------------------------------------------------------------
+// Inline wrappers which call the functions in the API structure
+
+// Convert a PyObject to a wxString
+// Assumes that the GIL has already been acquired.
+inline wxString Py2wxString(PyObject* source)
+    { return wxPyGetAPIPtr()->p_Py2wxString(source); }
+
+
+// Create a PyObject of the requested type from a void* and a class name.
+// Assumes that the GIL has already been acquired.
+inline PyObject* wxPyConstructObject(void* ptr, const wxString& className, bool setThisOwn=false)
+    { return wxPyGetAPIPtr()->p_wxPyConstructObject(ptr, className, setThisOwn); }
+
+
+// Check if a PyObject is a wrapped type
+inline bool wxPyWrappedPtr_Check(PyObject* obj)
+    { return wxPyGetAPIPtr()->p_wxPyWrappedPtr_Check(obj); }
+
+// Check if a PyObject is a specific wrapped type (or a subclass)
+inline bool wxPyWrappedPtr_TypeCheck(PyObject* obj, const wxString& className)
+    { return wxPyGetAPIPtr()->p_wxPyWrappedPtr_TypeCheck(obj, className); }
+
+
+// Convert a wrapped SIP object to its C++ pointer, ensuring that it is of the expected type
+inline bool wxPyConvertWrappedPtr(PyObject* obj, void **ptr, const wxString& className)
+    { return wxPyGetAPIPtr()->p_wxPyConvertWrappedPtr(obj, ptr, className); }
+
+
+// Calls from wxWindows back to Python code, or even any PyObject
+// manipulations, PyDECREF's and etc. should be wrapped in calls to these functions:
+inline wxPyBlock_t wxPyBeginBlockThreads()
+    { return wxPyGetAPIPtr()->p_wxPyBeginBlockThreads(); }
+
+inline void wxPyEndBlockThreads(wxPyBlock_t blocked)
+    { wxPyGetAPIPtr()->p_wxPyEndBlockThreads(blocked); }
+
+
+
+// A helper for converting a 2 element sequence to a pair of integers
+inline bool wxPy2int_seq_helper(PyObject* source, int* i1, int* i2)
+    { return wxPyGetAPIPtr()->p_wxPy2int_seq_helper(source, i1, i2); }
+
+// A helper for converting a 4 element sequence to a set of integers
+inline bool wxPy4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4)
+    { return wxPyGetAPIPtr()->p_wxPy4int_seq_helper(source, i1, i2, i3, i4); }
+
+
+// Convert a PyObject to a wxVariant
+inline wxVariant wxVariant_in_helper(PyObject* obj)
+    { return wxPyGetAPIPtr()->p_wxVariant_in_helper(obj); }
+
+// Convert a wxVariant to a PyObject
+inline PyObject* wxVariant_out_helper(const wxVariant& value)
+    { return wxPyGetAPIPtr()->p_wxVariant_out_helper(value); }
+
+
+// Check if a wx.App object has been created
+inline bool wxPyCheckForApp(bool raiseException=true)
+    { return wxPyGetAPIPtr()->p_wxPyCheckForApp(raiseException); }
+
+
+// Create a buffer object from a pointer and size
+inline PyObject* wxPyMakeBuffer(void* ptr, Py_ssize_t len, bool readOnly=false)
+    { return wxPyGetAPIPtr()->p_wxPyMakeBuffer(ptr, len, readOnly); }
+
+// Check if an object is a sequence of numbers
+inline bool wxPyNumberSequenceCheck(PyObject* obj, int reqLength=-1)
+    { return wxPyGetAPIPtr()->p_wxPyNumberSequenceCheck(obj, reqLength); }
+
+
+inline void* wxPyGetCppPtr(sipSimpleWrapper* sipPyObj)
+    { return wxPyGetAPIPtr()->p_wxPyGetCppPtr(sipPyObj); }
+
+inline PyObject* wxPyMethod_Self(PyObject* method)
+    { return wxPyGetAPIPtr()->p_wxPyMethod_Self(method); }
+
+
+inline void wxPyReinitializeModules()
+    { return wxPyGetAPIPtr()->p_wxPyReinitializeModules(); }
+
+
+
+inline int wxPyDateTime_Check(PyObject *obj)
+    { return wxPyGetAPIPtr()->p_wxPyDateTime_Check(obj); }
+
+inline int wxPyDate_Check(PyObject *obj)
+    { return wxPyGetAPIPtr()->p_wxPyDate_Check(obj); }
+
+inline wxDateTime* wxPyDateTime_ToWxDateTime(PyObject *obj)
+    { return wxPyGetAPIPtr()->p_wxPyDateTime_ToWxDateTime(obj); }
+
+inline wxDateTime* wxPyDate_ToWxDateTime(PyObject *obj)
+    { return wxPyGetAPIPtr()->p_wxPyDate_ToWxDateTime(obj); }
+
+
+inline bool wxPyCheckNumberSequence(PyObject *obj)
+{
+    return wxPyGetAPIPtr()->p_wxPyCheckNumberSequence(obj);
+}
+
+inline bool wxPyCheckStringSequence(PyObject *obj)
+{
+    return wxPyGetAPIPtr()->p_wxPyCheckStringSequence(obj);
+}
+
+//--------------------------------------------------------------------------
+// Convenience helper for RAII-style thread blocking
+
+class wxPyThreadBlocker {
+public:
+    explicit wxPyThreadBlocker(bool block=true)
+        :   m_oldstate(block ?  wxPyBeginBlockThreads() : wxPyBlock_t_default),
+            m_block(block)
+    { }
+
+    ~wxPyThreadBlocker() {
+        if (m_block) {
+            wxPyEndBlockThreads(m_oldstate);
+        }
+    }
+
+private:
+    void operator=(const wxPyThreadBlocker&);
+    explicit wxPyThreadBlocker(const wxPyThreadBlocker&);
+    wxPyBlock_t m_oldstate;
+    bool        m_block;
+};
+
+
+//--------------------------------------------------------------------------
+// helper template to make common code for all of the various user data owners
+
+template<typename Base>
+class wxPyUserDataHelper : public Base {
+public:
+    explicit wxPyUserDataHelper(PyObject* obj = NULL)
+        : m_obj(obj ? obj : Py_None)
+    {
+        wxPyThreadBlocker blocker;
+        Py_INCREF(m_obj);
+    }
+
+    ~wxPyUserDataHelper()
+    {   // normally the derived class does the clean up, or deliberately leaks
+        // by setting m_obj to 0, but if not then do it here.
+        if (m_obj) {
+            wxPyThreadBlocker blocker;
+            Py_DECREF(m_obj);
+            m_obj = 0;
+        }
+    }
+
+    // Return Value: New reference
+    PyObject* GetData() const {
+        wxPyThreadBlocker blocker;
+        Py_INCREF(m_obj);
+        return m_obj;
+    }
+
+    // Return Value: Borrowed reference
+    PyObject* BorrowData() const {
+        return m_obj;
+    }
+
+    void SetData(PyObject* obj) {
+        if (obj != m_obj) {
+            wxPyThreadBlocker blocker;
+            Py_DECREF(m_obj);
+            m_obj = obj ? obj : Py_None;
+            Py_INCREF(m_obj);
+        }
+    }
+
+    // Return the object in udata or None if udata is null
+    // Return Value: New reference
+    static PyObject* SafeGetData(wxPyUserDataHelper<Base>* udata) {
+        wxPyThreadBlocker blocker;
+        PyObject* obj = udata ? udata->BorrowData() : Py_None;
+        Py_INCREF(obj);
+        return obj;
+    }
+
+    // Set the m_obj to null, this should only be used during clean up, when
+    // the object should be leaked.
+    // Calling any other methods on this object is then undefined behaviour
+    void ReleaseDataDuringCleanup()
+    {
+        m_obj = 0;
+    }
+
+private:
+    PyObject* m_obj;
+};
+
+
+
+// A wxClientData that holds a reference to a Python object
+class wxPyClientData : public wxPyUserDataHelper<wxClientData>
+{
+public:
+    wxPyClientData(PyObject* obj = NULL)
+        : wxPyUserDataHelper<wxClientData>(obj)
+    { }
+};
+
+
+
+
+// A wxObject object that holds a reference to a Python object
+class wxPyUserData : public wxPyUserDataHelper<wxObject>
+{
+public:
+    wxPyUserData(PyObject* obj = NULL)
+        : wxPyUserDataHelper<wxObject>(obj)
+    { }
+};
+
+
+//--------------------------------------------------------------------------
+#endif

wx/lib/CDate.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+# Name:         CDate.py
+# Purpose:      Date and Calendar classes
+#
+# Author:       Lorne White (email: lwhite1@planet.eon.net)
+#
+# Created:
+# Version       0.2 08-Nov-1999
+# Licence:      wxWindows license
+# Tags:         phoenix-port, py3-port, documented, unittest
+#----------------------------------------------------------------------------
+# Updated:      01-Dec-2004
+# Action:       Cast the year variable to an integer under the Date Class
+# Reason:       When the year was compared in the isleap() function, if it was
+#               in a string format, then an error was raised.
+#
+"""Date and calendar classes and date utitility methods."""
+import time
+
+# I18N
+import wx
+_ = wx.GetTranslation
+
+
+Month = {0: None,
+         1: _('January'), 2: _('February'), 3: _('March'),
+         4: _('April'), 5: _('May'), 6: _('June'),
+         7: _('July'), 8: _('August'), 9: _('September'),
+         10: _('October'), 11: _('November'), 12: _('December')}
+
+# Number of days per month (except for February in leap years)
+mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+# Full and abbreviated names of weekdays
+day_name = [_('Sunday'), _('Monday'), _('Tuesday'), _('Wednesday'),
+            _('Thursday'), _('Friday'), _('Saturday')]
+day_abbr = [_('Sun'), _('Mon'), _('Tue'), _('Wed'), _('Thu'), _('Fri'),
+            _('Sat')]
+
+
+def leapdays(y1, y2):
+    """
+    Return number of leap years in range [y1, y2]
+    Assume y1 <= y2 and no funny (non-leap century) years
+    """
+    return (y2 + 3) // 4 - (y1 + 3) // 4
+
+
+def isleap(year):
+    """Verify if year is a leap year.
+
+    :param int `year`: the year to check
+    :return: True or False
+
+    """
+    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
+
+
+def FillDate(val):
+    s = str(val)
+    if len(s) < 2:
+        s = '0' + s
+    return s
+
+
+def julianDay(year, month, day):
+    """Convert a date to Julian
+
+    :param int `year`: the year
+    :param int `month`: the month
+    :param int `day`: the day
+
+    :returns: the julian date number
+
+    """
+    b = 0
+    if month > 12:
+        year = year + month // 12
+        month = month % 12
+    elif month < 1:
+        month = -month
+        year = year - month // 12 - 1
+        month = 12 - month % 12
+    if year > 0:
+        yearCorr = 0
+    else:
+        yearCorr = 3
+    if month < 3:
+        year = year - 1
+        month = month + 12
+    if year * 10000 + month * 100 + day > 15821014:
+        b = 2 - year // 100 + year // 400
+    return (1461 * year - yearCorr) // 4 + 306001 * (month + 1) // 10000 + day + 1720994 + b
+
+
+def TodayDay():
+    date = time.localtime(time.time())
+    year = date[0]
+    month = date[1]
+    day = date[2]
+    julian = julianDay(year, month, day)
+    daywk = dayOfWeek(julian)
+    daywk = day_name[daywk]
+    return(daywk)
+
+
+def FormatDay(value):
+    date = FromFormat(value)
+    daywk = DateCalc.dayOfWeek(date)
+    daywk = day_name[daywk]
+    return(daywk)
+
+
+def FromJulian(julian):
+    """Convert a julian date
+
+    :param int `julian`: the julian date to convert
+
+    :returns: year, month day as integers
+
+    """
+    if (julian < 2299160):
+        b = julian + 1525
+    else:
+        alpha = (4 * julian - 7468861) // 146097
+        b = julian + 1526 + alpha - alpha // 4
+    c = (20 * b - 2442) // 7305
+    d = 1461 * c // 4
+    e = 10000 * (b - d) // 306001
+    day = int(b - d - 306001 * e // 10000)
+    if e < 14:
+        month = int(e - 1)
+    else:
+        month = int(e - 13)
+    if month > 2:
+        year = c - 4716
+    else:
+        year = c - 4715
+    year = int(year)
+    return year, month, day
+
+
+def dayOfWeek(julian):
+    """Get day of week from a julian day
+
+    :param `julian`: the julian day
+
+    :returns: the day of week as an integer and Monday = 1
+
+    """
+    return int((julian + 1) % 7)
+
+
+def daysPerMonth(month, year):
+    """Get the number of days for the month.
+
+    :param int `month`: the month
+    :param int `year`: the year
+
+    :returns: the number of days in the requested month
+
+    """
+    ndays = mdays[month] + (month == 2 and isleap(year))
+    return ndays
+
+
+class now(object):
+    """A now date class"""
+    def __init__(self):
+        """
+        Default class constructor.
+        """
+        self.date = time.localtime(time.time())
+        self.year = self.date[0]
+        self.month = self.date[1]
+        self.day = self.date[2]
+        self.hour = self.date[3]
+        self.minutes = self.date[4]
+        self.secondes = self.date[5]
+        self.day_of_week = self.date[6]
+
+        self.julian = julianDay(self.year, self.month, self.day)
+
+
+class Date(object):
+    """A date class"""
+    def __init__(self, year, month, day):
+        """
+        Default class constructor.
+
+        :param `year`: the year as an int or string
+        :param `month`: the month as an int or string
+        :param `day`: the day as an int or string
+
+        """
+        self.julian = julianDay(year, month, day)
+        self.month = int(month)
+        self.year = int(year)
+        self.day = int(day)
+        self.day_of_week = dayOfWeek(self.julian)
+        self.days_in_month = daysPerMonth(self.month, self.year)

wx/lib/ClickableHtmlWindow.py

@@ -0,0 +1,57 @@
+# 12/01/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace. Not tested though.
+#
+# 12/17/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Removed wx prefix from class name,
+#   updated reverse renamer
+#
+
+"""
+sorry no documentation...
+Christopher J. Fama
+"""
+
+
+import  wx
+import  wx.html as  html
+
+class PyClickableHtmlWindow(html.HtmlWindow):
+    """
+    Class for a :class:`wx.html.HtmlWindow` which responds to clicks on
+    links by opening a browser pointed at that link, and to shift-clicks
+    by copying the link to the clipboard.
+    """
+    def __init__(self,parent,ID,**kw):
+        html.HtmlWindow.__init__(self, parent, ID, **kw)
+
+    def OnLinkClicked(self,link):
+        self.link = wx.TextDataObject(link.GetHref())
+        if link.GetEvent().ShiftDown():
+            if wx.TheClipboard.Open():
+                wx.TheClipboard.SetData(self.link)
+                wx.TheClipboard.Close()
+            else:
+                dlg = wx.MessageDialog(self,"Couldn't open clipboard!\n",wx.OK)
+                wx.Bell()
+                dlg.ShowModal()
+                dlg.Destroy()
+        else:
+            if 0:  # Chris's original code...
+                if sys.platform not in ["windows",'nt']           :
+                    #TODO: A MORE APPROPRIATE COMMAND LINE FOR Linux
+                    #[or rather, non-Windows platforms... as of writing,
+                    #this MEANS  Linux, until wxPython for wxMac comes along...]
+                    command = "/usr/bin/netscape"
+                else:
+                    command = "start"
+                command = "%s \"%s\"" % (command,
+                                         self.link.GetText ())
+                os.system (command)
+
+            else:  # My alternative
+                import webbrowser
+                webbrowser.open(link.GetHref())
+
+