wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/CDate.py

@@ -0,0 +1,202 @@
+# -*- 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."""
+from __future__ import division
+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())
+
+

wx/lib/activex.py

@@ -0,0 +1,178 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.activex
+# Purpose:     The 3rd (and hopefully final) implementation of an
+#              ActiveX container for wxPython.
+#
+# Author:      Robin Dunn
+#
+# Created:     5-June-2008
+# Copyright:   (c) 2008-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+
+
+"""
+This module provides a wx.Window that hosts ActiveX Controls using
+just the ctypes and comtypes packages.  This provides a light-weight
+COM implementation with full dynamic dispatch support.
+
+The only requirements are ctypes (included with Python 2.5 and
+available separately for earlier versions of Python) and the comtypes
+package, which is available from
+http://starship.python.net/crew/theller/comtypes/.  Be sure to get at
+least version 0.5, which at the time of this writing is only available
+from SVN.  You can fetch it with easy_install with a command like
+this:
+
+    easy_install http://svn.python.org/projects/ctypes/trunk/comtypes
+
+"""
+
+import wx
+import wx.msw
+
+import ctypes as ct
+import ctypes.wintypes as wt
+import comtypes
+import comtypes.client as cc
+import comtypes.hresult as hr
+
+import sys, os
+if not hasattr(sys, 'frozen'):
+    f = os.path.join(os.path.dirname(__file__), 'myole4ax.tlb')
+    cc.GetModule(f)
+from comtypes.gen import myole4ax
+
+
+kernel32 = ct.windll.kernel32
+user32 = ct.windll.user32
+atl = ct.windll.atl
+
+WS_CHILD        = 0x40000000
+WS_VISIBLE      = 0x10000000
+WS_CLIPCHILDREN = 0x2000000
+WS_CLIPSIBLINGS = 0x4000000
+CW_USEDEFAULT   = 0x80000000
+WM_KEYDOWN      = 256
+WM_DESTROY      = 2
+
+#------------------------------------------------------------------------------
+
+class ActiveXCtrl(wx.msw.PyAxBaseWindow):
+    """
+    A wx.Window for hosting ActiveX controls.  The COM interface of
+    the ActiveX control is accessible through the ctrl property of
+    this class, and this class is also set as the event sink for COM
+    events originating from the ActiveX control.  In other words, to
+    catch the COM events you merely have to derive from this class and
+    provide a method with the correct name.  See the comtypes package
+    documentation for more details.
+    """
+
+    def __init__(self, parent, axID, wxid=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=0, name="activeXCtrl"):
+        """
+        All parameters are like those used in normal wx.Windows with
+        the addition of axID which is a string that is either a ProgID
+        or a CLSID used to identify the ActiveX control.
+        """
+        pos = wx.Point(*pos)    # in case the arg is a tuple
+        size = wx.Size(*size)   # ditto
+
+        x = pos.x
+        y = pos.y
+        if x == -1: x = CW_USEDEFAULT
+        if y == -1: y = 20
+        w = size.width
+        h = size.height
+        if w == -1: w = 20
+        if h == -1: h = 20
+
+        # create the control
+        atl.AtlAxWinInit()
+        hInstance = kernel32.GetModuleHandleA(None)
+        hwnd = user32.CreateWindowExA(0, b"AtlAxWin", axID.encode("ASCII"),
+                                      WS_CHILD | WS_VISIBLE
+                                      | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+                                      x,y, w,h, parent.GetHandle(), None,
+                                      hInstance, 0)
+        assert hwnd != 0
+
+        # get the Interface for the Ax control
+        unknown = ct.POINTER(comtypes.IUnknown)()
+        res = atl.AtlAxGetControl(hwnd, ct.byref(unknown))
+        assert res == hr.S_OK
+        self._ax = cc.GetBestInterface(unknown)
+
+        # Fetch the interface for IOleInPlaceActiveObject. We'll use this
+        # later to call its TranslateAccelerator method so the AX Control can
+        # deal with things like tab traversal and such within itself.
+        self.ipao = self._ax.QueryInterface(myole4ax.IOleInPlaceActiveObject)
+
+        # Use this object as the event sink for the ActiveX events
+        self._evt_connections = []
+        self.AddEventSink(self)
+
+        wx.msw.PyAxBaseWindow.__init__(self, parent, wxid, pos, size, style, name)
+
+        # Turn the window handle into a wx.Window and set this object to be that window
+        self.AssociateHandle(hwnd)
+
+        # Set some wx.Window properties
+        if wxid == wx.ID_ANY:
+            wxid = wx.NewIdRef()
+        self.SetId(wxid)
+        self.SetName(name)
+        self.SetMinSize(size)
+
+        self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
+        self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
+        self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroyWindow)
+
+
+    def AddEventSink(self, sink, interface=None):
+        """
+        Add a new target to search for method names that match the COM
+        Event names.
+        """
+        self._evt_connections.append(cc.GetEvents(self._ax, sink, interface))
+
+
+    def GetCtrl(self):
+        """Easy access to the COM interface for the ActiveX Control"""
+        return self._ax
+    # And an even easier property
+    ctrl = property(GetCtrl)
+
+
+    def MSWTranslateMessage(self, msg):
+        # Pass native messages to the IOleInPlaceActiveObject
+        # interface before wx processes them, so navigation keys and
+        # accelerators can be dealt with the way that the AXControl
+        # wants them to be done. MSWTranslateMessage is called before
+        # wxWidgets handles and eats the navigation keys itself.
+        try:
+            res = self.ipao.TranslateAccelerator(msg)
+            if res == hr.S_OK:
+                return True
+        except OSError:
+            pass
+        return super(ActiveXCtrl, self).MSWTranslateMessage(msg)
+
+
+    # TBD: Are the focus handlers needed?
+    def OnSetFocus(self, evt):
+        self.ipao.OnFrameWindowActivate(True)
+
+    def OnKillFocus(self, evt):
+        self.ipao.OnFrameWindowActivate(False)
+
+    def OnDestroyWindow(self, evt):
+        # release our event sinks while the window still exists
+        self._evt_connections = None
+
+#------------------------------------------------------------------------------
+
+
+
+

