[tuxdroid-svn] r1221 - software/tuxgi/trunk

[Paul_R <c2m...@c2...>]

Author: Paul_R
Date: 2008-06-11 09:52:22 +0200 (Wed, 11 Jun 2008)
New Revision: 1221

Modified:
   software/tuxgi/trunk/tuxgi.py
Log:
* Adapted tuxgi to works with the new software suite.
  
  Limitations :
  - All sounds flash functionnalities aren't implemented on the API for the
    moment. 
  - TTS use the default voice and can't be changed ATM.
  - led_blink funnction don't use the counter value
  - No raw commands
  - No ping


Modified: software/tuxgi/trunk/tuxgi.py
===================================================================
--- software/tuxgi/trunk/tuxgi.py	2008-06-09 06:44:33 UTC (rev 1220)
+++ software/tuxgi/trunk/tuxgi.py	2008-06-11 07:52:22 UTC (rev 1221)
@@ -28,8 +28,10 @@
 # uses objects "tux" and "tss"
 # -----------------------------------------------
 import sys
-sys.path.append('/opt/tuxdroid/api/python')
-from tux import *
+import time
+
+from tuxisalive.api import *
+tux=shellTux()
 # -----------------------------------------------
 # Your script
 # -----------------------------------------------
@@ -46,7 +48,7 @@
 print "Graphical TuxDroid Interface " + app_version
 glade_dir = ""
 locale_dir = ""
-soundcard = tux.hw.alsa_device
+soundcard = 'hw:TuxDroid' #tux.hw.alsa_device
 
 bindtextdomain(app_name, locale_dir)
 
@@ -103,20 +105,13 @@
     # On new window
     #--------------------------------------------------------------------------
     def new(self):
-        self.update_voice_list()
-        tux.tts.on_sound_on=self.on_sound_on
-        tux.tts.on_sound_off=self.on_sound_off
-        tux.tts.on_voice_list=self.on_voice_list
-        tux.event.on_status=self.on_status
-        tux.event.on_left_blue_led_on=self.on_left_blue_led_on
-        tux.event.on_left_blue_led_off=self.on_left_blue_led_off
-        tux.event.on_right_blue_led_on=self.on_right_blue_led_on
-        tux.event.on_right_blue_led_off=self.on_right_blue_led_off
-        tux.event.on_mouth_stop=self.on_mouth_stop
-        tux.event.on_eyes_stop=self.on_eyes_stop
+        tux.event.handler.register("tts_0_sound_state", self.on_sound_on)
+        tux.event.handler.register("left_led_state", self.on_left_blue_led_on)
+        tux.event.handler.register("right_led_state", self.on_right_blue_led_on)
+        tux.event.handler.register("mouth_remaining_movements", self.on_mouth_stop, (0, None))
+        tux.event.handler.register("eyes_remaining_movements", self.on_eyes_stop, (0, None))
+        tux.event.handler.register("all", self.on_status)
         thread.start_new_thread(self.status_viewer_thread,())
-        tux.daemon.auto_connect(True)
-        tux.tts.auto_connect(True)
 
     #--------------------------------------------------------------------------
     # On window destroy
@@ -130,46 +125,38 @@
     #--------------------------------------------------------------------------
     # On left blue led status is on
     #--------------------------------------------------------------------------
-    def on_left_blue_led_on(self):
+    def on_left_blue_led_on(self, value, timeout):
         global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("checkbutton1").set_active(True)
-        toggled_by_event=False
+        if value == SSV_ON:
+            toggled_by_event=True
+            self.get_widget("checkbutton1").set_active(True)
+            toggled_by_event=False
+        else:
+            toggled_by_event=True
+            self.get_widget("checkbutton1").set_active(False)
+            toggled_by_event=False
 
     #--------------------------------------------------------------------------
-    # On left blue led status is off
-    #--------------------------------------------------------------------------
-    def on_left_blue_led_off(self):
-        global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("checkbutton1").set_active(False)
-        toggled_by_event=False
-
-    #--------------------------------------------------------------------------
     # On right blue led status is on
     #--------------------------------------------------------------------------
-    def on_right_blue_led_on(self):
+    def on_right_blue_led_on(self, value, timeout):
         global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("checkbutton2").set_active(True)
