wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/plot/utils.py

@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=E1101, C0330, C0103
+#   E1101: Module X has no Y member
+#   C0330: Wrong continued indentation
+#   C0103: Invalid attribute/variable/method name
+"""
+utils.py
+=========
+
+This is a collection of utilities used by the :mod:`wx.lib.plot` package.
+
+"""
+__docformat__ = "restructuredtext en"
+
+# Standard Library
+import functools
+import inspect
+import itertools
+from warnings import warn as _warn
+
+# Third Party
+import wx
+import numpy as np
+
+class PlotPendingDeprecation(wx.wxPyDeprecationWarning):
+    pass
+
+class DisplaySide(object):
+    """
+    Generic class for describing which sides of a box are displayed.
+
+    Used for fine-tuning the axis, ticks, and values of a graph.
+
+    This class somewhat mimics a collections.namedtuple factory function in
+    that it is an iterable and can have indiviual elements accessible by name.
+    It differs from a namedtuple in a few ways:
+
+    - it's mutable
+    - it's not a factory function but a full-fledged class
+    - it contains type checking, only allowing boolean values
+    - it contains name checking, only allowing valid_names as attributes
+
+    :param bottom: Display the bottom side
+    :type bottom: bool
+    :param left: Display the left side
+    :type left: bool
+    :param top: Display the top side
+    :type top: bool
+    :param right: Display the right side
+    :type right: bool
+    """
+    # TODO: Do I want to replace with __slots__?
+    #       Not much memory gain because this class is only called a small
+    #       number of times, but it would remove the need for part of
+    #       __setattr__...
+    valid_names = ("bottom", "left", "right", "top")
+
+    def __init__(self, bottom, left, top, right):
+        if not all([isinstance(x, bool) for x in [bottom, left, top, right]]):
+            raise TypeError("All args must be bools")
+        self.bottom = bottom
+        self.left = left
+        self.top = top
+        self.right = right
+
+    def __str__(self):
+        s = "{}(bottom={}, left={}, top={}, right={})"
+        s = s.format(self.__class__.__name__,
+                     self.bottom,
+                     self.left,
+                     self.top,
+                     self.right,
+                     )
+        return s
+
+    def __repr__(self):
+        # for now, just return the str representation
+        return self.__str__()
+
+    def __setattr__(self, name, value):
+        """
+        Override __setattr__ to implement some type checking and prevent
+        other attributes from being created.
+        """
+        if name not in self.valid_names:
+            err_str = "attribute must be one of {}"
+            raise NameError(err_str.format(self.valid_names))
+        if not isinstance(value, bool):
+            raise TypeError("'{}' must be a boolean".format(name))
+        self.__dict__[name] = value
+
+    def __len__(self):
+        return 4
+
+    def __hash__(self):
+        return hash(tuple(self))
+
+    def __getitem__(self, key):
+        return (self.bottom, self.left, self.top, self.right)[key]
+
+    def __setitem__(self, key, value):
+        if key == 0:
+            self.bottom = value
+        elif key == 1:
+            self.left = value
+        elif key == 2:
+            self.top = value
+        elif key == 3:
+            self.right = value
+        else:
+            raise IndexError("list index out of range")
+
+    def __iter__(self):
+        return iter([self.bottom, self.left, self.top, self.right])
+
+
+# TODO: replace with wx.DCPenChanger/wx.DCBrushChanger, etc.
+#       Alternatively, replace those with this function...
+class TempStyle(object):
+    """
+    Decorator / Context Manager to revert pen or brush changes.
+
+    Will revert pen, brush, or both to their previous values after a method
+    call or block finish.
+
+    :param which: The item to save and revert after execution. Can be
+                  one of ``{'both', 'pen', 'brush'}``.
+    :type which: str
+    :param dc: The DC to get brush/pen info from.
+    :type dc: :class:`wx.DC`
+
+    ::
+
+        # Using as a method decorator:
+        @TempStyle()                        # same as @TempStyle('both')
+        def func(self, dc, a, b, c):        # dc must be 1st arg (beside self)
+            # edit pen and brush here
+
+        # Or as a context manager:
+        with TempStyle('both', dc):
+            # do stuff
+
+    .. Note::
+
+       As of 2016-06-15, this can only be used as a decorator for **class
+       methods**, not standard functions. There is a plan to try and remove
+       this restriction, but I don't know when that will happen...
+
+    .. epigraph::
+
+       *Combination Decorator and Context Manager! Also makes Julienne fries!
+       Will not break! Will not... It broke!*
+
+       -- The Genie
+    """
+    _valid_types = {'both', 'pen', 'brush'}
+    _err_str = (
+        "No DC provided and unable to determine DC from context for function "
+        "`{func_name}`. When `{cls_name}` is used as a decorator, the "
+        "decorated function must have a wx.DC as a keyword arg 'dc=' or "
+        "as the first arg."
+    )
+
+    def __init__(self, which='both', dc=None):
+        if which not in self._valid_types:
+            raise ValueError(
+                "`which` must be one of {}".format(self._valid_types)
+            )
+        self.which = which
+        self.dc = dc
+        self.prevPen = None
+        self.prevBrush = None
+
+    def __call__(self, func):
+
+        @functools.wraps(func)
+        def wrapper(instance, dc, *args, **kwargs):
+            # fake the 'with' block. This solves:
+            # 1.  plots only being shown on 2nd menu selection in demo
+            # 2.  self.dc compalaining about not having a super called when
+            #     trying to get or set the pen/brush values in __enter__ and
+            #     __exit__:
+            #         RuntimeError: super-class __init__() of type
+            #         BufferedDC was never called
+            self._save_items(dc)
+            func(instance, dc, *args, **kwargs)
+            self._revert_items(dc)
+
+            #import copy                    # copy solves issue #1 above, but
+            #self.dc = copy.copy(dc)        # possibly causes issue #2.
+
+            #with self:
+            #    print('in with')
+            #    func(instance, dc, *args, **kwargs)
+
+        return wrapper
+
+    def __enter__(self):
+        self._save_items(self.dc)
+        return self
+
+    def __exit__(self, *exc):
+        self._revert_items(self.dc)
+        return False    # True means exceptions *are* suppressed.
+
+    def _save_items(self, dc):
+        if self.which == 'both':
+            self._save_pen(dc)
+            self._save_brush(dc)
+        elif self.which == 'pen':
+            self._save_pen(dc)
+        elif self.which == 'brush':
+            self._save_brush(dc)
+        else:
+            err_str = ("How did you even get here?? This class forces "
+                       "correct values for `which` at instancing..."
+                       )
+            raise ValueError(err_str)
+
+    def _revert_items(self, dc):
+        if self.which == 'both':
+            self._revert_pen(dc)
+            self._revert_brush(dc)
+        elif self.which == 'pen':
+            self._revert_pen(dc)
+        elif self.which == 'brush':
+            self._revert_brush(dc)
+        else:
+            err_str = ("How did you even get here?? This class forces "
+                       "correct values for `which` at instancing...")
+            raise ValueError(err_str)
+
+    def _save_pen(self, dc):
+        self.prevPen = dc.GetPen()
+
+    def _save_brush(self, dc):
+        self.prevBrush = dc.GetBrush()
+
+    def _revert_pen(self, dc):
+        dc.SetPen(self.prevPen)
+
+    def _revert_brush(self, dc):
+        dc.SetBrush(self.prevBrush)
+
+
+def pendingDeprecation(new_func):
+    """
+    Raise `PendingDeprecationWarning` and display a message.
+
+    Uses inspect.stack() to determine the name of the item that this
+    is called from.
+
+    :param new_func: The name of the function that should be used instead.
+    :type new_func: string.
+    """
+    warn_txt = "`{}` is pending deprecation. Please use `{}` instead."
+    _warn(warn_txt.format(inspect.stack()[1][3], new_func),
+          PlotPendingDeprecation)
+
+
+def scale_and_shift_point(x, y, scale=1, shift=0):
+    """
+    Creates a scaled and shifted 2x1 numpy array of [x, y] values.
+
+    The shift value must be in the scaled units.
+
+    :param float `x`:        The x value of the unscaled, unshifted point
+    :param float `y`:        The y valye of the unscaled, unshifted point
+    :param np.array `scale`: The scale factor to use ``[x_sacle, y_scale]``
+    :param np.array `shift`: The offset to apply ``[x_shift, y_shift]``.
+                             Must be in scaled units
+
+    :returns: a numpy array of 2 elements
+    :rtype: np.array
+
+    .. note::
+
+       :math:`new = (scale * old) + shift`
+    """
+    point = scale * np.array([x, y]) + shift
+    return point
+
+
+def set_displayside(value):
+    """
+    Wrapper around :class:`~wx.lib.plot._DisplaySide` that allows for "overloaded" calls.
+
+    If ``value`` is a boolean: all 4 sides are set to ``value``
+
+    If ``value`` is a 2-tuple: the bottom and left sides are set to ``value``
+    and the other sides are set to False.
+
+    If ``value`` is a 4-tuple, then each item is set individually: ``(bottom,
+    left, top, right)``
+
+    :param value: Which sides to display.
+    :type value:   bool, 2-tuple of bool, or 4-tuple of bool
+    :raises: `TypeError` if setting an invalid value.
+    :raises: `ValueError` if the tuple has incorrect length.
+    :rtype: :class:`~wx.lib.plot._DisplaySide`
+    """
+    err_txt = ("value must be a bool or a 2- or 4-tuple of bool")
+
+    # TODO: for 2-tuple, do not change other sides? rather than set to False.
+    if isinstance(value, bool):
+        # turns on or off all axes
+        _value = (value, value, value, value)
+    elif isinstance(value, tuple):
+        if len(value) == 2:
+            _value = (value[0], value[1], False, False)
+        elif len(value) == 4:
+            _value = value
+        else:
+            raise ValueError(err_txt)
+    else:
+        raise TypeError(err_txt)
+    return DisplaySide(*_value)
+
+
+def pairwise(iterable):
+    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+if __name__ == "__main__":
+    raise RuntimeError("This module is not intended to be run by itself.")

