path: root/ListenSpell.py

#!/usr/bin/env python
import pygtk
pygtk.require('2.0')

import gtk
import os
import string
from las import Listenspell
from sugar.activity import activity
from sugar.datastore import datastore
import logging
from gettext import gettext as _

class ListenSpell(activity.Activity):
			
	def __init__(self, handle = None, is_stand_alone = False):
		self.is_stand_alone = is_stand_alone
		
		if not self.is_stand_alone:
			activity.Activity.__init__(self, handle)
			self._name = handle
			self._logger = logging.getLogger('listen-spell')
						
		path = __file__
		path = path.rpartition("/")
		self.las = Listenspell()
		self.las.set_path(path[0])
		
		DBname = "dict.db"
		self.las.load_db(DBname)

		self.las.load_speechd_config()
		
		self.use_phoneme = False
		
		self.load_activity_interface()
		self.las.play_sound("begin")
		self.las.say_text("Welcome", wait = False)
		self.ask_skill_level()
		self.play_game("start")
		gtk.main()


	def load_activity_interface(self):
				
		if self.is_stand_alone:
			self.main_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
			self.main_window.connect("destroy", self.destroy)
			self.main_window.set_border_width(10)
			self.main_window.set_title("Listen and Spell")
		
		if not self.is_stand_alone:
			toolbox = activity.ActivityToolbox(self)			
			self.set_toolbox(toolbox)
			toolbox.show_all()
			# Set title for our Activity
			
			self.set_title('Listen and Spell')

		self.Hcontainer   = gtk.HBox()
		self.Hcontainer.show()
		
		if self.is_stand_alone:
			self.main_window.add(self.Hcontainer)
		
		self.vcontainer_left = gtk.VBox()
		self.vcontainer_left.set_border_width(10)
		self.vcontainer_left.show()

		self.vcontainer_right = gtk.VBox()
		self.vcontainer_right.set_border_width(10)
		self.vcontainer_right.show()


		self.Hcontainer.pack_start(self.vcontainer_left,True, True,0)
		self.Hcontainer.pack_end(self.vcontainer_right,False, False,0)

		#####################Left Pane widgets##########################

		
		self.text_input = gtk.Entry()
		self.text_input.show()
		self.text_input.connect("focus-in-event", self.text_input_focus, None)
		self.text_input.connect("activate", self.text_input_activate, None)

		self.console_text_view = gtk.TextView()
		
		self.console_text_sw = gtk.ScrolledWindow()
		self.console_text_sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
		self.console_text_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

		self.console_text_sw.add(self.console_text_view)


		self.text_submit_button = gtk.Button(label="Submit")
		self.text_submit_button.show()
		self.text_submit_button.connect("clicked", self.submit_button_clicked, None)

		self.console_text_buffer = gtk.TextBuffer()
		#self.console_text_buffer.set_text("This is hint text")
		self.console_text_view.set_editable(False)
		self.console_text_view.set_buffer(self.console_text_buffer)

		self.console_text_frame = gtk.Frame("Console:")
		self.console_text_frame.add(self.console_text_sw)
		self.console_text_frame.show_all()

		self.vcontainer_left.pack_start(self.console_text_frame, True, True )
		self.vcontainer_left.pack_start(self.text_input, False, True )
		self.vcontainer_left.pack_start(self.text_submit_button, False, False )

		################################################True################

		#################Right pane wigets##############################

		self.v_buttonbox = gtk.VButtonBox()

		self.repeat_word_button = gtk.Button(label="Repeat Word")
		self.repeat_word_button.connect("clicked", self.repeat_word_button_clicked, None)

		self.get_def_button = gtk.Button(label="Get Def")
		self.get_def_button.connect("clicked", self.get_def_button_clicked, None)

		self.get_usage_button = gtk.Button("Get Usage")
		self.get_usage_button.connect("clicked", self.get_usage_button_clicked, None)

		self.get_word_length_button = gtk.Button("Get Word Length")
		self.get_word_length_button.connect("clicked", self.get_word_length_button_clicked, None)

		self.change_skill_level_button = gtk.Button("Change Skill Level")
		self.change_skill_level_button.connect("clicked", self.change_skill_level_button_clicked, None)
		
		self.change_skill_level_button = gtk.Button("Speech Configuration")
		self.change_skill_level_button.connect("clicked", self.speech_configuration_button_clicked, None)
		
		self.v_buttonbox.add(self.repeat_word_button)
		self.v_buttonbox.add(self.get_def_button)
		self.v_buttonbox.add(self.get_usage_button)
		self.v_buttonbox.add(self.get_word_length_button)
		self.v_buttonbox.add(self.change_skill_level_button)

		self.v_buttonbox.show_all()

		self.button_frame = gtk.Frame("Buttons")
		self.button_frame.add(self.v_buttonbox)
		self.button_frame.show()

		self.vcontainer_right.add(self.button_frame)

		self.stats_frame = gtk.Frame("Stats")

		self.stats_table = gtk.Table(4,2,True)

		self.score_label = gtk.Label("Score: ")
		self.score_value_label = gtk.Label("?")
		#self.score_value_label.

		self.skill_level_label = gtk.Label("Skill Level: ")
		self.skill_level_value_label = gtk.Label("?")

		self.words_played_label = gtk.Label("Words played: ")
		self.words_played_value_label = gtk.Label("?")

		self.words_correct_label = gtk.Label("Correct Words: ")
		self.words_correct_value_label = gtk.Label("?")

		self.stats_table.attach(self.score_label, 0, 1, 0, 1)
		self.stats_table.attach(self.score_value_label, 1, 2, 0, 1)

		self.stats_table.attach(self.skill_level_label, 0, 1, 1, 2)
		self.stats_table.attach(self.skill_level_value_label, 1, 2, 1, 2)

		self.stats_table.attach(self.words_played_label, 0, 1, 2, 3)
		self.stats_table.attach(self.words_played_value_label, 1, 2, 2, 3)

		self.stats_table.attach(self.words_correct_label, 0, 1, 3, 4)
		self.stats_table.attach(self.words_correct_value_label, 1, 2, 3, 4)

		self.vcontainer_right.add(self.stats_frame)
		self.stats_frame.add(self.stats_table)

		self.stats_frame.show_all()
		if not self.is_stand_alone:
			self._logger.debug('activity loaded')

		################################################################
		if self.is_stand_alone:
			self.main_window.show()
		else:
			self.set_canvas(self.Hcontainer)
			self.show_all()

		##################Call Backs####################################

	

	
	
	def _update_configuration(self, widget, attribute ):
		if attribute == "voice":
			self.las.speechd_config(attribute, widget.get_active_text())
		else:
			self.las.speechd_config(attribute, widget.get_value())
		

	def _speech_test(self, widget, speech_text):
		self.las.say_text(str(speech_text))
	
	def speech_configuration_button_clicked(self, widget, data = None):
		self.config_dialog = gtk.Dialog("Speech Configuration", self,0,(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
		#self.las.say_text("Skill Level")
		#vbox = gtk.VBox(False, 8)
		#Vbox.set_border_width(8)
		
		config_table = gtk.Table(4,2)
		config_table.set_row_spacings(4)
		config_table.set_col_spacings(4)
		
		speech_frame= gtk.Frame("Speech Configuration")
		speech_frame.add(config_table)

		self.config_dialog.vbox.pack_start(speech_frame, False, False, 0)
		
		speech_config = self.las.get_speechd_config()
		previous_speechd_config = speech_config
		
		volume_adj = gtk.Adjustment(float(speech_config['volume']), -100, 101, 1, 1, 1)
		rate_adj = gtk.Adjustment(float(speech_config['rate']), -100, 101, 1, 1, 1)
		pitch_adj = gtk.Adjustment(float(speech_config['pitch']), -100, 101, 1, 1, 1)
		
		
		volume_hscale = gtk.HScale(volume_adj)
		rate_hscale = gtk.HScale(rate_adj)
		pitch_hscale = gtk.HScale(pitch_adj)
		
		volume_hscale.set_digits(0)
		rate_hscale.set_digits(0)
		pitch_hscale.set_digits(0)
		
		
		volume_hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
		rate_hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
		pitch_hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
		
		voice_box = gtk.combo_box_new_text()
		voice_list = ["MALE1", "MALE2", "MALE3", "FEMALE1", "FEMALE2", "FEMALE3", "CHILD_MALE", "CHILD_FEMALE"]
		#hscale4 = gtk.HScale(adj4)
		for voice in voice_list:
			voice_box.append_text(voice)
		
		try:
			voice_index = voice_list.index(speech_config['voice'])
		except ValueError:
			voice_box.set_active(0)
		else:
			voice_box.set_active(voice_index)
		
		volume_label = gtk.Label("Volume")
		rate_label = gtk.Label("Rate")
		pitch_label = gtk.Label("pitch")
		voice_label = gtk.Label("Voice")
		
		volume_adj.connect('value_changed',self._update_configuration, "volume")
		rate_adj.connect('value_changed',self._update_configuration, "rate")
		pitch_adj.connect('value_changed',self._update_configuration, "pitch")
		voice_box.connect('changed', self._update_configuration, "voice")
		
		
		config_table.attach(volume_label, 0,1,0,1)
		config_table.attach(rate_label, 0,1,1,2)
		config_table.attach(pitch_label, 0,1,2,3)
		config_table.attach(voice_label, 0,1,3,4)		
		
		config_table.attach(volume_hscale, 1,2,0,1)
		config_table.attach(rate_hscale, 1,2,1,2)
		config_table.attach(pitch_hscale, 1,2,2,3)
		config_table.attach(voice_box, 1,2,3,4)
		
		
		speech_test_frame = gtk.Frame("Test Speech Setting")
		
		self.config_dialog.vbox.pack_start(speech_test_frame, False, False, 0)
		
		
		
		speech_test_table = gtk.Table(2,1)
		speech_test_table.set_row_spacings(4)
		speech_test_table.set_col_spacings(4)

		speech_test_frame.add(speech_test_table)
		
		speech_test_text_entry = gtk.Entry()
		speech_test_text_entry.set_text("The quick brown fox jumps over the lazy dog")
		
		speech_test_button = gtk.Button("Test")
		
		speech_test_button.connect("clicked", self._speech_test, speech_test_text_entry.get_text())

		speech_test_table.attach(speech_test_text_entry, 0,1,0,1)
		speech_test_table.attach(speech_test_button, 0,1,1,2)
		
		
		
		self.config_dialog.show_all()
		
		response = self.config_dialog.run()
		
		if response == gtk.RESPONSE_OK:
			self.config_dialog.destroy()
		elif response == gtk.RESPONSE_CANCEL:
			print "going back"
			for k in previous_speechd_config:
				#print k + " " + str(previous_speechd_config[k])
				self.las.speechd_config(k, previous_speechd_config[k])
			self.config_dialog.destroy()
		
			

	
	def get_speechd_config(self):
		pass
	
	def submit_button_clicked(self, widget, data = None):
		answer = self.text_input.get_text()
		self.las.say_text("You typed")
		self.shout(answer)
		if answer == self.elem:
			self.las.say_text("Correct")
			self.las.ans_correct(self.wordid)
			
		else:
			self.las.ans_incorrect(self.wordid)
			self.las.say_text("Incorrect")
			self.display_console("Incorrect. The correct spelling is.. ")
			self.las.say_text("The correct spelling is..\n")
			self.shout(self.elem)
		self.update_all()
		self.play_game("next word")
		if not self.is_stand_alone:
			self._logger.debug('submit button clicked : ' + self.elem + '')
		return False

	def text_input_focus(self, widget, event, data= None):
		#print "text_input_focus_in"
		return False

	def text_input_activate(self, widget, data=None):
		self.submit_button_clicked(widget, data)
		#print "text_input_activate"
		return False

	def repeat_word_button_clicked(self, widget, data = None):
		if self.elem != self.pronounelem and self.use_phoneme:
			self.las.say_text(self.pronounelem, is_phoneme = True)
		else:
			self.las.say_text(self.elem)
		if not self.is_stand_alone:
			self._logger.debug('repeat button clicked : ' + self.elem + '')

	def get_def_button_clicked(self, widget, data = None):
		def_list = self.las.get_word_info(self.wordid, "def")
		self.display_console("Definition: ")
		for (pos, definition, name) in def_list:
			self.display_console(pos + "(" + name + ") : " + definition)
		if not self.is_stand_alone:
			self._logger.debug('get defination button clicked : ' + self.elem + '')

	def get_usage_button_clicked(self, widget, data = None):
		if self.usage_used == 0:
			usage = self.las.get_word_info(self.wordid, "usage")
			self.total_num_usage = len(usage)
		if self.total_num_usage == 0:
			self.display_console("No usage in the database")
		elif self.total_num_usage == self.usage_used:
			self.display_console("No more usage in the database")
		else:
			(sample) = usage[self.usage_used]
			las.say_text(sample)
			self.usage_used = self.usage_used + 1
		if not self.is_stand_alone:
			self._logger.debug('get usage button clicked : ' + self.elem + '')

	def get_word_length_button_clicked(self, widget, data = None):
		self.display_console("Word Length: " + str(len(self.elem)))
		if not self.is_stand_alone:
			self._logger.debug('get word length button clicked : ' + self.elem + '')

	def ask_skill_level(self):
		self.skill_level_dialog = gtk.Dialog("Enter Skill Level", self, 0,(gtk.STOCK_OK, gtk.RESPONSE_OK, "Quit Game", gtk.RESPONSE_CANCEL))
		self.las.say_text("Skill Level")
		hbox = gtk.HBox(False, 8)
		hbox.set_border_width(8)
		self.skill_level_dialog.vbox.pack_start(hbox, False, False, 0)
		
		table = gtk.Table(1, 1)
		table.set_row_spacings(4)
		table.set_col_spacings(4)
		hbox.pack_start(table, True, True, 0)

		label = gtk.Label("Skill Level")
		#label.set_use_underline(True)
		table.attach(label, 0, 1, 0, 1)
		local_skill_level = gtk.Entry()
		local_skill_level.set_text(str(self.las.get_skill_level()))
		local_skill_level.connect("activate", self.local_skill_level_activate, None)
		table.attach(local_skill_level, 1, 2, 0, 1)
		label.set_mnemonic_widget(local_skill_level)

		self.skill_level_dialog.show_all()
		response = self.skill_level_dialog.run()

		if response == gtk.RESPONSE_OK:
			skill_level = int (local_skill_level.get_text())
			if not self.is_stand_alone:
				self._logger.debug('level set : ' + str(skill_level) + '')
			self.skill_level_dialog.destroy()
			self.las.set_skill_level(skill_level)
			self.update_all()
		elif response == gtk.RESPONSE_CANCEL:
			self.game_exit()
		elif response == gtk.RESPONSE_NONE:
			self.game_exit()
			
	def local_skill_level_focus(self, widget, event, data= None): # not in use
		#print "text_input_focus_in"
		return False

	def local_skill_level_activate(self, widget, data=None):
		self.skill_level_dialog.response(gtk.RESPONSE_OK)

	
	def change_skill_level_button_clicked(self, widget, data=None):
		self.ask_skill_level()
		self.play_game("start")

	def shout(self,string):
		self.display_console("")
		for char in string:
			self.display_console(char, newline = False)
			self.las.say_text(char)
		self.las.say_text(string)
	
	
	################################################################

	#####################Update methods#############################
	def update_all(self):
		self.update_score()
		self.update_skill_level()
		self.update_words_played()
		self.update_words_correct()
		
	def update_score(self, score = None):
		if score ==None:
			score = self.las.get_points()
		self.score_value_label.set_text(str(score))

	def update_skill_level(self, skill_level = None):
		if skill_level ==None:
			skill_level = self.las.get_skill_level()
		self.skill_level_value_label.set_text(str(skill_level))

	def update_words_played(self, words_played = None):
		if words_played ==None:
			words_played = self.las.get_words_played()
		self.words_played_value_label.set_text(str(words_played))

	def update_words_correct(self, words_correct = None):
		if words_correct ==None:
			words_correct = self.las.get_words_correct()
		self.words_correct_value_label.set_text(str(words_correct))

	def play_word(self):
		self.usage_used = -1
		self.total_num_usage = -1
		
		self.text_input.set_text("") # Clear answer field
		
		# Initilazing variable for eacch word
		
		self.elem        = self.las.get_word_info(self.wordid, "word")   #get a word from the list
		self.pronounelem = self.las.get_word_info(self.wordid, "phnm")   #get a pronounciation from the list

		self.display_console("Spell...")       # say the explanation if the word is ambiguous.
		if self.use_phoneme and self.elem != self.pronounelem:    # determine whether to bother pronouncing a description
			self.las.say_text("Spell..." + self.pronounelem, is_phoneme = True)
		else:
			#print "Spell... "
			self.las.say_text("Spell..." + self.elem)
			
	def play_game(self,mode = "start"):
		if mode == "start":
			self.this_level_size = 7
			self.this_level_max_error = 3
			self.wordid_list = self.las.load_wordid(self.this_level_size + self.this_level_max_error)
			self.this_level_num_words = len(self.wordid_list)
			self.this_level_words_left = self.this_level_num_words
			self.word_index = 1
			self.wordid = self.wordid_list[self.word_index]
			self.play_word()
		elif mode == "next word":
			self.this_level_words_left -= 1
			if self.this_level_num_words == 0:
				if self.las.words_correct == self.this_level_size:
					self.display_console("You have crossed this level")
					self.las.say_text("congratulation")
					self.display_console("Please select new level to play the game")
				else:
					self.display_console("Sorry you are not able to cross this level")
					self.las.say_text("Game Over")
					self.display_console("Please select lower level to play the game")
				self.play_game("start")
			self.word_index += 1
			self.wordid = self.wordid_list[self.word_index]
			self.play_word()

	########################Display Methods#########################

	def display_console(self, data, newline = True ):
		if newline == True:
			data = "\n" + data
		self.console_text_buffer.insert_at_cursor(data)

	#def display_main_output(self, data, newline = True, clear_previous = True):
		#if clear_previous == True:
			#self.main_output_buffer.set_text(data)
		#elif newline == True:
			#text = "\n" + data
			#self.main_output_buffer.insert_at_cursor(data)
		#else:
			#self.main_output_buffer.insert_at_cursor(data)

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

	def close(self):
		self.game_exit()
	
	def game_exit(self):
		self._logger.debug('Quiting Game')
		self.las.exit_game()
		gtk.main_quit()

	

	def main(self):
		# All PyGTK applications must have a gtk.main(). Control ends here
		# and waits for an event to occur (like a key press or mouse event).
		gtk.main()

# If the program is run directly or passed as an argument to the python
# interpreter then create a HelloWorld instance and show it
if __name__ == "__main__":
	gui = ListenSpell(is_stand_alone = True)
	#gui.__init__()
	#gui.play_game("start")
	#gui.main()