-        toggled_by_event=False
+        if value == SSV_ON:
+            toggled_by_event=True
+            self.get_widget("checkbutton2").set_active(True)
+            toggled_by_event=False
+        else:
+            toggled_by_event=True
+            self.get_widget("checkbutton2").set_active(False)
+            toggled_by_event=False
 
     #--------------------------------------------------------------------------
-    # On right blue led status is off
-    #--------------------------------------------------------------------------
-    def on_right_blue_led_off(self):
-        global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("checkbutton2").set_active(False)
-        toggled_by_event=False
-
-    #--------------------------------------------------------------------------
     # On mouth stop
     #--------------------------------------------------------------------------
-    def on_mouth_stop(self):
+    def on_mouth_stop(self, value, timeout):
         global toggled_by_event
         toggled_by_event=True
-        if tux.status.get_mouth_open_position()==0:
+        if tux.mouth.getPosition() == SSV_CLOSE:
             self.get_widget("radiobutton3").set_active(True)
         else:
             self.get_widget("radiobutton4").set_active(True)
@@ -181,7 +168,7 @@
     def on_eyes_stop(self):
         global toggled_by_event
         toggled_by_event=True
-        if tux.status.get_eyes_closed_position_switch()==1:
+        if tux.eyes.getPosition() == SSV_OPEN:
             self.get_widget("radiobutton1").set_active(True)
         else:
             self.get_widget("radiobutton2").set_active(True)
@@ -190,16 +177,15 @@
     #--------------------------------------------------------------------------
     # Event on status
     #--------------------------------------------------------------------------
-    def on_status(self,frame):
+    def on_status(self, name, value, delay):
         global status_list_st
         global status_list_changed
-        explicite_status=tux.explicit_status(frame)
-        if explicite_status.find("RF connected->") != 0:
-            status_list_changed=True
-            status_list_st.append(explicite_status)
-            if len(status_list_st)==50:
-                for i in range(1):
-                    status_list_st.pop(0)
+        explicite_status=name + ' = ' + value
+        status_list_changed=True
+        status_list_st.append(explicite_status)
+        if len(status_list_st)==50:
+            for i in range(1):
+                status_list_st.pop(0)
 
     #--------------------------------------------------------------------------
     # Status viewer refreshing thread
@@ -227,48 +213,28 @@
                 else:
                     string=status_list_st[len(status_list_st)-1]+"\n"
                 statusview_b.insert(startiter,string)
-            if tux.daemon.connected!=last_tuxdaemon_connect:
-                last_tuxdaemon_connect=tux.daemon.connected
-                if tux.daemon.connected:
-                    onpause=False
-                    onplay=False
-                    global toggled_by_event
-                    toggled_by_event=True
-                    global soundcard
-                    tux.hw.alsa_devices_select(0)
-                    soundcard = tux.hw.alsa_device
-                    self.get_widget("togglebutton3").set_active(False)
-                    toggled_by_event=False
+            
+            if tux.server.getConnected() != last_tuxdaemon_connect:
+                last_tuxdaemon_connect = tux.server.getConnected()
+                print last_tuxdaemon_connect
+                
+                if tux.server.getConnected():
                     self.get_widget("image2").set_from_stock(gtk.STOCK_APPLY\
                     ,gtk.ICON_SIZE_BUTTON)
-                    self.on_mouth_stop()
-                    self.on_eyes_stop()
-                    tux.cmd.leds_blink(2,1)
                 else:
                     self.get_widget("image2").set_from_stock(gtk.STOCK_CANCEL\
                     ,gtk.ICON_SIZE_BUTTON)
