#!/usr/bin/python -t

import gobject, gtk, gtk.glade, pango, gnome, gnome.ui, gconf, sys, string, random, time, re, gettext

_ = gettext.gettext

class Words:

	deflist, word_count, barr = {}, {}, {}
	tough = []
	revise_mode = 0
	sequential = None
	prev_word = None

	def get_prev_word (self):
		return self.prev_word
	def set_prev_word (self, word):
		self.prev_word = word
	def set_sequential (self, seq):
		self.sequential = seq
	def get_sequential (self):
		return self.sequential
	def get_size (self):
		return len(self.barr.keys())
	def set_revise_mode (self, mode):
		self.revise_mode = mode
	def get_revise_mode (self):
		return self.revise_mode
	def get_filter (self):
		return self.filter_str
	def set_filter(self, filter_str):
		if not filter_str: filter_str = "a-z"
		self.filter_str = filter_str

	def get_breakup (self):
		return "; ".join([pos + ": " + str (wc) for pos, wc in self.word_count.items() if wc > 0])

	def is_tough (self, word):
		return word in self.tough
	
	def add_tough (self, word):
		if (len(word) > 0) and word not in self.tough: self.tough.append (word)

	def get_tough (self):
		self.tough.sort()
		return self.tough

	def set_tough (self, tough):
		for word in tough:
			self.add_tough (word)

	def remove_tough (self, word):
		try: self.tough.remove (word)
		except: pass
	
	def is_regular_defn (self, defn):
		if len (defn) == 0:	return None
		return not re.compile ('[A-Z]\w*[.:]').match (defn)

	def apply_filter (self):
	
		try: cur_word = self.filter_list[self.dict_filter_index]
		except: cur_word = None

		self.dict_filter_index = 0
		
		sp = self.filter_str.split ("-")
		lb = sp[0]
		ub = sp[-1]

		if self.revise_mode:
			list = filter (lambda w: self.lookup(w), self.tough)
		else:
			list = self.barr.keys()

		if self.sequential:
			list.sort()

		self.filter_list = filter (lambda w: w[0:len(lb)] >= lb and w[0:len(ub)] <= ub, list)
		self.filter_list.sort()
		
		if self.sequential:
			if not self.prev_word:
				self.prev_word = lb
			elif self.prev_word > lb and self.prev_word[0:len(ub)] <= ub:
				lb = self.prev_word
		else:
			self.prev_word = None

		self.cur_list = filter (lambda w: w > lb and w[0:len(ub)] <= ub, list)
		if len (self.cur_list) == 0:
			print _("Error: no words matching filter")
			self.filter_list = self.barr.keys()
			self.cur_list = self.barr.keys()

		if cur_word in self.filter_list:
			self.dict_filter_index = self.filter_list.index (cur_word)
			
	def readfile(self, wordlist):

		file = open (wordlist,'r')

		for line in file:
			if '#' in line:
				line = line[0:line.index('#')] #ignore comments
			try:
				(junk, word, junk, meaning, junk, pos, junk) = line.split('"')
			except ValueError:  #ignore invalid lines
				continue
			self.barr[word] = meaning, pos
			meanings = filter (self.is_regular_defn, meaning.split("; "))
			try: self.deflist[pos].extend (meanings)
			except: self.deflist[pos] = meanings
			try: self.word_count[pos] += 1
			except: self.word_count[pos] = 0

	def lookup(self, word):
		try: return self.barr[word]
		except: return None

	def check_empty(self):
		if len(self.cur_list) == 0:
			self.prev_word = None
			self.cur_list = [word for word in self.filter_list]
		
	def get_random_word (self, allow_seq = "True"):
		if self.sequential and allow_seq:
			self.check_empty()
			self.prev_word = word = self.cur_list[0]
			self.cur_list.remove (word)
			return word
		return self.filter_list[random.randint(0, len(self.filter_list)-1)]

	def dict_remove_word (self, word):
		try: self.cur_list.remove(word)
		except:	pass
		if len(self.cur_list) == 0:
			self.cur_list = [word for word in self.filter_list]
		

	def get_dict_next_word (self):
		word = self.filter_list[self.dict_filter_index]
		self.dict_filter_index += 1
		if self.dict_filter_index == len(self.filter_list):
			self.dict_filter_index = 0
		self.dict_remove_word (word)
		return word

	def get_dict_first_word (self):
		self.dict_filter_index = 1
		return self.filter_list[0]

	def get_dict_random_word (self):
		self.dict_filter_index = random.randint(0, len(self.filter_list)-1)
		word = self.filter_list[self.dict_filter_index]
		self.dict_remove_word (word)
		self.dict_filter_index += 1
		if self.dict_filter_index == len(self.filter_list):
			self.dict_filter_index = 0
		return word

	def dict_set (self, word):
		for i in range (len(self.filter_list)): 
			if self.filter_list[i] == word: self.dict_filter_index = i + 1
		if self.dict_filter_index == len (self.filter_list): self.dict_filter_index = 0
		self.dict_remove_word (word)

	def get_random_choice (self, word):
		junk, pos = self.barr[word]
		return self.deflist[pos][random.randint(0, len(self.deflist[pos])-1)]
				
	def get_random_meaning (self, word):
		meanings = self.get_meanings(word)
		return self.get_meanings(word)[random.randint(0, len(meanings)-1)]

	def get_meanings (self, word):
		meaning, pos = self.barr[word]
		meanings = []
		for defn in meaning.split ("; "):
			if len(defn) == 0:
				continue
			if self.is_regular_defn (defn):
				meanings.append (defn)
			else:
				break
		return meanings

	def __init__(self, wordlist):
		self.readfile (wordlist)


