wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/DelayedResult.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python
+
+"""
+This demonstrates a simple use of delayedresult: get/compute
+something that takes a long time, without hanging the GUI while this
+is taking place.
+
+The top button runs a small GUI that uses wx.lib.delayedresult.startWorker
+to wrap a long-running function into a separate thread. Just click
+Get, and move the slider, and click Get and Abort a few times, and
+observe that GUI responds. The key functions to look for in the code
+are startWorker() and __handleResult().
+
+The second button runs the same GUI, but without delayedresult.  Click
+Get: now the get/compute is taking place in main thread, so the GUI
+does not respond to user actions until worker function returns, it's
+not even possible to Abort.
+"""
+
+import wx
+import wx.lib.delayedresult as delayedresult
+
+
+class FrameSimpleDelayedBase(wx.Frame):
+    def __init__(self, *args, **kwds):
+        wx.Frame.__init__(self, *args, **kwds)
+        pnl = wx.Panel(self)
+        self.textUseDelayed = wx.StaticText(pnl, -1, "NOT using delayedresult")
+        self.buttonGet = wx.Button(pnl, -1, "Get")
+        self.buttonAbort = wx.Button(pnl, -1, "Abort")
+        self.slider = wx.Slider(pnl, -1, 0, 0, 10, size=(100,-1),
+                                style=wx.SL_HORIZONTAL|wx.SL_AUTOTICKS)
+        self.textCtrlResult = wx.TextCtrl(pnl, -1, "", style=wx.TE_READONLY)
+
+        self.buttonAbort.Enable(False)
+
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        vsizer.Add(self.textUseDelayed, 0, wx.ALL, 10)
+        hsizer.Add(self.buttonGet, 0, wx.ALL, 5)
+        hsizer.Add(self.buttonAbort, 0, wx.ALL, 5)
+        hsizer.Add(self.slider, 0, wx.ALL, 5)
+        hsizer.Add(self.textCtrlResult, 0, wx.ALL, 5)
+        vsizer.Add(hsizer, 0, wx.ALL, 5)
+        pnl.SetSizer(vsizer)
+        vsizer.SetSizeHints(self)
+
+        self.Bind(wx.EVT_BUTTON, self.handleGet, self.buttonGet)
+        self.Bind(wx.EVT_BUTTON, self.handleAbort, self.buttonAbort)
+
+
+
+class FrameSimpleDelayed(FrameSimpleDelayedBase):
+    """This demos simplistic use of delayedresult module."""
+
+    def __init__(self, *args, **kwargs):
+        FrameSimpleDelayedBase.__init__(self, *args, **kwargs)
+        self.jobID = 0
+        self.abortEvent = delayedresult.AbortEvent()
+        self.Bind(wx.EVT_CLOSE, self.handleClose)
+        self.textUseDelayed.SetLabel("USING delayedresult")
+
+
+    def setLog(self, log):
+        self.log = log
+
+
+    def handleClose(self, event):
+        """
+        Only needed because in demo, closing the window does not kill the
+        app, so worker thread continues and sends result to dead frame; normally
+        your app would exit so this would not happen.
+        """
+        if self.buttonAbort.IsEnabled():
+            self.log( "Exiting: Aborting job %s" % self.jobID )
+            self.abortEvent.set()
+        self.Destroy()
+
+    def handleGet(self, event):
+        """Compute result in separate thread, doesn't affect GUI response."""
+        self.buttonGet.Enable(False)
+        self.buttonAbort.Enable(True)
+        self.abortEvent.clear()
+        self.jobID += 1
+
+        self.log( "Starting job %s in producer thread: GUI remains responsive"
+                  % self.jobID )
+        delayedresult.startWorker(self._resultConsumer, self._resultProducer,
+                                  wargs=(self.jobID,self.abortEvent), jobID=self.jobID)
+
+
+    def _resultProducer(self, jobID, abortEvent):
+        """
+        Pretend to be a complex worker function or something that takes
+        long time to run due to network access etc. GUI will freeze if this
+        method is not called in separate thread.
+        """
+        import time
+        count = 0
+        while not abortEvent() and count < 50:
+            time.sleep(0.1)
+            count += 1
+        return jobID
+
+
+    def handleAbort(self, event):
+        """Abort the result computation."""
+        self.log( "Aborting result for job %s" % self.jobID )
+        self.buttonGet.Enable(True)
+        self.buttonAbort.Enable(False)
+        self.abortEvent.set()
+
+
+    def _resultConsumer(self, delayedResult):
+        jobID = delayedResult.getJobID()
+        assert jobID == self.jobID
+        try:
+            result = delayedResult.get()
+        except Exception as exc:
+            self.log( "Result for job %s raised exception: %s" % (jobID, exc) )
+            return
+
+        # output result
+        self.log( "Got result for job %s: %s" % (jobID, result) )
+        self.textCtrlResult.SetValue(str(result))
+
+        # get ready for next job:
+        self.buttonGet.Enable(True)
+        self.buttonAbort.Enable(False)
+
+
+
+class FrameSimpleDirect(FrameSimpleDelayedBase):
+    """This does not use delayedresult so the GUI will freeze while
+    the GET is taking place."""
+
+    def __init__(self, *args, **kwargs):
+        self.jobID = 1
+        FrameSimpleDelayedBase.__init__(self, *args, **kwargs)
+
+
+    def setLog(self, log):
+        self.log = log
+
+
+    def handleGet(self, event):
+        """
+        Not using delayedresult, this will compute result in the same thread,
+        and will affect GUI response because a thread is not used.
+        """
+        self.buttonGet.Enable(False)
+        self.buttonAbort.Enable(True)
+
+        self.log( "Doing job %s without delayedresult (same as GUI thread): GUI hangs (for a while)" % self.jobID )
+        result = self._resultProducer(self.jobID)
+        self._resultConsumer( result )
+
+
+    def _resultProducer(self, jobID):
+        """
+        Pretend to be a complex worker function or something that takes
+        long time to run due to network access etc. GUI will freeze if this
+        method is not called in separate thread.
+        """
+        import time
+        time.sleep(5)
+        return jobID
+
+
+    def handleAbort(self, event):
+        """can never be called"""
+        pass
+
+
+    def _resultConsumer(self, result):
+        # output result
+        self.log( "Got result for job %s: %s" % (self.jobID, result) )
+        self.textCtrlResult.SetValue(str(result))
+
+        # get ready for next job:
+        self.buttonGet.Enable(True)
+        self.buttonAbort.Enable(False)
+        self.jobID += 1
+
+
+#---------------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+        b = wx.Button(self, -1, "Long-running function in separate thread")
+        vsizer.Add(b, 0, wx.ALL, 5)
+        self.Bind(wx.EVT_BUTTON, self.OnButton1, b)
+
+        b = wx.Button(self, -1, "Long-running function in GUI thread")
+        vsizer.Add(b, 0, wx.ALL, 5)
+        self.Bind(wx.EVT_BUTTON, self.OnButton2, b)
+
+        bdr = wx.BoxSizer()
+        bdr.Add(vsizer, 0, wx.ALL, 50)
+        self.SetSizer(bdr)
+        self.Layout()
+
+    def OnButton1(self, evt):
+        frame = FrameSimpleDelayed(self, title="Long-running function in separate thread")
+        frame.setLog(self.log.WriteText)
+        frame.Show()
+
+    def OnButton2(self, evt):
+        frame = FrameSimpleDirect(self, title="Long-running function in GUI thread")
+        frame.setLog(self.log.WriteText)
+        frame.Show()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = __doc__
+
+
+if __name__ == '__main__':
+   import sys,os
+   import run
+   run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+

