wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/StaticText.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+import  wx
+
+
+USE_GENERIC = 0
+
+if USE_GENERIC:
+    from wx.lib.stattext import GenStaticText as StaticText
+else:
+    StaticText = wx.StaticText
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+        ##self.SetBackgroundColour("sky blue")
+
+        StaticText(self, -1, "This is an example of static text", (20, 10))
+        StaticText(self, -1, "using the wx.StaticText Control.", (20, 30))
+
+        StaticText(
+            self, -1, "Is this yellow?", (20, 70), (120, -1)
+            ).SetBackgroundColour('Yellow')
+
+        StaticText(
+            self, -1, "align center", (160, 70), (120, -1), wx.ALIGN_CENTER
+            ).SetBackgroundColour('Yellow')
+
+        StaticText(
+            self, -1, "align right", (300, 70), (120, -1), wx.ALIGN_RIGHT
+            ).SetBackgroundColour('Yellow')
+
+        str = "This is a different font."
+        text = StaticText(self, -1, str, (20, 120))
+        font = wx.Font(18, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)
+        text.SetFont(font)
+
+        StaticText(self, -1,
+                   "Multi-line wx.StaticText\nline 2\nline 3\n\nafter empty line",
+                   (20,170))
+        StaticText(self, -1,
+                   "Align right multi-line\nline 2\nline 3\n\nafter empty line",
+                   (220,170), style=wx.ALIGN_RIGHT)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    panel = TestPanel(nb)
+    return panel
+
+
+#---------------------------------------------------------------------------
+
+
+overview = '''\
+A StaticText control displays one or more lines of read-only text.
+
+'''
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/StatusBar.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+
+import  time
+import  wx
+
+RELATIVEWIDTHS = False
+
+#---------------------------------------------------------------------------
+
+class CustomStatusBar(wx.StatusBar):
+    def __init__(self, parent, log):
+        wx.StatusBar.__init__(self, parent, -1)
+
+        # This status bar has three fields
+        self.SetFieldsCount(3)
+        if RELATIVEWIDTHS:
+            # Sets the three fields to be relative widths to each other.
+            self.SetStatusWidths([-2, -1, -2])
+        else:
+            self.SetStatusWidths([-2, 90, 140])
+        self.log = log
+        self.sizeChanged = False
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+        # Field 0 ... just text
+        self.SetStatusText("A Custom StatusBar...", 0)
+
+        # This will fall into field 1 (the second field)
+        self.cb = wx.CheckBox(self, 1001, "toggle clock")
+        self.Bind(wx.EVT_CHECKBOX, self.OnToggleClock, self.cb)
+        self.cb.SetValue(True)
+
+        # set the initial position of the checkbox
+        self.Reposition()
+
+        # We're going to use a timer to drive a 'clock' in the last field.
+        self.timer = wx.PyTimer(self.Notify)
+        self.timer.Start(1000)
+        self.Notify()
+
+
+    # Handles events from the timer we started in __init__().
+    # We're using it to drive a 'clock' in field 2 (the third field).
+    def Notify(self):
+        t = time.localtime(time.time())
+        st = time.strftime("%d-%b-%Y   %I:%M:%S", t)
+        self.SetStatusText(st, 2)
+        self.log.WriteText("tick...\n")
+
+
+    # the checkbox was clicked
+    def OnToggleClock(self, event):
+        if self.cb.GetValue():
+            self.timer.Start(1000)
+            self.Notify()
+        else:
+            self.timer.Stop()
+
+
+    def OnSize(self, evt):
+        evt.Skip()
+        self.Reposition()  # for normal size events
+
+        # Set a flag so the idle time handler will also do the repositioning.
+        # It is done this way to get around a buglet where GetFieldRect is not
+        # accurate during the EVT_SIZE resulting from a frame maximize.
+        self.sizeChanged = True
+
+
+    def OnIdle(self, evt):
+        if self.sizeChanged:
+            self.Reposition()
+
+
+    # reposition the checkbox
+    def Reposition(self):
+        rect = self.GetFieldRect(1)
+        rect.x += 1
+        rect.y += 1
+        self.cb.SetRect(rect)
+        self.sizeChanged = False
+
+
+class TestCustomStatusBar(wx.Frame):
+    def __init__(self, parent, log):
+        wx.Frame.__init__(self, parent, -1, 'Test Custom StatusBar')
+
+        self.sb = CustomStatusBar(self, log)
+        self.SetStatusBar(self.sb)
+        tc = wx.TextCtrl(self, -1, "", style=wx.TE_READONLY|wx.TE_MULTILINE)
+
+        self.SetSize((640, 480))
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+    def OnCloseWindow(self, event):
+        self.sb.timer.Stop()
+        del self.sb.timer
+        self.Destroy()
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Show the StatusBar sample", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        win = TestCustomStatusBar(self, self.log)
+        win.Show(True)
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A status bar is a narrow window that can be placed along the bottom of
+a frame to give small amounts of status information. It can contain
+one or more fields, one or more of which can be variable length
+according to the size of the window.
+
+This example demonstrates how to create a custom status bar with actual
+gadgets embedded in it. In this case, the first field is just plain text,
+The second one has a checkbox that enables the timer, and the third
+field has a clock that shows the current time when it is enabled.
+
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])