class ScrollView:

	first = gtk.TRUE

	def put_text (self, text, weight = None, scroll = "Yes"):
		buf = self.view.get_buffer ()
		if not weight:
			buf.insert(buf.get_end_iter(), text)
		else:
			buf.insert_with_tags_by_name (buf.get_end_iter(), text, weight)
		if scroll:
			self.view.scroll_to_mark (self.end_mark, 0)
	
	def put_entry (self, words, word, type = None, scroll = "Yes"):
		if not self.first:
			self.put_text ("\n\n", scroll = scroll)
		self.first = gtk.FALSE
		ans = words.lookup (word)
		if not ans:
			out = ": " + _("Not found")
			retval = gtk.FALSE
		else:
			meaning, pos = ans
			meaning = "\n\t" + (meaning.replace("; ; ", "\n; ").replace("; ", "\n\t"))
			out = '(' + pos + "): " + meaning
			retval = gtk.TRUE
		self.put_text (word, type, scroll)
		self.put_text (out, scroll = scroll)
		return retval

	def copy (self):
		self.view.get_buffer().copy_clipboard (0)

	def clear (self):
		self.view.get_buffer().set_text ("")
		self.first = gtk.TRUE

	def set_underline (self, underline):
		self.view.get_buffer().get_tag_table().lookup ("incorrect").set_property ("underline-set", underline)

	def __init__(self, view):
		self.view = view
		buf = view.get_buffer ()
		iter = buf.get_end_iter ()
		self.end_mark = buf.create_mark ("end", iter, 0)
		tag = buf.create_tag ("emph")
		tag.set_property ("weight", pango.WEIGHT_BOLD)
		tag = buf.create_tag ("correct")
		tag.set_property ("weight", pango.WEIGHT_BOLD)
		tag.set_property ("foreground", "#267726")
		tag = buf.create_tag ("incorrect")
		tag.set_property ("weight", pango.WEIGHT_BOLD)
		tag.set_property ("foreground", "#DF421E")
		tag.set_property ("underline", pango.UNDERLINE_SINGLE)


