wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/mixins/__init__.py

@@ -0,0 +1,17 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.mixins
+# Purpose:     A package for helpful wxPython mix-in classes
+#
+# Author:      Robin Dunn
+#
+# Created:     15-May-2001
+# Copyright:   (c) 2001-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+# 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+#
+
+
+

wx/lib/mixins/grid.py

@@ -0,0 +1,47 @@
+#----------------------------------------------------------------------------
+# Name:        wx.lib.mixins.grid
+# Purpose:     Helpful mix-in classes for wx.Grid
+#
+# Author:      Robin Dunn
+#
+# Created:     5-June-2001
+# Copyright:   (c) 2001-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------------
+# 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+# o Untested
+#
+# 12/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wxGridAutoEditMixin -> GridAutoEditMixin
+#
+
+import  wx
+import  wx.grid
+
+#----------------------------------------------------------------------------
+
+
+class GridAutoEditMixin:
+    """A mix-in class that automatically enables the grid edit control when
+    a cell is selected.
+
+    If your class hooks EVT_GRID_SELECT_CELL be sure to call event.Skip so
+    this handler will be called too.
+    """
+
+    def __init__(self):
+        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.__OnSelectCell)
+
+
+    def __DoEnableEdit(self):
+        if self.CanEnableCellControl():
+            self.EnableCellEditControl()
+
+
+    def __OnSelectCell(self, evt):
+        wx.CallAfter(self.__DoEnableEdit)
+        evt.Skip()
+

wx/lib/mixins/gridlabelrenderer.py