wx/demo/StockButtons.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+
+import wx
+
+#----------------------------------------------------------------------
+
+
+stockIDs = [
+    wx.ID_ABOUT,
+    wx.ID_ADD,
+    wx.ID_APPLY,
+    wx.ID_BOLD,
+    wx.ID_CANCEL,
+    wx.ID_CLEAR,
+    wx.ID_CLOSE,
+    wx.ID_COPY,
+    wx.ID_CUT,
+    wx.ID_DELETE,
+    wx.ID_EDIT,
+    wx.ID_FIND,
+    wx.ID_FILE,
+    wx.ID_REPLACE,
+    wx.ID_BACKWARD,
+    wx.ID_DOWN,
+    wx.ID_FORWARD,
+    wx.ID_UP,
+    wx.ID_HELP,
+    wx.ID_HOME,
+    wx.ID_INDENT,
+    wx.ID_INDEX,
+    wx.ID_ITALIC,
+    wx.ID_JUSTIFY_CENTER,
+    wx.ID_JUSTIFY_FILL,
+    wx.ID_JUSTIFY_LEFT,
+    wx.ID_JUSTIFY_RIGHT,
+    wx.ID_NEW,
+    wx.ID_NO,
+    wx.ID_OK,
+    wx.ID_OPEN,
+    wx.ID_PASTE,
+    wx.ID_PREFERENCES,
+    wx.ID_PRINT,
+    wx.ID_PREVIEW,
+    wx.ID_PROPERTIES,
+    wx.ID_EXIT,
+    wx.ID_REDO,
+    wx.ID_REFRESH,
+    wx.ID_REMOVE,
+    wx.ID_REVERT_TO_SAVED,
+    wx.ID_SAVE,
+    wx.ID_SAVEAS,
+    wx.ID_SELECTALL,
+    wx.ID_STOP,
+    wx.ID_UNDELETE,
+    wx.ID_UNDERLINE,
+    wx.ID_UNDO,
+    wx.ID_UNINDENT,
+    wx.ID_YES,
+    wx.ID_ZOOM_100,
+    wx.ID_ZOOM_FIT,
+    wx.ID_ZOOM_IN,
+    wx.ID_ZOOM_OUT,
+
+    ]
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        sizer = wx.FlexGridSizer(cols=5, hgap=4, vgap=4)
+        for ID in stockIDs:
+            b = wx.Button(self, ID)
+            sizer.Add(b)
+
+        self.SetSizer(sizer)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>Stock Buttons</center></h2>
+
+It is now possible to create \"stock\" buttons.  Basically this means
+that you only have to provide one of the stock IDs (and an empty
+label) when creating the button and wxWidgets will choose the stock
+label to go with it automatically.  Additionally on the platforms that
+have a native concept of a stock button (currently only GTK2) then the
+native stock button will be used.
+
+<p>This sample shows buttons for all of the currently available stock
+IDs.  Notice that when the button is created that no label is given,
+and compare that with the button that is created.
+
+
+</body></html>
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/StyledTextCtrl_1.py

