~ubuntu-tour/+junk/new-lang-system

#!/usr/bin/env python

import glob
import os
import re
import locale
import gtk
import pygtk
from translate import Translate


class T:
	
	#When the class is loaded
	def __init__(self, tour, directory):

		#Folder
		self.folder = directory
		
		#Parent tour class
		self.tour = tour
		
		#Some empty values to fill later
		self.lang, self.info, self.parent, self.name, self.pos, self.default, self.id, self.t_pages = None, None, None, None, None, None, None, None
		
		#Run some stuff
		self.detect_lang()
		self.get_tour_info()
		self.num_pages()
	
	
	#Def detect lang
	def detect_lang(self):
		
		#Try using the language and country
		if os.path.isdir(os.path.join(self.folder, self.tour.user_lang)):
			self.lang = self.tour.user_lang
		
		#Fallback on just the language
		elif os.path.isdir(os.path.join(self.folder, self.tour.user_lang.split('_')[0])):
			self.lang = self.tour.user_lang.split('_')[0]
		
		#Fallback on default language
		else:
			self.lang = self.tour.default_lang
		
		#And return
		return self.lang
	
	
	#Get the tour info
	def get_tour_info(self):
		
		#Try and open the file
		try:
			#Load the info
			info = open(os.path.join(self.folder, self.lang, 'tour.info'),'r').read()
			
			#Parse the info
			self.info = {}
			for line in info.split('\n'):
				if ':' in line:
					l = line.split(':')
					self.info[l[0]] = l[1]
			
			#This is deliberately bad coding, so that if the tour is invalid, it will break the try and force the except to work.
			self.parent = self.info['parent']
			self.name = self.info['name']
			try:
				self.pos = int(self.info['position'])
			except:
				self.pos = 1000
			try:
				self.default = int(self.info['default'])#TODO: impliment features using this.
			except:
				self.default = 0
			
			#If it survived that it's valid.
			self.is_valid = True
		
		#Tour is not valid.
		except:
			self.tour.p(self.folder + " does not have a tour.info, folder rejected.")
			self.is_valid = False
	
	
	#How many pages
	def num_pages(self):
		
		#Get all the pages
		pages = glob.glob(os.path.join(self.folder, self.lang, "*"))
		
		#Loop through the pages
		count = 0
		for p in pages:
			if '_' in p.split('/')[-1]:
				try:
					page = int(p.split('/')[-1].split('_')[0])
					if page > count:
						count = page
				except:
					self.tour.p('Warning, ' + p.split('/')[-1] + ' contains an underscore, please rename.')
		
		#Set
		self.t_pages = count
		
		#How many then?
		return self.t_pages
	
	
	#Set id
	def set_id(self, n):
		self.id = n