wx/lib/popupctl.py

@@ -0,0 +1,250 @@
+#----------------------------------------------------------------------
+# Name:         popup
+# Purpose:      Generic popup control
+#
+# Author:       Gerrit van Dyk
+#
+# Created:      2002/11/20
+# Version:      0.1
+# License:      wxWindows license
+# Tags:         phoenix-port
+# (c) 2022 Zombie
+#----------------------------------------------------------------------
+# 11/24/2007 - Cody Precord
+#
+# o Use RendererNative to draw button
+#
+# 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+#
+# 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wxPopupDialog -> PopupDialog
+# o wxPopupControl -> PopupControl
+#
+
+import  wx
+from wx.lib.buttons import GenButtonEvent
+
+
+class PopButton(wx.Control):
+    def __init__(self,*_args,**_kwargs):
+        wx.Control.__init__(self, *_args, **_kwargs)
+
+        self.up = True
+        self.didDown = False
+
+        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+        self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
+        self.Bind(wx.EVT_MOTION, self.OnMotion)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+    def Notify(self):
+        evt = GenButtonEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, self.GetId())
+        evt.SetIsDown(not self.up)
+        evt.SetButtonObj(self)
+        evt.SetEventObject(self)
+        self.GetEventHandler().ProcessEvent(evt)
+
+    def OnEraseBackground(self, event):
+        pass
+
+    def OnLeftDown(self, event):
+        if not self.IsEnabled():
+            return
+        self.didDown = True
+        self.up = False
+        self.CaptureMouse()
+        self.GetParent().textCtrl.SetFocus()
+        self.Refresh()
+        event.Skip()
+
+    def OnLeftUp(self, event):
+        if not self.IsEnabled():
+            return
+        if self.didDown:
+            self.ReleaseMouse()
+            if not self.up:
+                self.Notify()
+            self.up = True
+            self.Refresh()
+            self.didDown = False
+        event.Skip()
+
+    def OnMotion(self, event):
+        if not self.IsEnabled():
+            return
+        if event.LeftIsDown():
+            if self.didDown:
+                x,y = event.GetPosition()
+                w,h = self.GetClientSize()
+                if self.up and x<w and x>=0 and y<h and y>=0:
+                    self.up = False
+                    self.Refresh()
+                    return
+                if not self.up and (x<0 or y<0 or x>=w or y>=h):
+                    self.up = True
+                    self.Refresh()
+                    return
+        event.Skip()
+
+    def OnPaint(self, event):
+        dc = wx.BufferedPaintDC(self)
+        if self.up:
+            flag = wx.CONTROL_CURRENT
+        else:
+            flag = wx.CONTROL_PRESSED
+        wx.RendererNative.Get().DrawComboBoxDropButton(self, dc, self.GetClientRect(), flag)
+
+
+#---------------------------------------------------------------------------
+
+
+# Tried to use wxPopupWindow but the control misbehaves on MSW
+class PopupDialog(wx.Dialog):
+    def __init__(self,parent,content = None):
+        wx.Dialog.__init__(self,parent,-1,'', style = wx.BORDER_SIMPLE|wx.STAY_ON_TOP)
+
+        self.ctrl = parent
+        self.win = wx.Window(self,-1,pos = (0,0),style = 0)
+
+        if content:
+            self.SetContent(content)
+
+    def SetContent(self,content):
+        self.content = content
+        self.content.Reparent(self.win)
+        self.content.Show(True)
+        self.win.SetClientSize(self.content.GetSize())
+        self.SetSize(self.win.GetSize())
+
+    def Display(self):
+        pos = self.ctrl.ClientToScreen( (0,0) )
+        dSize = wx.GetDisplaySize()
+        selfSize = self.GetSize()
+        tcSize = self.ctrl.GetSize()
+
+        pos.x -= (selfSize.width - tcSize.width) // 2
+        if pos.x + selfSize.width > dSize.width:
+            pos.x = dSize.width - selfSize.width
+        if pos.x < 0:
+            pos.x = 0
+
+        pos.y += tcSize.height
+        if pos.y + selfSize.height > dSize.height:
+            pos.y = dSize.height - selfSize.height
+        if pos.y < 0:
+            pos.y = 0
+
+        self.Move(pos)
+
+        self.ctrl.FormatContent()
+
+        self.ShowModal()
+
+
+#---------------------------------------------------------------------------
+
+
+class PopupControl(wx.Control):
+    def __init__(self,*_args,**_kwargs):
+        if 'value' in _kwargs:
+            del _kwargs['value']
+        style = _kwargs.get('style', 0)
+        if (style & wx.BORDER_MASK) == 0:
+            style |= wx.BORDER_NONE
+            _kwargs['style'] = style
+        wx.Control.__init__(self, *_args, **_kwargs)
+
+        self.textCtrl = wx.TextCtrl(self, wx.ID_ANY, '', pos = (0,0))
+        self.bCtrl = PopButton(self, wx.ID_ANY, style=wx.BORDER_NONE)
+        self.pop = None
+        self.content = None
+
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.bCtrl.Bind(wx.EVT_BUTTON, self.OnButton, self.bCtrl)
+        self.Bind(wx.EVT_SET_FOCUS, self.OnFocus)
+
+        self.SetInitialSize(_kwargs.get('size', wx.DefaultSize))
+        self.SendSizeEvent()
+
+
+    def OnFocus(self,evt):
+        # embedded control should get focus on TAB keypress
+        self.textCtrl.SetFocus()
+        evt.Skip()
+
+
+    def OnSize(self, evt):
+        # layout the child widgets
+        w,h = self.GetClientSize()
+        self.textCtrl.SetSize(0, 0, w - self.marginWidth - self.buttonWidth, h)
+        self.bCtrl.SetSize(w - self.buttonWidth, 0, self.buttonWidth, h)
+
+    def DoGetBestSize(self):
+        # calculate the best size of the combined control based on the
+        # needs of the child widgets.
+        tbs = self.textCtrl.GetBestSize()
+        return wx.Size(tbs.width + self.marginWidth + self.buttonWidth,
+                       tbs.height)
+
+
+    def OnButton(self, evt):
+        if not self.pop:
+            if self.content:
+                self.pop = PopupDialog(self,self.content)
+                del self.content
+            else:
+                print('No Content to pop')
+        if self.pop:
+            self.pop.Display()
+
+
+    def Enable(self, flag):
+        wx.Control.Enable(self,flag)
+        self.textCtrl.Enable(flag)
+        self.bCtrl.Enable(flag)
+
+
+    def SetPopupContent(self, content):
+        if not self.pop:
+            self.content = content
+            self.content.Show(False)
+        else:
+            self.pop.SetContent(content)
+
+    def FormatContent(self):
+        pass
+
+    def PopDown(self):
+        if self.pop:
+            self.pop.EndModal(1)
+
+    def SetValue(self, value):
+        self.textCtrl.SetValue(value)
+
+    def GetValue(self):
+        return self.textCtrl.GetValue()
+
+    def SetFont(self, font):
+        self.textCtrl.SetFont(font)
+
+    def GetFont(self):
+        return self.textCtrl.GetFont()
+
+
+    def _get_marginWidth(self):
+        if 'wxMac' in wx.PlatformInfo:
+            return 6
+        else:
+            return 3
+    marginWidth = property(_get_marginWidth)
+
+    def _get_buttonWidth(self):
+        return 20
+    buttonWidth = property(_get_buttonWidth)
+
+
+# an alias
+PopupCtrl = PopupControl