wxPython 4.3.2__cp315-cp315-win_amd64.whl

wx/lib/editor/images.py

@@ -0,0 +1,15 @@
+
+# images converted with wxPython's img2py.py tool
+
+# 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+#
+
+from wx.lib.embeddedimage import PyEmbeddedImage
+
+EofImage = PyEmbeddedImage(
+    "iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAYAAADEUlfTAAAABHNCSVQICAgIfAhkiAAAADpJ"
+    "REFUeJxdjsENADAIAsUJbv8p3aB90WD5KJwJCihrZg4g+06Q88EM0quqFkh1dqQAtZcfrIcc"
+    "5OEFYDIVnsU0yrQAAAAASUVORK5CYII=")
+

wx/lib/editor/selection.py

@@ -0,0 +1,44 @@
+# 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatibility update.
+#
+
+def RestOfLine(sx, width, data, bool):
+    if len(data) == 0 and sx == 0:
+        return [('', bool)]
+    if sx >= len(data):
+        return []
+    return [(data[sx:sx+width], bool)]
+
+def Selection(SelectBegin,SelectEnd, sx, width, line, data):
+    if SelectEnd is None or SelectBegin is None:
+        return RestOfLine(sx, width, data, False)
+    (bRow, bCol) = SelectBegin
+    (eRow, eCol) = SelectEnd
+    if (eRow < bRow):
+        (bRow, bCol) = SelectEnd
+        (eRow, eCol) = SelectBegin
+    if (line < bRow or eRow < line):
+        return RestOfLine(sx, width, data, False)
+    if (bRow < line and line < eRow):
+        return RestOfLine(sx, width, data, True)
+    if (bRow == eRow) and (eCol < bCol):
+        (bCol, eCol) = (eCol, bCol)
+    # selection either starts or ends on this line
+    end = min(sx+width, len(data))
+    if (bRow < line):
+        bCol = 0
+    if (line < eRow):
+        eCol = end
+    pieces = []
+    if (sx < bCol):
+        if bCol <= end:
+            pieces += [(data[sx:bCol], False)]
+        else:
+            return [(data[sx:end], False)]
+    pieces += [(data[max(bCol,sx):min(eCol,end)], True)]
+    if (eCol < end):
+        pieces += [(data[eCol:end], False)]
+    return pieces
+
+

wx/lib/embeddedimage.py

@@ -0,0 +1,76 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.embeddedimage
+# Purpose:     Defines a class used for embedding PNG images in Python
+#              code. The primary method of using this module is via
+#              the code generator in wx.tools.img2py.
+#
+# Author:      Anthony Tuininga
+#
+# Created:     26-Nov-2007
+# Copyright:   (c) 2007 by Anthony Tuininga
+# Licence:     wxWindows license
+# Tags:        phoenix-port
+#----------------------------------------------------------------------
+
+import base64
+from io import BytesIO
+
+import wx
+
+try:
+    b64decode = base64.b64decode
+except AttributeError:
+    b64decode = base64.decodestring
+
+
+class PyEmbeddedImage:
+    """
+    PyEmbeddedImage is primarily intended to be used by code generated
+    by img2py as a means of embedding image data in a python module so
+    the image can be used at runtime without needing to access the
+    image from an image file.  This makes distributing icons and such
+    that an application uses simpler since tools like py2exe will
+    automatically bundle modules that are imported, and the
+    application doesn't have to worry about how to locate the image
+    files on the user's filesystem.
+
+    The class can also be used for image data that may be acquired
+    from some other source at runtime, such as over the network or
+    from a database.  In this case pass False for isBase64 (unless the
+    data actually is base64 encoded.)  Any image type that
+    wx.Image can handle should be okay.
+    """
+
+    def __init__(self, data, isBase64=True):
+        self.data = data
+        self.isBase64 = isBase64
+
+    def GetBitmap(self):
+        return wx.Bitmap(self.GetImage())
+
+    def GetData(self):
+        data = self.data
+        if self.isBase64:
+            data = b64decode(self.data)
+        return data
+
+    def GetIcon(self):
+        icon = wx.Icon()
+        icon.CopyFromBitmap(self.GetBitmap())
+        return icon
+
+    def GetImage(self):
+        stream = BytesIO(self.GetData())
+        return wx.Image(stream)
+
+    # added for backwards compatibility
+    getBitmap = wx.deprecated(GetBitmap)
+    getData = wx.deprecated(GetData)
+    getIcon = wx.deprecated(GetIcon)
+    getImage = wx.deprecated(GetImage)
+
+    # define properties, for convenience
+    Bitmap = property(GetBitmap)
+    Data = property(GetData)
+    Icon = property(GetIcon)
+    Image = property(GetImage)

wx/lib/eventStack.py

