Ran update_copyright.py.

[hooke.git] / hooke / engine.py

diff --git a/hooke/engine.py b/hooke/engine.py
index 5bc2f6efb5728d8f83c047374714e96327b95273..93be79f686b0253542a71cd7eb225ace10971444 100644 (file)
--- a/hooke/engine.py
+++ b/hooke/engine.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2010 W. Trevor King <wking@drexel.edu>
+# Copyright (C) 2010-2012 W. Trevor King <wking@drexel.edu>
 #
 # This file is part of Hooke.
 #
@@ -21,6 +21,7 @@
 """
 
 import logging
+from Queue import Queue, Empty
 
 from .command import NullQueue
 
@@ -35,16 +36,55 @@ class CloseEngine (QueueMessage):
 
 
 class CommandMessage (QueueMessage):
-    """A message storing a command to run, `command` should be a
-    :class:`hooke.command.Command` instance, and `arguments` should be
-    a :class:`dict` with `argname` keys and `value` values to be
-    passed to the command.
+    """A message storing a command to run, `command` should be the
+    name of a :class:`hooke.command.Command` instance, and `arguments`
+    should be a :class:`dict` with `argname` keys and `value` values
+    to be passed to the command.
     """
     def __init__(self, command, arguments=None):
         self.command = command
         if arguments == None:
             arguments = {}
         self.arguments = arguments
+        self.explicit_user_call = True
+        """Message is explicitly user-executed.  This is useful for
+        distinguishing auto-generated calls (for which
+        `explicit_user_call` should be `False` such as the GUIs
+        current status requests.
+        """
+
+    def __str__(self):
+        return str(self.__unicode__())
+
+    def __unicode__(self):
+        """Return a unicode representation of the `CommandMessage`.
+
+        Examples
+        --------
+        >>> from .compat.odict import odict
+        >>> cm = CommandMessage('command A')
+        >>> print unicode(cm)
+        <CommandMessage command A>
+        >>> cm.arguments = odict([('param a','value a'), ('param b', 'value b')])
+        >>> print unicode(cm)
+        <CommandMessage command A {param a: value a, param b: value b}>
+
+        The parameters are sorted by name, so you won't be surprised
+        in any doctests, etc.
+
+        >>> cm.arguments = odict([('param b','value b'), ('param a', 'value a')])
+        >>> print unicode(cm)
+        <CommandMessage command A {param a: value a, param b: value b}>
+        """
+        if len(self.arguments) > 0:
+            return u'<%s %s {%s}>' % (
+                self.__class__.__name__, self.command,
+                ', '.join(['%s: %s' % (key, value)
+                           for key,value in sorted(self.arguments.items())]))
+        return u'<%s %s>' % (self.__class__.__name__, self.command)
+
+    def __repr__(self):
+        return self.__str__()
 
 
 class CommandEngine (object):
@@ -63,6 +103,10 @@ class CommandEngine (object):
         be ready to receive the next :class:`QueueMessage`.
         """
         log = logging.getLogger('hooke')
+        log.debug('engine starting')
+        for playlist in hooke.playlists:  # Curve._hooke is not pickled.
+            for curve in playlist:
+                curve.set_hooke(hooke)
         while True:
             log.debug('engine waiting for command')
             msg = ui_to_command_queue.get()
@@ -72,13 +116,14 @@ class CommandEngine (object):
                     'engine closing, placed hooke instance in return queue')
                 break
             assert isinstance(msg, CommandMessage), type(msg)
-            log.debug('engine running %s with %s'
-                      % (msg.command.name, msg.arguments))
-            msg.command.run(hooke, ui_to_command_queue, command_to_ui_queue,
-                            **msg.arguments)
+            log.debug('engine running %s' % msg)
+            cmd = hooke.command_by_name[msg.command]
+            cmd.run(hooke, ui_to_command_queue, command_to_ui_queue,
+                    **msg.arguments)
 
     def run_command(self, hooke, command, arguments):
-        """Internal command execution.
+        """Run the command named `command` with `arguments` using
+        :meth:`~hooke.engine.CommandEngine.run_command`.
 
         This allows commands to execute sub commands and enables
         :class:`~hooke.command_stack.CommandStack` execution.
@@ -87,6 +132,15 @@ class CommandEngine (object):
         communication queues, so make sure they will not need user
         interaction.
         """
-        log.debug('engine running internal %s with %s'
-                  % (command.name, arguments))
-        command.run(hooke, NullQueue(), NullQueue(), arguments)
+        log = logging.getLogger('hooke')
+        log.debug('engine running internal %s'
+                  % CommandMessage(command, arguments))
+        outqueue = Queue()
+        cmd = hooke.command_by_name[command]
+        cmd.run(hooke, NullQueue(), outqueue, **arguments)
+        while True:
+            try:
+                msg = outqueue.get(block=False)
+            except Empty:
+                break
+            log.debug('engine message from %s (%s): %s' % (command, type(msg), msg))