@@ -0,0 +1,251 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.mixins.gridlabelrenderer
+# Purpose:     A Grid mixin that enables renderers to be plugged in
+#              for drawing the row and col labels, similar to how the
+#              cell renderers work.
+#
+# Author:      Robin Dunn
+#
+# Created:     20-Mar-2009
+# Copyright:   (c) 2009-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+
+"""
+A Grid mixin that enables renderers to be plugged in for drawing the
+row and col labels, similar to how the cell renderers work.
+"""
+
+import wx
+
+
+class GridWithLabelRenderersMixin(object):
+    """
+    This class can be mixed with wx.grid.Grid to add the ability to plugin
+    label renderer objects for the row, column and corner labels, similar to
+    how the cell renderers work in the main Grid class.
+    """
+    def __init__(self):
+        self.GetGridRowLabelWindow().Bind(wx.EVT_PAINT, self._onPaintRowLabels)
+        self.GetGridColLabelWindow().Bind(wx.EVT_PAINT, self._onPaintColLabels)
+        self.GetGridCornerLabelWindow().Bind(wx.EVT_PAINT, self._onPaintCornerLabel)
+
+        self._rowRenderers = dict()
+        self._colRenderers = dict()
+        self._cornderRenderer = None
+        self._defRowRenderer = None
+        self._defColRenderer = None
+
+
+    def SetRowLabelRenderer(self, row, renderer):
+        """
+        Register a renderer to be used for drawing the label for the
+        given row.
+        """
+        if renderer is None:
+            if row in self._rowRenderers:
+                del self._rowRenderers[row]
+        else:
+            self._rowRenderers[row] = renderer
+
+
+    def SetDefaultRowLabelRenderer(self, renderer):
+        """
+        Set the row label renderer that should be used for any row
+        that does not have an explicitly set renderer.  Defaults to
+        an instance of `GridDefaultRowLabelRenderer`.
+        """
+        self._defRowRenderer = renderer
+
+
+    def SetColLabelRenderer(self, col, renderer):
+        """
+        Register a renderer to be used for drawing the label for the
+        given column.
+        """
+        if renderer is None:
+            if col in self._colRenderers:
+                del self._colRenderers[col]
+        else:
+            self._colRenderers[col] = renderer
+
+
+    def SetDefaultColLabelRenderer(self, renderer):
+        """
+        Set the column label renderer that should be used for any
+        column that does not have an explicitly set renderer.
+        Defaults to an instance of `GridDefaultColLabelRenderer`.
+        """
+        self._defColRenderer = renderer
+
+
+
+    def SetCornerLabelRenderer(self, renderer):
+        """
+        Sets the renderer that should be used for drawing the area in
+        the upper left corner of the Grid, between the row labels and
+        the column labels.  Defaults to an instance of
+        `GridDefaultCornerLabelRenderer`
+        """
+        self._cornderRenderer = renderer
+
+
+    #----------------------------------------------------------------
+
+    def _onPaintRowLabels(self, evt):
+        window = evt.GetEventObject()
+        dc = wx.PaintDC(window)
+
+        rows = self.CalcRowLabelsExposed(window.GetUpdateRegion())
+        if rows == [-1]:
+            return
+
+        x, y = self.CalcUnscrolledPosition((0,0))
+        pt = dc.GetDeviceOrigin()
+        dc.SetDeviceOrigin(pt.x, pt.y-y)
+        for row in rows:
+            top, bottom = self._getRowTopBottom(row)
+            rect = wx.Rect()
+            rect.top = top
+            rect.bottom = bottom
+            rect.x = 0
+            rect.width = self.GetRowLabelSize()
+
+            renderer = self._rowRenderers.get(row, None) or \
+                       self._defRowRenderer or GridDefaultRowLabelRenderer()
+            renderer.Draw(self, dc, rect, row)
+
+
+    def _onPaintColLabels(self, evt):
+        window = evt.GetEventObject()
+        dc = wx.PaintDC(window)
+
+        cols = self.CalcColLabelsExposed(window.GetUpdateRegion())
+        if cols == [-1]:
+            return
+
+        x, y = self.CalcUnscrolledPosition((0,0))
+        pt = dc.GetDeviceOrigin()
+        dc.SetDeviceOrigin(pt.x-x, pt.y)
+        for col in cols:
+            left, right = self._getColLeftRight(col)
+            rect = wx.Rect()
+            rect.left = left
+            rect.right = right
+            rect.y = 0
+            rect.height = self.GetColLabelSize()
+
+            renderer = self._colRenderers.get(col, None) or \
+                       self._defColRenderer or GridDefaultColLabelRenderer()
+            renderer.Draw(self, dc, rect, col)
+
+
+    def _onPaintCornerLabel(self, evt):
+        window = evt.GetEventObject()
+        dc = wx.PaintDC(window)
+        w, h = window.GetSize()
+        rect = wx.Rect(0, 0, w, h)
+
+        renderer = self._cornderRenderer or GridDefaultCornerLabelRenderer()
+        renderer.Draw(self, dc, rect, -1)
+
+
+
+    # NOTE: These helpers or something like them should probably be publicly
+    # available in the C++ wxGrid class, but they are currently protected so
+    # for now we will have to calculate them ourselves.
+    def _getColLeftRight(self, col):
+        c = 0
+        left = -1
+        while c < col:
+            left += self.GetColSize(c)
+            c += 1
+        right = left + self.GetColSize(col)
+        return left, right
+
+    def _getRowTopBottom(self, row):
+        r = 0
+        top = -1
+        while r < row:
+            top += self.GetRowSize(r)
+            r += 1
+        bottom = top + self.GetRowSize(row)
+        return top, bottom
+
+
+
+
+class GridLabelRenderer(object):
+    """
+    Base class for row, col or corner label renderers.
+    """
+
+    def Draw(self, grid, dc, rect, row_or_col):
+        """
+        Override this method in derived classes to do the actual
+        drawing of the label.
+        """
+        raise NotImplementedError
+
+
+    # These two can be used to duplicate the default wxGrid label drawing
+    def DrawBorder(self, grid, dc, rect):
+        """
+        Draw a standard border around the label, to give a simple 3D
+        effect like the stock wx.grid.Grid labels do.
+        """
+        top = rect.top
+        bottom = rect.bottom
+        left = rect.left
+        right = rect.right
+        dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DSHADOW)))
+        dc.DrawLine(right, top, right, bottom)
+        dc.DrawLine(left, top, left, bottom)
+        dc.DrawLine(left, bottom, right, bottom)
+        dc.SetPen(wx.WHITE_PEN)
+        if top == 0:
+            dc.DrawLine(left + 1, top, left + 1, bottom)
+            dc.DrawLine(left + 1, top, right, top)
+        else:
+            dc.DrawLine(left + 1, top + 1, left + 1, bottom)
+            dc.DrawLine(left + 1, top + 1, right - 1, top + 1)
+
+
+    def DrawText(self, grid, dc, rect, text, hAlign, vAlign):
+        """
+        Draw the label's text in the rectangle, using the alignment
+        flags, and the grid's specified label font and color.
+        """
+        dc.SetBackgroundMode(wx.TRANSPARENT)
+        dc.SetTextForeground(grid.GetLabelTextColour())
+        dc.SetFont(grid.GetLabelFont())
+        rect = wx.Rect(*rect)
+        rect.Deflate(2,2)
+        grid.DrawTextRectangle(dc, text, rect, hAlign, vAlign)
+
+
+
+# These classes draw approximately the same things that the built-in
+# label windows do in C++, but are adapted to fit into this label
+# renderer scheme.
+
+class GridDefaultRowLabelRenderer(GridLabelRenderer):
+    def Draw(self, grid, dc, rect, row):
+        hAlign, vAlign = grid.GetRowLabelAlignment()
+        text = grid.GetRowLabelValue(row)
+        self.DrawBorder(grid, dc, rect)
+        self.DrawText(grid, dc, rect, text, hAlign, vAlign)
+
+class GridDefaultColLabelRenderer(GridLabelRenderer):
+    def Draw(self, grid, dc, rect, col):
+        hAlign, vAlign = grid.GetColLabelAlignment()
+        text = grid.GetColLabelValue(col)
+        self.DrawBorder(grid, dc, rect)
+        self.DrawText(grid, dc, rect, text, hAlign, vAlign)
+
+class GridDefaultCornerLabelRenderer(GridLabelRenderer):
+    def Draw(self, grid, dc, rect, row_or_col):
+        self.DrawBorder(grid, dc, rect)
+
+
+#---------------------------------------------------------------------------