class Config:

	def get (self, key):
		value = self.client.get_string (self.prefix + "/" + key)
		if value == "None":
			value = None
		return value

	def set (self, key, value):
		if value is None:
			value = "None"
		self.client.set_string (self.prefix + "/" + key, value)

	def get_boolean (self, key, on = gtk.TRUE, off = gtk.FALSE):
		value = self.get (key)
		if value == "On" or value == "Yes" or value == "True":
			return on
		else:
			return off
		
	def set_boolean (self, key, value, on = gtk.TRUE, off = gtk.FALSE):
		if value == on:
			value = "On"
		else:
			value = "Off"
		self.set (key, value)

	def __init__ (self):
		self.client = gconf.client_get_default()
		self.prefix = "/apps/gretools"
		self.client.add_dir (self.prefix, 'preload-none')


class Gui:
		
	syn_num_choices = 5

	dict_prev_word = None
	inv_prev_word = None
	glob_prev_word = None

	def inv_magic_score (self, ndefs, nclues, nguesses):
		entropy = 0.0
		for i in range (ndefs-1):
			entropy += 1.0 / (i+1)
		entropy = entropy + 1.5 * nclues + 0.3 * nguesses
		if entropy <= 1:
			return 1.0
		if entropy >= 7:
			return 0.0
		return (7 - entropy) / 6.0
	
	def destroy_cb(self, *args):
		self.config.set ("prev_word", self.words.get_prev_word())
		self.config.set ("tough_words", ":".join(self.words.get_tough()))
		self.config.set ("filter", self.words.get_filter())
		self.config.set_boolean ("sequential", self.words.get_sequential())
		self.config.set_boolean ("revise_mode", self.words.get_revise_mode ())
		self.config.set ("synonyms_num_choices", str (self.syn_num_choices))
		self.config.set ("word_list_file", self.wordlist)
		self.config.set_boolean ("underline_incorrect", self.underline_incorrect)
		gtk.main_quit()

	def about_cb(self, *args):
		about_dialog = gtk.glade.XML(glade_file, 'aboutdialog').get_widget('aboutdialog')
		about_dialog.set_property ("logo", gtk.gdk.pixbuf_new_from_file(image_dir + "/gretools.png"))
		about_dialog.set_property ("name", package_name)
		about_dialog.set_property ("version", package_version)
		about_dialog.show()

	def prefs_underline_cb (self, *args):
		self.underline_incorrect = self.prefs_window.get_widget ('prefs_underline').get_active()
		self.syn_view.set_underline (self.underline_incorrect)
		self.inv_view.set_underline (self.underline_incorrect)

	def prefs_cb(self, *args):
		self.prefs_window = gtk.glade.XML(glade_file, 'prefsdialog')
		self.prefs_window.signal_autoconnect (self.cb_table)
		wid = self.prefs_window.get_widget('prefsdialog')
		self.prefs_window.get_widget ('prefs_filter_entry').set_text(self.words.get_filter())
		self.prefs_window.get_widget ('prefs_underline').set_active(self.underline_incorrect)
		if self.words.get_sequential():
			self.prefs_window.get_widget ('prefs_sequential').set_active(gtk.TRUE)
		else:
			self.prefs_window.get_widget ('prefs_random').set_active(gtk.TRUE)
		self.rundialog (wid, destroy = None)
		self.words.set_filter(self.prefs_window.get_widget ('prefs_filter_entry').get_text())
		self.words.set_sequential(self.prefs_window.get_widget ('prefs_sequential').get_active())
		self.words.apply_filter()
		wid.destroy()

	def set_prev_word (self, word):
		self.glob_prev_word = word
		self.wid('menu_add').set_sensitive(gtk.TRUE)
		self.wid('menu_add').set_active(self.words.is_tough (word))
		self.wid ('menu_add').get_children()[0].set_text (_("Mark \"%s\" as difficult") % word)
		return word
	
	def lookup_cb(self, *args):
		word = self.wid('dict_entry').get_text()
		word = word.strip()
		if word == "" or word == self.dict_prev_word:
			return
		self.dict_prev_word = self.set_prev_word (word)
		self.words.dict_set (word)
		if not self.dict_view.put_entry (self.words, word, "emph"):
			dialog = gtk.glade.XML(glade_file, 'notfound_dialog')
			wid = dialog.get_widget('notfound_dialog')
			dialog.get_widget('notfound_label').set_label(dialog.get_widget('notfound_label').get_label()%word)
			if wid.run() == gtk.RESPONSE_OK:
				if not gnome.execute_shell (".", "gnome-dictionary %s" % word):
					self.run_new_dialog('dict_error_dialog')
			wid.destroy()

	def run_new_dialog(self, name):
		return self.rundialog (gtk.glade.XML(glade_file, name).get_widget (name))

	def lookup_first_cb (self, *args):
		word = self.words.get_dict_first_word()
		self.set_prev_word (word)
		self.dict_view.put_entry (self.words, word, "emph")
	
	def lookup_next_cb (self, *args):
		word = self.words.get_dict_next_word()
		self.set_prev_word (word)
		self.dict_view.put_entry (self.words, word, "emph")
	
	def random_cb (self, *args):
		word = self.words.get_dict_random_word()
		self.set_prev_word (word)
		self.dict_view.put_entry (self.words, word, "emph")

	def syn_start_cb (self, *args):
		self.wid('syn_start_button').destroy()
		self.wid('syn_ok_button').set_sensitive(gtk.TRUE)
		map (lambda x: self.wid(x).set_sensitive(gtk.TRUE),\
				['syn_ok_button', 'syn_answer_label', 'syn_view'])
		self.wid('syn_question_label').show()
		self.syn_cur_time, self.syn_num_correct, self.syn_num_total, self.syn_wrong = 0, 0, 0, 0
		gtk.timeout_add (1000, self.syn_update_time)
		self.syn_show_next ()

	def syn_ok_cb (self, *args):
		if self.syn_wrong == 1:
			self.syn_wrong = 0
			self.wid('syn_score').set_markup\
				("Score: " + str(self.syn_num_correct) + "/" + str(self.syn_num_total))
			self.syn_show_next ()
			return
		else:
			for i in range (self.syn_num_choices):
				if self.wid(self.mwidgets[i]).get_active():
					break
			self.syn_num_total += 1
			if (i == self.syn_correct):
				self.syn_view.put_entry (self.words, self.syn_cur_word, "correct")
				self.syn_show_next ()
				self.syn_num_correct += 1
				self.wid('syn_score').set_markup\
					("Score: " + str(self.syn_num_correct) + "/" + str(self.syn_num_total))
			else:
				self.syn_view.put_entry (self.words, self.syn_cur_word, "incorrect")
				self.syn_wrong = 1
				self.wid('syn_score').set_markup ("<b><span foreground=\"#DF421E\">Incorrect</span></b>")
				self.wid('syn_ok_button').hide()
				self.wid('syn_next_button').show()
				self.wid('menu_add').set_active(gtk.TRUE)
				self.words.add_tough (self.syn_cur_word)

	def syn_show_next (self):
		self.syn_cur_word = self.words.get_random_word()
		self.set_prev_word (self.syn_cur_word)
		qlabel = self.wid ('syn_question_label')
		qlabel.set_markup (_("<b>The synonym of <big><i> %s </i></big> is</b>:") % self.syn_cur_word)
		for i in range (self.syn_num_choices):
			self.wid (self.mwidgets[i]).set_label (self.words.get_random_choice(self.syn_cur_word))
		self.syn_correct = random.randint (0, self.syn_num_choices-1)
		self.wid (self.mwidgets[self.syn_correct]).\
			set_label (self.words.get_random_meaning(self.syn_cur_word))
		self.wid(self.mwidgets[0]).set_active(gtk.TRUE)
		self.wid('syn_ok_button').show()
		self.wid('syn_next_button').hide()

	def syn_update_time (self):
		self.syn_cur_time += 1
		self.wid('syn_time').set_markup (_("Time: ") + time.strftime ("%M:%S", time.gmtime (self.syn_cur_time)))
		return gtk.TRUE

	def inv_start_cb (self, *args):
		self.wid('inv_start_button').destroy()
		map (lambda x: self.wid(x).set_sensitive(gtk.TRUE),\
				['inv_guess_button', 'inv_newclue_button', 'inv_giveup_button',
				'inv_entry', 'inv_guess_label', 'inv_answers_label', 'inv_hints'])
		self.inv_cur_time, self.inv_score, self.inv_num_total = 0, 0, 0
		self.inv_cur_labels, self.inv_guess_labels, self.inv_cur_buttons = [], [], []
		self.inv_cur_word = None
		gtk.timeout_add (1000, self.inv_update_time)
		self.inv_show_next ()

	def inv_letter_cb (self, widget, which):
		widget.set_label (self.inv_cur_word[int(which)])
		self.inv_num_chars += 1

	def inv_show_next (self):
		self.wid('inv_newclue_button').set_sensitive(gtk.TRUE)
		self.wid('inv_entry').set_text("")
		if self.inv_cur_word:
			self.set_prev_word (self.inv_cur_word)
		word = self.inv_cur_word = self.words.get_random_word(allow_seq = None)
		self.inv_cur_meanings = self.words.get_meanings (word)
		map (lambda wid: wid.destroy(), self.inv_cur_labels)
		map (lambda wid: wid.destroy(), self.inv_guess_labels)
		map (lambda wid: wid.destroy(), self.inv_cur_buttons)
		self.inv_cur_labels, self.inv_cur_buttons = [], []
		for i in range (len(word)):
			button = gtk.Button ("?")
			self.wid('inv_letters_box').pack_start (button)
			button.show()
			button.connect ("clicked", self.inv_letter_cb, str(i))
			self.inv_cur_buttons.append (button)
		self.inv_cur_num_clues, self.inv_num_wrong, self.inv_num_chars = 0, 0, 0
		self.inv_num_total += 1
		self.inv_new_clue_cb()

	def inv_new_clue_cb (self, *args):
		self.inv_cur_num_clues += 1
		if len(self.inv_cur_meanings) == self.inv_cur_num_clues:
			self.wid('inv_newclue_button').set_sensitive(gtk.FALSE)
		box = self.wid ('inv_clues_box')
		label = gtk.Label (str (self.inv_cur_num_clues) + ". " + self.inv_cur_meanings[self.inv_cur_num_clues-1])
		label.show()
		label.set_alignment (0, 0.5)
		box.pack_start (label, gtk.FALSE, gtk.FALSE, 3)
		self.inv_cur_labels.append (label)

	def inv_give_up_cb (self, *args):
		self.inv_view.put_entry (self.words, self.inv_cur_word, "incorrect")
		self.wid('inv_score').set_markup\
			(_("Score: ") + str(self.inv_score) + "/" + str(self.inv_num_total))
		self.words.add_tough (self.inv_cur_word)
		self.inv_show_next()

	def inv_guess_cb (self, *args):
		ans = self.wid ('inv_entry').get_text().strip ()
		if ans == "" or ans == self.inv_prev_word:
			return
		self.inv_prev_word = ans
		if ans == self.inv_cur_word:
			self.inv_view.put_entry (self.words, self.inv_cur_word, "correct")
			score = self.inv_magic_score (self.inv_cur_num_clues, self.inv_num_chars, self.inv_num_wrong)
			score = int (score * 100) / 100.0
			self.inv_score += score
			self.wid('inv_score').set_markup\
				(_("Score: ") + str(self.inv_score) + "/" + str(self.inv_num_total))
			self.inv_show_next ()
		else:
			self.inv_num_wrong += 1
