Upload 498 files

.gitattributes

@@ -84,3 +84,5 @@ MLPY/Lib/site-packages/numpy/core/_simd.cp39-win_amd64.pyd filter=lfs diff=lfs m
 MLPY/Lib/site-packages/onnx/onnx_cpp2py_export.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
 MLPY/Lib/site-packages/PIL/_imaging.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
 MLPY/Lib/site-packages/PIL/_imagingft.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+MLPY/Lib/site-packages/pythonwin/mfc140u.dll filter=lfs diff=lfs merge=lfs -text
+MLPY/Lib/site-packages/pythonwin/win32ui.pyd filter=lfs diff=lfs merge=lfs -text

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0.1
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Author: Kirill Simonov
+Author-email: [email protected]
+License: MIT
+Download-URL: https://pypi.org/project/PyYAML/
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
+

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+PyYAML-6.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.1.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.1.dist-info/METADATA,sha256=9LqpZ7ARc_UDWHhaztw28ggwznRds8xf8oJCGOCT60I,2106
+PyYAML-6.0.1.dist-info/RECORD,,
+PyYAML-6.0.1.dist-info/WHEEL,sha256=eep6QWEFiQfg2wcclssb_WY-D33AnLYLnEKGA9Rn-VU,100
+PyYAML-6.0.1.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-39.pyc,,
+yaml/__init__.py,sha256=bhl05qSeO-1ZxlSRjGrvl2m9nrXb1n9-GQatTN0Mrqc,12311
+yaml/__pycache__/__init__.cpython-39.pyc,,
+yaml/__pycache__/composer.cpython-39.pyc,,
+yaml/__pycache__/constructor.cpython-39.pyc,,
+yaml/__pycache__/cyaml.cpython-39.pyc,,
+yaml/__pycache__/dumper.cpython-39.pyc,,
+yaml/__pycache__/emitter.cpython-39.pyc,,
+yaml/__pycache__/error.cpython-39.pyc,,
+yaml/__pycache__/events.cpython-39.pyc,,
+yaml/__pycache__/loader.cpython-39.pyc,,
+yaml/__pycache__/nodes.cpython-39.pyc,,
+yaml/__pycache__/parser.cpython-39.pyc,,
+yaml/__pycache__/reader.cpython-39.pyc,,
+yaml/__pycache__/representer.cpython-39.pyc,,
+yaml/__pycache__/resolver.cpython-39.pyc,,
+yaml/__pycache__/scanner.cpython-39.pyc,,
+yaml/__pycache__/serializer.cpython-39.pyc,,
+yaml/__pycache__/tokens.cpython-39.pyc,,
+yaml/_yaml.cp39-win_amd64.pyd,sha256=AULP_23onG6Yy5UUqIe4N5f4szwfM5lkHQ60Ak04FTQ,251904
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64
+

MLPY/Lib/site-packages/PyYAML-6.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_yaml
+yaml

MLPY/Lib/site-packages/pythonwin/license.txt

@@ -0,0 +1,30 @@
+Unless stated in the specfic source file, this work is
+Copyright (c) 1994-2008, Mark Hammond 
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+
+Redistributions of source code must retain the above copyright notice, 
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright 
+notice, this list of conditions and the following disclaimer in 
+the documentation and/or other materials provided with the distribution.
+
+Neither name of Mark Hammond nor the name of contributors may be used 
+to endorse or promote products derived from this software without 
+specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

MLPY/Lib/site-packages/pythonwin/mfc140u.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e06c4bd078f4690aa8874a3deb38e802b2a16ccb602a7edc2e077e98c05b5807
+size 5653424

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/basictimerapp.py

