root/projects/WinDictator/trunk/windictator/linux/protocol.py

# WinDictator:
# Dictate in Windows, have the text typed in Linux via X faked keystroke events
#
# Copyright (C) 2005-2006 by Edwin A. Suominen, http://www.eepatents.com
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
# 
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the file COPYING for more details.
# 
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

"""
Process Protocol
"""

from twisted.internet import defer, protocol


class ProcessProtocol(protocol.ProcessProtocol):
    """
    Protocol for the I{typist} and I{xnee} processes.
    """
    def __init__(self, dStart, dStop, lineReceiver):
        """
        Instantiates a new process protocol object with:

            dStart
                A C{Deferred} to fire when a connection has been made to the
                process via STDIN and STDOUT.

            dStop
                A C{Deferred} to fire when the process has ended.

            lineReceiver
                A callback function for supplying the outside world with lines
                received from the process via STDOUT.
            
        """
        self.dStart = dStart
        self.dStop = dStop
        self.lineReceiver = lineReceiver
    
    def connectionMade(self):
        """
        Called when the connection has been made to the process, with
        I{self.transport} set to the process transport used for the connection.

        Fires my C{Deferred} with the transport object, thus supplying the
        L{Keyer) instance with a reference to it and its C{loseConnection}
        method.
        """
        self.received = []
        self.dStart.callback(self.transport)

    def outReceived(self, data):
        """
        Handles a chunk of data from the process via STDOUT, running the
        I{self.lineReceiver} callback with any lines in the total accumulated
        data.
        """
        lines = data.strip().split('\n')
        self.received.append(lines.pop(0))
        while self.received:
            result = ''.join(self.received)
            self.lineReceiver(result)
            if lines:
                self.received = [lines.pop(0)]
            else:
                self.received = []

    def processEnded(self, reason):
        """
        Called when the process has shut down for some reason.
        """
        if not self.dStop.called:
            self.dStop.callback(reason)