wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/scrolledpanel.py

@@ -0,0 +1,225 @@
+#----------------------------------------------------------------------------
+# Name:         scrolledpanel.py
+# Author:       Will Sadkin
+# Created:      03/21/2003
+# Copyright:    (c) 2003 by Will Sadkin
+# License:      wxWindows license
+# Tags:         phoenix-port
+#----------------------------------------------------------------------------
+# 12/11/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+#
+# 12/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wxScrolledPanel -> ScrolledPanel
+#
+# 21 Dec 2012 - Andrea Gavana (andrea.gavana@gmail.com)
+#
+# Tags:        phoenix-port, unittest, documented
+#
+
+"""
+:class:`~lib.scrolledpanel.ScrolledPanel` extends :class:`ScrolledWindow`, adding all
+the necessary bits to set up scroll handling for you.
+
+Description
+===========
+
+:class:`ScrolledPanel` fills a "hole" in the implementation of
+:class:`ScrolledWindow`, providing automatic scrollbar and scrolling
+behavior and the tab traversal management that :class:`ScrolledWindow`
+lacks.  This code was based on the original demo code showing how
+to do this, but is now available for general use as a proper class
+(and the demo is now converted to just use it.)
+
+It is assumed that the :class:`ScrolledPanel` will have a sizer, as it is
+used to calculate the minimal virtual size of the panel and etc.
+
+Usage
+=====
+
+Usage example::
+
+
+    text = '''
+    ScrolledPanel extends wx.ScrolledWindow, adding all
+    the necessary bits to set up scroll handling for you.
+
+    Here are three fixed size examples of its use. The
+    demo panel for this sample is also using it -- the
+    wx.StaticLine below is intentionally made too long so a scrollbar will be
+    activated.'''
+
+    import wx
+    import wx.lib.scrolledpanel as scrolled
+
+    class TestPanel(scrolled.ScrolledPanel):
+
+        def __init__(self, parent):
+
+            scrolled.ScrolledPanel.__init__(self, parent, -1)
+
+            vbox = wx.BoxSizer(wx.VERTICAL)
+
+            desc = wx.StaticText(self, -1, text)
+
+            desc.SetForegroundColour("Blue")
+            vbox.Add(desc, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+            vbox.Add(wx.StaticLine(self, -1, size=(1024, -1)), 0, wx.ALL, 5)
+            vbox.Add((20, 20))
+
+            self.SetSizer(vbox)
+            self.SetupScrolling()
+
+
+    app = wx.App(0)
+    frame = wx.Frame(None, wx.ID_ANY)
+    fa = TestPanel(frame)
+    frame.Show()
+    app.MainLoop()
+
+"""
+
+import wx
+import math
+
+class ScrolledPanel(wx.ScrolledWindow):
+    """
+    :class:`ScrolledPanel` fills a "hole" in the implementation of
+    :class:`ScrolledWindow`, providing automatic scrollbar and scrolling
+    behavior and the tab traversal management that :class:`ScrolledWindow` lacks.
+    """
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.TAB_TRAVERSAL,
+                 name="scrolledpanel"):
+        """
+        Default class constructor.
+
+        :param wx.Window `parent`: parent window. Must not be ``None``;
+        :param integer `id`: window identifier. A value of -1 indicates a default value;
+        :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;
+        :type `pos`: tuple or :class:`wx.Point`
+        :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;
+        :type `size`: tuple or :class:`wx.Size`
+        :param integer `style`: the underlying :class:`wx.ScrolledWindow` style;
+        :param string `name`: the scrolled panel name.
+        """
+
+        wx.ScrolledWindow.__init__(self, parent, id,
+                                     pos=pos, size=size,
+                                     style=style, name=name)
+        self.scrollIntoView = True
+        self.SetInitialSize(size)
+        self.Bind(wx.EVT_CHILD_FOCUS, self.OnChildFocus)
+
+
+    def SetupScrolling(self, scroll_x=True, scroll_y=True, rate_x=20, rate_y=20,
+                       scrollToTop=True, scrollIntoView=True):
+        """
+        This function sets up the event handling necessary to handle
+        scrolling properly. It should be called within the `__init__`
+        function of any class that is derived from :class:`ScrolledPanel`,
+        once the controls on the panel have been constructed and
+        thus the size of the scrolling area can be determined.
+
+        :param bool `scroll_x`: ``True`` to allow horizontal scrolling, ``False`` otherwise;
+        :param bool `scroll_y`: ``True`` to allow vertical scrolling, ``False`` otherwise;
+        :param int `rate_x`: the horizontal scroll increment;
+        :param int `rate_y`: the vertical scroll increment;
+        :param bool `scrollToTop`: ``True`` to scroll all way to the top, ``False`` otherwise;
+        :param bool `scrollIntoView`: ``True`` to scroll a focused child into view, ``False`` otherwise.
+        """
+
+        self.scrollIntoView = scrollIntoView
+
+        # The following is all that is needed to integrate the sizer and the scrolled window
+        if not scroll_x: rate_x = 0
+        if not scroll_y: rate_y = 0
+
+        # Round up the virtual size to be a multiple of the scroll rate
+        sizer = self.GetSizer()
+        if sizer:
+            w, h = sizer.GetMinSize()
+            if rate_x:
+                w += rate_x - (w % rate_x)
+            if rate_y:
+                h += rate_y - (h % rate_y)
+            self.SetVirtualSize( (w, h) )
+        self.SetScrollRate(rate_x, rate_y)
+        wx.CallAfter(self._SetupAfter, scrollToTop) # scroll back to top after initial events
+
+
+    def _SetupAfter(self, scrollToTop):
+        self.SetVirtualSize(self.GetBestVirtualSize())
+        if scrollToTop:
+            self.Scroll(0,0)
+
+
+    def OnChildFocus(self, evt):
+        """
+        If the child window that gets the focus is not fully visible,
+        this handler will try to scroll enough to see it.
+
+        :param `evt`: a :class:`ChildFocusEvent` event to be processed.
+        """
+
+        child = evt.GetWindow()
+        if self.scrollIntoView:
+            self.ScrollChildIntoView(child)
+            evt.Skip()
+
+
+    def ScrollChildIntoView(self, child):
+        """
+        Scroll the panel so that the specified child window is in view.
+
+        :param wx.Window `child`: any :class:`wx.Window` - derived control.
+
+        .. note:: This method looks redundant if `evt.Skip()` is
+           called as well - the base :class:`ScrolledWindow` widget now seems
+           to be doing the same thing anyway.
+
+        """
+
+        sppu_x, sppu_y = self.GetScrollPixelsPerUnit()
+        vs_x, vs_y   = self.GetViewStart()
+        cr = child.GetRect()
+        clntsz = self.GetClientSize()
+        new_vs_x, new_vs_y = -1, -1
+
+        # is it before the left edge?
+        if cr.x < 0 and sppu_x > 0:
+            new_vs_x = vs_x + (cr.x / sppu_x)
+
+        # is it above the top?
+        if cr.y < 0 and sppu_y > 0:
+            new_vs_y = vs_y + (cr.y / sppu_y)
+
+        # For the right and bottom edges, scroll enough to show the
+        # whole control if possible, but if not just scroll such that
+        # the top/left edges are still visible
+
+        # is it past the right edge ?
+        if cr.right > clntsz.width and sppu_x > 0:
+            diff = math.ceil(1.0 * (cr.right - clntsz.width + 1) / sppu_x)
+            if cr.x - diff * sppu_x > 0:
+                new_vs_x = vs_x + diff
+            else:
+                new_vs_x = vs_x + (cr.x / sppu_x)
+
+        # is it below the bottom ?
+        if cr.bottom > clntsz.height and sppu_y > 0:
+            diff = math.ceil(1.0 * (cr.bottom - clntsz.height + 1) / sppu_y)
+            if cr.y - diff * sppu_y > 0:
+                new_vs_y = vs_y + diff
+            else:
+                new_vs_y = vs_y + (cr.y / sppu_y)
+
+        # if we need to adjust
+        if new_vs_x != -1 or new_vs_y != -1:
+            #print("%s: (%s, %s)" % (self.GetName(), new_vs_x, new_vs_y))
+            self.Scroll(new_vs_x, new_vs_y)