#			self.wid('inv_wrong_label').set_text ("Wrong guesses: " + str (self.inv_num_wrong))
			box = self.wid ('inv_guess_box')
			label = gtk.Label (str (self.inv_num_wrong) + ". " + ans)
			label.show()
			label.set_alignment (0, 0.5)
			box.pack_start (label, gtk.FALSE, gtk.FALSE, 3)
			self.inv_guess_labels.append (label)
 
	def inv_update_time (self):
		self.inv_cur_time += 1
		self.wid('inv_time').set_markup (_("Time: ") + time.strftime ("%M:%S", time.gmtime (self.inv_cur_time)))
		return gtk.TRUE

	def tough_edited_cb (self, cell, path, text, iter):
		self.tough_model.set_value(iter,0,text)
		self.tough_model.set_value(iter,1,gtk.FALSE)
		self.words.add_tough (text)

	def tough_select_cb (self, *args):
		self.tough_window.get_widget ('tough_show').set_sensitive (gtk.TRUE)
		self.tough_window.get_widget ('tough_remove').set_sensitive (gtk.TRUE)
		return gtk.TRUE

	def show_tough (self, *args):
		self.tough_window = gtk.glade.XML(glade_file, 'tough_dialog')
		self.tough_window.signal_autoconnect (self.cb_table)
		self.tough_model = model = gtk.TreeStore (gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
		if not self.words:
			return
		words =  self.words.get_tough()
		for word in words:
			iter = model.insert_before(None,None)
			model.set_value(iter,0,word)
			model.set_value(iter,1,gtk.FALSE)
		self.tough_view = view = gtk.TreeView(model)
		self.tough_renderer = renderer = gtk.CellRendererText()
		column = gtk.TreeViewColumn("", renderer, text=0, editable=1)
		view.append_column(column)
		view.get_selection().set_mode (gtk.SELECTION_MULTIPLE)
		view.get_selection().set_select_function (self.tough_select_cb, None)
		view.set_headers_visible (gtk.FALSE)
		
		self.tough_window.get_widget('tough_scrwin').add (view)
		view.show()
		wid = self.tough_window.get_widget('tough_dialog')
		self.rundialog (wid, 400, 300)

	def tough_remove_cb(self, *args):
		iters = []
		self.tough_view.get_selection().selected_foreach (lambda spam1, spam2, iter: iters.append(iter))
		if len(iters) == 0: self.tough_nothing_selected ()
		ok = gtk.TRUE
		if len(iters) > 5:
			xml = gtk.glade.XML(glade_file, 'rm_conf_dialog')
			dialog = xml.get_widget ('rm_conf_dialog')
			label = xml.get_widget('rm_conf_label')
			label.set_label(label.get_label()%str(len(iters)))
			if dialog.run() != gtk.RESPONSE_OK:
				ok = gtk.FALSE
			dialog.destroy()
		if not ok: return
		for iter in iters:
			try:
				self.words.remove_tough (self.tough_model.get_value (iter, 0))
				self.tough_model.remove (iter)
			except:
				pass

	def tough_revise_cb (self, *args):
		self.words.set_revise_mode (self.wid('tough_revise').get_active())
		self.words.apply_filter ()

	def tough_add_cb (self, *args):
		xml = gtk.glade.XML(glade_file, 'tough_add_dialog')
		dialog = xml.get_widget ('tough_add_dialog')
		if dialog.run () == gtk.RESPONSE_OK:
			word = xml.get_widget ('tough_add_entry').get_text()
			if len(word) > 0:
				iter = self.tough_model.insert_before (None, None)
				self.tough_model.set_value (iter, 0, word)
				self.tough_model.set_value (iter, 1, gtk.FALSE)
				self.tough_view.set_cursor (self.tough_model.get_path(iter), self.tough_view.get_column(0), gtk.FALSE)
				self.words.add_tough (word)
		dialog.destroy()

	def tough_select_all_cb (self, *args):
		self.tough_view.get_selection().select_all()
				
	def wlist_info_cb (self, *args):
		self.wlist_dialog = gtk.glade.XML(glade_file, 'wlist_info')
		self.wlist_dialog.signal_autoconnect (self.cb_table)
		self.wlist_dialog.get_widget ('info_name').set_text (self.wordlist.split ("/")[-1].split(".")[0])
		self.wlist_dialog.get_widget ('info_location').set_text (self.wordlist)
		self.wlist_dialog.get_widget ('info_words').set_text (str (self.words.get_size()))
		self.wlist_dialog.get_widget ('info_breakup').set_text (self.words.get_breakup())
		wid = self.wlist_dialog.get_widget('wlist_info')
		self.rundialog (wid, 400, 200)
	
	def rundialog (self, wid, xsize = None, ysize = None, destroy = "Yes"):
		if xsize and ysize:
			wid.set_size_request (xsize, ysize)
		while 1:
			val = wid.run()
			if val == gtk.RESPONSE_CLOSE or val == gtk.RESPONSE_DELETE_EVENT:
				break
		if destroy:
			wid.destroy()

	def tough_nothing_selected (self):
		wid = gtk.MessageDialog (self.tough_window.get_widget ('tough_dialog'),\
			   type = gtk.MESSAGE_ERROR,\
			   message_format = _("No words selected"),\
			   buttons = gtk.BUTTONS_CLOSE)
		self.rundialog (wid)
			
	def tdef_showdef_cb (self, *args):
		self.tdef_dialog = gtk.glade.XML(glade_file, 'tdef_dialog')
		self.tdef_view = ScrollView (self.tdef_dialog.get_widget('tdef_view'))
		iters = []
		self.tough_view.get_selection().selected_foreach (lambda spam1, spam2, iter: iters.append(iter))
		if len (iters) == 0: self.tough_nothing_selected ()
		else:
			wid = self.tdef_dialog.get_widget ('tdef_dialog')
			for iter in iters:
				self.tdef_view.put_entry (self.words, self.tough_model.get_value (iter, 0), "emph", scroll = None)
			self.rundialog (wid, 400, 300)

	def menu_add_cb (self, *args):
		if not self.glob_prev_word:	return
		if (self.wid('menu_add')).get_active():
			self.words.add_tough (self.glob_prev_word)
		else:
			self.words.remove_tough (self.glob_prev_word)

	def menu_copy_cb (self, *args):
		self.text_views[self.wid('main_notebook').get_current_page()].copy()

	def menu_clear_cb (self, *args):
		self.text_views[self.wid('main_notebook').get_current_page()].clear()

	def wid (self, name):
		return self.main_window.get_widget (name)

	def launch_help_cb (self, widget):
		#mapping between context help widgets and corresponding sections of the documentation
		help_id_map = {
			"menu_help" : "",
			"prefs_help" : "gretools-prefs",
			"tough_help" : "gretools-view-tough-words",
		}

		try:
			id = help_id_map[widget.get_name()]
		except KeyError:
			print _("Warning: no help section for this context, defaulting to index")
			id = ""
		gnome.help_display ('gretools.xml', id)

	def initwords (self, list_name):
		if list_name and len(list_name) > 0:
			try:
				self.words = Words (list_name)
				self.wordlist = list_name
			except IOError, detail: 
				print _("Warning: Could not open word list") + " \"" + list_name + "\": " + str(detail)
			except:
				print _("Warning: Unknown error opening word list") + " \"" + list_name + "\""
		
	def initialize(self):
		self.words = None
		self.initwords(self.config.get ("word_list_file"))
		if not self.words: self.initwords (wordlist_dir + "/" + "default.wl")
		if not self.words:
			wid = gtk.MessageDialog (self.wid('Gretools'),\
				type = gtk.MESSAGE_ERROR,\
				message_format = _("Could not open word list.\n") + self.application_name + _(" will now exit."),\
				buttons = gtk.BUTTONS_CLOSE)
			self.rundialog (wid, 300, 120)
			gtk.main_quit()
			sys.exit (3)
			
		tough = self.config.get ("tough_words")
		if not tough: tough = ""
		self.words.set_tough(tough.split (":"))
		try:
			nc = int(self.config.get ("synonyms_num_choices"))
		except TypeError, ValueError:
			nc = 5
		if (nc < 3):
			nc = 5
		self.syn_num_choices = nc
		self.words.set_prev_word (self.config.get ("prev_word"))
		self.words.set_filter (self.config.get ("filter"))
		self.words.set_sequential (self.config.get_boolean ("sequential"))
		mode = self.config.get_boolean ("revise_mode")
		self.words.set_revise_mode (mode)
		self.underline_incorrect = self.config.get_boolean ("underline_incorrect")

		self.dict_view = ScrollView (self.wid('dict_view'))
		self.syn_view = ScrollView (self.wid('syn_view'))
		self.inv_view = ScrollView (self.wid('inv_view'))

		self.syn_view.set_underline (self.underline_incorrect)
		self.inv_view.set_underline (self.underline_incorrect)

		#The order in which they appear in the notebook
		self.text_views = [self.syn_view, self.inv_view, self.dict_view]

		self.wid('tough_revise').set_active (mode)
		self.words.apply_filter()
		self.wid('syn_start_button').set_sensitive(gtk.TRUE)
		self.wid('syn_start_button').grab_focus()

	def __init__(self):

		gettext.bindtextdomain('gretools', locale_dir)
		gettext.textdomain('gretools')

		self.application_name = _("Vocabulary Builder")

		program = gnome.program_init (package_name, package_version)
		program.set_property('app-libdir',prefix_dir + "/lib")
		program.set_property('app-datadir', prefix_dir + "/share/")
		program.set_property('app-sysconfdir', prefix_dir + "/etc")
		program.set_property('app-prefix', prefix_dir)

		self.main_window = gtk.glade.XML(glade_file)

		self.cb_table = { 
			"on_quit1_activate" : self.destroy_cb, 
			"on_Gretools_destroy" : self.destroy_cb, 
			"on_about1_activate" : self.about_cb,
			"on_preferences1_activate" : self.prefs_cb,
			"on_prefs_underline_toggled" : self.prefs_underline_cb,
			"on_dict_lookup_clicked" : self.lookup_cb,
			"on_dict_entry_activate" : self.lookup_cb,
			"on_dict_random_clicked" : self.random_cb,
			"on_dict_next_clicked" : self.lookup_next_cb,
			"on_dict_first_clicked" : self.lookup_first_cb,
			"on_syn_ok_button_clicked" : self.syn_ok_cb,
			"on_syn_start_button_clicked" : self.syn_start_cb,
			"on_inv_start_button_clicked" : self.inv_start_cb,
			"on_inv_newclue_button_clicked" : self.inv_new_clue_cb,
			"on_inv_giveup_button_clicked" : self.inv_give_up_cb,
			"on_inv_guess_button_clicked" : self.inv_guess_cb,
			"on_inv_entry_activate" : self.inv_guess_cb,
			"on_tough_view_activate" : self.show_tough,
			"on_tough_remove_clicked" : self.tough_remove_cb,
			"on_tough_revise_activate" : self.tough_revise_cb,
			"on_menu_info_activate" : self.wlist_info_cb,
			"on_tough_add_clicked" : self.tough_add_cb, 
			"on_tough_select_clicked" : self.tough_select_all_cb,
			"on_tough_show_clicked" : self.tdef_showdef_cb,
			"on_menu_add_activate" : self.menu_add_cb,
			"on_menu_copy_activate" : self.menu_copy_cb,
			"on_menu_clear_activate" : self.menu_clear_cb,
			"on_menu_help_activate" : self.launch_help_cb,
			"on_tough_help_clicked" : self.launch_help_cb,
			"on_prefs_help_clicked" : self.launch_help_cb
		}

		self.main_window.signal_autoconnect (self.cb_table)

		self.config = Config()
		self.words = None

		self.wid('menu_add').set_sensitive(gtk.FALSE)
		self.wid('main_notebook').set_current_page (0)

		gtk.idle_add (self.initialize)
		
		max_choices = 0
		self.mwidgets = []
		while 1:
			but_name = 'syn_choice_button' + str(max_choices+1)
			if (self.wid(but_name)):
				max_choices += 1
				self.mwidgets.append (but_name)
			else:
				break
		if (self.syn_num_choices > max_choices):
			self.syn_num_choices = max_choices
		for i in range (self.syn_num_choices, max_choices):
			self.wid('syn_choice_button' + str(i+1)).destroy()

		gtk.main()

if __name__ == "__main__":
	Gui()