wx/lib/mixins/imagelist.py

@@ -0,0 +1,77 @@
+#----------------------------------------------------------------------------
+# Name:        wx.lib.mixins.imagelist
+# Purpose:     Helpful mix-in classes for using a wxImageList
+#
+# Author:      Robin Dunn
+#
+# Created:     15-May-2001
+# Copyright:   (c) 2001-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------------
+# 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+# o Untested.
+#
+
+import  wx
+
+#----------------------------------------------------------------------------
+
+class MagicImageList:
+    '''
+    Mix-in to provide "magic" growing image lists
+    By Mike Fletcher
+    '''
+
+    ### LAZYTREE and LISTCONTROL Methods
+    DEFAULTICONSIZE = 16
+
+    def SetupIcons(self, images=(), size=None):
+        self.__size = size or self.DEFAULTICONSIZE
+        self.__magicImageList = wx.ImageList (self.__size,self.__size)
+        self.__magicImageListMapping = {}
+        self.SetImageList (
+            self.__magicImageList, {
+                16:wx.IMAGE_LIST_SMALL,
+                32:wx.IMAGE_LIST_NORMAL,
+            }[self.__size]
+        )
+        for image in images:
+            self.AddIcon (image)
+
+    def GetIcons (self, node):
+        '''Get icon indexes for a given node, or None if no associated icon'''
+        icon = self.GetIcon( node )
+        if icon:
+            index = self.AddIcon (icon)
+            return index, index
+        return None
+
+
+    ### Local methods...
+    def AddIcon(self, icon, mask = wx.NullBitmap):
+        '''Add an icon to the image list, or get the index if already there'''
+        index = self.__magicImageListMapping.get (id (icon))
+        if index is None:
+            if isinstance( icon, wxIconPtr ):
+                index = self.__magicImageList.AddIcon( icon )
+            elif isinstance( icon, wx.BitmapPtr ):
+                if isinstance( mask, wx.Colour ):
+                    index = self.__magicImageList.AddWithColourMask( icon, mask )
+                else:
+                    index = self.__magicImageList.Add( icon, mask )
+            else:
+                raise ValueError("Unexpected icon object %s, "
+                                 "expected wx.Icon or wx.Bitmap" % (icon))
+            self.__magicImageListMapping [id (icon)] = index
+        return index
+
+    ### Customisation point...
+    def GetIcon( self, node ):
+        '''Get the actual icon object for a node'''
+        if hasattr (node,"DIAGRAMICON"):
+            return node.DIAGRAMICON
+
+
+

wx/lib/mixins/inspection.py