@@ -0,0 +1,258 @@
+# basictimerapp - a really simple timer application.
+# This should be run using the command line:
+# pythonwin /app demos\basictimerapp.py
+import sys
+import time
+
+import timer
+import win32api
+import win32con
+import win32ui
+from pywin.framework import app, cmdline, dlgappcore
+
+
+class TimerAppDialog(dlgappcore.AppDialog):
+    softspace = 1
+
+    def __init__(self, appName=""):
+        dlgappcore.AppDialog.__init__(self, win32ui.IDD_GENERAL_STATUS)
+        self.timerAppName = appName
+        self.argOff = 0
+        if len(self.timerAppName) == 0:
+            if len(sys.argv) > 1 and sys.argv[1][0] != "/":
+                self.timerAppName = sys.argv[1]
+                self.argOff = 1
+
+    def PreDoModal(self):
+        # 		sys.stderr = sys.stdout
+        pass
+
+    def ProcessArgs(self, args):
+        for arg in args:
+            if arg == "/now":
+                self.OnOK()
+
+    def OnInitDialog(self):
+        win32ui.SetProfileFileName("pytimer.ini")
+        self.title = win32ui.GetProfileVal(
+            self.timerAppName, "Title", "Remote System Timer"
+        )
+        self.buildTimer = win32ui.GetProfileVal(
+            self.timerAppName, "Timer", "EachMinuteIntervaler()"
+        )
+        self.doWork = win32ui.GetProfileVal(self.timerAppName, "Work", "DoDemoWork()")
+        # replace "\n" with real \n.
+        self.doWork = self.doWork.replace("\\n", "\n")
+        dlgappcore.AppDialog.OnInitDialog(self)
+
+        self.SetWindowText(self.title)
+        self.prompt1 = self.GetDlgItem(win32ui.IDC_PROMPT1)
+        self.prompt2 = self.GetDlgItem(win32ui.IDC_PROMPT2)
+        self.prompt3 = self.GetDlgItem(win32ui.IDC_PROMPT3)
+        self.butOK = self.GetDlgItem(win32con.IDOK)
+        self.butCancel = self.GetDlgItem(win32con.IDCANCEL)
+        self.prompt1.SetWindowText("Python Timer App")
+        self.prompt2.SetWindowText("")
+        self.prompt3.SetWindowText("")
+        self.butOK.SetWindowText("Do it now")
+        self.butCancel.SetWindowText("Close")
+
+        self.timerManager = TimerManager(self)
+        self.ProcessArgs(sys.argv[self.argOff :])
+        self.timerManager.go()
+        return 1
+
+    def OnDestroy(self, msg):
+        dlgappcore.AppDialog.OnDestroy(self, msg)
+        self.timerManager.stop()
+
+    def OnOK(self):
+        # stop the timer, then restart after setting special boolean
+        self.timerManager.stop()
+        self.timerManager.bConnectNow = 1
+        self.timerManager.go()
+        return
+
+
+# 	def OnCancel(self): default behaviour - cancel == close.
+# 		return
+
+
+class TimerManager:
+    def __init__(self, dlg):
+        self.dlg = dlg
+        self.timerId = None
+        self.intervaler = eval(self.dlg.buildTimer)
+        self.bConnectNow = 0
+        self.bHaveSetPrompt1 = 0
+
+    def CaptureOutput(self):
+        self.oldOut = sys.stdout
+        self.oldErr = sys.stderr
+        sys.stdout = sys.stderr = self
+        self.bHaveSetPrompt1 = 0
+
+    def ReleaseOutput(self):
+        sys.stdout = self.oldOut
+        sys.stderr = self.oldErr
+
+    def write(self, str):
+        s = str.strip()
+        if len(s):
+            if self.bHaveSetPrompt1:
+                dest = self.dlg.prompt3
+            else:
+                dest = self.dlg.prompt1
+                self.bHaveSetPrompt1 = 1
+            dest.SetWindowText(s)
+
+    def go(self):
+        self.OnTimer(None, None)
+
+    def stop(self):
+        if self.timerId:
+            timer.kill_timer(self.timerId)
+        self.timerId = None
+
+    def OnTimer(self, id, timeVal):
+        if id:
+            timer.kill_timer(id)
+        if self.intervaler.IsTime() or self.bConnectNow:
+            # do the work.
+            try:
+                self.dlg.SetWindowText(self.dlg.title + " - Working...")
+                self.dlg.butOK.EnableWindow(0)
+                self.dlg.butCancel.EnableWindow(0)
+                self.CaptureOutput()
+                try:
+                    exec(self.dlg.doWork)
+                    print("The last operation completed successfully.")
+                except:
+                    t, v, tb = sys.exc_info()
+                    str = "Failed: %s: %s" % (t, repr(v))
+                    print(str)
+                    self.oldErr.write(str)
+                    tb = None  # Prevent cycle
+            finally:
+                self.ReleaseOutput()
+                self.dlg.butOK.EnableWindow()
+                self.dlg.butCancel.EnableWindow()
+                self.dlg.SetWindowText(self.dlg.title)
+        else:
+            now = time.time()
+            nextTime = self.intervaler.GetNextTime()
+            if nextTime:
+                timeDiffSeconds = nextTime - now
+                timeDiffMinutes = int(timeDiffSeconds / 60)
+                timeDiffSeconds = timeDiffSeconds % 60
+                timeDiffHours = int(timeDiffMinutes / 60)
+                timeDiffMinutes = timeDiffMinutes % 60
+                self.dlg.prompt1.SetWindowText(
+                    "Next connection due in %02d:%02d:%02d"
+                    % (timeDiffHours, timeDiffMinutes, timeDiffSeconds)
+                )
+        self.timerId = timer.set_timer(
+            self.intervaler.GetWakeupInterval(), self.OnTimer
+        )
+        self.bConnectNow = 0
+
+
+class TimerIntervaler:
+    def __init__(self):
+        self.nextTime = None
+        self.wakeUpInterval = 2000
+
+    def GetWakeupInterval(self):
+        return self.wakeUpInterval
+
+    def GetNextTime(self):
+        return self.nextTime
+
+    def IsTime(self):
+        now = time.time()
+        if self.nextTime is None:
+            self.nextTime = self.SetFirstTime(now)
+        ret = 0
+        if now >= self.nextTime:
+            ret = 1
+            self.nextTime = self.SetNextTime(self.nextTime, now)
+            # do the work.
+        return ret
+
+
+class EachAnyIntervaler(TimerIntervaler):
+    def __init__(self, timeAt, timePos, timeAdd, wakeUpInterval=None):
+        TimerIntervaler.__init__(self)
+        self.timeAt = timeAt
+        self.timePos = timePos
+        self.timeAdd = timeAdd
+        if wakeUpInterval:
+            self.wakeUpInterval = wakeUpInterval
+
+    def SetFirstTime(self, now):
+        timeTup = time.localtime(now)
+        lst = []
+        for item in timeTup:
+            lst.append(item)
+        bAdd = timeTup[self.timePos] > self.timeAt
+        lst[self.timePos] = self.timeAt
+        for pos in range(self.timePos + 1, 6):
+            lst[pos] = 0
+        ret = time.mktime(tuple(lst))
+        if bAdd:
+            ret = ret + self.timeAdd
+        return ret
+
+    def SetNextTime(self, lastTime, now):
+        return lastTime + self.timeAdd
+
+
+class EachMinuteIntervaler(EachAnyIntervaler):
+    def __init__(self, at=0):
+        EachAnyIntervaler.__init__(self, at, 5, 60, 2000)
+
+
+class EachHourIntervaler(EachAnyIntervaler):
+    def __init__(self, at=0):
+        EachAnyIntervaler.__init__(self, at, 4, 3600, 10000)
+
+
+class EachDayIntervaler(EachAnyIntervaler):
+    def __init__(self, at=0):
+        EachAnyIntervaler.__init__(self, at, 3, 86400, 10000)
+
+
+class TimerDialogApp(dlgappcore.DialogApp):
+    def CreateDialog(self):
+        return TimerAppDialog()
+
+
+def DoDemoWork():
+    print("Doing the work...")
+    print("About to connect")
+    win32api.MessageBeep(win32con.MB_ICONASTERISK)
+    win32api.Sleep(2000)
+    print("Doing something else...")
+    win32api.MessageBeep(win32con.MB_ICONEXCLAMATION)
+    win32api.Sleep(2000)
+    print("More work.")
+    win32api.MessageBeep(win32con.MB_ICONHAND)
+    win32api.Sleep(2000)
+    print("The last bit.")
+    win32api.MessageBeep(win32con.MB_OK)
+    win32api.Sleep(2000)
+
+
+app = TimerDialogApp()
+
+
+def t():
+    t = TimerAppDialog("Test Dialog")
+    t.DoModal()
+    return t
+
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NeedApp()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/customprint.py