-                    tux.status.rf_connected = False
-            if tux.tts.connected!=last_tuxttsdaemon_connect:
-                last_tuxttsdaemon_connect=tux.tts.connected
-                if tux.tts.connected:
-                    self.get_widget("image3").set_from_stock(gtk.STOCK_APPLY\
-                    ,gtk.ICON_SIZE_BUTTON)
-                else:
-                    self.get_widget("image3").set_from_stock(gtk.STOCK_CANCEL\
-                    ,gtk.ICON_SIZE_BUTTON)
-            if tux.status.rf_state()!=last_rf_state:
-                last_rf_state = tux.status.rf_connected
+                
+            if tux.radio.getConnected()!=last_rf_state:
+                last_rf_state = tux.radio.getConnected()
                 if last_rf_state:
                     self.get_widget("image4").set_from_stock(gtk.STOCK_APPLY\
                     ,gtk.ICON_SIZE_BUTTON)
                 else:
                     self.get_widget("image4").set_from_stock(gtk.STOCK_CANCEL\
                     ,gtk.ICON_SIZE_BUTTON)
-            if voice_list_changed:
-                voice_list_changed = False
-                self.update_voice_list()
 
-            tux.sys.wait(0.5)
+                time.sleep(0.5)
 # -----------------------------------------------------------------------------
 # Tab "main" events
 # -----------------------------------------------------------------------------
@@ -280,9 +246,9 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.ledl_on()
+            tux.led.left.on()
         else:
-            tux.cmd.ledl_off()
+            tux.led.left.off()
 
     #--------------------------------------------------------------------------
     # On right led checkbox toggled
@@ -291,9 +257,9 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.ledr_on()
+            tux.led.right.on()
         else:
-            tux.cmd.ledr_off()
+            tux.led.right.off()
 
     #--------------------------------------------------------------------------
     # On flash leds button clicked
@@ -301,7 +267,8 @@
     def on_flash_bt_clicked(self, widget, *args):
         def _funct():
             num_sb=self.get_widget("spinbutton1")
-            tux.cmd.leds_blink(int(num_sb.get_value()),15)
+            # XXX New command with counter
+            tux.led.both.blinkAsync(SPV_NORMAL, 1.0)
 
         thread.start_new_thread(_funct,())
 
@@ -312,7 +279,7 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.eyes_open()
+            tux.eyes.open()
 
     #--------------------------------------------------------------------------
     # On eyes close radiobutton toggled
@@ -321,14 +288,14 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.eyes_close()
+            tux.eyes.close()
 
     #--------------------------------------------------------------------------
     # On eyes blink button clicked
     #--------------------------------------------------------------------------
     def on_eyes_blink_bt_clicked(self, widget, *args):
         num_sb=self.get_widget("spinbutton2")
-        tux.cmd.eyes_on_free(int(num_sb.get_value()))
+        tux.eyes.onAsync(int(num_sb.get_value()), SSV_NDEF)
 
     #--------------------------------------------------------------------------
     # On beak open radiobutton toggled
@@ -337,7 +304,7 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.mouth_open()
+            tux.mouth.open()
 
     #--------------------------------------------------------------------------
     # On beak close radiobutton toggled
@@ -346,14 +313,14 @@
         global toggled_by_event
         if toggled_by_event: return
         if widget.get_active():
-            tux.cmd.mouth_close()
+            tux.mouth.close()
 
     #--------------------------------------------------------------------------
     # On beak talk button clicked
     #--------------------------------------------------------------------------
     def on_beak_talk_bt_clicked(self, widget, *args):
         num_sb=self.get_widget("spinbutton3")
-        tux.cmd.mouth_on_free(int(num_sb.get_value()))
+        tux.mouth.onAsync(int(num_sb.get_value()), SSV_NDEF)
 
     #--------------------------------------------------------------------------
     # On flippers up radiobutton toggled
@@ -363,8 +330,7 @@
             global toggled_by_event
             if toggled_by_event: return
             if widget.get_active():
-                tux.cmd.raw(0x39,0,0,0)
-                tux.event.wait_status(DATAS_STATUS_WINGS_POSITION_COUNTER,0,5)
+                tux.flippers.up()
 
         thread.start_new_thread(_funct,())
 
@@ -376,8 +342,7 @@
             global toggled_by_event
             if toggled_by_event: return
             if widget.get_active():
-                tux.cmd.raw(0x3A,0,0,0)
-                tux.event.wait_status(DATAS_STATUS_WINGS_POSITION_COUNTER,0,5)
+                tux.flippers.down()
 
         thread.start_new_thread(_funct,())
 