@@ -0,0 +1,184 @@
+#----------------------------------------------------------------------------
+# Name:        wx.lib.mixins.inspection
+# Purpose:     A mix-in class that can add PyCrust-based inspection of the
+#              app's widgets and sizers.
+#
+# Author:      Robin Dunn
+#
+# Created:     21-Nov-2006
+# Copyright:   (c) 2006-2020 by Total Control Software
+# Licence:     wxWindows license
+#
+# Tags: phoenix-port, documented, unittest
+#----------------------------------------------------------------------------
+#
+# NOTE: This class was originally based on ideas sent to the
+# wxPython-users mail list by Dan Eloff.
+"""
+This module provides the :class:`~lib.mixins.inspection.InspectableApp` and
+:class:`~lib.mixins.inspection.InspectionMixin` which make it easy to use the Widget
+Inspection Tool (WIT).
+
+
+Description
+===========
+
+The Widget Inspection Tool (WIT) is very useful debugging tool provided with
+wxPython, especially useful to debug layout issues when using :class:`wx.Sizer`.
+
+The :class:`InspectableApp` is a "pre-mixed" :class:`App` and the
+:class:`InspectionMixin` allows you to mix it with your custom :class:`App`
+class.
+
+
+Usage
+=====
+
+The following samples assume the default key sequence (*ctrl-alt-i*) to start
+the WIT, additional information can be found on the following wiki page.
+
+http://wiki.wxpython.org/Widget_Inspection_Tool
+
+InspectableApp usage::
+
+    import wx
+    import wx.lib.sized_controls as sc
+    import wx.lib.mixins.inspection as wit
+
+    app = wit.InspectableApp()
+
+    frame = sc.SizedFrame(None, -1, "WIT InspectableApp")
+
+    pane = frame.GetContentsPane()
+    pane.SetSizerType("horizontal")
+
+    b1 = wx.Button(pane, wx.ID_ANY)
+    t1 = wx.TextCtrl(pane, -1)
+    t1.SetSizerProps(expand=True)
+
+    frame.Show()
+
+    app.MainLoop()
+
+
+InspectionMixin usage::
+
+    import wx
+    import wx.lib.sized_controls as sc
+    import wx.lib.mixins.inspection as wit
+
+    class MyApp(wx.App, wit.InspectionMixin):
+        def OnInit(self):
+            self.Init()  # initialize the inspection tool
+            return True
+
+    app = MyApp()
+
+    frame = sc.SizedFrame(None, -1, "WIT InspectionMixin")
+
+    pane = frame.GetContentsPane()
+    pane.SetSizerType("horizontal")
+
+    b1 = wx.Button(pane, wx.ID_ANY)
+    t1 = wx.TextCtrl(pane, -1)
+    t1.SetSizerProps(expand=True)
+
+    frame.Show()
+
+    app.MainLoop()
+
+"""
+
+
+import wx
+from wx.lib.inspection import InspectionTool
+
+
+#----------------------------------------------------------------------------
+
+class InspectionMixin(object):
+    """
+    This class is intended to be used as a mix-in with the :class:`App`.
+    When used it will add the ability to popup a
+    :class:`~lib.inspection.InspectionFrame` window
+    where the widget under the mouse cursor will be selected in the tree and
+    loaded into the shell's namespace as 'obj'.  The default key sequence to
+    activate the inspector is Ctrl-Alt-I (or Cmd-Alt-I on Mac) but this can be
+    changed via parameters to the `Init` method, or the application can call
+    :meth:`~lib.mixins.inspection.InspectionMixin.ShowInspectionTool` from other
+    event handlers if desired.
+
+    To use this class simply derive a class from :class:`App` and
+    :class:`InspectionMixin` and then call the
+    :meth:`InspectionMixin.Init` method from the app's
+    :meth:`AppConsole.OnInit` method.
+    """
+    def InitInspection(self, pos=wx.DefaultPosition, size=wx.Size(850,700),
+                       config=None, locals=None,
+                       alt=True, cmd=True, shift=False, keyCode=ord('I')):
+        """
+        Make the event binding that will activate the InspectionFrame window.
+
+        :param `pos`: the control position. A value of (-1, -1) indicates a default position,
+         chosen by either the windowing system or wxPython, depending on platform;
+        :param `size`: the control size. A value of (-1, -1) indicates a default size,
+         chosen by either the windowing system or wxPython, depending on platform;
+        :param `config`: A :class:`Config` object to be used to store layout
+            and other info to when the inspection frame is closed.
+            This info will be restored the next time the inspection
+            frame is used.
+        :param `locals`: A dictionary of names to be added to the PyCrust
+            namespace.
+        :param boolean `alt`: use alt in the short cut sequence
+        :param boolean `cmd`: use ctrl/cmd in the short cut sequence
+        :param boolean `shift`: use shift in the short cut sequence
+        :param string `keyCode`: the key code for the short cut sequence
+
+        """
+        self.Bind(wx.EVT_KEY_DOWN, self._OnKeyPress)
+        self._alt = alt
+        self._cmd = cmd
+        self._shift = shift
+        self._keyCode = keyCode
+        InspectionTool().Init(pos, size, config, locals, self)
+
+    def _OnKeyPress(self, evt):
+        """
+        Event handler, check for our hot-key.  Normally it is
+        Ctrl-Alt-I but that can be changed by what is passed to the
+        Init method.
+        """
+        if evt.AltDown() == self._alt  and \
+               evt.CmdDown() == self._cmd and \
+               evt.ShiftDown() == self._shift and \
+               evt.GetKeyCode() == self._keyCode:
+            self.ShowInspectionTool()
+        else:
+            evt.Skip()
+
+    Init = InitInspection  # compatibility alias
+
+    def ShowInspectionTool(self):
+        """
+        Show the Inspection tool, creating it if neccesary, setting it
+        to display the widget under the cursor.
+        """
+        # get the current widget under the mouse
+        wnd, pt = wx.FindWindowAtPointer()
+        InspectionTool().Show(wnd)
+
+
+#---------------------------------------------------------------------------
+
+class InspectableApp(wx.App, InspectionMixin):
+    """
+    A simple mix of :class:`App` and :class:`InspectionMixin` that can be used
+    stand-alone.
+    """
+
+    def OnInit(self):
+        self.InitInspection()
+        return True
+
+#---------------------------------------------------------------------------
+