@@ -0,0 +1,186 @@
+# A demo of an Application object that has some custom print functionality.
+
+# If you desire, you can also run this from inside Pythonwin, in which
+# case it will do the demo inside the Pythonwin environment.
+
+# This sample was contributed by Roger Burnham.
+
+import win32api
+import win32con
+import win32ui
+from pywin.framework import app
+from pywin.mfc import afxres, dialog, docview
+
+PRINTDLGORD = 1538
+IDC_PRINT_MAG_EDIT = 1010
+
+
+class PrintDemoTemplate(docview.DocTemplate):
+    def _SetupSharedMenu_(self):
+        pass
+
+
+class PrintDemoView(docview.ScrollView):
+    def OnInitialUpdate(self):
+        ret = self._obj_.OnInitialUpdate()
+        self.colors = {
+            "Black": (0x00 << 0) + (0x00 << 8) + (0x00 << 16),
+            "Red": (0xFF << 0) + (0x00 << 8) + (0x00 << 16),
+            "Green": (0x00 << 0) + (0xFF << 8) + (0x00 << 16),
+            "Blue": (0x00 << 0) + (0x00 << 8) + (0xFF << 16),
+            "Cyan": (0x00 << 0) + (0xFF << 8) + (0xFF << 16),
+            "Magenta": (0xFF << 0) + (0x00 << 8) + (0xFF << 16),
+            "Yellow": (0xFF << 0) + (0xFF << 8) + (0x00 << 16),
+        }
+        self.pens = {}
+        for name, color in self.colors.items():
+            self.pens[name] = win32ui.CreatePen(win32con.PS_SOLID, 5, color)
+        self.pen = None
+        self.size = (128, 128)
+        self.SetScaleToFitSize(self.size)
+        self.HookCommand(self.OnFilePrint, afxres.ID_FILE_PRINT)
+        self.HookCommand(self.OnFilePrintPreview, win32ui.ID_FILE_PRINT_PREVIEW)
+        return ret
+
+    def OnDraw(self, dc):
+        oldPen = None
+        x, y = self.size
+        delta = 2
+        colors = list(self.colors.keys())
+        colors.sort()
+        colors = colors * 2
+        for color in colors:
+            if oldPen is None:
+                oldPen = dc.SelectObject(self.pens[color])
+            else:
+                dc.SelectObject(self.pens[color])
+            dc.MoveTo((delta, delta))
+            dc.LineTo((x - delta, delta))
+            dc.LineTo((x - delta, y - delta))
+            dc.LineTo((delta, y - delta))
+            dc.LineTo((delta, delta))
+            delta = delta + 4
+            if x - delta <= 0 or y - delta <= 0:
+                break
+        dc.SelectObject(oldPen)
+
+    def OnPrepareDC(self, dc, pInfo):
+        if dc.IsPrinting():
+            mag = self.prtDlg["mag"]
+            dc.SetMapMode(win32con.MM_ANISOTROPIC)
+            dc.SetWindowOrg((0, 0))
+            dc.SetWindowExt((1, 1))
+            dc.SetViewportOrg((0, 0))
+            dc.SetViewportExt((mag, mag))
+
+    def OnPreparePrinting(self, pInfo):
+        flags = (
+            win32ui.PD_USEDEVMODECOPIES
+            | win32ui.PD_PAGENUMS
+            | win32ui.PD_NOPAGENUMS
+            | win32ui.PD_NOSELECTION
+        )
+        self.prtDlg = ImagePrintDialog(pInfo, PRINTDLGORD, flags)
+        pInfo.SetPrintDialog(self.prtDlg)
+        pInfo.SetMinPage(1)
+        pInfo.SetMaxPage(1)
+        pInfo.SetFromPage(1)
+        pInfo.SetToPage(1)
+        ret = self.DoPreparePrinting(pInfo)
+        return ret
+
+    def OnBeginPrinting(self, dc, pInfo):
+        return self._obj_.OnBeginPrinting(dc, pInfo)
+
+    def OnEndPrinting(self, dc, pInfo):
+        del self.prtDlg
+        return self._obj_.OnEndPrinting(dc, pInfo)
+
+    def OnFilePrintPreview(self, *arg):
+        self._obj_.OnFilePrintPreview()
+
+    def OnFilePrint(self, *arg):
+        self._obj_.OnFilePrint()
+
+    def OnPrint(self, dc, pInfo):
+        doc = self.GetDocument()
+        metrics = dc.GetTextMetrics()
+        cxChar = metrics["tmAveCharWidth"]
+        cyChar = metrics["tmHeight"]
+        left, top, right, bottom = pInfo.GetDraw()
+        dc.TextOut(0, 2 * cyChar, doc.GetTitle())
+        top = top + (7 * cyChar) / 2
+        dc.MoveTo(left, top)
+        dc.LineTo(right, top)
+        top = top + cyChar
+        # this seems to have not effect...
+        # get what I want with the dc.SetWindowOrg calls
+        pInfo.SetDraw((left, top, right, bottom))
+        dc.SetWindowOrg((0, -top))
+
+        self.OnDraw(dc)
+        dc.SetTextAlign(win32con.TA_LEFT | win32con.TA_BOTTOM)
+
+        rect = self.GetWindowRect()
+        rect = self.ScreenToClient(rect)
+        height = rect[3] - rect[1]
+        dc.SetWindowOrg((0, -(top + height + cyChar)))
+        dc.MoveTo(left, 0)
+        dc.LineTo(right, 0)
+
+        x = 0
+        y = (3 * cyChar) / 2
+
+        dc.TextOut(x, y, doc.GetTitle())
+        y = y + cyChar
+
+
+class PrintDemoApp(app.CApp):
+    def __init__(self):
+        app.CApp.__init__(self)
+
+    def InitInstance(self):
+        template = PrintDemoTemplate(None, None, None, PrintDemoView)
+        self.AddDocTemplate(template)
+        self._obj_.InitMDIInstance()
+        self.LoadMainFrame()
+        doc = template.OpenDocumentFile(None)
+        doc.SetTitle("Custom Print Document")
+
+
+class ImagePrintDialog(dialog.PrintDialog):
+    sectionPos = "Image Print Demo"
+
+    def __init__(self, pInfo, dlgID, flags=win32ui.PD_USEDEVMODECOPIES):
+        dialog.PrintDialog.__init__(self, pInfo, dlgID, flags=flags)
+        mag = win32ui.GetProfileVal(self.sectionPos, "Document Magnification", 0)
+        if mag <= 0:
+            mag = 2
+            win32ui.WriteProfileVal(self.sectionPos, "Document Magnification", mag)
+
+        self["mag"] = mag
+
+    def OnInitDialog(self):
+        self.magCtl = self.GetDlgItem(IDC_PRINT_MAG_EDIT)
+        self.magCtl.SetWindowText(repr(self["mag"]))
+        return dialog.PrintDialog.OnInitDialog(self)
+
+    def OnOK(self):
+        dialog.PrintDialog.OnOK(self)
+        strMag = self.magCtl.GetWindowText()
+        try:
+            self["mag"] = int(strMag)
+        except:
+            pass
+        win32ui.WriteProfileVal(self.sectionPos, "Document Magnification", self["mag"])
+
+
+if __name__ == "__main__":
+    # Running under Pythonwin
+    def test():
+        template = PrintDemoTemplate(None, None, None, PrintDemoView)
+        template.OpenDocumentFile(None)
+
+    test()
+else:
+    app = PrintDemoApp()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/demoutils.py

@@ -0,0 +1,65 @@
+# Utilities for the demos
+
+import sys
+
+import win32api
+import win32con
+import win32ui
+
+NotScriptMsg = """\
+This demo program is not designed to be run as a Script, but is
+probably used by some other test program.  Please try another demo.
+"""
+
+NeedGUIMsg = """\
+This demo program can only be run from inside of Pythonwin
+
+You must start Pythonwin, and select 'Run' from the toolbar or File menu
+"""
+
+
+NeedAppMsg = """\
+This demo program is a 'Pythonwin Application'.
+
+It is more demo code than an example of Pythonwin's capabilities.
+
+To run it, you must execute the command:
+pythonwin.exe /app "%s"
+
+Would you like to execute it now?
+"""
+
+
+def NotAScript():
+    import win32ui
+
+    win32ui.MessageBox(NotScriptMsg, "Demos")
+
+
+def NeedGoodGUI():
+    from pywin.framework.app import HaveGoodGUI
+
+    rc = HaveGoodGUI()
+    if not rc:
+        win32ui.MessageBox(NeedGUIMsg, "Demos")
+    return rc
+
+
+def NeedApp():
+    import win32ui
+
+    rc = win32ui.MessageBox(NeedAppMsg % sys.argv[0], "Demos", win32con.MB_YESNO)
+    if rc == win32con.IDYES:
+        try:
+            parent = win32ui.GetMainFrame().GetSafeHwnd()
+            win32api.ShellExecute(
+                parent, None, "pythonwin.exe", '/app "%s"' % sys.argv[0], None, 1
+            )
+        except win32api.error as details:
+            win32ui.MessageBox("Error executing command - %s" % (details), "Demos")
+
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NotAScript()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/dlgappdemo.py