@@ -386,7 +351,7 @@
     #--------------------------------------------------------------------------
     def on_flippers_flap_bt_clicked(self, widget, *args):
         num_sb=self.get_widget("spinbutton4")
-        tux.cmd.wings_on_free(int(num_sb.get_value()))
+        tux.flippers.onAsync(int(num_sb.get_value()), SSV_NDEF)
 
     #--------------------------------------------------------------------------
     # On rotation button clicked
@@ -394,9 +359,9 @@
     def on_rotation_spin_bt_clicked(self, widget, *args):
         num_sb=self.get_widget("spinbutton5")
         if self.get_widget("radiobutton7").get_active():
-            tux.cmd.spinl_on_free(int(num_sb.get_value()))
+            tux.spinning.leftOnAsync(int(num_sb.get_value()), SPV_VERYFAST)
         else:
-            tux.cmd.spinr_on_free(int(num_sb.get_value()))
+            tux.spinning.rightOnAsync(int(num_sb.get_value()), SPV_VERYFAST)
 
 
     #--------------------------------------------------------------------------
@@ -409,19 +374,22 @@
     # On "Tux Droid shell" button clicked
     #--------------------------------------------------------------------------
     def on_tdshell_bt_clicked(self, widget, *args):
-        tux.sys.shell_free(xterm_cmd)
+        print "FIXME :: tuxsh : not implemented"
+        #tux.sys.shell_free(xterm_cmd)
 
     #--------------------------------------------------------------------------
     # On "Get light level" button clicked
     #--------------------------------------------------------------------------
     def on_cversion_bt_clicked(self, widget, *args):
-        thread.start_new_thread(tux.status.get_light_level,())
+        a, b = tux.status.requestOne('light_level')
+        return a
 
     #--------------------------------------------------------------------------
     # On "Ping" button clicked
     #--------------------------------------------------------------------------
     def on_ping_bt_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.ping,(200,))
+        print "FIXME :: Ping : this function isn't implemented yet"
+        #thread.start_new_thread(tux.cmd.ping,(200,))
 
 # -----------------------------------------------------------------------------
 # Tab "TTS" events
@@ -445,24 +413,19 @@
 
         if toggled_by_event: return
         global onplay
-        if onplay:
-            tux.tts.stop()
-        else:
-            voice_cb=self.get_widget("comboboxentry1")
-            pitch_sb=self.get_widget("spinbutton6")
-            voice_id = voice_dic[voice_list[voice_cb.get_active()][0]]
-            current_voice = voice_list[voice_cb.get_active()][0]
-            tux.tts.select_voice(voice_id,pitch_sb.get_value())
-            tux.tts.stop()
-            textedit=self.get_widget("textview2")
-            buffer=textedit.get_buffer()
-            my_text=buffer.get_text(*buffer.get_bounds())
-            tux.tts.speak_free(my_text)
-
+        voice_cb=self.get_widget("comboboxentry1")
+        pitch_sb=self.get_widget("spinbutton6").get_value()
+        textedit=self.get_widget("textview2")
+        buffer=textedit.get_buffer()
+        my_text=buffer.get_text(*buffer.get_bounds())
+        tux.tts.setPitch(int(pitch_sb))
+        tux.tts.speakAsync(my_text)
     #--------------------------------------------------------------------------
     # On "pause" button clicked
     #--------------------------------------------------------------------------
     def on_tts_pause_bt_clicked(self, widget, *args):
+        print "FIXME : TTS pause : not implemented yet"
+        '''
         global onpause
         if onpause:
             tux.tts.play()
@@ -470,7 +433,7 @@
         else:
             tux.tts.pause()
             onpause=True
-
+        '''
     #--------------------------------------------------------------------------
     # On "Clear text" button clicked
     #--------------------------------------------------------------------------
@@ -482,28 +445,23 @@
     #--------------------------------------------------------------------------
     # On TTS sound on event
     #--------------------------------------------------------------------------
-    def on_sound_on(self):
+    def on_sound_on(self, value, timeout):
         global onplay
         global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("togglebutton3").set_active(True)
