wxPython 4.3.2__cp315-cp315-win_amd64.whl

wx/lib/ticker.py

@@ -0,0 +1,306 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.ticker
+# Purpose:     A news-ticker style scrolling text control
+#
+# Author:      Chris Mellon
+#
+# Created:     29-Aug-2004
+# Copyright:   (c) 2004 by Chris Mellon
+# Licence:     wxWindows license
+# Tags:        phoenix-port, unittest, documented, py3-port
+#----------------------------------------------------------------------
+
+"""
+News-ticker style scrolling text control
+
+    * Can scroll from right to left or left to right.
+
+    * Speed of the ticking is controlled by two parameters:
+
+      - Frames per Second(FPS): How many times per second the ticker updates
+
+      - Pixels per Frame(PPF): How many pixels the text moves each update
+
+Low FPS with high PPF will result in "jumpy" text, lower PPF with higher FPS
+is smoother (but blurrier and more CPU intensive) text.
+"""
+
+import wx
+
+#----------------------------------------------------------------------
+
+class Ticker(wx.Control):
+    def __init__(self,
+            parent,
+            id=-1,
+            text=wx.EmptyString,
+            fgcolor = wx.BLACK,
+            bgcolor = wx.WHITE,
+            start=True,
+            ppf=2,
+            fps=20,
+            direction="rtl",
+            pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.NO_BORDER,
+            name="Ticker"
+        ):
+        """
+        Default class constructor.
+
+        :param wx.Window `parent`: the parent
+        :param integer `id`: an identifier for the control: a value of -1 is taken to mean a default
+        :param string `text`: text in the ticker
+        :param wx.Colour `fgcolor`: text/foreground color
+        :param wx.Colour `bgcolor`: background color
+        :param boolean `start`: if True, the ticker starts immediately
+        :param int `ppf`: pixels per frame
+        :param int `fps`: frames per second
+        :param `direction`: direction of ticking, 'rtl' or 'ltr'
+        :param wx.Point `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 `name`: the control name
+
+        """
+        wx.Control.__init__(self, parent, id=id, pos=pos, size=size, style=style, name=name)
+        self.timer = wx.Timer(owner=self)
+        self._extent = (-1, -1)  #cache value for the GetTextExtent call
+        self._offset = 0
+        self._fps = fps  #frames per second
+        self._ppf = ppf  #pixels per frame
+        self.SetDirection(direction)
+        self.SetText(text)
+        self.SetInitialSize(size)
+        self.SetForegroundColour(fgcolor)
+        self.SetBackgroundColour(bgcolor)
+        self.Bind(wx.EVT_TIMER, self.OnTick)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnErase)
+        self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroyWindow)
+        if start:
+            self.Start()
+
+
+    def OnDestroyWindow(self, evt):
+        """
+        Handles the ``wx.EVT_WINDOW_DESTROY`` event for :class:`Ticker`.
+
+        :param `evt`: a :class:`wx.WindowDestroyEvent` event to be processed.
+
+        """
+        self.Stop()
+        evt.Skip()
+
+
+    def Stop(self):
+        """Stop moving the text"""
+        self.timer.Stop()
+
+
+    def Start(self):
+        """Starts the text moving"""
+        if not self.timer.IsRunning():
+            self.timer.Start(1000 // self._fps)
+
+
+    def IsTicking(self):
+        """Is the ticker ticking? ie, is the text moving?"""
+        return self.timer.IsRunning()
+
+
+    def SetFPS(self, fps):
+        """
+        Adjust the update speed of the ticker.
+
+        :param int `fps`: frames per second.
+
+        """
+        self._fps = fps
+        self.Stop()
+        self.Start()
+
+
+    def GetFPS(self):
+        """
+        Get the frames per second speed of the ticker.
+        """
+        return self._fps
+
+
+    def SetPPF(self, ppf):
+        """
+        Set the number of pixels per frame the ticker moves - ie,
+        how "jumpy" it is.
+
+        :param int `ppf`: the pixels per frame setting.
+
+        """
+        self._ppf = ppf
+
+
+    def GetPPF(self):
+        """Get pixels per frame setting."""
+        return self._ppf
+
+
+    def SetFont(self, font):
+        """
+        Set the font for the control.
+
+        :param wx.Font `font`: the font to be used.
+
+        """
+        self._extent = (-1, -1)
+        wx.Control.SetFont(self, font)
+
+
+    def SetDirection(self, dir):
+        """
+        Sets the direction of the ticker: right to left (rtl) or
+        left to right (ltr).
+
+        :param `dir`: the direction 'rtl' or 'ltr'
+
+        """
+        if dir == "ltr" or dir == "rtl":
+            if self._offset != 0:
+                #Change the offset so it's correct for the new direction
+                self._offset = self._extent[0] + self.GetSize()[0] - self._offset
+            self._dir = dir
+        else:
+            raise TypeError
+
+
+    def GetDirection(self):
+        """Get the set direction."""
+        return self._dir
+
+
+    def SetText(self, text):
+        """
+        Set the ticker text.
+
+        :param string `text`: the ticker text
+
+        """
+        self._text = text
+        self._extent = (-1, -1)
+        if not self._text:
+            self.Refresh() #Refresh here to clear away the old text.
+
+
+    def GetText(self):
+        """Get the current ticker text."""
+        return self._text
+
+
+    def UpdateExtent(self, dc):
+        """
+        Updates the cached text extent if needed.
+
+        :param wx.DC `dc`: the dc to use.
+
+        """
+        if not self._text:
+            self._extent = (-1, -1)
+            return
+        if self._extent == (-1, -1):
+            self._extent = dc.GetTextExtent(self.GetText())
+
+
+    def DrawText(self, dc):
+        """
+        Draws the ticker text at the current offset using the provided DC.
+
+        :param wx.DC `dc`: the dc to use.
+
+        """
+        dc.SetTextForeground(self.GetForegroundColour())
+        dc.SetFont(self.GetFont())
+        self.UpdateExtent(dc)
+        if self._dir == "ltr":
+            offx = self._offset - self._extent[0]
+        else:
+            offx = self.GetSize()[0] - self._offset
+        offy = (self.GetSize()[1] - self._extent[1]) // 2 #centered vertically
+        dc.DrawText(self._text, offx, offy)
+
+
+    def OnTick(self, evt):
+        """
+        Handles the ``wx.EVT_TIMER`` event for :class:`Ticker`.
+
+        :param `evt`: a :class:`TimerEvent` event to be processed.
+
+        """
+        self._offset += self._ppf
+        w1 = self.GetSize()[0]
+        w2 = self._extent[0]
+        if self._offset >= w1+w2:
+            self._offset = 0
+        self.Refresh()
+
+
+    def OnPaint(self, evt):
+        """
+        Handles the ``wx.EVT_PAINT`` event for :class:`Ticker`.
+
+        :param `evt`: a :class:`PaintEvent` event to be processed.
+
+        """
+        dc = wx.BufferedPaintDC(self)
+        brush = wx.Brush(self.GetBackgroundColour())
+        dc.SetBackground(brush)
+        dc.Clear()
+        self.DrawText(dc)
+
+
+    def OnErase(self, evt):
+        """
+        Noop because of double buffering
+
+        Handles the ``wx.EVT_ERASE_BACKGROUND`` event for :class:`Ticker`.
+
+        :param `evt`: a :class:`EraseEvent` event to be processed.
+
+        """
+        pass
+
+
+    def AcceptsFocus(self):
+        """Non-interactive, so don't accept focus"""
+        return False
+
+
+    def DoGetBestSize(self):
+        """
+        Width we don't care about, height is either -1, or the character
+        height of our text with a little extra padding
+        """
+        if self._extent == (-1, -1):
+            if not self._text:
+                h = self.GetCharHeight()
+            else:
+                h = self.GetTextExtent(self.GetText())[1]
+        else:
+            h = self._extent[1]
+        return (100, h+5)
+
+
+    def ShouldInheritColours(self):
+        """Don't get colours from our parent."""
+        return False
+
+
+
+#testcase/demo
+if __name__ == '__main__':
+    app = wx.App()
+    f = wx.Frame(None)
+    p = wx.Panel(f)
+    t = Ticker(p, text="Some sample ticker text")
+    #set ticker properties here if you want
+    s = wx.BoxSizer(wx.VERTICAL)
+    s.Add(t, flag=wx.GROW, proportion=0)
+    p.SetSizer(s)
+    f.Show()
+    app.MainLoop()
+

wx/lib/ticker_xrc.py

@@ -0,0 +1,48 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.ticker_xrc
+# Purpose:     A XRC handler for wx.lib.ticker
+#
+# Author:      Chris Mellon
+#
+# Created:     17-May-2005
+# Copyright:   (c) 2005 by Chris Mellon
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+
+import wx
+import wx.xrc as xrc
+from wx.lib.ticker import Ticker
+
+class wxTickerXmlHandler(xrc.XmlResourceHandler):
+    def __init__(self):
+        xrc.XmlResourceHandler.__init__(self)
+        self.AddWindowStyles()
+
+    def CanHandle(self, node):
+        return self.IsOfClass(node, "wxTicker")
+
+    def DoCreateResource(self):
+        t = Ticker(
+            self.GetParentAsWindow(),
+            self.GetID(),
+            pos = self.GetPosition(),
+            size = self.GetSize(),
+            style=self.GetStyle()
+        )
+        if self.HasParam("text"):
+            t.SetText(self.GetText("text"))
+        if self.HasParam("start"):
+            if self.GetBool("start"):
+                t.Start()
+            else:
+                t.Stop()
+        if self.HasParam("ppf"):
+            t.SetPPF(self.GetLong("ppf"))
+        if self.HasParam("fps"):
+            t.SetFPS(self.GetLong("fps"))
+        if self.HasParam("direction"):
+            t.SetDirection(self.GetText("direction"))
+
+        self.SetupWindow(t)     # handles font, bg/fg color
+        return t
+

wx/lib/utils.py

@@ -0,0 +1,89 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.utils
+# Purpose:     Miscellaneous utility functions
+#
+# Author:      Robin Dunn
+#
+# Created:     18-Jan-2009
+# Copyright:   (c) 2009-2020 Total Control Software
+# Licence:     wxWidgets license
+#
+# Tags:        phoenix-port, unittest, documented
+#
+#----------------------------------------------------------------------
+
+"""
+A few useful functions.  (Ok, only one so far...)
+"""
+
+import wx
+
+#---------------------------------------------------------------------------
+
+def AdjustRectToScreen(rect, adjust=(0,0)):
+    """
+    Compare the rect with the dimensions of the display that the rect's
+    upper left corner is positioned on. If it doesn't fit entirely on
+    screen then attempt to make it do so either by repositioning the
+    rectangle, resizing it, or both.  Returns the adjusted rectangle.
+
+    If the adjustment value is given then it will be used to ensure that
+    the rectangle is at least that much smaller than the display's client
+    area.
+
+    :param wx.Rect `rect`: the rectangle to be repositioned;
+    :param tuple `adjust`: if given, it will be used to ensure that
+     the rectangle is at least that much smaller than the display's client
+     area.
+
+    :rtype: `rect`
+    """
+
+    assert isinstance(rect, wx.Rect)
+    if -1 in rect.Get():
+        # bail out if there are any -1's in the dimensions
+        return rect
+
+    dispidx = wx.Display.GetFromPoint(rect.Position)
+    if dispidx == wx.NOT_FOUND:
+        dispidx = 0
+    ca = wx.Display(dispidx).GetClientArea()
+    assert isinstance(ca, wx.Rect)
+
+    # is it already fully visible?
+    if ca.Contains(rect):
+        return rect
+
+    # if not then try adjusting the position
+    if not ca.Contains(rect.Position):
+        rect.Position = ca.Position
+        if ca.Contains(rect):
+            return rect
+    dx = dy = 0
+    if rect.right > ca.right:
+        dx = ca.right - rect.right
+    if rect.bottom > ca.bottom:
+        dy = ca.bottom - rect.bottom
+    rect.Offset(dx, dy)
+
+    # if the rectangle has been moved too far, then readjust the position
+    # and also adjust the size
+    if rect.left < ca.left:
+        rect.width -= (ca.left - rect.left)
+        rect.left = ca.left
+    if rect.top < ca.top:
+        rect.height -= (ca.top - rect.top)
+        rect.top = ca.top
+
+    # make final adjustments if needed
+    adjust = wx.Size(*adjust)
+    if rect.width > (ca.width - adjust.width):
+        rect.width = ca.width - adjust.width
+    if rect.height > (ca.height - adjust.height):
+        rect.height = ca.height - adjust.height
+
+    # return the result
+    return rect
+
+
+#---------------------------------------------------------------------------

wx/lib/wordwrap.py

@@ -0,0 +1,97 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.wordwrap
+# Purpose:     Contains a function to aid in word-wrapping some text
+#
+# Author:      Robin Dunn
+#
+# Created:     15-Oct-2006
+# Copyright:   (c) 2006-2020 by Total Control Software
+# Licence:     wxWindows license
+# Tags:        phoenix-port
+#----------------------------------------------------------------------
+
+def wordwrap(text, width, dc, breakLongWords=True, margin=0):
+    """
+    Returns a copy of text with newline characters inserted where long
+    lines should be broken such that they will fit within the given
+    width, with the given margin left and right, on the given `wx.DC`
+    using its current font settings.  By default words that are wider
+    than the margin-adjusted width will be broken at the nearest
+    character boundary, but this can be disabled by passing ``False``
+    for the ``breakLongWords`` parameter.
+    """
+
+    wrapped_lines = []
+    text = text.split('\n')
+    for line in text:
+        pte = dc.GetPartialTextExtents(line)
+        wid = ( width - (2*margin+1)*dc.GetTextExtent(' ')[0]
+              - max([0] + [pte[i]-pte[i-1] for i in range(1,len(pte))]) )
+        idx = 0
+        start = 0
+        startIdx = 0
+        spcIdx = -1
+        while idx < len(pte):
+            # remember the last seen space
+            if line[idx] == ' ':
+                spcIdx = idx
+
+            # have we reached the max width?
+            if pte[idx] - start > wid and (spcIdx != -1 or breakLongWords):
+                if spcIdx != -1:
+                    idx = min(spcIdx + 1, len(pte) - 1)
+                wrapped_lines.append(' '*margin + line[startIdx : idx] + ' '*margin)
+                start = pte[idx]
+                startIdx = idx
+                spcIdx = -1
+
+            idx += 1
+
+        wrapped_lines.append(' '*margin + line[startIdx : idx] + ' '*margin)
+
+    return '\n'.join(wrapped_lines)
+
+
+
+if __name__ == '__main__':
+    import wx
+    class TestPanel(wx.Panel):
+        def __init__(self, parent):
+            wx.Panel.__init__(self, parent)
+
+            self.tc = wx.TextCtrl(self, -1, "", (20,20), (150,150), wx.TE_MULTILINE)
+            self.Bind(wx.EVT_TEXT, self.OnDoUpdate, self.tc)
+            self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+        def OnSize(self, evt):
+            wx.CallAfter(self.OnDoUpdate, None)
+
+
+        def OnDoUpdate(self, evt):
+            WIDTH = self.GetSize().width - 220
+            HEIGHT = 200
+            bmp = wx.Bitmap(WIDTH, HEIGHT)
+            mdc = wx.MemoryDC(bmp)
+            mdc.SetBackground(wx.Brush("white"))
+            mdc.Clear()
+            mdc.SetPen(wx.Pen("black"))
+            mdc.SetFont(wx.Font(10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
+            mdc.DrawRectangle(0,0, WIDTH, HEIGHT)
+
+            text = wordwrap(self.tc.GetValue(), WIDTH-2, mdc, False)
+            #print(repr(text))
+            mdc.DrawLabel(text, (1,1, WIDTH-2, HEIGHT-2))
+
+            del mdc
+            dc = wx.ClientDC(self)
+            dc.DrawBitmap(bmp, 200, 20)
+
+
+    app = wx.App(False)
+    frm = wx.Frame(None, title="Test wordWrap")
+    pnl = TestPanel(frm)
+    frm.Show()
+    app.MainLoop()
+
+

wx/lib/wxcairo/__init__.py

@@ -0,0 +1,139 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.wxcairo
+# Purpose:     Glue code to allow either the PyCairo package or the
+#              cairocffi package to be used with a wx.DC as the cairo
+#              surface.
+#
+# Author:      Robin Dunn
+#
+# Created:     3-Sept-2008
+# Copyright:   (c) 2008-2020 by Total Control Software
+# Licence:     wxWindows license
+#
+# Tags:        phoenix-port, py3-port
+#----------------------------------------------------------------------
+
+"""
+This package provides some glue code that allows the Cairo library to draw
+directly on :class:`wx.DC` objects, convert to/from :class:`wx.Bitmap`
+objects, etc. using either the PyCairo or the newer cairocffi Cairo wrappers.
+In Cairo terms, the DC is the drawing surface.  The ``CairoContextFromDC``
+function in this module will return an instance of the Cairo Context class
+that is ready for drawing, using the native cairo surface type for the current
+platform.
+
+.. note:: Be sure to import ``wx.lib.wxcairo`` before importing the ``cairo``
+   module.
+
+To use Cairo with wxPython you will need to have a few dependencies
+installed.  On Linux and other unix-like systems you may already have
+them, or can easily get them with your system's package manager.  Just
+check if libcairo and either cairocffi or pycairo packages are installed.
+
+On Mac you can get Cairo from MacPorts or similar tools.  Make sure that
+the quartz option is turned on so those Mac-specific APIs will be included in
+the Cairo library when it is built.  You can then use ``pip install cairocffi``
+to get the Python wrappers. If your cairo shared library is in a non-standard
+location, then you can help it be found by setting DYLD_FALLBACK_LIBRARY_PATH
+in the environment.
+
+On Windows a copy of the Cairo and related DLLs are included with wxPython
+inside the wx package folder.  These files were extracted from the GTK runtime
+installers found at the following URLs. You can replace those DLLs with others
+if you choose, or you can cause the wx_cairocffi module to use DLLs from some
+other location by setting the CAIRO environment variable.
+
+    32bit: http://gtk-win.sourceforge.net/home/index.php/Main/Downloads
+    64bit: https://github.com/tschoonj/GTK-for-Windows-Runtime-Environment-Installer
+
+"""
+
+#----------------------------------------------------------------------------
+
+import wx
+
+# Import our glue functions for either cairocffi or pycairo, depending on
+# which is installed.
+try:
+    # Use cairocffi first if it is available
+    from .wx_cairocffi import _ContextFromDC, _FontFaceFromFont
+    import cairo
+except ImportError:
+    try:
+        # otherwise use pycairo
+        from .wx_pycairo import _ContextFromDC, _FontFaceFromFont
+        import cairo
+    except ImportError:
+        # or provide some exception raising stubs instead
+        def _ContextFromDC(dc):
+            raise NotImplementedError("Cairo wrappers not found")
+
+        def _FontFaceFromFont(font):
+            raise NotImplementedError("Cairo wrappers not found")
+
+#----------------------------------------------------------------------------
+
+def ContextFromDC(dc):
+    """
+    Creates and returns a ``cairo.Context`` object using the :class:`wx.DC` as
+    the surface.  (Only window, client, paint and memory DC's are allowed at
+    this time.)
+    """
+    return _ContextFromDC(dc)
+
+
+def FontFaceFromFont(font):
+    """
+    Creates and returns a ``cairo.FontFace`` object from the native
+    information in a :class:`wx.Font`.
+    """
+    return _FontFaceFromFont(font)
+
+#----------------------------------------------------------------------------
+# wxBitmap <--> ImageSurface
+
+def BitmapFromImageSurface(surface):
+    """
+    Create a :class:`wx.Bitmap` from a Cairo ``ImageSurface``.
+    """
+    format = surface.get_format()
+    if format not in [cairo.FORMAT_ARGB32, cairo.FORMAT_RGB24]:
+        raise TypeError("Unsupported format")
+
+    width  = surface.get_width()
+    height = surface.get_height()
+    stride = surface.get_stride()
+    data   = surface.get_data()
+    if format == cairo.FORMAT_ARGB32:
+        fmt = wx.BitmapBufferFormat_ARGB32
+    else:
+        fmt = wx.BitmapBufferFormat_RGB32
+
+    bmp = wx.Bitmap(width, height, 32)
+    bmp.CopyFromBuffer(data, fmt, stride)
+    return bmp
+
+
+def ImageSurfaceFromBitmap(bitmap):
+    """
+    Create a Cairo ``ImageSurface`` from a :class:`wx.Bitmap`
+    """
+    width, height = bitmap.GetSize()
+    if bitmap.ConvertToImage().HasAlpha():
+        format = cairo.FORMAT_ARGB32
+        fmt = wx.BitmapBufferFormat_ARGB32
+    else:
+        format = cairo.FORMAT_RGB24
+        fmt = wx.BitmapBufferFormat_RGB32
+
+    try:
+        stride = cairo.ImageSurface.format_stride_for_width(format, width)
+    except AttributeError:
+        stride = width * 4
+
+    surface = cairo.ImageSurface(format, width, height)
+    bitmap.CopyToBuffer(surface.get_data(), fmt, stride)
+    surface.mark_dirty()
+    return surface
+
+#----------------------------------------------------------------------------