@@ -0,0 +1,51 @@
+# dlgappdemo - a demo of a dialog application.
+# This is a demonstration of both a custom "application" module,
+# and a Python program in a dialog box.
+#
+# NOTE:  You CAN NOT import this module from either PythonWin or Python.
+# This module must be specified on the commandline to PythonWin only.
+# eg, PythonWin /app dlgappdemo.py
+
+import sys
+
+import win32ui
+from pywin.framework import app, dlgappcore
+
+
+class TestDialogApp(dlgappcore.DialogApp):
+    def CreateDialog(self):
+        return TestAppDialog()
+
+
+class TestAppDialog(dlgappcore.AppDialog):
+    def __init__(self):
+        self.edit = None
+        dlgappcore.AppDialog.__init__(self, win32ui.IDD_LARGE_EDIT)
+
+    def OnInitDialog(self):
+        self.SetWindowText("Test dialog application")
+        self.edit = self.GetDlgItem(win32ui.IDC_EDIT1)
+        print("Hello from Python")
+        print("args are:", end=" ")
+        for arg in sys.argv:
+            print(arg)
+        return 1
+
+    def PreDoModal(self):
+        sys.stdout = sys.stderr = self
+
+    def write(self, str):
+        if self.edit:
+            self.edit.SetSel(-2)
+            # translate \n to \n\r
+            self.edit.ReplaceSel(str.replace("\n", "\r\n"))
+        else:
+            win32ui.OutputDebug("dlgapp - no edit control! >>\n%s\n<<\n" % str)
+
+
+app.AppBuilder = TestDialogApp
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NeedApp()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/dojobapp.py

@@ -0,0 +1,72 @@
+# dojobapp - do a job, show the result in a dialog, and exit.
+#
+# Very simple - faily minimal dialog based app.
+#
+# This should be run using the command line:
+# pythonwin /app demos\dojobapp.py
+
+
+import win32api
+import win32con
+import win32ui
+from pywin.framework import app, dlgappcore
+
+
+class DoJobAppDialog(dlgappcore.AppDialog):
+    softspace = 1
+
+    def __init__(self, appName=""):
+        self.appName = appName
+        dlgappcore.AppDialog.__init__(self, win32ui.IDD_GENERAL_STATUS)
+
+    def PreDoModal(self):
+        pass
+
+    def ProcessArgs(self, args):
+        pass
+
+    def OnInitDialog(self):
+        self.SetWindowText(self.appName)
+        butCancel = self.GetDlgItem(win32con.IDCANCEL)
+        butCancel.ShowWindow(win32con.SW_HIDE)
+        p1 = self.GetDlgItem(win32ui.IDC_PROMPT1)
+        p2 = self.GetDlgItem(win32ui.IDC_PROMPT2)
+
+        # Do something here!
+
+        p1.SetWindowText("Hello there")
+        p2.SetWindowText("from the demo")
+
+    def OnDestroy(self, msg):
+        pass
+
+
+# 	def OnOK(self):
+# 		pass
+# 	def OnCancel(self): default behaviour - cancel == close.
+# 		return
+
+
+class DoJobDialogApp(dlgappcore.DialogApp):
+    def CreateDialog(self):
+        return DoJobAppDialog("Do Something")
+
+
+class CopyToDialogApp(DoJobDialogApp):
+    def __init__(self):
+        DoJobDialogApp.__init__(self)
+
+
+app.AppBuilder = DoJobDialogApp
+
+
+def t():
+    t = DoJobAppDialog("Copy To")
+    t.DoModal()
+    return t
+
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NeedApp()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/app/helloapp.py

@@ -0,0 +1,53 @@
+##
+## helloapp.py
+##
+##
+## A nice, small 'hello world' Pythonwin application.
+## NOT an MDI application - just a single, normal, top-level window.
+##
+## MUST be run with the command line "pythonwin.exe /app helloapp.py"
+## (or if you are really keen, rename "pythonwin.exe" to something else, then
+## using MSVC or similar, edit the string section in the .EXE to name this file)
+##
+## Originally by Willy Heineman <[email protected]>
+
+
+import win32con
+import win32ui
+from pywin.mfc import afxres, dialog, window
+from pywin.mfc.thread import WinApp
+
+
+# The main frame.
+# Does almost nothing at all - doesnt even create a child window!
+class HelloWindow(window.Wnd):
+    def __init__(self):
+        # The window.Wnd ctor creates a Window object, and places it in
+        # self._obj_.  Note the window object exists, but the window itself
+        # does not!
+        window.Wnd.__init__(self, win32ui.CreateWnd())
+
+        # Now we ask the window object to create the window itself.
+        self._obj_.CreateWindowEx(
+            win32con.WS_EX_CLIENTEDGE,
+            win32ui.RegisterWndClass(0, 0, win32con.COLOR_WINDOW + 1),
+            "Hello World!",
+            win32con.WS_OVERLAPPEDWINDOW,
+            (100, 100, 400, 300),
+            None,
+            0,
+            None,
+        )
+
+
+# The application object itself.
+class HelloApp(WinApp):
+    def InitInstance(self):
+        self.frame = HelloWindow()
+        self.frame.ShowWindow(win32con.SW_SHOWNORMAL)
+        # We need to tell MFC what our main frame is.
+        self.SetMainFrame(self.frame)
+
+
+# Now create the application object itself!
+app = HelloApp()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/cmdserver.py

@@ -0,0 +1,116 @@
+# cmdserver.py
+
+# Demo code that is not Pythonwin related, but too good to throw away...
+
+import _thread
+import sys
+import traceback
+
+import win32api
+from pywin.framework import winout
+
+
+class ThreadWriter:
+    "Assign an instance to sys.stdout for per-thread printing objects - Courtesy Guido!"
+
+    def __init__(self):
+        "Constructor -- initialize the table of writers"
+        self.writers = {}
+        self.origStdOut = None
+
+    def register(self, writer):
+        "Register the writer for the current thread"
+        self.writers[_thread.get_ident()] = writer
+        if self.origStdOut is None:
+            self.origStdOut = sys.stdout
+            sys.stdout = self
+
+    def unregister(self):
+        "Remove the writer for the current thread, if any"
+        try:
+            del self.writers[_thread.get_ident()]
+        except KeyError:
+            pass
+        if len(self.writers) == 0:
+            sys.stdout = self.origStdOut
+            self.origStdOut = None
+
+    def getwriter(self):
+        "Return the current thread's writer, default sys.stdout"
+        try:
+            return self.writers[_thread.get_ident()]
+        except KeyError:
+            return self.origStdOut
+
+    def write(self, str):
+        "Write to the current thread's writer, default sys.stdout"
+        self.getwriter().write(str)
+
+
+def Test():
+    num = 1
+    while num < 1000:
+        print("Hello there no " + str(num))
+        win32api.Sleep(50)
+        num = num + 1
+
+
+class flags:
+    SERVER_BEST = 0
+    SERVER_IMMEDIATE = 1
+    SERVER_THREAD = 2
+    SERVER_PROCESS = 3
+
+
+def StartServer(cmd, title=None, bCloseOnEnd=0, serverFlags=flags.SERVER_BEST):
+    out = winout.WindowOutput(title, None, winout.flags.WQ_IDLE)
+    if not title:
+        title = cmd
+    out.Create(title)
+    # 	ServerThread((out, cmd, title, bCloseOnEnd))
+    # 	out = sys.stdout
+    _thread.start_new_thread(ServerThread, (out, cmd, title, bCloseOnEnd))
+
+
+def ServerThread(myout, cmd, title, bCloseOnEnd):
+    try:
+        writer.register(myout)
+        print('Executing "%s"\n' % cmd)
+        bOK = 1
+        try:
+            import __main__
+
+            exec(cmd + "\n", __main__.__dict__)
+        except:
+            bOK = 0
+        if bOK:
+            print("Command terminated without errors.")
+        else:
+            t, v, tb = sys.exc_info()
+            print(t, ": ", v)
+            traceback.print_tb(tb)
+            tb = None  # prevent a cycle
+            print("Command terminated with an unhandled exception")
+        writer.unregister()
+        if bOK and bCloseOnEnd:
+            myout.frame.DestroyWindow()
+
+    # Unhandled exception of any kind in a thread kills the gui!
+    except:
+        t, v, tb = sys.exc_info()
+        print(t, ": ", v)
+        traceback.print_tb(tb)
+        tb = None
+        print("Thread failed")
+
+
+# assist for reloading (when debugging) - use only 1 tracer object,
+# else a large chain of tracer objects will exist.
+# try:
+# 	writer
+# except NameError:
+# 	writer=ThreadWriter()
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NotAScript()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/createwin.py