-        toggled_by_event=False
-        onplay=True
-        tux.cmd.mouth_open()
+        if value == "ON":
+            toggled_by_event=True
+            self.get_widget("togglebutton3").set_active(True)
+            toggled_by_event=False
+            onplay=True
+            tux.mouth.open()
+        else:
+            toggled_by_event=True
+            self.get_widget("togglebutton3").set_active(False)
+            toggled_by_event=False
+            onplay=False
+            tux.mouth.close()
 
     #--------------------------------------------------------------------------
-    # On TTS sound off event
-    #--------------------------------------------------------------------------
-    def on_sound_off(self):
-        global onplay
-        global toggled_by_event
-        toggled_by_event=True
-        self.get_widget("togglebutton3").set_active(False)
-        toggled_by_event=False
-        onplay=False
-        tux.cmd.mouth_close()
-
-    #--------------------------------------------------------------------------
     # On new authorized voices list event
     #--------------------------------------------------------------------------
     def on_voice_list(self):
@@ -515,10 +473,12 @@
     # Update the voices list in the combobox
     #--------------------------------------------------------------------------
     def update_voice_list(self):
+        pass
+        '''
         global voice_list
         global voice_dic
         global current_voice
-
+        
         voice_dic = {}
         voice_list.clear()
         for voice_id in tux.tts.authorized_voices_list:
@@ -532,8 +492,8 @@
                     break
         else:
             self.get_widget("comboboxentry1").set_active(0)
+        '''
 
-
 # -----------------------------------------------------------------------------
 # Tab "Audio" events
 # -----------------------------------------------------------------------------
@@ -551,14 +511,18 @@
     # On "play" external wave file button clicked
     #--------------------------------------------------------------------------
     def on_wave_external_play_bt_clicked(self, widget, *args):
+        print "FIXME :: play external : not implemented yet"
+        '''
         if str(self.get_widget("filechooserbutton1").get_filename())=="None": return
         tux.sys.shell_free("aplay -D %s %s"% (soundcard,
         self.get_widget("filechooserbutton1").get_filename()))
-
+        '''
     #--------------------------------------------------------------------------
     # On select original sounds
     #--------------------------------------------------------------------------
     def on_incl_orig_toggled(self, widget, *args):
+        print "FIXME :: Original waves : not implemented yet"
+        '''
         st_wav_paths = wavs.wav_paths
         if widget.get_active():
             wavs.wav_paths=[]
@@ -576,38 +540,50 @@
                 wavs.wav_paths=[]
                 wavs.wav_sizes=[]
         self.refresh_wav_list()
+        '''
 
     #--------------------------------------------------------------------------
     # On select internal wave file event
     #--------------------------------------------------------------------------
     def on_wave_internal_changed(self, widget, *args):
+        print "FIXME :: Internal waves : not implemented yet"
+        '''
         filename=widget.get_filename()
         ext=len(filename)-filename.find(".wav")
         if ext != 4 :
             widget.unselect_filename(filename)
+        '''
 
     #--------------------------------------------------------------------------
     # On "add" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_add_bt_clicked(self, widget, *args):
+        print "FIXME :: Add sound : not implemented yet"
+        '''
         if str(self.get_widget("filechooserbutton2").get_filename())=="None": return
         wavs.add_wav_path(self.get_widget("filechooserbutton2").get_filename())
         self.refresh_wav_list()
+        '''
 
     #--------------------------------------------------------------------------
     # On "remove" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_remove_bt_clicked(self, widget, *args):
+        print "FIXME :: Remove sound : not implemented yet"
+        '''
         index=int(self.get_widget("spinbutton8").get_value())
         if index>len(wavs.wav_paths):return
         wavs.wav_sizes.pop(index-1)
         wavs.wav_paths.pop(index-1)
         self.refresh_wav_list()
+        '''
 
     #--------------------------------------------------------------------------
     # Refreshing wave list function
     #--------------------------------------------------------------------------
     def refresh_wav_list(self):
+        print "FIXME :: Clear list : not implemented yet"
+        '''
         wav_te=self.get_widget("textview3")
         wav_buffer=wav_te.get_buffer()
         wav_buffer.set_text("")
@@ -616,26 +592,33 @@
             filename=wavfile[wavfile.rfind('/')+1:]
             wav_buffer.insert(wav_buffer.get_end_iter(),"%.2d : %s\n" %(i,filename))
             i=i+1
+        '''
 
     #--------------------------------------------------------------------------
     # On "clear" internal wave file list button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_clist_bt_clicked(self, widget, *args):
