Gammon Forum

from time import clock
import threading

def sleep(num, func, test, args):
    fire = clock() + num
    while clock() < fire:
        if not test():
            return
    func(*args)

def balance(num, func, test, args = [], tar = sleep):
    t = threading.Thread(target = tar, kwargs = locals())
    t.start()

<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE muclient>
<!-- Saved on Thursday, July 21, 2005, 9:57 PM -->
<!-- MuClient version 3.66 -->


<muclient>
<plugin
   name="Bazzinator"
   author="mudguy"
   id="bd3b5b5ec7994dc41dfbd2ca"
   language="Python"
   purpose="To bazzinate the foobar"
   save_state="y"
   date_written="2005-07-21 21:57:00"
   requires="3.66"
   >

</plugin>


<!--  Get our standard constants -->

<include name="constants.pys"/>


<!--  Script  -->


<script>
<![CDATA[
import timer

def foo():
    timer.balance(10, baz, bar)

def bar():
    return True

def baz():
    world.Note('Done!')
]]>
</script>


</muclient>

import thread, pythoncom
from time import sleep
from win32com.client import Dispatch

class Ticker(object):
    def __init__(self, func, world):
        self.keep_alive = False
        self.interval = 0.1
        self.lock = thread.allocate_lock()
        if callable(func):
            self.func = func
        else:
            raise Error, "Argument passed to the Ticker class must be a callable object, got %s instead." % str(type(func))

        if world:
            self.mc = Dispatch(world)
        else:
            self.mc = None
            
        
    def start(self):
        #Marshal the caller object ('World' ref dispatched above) so it can be passed into the timer thread
        stream = pythoncom.CoMarshalInterThreadInterfaceInStream(pythoncom.IID_IDispatch, self.mc._oleobj_)
        #start timer thread using the Run method and passing the marshaled stream object to it

        self.keep_alive = True
        thread.start_new_thread(self.run, (stream,))

    def run(self, stream):
        #COM must be initialized manually in secondary threads
        pythoncom.CoInitialize()
        #extract the World interface from stream and release the latter
        caller = pythoncom.CoGetInterfaceAndReleaseStream(stream, pythoncom.IID_IDispatch)
        world = Dispatch(caller)  #caller is dispatched in this thread's context now

        while self.keep_alive:
            self.lock.acquire()
            self.func(world)
            self.lock.release()
            sleep(self.interval)

        world = None
        pythoncom.CoUninitialize()


    def stop(self):
        self.keep_alive = False

    def setInterval(self, interval):
        self.lock.acquire()
        self.interval = interval
        self.lock.release()