From 2d844d1ddc581c80116c88be5854720bcf84f3e0 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Sun, 7 Apr 1991 13:41:50 +0000 Subject: Initial revision --- Lib/lib-stdwin/DirList.py | 63 +++++++++ Lib/lib-stdwin/FormSplit.py | 56 ++++++++ Lib/lib-stdwin/TextEdit.py | 58 +++++++++ Lib/lib-stdwin/WindowSched.py | 57 ++++++++ Lib/persist.py | 297 ++++++++++++++++++++++++++++++++++++++++++ Lib/sched.py | 96 ++++++++++++++ Lib/stdwin/DirList.py | 63 +++++++++ Lib/stdwin/FormSplit.py | 56 ++++++++ Lib/stdwin/TextEdit.py | 58 +++++++++ Lib/stdwin/WindowSched.py | 57 ++++++++ 10 files changed, 861 insertions(+) create mode 100644 Lib/lib-stdwin/DirList.py create mode 100644 Lib/lib-stdwin/FormSplit.py create mode 100644 Lib/lib-stdwin/TextEdit.py create mode 100644 Lib/lib-stdwin/WindowSched.py create mode 100755 Lib/persist.py create mode 100644 Lib/sched.py create mode 100755 Lib/stdwin/DirList.py create mode 100755 Lib/stdwin/FormSplit.py create mode 100755 Lib/stdwin/TextEdit.py create mode 100755 Lib/stdwin/WindowSched.py diff --git a/Lib/lib-stdwin/DirList.py b/Lib/lib-stdwin/DirList.py new file mode 100644 index 0000000..fb0ae99 --- /dev/null +++ b/Lib/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))) + # diff --git a/Lib/lib-stdwin/FormSplit.py b/Lib/lib-stdwin/FormSplit.py new file mode 100644 index 0000000..4f0bd01 --- /dev/null +++ b/Lib/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 + # diff --git a/Lib/lib-stdwin/TextEdit.py b/Lib/lib-stdwin/TextEdit.py new file mode 100644 index 0000000..8d12465 --- /dev/null +++ b/Lib/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) + # diff --git a/Lib/lib-stdwin/WindowSched.py b/Lib/lib-stdwin/WindowSched.py new file mode 100644 index 0000000..19be2b1 --- /dev/null +++ b/Lib/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() diff --git a/Lib/persist.py b/Lib/persist.py new file mode 100755 index 0000000..bc91e4d --- /dev/null +++ b/Lib/persist.py @@ -0,0 +1,297 @@ +# persist.py +# +# Implement limited persistence. +# +# Simple interface: +# persist.save() save __main__ module on file (overwrite) +# persist.load() load __main__ module from file (merge) +# +# These use the filename persist.defaultfile, initialized to 'wsrestore.py'. +# +# A raw interface also exists: +# persist.writedict(dict, fp) save dictionary to open file +# persist.readdict(dict, fp) read (merge) dictionary from open file +# +# Internally, the function dump() and a whole bunch of support of functions +# traverse a graph of objects and print them in a restorable form +# (which happens to be a Python module). +# +# XXX Limitations: +# - Volatile objects are dumped as strings: +# - open files, windows etc. +# - Other 'obscure' objects are dumped as strings: +# - classes, instances and methods +# - compiled regular expressions +# - anything else reasonably obscure (e.g., capabilities) +# - type objects for obscure objects +# - It's slow when there are many of lists or dictionaries +# (This could be fixed if there were a quick way to compute a hash +# function of any object, even if recursive) + +defaultfile = 'wsrestore.py' + +def save(): + import __main__ + import posix + # XXX On SYSV, if len(defaultfile) >= 14, this is wrong! + backup = defaultfile + '~' + try: + posix.unlink(backup) + except posix.error: + pass + try: + posix.rename(defaultfile, backup) + except posix.error: + pass + fp = open(defaultfile, 'w') + writedict(__main__.__dict__, fp) + fp.close() + +def load(): + import __main__ + fp = open(defaultfile, 'r') + readdict(__main__.__dict__, fp) + +def writedict(dict, fp): + import sys + savestdout = sys.stdout + try: + sys.stdout = fp + dump(dict) # Writes to sys.stdout + finally: + sys.stdout = savestdout + +def readdict(dict, fp): + contents = fp.read() # Or: util.readopenfile(fp) + globals = {} + exec(contents, globals) + top = globals['top'] + for key in top.keys(): + if dict.has_key(key): + print 'warning:', key, 'not overwritten' + else: + dict[key] = top[key] + + +# Function dump(x) prints (on sys.stdout!) a sequence of Python statements +# that, when executed in an empty environment, will reconstruct the +# contents of an arbitrary dictionary. + +import sys + +# Name used for objects dict on output. +# +FUNNYNAME = FN = 'A' + +# Top-level function. Call with the object you want to dump. +# +def dump(x): + types = {} + stack = [] # Used by test for recursive objects + print FN, '= {}' + topuid = dumpobject(x, types, stack) + print 'top =', FN, '[', `topuid`, ']' + +# Generic function to dump any object. +# +dumpswitch = {} +# +def dumpobject(x, types, stack): + typerepr = `type(x)` + if not types.has_key(typerepr): + types[typerepr] = {} + typedict = types[typerepr] + if dumpswitch.has_key(typerepr): + return dumpswitch[typerepr](x, typedict, types, stack) + else: + return dumpbadvalue(x, typedict, types, stack) + +# Generic function to dump unknown values. +# This assumes that the Python interpreter prints such values as +# . +# The object will be read back as a string: ''. +# In some cases it may be possible to fix the dump manually; +# to ease the editing, these cases are labeled with an XXX comment. +# +def dumpbadvalue(x, typedict, types, stack): + xrepr = `x` + if typedict.has_key(xrepr): + return typedict[xrepr] + uid = genuid() + typedict[xrepr] = uid + print FN, '[', `uid`, '] =', `xrepr`, '# XXX' + return uid + +# Generic function to dump pure, simple values, except strings +# +def dumpvalue(x, typedict, types, stack): + xrepr = `x` + if typedict.has_key(xrepr): + return typedict[xrepr] + uid = genuid() + typedict[xrepr] = uid + print FN, '[', `uid`, '] =', `x` + return uid + +# Functions to dump string objects +# +def dumpstring(x, typedict, types, stack): + # XXX This can break if strings have embedded '\0' bytes + # XXX because of a bug in the dictionary module + if typedict.has_key(x): + return typedict[x] + uid = genuid() + typedict[x] = uid + print FN, '[', `uid`, '] =', `x` + return uid + +# Function to dump type objects +# +typeswitch = {} +class some_class(): + def method(self): pass +some_instance = some_class() +# +def dumptype(x, typedict, types, stack): + xrepr = `x` + if typedict.has_key(xrepr): + return typedict[xrepr] + uid = genuid() + typedict[xrepr] = uid + if typeswitch.has_key(xrepr): + print FN, '[', `uid`, '] =', typeswitch[xrepr] + elif x = type(sys): + print 'import sys' + print FN, '[', `uid`, '] = type(sys)' + elif x = type(sys.stderr): + print 'import sys' + print FN, '[', `uid`, '] = type(sys.stderr)' + elif x = type(dumptype): + print 'def some_function(): pass' + print FN, '[', `uid`, '] = type(some_function)' + elif x = type(some_class): + print 'class some_class(): pass' + print FN, '[', `uid`, '] = type(some_class)' + elif x = type(some_instance): + print 'class another_class(): pass' + print 'some_instance = another_class()' + print FN, '[', `uid`, '] = type(some_instance)' + elif x = type(some_instance.method): + print 'class yet_another_class():' + print ' def method(): pass' + print 'another_instance = yet_another_class()' + print FN, '[', `uid`, '] = type(another_instance.method)' + else: + # Unknown type + print FN, '[', `uid`, '] =', `xrepr`, '# XXX' + return uid + +# Initialize the typeswitch +# +for x in None, 0, 0.0, '', (), [], {}: + typeswitch[`type(x)`] = 'type(' + `x` + ')' +for s in 'type(0)', 'abs', '[].append': + typeswitch[`type(eval(s))`] = 'type(' + s + ')' + +# Dump a tuple object +# +def dumptuple(x, typedict, types, stack): + item_uids = [] + xrepr = '' + for item in x: + item_uid = dumpobject(item, types, stack) + item_uids.append(item_uid) + xrepr = xrepr + ' ' + item_uid + del stack[-1:] + if typedict.has_key(xrepr): + return typedict[xrepr] + uid = genuid() + typedict[xrepr] = uid + print FN, '[', `uid`, '] = (', + for item_uid in item_uids: + print FN, '[', `item_uid`, '],', + print ')' + return uid + +# Dump a list object +# +def dumplist(x, typedict, types, stack): + # Check for recursion + for x1, uid1 in stack: + if x is x1: return uid1 + # Check for occurrence elsewhere in the typedict + for uid1 in typedict.keys(): + if x is typedict[uid1]: return uid1 + # This uses typedict differently! + uid = genuid() + typedict[uid] = x + print FN, '[', `uid`, '] = []' + stack.append(x, uid) + item_uids = [] + for item in x: + item_uid = dumpobject(item, types, stack) + item_uids.append(item_uid) + del stack[-1:] + for item_uid in item_uids: + print FN, '[', `uid`, '].append(', FN, '[', `item_uid`, '])' + return uid + +# Dump a dictionary object +# +def dumpdict(x, typedict, types, stack): + # Check for recursion + for x1, uid1 in stack: + if x is x1: return uid1 + # Check for occurrence elsewhere in the typedict + for uid1 in typedict.keys(): + if x is typedict[uid1]: return uid1 + # This uses typedict differently! + uid = genuid() + typedict[uid] = x + print FN, '[', `uid`, '] = {}' + stack.append(x, uid) + item_uids = [] + for key in x.keys(): + val_uid = dumpobject(x[key], types, stack) + item_uids.append(key, val_uid) + del stack[-1:] + for key, val_uid in item_uids: + print FN, '[', `uid`, '][', `key`, '] =', + print FN, '[', `val_uid`, ']' + return uid + +# Dump a module object +# +def dumpmodule(x, typedict, types, stack): + xrepr = `x` + if typedict.has_key(xrepr): + return typedict[xrepr] + from string import split + # `x` has the form + name = xrepr[9:-2] + uid = genuid() + typedict[xrepr] = uid + print 'import', name + print FN, '[', `uid`, '] =', name + return uid + + +# Initialize dumpswitch, a table of functions to dump various objects, +# indexed by `type(x)`. +# +for x in None, 0, 0.0: + dumpswitch[`type(x)`] = dumpvalue +for x, f in ('', dumpstring), (type(0), dumptype), ((), dumptuple), \ + ([], dumplist), ({}, dumpdict), (sys, dumpmodule): + dumpswitch[`type(x)`] = f + + +# Generate the next unique id; a string consisting of digits. +# The seed is stored as seed[0]. +# +seed = [0] +# +def genuid(): + x = seed[0] + seed[0] = seed[0] + 1 + return `x` diff --git a/Lib/sched.py b/Lib/sched.py new file mode 100644 index 0000000..b70a998 --- /dev/null +++ b/Lib/sched.py @@ -0,0 +1,96 @@ +# Module sched -- a generally useful event scheduler class + +# Each instance of this class manages its own queue. +# No multi-threading is implied; you are supposed to hack that +# yourself, or use a single instance per application. +# +# Each instance is parametrized with two functions, one that is +# supposed to return the current time, one that is supposed to +# implement a delay. You can implement fine- or course-grained +# real-time scheduling by substituting time and sleep or millitimer +# and millisleep from the built-in module time, or you can implement +# simulated time by writing your own functions. This can also be +# used to integrate scheduling with STDWIN events; the delay function +# is allowed to modify the queue. Time can be expressed +# as integers or floating point numbers, as long as it is consistent. + +# Events are specified by tuples (time, priority, action, argument). +# As in UNIX, lower priority numbers mean higher priority; in this +# way the queue can be maintained fully sorted. Execution of the +# event means calling the action function, passing it the argument. +# Remember that in Python, multiple function arguments can be packed +# in a tuple. The action function may be an instance method so it +# has another way to reference private data (besides global variables). +# Parameterless functions or methods cannot be used, however. + +class scheduler(): + # + # Initialize a new instance, passing the time and delay functions + # + def init(self, (timefunc, delayfunc)): + self.queue = [] + self.timefunc = timefunc + self.delayfunc = delayfunc + return self + # + # Enter a new event in the queue at an absolute time. + # Returns an ID for the event which can be used + # to remove it, if necessary. + # + def enterabs(self, event): + time, priority, action, argument = event + q = self.queue + # XXX Could use bisection or linear interpolation? + for i in range(len(q)): + qtime, qpri, qact, qarg = q[i] + if time < qtime: break + if time = qtime and priority < qpri: break + else: + i = len(q) + q.insert(i, event) + return event # The ID + # + # A variant that specifies the time as a relative time. + # This is actually the more commonly used interface. + # + def enter(self, (delay, priority, action, argument)): + time = self.timefunc() + delay + return self.enterabs(time, priority, action, argument) + # + # Remove an event from the queue. + # This must be presented the ID as returned by enter(). + # If the event is not in the queue, this raises RuntimeError. + # + def cancel(self, event): + self.queue.remove(event) + # + # Check whether the queue is empty. + # + def empty(self): + return len(self.queue) = 0 + # + # Run: execute events until the queue is empty. + # + # When there is a positive delay until the first event, the + # delay function is called and the event is left in the queue; + # otherwise, the event is removed from the queue and executed + # (its action function is called, passing it the argument). + # If the delay function returns prematurely, it is simply + # restarted. + # + # It is legal for both the delay function and the action + # function to to modify the queue or to raise an exception; + # exceptions are not caught but the scheduler's state + # remains well-defined so run() may be called again. + # + def run(self): + q = self.queue + while q: + time, priority, action, argument = q[0] + now = self.timefunc() + if now < time: + self.delayfunc(time - now) + else: + del q[0] + void = action(argument) + # diff --git a/Lib/stdwin/DirList.py b/Lib/stdwin/DirList.py new file mode 100755 index 0000000..fb0ae99 --- /dev/null +++ b/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))) + # diff --git a/Lib/stdwin/FormSplit.py b/Lib/stdwin/FormSplit.py new file mode 100755 index 0000000..4f0bd01 --- /dev/null +++ b/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 + # diff --git a/Lib/stdwin/TextEdit.py b/Lib/stdwin/TextEdit.py new file mode 100755 index 0000000..8d12465 --- /dev/null +++ b/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) + # diff --git a/Lib/stdwin/WindowSched.py b/Lib/stdwin/WindowSched.py new file mode 100755 index 0000000..19be2b1 --- /dev/null +++ b/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() -- cgit v0.12