@@ -0,0 +1,136 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.eventStack
+# Purpose:     These mixins implement a push and pop menu/UI update event
+#              handler system at the wx.App level. This is useful for resolving
+#              cases where multiple views may want to respond to an event
+#              (say, wx.ID_COPY) and where you also want a "default" handler
+#              for the event (and UI update status) when there is no active
+#              view which wishes to handle the event.
+#
+# Author:      Kevin Ollivier
+#
+# Created:     -Mar-
+# Copyright:   (c)  Kevin Ollivier
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+
+import sys, os
+import wx
+
+class AppEventManager:
+    ui_events = [
+                    wx.ID_NEW, wx.ID_OPEN, wx.ID_CLOSE_ALL, wx.ID_CLOSE,
+                    wx.ID_REVERT, wx.ID_SAVE, wx.ID_SAVEAS, wx.ID_UNDO,
+                    wx.ID_REDO, wx.ID_PRINT, wx.ID_PRINT_SETUP, wx.ID_PREVIEW,
+                    wx.ID_EXIT
+                ]
+
+    def __init__(self):
+        pass
+
+    def RegisterEvents(self):
+        app = wx.GetApp()
+        #app.AddHandlerForID(wx.ID_EXIT, self.OnExit)
+        #app.AddHandlerForID(wx.ID_ABOUT, self.OnAbout)
+
+        for eventID in self.ui_events:
+            app.AddHandlerForID(eventID, self.ProcessEvent)
+            app.AddUIHandlerForID(eventID, self.ProcessUpdateUIEvent)
+
+class AppEventHandlerMixin:
+    """
+    The purpose of the AppEventHandlerMixin is to provide a centralized
+    location to manage menu and toolbar events. In an IDE which may have
+    any number of file editors and services open that may want to respond
+    to certain menu and toolbar events (e.g. copy, paste, select all),
+    we need this to efficiently make sure that the right handler is handling
+    the event.
+
+    To work with this system, views must call::
+
+            AddHandlerForID(ID, handlerFunc)
+
+
+    or::
+
+            AddUIHandlerForID(ID, handlerFunc)
+
+
+    in their EVT_SET_FOCUS handler, and call Remove(UI)HandlerForID(ID) in their
+    EVT_KILL_FOCUS handler.
+    """
+
+    def __init__(self):
+        self.handlers = {}
+        self.uihandlers = {}
+
+        # When a view changes the handler, move the old one here.
+        # Then "pop" the handler when the view loses the focus
+        self.pushed_handlers = {}
+        self.pushed_uihandlers = {}
+
+    def AddHandlerForIDs(self, eventID_list, handlerFunc):
+        for eventID in eventID_list:
+            self.AddHandlerForID(eventID, handlerFunc)
+
+    def AddHandlerForID(self, eventID, handlerFunc):
+        self.Bind(wx.EVT_MENU, self.HandleEvent, id=eventID)
+
+        if eventID in self.handlers:
+            self.pushed_handlers[eventID] = self.handlers[eventID]
+
+        self.handlers[eventID] = handlerFunc
+
+    def AddUIHandlerForID(self, eventID, handlerFunc):
+        self.Bind(wx.EVT_UPDATE_UI, self.HandleUpdateUIEvent, id=eventID)
+
+        if eventID in self.uihandlers:
+            self.pushed_uihandlers[eventID] = self.uihandlers[eventID]
+
+        self.uihandlers[eventID] = handlerFunc
+
+    def RemoveHandlerForIDs(self, eventID_list):
+        for eventID in eventID_list:
+            self.RemoveHandlerForID(eventID)
+
+    def RemoveHandlerForID(self, eventID):
+        self.Unbind(wx.EVT_MENU, id=eventID)
+        self.handlers[eventID] = None
+
+        if eventID in self.pushed_handlers:
+            self.handlers[eventID] = self.pushed_handlers[eventID]
+
+    def RemoveUIHandlerForID(self, eventID):
+        self.Unbind(wx.EVT_UPDATE_UI, id=eventID)
+        self.uihandlers[eventID] = None
+
+        if eventID in self.pushed_uihandlers:
+            self.uihandlers[eventID] = self.pushed_uihandlers[eventID]
+
+    def HandleEvent(self, event):
+        e_id = event.GetId()
+        if e_id in self.handlers:
+            handler = self.handlers[e_id]
+            try:
+                if handler:
+                    return handler(event)
+            except RuntimeError:
+                self.RemoveHandlerForID(e_id)
+        else:
+            event.Skip()
+
+        return False
+
+    def HandleUpdateUIEvent(self, event):
+        e_id = event.GetId()
+        if e_id in self.uihandlers:
+            handler = self.uihandlers[e_id]
+            try:
+                if handler:
+                    return handler(event)
+            except RuntimeError:
+                self.RemoveUIHandlerForID(e_id)
+        else:
+            event.Skip()
+
+        return False