commit 3877047d39e5e0f6bbdf1ea0ef6d59604ed2c509
Author: Simon Schulz <sschulz@cit-ec.uni-bielefeld.de>
Date:   Mon Dec 7 12:42:50 2015 +0100

    fixed intent to make flier happy. thats your christmas present ;)

diff --git a/client/python/hlrc_client/RobotController.py b/client/python/hlrc_client/RobotController.py
index b419ce9..55c709b 100644
--- a/client/python/hlrc_client/RobotController.py
+++ b/client/python/hlrc_client/RobotController.py
@@ -30,116 +30,116 @@ import sys
 import errno
 
 class RobotController:
-	def __init__(self, mw_name, scope, loglevel=logging.WARNING):
-		"""initialise
-		:param mw_name: which mw to use, currentyl ROS and RSB are supported
-		:param scope: base scope we want to listen on 
-		:param  loglevel: optional log level
-		"""
-		self.logger = logging.getLogger(__name__)
-		
-		# create nice and actually usable formatter and add it to the handler
-		self.config_logger(loglevel)
-		
-		#store 
-		self.scope = scope
-		self.mw = mw_name
-		self.loglevel = loglevel
-		
-		self.middleware = None
-		
-				
-		if (self.mw.upper() == "RSB"):
-			self.logger.info("creating new middleware connection via RSB")
-			try:
-				from MiddlewareRSB import MiddlewareRSB
-			except ImportError, e:
-				self.logger.error("failed to import RSB or the necessary data types: {}".format(e))
-				sys.exit(errno.EINVAL)
+    def __init__(self, mw_name, scope, loglevel=logging.WARNING):
+	"""initialise
+	:param mw_name: which mw to use, currentyl ROS and RSB are supported
+	:param scope: base scope we want to listen on
+	:param  loglevel: optional log level
+	"""
+	self.logger = logging.getLogger(__name__)
+
+	# create nice and actually usable formatter and add it to the handler
+	self.config_logger(loglevel)
+
+	#store
+	self.scope = scope
+	self.mw = mw_name
+	self.loglevel = loglevel
+
+	self.middleware = None
 
-			#import worked, safe to intantiate RSB mw now
-			self.middleware = MiddlewareRSB(self.scope, self.loglevel)
 
-		elif (self.mw.upper() == "ROS"):
+	if (self.mw.upper() == "RSB"):
+	    self.logger.info("creating new middleware connection via RSB")
+	    try:
+		from MiddlewareRSB import MiddlewareRSB
+		except ImportError, e:
+		    self.logger.error("failed to import RSB or the necessary data types: {}".format(e))
+		    sys.exit(errno.EINVAL)
+
+		    #import worked, safe to intantiate RSB mw now
+		    self.middleware = MiddlewareRSB(self.scope, self.loglevel)
+
+		    elif (self.mw.upper() == "ROS"):
 			self.logger.info("creating new middleware connection via ROS")
 			try:
-				from MiddlewareROS import MiddlewareROS
-			except ImportError, e:
-                                self.logger.error("failed to import ROS or the necessary data types: {}".format(e))
-                                sys.exit(errno.EINVAL)
-
-			#import worked, safe to intantiate RSB mw now
-			self.middleware = MiddlewareROS(self.scope, self.loglevel)
-		else:
-			self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))
-			sys.exit(errno.EINVAL)
-	
-	def __del__(self):
-		"""destructor
-		"""
-		self.logger.debug("destructor of RobotController called")
-	
-	def config_logger(self, level):
-		"""initialise a nice logger formatting
-		:param  level: log 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)
-
-	def set_current_emotion(self, robot_emotion, blocking = False):
-		"""set the current emotion
-		:param robot_emotion: a RobotEmotion object
-		:param blocking: should this call block during execution?
-		"""
-		self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_current_emotion(robot_emotion, blocking)
-		
-	def set_default_emotion(self, robot_emotion, blocking = False):
-		"""set the default emotion
-		:param robot_emotion: a RobotEmotion object
-		:param blocking: should this call block during execution?
-		"""
-		self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_default_emotion(robot_emotion, blocking)
-	
-	def set_gaze_target(self, robot_gaze, blocking = False):
-		"""set a gaze target
-		:param robot_gaze: a RobotGaze object
-		:param blocking: should this call block during execution?
-		"""
-		
-		self.logger.debug("set_gaze_target(%s) %s" % (robot_gaze, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_gaze_target(robot_gaze, blocking)
-	
-	def set_mouth_target(self, robot_mouth, blocking = False):
-		"""set a mouth target
-		:param robot_mouth: a RobotMouth object
-		:param blocking: should this call block during execution?
-		"""		
-		self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_mouth_target(robot_mouth, blocking)
-	
-	def set_head_animation(self, robot_animation, blocking = False):
-		"""set a head animation
-		:param robot_animation: a RobotAnimation object
-		:param blocking: should this call block during execution?
-		"""		
-		self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_head_animation(robot_animation, blocking)
-	
-	def set_speak(self, text, blocking = False):
-		"""request the robot to say something using tts
-		:param text: text to synthesize
-		:param blocking: should this call block during execution?
-		"""
-		self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))
-		self.middleware.set_speak(text, blocking)
-
-	#def get_gaze_target(self):
-	#	result = self.middleware.get_gaze_target()
-	#	self.logger.debug("get_gaze_target() returned %s" % (result))
-	#	return self.middleware.get_gaze_target()
+			    from MiddlewareROS import MiddlewareROS
+			    except ImportError, e:
+				self.logger.error("failed to import ROS or the necessary data types: {}".format(e))
+				sys.exit(errno.EINVAL)
+
+				#import worked, safe to intantiate RSB mw now
+				self.middleware = MiddlewareROS(self.scope, self.loglevel)
+				else:
+				    self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))
+				    sys.exit(errno.EINVAL)
+
+				    def __del__(self):
+					"""destructor
+					"""
+					self.logger.debug("destructor of RobotController called")
+
+					def config_logger(self, level):
+					    """initialise a nice logger formatting
+					    :param  level: log 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)
+
+					    def set_current_emotion(self, robot_emotion, blocking = False):
+						"""set the current emotion
+						:param robot_emotion: a RobotEmotion object
+						:param blocking: should this call block during execution?
+						"""
+						self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
+						self.middleware.set_current_emotion(robot_emotion, blocking)
+
+						def set_default_emotion(self, robot_emotion, blocking = False):
+						    """set the default emotion
+						    :param robot_emotion: a RobotEmotion object
+						    :param blocking: should this call block during execution?
+						    """
+						    self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
+						    self.middleware.set_default_emotion(robot_emotion, blocking)
+
+						    def set_gaze_target(self, robot_gaze, blocking = False):
+							"""set a gaze target
+							:param robot_gaze: a RobotGaze object
+							:param blocking: should this call block during execution?
+							"""
+
+							self.logger.debug("set_gaze_target(%s) %s" % (robot_gaze, ("BLOCKING" if blocking else "NON_BLOCKING")))
+							self.middleware.set_gaze_target(robot_gaze, blocking)
+
+							def set_mouth_target(self, robot_mouth, blocking = False):
+							    """set a mouth target
+							    :param robot_mouth: a RobotMouth object
+							    :param blocking: should this call block during execution?
+							    """
+							    self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))
+							    self.middleware.set_mouth_target(robot_mouth, blocking)
+
+							    def set_head_animation(self, robot_animation, blocking = False):
+								"""set a head animation
+								:param robot_animation: a RobotAnimation object
+								:param blocking: should this call block during execution?
+								"""
+								self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))
+								self.middleware.set_head_animation(robot_animation, blocking)
+
+								def set_speak(self, text, blocking = False):
+								    """request the robot to say something using tts
+								    :param text: text to synthesize
+								    :param blocking: should this call block during execution?
+								    """
+								    self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))
+								    self.middleware.set_speak(text, blocking)
+
+								    #def get_gaze_target(self):
+									#	result = self.middleware.get_gaze_target()
+									#	self.logger.debug("get_gaze_target() returned %s" % (result))
+									#	return self.middleware.get_gaze_target()