class Tour:

	#Things to do when class is loaded
	def __init__(self, debug, html, colours):
		self.default_lang = 'en'
		self.user_lang = self.detect_lang()
		self.dialect = self.load_dialect()
		
		self.debug = debug
		self.html = html
		self.colours = colours
		self.parse_colours()
		
		self.folder=None
		self.page=0
		self.t_pages = 0
		
		self.progression_reqs = ''
		self.fullscreen = False
		
		self.get_sections()
		
		self.catagories = ['Hidden', 'Getting Started', 'Internet', 'Office', 'Multimedia', 'Continue Playing']
	
	#Debug print function
	def p(self, string):
		if self.debug:
			print string


	#Get a list of tutorials available
	def get_sections(self):
		#Get all for folders
		if os.path.exists(os.path.join(os.getcwd(), "tours")):
			dirs = glob.glob(os.path.join(os.getcwd(), "tours", "*"))
		elif os.path.exists(os.path.join("/", "usr","share","ubuntu-tour","tours")):
			dirs = glob.glob(os.path.join("/", "usr","share","ubuntu-tour","tours","*"))
		elif os.path.exists(os.path.join(os.path.expanduser('~'), ".ubuntu-tour", "tours")):
			dirs = glob.glob(os.path.join(os.path.expanduser('~'), ".ubuntu-tour", "tours", "*"))
		
		#Go through the folders
		self.tours = []
		n = 0
		for folder in dirs:
			tour = T(self, folder)
			if tour.is_valid:
				tour.set_id(n)
				self.tours.append(tour)
				n+=1
				
		#Return the list
		return self.tours


		def GetDefaultApp(Type):
			if (Type.lower() == "browser"):
				return os.popen("gconftool-2 -g /desktop/gnome/applications/browser/exec").read()[:-1]
			elif (Type.lower() == "music" or Type.lower() == "media"):
				return os.popen("gconftool-2 -g /desktop/gnome/applications/media/exec").read()[:-1]
			else:
				print "There's no support for looking up the apps for \"" + Type + "\""
			return 0

	#Load page
	def load_page(self, tour_id, page=0, fullscreen=False, dark=False):
		#Debug
		self.p("Loading page")
		
		#Get the folder name and page number
		self.page = int(page)
		
		#Get the tour
		self.current_tour = self.tours[int(tour_id)]
		tour = self.current_tour
		
		#Try and read the page, if not, return a generic page
		try:
			#Get the files
			files = glob.glob(tour.folder + "/" + tour.lang + '/' + str(self.page) + "_*")
			
			#Find the html one
			html = -1
			for n in range(0, len(files)):
				if files[n].split('.')[-1] == 'html':
					html = n
			
			#Are we using the html
			if self.html:
			
				#Is there a html file?
				if html >= 0:
					#Open the html file
					msg = open(files[html],'r')
					
					#Get the text
					text = msg.read()
				
				else:
					#Open the text file
					msg = open(files[html],'r')
					
					#Get the text
					text = msg.read()
					
					#Convert to html
					text = self.raw_to_html(text)
			
			#Otherwise we are using plain text
			else:
				#Usually the file will be 0
				f = 0
				convert = False
				
				#If however -1 is the html
				if html == -1:
					#If there is another file
					if len(files) > 1:
						f = 1
					
					#Otherwise convert the html file to a text file
					else:
						convert = True
				
				#Open the file
				msg=open(files[f],'r')
			
				#Get the text
				text = msg.read()
				
				#Should we try and convert
				if convert:
					text = self.html_to_raw(text)
			
			#Get the progression requirements
			if '"Requirements" -->' in text:
				reqs = text.split('"Requirements" -->', 2)[0]
				if '<!-- "Requirements"' in reqs:
					reqs = reqs.split('<!-- "Requirements"', 2)[1]
					
					#Save these requirements
					self.progression_reqs = reqs
				
				else:
					self.progression_reqs = ''

			else:
				self.progression_reqs = ''
					
			#Convert text to the local dialect
			if not '_' in tour.lang:
				self.p('using dialect')
				text = self.convert_to_dialect(text)	
			
			#Set the text
			if self.html:
				self.gui.html.load_html_string(self.parse_html(text, dark), 'file://' + tour.folder + "/" + tour.lang + "/")
			else:
				self.gui.buffer.set_text(text)
			
			#Category homes
			if tour.name == "Home":
				if tour.parent == "Hidden":
					self.gui.addressbar.set_items(['Home'])
				else:
					self.gui.addressbar.set_items(['Home', tour.parent])
			
			#General tours
			elif tour.parent != "Hidden":
				self.gui.addressbar.set_items(['Home', tour.parent, tour.name])
					
			
			#Close the file
			msg.close()
			
		except:
			#If we can't load the file, we should give some generic text.
			if self.html:
				self.gui.html.load_html_string(self.parse_html("Nothing written yet.", dark), 'file://' + tour.folder + "/" + tour.lang + "/")
			else:
				self.gui.buffer.set_text("Nothing written yet.")
		
		finally:
			
			#Fullscreen?
			if fullscreen:
				if not self.fullscreen:
					#Hide everything
					self.gui.progressbar.hide()
					self.gui.buttonbox.hide()
					self.gui.menuscroll.hide()
					
					#Set to fullscreen
					self.fullscreen = True
					
			else:
				if self.fullscreen:
					#Show everything
					self.gui.progressbar.show()
					self.gui.buttonbox.show()
					self.gui.menuscroll.show()
					
					#Now longer fullscreen
					self.fullscreen = False
		
		#Now we have loaded the page, lets see about the position.
		if tour.t_pages == 0:
			self.gui.next_button.set_sensitive(False)
			self.gui.back_button.set_sensitive(False)
		elif self.page == 0:
			self.gui.next_button.set_sensitive(True)
			self.gui.back_button.set_sensitive(False)
		elif self.page == tour.t_pages:
			self.gui.next_button.set_sensitive(False)
			self.gui.back_button.set_sensitive(True)
		else:
			self.gui.next_button.set_sensitive(True)
			self.gui.back_button.set_sensitive(True)
		
		if self.page==1 and self.current_tour.name=="Managing software":
			self.gui.next_button.hide()
			self.gui.check_button.show()
		else:
			self.gui.next_button.show()
			self.gui.check_button.hide()
		
		#Progress
		if tour.t_pages > 0:
			progress = float(self.page) / float(tour.t_pages)
		else:
			progress = 1
		self.gui.progressbar.set_fraction(progress)
		
	
	
	#How many pages
	def num_pages(self, tutorial):
		#Get the path to the tutorial
		path = os.getcwd() + "/" + tutorial.replace(" ","-").lower() + "/"
		
		#Get all the pages
		pages = glob.glob(path + self.default_lang + "/*")
		
		#Loop through the pages
		count = 0
		for p in pages:
			if '_' in p:
				page = int(p.split('/')[-1].split('_')[0])
				if page > count:
					count = page
		
		#How many then?
		return count


	#Detect the language that the user is using.
	def detect_lang(self):
		#Return the language 
		return locale.getdefaultlocale()[0]
	
	
	#Detect the local dialect
	def load_dialect(self):
		
		#Dialects, start off empty
		dialects = {}
		
		#For all the possible paths
		for path in [os.path.join("/", "usr","share","ubuntu-tour","dialects", self.user_lang), os.path.join(os.getcwd(), "dialects", self.user_lang)]:
		
			#See if the dialect exists here
			if os.path.exists(path):
				#Read
				f = open(path, 'r')
				repls = f.read()
				f.close()
				
				#Loop through replacements
				for replace in repls.split('\n'):
					#Is it valid
					if '->' in replace:
						#Get the find and replace part
						r = replace.split('->', 1)
						
						#And clean then
						r[0] = r[0].strip()
						r[1] = r[1].strip()
						
						#And add to the dialect, provided there is something
						if len(r[0]) > 0:
							dialects[r[0]] = r[1]
		
		#All done, return the dialects
		return dialects
	
	
	#Convert text into the dialect
	def convert_to_dialect(self, text):
		self.p(self.dialect)
		
		#Create a regex search for words which need changing
		regex = '((.|\\r|\\n)(' + '|'.join(self.dialect.keys()) + ')(.|\\r|\\n))'
		
		#Make a note of softkeys to remove
		softkey_remove = []
		softkey = '@'
		
		#Loop through all items of the original language
		for i in re.findall(regex,text):
			#self.p(i)
			#Try and convert it
			try:
				#If it is being used in the html, then we should not change it. (Protection against colo(u)r and cent[re/er])
				if i[2] == 'color' and i[3] == '=':
					replace = i[0]
				if i[2] == 'center' and i[1] == '=':
					replace = i[0]
				
				#If prepended by an softkey symbol, then we don't convert
				elif i[1] == softkey:
					softkey_remove.append(i[2] + i[3])
					replace = i[0]
				
				#Otherwise, we convert
				else:
					replace = i[1] + self.dialect[i[2]] + i[3]
				
				#Go ahead and replace
				if i[0] != replace:
					self.p(i[0] + " to be replaced with " + replace)
					text = text.replace(i[0], replace)
			
			#If something goes wrong, complain quitly
			except Exception, e:
			
				#Error!!
				#TODO: this spams '' errors. Why?
				#self.p(e)
				pass
		
		#Now remove the softkeys
		for s in softkey_remove:
			text = text.replace(softkey + s, s)
		
		#And return the new text
		return text
	
	#Convert a plain text file to html
	def raw_to_html(self, text):
		
		#Convert line breaks
		text = text.replace('\n', '<br />\n')
		
		#Return
		return text
	
	
	#Convert html to plain
	def html_to_raw(self, text):
		
		#Convert line breaks
		text = text.replace('\r', '')
		text = text.replace('\r\n', '\n')
		text = text.replace('<br />\n', '\n')
		text = text.replace('<br />', '\n')
		
		#Return
		return text
	
	
	#Parse html, to get a whole page
	def parse_html(self, html, dark=False):
	
		#For Lightbox Effect: Search for screenshot tag and replace with img tag
		pattern			= r'''<screenshot([^"]+)src="([^"]+)"([^>]+)'''
		pattern_string	= re.compile(pattern)
		replace_string	= r'''<a id="lightbox" href="\2"><img src="\2" \1\3></a'''
		if re.search(pattern_string,html):
			html = re.sub(pattern_string,replace_string,html)

		#Get the html opening
		f = open(os.getcwd() + "/html/start.html",'r')
		start = f.read()
		f.close()
		
		#Get the html closing
		f = open(os.getcwd() + "/html/end.html",'r')
		end = f.read()
		f.close()
		
		#Get full html
		html = start + html + end
		
		#Parse colour
		if dark:
			html = html.replace('{{BACK-COLOUR}}', self.colours['background_t'][0])
			html = html.replace('{{TEXT-COLOUR}}', self.colours['foreground_t'][0])
		else:
			html = html.replace('{{BACK-COLOUR}}', self.colours['background'][0])
			html = html.replace('{{TEXT-COLOUR}}', self.colours['foreground'][0])
		
		#Return the combined html
		return html
	
	
	#Parse the colours
	def parse_colours(self):
		#Loop through them
		for k in self.colours.keys():
			#Get 64k colour hex
			hex = self.colours[k].to_string()
			
			#Convert to 256 colour hex
			if len(hex) == 13:
				hex = hex[0:3] + hex[5:7] + hex[9:11]
			
			#Set the colour
			self.colours[k] = (hex, self.colours[k])
	
	
	#Make the menu
	def make_menu(self, gui):
	
		#Load the gui
		self.gui = gui
		
		#Create a treeview
		self.tree_menu = gtk.TreeView()
		
		#Create a column
		self.tree_sections = gtk.TreeViewColumn("Chapters", gtk.CellRendererText(), text=0)
		self.tree_menu.append_column(self.tree_sections)
		
		self.tree_ids = gtk.TreeViewColumn("ID", gtk.CellRendererText(), text=1)
		self.tree_ids.set_visible(False)
		self.tree_menu.append_column(self.tree_ids)
		
		#Create the store
		self.update_menu()
			
		#Add a callback
		self.tree_menu.get_selection().connect("changed", self.row_selected)
		self.tree_menu.set_property("headers-visible", False)
		
		self.tree_menu.modify_base(gtk.STATE_NORMAL, self.colours['background'][1])
		self.tree_menu.modify_text(gtk.STATE_NORMAL, self.colours['foreground'][1])
		self.tree_menu.expand_all()
		
		#Append, if it's not already there
		child = self.gui.menuscroll.get_child()
		if child == None:
			self.gui.menuscroll.add(self.tree_menu)
		#self.gui.hbox.pack_start(self.tree_menu, False, True)
	
	
	#Make the menu
	def update_menu(self, rescan=True):
		
		#Get the tours
		if rescan:
			self.get_sections()
		
		#Create the store
		self.tree_store = gtk.TreeStore(str, int)
		
		#See how many times each catagory is used
		cat_count = {}
		for cat in self.catagories:
			cat_count[cat] = 0
		for t in self.tours:
			cat_count[t.parent] = 1
		
		#Catagories
		self.parents = {}
		self.tree_catagories = []
		self.children = {}
		for cat in self.catagories:
			if cat_count[cat] > 0:
				#Create the parent
				self.children[cat] = []
				self.tree_catagories.append(cat)
				
				#If it's not hidden, add it.
				if cat.lower() != 'hidden':
					self.parents[cat] = self.tree_store.append(None, [cat, -1])
		
		#Sort the tours
		self.sorted_tours = sorted(self.tours, cmp=lambda x,y: self.TourCmp(x, y))
		
		#Loop through the tours
		for t in self.sorted_tours:
			#Debug
			self.p(t.name)
			self.p(t.parent)
			
			#Add the parent if its not common
			if not t.parent in self.children.keys():
				if t.parent.lower() != 'hidden':
					self.parents[t.parent] = self.tree_store.append(None, [t.parent, -1])
				self.tree_catagories.append(t.parent)
				self.children[t.parent] = []
		
			#Add to tree store if its not a hidden tour
			if t.parent.lower() != 'hidden':
				self.tree_store.append(self.parents[t.parent], [t.name, t.id])
			
			#Add to list of parents children
			self.children[t.parent].append(t.id)
			
		#Set the model
		self.tree_menu.set_model(model=self.tree_store)
		
		#Expand
		self.tree_menu.expand_all()
	
	
	#A function to sort tours
	def TourCmp(self, a, b):
		#print a,b
		if a.pos < b.pos:
			return -1
		elif a.pos > b.pos:
			return 1
		else:
			return 0
	
	
	#Row selected callback
	def row_selected(self, selection, user_param=None):
		if len(selection.get_selected_rows()[1]) > 0:
			#Get the position
			pos = selection.get_selected_rows()[1][0]
			
			#Scroll to the selected value
			self.tree_menu.scroll_to_cell(pos)
			
			#What is the selected value
			if len(pos) == 2:
				try:
					self.load_page(self.children[self.tree_catagories[pos[0]+1]][pos[1]],0)
				except:
					self.p('Could not load ' + pos)