wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/rcsizer.py

@@ -0,0 +1,229 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.rcsizer
+# Purpose:     RowColSizer:
+#
+# Author:      Robin Dunn, adapted from code by Niki Spahiev
+#
+# Created:     26-Feb-2002
+# Copyright:   (c) 2002-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+# 12/10/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+# o There appears to be a prob with the wx.Sizer.GetSize() method.
+#
+# 12/23/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wx.Sizer.GetSize() method working right now.
+#
+
+"""
+A pure-Python Sizer that lays out items in a grid similar to
+wx.FlexGridSizer but item position is not implicit but explicitly
+specified by row and col, and row/col spanning is supported.
+
+Adapted from code by Niki Spahiev.
+
+NOTE: There is now a C++ version of this class that has been wrapped
+as wx.GridBagSizer.  It is quicker and more capable so you are
+encouraged to switch.
+"""
+
+import  operator
+import  wx
+
+import six
+if six.PY3:
+    from functools import reduce as reduce
+
+# After the lib and demo no longer uses this sizer enable this warning...
+
+## import  warnings
+## warningmsg = r"""\
+
+## #####################################################\
+## # THIS MODULE IS NOW DEPRECATED                      |
+## #                                                    |
+## # The core wx library now contains a similar class   |
+## # wrapped as wx.GridBagSizer.                        |
+## #####################################################/
+
+## """
+
+## warnings.warn(warningmsg, DeprecationWarning, stacklevel=2)
+
+#----------------------------------------------------------------------
+
+class RowColSizer(wx.Sizer):
+
+    # default sizes for cells with no item
+    col_w = 10
+    row_h = 22
+
+    def __init__(self):
+        wx.Sizer.__init__(self)
+        self.growableRows = []
+        self.growableCols = []
+
+
+    def AddGrowableRow(self, idx):
+        self.growableRows.append(idx)
+
+    def AddGrowableCol(self, idx):
+        self.growableCols.append(idx)
+
+
+    #--------------------------------------------------
+    def Add(self, item, option=0, flag=0, border=0,
+            # row, col and spanning can be specified individually...
+            row=-1, col=-1,
+            rowspan=1, colspan=1,
+            # or as tuples (row,col) and (rowspan,colspan)
+            pos=None, size=None,
+            ):
+
+        if pos is not None:
+            row, col = pos
+        if size is not None:
+            rowspan, colspan = size
+
+        assert row != -1, "Row must be specified"
+        assert col != -1, "Column must be specified"
+
+        # Do I really want to do this?  Probably not...
+        #if rowspan > 1 or colspan > 1:
+        #    flag = flag | wx.EXPAND
+
+        return wx.Sizer.Add(self, item, option, flag, border,
+                              userData=(row, col, row+rowspan, col+colspan))
+
+    #AddWindow = Add
+    #AddSizer  = Add
+
+    def AddSpacer(self, width, height, option=0, flag=0, border=0,
+                  row=-1, col=-1,
+                  rowspan=1, colspan=1,
+                  pos=None, size=None,
+                  ):
+        if pos is not None:
+            row, col = pos
+        if size is not None:
+            rowspan, colspan = size
+
+        assert row != -1, "Row must be specified"
+        assert col != -1, "Column must be specified"
+
+        return wx.Sizer.Add(self, (width, height), option, flag, border,
+                              userData=(row, col, row+rowspan, col+colspan))
+
+    #--------------------------------------------------
+    def _add( self, size, dim ):
+        r, c, r2, c2 = dim   # unpack coords and spanning
+
+        # are the widths and heights lists long enough?
+        if r2 > len(self.rowHeights):
+            x = [self.row_h] * (r2-len(self.rowHeights))
+            self.rowHeights.extend( x )
+        if c2 > len(self.colWidths):
+            x = [self.col_w] * (c2-len(self.colWidths))
+            self.colWidths.extend( x )
+
+        # set the widths and heights lists for this item
+        scale = (r2 - r)
+        for i in range(r, r2):
+            self.rowHeights[i] = max( self.rowHeights[i], size.height / scale )
+        scale = (c2 - c)
+        for i in range(c, c2):
+            self.colWidths[i] = max( self.colWidths[i], size.width / scale )
+
+
+    #--------------------------------------------------
+    def CalcMin( self ):
+        self.rowHeights = []
+        self.colWidths = []
+
+        items = self.GetChildren()
+        if not items:
+            return wx.Size(10, 10)
+
+        for item in items:
+            self._add( item.CalcMin(), item.GetUserData() )
+
+        size = wx.Size( reduce( operator.add, self.colWidths),
+                        reduce( operator.add, self.rowHeights) )
+        return size
+
+
+    #--------------------------------------------------
+    def RecalcSizes( self ):
+        # save current dimensions, etc.
+        curWidth, curHeight  = self.GetSize()
+        px, py = self.GetPosition()
+        minWidth, minHeight  = self.CalcMin()
+
+        # Check for growables
+        if self.growableRows and curHeight > minHeight:
+            delta = (curHeight - minHeight) / len(self.growableRows)
+            extra = (curHeight - minHeight) % len(self.growableRows)
+            for idx in self.growableRows:
+                self.rowHeights[idx] += delta
+            self.rowHeights[self.growableRows[0]] += extra
+
+        if self.growableCols and curWidth > minWidth:
+            delta = (curWidth - minWidth) / len(self.growableCols)
+            extra = (curWidth - minWidth) % len(self.growableCols)
+            for idx in self.growableCols:
+                self.colWidths[idx] += delta
+            self.colWidths[self.growableCols[0]] += extra
+
+        rpos = [0] * len(self.rowHeights)
+        cpos = [0] * len(self.colWidths)
+
+        for i in range(len(self.rowHeights)):
+            height = self.rowHeights[i]
+            rpos[i] = py
+            py += height
+
+        for i in range(len(self.colWidths)):
+            width = self.colWidths[i]
+            cpos[i] = px
+            px += width
+
+        # iterate children and set dimensions...
+        for item in self.GetChildren():
+            r, c, r2, c2 = item.GetUserData()
+            width = reduce( operator.add, self.colWidths[c:c2] )
+            height = reduce( operator.add, self.rowHeights[r:r2] )
+            self.SetItemBounds( item, cpos[c], rpos[r], width, height )
+
+
+    #--------------------------------------------------
+    def SetItemBounds(self, item, x, y, w, h):
+        # calculate the item's actual size and position within
+        # its grid cell
+        ipt = wx.Point(x, y)
+        isz = item.CalcMin()
+        flag = item.GetFlag()
+
+        if flag & wx.EXPAND or flag & wx.SHAPED:
+            isz = wx.Size(w, h)
+        else:
+            if flag & wx.ALIGN_CENTER_HORIZONTAL:
+                ipt.x = x + (w - isz.width) / 2
+            elif flag & wx.ALIGN_RIGHT:
+                ipt.x = x + (w - isz.width)
+
+            if flag & wx.ALIGN_CENTER_VERTICAL:
+                ipt.y = y + (h - isz.height) / 2
+            elif flag & wx.ALIGN_BOTTOM:
+                ipt.y = y + (h - isz.height)
+
+        item.SetDimension(ipt, isz)
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+
+