wx/lib/sheet.py

@@ -0,0 +1,350 @@
+# sheet.py
+# CSheet - A wxPython spreadsheet class.
+# This is free software.  Feel free to adapt it as you like.
+# Author: Mark F. Russo (russomf@hotmail.com) 2002/01/31
+# Tags: phoenix-port
+#---------------------------------------------------------------------------
+# 12/11/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+# o Untested.
+#
+
+import  string
+import  wx
+import  wx.grid
+
+#---------------------------------------------------------------------------
+class CTextCellEditor(wx.TextCtrl):
+    """ Custom text control for cell editing """
+    def __init__(self, parent, id, grid):
+        wx.TextCtrl.__init__(self, parent, id, "", style=wx.NO_BORDER)
+        self._grid = grid                           # Save grid reference
+        self.Bind(wx.EVT_CHAR, self.OnChar)
+
+    def OnChar(self, evt):                          # Hook OnChar for custom behavior
+        """Customizes char events """
+        key = evt.GetKeyCode()
+        if   key == wx.WXK_DOWN:
+            self._grid.DisableCellEditControl()     # Commit the edit
+            self._grid.MoveCursorDown(False)        # Change the current cell
+        elif key == wx.WXK_UP:
+            self._grid.DisableCellEditControl()     # Commit the edit
+            self._grid.MoveCursorUp(False)          # Change the current cell
+        elif key == wx.WXK_LEFT:
+            self._grid.DisableCellEditControl()     # Commit the edit
+            self._grid.MoveCursorLeft(False)        # Change the current cell
+        elif key == wx.WXK_RIGHT:
+            self._grid.DisableCellEditControl()     # Commit the edit
+            self._grid.MoveCursorRight(False)       # Change the current cell
+
+        evt.Skip()                                  # Continue event
+
+#---------------------------------------------------------------------------
+class CCellEditor(wx.grid.PyGridCellEditor):
+    """ Custom cell editor """
+    def __init__(self, grid):
+        wx.grid.PyGridCellEditor.__init__(self)
+        self._grid = grid                           # Save a reference to the grid
+
+    def Create(self, parent, id, evtHandler):
+        """ Create the actual edit control.  Must derive from wxControl.
+            Must Override
+        """
+        self._tc = CTextCellEditor(parent, id, self._grid)
+        self._tc.SetInsertionPoint(0)
+        self.SetControl(self._tc)
+        if evtHandler:
+            self._tc.PushEventHandler(evtHandler)
+
+    def SetSize(self, rect):
+        """ Position/size the edit control within the cell rectangle. """
+        # Size text control to exactly overlay in-cell editing
+        self._tc.SetSize(rect.x+3, rect.y+3, rect.width-2, rect.height-2)
+
+    def Show(self, show, attr):
+        """ Show or hide the edit control.  Use the attr (if not None)
+            to set colors or fonts for the control.
+
+            NOTE: There is no need to everride this if you don't need
+            to do something out of the ordinary.
+        """
+        super(CCellEditor, self).Show(show, attr)
+
+    def PaintBackground(self, rect, attr):
+        """ Draws the part of the cell not occupied by the edit control.  The
+            base class version just fills it with background colour from the
+            attribute.
+
+            NOTE: There is no need to everride this if you don't need
+            to do something out of the ordinary.
+        """
+        # Call base class method.
+        super(CCellEditor, self).PaintBackground(rect, attr)
+
+    def BeginEdit(self, row, col, grid):
+        """ Fetch the value from the table and prepare edit control to begin editing.
+            Set the focus to the edit control.  Must Override.
+        """
+        self._startValue = grid.GetTable().GetValue(row, col)
+        self._tc.SetValue(self._startValue)
+        self._tc.SetFocus()
+
+        # Select the text when initiating an edit so that subsequent typing
+        # replaces the contents.
+        self._tc.SetSelection(0, self._tc.GetLastPosition())
+
+    def EndEdit(self, row, col, grid):
+        """ Commit editing the current cell. Returns True if the value has changed.
+            If necessary, the control may be destroyed. Must Override.
+        """
+        changed = False                             # Assume value not changed
+        val = self._tc.GetValue()                   # Get value in edit control
+        if val != self._startValue:                 # Compare
+            changed = True                          # If different then changed is True
+            grid.GetTable().SetValue(row, col, val) # Update the table
+        self._startValue = ''                       # Clear the class' start value
+        self._tc.SetValue('')                       # Clear contents of the edit control
+
+        return changed
+
+    def Reset(self):
+        """ Reset the value in the control back to its starting value. Must Override. """
+        self._tc.SetValue(self._startValue)
+        self._tc.SetInsertionPointEnd()
+
+    def IsAcceptedKey(self, evt):
+        """ Return True to allow the given key to start editing.  The base class
+            version only checks that the event has no modifiers.  F2 is special
+            and will always start the editor.
+        """
+        return (not (evt.ControlDown() or evt.AltDown())
+                and  evt.GetKeyCode() != wx.WXK_SHIFT)
+
+    def StartingKey(self, evt):
+        """ If the editor is enabled by pressing keys on the grid, this will be
+            called to let the editor react to that first key.
+        """
+        key = evt.GetKeyCode()              # Get the key code
+        ch = None                           # Handle num pad keys
+        if key in [ wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3,
+                    wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7,
+                    wx.WXK_NUMPAD8, wx.WXK_NUMPAD9]:
+            ch = chr(ord('0') + key - wx.WXK_NUMPAD0)
+
+        elif key == wx.WXK_BACK:               # Empty text control when init w/ back key
+            ch = ""
+                                            # Handle normal keys
+        elif key < 256 and key >= 0 and chr(key) in string.printable:
+            ch = chr(key)
+            if not evt.ShiftDown():
+                ch = ch.lower()
+
+        if ch is not None:                  # If are at this point with a key,
+            self._tc.SetValue(ch)           # replace the contents of the text control.
+            self._tc.SetInsertionPointEnd() # Move to the end so that subsequent keys are appended
+        else:
+            evt.Skip()
+
+    def StartingClick(self):
+        """ If the editor is enabled by clicking on the cell, this method will be
+            called to allow the editor to simulate the click on the control.
+        """
+        pass
+
+    def Destroy(self):
+        """ Final cleanup
+
+            NOTE: There is no need to everride this if you don't need
+            to do something out of the ordinary.
+        """
+        super(CCellEditor, self).Destroy()
+
+    def Clone(self):
+        """ Create a new object which is the copy of this one. Must Override. """
+        return CCellEditor()
+
+#---------------------------------------------------------------------------
+class CSheet(wx.grid.Grid):
+    def __init__(self, parent):
+        wx.grid.Grid.__init__(self, parent, -1)
+
+        # Init variables
+        self._lastCol = -1              # Init last cell column clicked
+        self._lastRow = -1              # Init last cell row clicked
+        self._selected = None           # Init range currently selected
+                                        # Map string datatype to default renderer/editor
+        self.RegisterDataType(wx.grid.GRID_VALUE_STRING,
+                              wx.grid.GridCellStringRenderer(),
+                              CCellEditor(self))
+
+        self.CreateGrid(4, 3)           # By default start with a 4 x 3 grid
+        self.SetColLabelSize(18)        # Default sizes and alignment
+        self.SetRowLabelSize(50)
+        self.SetRowLabelAlignment(wx.ALIGN_RIGHT, wx.ALIGN_BOTTOM)
+        self.SetColSize(0, 75)          # Default column sizes
+        self.SetColSize(1, 75)
+        self.SetColSize(2, 75)
+
+        # Sink events
+        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnLeftClick)
+        self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightClick)
+        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.OnLeftDoubleClick)
+        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
+        self.Bind(wx.grid.EVT_GRID_ROW_SIZE, self.OnRowSize)
+        self.Bind(wx.grid.EVT_GRID_COL_SIZE, self.OnColSize)
+        self.Bind(wx.grid.EVT_GRID_CELL_CHANGED, self.OnCellChange)
+        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnGridSelectCell)
+
+    def OnGridSelectCell(self, event):
+        """ Track cell selections """
+        # Save the last cell coordinates
+        self._lastRow, self._lastCol = event.GetRow(), event.GetCol()
+        event.Skip()
+
+    def OnRowSize(self, event):
+        event.Skip()
+
+    def OnColSize(self, event):
+        event.Skip()
+
+    def OnCellChange(self, event):
+        event.Skip()
+
+    def OnLeftClick(self, event):
+        """ Override left-click behavior to prevent left-click edit initiation """
+        # Save the cell clicked
+        currCell = (event.GetRow(), event.GetCol())
+
+        # Suppress event if same cell clicked twice in a row.
+        # This prevents a single-click from initiating an edit.
+        if currCell != (self._lastRow, self._lastCol): event.Skip()
+
+    def OnRightClick(self, event):
+        """ Move grid cursor when a cell is right-clicked """
+        self.SetGridCursor( event.GetRow(), event.GetCol() )
+        event.Skip()
+
+    def OnLeftDoubleClick(self, event):
+        """ Initiate the cell editor on a double-click """
+        # Move grid cursor to double-clicked cell
+        if self.CanEnableCellControl():
+            self.SetGridCursor( event.GetRow(), event.GetCol() )
+            self.EnableCellEditControl(True)    # Show the cell editor
+        event.Skip()
+
+    def OnRangeSelect(self, event):
+        """ Track which cells are selected so that copy/paste behavior can be implemented """
+        # If a single cell is selected, then Selecting() returns False (0)
+        # and range coords are entire grid.  In this case cancel previous selection.
+        # If more than one cell is selected, then Selecting() is True (1)
+        # and range accurately reflects selected cells.  Save them.
+        # If more cells are added to a selection, selecting remains True (1)
+        self._selected = None
+        if event.Selecting():
+            self._selected = ((event.GetTopRow(), event.GetLeftCol()),
+                              (event.GetBottomRow(), event.GetRightCol()))
+        event.Skip()
+
+    def Copy(self):
+        """ Copy the currently selected cells to the clipboard """
+        # TODO: raise an error when there are no cells selected?
+        if self._selected is None: return
+        ((r1, c1), (r2, c2)) = self._selected
+
+        # Build a string to put on the clipboard
+        # (Is there a faster way to do this in Python?)
+        crlf = chr(13) + chr(10)
+        tab = chr(9)
+        s = ""
+        for row in range(r1, r2+1):
+            for col in range(c1, c2):
+                s += self.GetCellValue(row,col)
+                s += tab
+            s += self.GetCellValue(row, c2)
+            s += crlf
+
+        # Put the string on the clipboard
+        if wx.TheClipboard.Open():
+            wx.TheClipboard.Clear()
+            wx.TheClipboard.SetData(wx.TextDataObject(s))
+            wx.TheClipboard.Close()
+
+    def Paste(self):
+        """ Paste the contents of the clipboard into the currently selected cells """
+        # (Is there a better way to do this?)
+        if wx.TheClipboard.Open():
+            td = wx.TextDataObject()
+            success = wx.TheClipboard.GetData(td)
+            wx.TheClipboard.Close()
+            if not success: return              # Exit on failure
+            s = td.GetText()                    # Get the text
+
+            crlf = chr(13) + chr(10)            # CrLf characters
+            tab = chr(9)                        # Tab character
+
+            rows = s.split(crlf)               # split into rows
+            rows = rows[0:-1]                   # leave out last element, which is always empty
+            for i in range(0, len(rows)):       # split rows into elements
+                rows[i] = rows[i].split(tab)
+
+            # Get the starting and ending cell range to paste into
+            if self._selected is None:          # If no cells selected...
+                r1 = self.GetGridCursorRow()    # Start the paste at the current location
+                c1 = self.GetGridCursorCol()
+                r2 = self.GetNumberRows()-1     # Go to maximum row and col extents
+                c2 = self.GetNumberCols()-1
+            else:                               # If cells selected, only paste there
+                ((r1, c1), (r2, c2)) = self._selected
+
+            # Enter data into spreadsheet cells one at a time
+            r = r1                              # Init row and column counters
+            c = c1
+            for row in rows:                    # Loop over all rows
+                for element in row:             # Loop over all row elements
+                    self.SetCellValue(r, c, str(element))   # Set cell value
+                    c += 1                      # Increment the column counter
+                    if c > c2: break            # Do not exceed maximum column
+                r += 1
+                if r > r2: break                # Do not exceed maximum row
+                c = c1
+
+    def Clear(self):
+        """ Clear the currently selected cells """
+        if self._selected is None:              # If no selection...
+            r = self.GetGridCursorRow()         # clear only current cell
+            c = self.GetGridCursorCol()
+            self.SetCellValue(r, c, "")
+        else:                                   # Otherwise clear selected cells
+            ((r1, c1), (r2, c2)) = self._selected
+            for r in range(r1, r2+1):
+                for c in range(c1, c2+1):
+                    self.SetCellValue(r, c, "")
+
+    def SetNumberRows(self, numRows=1):
+        """ Set the number of rows in the sheet """
+        # Check for non-negative number
+        if numRows < 0:  return False
+
+        # Adjust number of rows
+        curRows = self.GetNumberRows()
+        if curRows < numRows:
+            self.AppendRows(numRows - curRows)
+        elif curRows > numRows:
+            self.DeleteRows(numRows, curRows - numRows)
+
+        return True
+
+    def SetNumberCols(self, numCols=1):
+        """ Set the number of columns in the sheet """
+        # Check for non-negative number
+        if numCols < 0:  return False
+
+        # Adjust number of rows
+        curCols = self.GetNumberCols()
+        if curCols < numCols:
+            self.AppendCols(numCols - curCols)
+        elif curCols > numCols:
+            self.DeleteCols(numCols, curCols - numCols)
+
+        return True