home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / TkReactor.py < prev    next >
Text File  |  1999-06-28  |  8KB  |  287 lines
  1. #!/usr/bin/env python
  2. #############################################################################
  3. # Copyright (C) DSTC Pty Ltd (ACN 052 372 577) 1997, 1998, 1999
  4. # All Rights Reserved.
  5. #
  6. # The software contained on this media is the property of the DSTC Pty
  7. # Ltd.  Use of this software is strictly in accordance with the
  8. # license agreement in the accompanying LICENSE.HTML file.  If your
  9. # distribution of this software does not contain a LICENSE.HTML file
  10. # then you have no rights to use this software in any manner and
  11. # should contact DSTC at the address below to determine an appropriate
  12. # licensing arrangement.
  13. # 
  14. #      DSTC Pty Ltd
  15. #      Level 7, GP South
  16. #      Staff House Road
  17. #      University of Queensland
  18. #      St Lucia, 4072
  19. #      Australia
  20. #      Tel: +61 7 3365 4310
  21. #      Fax: +61 7 3365 4311
  22. #      Email: enquiries@dstc.edu.au
  23. # 
  24. # This software is being provided "AS IS" without warranty of any
  25. # kind.  In no event shall DSTC Pty Ltd be liable for damage of any
  26. # kind arising out of or in connection with the use or performance of
  27. # this software.
  28. #
  29. # Project:      Fnorb
  30. # File:         $Source: /units/arch/src/Fnorb/orb/RCS/TkReactor.py,v $
  31. # Version:      @(#)$RCSfile: TkReactor.py,v $ $Revision: 1.15 $
  32. #
  33. #############################################################################
  34. """ A Reactor for use with 'tkinter'. 
  35.  
  36. 'tkinter' (and 'Tk' itself) are NOT thread-safe, and therefore this module
  37. assumes a single-threaded environment.
  38.  
  39. """
  40.  
  41.  
  42. # The Python module for Tk 4.1 and upwards is "_tkinter", for Tk 4.0 it is
  43. # "tkinter" 8^(
  44. try:
  45.     import _tkinter
  46.  
  47. except ImportError:
  48.     import tkinter; _tkinter = tkinter
  49.     
  50. # Fnorb modules.
  51. import Reactor
  52.  
  53.  
  54. def TkReactor_init():
  55.     """ Initialise the TkReactor.
  56.  
  57.     There can only be one instance of any concrete reactor class per process.
  58.  
  59.     """
  60.     try:
  61.     reactor = TkReactor()
  62.  
  63.     except Reactor.Reactor, reactor:
  64.     pass
  65.  
  66.     return reactor
  67.  
  68.  
  69. class TkReactor(Reactor.Reactor):
  70.     """ The TkReactor.
  71.  
  72.     The TkReactor uses the Tk event loop to dispatch Fnorb events.
  73.  
  74.     """
  75.  
  76.     def __init__(self):
  77.     """ Constructor. """
  78.  
  79.     # There can be at most one instance of any concrete reactor class per
  80.     # process.
  81.     if Reactor.Reactor._instance is not None:
  82.         # A reactor already exists.
  83.         raise Reactor.Reactor._instance
  84.  
  85.     Reactor.Reactor._instance = self
  86.  
  87.     # A dictionary of all registered event handlers. All handles in the
  88.     # TkReactor are actually just file descriptors.
  89.     self.__handlers = {} # {Handle: (EventHandler, Mask)}
  90.  
  91.     return
  92.  
  93.     #########################################################################
  94.     # Reactor interface.
  95.     #########################################################################
  96.  
  97.     def register_handler(self, handler, mask):
  98.     """ Register an event handler. """
  99.  
  100.     # Get the event handler's underlying I/O handle.
  101.     handle = handler.handle()
  102.  
  103.     # If the handler is already registered then update the mask.
  104.     try:
  105.         # Find the event handler associated with the handle.
  106.         (handler, handler_mask) = self.__handlers[handle]
  107.  
  108.         # Update the mask.
  109.         handler_mask = handler_mask | mask
  110.  
  111.     # Otherwise, add the new handler.
  112.     except KeyError:
  113.         handler_mask = mask
  114.  
  115.     # Do the add/update.
  116.     self.__handlers[handle] = (handler, handler_mask)
  117.  
  118.     # Register with Tk.
  119.     self.__register_Tk_handler(handle, handler_mask)
  120.  
  121.     return
  122.  
  123.     def unregister_handler(self, handler, mask):
  124.     """ Withdraw a handler's registration. """
  125.  
  126.     # Get the event handler's underlying I/O handle.
  127.     handle = handler.handle()
  128.  
  129.     try:
  130.         # Find the event handler associated with the handle.
  131.         (handler, handler_mask) = self.__handlers[handle]
  132.  
  133.         # Update the mask.
  134.         handler_mask = handler_mask & ~mask
  135.  
  136.         # If the mask is now zero (ie. the handler is no longer interested
  137.         # in *any* events) then delete the handler.
  138.         if handler_mask == 0:
  139.         # Remove the handler from Tk.
  140.         _tkinter.deletefilehandler(handle)
  141.  
  142.         # Delete it!
  143.         del self.__handlers[handle]
  144.  
  145.         # Otherwise, update the handler's mask and re-register with Tk.
  146.         else:
  147.         # Update the handler's mask.
  148.         self.__handlers[handle] = (handler, handler_mask)
  149.  
  150.         # Re-register with Tk.
  151.         self.__register_Tk_handler(handle, handler_mask)
  152.  
  153.     # Ignore any attempts to un-register something that wasn't registerd!
  154.     except KeyError:
  155.         pass
  156.  
  157.     return
  158.  
  159.     def start_event_loop(self, timeout=None):
  160.     """ Start the event loop. """
  161.  
  162.     # Enter the Tk mainloop (ie. Tk will dispatch the events).
  163.     _tkinter.mainloop()
  164.  
  165.     # Close all registered handlers.
  166.     self.__close_all_handlers()
  167.  
  168.     return
  169.  
  170.     def stop_event_loop(self):
  171.     """ Stop the event loop. """
  172.  
  173.     # Quit the Tk mainloop.
  174.     _tkinter.quit()
  175.  
  176.     return
  177.  
  178.     def do_one_event(self):
  179.     """ Dispatch a single event. """
  180.  
  181.     _tkinter.dooneevent()
  182.  
  183.     return
  184.  
  185.     # The following two methods are provided to allow Fnorb events to be
  186.     # handled in other event loops.
  187.     def handles(self):
  188.     """ Return the read/write/exception handles for registered handlers.
  189.  
  190.     The return value is a tuple in the form:-
  191.  
  192.     ([ReadHandles], [WriteHandles], [ExceptionHandles])
  193.  
  194.     """
  195.     return self.__get_handles()
  196.  
  197.     def handle_one_event(self, handle, tk_mask):
  198.     """ Handle a single Tk event. """
  199.  
  200.     self.__handle_Tk_event(handle, tk_mask)
  201.  
  202.     return
  203.  
  204.     #########################################################################
  205.     # Private interface.
  206.     #########################################################################
  207.  
  208.     def __get_handles(self):
  209.     """ Return the read/write/exception handles for registered handlers.
  210.  
  211.     The return value is a tuple in the form:-
  212.  
  213.     ([ReadHandles], [WriteHandles], [ExceptionHandles])
  214.  
  215.     """
  216.     iwtd = {}
  217.     owtd = {}
  218.     ewtd = {}
  219.  
  220.     for handle in self.__handlers.keys():
  221.         # Find the event handler associated with the handle.
  222.         (handler, mask) = self.__handlers[handle]
  223.  
  224.         if mask & Reactor.READ:
  225.         iwtd[handle] = None
  226.  
  227.         if mask & Reactor.WRITE:
  228.         owtd[handle] = None
  229.  
  230.         # Listen for errors on all handles.
  231.         ewtd[handle] = None
  232.  
  233.     return (iwtd.keys(), owtd.keys(), ewtd.keys())
  234.  
  235.     def __handle_Tk_event(self, handle, tk_mask):
  236.     """ Handle an event. """
  237.  
  238.     # Translate between Tk and Fnorb event masks.
  239.     mask = 0x0
  240.     if tk_mask & _tkinter.READABLE:
  241.         mask = mask | Reactor.READ
  242.  
  243.     if tk_mask & _tkinter.WRITABLE:
  244.         mask = mask | Reactor.WRITE
  245.  
  246.     if tk_mask & _tkinter.EXCEPTION:
  247.         mask = mask | Reactor.EXCEPTION
  248.  
  249.     # Find the event handler associated with the handle.
  250.     (handler, handler_mask) = self.__handlers[handle]
  251.  
  252.     # Handler callback.
  253.     handler.handle_event(mask)
  254.     
  255.     return
  256.  
  257.     def __register_Tk_handler(self, handle, mask):
  258.     """ Register a file handler with Tk. """
  259.  
  260.     # Translate between Fnorb and Tk event masks (we are always interested
  261.     # in exceptions!).
  262.     tk_mask = _tkinter.EXCEPTION
  263.  
  264.     if mask & Reactor.READ:
  265.         tk_mask = tk_mask | _tkinter.READABLE
  266.  
  267.     if mask & Reactor.WRITE:
  268.         tk_mask = tk_mask | _tkinter.WRITABLE
  269.  
  270.     # Register with Tk.
  271.     _tkinter.createfilehandler(handle, tk_mask, self.__handle_Tk_event)
  272.     
  273.     return
  274.  
  275.     def __close_all_handlers(self):
  276.     """ Close all registered handlers. """
  277.  
  278.     # We work on a copy of the list, 'cos the handlers will most likely
  279.     # call 'unregister_handler' in their 'close' method.
  280.     for (handler, mask) in self.__handlers.values():
  281.         # Handler callback.
  282.         handler.handle_close()
  283.  
  284.     return
  285.  
  286. #############################################################################
  287.