hlrc

"""

This file is part of hlrc

Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

http://opensource.cit-ec.de/projects/hlrc

This file may be licensed under the terms of the

GNU General Public License Version 3 (the ``GPL''),

or (at your option) any later version.

Software distributed under the License is distributed

on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

express or implied. See the GPL for the specific language

governing rights and limitations.

You should have received a copy of the GPL along with this

program. If not, go to http://www.gnu.org/licenses/gpl.html

or write to the Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

The development of this software was supported by the

Excellence Cluster EXC 277 Cognitive Interaction Technology.

The Excellence Cluster EXC 277 is a grant of the Deutsche

Forschungsgemeinschaft (DFG) in the context of the German

Excellence Initiative.

"""

import sys

import logging

from RobotEmotion import *

from RobotGaze import *

from RobotMouth import *

from RobotAnimation import *

class Middleware:

        #######################################################################

        def __init__(self, scope, loglevel=logging.WARNING):

                """initialise

                :param scope: base scope we want to listen on 

                """

                self.base_scope = scope

                self.logger = logging.getLogger(__name__)

                # create nice and actually usable formatter and add it to the handler

                self.config_logger(loglevel)

                #initialise defaults

                self.default_emotion = RobotEmotion()

                self.current_emotion = RobotEmotion()

                self.gaze_target = RobotGaze()

                self.mouth_target = RobotMouth()

                self.robot_animation = RobotAnimation()

        def __del__(self):

                """destructor

                """

                self.logger.debug("destructor of Middleware called")

        def config_logger(self, level):

                formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')

                ch = logging.StreamHandler()

                #ch.setLevel(level)

                ch.setFormatter(formatter)

                self.logger.setLevel(level)

                self.logger.addHandler(ch)

        #######################################################################

        #abstract/virtual functions

        def die_virtual(self, funcname):

                raise NotImplementedError(funcname + "() is virtual, must be overwritten")

        def init_middleware(self):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_default_emotion(self, emotion, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_current_emotion(self, emotion, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_gaze_target(self, gaze, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_mouth_target(self, mouth, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_head_animation(self, animation, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        def publish_speech(self, text, blocking):

                self.die_virtual(sys._getframe().f_code.co_name)

        #######################################################################

        #finally some implemented functions

        def set_default_emotion(self, emotion, blocking):

                """set the default emotion

                :param emotion: RobotEmotion to set 

                :param blocking: True if this call should block until execution finished on robot

                """

                self.default_emotion = emotion

                self.publish_default_emotion(emotion, blocking)

        def set_current_emotion(self, emotion, blocking):

                """set a temporary emotion (duration: see emotion.time_ms)

                :param emotion: RobotEmotion to set temporarily

                :param blocking: True if this call should block until execution finished on robot

                """

                self.current_emotion = emotion

                self.publish_current_emotion(emotion, blocking)

        def set_head_animation(self, animation, blocking):

                """trigger a head animation

                :param animation: RobotAnimation to set

                :param blocking: True if this call should block until execution finished on robot

                """

                self.animation = animation

                self.publish_head_animation(animation, blocking)

        def set_mouth_target(self, mouth, blocking):

                """set a mouth target

                :param mouth: RobotMouth to set

                :param blocking: True if this call should block until execution finished on robot

                """

                self.mouth_target = mouth

                self.publish_mouth_target(mouth, blocking)

        def set_speak(self, text, blocking):

                """trigger a tts speech output

                :param text: text to synthesize and speak

                :param blocking: True if this call should block until execution finished on robot

                """

                self.publish_speech(text, blocking)

        def set_gaze_target(self, gaze, blocking):

                """set a new gaze 

                :param gaze: RobotGaze to set

                :param blocking: True if this call should block until execution finished on robot

                """

                self.gaze_target = gaze

                self.publish_gaze_target(gaze, blocking)

        #######################################################################

        #some get methods

        #def get_current_emotion(self):

        #        return self.current_emotion

        #

        #def get_default_emotion(self):

        #        return self.default_emotion

        #