@@ -0,0 +1,303 @@
+
+import wx
+import wx.stc as stc
+
+#----------------------------------------------------------------------
+
+debug = 1
+
+
+demoText = """\
+This editor is provided by a class named wx.StyledTextCtrl.  As
+the name suggests, you can define styles that can be applied to
+sections of text.  This will typically be used for things like
+syntax highlighting code editors, but I'm sure that there are other
+applications as well.  A style is a combination of font, point size,
+foreground and background colours.  The editor can handle
+proportional fonts just as easily as monospaced fonts, and various
+styles can use different sized fonts.
+
+There are a few canned language lexers and colourizers included,
+(see the next demo) or you can handle the colourization yourself.
+If you do you can simply register an event handler and the editor
+will let you know when the visible portion of the text needs
+styling.
+
+wx.StyledTextCtrl also supports setting markers in the margin...
+
+
+
+
+...and indicators within the text.  You can use these for whatever
+you want in your application.  Cut, Copy, Paste, Drag and Drop of
+text works, as well as virtually unlimited Undo and Redo
+capabilities, (right click to try it out.)
+"""
+
+if wx.Platform == '__WXMSW__':
+    face1 = 'Arial'
+    face2 = 'Times New Roman'
+    face3 = 'Courier New'
+    pb = 10
+else:
+    face1 = 'Helvetica'
+    face2 = 'Times'
+    face3 = 'Courier'
+    pb = 12
+
+
+#----------------------------------------------------------------------
+# This shows how to catch the Modified event from the wx.StyledTextCtrl
+
+class MySTC(stc.StyledTextCtrl):
+    def __init__(self, parent, ID, log):
+        stc.StyledTextCtrl.__init__(self, parent, ID)
+        self.log = log
+
+        self.Bind(stc.EVT_STC_DO_DROP, self.OnDoDrop)
+        self.Bind(stc.EVT_STC_DRAG_OVER, self.OnDragOver)
+        self.Bind(stc.EVT_STC_START_DRAG, self.OnStartDrag)
+        self.Bind(stc.EVT_STC_MODIFIED, self.OnModified)
+
+        self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
+
+    def OnDestroy(self, evt):
+        # This is how the clipboard contents can be preserved after
+        # the app has exited.
+        if 'wxMac' not in wx.PlatformInfo:
+            wx.TheClipboard.Flush()
+        evt.Skip()
+
+
+    def OnStartDrag(self, evt):
+        self.log.write("OnStartDrag: %d, %s\n"
+                       % (evt.GetDragAllowMove(), evt.GetDragText()))
+
+        if debug and evt.GetPosition() < 250:
+            evt.SetDragAllowMove(False)     # you can prevent moving of text (only copy)
+            evt.SetDragText("DRAGGED TEXT") # you can change what is dragged
+            #evt.SetDragText("")             # or prevent the drag with empty text
+
+
+    def OnDragOver(self, evt):
+        self.log.write(
+            "OnDragOver: x,y=(%d, %d)  pos: %d  DragResult: %d\n"
+            % (evt.GetX(), evt.GetY(), evt.GetPosition(), evt.GetDragResult())
+            )
+
+        if debug and evt.GetPosition() < 250:
+            evt.SetDragResult(wx.DragNone)   # prevent dropping at the beginning of the buffer
+
+
+    def OnDoDrop(self, evt):
+        self.log.write("OnDoDrop: x,y=(%d, %d)  pos: %d  DragResult: %d\n"
+                       "\ttext: %s\n"
+                       % (evt.GetX(), evt.GetY(), evt.GetPosition(), evt.GetDragResult(),
+                          evt.GetDragText()))
+
+        if debug and evt.GetPosition() < 500:
+            evt.SetDragText("DROPPED TEXT")  # Can change text if needed
+            #evt.SetDragResult(wx.DragNone)  # Can also change the drag operation, but it
+                                             # is probably better to do it in OnDragOver so
+                                             # there is visual feedback
+
+            #evt.SetPosition(25)             # Can also change position, but I'm not sure why
+                                             # you would want to...
+
+
+
+
+    def OnModified(self, evt):
+        self.log.write("""OnModified
+        Mod type:     %s
+        At position:  %d
+        Lines added:  %d
+        Text Length:  %d
+        Text:         %s\n""" % ( self.transModType(evt.GetModificationType()),
+                                  evt.GetPosition(),
+                                  evt.GetLinesAdded(),
+                                  evt.GetLength(),
+                                  repr(evt.GetText()) ))
+
+
+    def transModType(self, modType):
+        st = ""
+        table = [(stc.STC_MOD_INSERTTEXT, "InsertText"),
+                 (stc.STC_MOD_DELETETEXT, "DeleteText"),
+                 (stc.STC_MOD_CHANGESTYLE, "ChangeStyle"),
+                 (stc.STC_MOD_CHANGEFOLD, "ChangeFold"),
+                 (stc.STC_PERFORMED_USER, "UserFlag"),
+                 (stc.STC_PERFORMED_UNDO, "Undo"),
+                 (stc.STC_PERFORMED_REDO, "Redo"),
+                 (stc.STC_LASTSTEPINUNDOREDO, "Last-Undo/Redo"),
+                 (stc.STC_MOD_CHANGEMARKER, "ChangeMarker"),
+                 (stc.STC_MOD_BEFOREINSERT, "B4-Insert"),
+                 (stc.STC_MOD_BEFOREDELETE, "B4-Delete")
+                 ]
+
+        for flag,text in table:
+            if flag & modType:
+                st = st + text + " "
+
+        if not st:
+            st = 'UNKNOWN'
+
+        return st
+
+
+
+
+#----------------------------------------------------------------------
+
+_USE_PANEL = 1
+
+def runTest(frame, nb, log):
+    if not _USE_PANEL:
+        ed = p = MySTC(nb, -1, log)
+
+    else:
+        p = wx.Panel(nb, -1, style=wx.NO_FULL_REPAINT_ON_RESIZE)
+        ed = MySTC(p, -1, log)
+        s = wx.BoxSizer(wx.HORIZONTAL)
+        s.Add(ed, 1, wx.EXPAND)
+        p.SetSizer(s)
+        p.SetAutoLayout(True)
+
+
+    ed.SetText(demoText)
+
+    import codecs
+    decode = codecs.lookup("utf-8")[1]
+
+    ed.GotoPos(ed.GetLength())
+    ed.AddText("\n\nwx.StyledTextCtrl can also do Unicode:\n")
+    uniline = ed.GetCurrentLine()
+    unitext, l = decode(b'\xd0\x9f\xd0\xb8\xd1\x82\xd0\xbe\xd0\xbd - ' +
+                        b'\xd0\xbb\xd1\x83\xd1\x87\xd1\x88\xd0\xb8\xd0\xb9 ' +
+                        b'\xd1\x8f\xd0\xb7\xd1\x8b\xd0\xba \xd0\xbf\xd1\x80\xd0\xbe\xd0\xb3\xd1\x80\xd0\xb0\xd0\xbc\xd0\xbc\xd0\xb8\xd1\x80\xd0\xbe\xd0\xb2\xd0\xb0\xd0\xbd\xd0\xb8\xd1\x8f!\n\n')
+    ed.AddText('\tRussian: ')
+    ed.AddText(unitext)
+    ed.GotoPos(0)
+
+    ed.EmptyUndoBuffer()
+
+    # make some styles
+    ed.StyleSetSpec(stc.STC_STYLE_DEFAULT, "size:%d,face:%s" % (pb, face3))
+    ed.StyleClearAll()
+    ed.StyleSetSpec(1, "size:%d,bold,face:%s,fore:#0000FF" % (pb, face1))
+    ed.StyleSetSpec(2, "face:%s,italic,fore:#FF0000,size:%d" % (face2, pb))
+    ed.StyleSetSpec(3, "face:%s,bold,size:%d" % (face2, pb))
+    ed.StyleSetSpec(4, "face:%s,size:%d" % (face1, pb-1))
+
+    if wx.VERSION[0:3] < (4, 1, 0, 0, '')[0:3]:
+        def StartStyling(start, mask=255):
+            ed.StartStyling(start, mask)
+    else:
+        def StartStyling(start):
+            ed.StartStyling(start)
+
+    # Now set some text to those styles...  Normally this would be
+    # done in an event handler that happens when text needs displayed.
+    StartStyling(98)
+    ed.SetStyling(6, 1)  # set style for 6 characters using style 1
+
+    StartStyling(190)
+    ed.SetStyling(20, 2)
+
+    StartStyling(310)
+    ed.SetStyling(4, 3)
+    ed.SetStyling(2, 0)
+    ed.SetStyling(10, 4)
+
+
+    # line numbers in the margin
+    ed.SetMarginType(0, stc.STC_MARGIN_NUMBER)
+    ed.SetMarginWidth(0, 22)
+    ed.StyleSetSpec(stc.STC_STYLE_LINENUMBER, "size:%d,face:%s" % (pb-2, face1))
+
+    # setup some markers
+    ed.SetMarginType(1, stc.STC_MARGIN_SYMBOL)
+    ed.MarkerDefine(0, stc.STC_MARK_ROUNDRECT, "#CCFF00", "RED")
+    ed.MarkerDefine(1, stc.STC_MARK_CIRCLE, "FOREST GREEN", "SIENNA")
+    ed.MarkerDefine(2, stc.STC_MARK_SHORTARROW, "blue", "blue")
+    ed.MarkerDefine(3, stc.STC_MARK_ARROW, "#00FF00", "#00FF00")
+
+    # put some markers on some lines
+    ed.MarkerAdd(17, 0)
+    ed.MarkerAdd(18, 1)
+    ed.MarkerAdd(19, 2)
+    ed.MarkerAdd(20, 3)
+    ed.MarkerAdd(20, 0)
+
+    ed.INDICSTYLE00 = 0
+    ed.INDICSTYLE01 = 1
+    ed.INDICSTYLE02 = 2
+
+    # and finally, an indicator or two
+    # ed.SetIndicatorCurrent(ed.INDICSTYLE00)
+    ed.IndicatorSetStyle(ed.INDICSTYLE00, stc.STC_INDIC_SQUIGGLE)
+    ed.IndicatorSetForeground(ed.INDICSTYLE00, wx.RED)
+    ed.IndicatorSetAlpha(ed.INDICSTYLE00, 64)
+    ed.IndicatorSetUnder(ed.INDICSTYLE00, True)
+    ed.IndicatorSetStyle(ed.INDICSTYLE01, stc.STC_INDIC_DIAGONAL)
+    ed.IndicatorSetForeground(ed.INDICSTYLE01, wx.BLUE)
+    ed.IndicatorSetStyle(ed.INDICSTYLE02, stc.STC_INDIC_STRIKE)
+    ed.IndicatorSetForeground(ed.INDICSTYLE02, wx.RED)
+
+    ed.SetIndicatorCurrent(ed.INDICSTYLE00)
+    ed.IndicatorFillRange(836, 10)
+    ed.SetIndicatorCurrent(ed.INDICSTYLE01)
+    ed.IndicatorFillRange(846, 8)
+    ed.SetIndicatorCurrent(ed.INDICSTYLE02)
+    ed.IndicatorFillRange(854, 10)
+
+    ed.AppendText('wxPython %s\n%s\n\n' % (wx.VERSION_STRING, wx.stc.StyledTextCtrl.GetLibraryVersionInfo().GetVersionString()))
+
+
+    # some test stuff...
+    if debug:
+        print("GetTextLength(): ", ed.GetTextLength(), len(ed.GetText()))
+        print("GetText(): ", repr(ed.GetText()))
+        print()
+        print("GetStyledText(98, 104): ", repr(ed.GetStyledText(98, 104)), len(ed.GetStyledText(98, 104)))
+        print()
+        print("GetCurLine(): ", repr(ed.GetCurLine()))
+        ed.GotoPos(5)
+        print("GetCurLine(): ", repr(ed.GetCurLine()))
+        print()
+        print("GetLine(1): ", repr(ed.GetLine(1)))
+        print()
+        ed.SetSelection(25, 35)
+        print("GetSelectedText(): ", repr(ed.GetSelectedText()))
+        print("GetTextRange(25, 35): ", repr(ed.GetTextRange(25, 35)))
+        print("FindText(0, max, 'indicators'): ",
+              ed.FindText(0, ed.GetTextLength(), "indicators"))
+        # if wx.USE_UNICODE:
+        end = ed.GetLength()
+        start = ed.PositionFromLine(uniline)
+        print("GetTextRange(%d, %d): " % (start, end),)
+        print(repr(ed.GetTextRange(start, end)))
+
+
+    wx.CallAfter(ed.GotoPos, 0)
+    return p
+
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+<html><body>
+Once again, no docs yet.  <b>Sorry.</b>  But <a href="data/stc.h.html">this</a>
+and <a href="http://www.scintilla.org/ScintillaDoc.html">this</a> should
+be helpful.
+</body><html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+