+        print "FIXME :: Internal sounds : not implemented yet"
+        '''
         wavs.wav_sizes=[]
         wavs.wav_paths=[]
         self.get_widget("checkbutton4").set_active(False)
         self.refresh_wav_list()
+        '''
 
     #--------------------------------------------------------------------------
     # On "store" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_store_bt_clicked(self, widget, *args):
-        thread.start_new_thread(self.sound_storing,())
+        print "FIXME :: Store waves : not implemented yet"
+        #thread.start_new_thread(self.sound_storing,())
 
     #--------------------------------------------------------------------------
     # Store sound function
     #--------------------------------------------------------------------------
     def sound_storing(self):
+        print "FIXME :: Sound storing : not implemeted yet"
+        '''
         if tux.status.rf_state() == 0: return
         if len(wavs.wav_sizes)==0: return
         wav_te=self.get_widget("textview3")
@@ -663,90 +646,109 @@
         wav_buffer.insert(wav_buffer.get_end_iter(),
         "Sound storing : Storage done.\n")
         tux.sys.wait(0.3)
-
+        '''
     #--------------------------------------------------------------------------
     # On "play" flash sound button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play_bt_clicked(self, widget, *args):
+        print "FIXME :: Play internal wave %d : Not implemented yet" \
+                %(self.get_widget("spinbutton7").get_value())
+        '''
         def _funct():
             index=self.get_widget("spinbutton7").get_value()
             tux.cmd.sound_play(int(index),0)
 
         thread.start_new_thread(_funct,())
-
+        '''
     #--------------------------------------------------------------------------
     # On "play flash sound number 1" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play1_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(1,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(1,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 2" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play2_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(2,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(2,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 3" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play3_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(3,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(3,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 4" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internat_play4_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(4,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(4,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 5" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play5_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(5,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(5,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 6" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play6_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(6,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(6,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 7" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play7_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(7,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(7,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 8" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play8_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(8,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(8,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 9" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play9_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(9,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(9,0,))
 
     #--------------------------------------------------------------------------
     # On "play flash sound number 10" button clicked
     #--------------------------------------------------------------------------
     def on_wave_internal_play10_clicked(self, widget, *args):
-        thread.start_new_thread(tux.cmd.sound_play,(10,0,))
+        pass
+        #thread.start_new_thread(tux.cmd.sound_play,(10,0,))
 
     #--------------------------------------------------------------------------
     # On "Play recorded wave file" button clicked
     #--------------------------------------------------------------------------
     def on_mic_play_bt_clicked(self, widget, *args):
-        tux.sys.shell_free("aplay -D %s rec.wav"%soundcard)
+        print "FIXME :: Play recorded sound : not implemented yet"
+        #tux.sys.shell_free("aplay -D %s rec.wav"%soundcard)
 
     #--------------------------------------------------------------------------
     # On "Record wave file" button clicked
     #--------------------------------------------------------------------------
     def on_mic_record_bt_clicked(self, widget, *args):
-        tux.cmd.mouth_open()
+        print "FIXME :: Record : Not implemented yet"
+        '''
+        tux.mouth.open()
+        #tux.cmd.mouth_open()
         tux.sys.shell("arecord -D %s -d 10 -t wav rec.wav"%soundcard)
-        tux.cmd.mouth_close()
+        tux.mouth.close()
+        #tux.cmd.mouth_close()
+        '''
 
 #==============================================================================
 # Send command window class
@@ -789,8 +791,9 @@
                     commandp[i]=int(commands[i][2:],16)
                 else:
                     commandp[i]=int(commands[i])
-            tux.cmd.raw(int(commandp[0]),int(commandp[1]),int(commandp[2]),
-            int(commandp[3]))
+            print "FIXME :: Raw command : This function isn't implemented yet"
+            #tux.cmd.raw(int(commandp[0]),int(commandp[1]),int(commandp[2]),
+            #int(commandp[3]))
 
 
 #------------------------------------------------------------------------------