wx/lib/activexwrapper.py

@@ -0,0 +1,153 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.activexwrapper
+# Purpose:     a wxWindow derived class that can hold an ActiveX control
+#
+# Author:      Robin Dunn
+#
+# Copyright:   (c) 2000-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+# o Tested with updated demo
+#
+
+import  wx
+
+try:
+    import win32ui
+    import pywin.mfc.activex
+    import win32com.client
+except ImportError:
+    import sys
+    if hasattr(sys, "frozen"):
+        import os, win32api
+        dllpath = os.path.join(win32api.GetSystemDirectory(), 'MFC71.DLL')
+        if sys.version[:3] >= '2.4' and not os.path.exists(dllpath):
+            message = "%s not found" % dllpath
+        else:
+            raise       # original error message
+    else:
+        message = "ActiveXWrapper requires PythonWin. Please install the PyWin32 package."
+    raise ImportError(message)
+
+##from win32con import WS_TABSTOP, WS_VISIBLE
+WS_TABSTOP = 0x00010000
+WS_VISIBLE = 0x10000000
+
+#----------------------------------------------------------------------
+
+
+def MakeActiveXClass(CoClass, eventClass=None, eventObj=None):
+    """
+    Dynamically construct a new class that derives from wxWindow, the
+    ActiveX control and the appropriate COM classes.  This new class
+    can be used just like the wxWindow class, but will also respond
+    appropriately to the methods and properties of the COM object.  If
+    this class, a derived class or a mix-in class has method names
+    that match the COM object's event names, they will be called
+    automatically.
+
+    CoClass -- A COM control class from a module generated by
+            makepy.py from a COM TypeLibrary.  Can also accept a
+            CLSID.
+
+    eventClass -- If given, this class will be added to the set of
+            base classes that the new class is drived from.  It is
+            good for mix-in classes for catching events.
+
+    eventObj -- If given, this object will be searched for attributes
+            by the new class's __getattr__ method, (like a mix-in
+            object.)  This is useful if you want to catch COM
+            callbacks in an existing object, (such as the parent
+            window.)
+
+    """
+
+
+    if type(CoClass) == type(""):
+        # use the CLSID to get the real class
+        CoClass = win32com.client.CLSIDToClass(CoClass)
+
+    # determine the base classes
+    axEventClass = CoClass.default_source
+    baseClasses = [pywin.mfc.activex.Control, wx.Window, CoClass, axEventClass]
+    if eventClass:
+        baseClasses.append(eventClass)
+    baseClasses = tuple(baseClasses)
+
+    # define the class attributes
+    className = 'AXControl_'+CoClass.__name__
+    classDict = { '__init__'    : axw__init__,
+                  '__getattr__' : axw__getattr__,
+                  'axw_OnSize'  : axw_OnSize,
+                  'axw_OEB'     : axw_OEB,
+                  '_name'       : className,
+                  '_eventBase'  : axEventClass,
+                  '_eventObj'   : eventObj,
+                  'Cleanup'     : axw_Cleanup,
+                  }
+
+    # make a new class object
+    classObj = type(className, baseClasses, classDict)
+    return classObj
+
+
+
+
+# These functions will be used as methods in the new class
+def axw__init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0):
+
+    # init base classes
+    pywin.mfc.activex.Control.__init__(self)
+    wx.Window.__init__( self, parent, -1, pos, size, style|wx.NO_FULL_REPAINT_ON_RESIZE)
+    #self.this.own(False)  # this should be set in wx.Window.__init__ when it calls _setOORInfo, but...
+
+    win32ui.EnableControlContainer()
+    self._eventObj = self._eventObj  # move from class to instance
+
+    # create a pythonwin wrapper around this wxWindow
+    handle = self.GetHandle()
+    self._wnd = win32ui.CreateWindowFromHandle(handle)
+
+    # create the control
+    sz = self.GetSize()
+    self.CreateControl(self._name, WS_TABSTOP | WS_VISIBLE,
+                       (0, 0, sz.width, sz.height), self._wnd, ID)
+
+    # init the ax events part of the object
+    self._eventBase.__init__(self, self._dispobj_)
+
+    # hook some wx events
+    self.Bind(wx.EVT_SIZE, self.axw_OnSize)
+
+def axw__getattr__(self, attr):
+    try:
+        return pywin.mfc.activex.Control.__getattr__(self, attr)
+    except (AttributeError, win32ui.error):
+        try:
+            eo = self.__dict__['_eventObj']
+            return getattr(eo, attr)
+        except AttributeError:
+            raise AttributeError('Attribute not found: %s' % attr)
+
+
+def axw_OnSize(self, event):
+    sz = self.GetClientSize()                        # get wxWindow size
+    self.MoveWindow((0, 0, sz.width, sz.height), 1)  # move the AXControl
+
+
+def axw_OEB(self, event):
+    pass
+
+
+def axw_Cleanup(self):
+    #del self._wnd
+    self.close()
+    pass
+
+
+
+
+