@@ -0,0 +1,114 @@
+#
+# Window creation example
+#
+# 	This example creates a minimal "control" that just fills in its
+# 	window with red.  To make your own control, subclass Control and
+# 	write your own OnPaint() method.  See PyCWnd.HookMessage for what
+# 	the parameters to OnPaint are.
+#
+
+import win32api
+import win32con
+import win32ui
+from pywin.mfc import dialog, window
+
+
+class Control(window.Wnd):
+    """Generic control class"""
+
+    def __init__(self):
+        window.Wnd.__init__(self, win32ui.CreateWnd())
+
+    def OnPaint(self):
+        dc, paintStruct = self.BeginPaint()
+        self.DoPaint(dc)
+        self.EndPaint(paintStruct)
+
+    def DoPaint(self, dc):  # Override this!
+        pass
+
+
+class RedBox(Control):
+    def DoPaint(self, dc):
+        dc.FillSolidRect(self.GetClientRect(), win32api.RGB(255, 0, 0))
+
+
+class RedBoxWithPie(RedBox):
+    def DoPaint(self, dc):
+        RedBox.DoPaint(self, dc)
+        r = self.GetClientRect()
+        dc.Pie(r[0], r[1], r[2], r[3], 0, 0, r[2], r[3] // 2)
+
+
+def MakeDlgTemplate():
+    style = (
+        win32con.DS_MODALFRAME
+        | win32con.WS_POPUP
+        | win32con.WS_VISIBLE
+        | win32con.WS_CAPTION
+        | win32con.WS_SYSMENU
+        | win32con.DS_SETFONT
+    )
+    cs = win32con.WS_CHILD | win32con.WS_VISIBLE
+
+    w = 64
+    h = 64
+
+    dlg = [
+        ["Red box", (0, 0, w, h), style, None, (8, "MS Sans Serif")],
+    ]
+
+    s = win32con.WS_TABSTOP | cs
+
+    dlg.append(
+        [
+            128,
+            "Cancel",
+            win32con.IDCANCEL,
+            (7, h - 18, 50, 14),
+            s | win32con.BS_PUSHBUTTON,
+        ]
+    )
+
+    return dlg
+
+
+class TestDialog(dialog.Dialog):
+    def OnInitDialog(self):
+        rc = dialog.Dialog.OnInitDialog(self)
+        self.redbox = RedBox()
+        self.redbox.CreateWindow(
+            None,
+            "RedBox",
+            win32con.WS_CHILD | win32con.WS_VISIBLE,
+            (5, 5, 90, 68),
+            self,
+            1003,
+        )
+        return rc
+
+
+class TestPieDialog(dialog.Dialog):
+    def OnInitDialog(self):
+        rc = dialog.Dialog.OnInitDialog(self)
+        self.control = RedBoxWithPie()
+        self.control.CreateWindow(
+            None,
+            "RedBox with Pie",
+            win32con.WS_CHILD | win32con.WS_VISIBLE,
+            (5, 5, 90, 68),
+            self,
+            1003,
+        )
+
+
+def demo(modal=0):
+    d = TestPieDialog(MakeDlgTemplate())
+    if modal:
+        d.DoModal()
+    else:
+        d.CreateWindow()
+
+
+if __name__ == "__main__":
+    demo(1)

MLPY/Lib/site-packages/pythonwin/pywin/Demos/demoutils.py

@@ -0,0 +1,67 @@
+# Utilities for the demos
+
+import sys
+
+import win32api
+import win32con
+import win32ui
+
+NotScriptMsg = """\
+This demo program is not designed to be run as a Script, but is
+probably used by some other test program.  Please try another demo.
+"""
+
+NeedGUIMsg = """\
+This demo program can only be run from inside of Pythonwin
+
+You must start Pythonwin, and select 'Run' from the toolbar or File menu
+"""
+
+
+NeedAppMsg = """\
+This demo program is a 'Pythonwin Application'.
+
+It is more demo code than an example of Pythonwin's capabilities.
+
+To run it, you must execute the command:
+pythonwin.exe /app "%s"
+
+Would you like to execute it now?
+"""
+
+
+def NotAScript():
+    import win32ui
+
+    win32ui.MessageBox(NotScriptMsg, "Demos")
+
+
+def NeedGoodGUI():
+    from pywin.framework.app import HaveGoodGUI
+
+    rc = HaveGoodGUI()
+    if not rc:
+        win32ui.MessageBox(NeedGUIMsg, "Demos")
+    return rc
+
+
+def NeedApp():
+    import win32ui
+
+    rc = win32ui.MessageBox(NeedAppMsg % sys.argv[0], "Demos", win32con.MB_YESNO)
+    if rc == win32con.IDYES:
+        try:
+            parent = win32ui.GetMainFrame().GetSafeHwnd()
+            win32api.ShellExecute(
+                parent, None, "pythonwin.exe", '/app "%s"' % sys.argv[0], None, 1
+            )
+        except win32api.error as details:
+            win32ui.MessageBox("Error executing command - %s" % (details), "Demos")
+
+
+from pywin.framework.app import HaveGoodGUI
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NotAScript()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/dibdemo.py

@@ -0,0 +1,73 @@
+# A demo which creates a view and a frame which displays a PPM format bitmap
+#
+# This hasnnt been run in a while, as I dont have many of that format around!
+
+import win32api
+import win32con
+import win32ui
+
+
+class DIBView:
+    def __init__(self, doc, dib):
+        self.dib = dib
+        self.view = win32ui.CreateView(doc)
+        self.width = self.height = 0
+        # set up message handlers
+        # 		self.view.OnPrepareDC = self.OnPrepareDC
+        self.view.HookMessage(self.OnSize, win32con.WM_SIZE)
+
+    def OnSize(self, params):
+        lParam = params[3]
+        self.width = win32api.LOWORD(lParam)
+        self.height = win32api.HIWORD(lParam)
+
+    def OnDraw(self, ob, dc):
+        # set sizes used for "non strecth" mode.
+        self.view.SetScrollSizes(win32con.MM_TEXT, self.dib.GetSize())
+        dibSize = self.dib.GetSize()
+        dibRect = (0, 0, dibSize[0], dibSize[1])
+        # stretch BMP.
+        # self.dib.Paint(dc, (0,0,self.width, self.height),dibRect)
+        # non stretch.
+        self.dib.Paint(dc)
+
+
+class DIBDemo:
+    def __init__(self, filename, *bPBM):
+        # init data members
+        f = open(filename, "rb")
+        dib = win32ui.CreateDIBitmap()
+        if len(bPBM) > 0:
+            magic = f.readline()
+            if magic != "P6\n":
+                print("The file is not a PBM format file")
+                raise ValueError("Failed - The file is not a PBM format file")
+            # check magic?
+            rowcollist = f.readline().split()
+            cols = int(rowcollist[0])
+            rows = int(rowcollist[1])
+            f.readline()  # whats this one?
+            dib.LoadPBMData(f, (cols, rows))
+        else:
+            dib.LoadWindowsFormatFile(f)
+        f.close()
+        # create doc/view
+        self.doc = win32ui.CreateDoc()
+        self.dibView = DIBView(self.doc, dib)
+        self.frame = win32ui.CreateMDIFrame()
+        self.frame.LoadFrame()  # this will force OnCreateClient
+        self.doc.SetTitle("DIB Demo")
+        self.frame.ShowWindow()
+
+        # display the sucka
+        self.frame.ActivateFrame()
+
+    def OnCreateClient(self, createparams, context):
+        self.dibView.view.CreateWindow(self.frame)
+        return 1
+
+
+if __name__ == "__main__":
+    import demoutils
+
+    demoutils.NotAScript()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/dlgtest.py

@@ -0,0 +1,145 @@
+# A Demo of Pythonwin's Dialog and Property Page support.
+
+###################
+#
+# First demo - use the built-in to Pythonwin "Tab Stop" dialog, but
+# customise it heavily.
+#
+# ID's for the tabstop dialog - out test.
+#
+import win32con
+import win32ui
+from pywin.mfc import dialog
+from win32con import IDCANCEL
+from win32ui import IDC_EDIT_TABS, IDC_PROMPT_TABS, IDD_SET_TABSTOPS
+
+
+class TestDialog(dialog.Dialog):
+    def __init__(self, modal=1):
+        dialog.Dialog.__init__(self, IDD_SET_TABSTOPS)
+        self.counter = 0
+        if modal:
+            self.DoModal()
+        else:
+            self.CreateWindow()
+
+    def OnInitDialog(self):
+        # Set the caption of the dialog itself.
+        self.SetWindowText("Used to be Tab Stops!")
+        # Get a child control, remember it, and change its text.
+        self.edit = self.GetDlgItem(IDC_EDIT_TABS)  # the text box.
+        self.edit.SetWindowText("Test")
+        # Hook a Windows message for the dialog.
+        self.edit.HookMessage(self.KillFocus, win32con.WM_KILLFOCUS)
+        # Get the prompt control, and change its next.
+        prompt = self.GetDlgItem(IDC_PROMPT_TABS)  # the prompt box.
+        prompt.SetWindowText("Prompt")
+        # And the same for the button..
+        cancel = self.GetDlgItem(IDCANCEL)  # the cancel button
+        cancel.SetWindowText("&Kill me")
+
+        # And just for demonstration purposes, we hook the notify message for the dialog.
+        # This allows us to be notified when the Edit Control text changes.
+        self.HookCommand(self.OnNotify, IDC_EDIT_TABS)
+
+    def OnNotify(self, controlid, code):
+        if code == win32con.EN_CHANGE:
+            print("Edit text changed!")
+        return 1  # I handled this, so no need to call defaults!
+
+    # kill focus for the edit box.
+    # Simply increment the value in the text box.
+    def KillFocus(self, msg):
+        self.counter = self.counter + 1
+        if self.edit != None:
+            self.edit.SetWindowText(str(self.counter))
+
+    # Called when the dialog box is terminating...
+    def OnDestroy(self, msg):
+        del self.edit
+        del self.counter
+
+
+# A very simply Property Sheet.
+# We only make a new class for demonstration purposes.
+class TestSheet(dialog.PropertySheet):
+    def __init__(self, title):
+        dialog.PropertySheet.__init__(self, title)
+        self.HookMessage(self.OnActivate, win32con.WM_ACTIVATE)
+
+    def OnActivate(self, msg):
+        pass
+
+
+# A very simply Property Page, which will be "owned" by the above
+# Property Sheet.
+# We create a new class, just so we can hook a control notification.
+class TestPage(dialog.PropertyPage):
+    def OnInitDialog(self):
+        # We use the HookNotify function to allow Python to respond to
+        # Windows WM_NOTIFY messages.
+        # In this case, we are interested in BN_CLICKED messages.
+        self.HookNotify(self.OnNotify, win32con.BN_CLICKED)
+
+    def OnNotify(self, std, extra):
+        print("OnNotify", std, extra)
+
+
+# Some code that actually uses these objects.
+def demo(modal=0):
+    TestDialog(modal)
+
+    # property sheet/page demo
+    ps = win32ui.CreatePropertySheet("Property Sheet/Page Demo")
+    # Create a completely standard PropertyPage.
+    page1 = win32ui.CreatePropertyPage(win32ui.IDD_PROPDEMO1)
+    # Create our custom property page.
+    page2 = TestPage(win32ui.IDD_PROPDEMO2)
+    ps.AddPage(page1)
+    ps.AddPage(page2)
+    if modal:
+        ps.DoModal()
+    else:
+        style = (
+            win32con.WS_SYSMENU
+            | win32con.WS_POPUP
+            | win32con.WS_CAPTION
+            | win32con.DS_MODALFRAME
+            | win32con.WS_VISIBLE
+        )
+        styleex = win32con.WS_EX_DLGMODALFRAME | win32con.WS_EX_PALETTEWINDOW
+        ps.CreateWindow(win32ui.GetMainFrame(), style, styleex)
+
+
+def test(modal=1):
+    # 	dlg=dialog.Dialog(1010)
+    # 	dlg.CreateWindow()
+    # 	dlg.EndDialog(0)
+    # 	del dlg
+    # 	return
+    # property sheet/page demo
+    ps = TestSheet("Property Sheet/Page Demo")
+    page1 = win32ui.CreatePropertyPage(win32ui.IDD_PROPDEMO1)
+    page2 = win32ui.CreatePropertyPage(win32ui.IDD_PROPDEMO2)
+    ps.AddPage(page1)
+    ps.AddPage(page2)
+    del page1
+    del page2
+    if modal:
+        ps.DoModal()
+    else:
+        ps.CreateWindow(win32ui.GetMainFrame())
+    return ps
+
+
+def d():
+    dlg = win32ui.CreateDialog(win32ui.IDD_DEBUGGER)
+    dlg.datalist.append((win32ui.IDC_DBG_RADIOSTACK, "radio"))
+    print("data list is ", dlg.datalist)
+    dlg.data["radio"] = 1
+    dlg.DoModal()
+    print(dlg.data["radio"])
+
+
+if __name__ == "__main__":
+    demo(1)

MLPY/Lib/site-packages/pythonwin/pywin/Demos/dyndlg.py

@@ -0,0 +1,104 @@
+# dyndlg.py
+# contributed by Curt Hagenlocher <[email protected]>
+
+# Dialog Template params:
+# 	Parameter 0 - Window caption
+# 	Parameter 1 - Bounds (rect tuple)
+# 	Parameter 2 - Window style
+# 	Parameter 3 - Extended style
+# 	Parameter 4 - Font tuple
+# 	Parameter 5 - Menu name
+# 	Parameter 6 - Window class
+# Dialog item params:
+# 	Parameter 0 - Window class
+# 	Parameter 1 - Text
+# 	Parameter 2 - ID
+# 	Parameter 3 - Bounds
+# 	Parameter 4 - Style
+# 	Parameter 5 - Extended style
+# 	Parameter 6 - Extra data
+
+
+import win32con
+import win32ui
+from pywin.mfc import dialog, window
+
+
+def MakeDlgTemplate():
+    style = (
+        win32con.DS_MODALFRAME
+        | win32con.WS_POPUP
+        | win32con.WS_VISIBLE
+        | win32con.WS_CAPTION
+        | win32con.WS_SYSMENU
+        | win32con.DS_SETFONT
+    )
+    cs = win32con.WS_CHILD | win32con.WS_VISIBLE
+    dlg = [
+        ["Select Warehouse", (0, 0, 177, 93), style, None, (8, "MS Sans Serif")],
+    ]
+    dlg.append([130, "Current Warehouse:", -1, (7, 7, 69, 9), cs | win32con.SS_LEFT])
+    dlg.append([130, "ASTORIA", 128, (16, 17, 99, 7), cs | win32con.SS_LEFT])
+    dlg.append([130, "New &Warehouse:", -1, (7, 29, 69, 9), cs | win32con.SS_LEFT])
+    s = win32con.WS_TABSTOP | cs
+    # 	dlg.append([131, None, 130, (5, 40, 110, 48),
+    # 		s | win32con.LBS_NOTIFY | win32con.LBS_SORT | win32con.LBS_NOINTEGRALHEIGHT | win32con.WS_VSCROLL | win32con.WS_BORDER])
+    dlg.append(
+        [
+            "{8E27C92B-1264-101C-8A2F-040224009C02}",
+            None,
+            131,
+            (5, 40, 110, 48),
+            win32con.WS_TABSTOP,
+        ]
+    )
+
+    dlg.append(
+        [128, "OK", win32con.IDOK, (124, 5, 50, 14), s | win32con.BS_DEFPUSHBUTTON]
+    )
+    s = win32con.BS_PUSHBUTTON | s
+    dlg.append([128, "Cancel", win32con.IDCANCEL, (124, 22, 50, 14), s])
+    dlg.append([128, "&Help", 100, (124, 74, 50, 14), s])
+
+    return dlg
+
+
+def test1():
+    win32ui.CreateDialogIndirect(MakeDlgTemplate()).DoModal()
+
+
+def test2():
+    dialog.Dialog(MakeDlgTemplate()).DoModal()
+
+
+def test3():
+    dlg = win32ui.LoadDialogResource(win32ui.IDD_SET_TABSTOPS)
+    dlg[0][0] = "New Dialog Title"
+    dlg[0][1] = (80, 20, 161, 60)
+    dlg[1][1] = "&Confusion:"
+    cs = (
+        win32con.WS_CHILD
+        | win32con.WS_VISIBLE
+        | win32con.WS_TABSTOP
+        | win32con.BS_PUSHBUTTON
+    )
+    dlg.append([128, "&Help", 100, (111, 41, 40, 14), cs])
+    dialog.Dialog(dlg).DoModal()
+
+
+def test4():
+    page1 = dialog.PropertyPage(win32ui.LoadDialogResource(win32ui.IDD_PROPDEMO1))
+    page2 = dialog.PropertyPage(win32ui.LoadDialogResource(win32ui.IDD_PROPDEMO2))
+    ps = dialog.PropertySheet("Property Sheet/Page Demo", None, [page1, page2])
+    ps.DoModal()
+
+
+def testall():
+    test1()
+    test2()
+    test3()
+    test4()
+
+
+if __name__ == "__main__":
+    testall()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/fontdemo.py

@@ -0,0 +1,86 @@
+# Demo of Generic document windows, DC, and Font usage
+# by Dave Brennan ([email protected])
+
+# usage examples:
+
+# >>> from fontdemo import *
+# >>> d = FontDemo('Hello, Python')
+# >>> f1 = { 'name':'Arial', 'height':36, 'weight':win32con.FW_BOLD}
+# >>> d.SetFont(f1)
+# >>> f2 = {'name':'Courier New', 'height':24, 'italic':1}
+# >>> d.SetFont (f2)
+
+import win32api
+import win32con
+import win32ui
+from pywin.mfc import docview
+
+# font is a dictionary in which the following elements matter:
+# (the best matching font to supplied parameters is returned)
+#   name		string name of the font as known by Windows
+#   size		point size of font in logical units
+#   weight		weight of font (win32con.FW_NORMAL, win32con.FW_BOLD)
+#   italic		boolean; true if set to anything but None
+#   underline	boolean; true if set to anything but None
+
+
+class FontView(docview.ScrollView):
+    def __init__(
+        self, doc, text="Python Rules!", font_spec={"name": "Arial", "height": 42}
+    ):
+        docview.ScrollView.__init__(self, doc)
+        self.font = win32ui.CreateFont(font_spec)
+        self.text = text
+        self.width = self.height = 0
+        # set up message handlers
+        self.HookMessage(self.OnSize, win32con.WM_SIZE)
+
+    def OnAttachedObjectDeath(self):
+        docview.ScrollView.OnAttachedObjectDeath(self)
+        del self.font
+
+    def SetFont(self, new_font):
+        # Change font on the fly
+        self.font = win32ui.CreateFont(new_font)
+        # redraw the entire client window
+        selfInvalidateRect(None)
+
+    def OnSize(self, params):
+        lParam = params[3]
+        self.width = win32api.LOWORD(lParam)
+        self.height = win32api.HIWORD(lParam)
+
+    def OnPrepareDC(self, dc, printinfo):
+        # Set up the DC for forthcoming OnDraw call
+        self.SetScrollSizes(win32con.MM_TEXT, (100, 100))
+        dc.SetTextColor(win32api.RGB(0, 0, 255))
+        dc.SetBkColor(win32api.GetSysColor(win32con.COLOR_WINDOW))
+        dc.SelectObject(self.font)
+        dc.SetTextAlign(win32con.TA_CENTER | win32con.TA_BASELINE)
+
+    def OnDraw(self, dc):
+        if self.width == 0 and self.height == 0:
+            left, top, right, bottom = self.GetClientRect()
+            self.width = right - left
+            self.height = bottom - top
+        x, y = self.width // 2, self.height // 2
+        dc.TextOut(x, y, self.text)
+
+
+def FontDemo():
+    # create doc/view
+    template = docview.DocTemplate(win32ui.IDR_PYTHONTYPE, None, None, FontView)
+    doc = template.OpenDocumentFile(None)
+    doc.SetTitle("Font Demo")
+    # 	print "template is ", template, "obj is", template._obj_
+    template.close()
+
+
+# 	print "closed"
+# 	del template
+
+if __name__ == "__main__":
+    import demoutils
+
+    if demoutils.NeedGoodGUI():
+        FontDemo()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/guidemo.py

@@ -0,0 +1,86 @@
+# GUI Demo - just a worker script to invoke all the other demo/test scripts.
+import sys
+
+import __main__
+import regutil
+import win32api
+import win32ui
+
+demos = [  # 	('Font', 'import fontdemo;fontdemo.FontDemo()'),
+    ("Open GL Demo", "import openGLDemo;openGLDemo.test()"),
+    ("Threaded GUI", "import threadedgui;threadedgui.ThreadedDemo()"),
+    ("Tree View Demo", "import hiertest;hiertest.demoboth()"),
+    ("3-Way Splitter Window", "import splittst;splittst.demo()"),
+    ("Custom Toolbars and Tooltips", "import toolbar;toolbar.test()"),
+    ("Progress Bar", "import progressbar;progressbar.demo()"),
+    ("Slider Control", "import sliderdemo;sliderdemo.demo()"),
+    ("Dynamic window creation", "import createwin;createwin.demo()"),
+    ("Various Dialog demos", "import dlgtest;dlgtest.demo()"),
+    ("OCX Control Demo", "from ocx import ocxtest;ocxtest.demo()"),
+    ("OCX Serial Port Demo", "from ocx import ocxserialtest;	ocxserialtest.test()"),
+    (
+        "IE4 Control Demo",
+        'from ocx import webbrowser; webbrowser.Demo("http://www.python.org")',
+    ),
+]
+
+
+def demo():
+    try:
+        # seeif I can locate the demo files.
+        import fontdemo
+    except ImportError:
+        # else put the demos direectory on the path (if not already)
+        try:
+            instPath = regutil.GetRegistryDefaultValue(
+                regutil.BuildDefaultPythonKey() + "\\InstallPath"
+            )
+        except win32api.error:
+            print(
+                "The InstallPath can not be located, and the Demos directory is not on the path"
+            )
+            instPath = "."
+
+        demosDir = win32ui.FullPath(instPath + "\\Demos")
+        for path in sys.path:
+            if win32ui.FullPath(path) == demosDir:
+                break
+        else:
+            sys.path.append(demosDir)
+        import fontdemo
+
+    import sys
+
+    if "/go" in sys.argv:
+        for name, cmd in demos:
+            try:
+                exec(cmd)
+            except:
+                print(
+                    "Demo of %s failed - %s:%s"
+                    % (cmd, sys.exc_info()[0], sys.exc_info()[1])
+                )
+        return
+    # Otherwise allow the user to select the demo to run
+
+    import pywin.dialogs.list
+
+    while 1:
+        rc = pywin.dialogs.list.SelectFromLists("Select a Demo", demos, ["Demo Title"])
+        if rc is None:
+            break
+        title, cmd = demos[rc]
+        try:
+            exec(cmd)
+        except:
+            print(
+                "Demo of %s failed - %s:%s"
+                % (title, sys.exc_info()[0], sys.exc_info()[1])
+            )
+
+
+if __name__ == __main__.__name__:
+    import demoutils
+
+    if demoutils.NeedGoodGUI():
+        demo()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/hiertest.py

@@ -0,0 +1,138 @@
+import os
+
+import commctrl
+import win32ui
+from pywin.mfc import docview, window
+from pywin.tools import hierlist
+
+
+# directory listbox
+# This has obvious limitations - doesnt track subdirs, etc.  Demonstrates
+# simple use of Python code for querying the tree as needed.
+# Only use strings, and lists of strings (from curdir())
+class DirHierList(hierlist.HierList):
+    def __init__(self, root, listBoxID=win32ui.IDC_LIST1):
+        hierlist.HierList.__init__(self, root, win32ui.IDB_HIERFOLDERS, listBoxID)
+
+    def GetText(self, item):
+        return os.path.basename(item)
+
+    def GetSubList(self, item):
+        if os.path.isdir(item):
+            ret = [os.path.join(item, fname) for fname in os.listdir(item)]
+        else:
+            ret = None
+        return ret
+
+    # if the item is a dir, it is expandable.
+    def IsExpandable(self, item):
+        return os.path.isdir(item)
+
+    def GetSelectedBitmapColumn(self, item):
+        return self.GetBitmapColumn(item) + 6  # Use different color for selection
+
+
+class TestDocument(docview.Document):
+    def __init__(self, template):
+        docview.Document.__init__(self, template)
+        self.hierlist = hierlist.HierListWithItems(
+            HLIFileDir("\\"), win32ui.IDB_HIERFOLDERS, win32ui.AFX_IDW_PANE_FIRST
+        )
+
+
+class HierListView(docview.TreeView):
+    def OnInitialUpdate(self):
+        rc = self._obj_.OnInitialUpdate()
+        self.hierList = self.GetDocument().hierlist
+        self.hierList.HierInit(self.GetParent())
+        self.hierList.SetStyle(
+            commctrl.TVS_HASLINES | commctrl.TVS_LINESATROOT | commctrl.TVS_HASBUTTONS
+        )
+        return rc
+
+
+class HierListFrame(window.MDIChildWnd):
+    pass
+
+
+def GetTestRoot():
+    tree1 = ("Tree 1", [("Item 1", "Item 1 data"), "Item 2", 3])
+    tree2 = ("Tree 2", [("Item 2.1", "Item 2 data"), "Item 2.2", 2.3])
+    return ("Root", [tree1, tree2, "Item 3"])
+
+
+def demoboth():
+    template = docview.DocTemplate(
+        win32ui.IDR_PYTHONTYPE, TestDocument, HierListFrame, HierListView
+    )
+    template.OpenDocumentFile(None).SetTitle("Hierlist demo")
+
+    demomodeless()
+
+
+def demomodeless():
+    testList2 = DirHierList("\\")
+    dlg = hierlist.HierDialog("hier list test", testList2)
+    dlg.CreateWindow()
+
+
+def demodlg():
+    testList2 = DirHierList("\\")
+    dlg = hierlist.HierDialog("hier list test", testList2)
+    dlg.DoModal()
+
+
+def demo():
+    template = docview.DocTemplate(
+        win32ui.IDR_PYTHONTYPE, TestDocument, HierListFrame, HierListView
+    )
+    template.OpenDocumentFile(None).SetTitle("Hierlist demo")
+
+
+#
+# Demo/Test for HierList items.
+#
+# Easy to make a better directory program.
+#
+class HLIFileDir(hierlist.HierListItem):
+    def __init__(self, filename):
+        self.filename = filename
+        hierlist.HierListItem.__init__(self)
+
+    def GetText(self):
+        try:
+            return "%-20s %d bytes" % (
+                os.path.basename(self.filename),
+                os.stat(self.filename)[6],
+            )
+        except os.error as details:
+            return "%-20s - %s" % (self.filename, details[1])
+
+    def IsExpandable(self):
+        return os.path.isdir(self.filename)
+
+    def GetSubList(self):
+        ret = []
+        for newname in os.listdir(self.filename):
+            if newname not in (".", ".."):
+                ret.append(HLIFileDir(os.path.join(self.filename, newname)))
+        return ret
+
+
+def demohli():
+    template = docview.DocTemplate(
+        win32ui.IDR_PYTHONTYPE,
+        TestDocument,
+        hierlist.HierListFrame,
+        hierlist.HierListView,
+    )
+    template.OpenDocumentFile(None).SetTitle("Hierlist demo")
+
+
+if __name__ == "__main__":
+    import demoutils
+
+    if demoutils.HaveGoodGUI():
+        demoboth()
+    else:
+        demodlg()

MLPY/Lib/site-packages/pythonwin/pywin/Demos/menutest.py

@@ -0,0 +1,13 @@
+# Run this as a python script, to gray "close" off the edit window system menu.
+import win32con
+from pywin.framework import interact
+
+if __name__ == "__main__":
+    import demoutils
+
+    if demoutils.NeedGoodGUI():
+        win = interact.edit.currentView.GetParent()
+        menu = win.GetSystemMenu()
+        id = menu.GetMenuItemID(6)
+        menu.EnableMenuItem(id, win32con.MF_BYCOMMAND | win32con.MF_GRAYED)
+        print("The interactive window's 'Close' menu item is now disabled.")