wx/lib/resizewidget.py

@@ -0,0 +1,357 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.resizewidget
+# Purpose:     Adds a resize handle to any widget, with support for
+#              notifying parents when layout needs done.
+#
+# Author:      Robin Dunn
+#
+# Created:     12-June-2008
+# Copyright:   (c) 2008-2020 by Total Control Software
+# Licence:     wxWindows license
+# Tags:        phoenix-port, unittest, documented, py3-port
+#----------------------------------------------------------------------
+
+"""
+Reparents a given widget into a specialized panel that provides a resize
+handle for the widget. When the user drags the resize handle the widget is
+resized accordingly, and an event is sent to notify parents that they should
+recalculate their layout.
+"""
+
+import wx
+import wx.lib.newevent
+
+#-----------------------------------------------------------------------------
+
+# dimensions used for the handle
+RW_THICKNESS = 4
+RW_LENGTH = 12
+
+# default colors for the handle
+RW_PEN   = 'black'
+RW_FILL  = '#A0A0A0'
+RW_FILL2 = '#E0E0E0'
+
+# An event and event binder that will notify the containers that they should
+# redo the layout in whatever way makes sense for their particular content.
+_RWLayoutNeededEvent, EVT_RW_LAYOUT_NEEDED = wx.lib.newevent.NewCommandEvent()
+
+
+# TODO: Add a style flag that indicates that the ResizeWidget should
+# try to adjust the layout itself by looking up the sizer and
+# containment hierachy.  Maybe also a style that says that it is okay
+# to adjust the size of top-level windows too.
+
+#-----------------------------------------------------------------------------
+
+class ResizeWidget(wx.Panel):
+    """
+    Reparents a given widget into a specialized panel that provides a resize
+    handle for the widget.
+
+    """
+    def __init__(self, *args, **kw):
+        """
+        Default class constructor.
+
+        :param `args`: arguments will be passed on to the wx.Panel
+        :param `kw`: key words will be passed on to the wx.Panel
+
+        """
+        wx.Panel.__init__(self, *args, **kw)
+        self._init()
+
+        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+        self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
+        self.Bind(wx.EVT_MOTION,  self.OnMouseMove)
+        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnMouseLeave)
+
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+    def _init(self):
+        self._managedChild = None
+        self._bestSize = wx.Size(100, 25)
+        self.InvalidateBestSize()
+        self._resizeCursor = False
+        self._dragPos = None
+        self._resizeEnabled = True
+        self._reparenting = False
+
+        self.SetDimensions()
+        self.SetColors()
+
+    def SetDimensions(self, thickness=RW_THICKNESS, length=RW_LENGTH):
+        """
+        Set the dimensions of handles.
+
+        :param `thickness`: the thickness of the handles
+        :param `length`: the length of the handles
+
+        """
+        self.RW_THICKNESS = thickness
+        self.RW_LENGTH = length
+
+    def SetColors(self, pen=RW_PEN, fill=RW_FILL, fill2=RW_FILL2):
+        """
+        Set the colors of handles.
+
+        :param `pen`: the pen color
+        :param `fill`: the fill color
+        :param `fill2`: the secondary fill color
+
+        """
+        self.RW_PEN   = pen
+        self.RW_FILL  = fill
+        self.RW_FILL2 = fill2
+
+    def SetManagedChild(self, child):
+        """
+        Set a managed child.
+
+        :param `child`: child to manage
+
+        """
+        self._reparenting = True
+        child.Reparent(self)  # This calls AddChild, so do the rest of the init there
+        self._reparenting = False
+        self.AdjustToChild()
+
+    def GetManagedChild(self):
+        """Get the managed child."""
+        return self._managedChild
+
+    ManagedChild = property(GetManagedChild, SetManagedChild)
+
+
+    def AdjustToChild(self):
+        """Adjust the size to the child."""
+        self.AdjustToSize(self._managedChild.GetEffectiveMinSize())
+
+
+    def AdjustToSize(self, size):
+        """
+        Adjust to given size.
+
+        :param `size`: size to adjust to.
+
+        """
+        size = wx.Size(*size)
+        self._bestSize = size + (self.RW_THICKNESS, self.RW_THICKNESS)
+        self.InvalidateBestSize()
+        self.SetSize(self._bestSize)
+
+
+    def EnableResize(self, enable=True):
+        """
+        Enable resizing.
+
+        :param boolean `enable`: enable or disable resizing.
+
+        """
+        self._resizeEnabled = enable
+        self.Refresh(False)
+
+
+    def IsResizeEnabled(self):
+        """Is resize enabled?"""
+        return self._resizeEnabled
+
+
+    #=== Event handler methods ===
+    def OnLeftDown(self, evt):
+        """
+        Handles the ``wx.EVT_LEFT_DOWN`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`MouseEvent` event to be processed.
+
+        """
+        if self._hitTest(evt.GetPosition()) and self._resizeEnabled:
+            self.CaptureMouse()
+            self._dragPos = evt.GetPosition()
+
+
+    def OnLeftUp(self, evt):
+        """
+        Handles the ``wx.EVT_LEFT_UP`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`MouseEvent` event to be processed.
+
+        """
+        if self.HasCapture():
+            self.ReleaseMouse()
+        self._dragPos = None
+
+
+    def OnMouseMove(self, evt):
+        """
+        Handles the ``wx.EVT_MOTION`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`MouseEvent` event to be processed.
+
+        """
+        # set or reset the drag cursor
+        pos = evt.GetPosition()
+        if self._hitTest(pos) and self._resizeEnabled:
+            if not self._resizeCursor:
+                self.SetCursor(wx.Cursor(wx.CURSOR_SIZENWSE))
+                self._resizeCursor = True
+        else:
+            if self._resizeCursor:
+                self.SetCursor(wx.Cursor(wx.CURSOR_ARROW))
+                self._resizeCursor = False
+
+        # determine if a new size is needed
+        if evt.Dragging() and self._dragPos is not None:
+            delta = self._dragPos - pos
+            newSize = self.GetSize() - delta.Get()
+            self._adjustNewSize(newSize)
+            if newSize != self.GetSize():
+                self.SetSize(newSize)
+                self._dragPos = pos
+                self._bestSize = newSize
+                self.InvalidateBestSize()
+                self._sendEvent()
+
+
+    def _sendEvent(self):
+        event = _RWLayoutNeededEvent(self.GetId())
+        event.SetEventObject(self)
+        self.GetEventHandler().ProcessEvent(event)
+
+
+    def _adjustNewSize(self, newSize):
+        if newSize.width < self.RW_LENGTH:
+            newSize.width = self.RW_LENGTH
+        if newSize.height < self.RW_LENGTH:
+            newSize.height = self.RW_LENGTH
+
+        if self._managedChild:
+            minsize = self._managedChild.GetMinSize()
+            if minsize.width != -1 and newSize.width - self.RW_THICKNESS < minsize.width:
+                newSize.width = minsize.width + self.RW_THICKNESS
+            if minsize.height != -1 and newSize.height - self.RW_THICKNESS < minsize.height:
+                newSize.height = minsize.height + self.RW_THICKNESS
+            maxsize = self._managedChild.GetMaxSize()
+            if maxsize.width != -1 and newSize.width - self.RW_THICKNESS > maxsize.width:
+                newSize.width = maxsize.width + self.RW_THICKNESS
+            if maxsize.height != -1 and newSize.height - self.RW_THICKNESS > maxsize.height:
+                newSize.height = maxsize.height + self.RW_THICKNESS
+
+
+    def OnMouseLeave(self, evt):
+        """
+        Handles the ``wx.EVT_LEAVE_WINDOW`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`MouseEvent` event to be processed.
+
+        """
+        if self._resizeCursor:
+            self.SetCursor(wx.Cursor(wx.CURSOR_ARROW))
+            self._resizeCursor = False
+
+
+    def OnSize(self, evt):
+        """
+        Handles the ``wx.EVT_SIZE`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`wx.SizeEvent` event to be processed.
+
+        """
+        if not self._managedChild:
+            return
+        sz = self.GetSize()
+        cr = wx.Rect((0, 0), sz - (self.RW_THICKNESS, self.RW_THICKNESS))
+        self._managedChild.SetRect(cr)
+        r1 = wx.Rect(0, cr.height, sz.width, self.RW_THICKNESS)
+        r2 = wx.Rect(cr.width, 0, self.RW_THICKNESS, sz.height)
+        self.RefreshRect(r1)
+        self.RefreshRect(r2)
+
+
+    def OnPaint(self, evt):
+        """
+        Handles the ``wx.EVT_PAINT`` event for :class:`ResizeWidget`.
+
+        :param `evt`: a :class:`PaintEvent` event to be processed.
+
+        """
+        # draw the resize handle
+        dc = wx.PaintDC(self)
+        w, h = self.GetSize()
+        points = [ (w - 1,                 h - self.RW_LENGTH),
+                   (w - self.RW_THICKNESS, h - self.RW_LENGTH),
+                   (w - self.RW_THICKNESS, h - self.RW_THICKNESS),
+                   (w - self.RW_LENGTH,    h - self.RW_THICKNESS),
+                   (w - self.RW_LENGTH,    h - 1),
+                   (w - 1,                 h - 1),
+                   (w - 1,                 h - self.RW_LENGTH),
+                   ]
+        dc.SetPen(wx.Pen(self.RW_PEN, 1))
+        if self._resizeEnabled:
+            fill = self.RW_FILL
+        else:
+            fill = self.RW_FILL2
+        dc.SetBrush(wx.Brush(fill))
+        dc.DrawPolygon(points)
+
+
+    def _hitTest(self, pos):
+        # is the position in the area to be used for the resize handle?
+        w, h = self.GetSize()
+        if ( w - self.RW_THICKNESS <= pos.x <= w
+             and h - self.RW_LENGTH <= pos.y <= h ):
+            return True
+        if ( w - self.RW_LENGTH <= pos.x <= w
+             and h - self.RW_THICKNESS <= pos.y <= h ):
+            return True
+        return False
+
+
+    #=== Overriden virtuals from the base class ===
+    def AddChild(self, child):
+        """
+        Add the child to manage.
+
+        :param `child`: the child to manage.
+
+        """
+        assert self._managedChild is None, "Already managing a child widget, can only do one"
+        self._managedChild = child
+        wx.Panel.AddChild(self, child)
+
+        # This little hack is needed because if this AddChild was called when
+        # the widget was first created, then the OOR values will get reset
+        # after this function call, and so the Python proxy object saved in
+        # the window may be different than the child object we have now, so we
+        # need to reset which proxy object we're using.  Look for it by ID.
+        def _doAfterAddChild(self, id):
+            if not self:
+                return
+            child = self.FindWindow(id)
+            self._managedChild = child
+            self.AdjustToChild()
+            self._sendEvent()
+        if self._reparenting:
+            _doAfterAddChild(self, child.GetId())
+        else:
+            wx.CallAfter(_doAfterAddChild, self, child.GetId())
+
+    def RemoveChild(self, child):
+        """
+        Remove the managed child.
+
+        :param `child`: child to remove.
+
+        """
+        self._init()
+        wx.Panel.RemoveChild(self, child)
+
+
+    def DoGetBestSize(self):
+        """Return the best size."""
+        return self._bestSize
+
+
+#-----------------------------------------------------------------------------