Initial revision

Lib/stdwin/DirList.py

@@ -0,0 +1,63 @@
+# DirList -- Directory Listing widget
+
+try:
+	import posix, path
+	os = posix
+except NameError:
+	import mac, macpath
+	os = mac
+	path = macpath
+
+import stdwin, rect
+from stdwinevents import *
+from Buttons import PushButton
+from WindowParent import WindowParent
+from HVSplit import HSplit, VSplit
+
+class DirList() = VSplit():
+	#
+	def create(self, (parent, dirname)):
+		self = VSplit.create(self, parent)
+		names = os.listdir(dirname)
+		for name in names:
+			if path.isdir(path.cat(dirname, name)):
+				fullname = path.cat(dirname, name)
+				btn = SubdirButton().definetext(self, fullname)
+			elif name[-3:] = '.py':
+				btn = ModuleButton().definetext(self, name)
+			else:
+				btn = FileButton().definetext(self, name)
+		return self
+	#
+
+class DirListWindow() = WindowParent():
+	#
+	def create(self, dirname):
+		self = WindowParent.create(self, (dirname, (0, 0)))
+		child = DirList().create(self, dirname)
+		self.realize()
+		return self
+	#
+
+class SubdirButton() = PushButton():
+	#
+	def drawpict(self, d):
+		PushButton.drawpict(self, d)
+		d.box(rect.inset(self.bounds, (3, 1)))
+	#
+	def up_trigger(self):
+		window = DirListWindow().create(self.text)
+	#
+
+class FileButton() = PushButton():
+	#
+	def up_trigger(self):
+		stdwin.fleep()
+	#
+
+class ModuleButton() = FileButton():
+	#
+	def drawpict(self, d):
+		PushButton.drawpict(self, d)
+		d.box(rect.inset(self.bounds, (1, 3)))
+	#

Lib/stdwin/FormSplit.py

@@ -0,0 +1,56 @@
+# A FormSplit lets you place its children exactly where you want them
+# (including silly places!).
+# It does no explicit geometry management except moving its children
+# when it is moved.
+# The interface to place children is as follows.
+# Before you add a child, you may specify its (left, top) position
+# relative to the FormSplit.  If you don't specify a position for
+# a child, it goes right below the previous child; the first child
+# goes to (0, 0) by default.
+# NB: This places data attributes named form_* on its children.
+# XXX Yes, I know, there should be options to do all sorts of relative
+# placement, but for now this will do.
+
+from Split import Split
+
+class FormSplit() = Split():
+	#
+	def create(self, parent):
+		self.next_left = self.next_top = 0
+		self.last_child = None
+		return Split.create(self, parent)
+	#
+	def minsize(self, m):
+		max_width, max_height = 0, 0
+		for c in self.children:
+			c.form_width, c.form_height = c.minsize(m)
+			max_width = max(max_width, c.form_width + c.form_left)
+			max_height = max(max_height, c.form_height + c.form_top)
+		return max_width, max_height
+	#
+	def getbounds(self):
+		return self.bounds
+	#
+	def setbounds(self, bounds):
+		self.bounds = bounds
+		fleft, ftop = bounds[0]
+		for c in self.children:
+			left, top = c.form_left + fleft, c.form_top + ftop
+			right, bottom = left + c.form_width, top + c.form_height
+			c.setbounds((left, top), (right, bottom))
+	#
+	def placenext(self, (left, top)):
+		self.next_left = left
+		self.next_top = top
+		self.last_child = None
+	#
+	def addchild(self, child):
+		if self.last_child:
+			width, height = \
+			    self.last_child.minsize(self.beginmeasuring())
+			self.next_top = self.next_top + height
+		child.form_left = self.next_left
+		child.form_top = self.next_top
+		Split.addchild(self, child)
+		self.last_child = child
+	#

Lib/stdwin/TextEdit.py

@@ -0,0 +1,58 @@
+# Text editing widget
+
+from stdwinevents import *
+
+class TextEdit():
+	#
+	def create(self, (parent, (cols, rows))):
+		parent.addchild(self)
+		self.parent = parent
+		self.cols = cols
+		self.rows = rows
+		self.text = ''
+		# Creation of the editor is done in realize()
+		self.editor = 0
+		return self
+	#
+	# Downcalls from parent to child
+	#
+	def destroy(self):
+		del self.parent
+		del self.editor
+		del self.window
+	#
+	def minsize(self, m):
+		return self.cols*m.textwidth('n'), self.rows*m.lineheight()
+	def setbounds(self, bounds):
+		self.bounds = bounds
+		if self.editor:
+			self.editor.move(bounds)
+	def getbounds(self, bounds):
+		if self.editor:
+			return self.editor.getrect()
+		else:
+			return self.bounds
+	def realize(self):
+		self.window = self.parent.getwindow()
+		self.editor = self.window.textcreate(self.bounds)
+		self.editor.replace(self.text)
+		self.parent.need_mouse(self)
+		self.parent.need_keybd(self)
+		self.parent.need_altdraw(self)
+	def draw(self, (d, area)):
+		pass
+	def altdraw(self, area):
+		self.editor.draw(area)
+	#
+	# Event downcalls
+	#
+	def mouse_down(self, detail):
+		x = self.editor.event(WE_MOUSE_DOWN, self.window, detail)
+	def mouse_move(self, detail):
+		x = self.editor.event(WE_MOUSE_MOVE, self.window, detail)
+	def mouse_up(self, detail):
+		x = self.editor.event(WE_MOUSE_UP, self.window, detail)
+	#
+	def keybd(self, (type, detail)):
+		x = self.editor.event(type, self.window, detail)
+	#

Lib/stdwin/WindowSched.py

@@ -0,0 +1,57 @@
+# Combine a real-time scheduling queue and stdwin event handling.
+# Uses the millisecond timer.
+
+import stdwin
+from stdwinevents import WE_TIMER
+import WindowParent
+import sched
+import time
+
+# Delay function called by the scheduler when it has nothing to do.
+# Return immediately when something is done, or when the delay is up.
+#
+def delayfunc(msecs):
+	#
+	# Check for immediate stdwin event
+	#
+	event = stdwin.pollevent()
+	if event:
+		WindowParent.Dispatch(event)
+		return
+	#
+	# Use millisleep for very short delays or if there are no windows
+	#
+	if msecs < 100 or WindowParent.CountWindows() = 0:
+		time.millisleep(msecs)
+		return
+	#
+	# Post a timer event on an arbitrary window and wait for it
+	#
+	window = WindowParent.AnyWindow()
+	window.settimer(msecs/100)
+	event = stdwin.getevent()
+	window.settimer(0)
+	if event[0] <> WE_TIMER:
+		WindowParent.Dispatch(event)
+
+q = sched.scheduler().init(time.millitimer, delayfunc)
+
+# Export functions enter, enterabs and cancel just like a scheduler
+#
+enter = q.enter
+enterabs = q.enterabs
+cancel = q.cancel
+
+# Emptiness check must check both queues
+#
+def empty():
+	return q.empty() and WindowParent.CountWindows() = 0
+
+# Run until there is nothing left to do
+#
+def run():
+	while not empty():
+		if q.empty():
+			WindowParent.Dispatch(stdwin.getevent())
+		else:
+			q.run()