wx/demo/Dialog.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+
+import wx
+
+#---------------------------------------------------------------------------
+# Create and set a help provider.  Normally you would do this in
+# the app's OnInit as it must be done before any SetHelpText calls.
+provider = wx.SimpleHelpProvider()
+wx.HelpProvider.Set(provider)
+
+#---------------------------------------------------------------------------
+
+class TestDialog(wx.Dialog):
+    def __init__(
+            self, parent, id, title, size=wx.DefaultSize, pos=wx.DefaultPosition,
+            style=wx.DEFAULT_DIALOG_STYLE, name='dialog'
+            ):
+
+        # Instead of calling wx.Dialog.__init__ we precreate the dialog
+        # so we can set an extra style that must be set before
+        # creation, and then we create the GUI object using the Create
+        # method.
+        wx.Dialog.__init__(self)
+        self.SetExtraStyle(wx.DIALOG_EX_CONTEXTHELP)
+        self.Create(parent, id, title, pos, size, style, name)
+
+        # Now continue with the normal construction of the dialog
+        # contents
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        label = wx.StaticText(self, -1, "This is a wx.Dialog")
+        label.SetHelpText("This is the help text for the label")
+        sizer.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+        box = wx.BoxSizer(wx.HORIZONTAL)
+
+        label = wx.StaticText(self, -1, "Field #1:")
+        label.SetHelpText("This is the help text for the label")
+        box.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+        text = wx.TextCtrl(self, -1, "", size=(80,-1))
+        text.SetHelpText("Here's some help text for field #1")
+        box.Add(text, 1, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+        sizer.Add(box, 0, wx.EXPAND|wx.ALL, 5)
+
+        box = wx.BoxSizer(wx.HORIZONTAL)
+
+        label = wx.StaticText(self, -1, "Field #2:")
+        label.SetHelpText("This is the help text for the label")
+        box.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+        text = wx.TextCtrl(self, -1, "", size=(80,-1))
+        text.SetHelpText("Here's some help text for field #2")
+        box.Add(text, 1, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+        sizer.Add(box, 0, wx.EXPAND|wx.ALL, 5)
+
+        line = wx.StaticLine(self, -1, size=(20,-1), style=wx.LI_HORIZONTAL)
+        sizer.Add(line, 0, wx.EXPAND|wx.RIGHT|wx.TOP, 5)
+
+        btnsizer = wx.StdDialogButtonSizer()
+
+        if wx.Platform != "__WXMSW__":
+            btn = wx.ContextHelpButton(self)
+            btnsizer.AddButton(btn)
+
+        btn = wx.Button(self, wx.ID_OK)
+        btn.SetHelpText("The OK button completes the dialog")
+        btn.SetDefault()
+        btnsizer.AddButton(btn)
+
+        btn = wx.Button(self, wx.ID_CANCEL)
+        btn.SetHelpText("The Cancel button cancels the dialog. (Cool, huh?)")
+        btnsizer.AddButton(btn)
+        btnsizer.Realize()
+
+        sizer.Add(btnsizer, 0, wx.ALL, 5)
+
+        self.SetSizer(sizer)
+        sizer.Fit(self)
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Create and Show a custom Dialog", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+        b = wx.Button(self, -1, "Show dialog with ShowWindowModal", (50, 140))
+        self.Bind(wx.EVT_BUTTON, self.OnShowWindowModal, b)
+        self.Bind(wx.EVT_WINDOW_MODAL_DIALOG_CLOSED, self.OnWindowModalDialogClosed)
+
+
+    def OnButton(self, evt):
+        dlg = TestDialog(self, -1, "Sample Dialog", size=(350, 200),
+                         style=wx.DEFAULT_DIALOG_STYLE,
+                         )
+        dlg.CenterOnScreen()
+
+        # this does not return until the dialog is closed.
+        val = dlg.ShowModal()
+
+        if val == wx.ID_OK:
+            self.log.WriteText("You pressed OK\n")
+        else:
+            self.log.WriteText("You pressed Cancel\n")
+
+        dlg.Destroy()
+
+
+    def OnShowWindowModal(self, evt):
+        dlg = TestDialog(self, -1, "Sample Dialog", size=(350, 200),
+                         style=wx.DEFAULT_DIALOG_STYLE)
+        dlg.ShowWindowModal()
+
+
+    def OnWindowModalDialogClosed(self, evt):
+        dialog = evt.GetDialog()
+        val = evt.GetReturnCode()
+        try:
+            btnTxt = { wx.ID_OK : "OK",
+                       wx.ID_CANCEL: "Cancel" }[val]
+        except KeyError:
+            btnTxt = '<unknown>'
+
+        wx.MessageBox("You closed the window-modal dialog with the %s button" % btnTxt)
+
+        dialog.Destroy()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+wxPython offers quite a few general purpose dialogs for useful data input from
+the user; they are all based on the wx.Dialog class, which you can also subclass
+to create custom dialogs to suit your needs.
+
+The Dialog class, in addition to dialog-like behaviors, also supports the full
+wxWindows layout featureset, which means that you can incorporate sizers or
+layout constraints as needed to achieve the look and feel desired. It even supports
+context-sensitive help, which is illustrated in this example.
+
+The example is very simple; in real world situations, a dialog that had input
+fields such as this would no doubt be required to deliver those values back to
+the calling function. The Dialog class supports data retrieval in this manner.
+<b>However, the data must be retrieved prior to the dialog being destroyed.</b>
+The example shown here is <i>modal</i>; non-modal dialogs are possible as well.
+
+See the documentation for the <code>Dialog</code> class for more details.
+
+"""
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/DialogUnits.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+
+#----------------------------------------------------------------------------
+# Name:         DialogUnits.py
+# Purpose:      A minimal wxPython program that is a bit smarter than test1.
+#
+# Author:       Robin Dunn
+#
+# Created:      A long time ago, in a galaxy far, far away...
+# Copyright:    (c) 1998-2020 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+
+import wx
+
+#---------------------------------------------------------------------------
+
+# Create a new frame class, derived from the wxPython Frame.
+class MyFrame(wx.Frame):
+
+    def __init__(self, parent, id, title):
+        # First, call the base class' __init__ method to create the frame
+        wx.Frame.__init__(self, parent, id, title, (100, 100), (160, 100))
+
+        # Associate some events with methods of this class
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.Bind(wx.EVT_MOVE, self.OnMove)
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+        # Add a panel and some controls to display the size and position
+        panel = wx.Panel(self, -1)
+
+        wx.StaticText(panel, -1, "Size:",
+            panel.DLG_UNIT((4, 4)),  wx.DefaultSize
+            )
+
+        wx.StaticText(panel, -1, "Pos:",
+            panel.DLG_UNIT((4, 20)), wx.DefaultSize
+            )
+
+        self.sizeCtrl = wx.TextCtrl(panel, -1, "",
+                            panel.DLG_UNIT((24, 4)),
+                            panel.DLG_UNIT((36, -1)),
+                            wx.TE_READONLY)
+
+        self.posCtrl = wx.TextCtrl(panel, -1, "",
+                            panel.DLG_UNIT((24, 20)),
+                            panel.DLG_UNIT((36, -1)),
+                            wx.TE_READONLY)
+
+        #print(wx.DLG_UNIT(panel, (24, 4)), wx.DLG_UNIT(panel, (36, -1)))
+        #print(panel.DLG_UNIT((24, 16)), panel.DLG_UNIT((36, -1)))
+
+
+    # This method is called automatically when the CLOSE event is
+    # sent to this window
+    def OnCloseWindow(self, event):
+        # tell the window to kill itself
+        self.Destroy()
+
+    # This method is called by the System when the window is resized,
+    # because of the association above.
+    def OnSize(self, event):
+        size = event.GetSize()
+        self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
+
+        # tell the event system to continue looking for an event handler,
+        # so the default handler will get called.
+        event.Skip()
+
+    # This method is called by the System when the window is moved,
+    # because of the association above.
+    def OnMove(self, event):
+        pos = event.GetPosition()
+        self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
+
+
+
+#---------------------------------------------------------------------------
+# if running standalone
+
+if __name__ == "__main__":
+    # Every wxWindows application must have a class derived from wxApp
+    class MyApp(wx.App):
+
+        # wxWindows calls this method to initialize the application
+        def OnInit(self):
+
+            # Create an instance of our customized Frame class
+            frame = MyFrame(None, -1, "This is a test")
+            frame.Show(True)
+
+            # Tell wxWindows that this is our main window
+            self.SetTopWindow(frame)
+
+            # Return a success flag
+            return True
+
+
+    app = MyApp(0)     # Create an instance of the application class
+    app.MainLoop()     # Tell it to start processing events
+
+
+#---------------------------------------------------------------------------
+# if running as part of the Demo Framework...
+
+def runTest(frame, nb, log):
+    win = MyFrame(frame, -1, "This is a test")
+    frame.otherWin = win
+    win.Show(True)
+
+
+overview = """\
+A simple example that shows how to use Dialog Units.
+"""
+
+#----------------------------------------------------------------------------
+#
+
+
+
+
+
+
+
+
+

wx/demo/DirDialog.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Create and Show a DirDialog", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        # In this case we include a "New directory" button.
+        dlg = wx.DirDialog(self, "Choose a directory:",
+                          style=wx.DD_DEFAULT_STYLE
+                           #| wx.DD_DIR_MUST_EXIST
+                           #| wx.DD_CHANGE_DIR
+                           )
+
+        # If the user selects OK, then we process the dialog's data.
+        # This is done by getting the path data from the dialog - BEFORE
+        # we destroy it.
+        if dlg.ShowModal() == wx.ID_OK:
+            self.log.WriteText('You selected: %s\n' % dlg.GetPath())
+
+        # Only destroy a dialog after you're done with it.
+        dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+This class represents the directory chooser dialog.  It is used when all you
+need from the user is the name of a directory. Data is retrieved via utility
+methods; see the <code>DirDialog</code> documentation for specifics.
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+