install pywin32-220

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

@@ -0,0 +1,221 @@
+# basictimerapp - a really simple timer application.
+# This should be run using the command line:
+# pythonwin /app demos\basictimerapp.py
+import win32ui
+import win32api
+import win32con
+import sys
+from pywin.framework import app, cmdline, dlgappcore, cmdline
+import timer
+import time
+import string
+
+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()

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

@@ -0,0 +1,194 @@
+# 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.
+
+from pywin.mfc import docview, dialog, afxres
+from pywin.framework import app
+
+import win32con
+import win32ui
+import win32api
+
+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()
+

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

@@ -0,0 +1,52 @@
+# Utilities for the demos
+
+import sys, win32api, win32con, 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()

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

@@ -0,0 +1,46 @@
+# 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
+
+from pywin.framework import dlgappcore, app
+import win32ui
+import sys
+
+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()

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

@@ -0,0 +1,62 @@
+# 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 win32ui
+import win32api
+import win32con
+import sys
+from pywin.framework import app, dlgappcore
+import string
+
+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()

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

@@ -0,0 +1,45 @@
+##
+## 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 <wheineman@uconect.net>
+
+
+import win32con
+import win32ui
+from pywin.mfc import window, dialog, afxres
+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()