wxPython 4.3.2__cp315-cp315-win_amd64.whl

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 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
+
+
+
+
+

wx/lib/agw/__init__.py

@@ -0,0 +1,128 @@
+
+"""
+This is the Advanced Generic Widgets package (AGW). It provides many
+custom-drawn wxPython controls: some of them can be used as a replacement
+of the platform native controls, others are simply an addition to the
+already rich wxPython widgets set.
+
+
+Description:
+
+AGW contains many different modules, listed below. Items labelled with
+an asterisk were already present in :mod:`lib` before:
+
+- AdvancedSplash: reproduces the behaviour of :class:`~adv.SplashScreen`, with more
+  advanced features like custom shapes and text animations;
+- AquaButton: this is another custom-drawn button class which
+  *approximately* mimics the behaviour of Aqua buttons on the Mac;
+- AUI: a pure-Python implementation of :mod:`~wx.lib.agw.aui`, with many bug fixes and
+  new features like HUD docking and :class:`~wx.lib.agw.aui.auibook.AuiNotebook` tab arts;
+- BalloonTip: allows you to display tooltips in a balloon style window
+  (actually a frame), similarly to the Windows XP balloon help;
+- ButtonPanel (*): a panel with gradient background shading with the
+  possibility to add buttons and controls still respecting the gradient
+  background;
+- CubeColourDialog: an alternative implementation of :class:`wx.ColourDialog`, it
+  offers different functionalities like colour wheel and RGB cube;
+- CustomTreeCtrl (*): mimics the behaviour of :class:`TreeCtrl`, with almost the
+  same base functionalities plus a bunch of enhancements and goodies;
+- FlatMenu: as the name implies, it is a generic menu implementation,
+  offering the same :class:`wx.MenuBar` / :class:`wx.Menu` / :class:`ToolBar` capabilities and much more;
+- FlatNotebook (*): a full implementation of the :class:`Notebook`, and designed
+  to be a drop-in replacement for :class:`Notebook` with enhanced capabilities;
+- FloatSpin: this class implements a floating point spinctrl, cabable (in
+  theory) of handling infinite-precision floating point numbers;
+- FoldPanelBar (*): a control that contains multiple panels that can be
+  expanded or collapsed a la Windows Explorer/Outlook command bars;
+- FourWaySplitter: this is a layout manager which manages four children like
+  four panes in a window, similar to many CAD software interfaces;
+- GenericMessageDialog: it is a possible replacement for the standard
+  :class:`MessageDialog`, with a fancier look and extended functionalities;
+- GradientButton: another custom-drawn button class which mimics Windows CE
+  mobile gradient buttons, using a tri-vertex blended gradient background;
+- HyperLinkCtrl (*): this widget acts line an hyper link in a typical browser;
+- HyperTreeList: a class that mimics the behaviour of :class:`wx.adv.TreeListCtrl`,
+  with almost the same base functionalities plus some more enhancements;
+- InfoBar: a transient window shown at top or bottom of its parent window to display
+  non-critical information to the user;
+- KnobCtrl: a widget which lets the user select a numerical value by
+  rotating it, like a slider with a wheel shape;
+- LabelBook and FlatImageBook: these are a quasi-full implementations of
+  :class:`Listbook`, with additional features;
+- MultiDirDialog: it represents a possible replacement for :class:`DirDialog`,
+  with the additional ability of selecting multiple folders at once and a
+  fancier look;
+- PeakMeter: this widget mimics the behaviour of LED equalizers that are
+  usually found in stereos and MP3 players;
+- PersistentControls: widgets which automatically save their state
+  when they are destroyed and restore it when they are recreated, even during
+  another program invocation;
+- PieCtrl and ProgressPie: these are simple classes that reproduce the
+  behavior of a pie chart, in a static or progress-gauge-like way;
+- PyBusyInfo: constructs a busy info window and displays a message in it:
+  it is similar to :class:`BusyInfo`;
+- PyCollapsiblePane: a pure Python implementation of the original wxWidgets
+  C++ code of :class:`CollapsiblePane`, with customizable buttons;
+- PyGauge: a generic :class:`Gauge` implementation, it supports the determinate
+  mode functions as :class:`Gauge`;
+- PyProgress: it is similar to :class:`ProgressDialog` in indeterminated mode, but
+  with a different gauge appearance and a different spinning behavior;
+- RibbonBar: the RibbonBar library is a set of classes for writing a ribbon
+  user interface, similar to the user interface present in recent versions
+  of Microsoft Office;
+- RulerCtrl: it implements a ruler window that can be placed on top, bottom,
+  left or right to any wxPython widget. It is somewhat similar to the rulers
+  you can find in text editors software;
+- ShapedButton: this class tries to fill the lack of "custom shaped" controls
+  in wxPython. It can be used to build round buttons or elliptic buttons;
+- ShortcutEditor: a widget that allows the user to customize and change
+  keyboard shortcuts via a dialog;
+- SpeedMeter: this widget tries to reproduce the behavior of some car
+  controls (but not only), by creating an "angular" control;
+- SuperToolTip: a class that mimics the behaviour of :class:`TipWindow` and
+  generic tooltips, with many features and highly customizable;
+- ThumbnailCtrl: a widget that can be used to display a series of images
+  in a "thumbnail" format; it mimics, for example, the Windows Explorer
+  behavior when you select the "view thumbnails" option;
+- ToasterBox: a cross-platform widget to make the creation of MSN-style
+  "toaster" popups easier;
+- UltimateListCtrl: mimics the behaviour of :class:`ListCtrl`, with almost the same
+  base functionalities plus some more enhancements;
+- XLSGrid: a class based on :class:`grid.Grid` that can be used to faithfully
+  reproduce the appearance of a Microsoft Excel spreadsheets;
+- ZoomBar: a class that *appoximatively* mimics the behaviour of the Mac Dock,
+  inside a :class:`Panel`.
+
+
+Bugs and Limitations: many, patches and fixes welcome :-D
+
+See the demos for an example of what AGW can do, and on how to use it.
+
+Copyright: Andrea Gavana
+
+License: Same as the version of wxPython you are using it with.
+
+SVN for latest code:
+http://svn.wxwidgets.org/viewvc/wx/wxPython/3rdParty/AGW/
+
+Mailing List:
+wxpython-users@lists.wxwidgets.org
+
+My personal web page:
+http://xoomer.alice.it/infinity77
+
+Please let me know if you are using AGW!
+
+You can contact me at:
+
+andrea.gavana@gmail.com
+andrea.gavana@maerskoil.com
+
+AGW version: 0.9.7
+
+Last updated: 09 January 2014, 23.00 GMT
+
+"""
+
+__version__ = "0.9.7"
+__author__ = "Andrea Gavana <andrea.gavana@gmail.com>"