﻿#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import pygtk
if not sys.platform == 'win32':
	pygtk.require('2.0')
import gtk
import gobject
import re
import Image
import os
import shutil
import ConfigParser
import string
import glob
import webbrowser
import threading
import time
import xml.etree.ElementTree
import ArgImagePlugin
import BmpImagePlugin
import CurImagePlugin
import DcxImagePlugin
import EpsImagePlugin
import FliImagePlugin
import FpxImagePlugin
import GbrImagePlugin
import GifImagePlugin
import IcoImagePlugin
import ImImagePlugin
import ImtImagePlugin
import IptcImagePlugin
import JpegImagePlugin
import McIdasImagePlugin
import MicImagePlugin
import MpegImagePlugin
import MspImagePlugin
import PalmImagePlugin
import PcdImagePlugin
import PcxImagePlugin
import PdfImagePlugin
import PixarImagePlugin
import PngImagePlugin
import PpmImagePlugin
import PsdImagePlugin
import SgiImagePlugin
import SunImagePlugin
import TgaImagePlugin
import TiffImagePlugin
import WmfImagePlugin
import XVThumbImagePlugin
import XbmImagePlugin
import XpmImagePlugin

class FenetrePrincipale:
	def __init__(self, pref = [32, False, False, True, True, True, True, True, True, True, True, False]):
		#Configure l'affichage des icônes dans les boutons
		gtksettings = gtk.settings_get_default()
		gtksettings.set_long_property('gtk-button-images', 1, '')
		
		self.FramaKiosk = pref[3]
		self.AppsDir = pref[4]
		#Creation de la fenetre
		self.fenetre = gtk.Window()
		self.fenetre.set_title("FramaKioskTune " + str(version))
		self.fenetre.set_size_request(550, 350)
		self.fenetre.set_icon(gtk.gdk.pixbuf_new_from_file("img/FramaKioskTune.ico"))
		self.fenetre.connect("destroy", self.on_FenPrincipale_destroy)
		
		#Creation de la barre de menus
		self.MenuFichier =  gtk.Menu()
		self.MenuImport = gtk.Menu()
		self.MenuAide = gtk.Menu()
		
		self.Actualiser = gtk.ImageMenuItem("gtk-refresh")
		self.Actualiser.connect("activate", self.GenererArbre)
		self.Previsualiser = gtk.ImageMenuItem("gtk-find")
		self.Previsualiser.get_children()[0].set_label('P_révisualiser')
		self.Previsualiser.connect("activate", self.PrevisualiserFramaKiosk)
		self.Preferences = gtk.ImageMenuItem("gtk-preferences")
		self.Preferences.connect("activate", self.OuvrirPreferences)
		self.Enregistrer = gtk.ImageMenuItem("gtk-save")
		self.Enregistrer.connect("activate", self.on_Enregistrer_clicked)
		self.Quitter = gtk.ImageMenuItem("gtk-quit")
		self.Quitter.connect("activate", self.on_FenPrincipale_destroy)
		
		self.ImportApps = gtk.ImageMenuItem("gtk-open")
		self.ImportApps.get_children()[0].set_label('Dossier Apps')
		self.ImportApps.connect("activate", self.ImportAppsFolder)
		
		self.Aide = gtk.ImageMenuItem("gtk-help")
		self.Aide.get_children()[0].set_label('Docum_entation')
		self.Aide.connect("activate", self.OuvrirAide)
		
		self.APropos = gtk.ImageMenuItem("gtk-about")
		self.APropos.connect("activate", self.OuvrirFenAPropos)
		
		self.MenuFichier.append(self.Actualiser)
		#self.MenuFichier.append(self.Previsualiser)
		self.MenuFichier.append(self.Preferences)
		self.MenuFichier.append(self.Enregistrer)
		self.MenuFichier.append(self.Quitter)
		
		self.MenuImport.append(self.ImportApps)
		
		self.MenuAide.append(self.Aide)
		self.MenuAide.append(self.APropos)
		
		self.BarreMenus = gtk.MenuBar()
		
		self.Fichier = gtk.MenuItem("Fichier", True)
		self.Import = gtk.MenuItem("Importation", True)
		self.Aide = gtk.MenuItem("Aide", True)
		
		self.Fichier.set_submenu(self.MenuFichier)
		self.Import.set_submenu(self.MenuImport)
		self.Aide.set_submenu(self.MenuAide)
		
		self.BarreMenus.append(self.Fichier)
		#self.BarreMenus.append(self.Import)
		self.BarreMenus.append(self.Aide)
		
		#Creation de la barre d'etat
		self.BarreEtat = gtk.Statusbar()
		self.BarreEtat.push(1, "FramaKioskTune 0.3")
		
		#Creation du menu contextuel
		self.MenuContextuel = gtk.Menu()
		
		self.MenuAjouterOnglet = gtk.MenuItem("Ajouter un onglet")
		self.MenuAjouterApplication = gtk.MenuItem("Ajouter une application")
		self.MenuAjouterSeparateur = gtk.MenuItem("Ajouter un séparateur")
		self.MenuSupprimer = gtk.MenuItem("Supprimer")
		self.MenuProprietes = gtk.MenuItem("Propriétés")

		self.MenuContextuel.append(self.MenuAjouterOnglet)
		self.MenuContextuel.append(self.MenuAjouterApplication)
		self.MenuContextuel.append(self.MenuAjouterSeparateur)
		self.MenuContextuel.append(self.MenuSupprimer)
		self.MenuContextuel.append(self.MenuProprietes)
		
		self.MenuAjouterOnglet.connect("activate", self.NouvelOnglet)
		self.MenuAjouterApplication.connect("activate", self.NouvelleApp)
		self.MenuAjouterSeparateur.connect("activate", self.NouveauSeparateur)
		self.MenuSupprimer.connect("activate", self.Supprimer)
		self.MenuProprietes.connect("activate", self.Proprietes)

		self.MenuAjouterOnglet.show()
		self.MenuAjouterApplication.show()
		self.MenuAjouterSeparateur.show()
		self.MenuSupprimer.show()
		self.MenuProprietes.show()
		
		#Creation de la barre d'outils
		self.BarreOutils = gtk.Toolbar()
		self.BarreOutils.set_style(gtk.TOOLBAR_ICONS)
		
		self.ImgPrevisualiser = gtk.Image()
		self.ImgPrevisualiser.set_from_stock("gtk-find", gtk.ICON_SIZE_SMALL_TOOLBAR)
		self.ImgNewOnglet = gtk.Image()
		self.ImgNewOnglet.set_from_file("img/ajouteronglet.ico")
		self.ImgNewApp = gtk.Image()
		self.ImgNewApp.set_from_file("img/ajouterapp.ico")
		self.ImgNewSep = gtk.Image()
		self.ImgNewSep.set_from_file("img/ajoutersep.ico")
		
		self.OutilActualiser = gtk.ToolButton("gtk-refresh")
		self.OutilActualiser.connect("clicked", self.GenererArbre)
		self.OutilPrevisualiser = gtk.ToolButton(self.ImgPrevisualiser, "Previsualiser")
		self.OutilPrevisualiser.connect("clicked", self.PrevisualiserFramaKiosk)
		self.OutilPreferences = gtk.ToolButton("gtk-preferences")
		self.OutilPreferences.connect("clicked", self.OuvrirPreferences)
		self.OutilEnregistrer = gtk.ToolButton("gtk-save")
		self.OutilEnregistrer.connect("clicked", self.on_Enregistrer_clicked)
		self.OutilQuitter = gtk.ToolButton("gtk-quit")
		self.OutilQuitter.connect("clicked", self.on_FenPrincipale_destroy)
		
		self.OutilsSep1 = gtk.SeparatorToolItem()
		
		self.OutilNewOnglet = gtk.ToolButton(self.ImgNewOnglet, "Nouvel Onglet")
		self.OutilNewOnglet.connect("clicked", self.NouvelOnglet)
		self.OutilNewApp = gtk.ToolButton(self.ImgNewApp, "Nouvelle Application")
		self.OutilNewApp.connect("clicked", self.NouvelleApp)
		self.OutilNewSep = gtk.ToolButton(self.ImgNewSep, "Nouveau Separateur")
		self.OutilNewSep.connect("clicked", self.NouveauSeparateur)
		self.OutilSupprimer = gtk.ToolButton("gtk-remove")
		self.OutilSupprimer.connect("clicked", self.Supprimer)
		self.OutilProprietes = gtk.ToolButton("gtk-properties")
		self.OutilProprietes.connect("clicked", self.Proprietes)
		
		self.BarreOutils.insert(self.OutilActualiser, -1)
		#self.BarreOutils.insert(self.OutilPrevisualiser, -1)
		self.BarreOutils.insert(self.OutilPreferences, -1)
		self.BarreOutils.insert(self.OutilEnregistrer, -1)
		self.BarreOutils.insert(self.OutilQuitter, -1)
		
		self.BarreOutils.insert(self.OutilsSep1, -1)
		
		self.BarreOutils.insert(self.OutilNewOnglet, -1)
		self.BarreOutils.insert(self.OutilNewApp, -1)
		self.BarreOutils.insert(self.OutilNewSep, -1)
		self.BarreOutils.insert(self.OutilSupprimer, -1)
		self.BarreOutils.insert(self.OutilProprietes, -1)
		
		#Creation de l'arbre
		self.TreeStoreArbre = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, str, str, str, str, str, str)
		
		self.ArbreIconSize = pref[0]
		self.GenererArbre()
		
		self.Arbre = gtk.TreeView(self.TreeStoreArbre)
		self.Arbre.set_enable_search(False)
		self.Arbre.set_headers_clickable(False)
		self.Arbre.set_enable_tree_lines(pref[1])
		self.Arbre.connect("button_press_event", self.on_Arbre_clicked)
		
		
		self.ColonneNom = gtk.TreeViewColumn('Nom')
		self.ColonneNom.set_resizable(True)
		self.ColonneFichier = gtk.TreeViewColumn('Fichier')
		self.ColonneFichier.set_resizable(True)
		self.ColonneIcone = gtk.TreeViewColumn('Icone')
		self.ColonneIcone.set_resizable(True)
		self.ColonneApplication = gtk.TreeViewColumn('Application')
		self.ColonneApplication.set_resizable(True)
		self.ColonneExecutable = gtk.TreeViewColumn('Executable')
		self.ColonneExecutable.set_resizable(True)
		self.ColonneParametres = gtk.TreeViewColumn('Parametres')
		self.ColonneParametres.set_resizable(True)
		self.ColonneDossier = gtk.TreeViewColumn('Dossier')
		self.ColonneDossier.set_resizable(True)
		self.ColonneDescription = gtk.TreeViewColumn('Description')
		self.ColonneDescription.set_resizable(True)
		self.ColonneDescription.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
		self.ColonneType = gtk.TreeViewColumn('Type')
		self.Arbre.append_column(self.ColonneNom)
		self.Arbre.append_column(self.ColonneFichier)
		self.Arbre.append_column(self.ColonneIcone)
		self.Arbre.append_column(self.ColonneApplication)
		self.Arbre.append_column(self.ColonneExecutable)
		self.Arbre.append_column(self.ColonneParametres)
		self.Arbre.append_column(self.ColonneDossier)
		self.Arbre.append_column(self.ColonneDescription)
		self.Arbre.append_column(self.ColonneType)
		
		self.CellImgIcon = gtk.CellRendererPixbuf()
		self.CellNom = gtk.CellRendererText()
		self.CellNom.set_property('editable', True)
		self.CellNom.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 1))
		self.CellFichier = gtk.CellRendererText()
		self.CellFichier.set_property('editable', True)
		self.CellFichier.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 2))
		self.CellTextIcon = gtk.CellRendererText()
		self.CellTextIcon.set_property('editable', True)
		self.CellTextIcon.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 3))
		self.CellApplication = gtk.CellRendererText()
		self.CellApplication.set_property('editable', True)
		self.CellApplication.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 4))
		self.CellExecutable = gtk.CellRendererText()
		self.CellExecutable.set_property('editable', True)
		self.CellExecutable.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 5))
		self.CellParametres = gtk.CellRendererText()
		self.CellParametres.set_property('editable', True)
		self.CellParametres.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 6))
		self.CellDossier = gtk.CellRendererText()
		self.CellDossier.set_property('editable', True)
		self.CellDossier.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 7))
		self.CellDescription = gtk.CellRendererText()
		self.CellDescription.set_property('editable', True)
		self.CellDescription.connect('edited', self.CellRendererEdit, (self.TreeStoreArbre, 8))
		self.CellType = gtk.CellRendererText()
		
		self.ColonneNom.pack_start(self.CellImgIcon, True)
		self.ColonneNom.pack_start(self.CellNom, True)
		self.ColonneNom.add_attribute(self.CellImgIcon, 'pixbuf', 0)
		self.ColonneNom.add_attribute(self.CellNom, 'text', 1)
		self.ColonneNom.set_visible(pref[5])
		
		self.ColonneFichier.pack_start(self.CellFichier, True)
		self.ColonneFichier.add_attribute(self.CellFichier, 'text', 2)
		self.ColonneFichier.set_visible(pref[6])
		
		self.ColonneIcone.pack_start(self.CellTextIcon, True)
		self.ColonneIcone.add_attribute(self.CellTextIcon, 'text', 3)
		self.ColonneIcone.set_visible(pref[7])
		
		self.ColonneApplication.pack_start(self.CellApplication, True)
		self.ColonneApplication.add_attribute(self.CellApplication, 'text', 4)
		self.ColonneApplication.set_visible(pref[8])
		
		
		self.ColonneExecutable.pack_start(self.CellExecutable, True)
		self.ColonneExecutable.add_attribute(self.CellExecutable, 'text', 5)
		self.ColonneExecutable.set_visible(pref[9])
		
		self.ColonneParametres.pack_start(self.CellParametres, True)
		self.ColonneParametres.add_attribute(self.CellParametres, 'text', 6)
		self.ColonneParametres.set_visible(pref[10])
		
		self.ColonneDossier.pack_start(self.CellDossier, True)
		self.ColonneDossier.add_attribute(self.CellDossier, 'text', 7)
		self.ColonneDossier.set_visible(pref[11])
		
		self.ColonneDescription.pack_start(self.CellDescription, True)
		self.ColonneDescription.add_attribute(self.CellDescription, 'text', 8)
		self.ColonneDescription.set_visible(pref[12])
		
		self.ColonneType.pack_start(self.CellType, True)
		self.ColonneType.add_attribute(self.CellType, 'text', 9)
		self.ColonneType.set_visible(pref[13])
		
		self.Arbre.set_reorderable(True)
		
		#Creation de la Vbox principale (contient: Barre de menus - Barre d'outils - Arbre - Barre d'etat)
		self.vBox = gtk.VBox()
		self.vBox.pack_start(self.BarreMenus, False, False, 0)
		self.vBox.pack_start(self.BarreOutils, False, False, 0)
		self.DefilementArbre = gtk.ScrolledWindow()
		self.DefilementArbre.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
		self.DefilementArbre.add(self.Arbre)
		self.vBox.pack_start(self.DefilementArbre)
		self.vBox.pack_start(self.BarreEtat, False, False, 0)

		self.fenetre.add(self.vBox)
		
		#Affichage de la fenetre
		self.fenetre.show_all()
		
	def on_Arbre_clicked(self, treeview, event):
		if event.button == 3:
			x = int(event.x)
			y = int(event.y)
			time = event.time
			pthinfo = treeview.get_path_at_pos(x, y)
			if pthinfo is not None:
				path, col, cellx, celly = pthinfo
				treeview.grab_focus()
				treeview.set_cursor( path, col, 0)
				self.MenuContextuel.popup( None, None, None, event.button, time)
			else:
				self.MenuContextuel.popup( None, None, None, event.button, time)
			return 1

	def PrevisualiserFramaKiosk(self, widget):
		threading.Thread(None, self.threadStatusMessage, None, (), {"message":"Fonctionnalité indisponible"}).start()
		FenetrePrevisualisation()

	def NouvelOnglet(self, widget):
		selection = self.Arbre.get_selection()
		(modele, iter) = selection.get_selected()
		FenetreOnglet(iter, self.FramaKiosk, "Ajouter", self)

	def NouvelleApp(self, widget):
		selection = self.Arbre.get_selection()
		(modele, iter) = selection.get_selected()
		FenetreApplication(iter, self.FramaKiosk, self.AppsDir, "Ajouter", self)
		
	def NouveauSeparateur(self, widget):
		selection = self.Arbre.get_selection()
		(modele, iter) = selection.get_selected()
		FenetreSeparateur(iter, "Ajouter", self)

	def Supprimer(self, widget):
		selection = self.Arbre.get_selection()
		(modele, iter) = selection.get_selected()
		if self.TreeStoreArbre[modele.get_path(iter)][9] == "Séparateur":
			self.FenConfirmSuppr = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK_CANCEL, "Supprimer le " + string.lower(self.TreeStoreArbre[modele.get_path(iter)][9]) + " \"" + self.TreeStoreArbre[modele.get_path(iter)][1] + "\" du FramaKiosk?")
		else:
			self.FenConfirmSuppr = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK_CANCEL, "Supprimer l'" + string.lower(self.TreeStoreArbre[modele.get_path(iter)][9]) + " \"" + self.TreeStoreArbre[modele.get_path(iter)][1] + "\" du FramaKiosk?");
		result = self.FenConfirmSuppr.run()
		
		if(result == gtk.RESPONSE_OK):
			self.TreeStoreArbre.remove(iter)
			self.FenConfirmSuppr.destroy()
			threading.Thread(None, self.threadStatusMessage, None, (), {"message":"Elément supprimé"}).start()
		else:
			self.FenConfirmSuppr.destroy()
	
	def OuvrirPreferences(self, widget):
		FenetrePreferences(parent = self)
	
	def ImportAppsFolder(self, widget):
		threading.Thread(None, self.threadStatusMessage, None, (), {"message":"Fonctionnalité indisponible"}).start()
		
	def CellRendererEdit(self, celltext, chemin, nouveau_texte, donnees_utilisateur):
		liststore, colonne = donnees_utilisateur
		if (liststore[chemin][9] != "Séparateur" or colonne == 1) and (liststore[chemin][9] != "Onglet" or colonne == 1 or colonne == 2 or colonne == 3):
			liststore[chemin][colonne] = nouveau_texte
			if colonne == 3 and self.ArbreIconSize > 0:
				icone = nouveau_texte
				if liststore[chemin][9] == "Application":
					if icone != "":
						tmp = Image.open(FramaKiosk + "/FramaKioskPages/" + icone)
						if tmp.size[1] > tmp.size[0]:
							liststore[chemin][0] = gtk.gdk.pixbuf_new_from_file(FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(int(tmp.size[0]/(tmp.size[1]/float(self.ArbreIconSize))),self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
						else:
							liststore[chemin][0] = gtk.gdk.pixbuf_new_from_file(FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(self.ArbreIconSize,int(tmp.size[1]/(tmp.size[0]/float(self.ArbreIconSize))),gtk.gdk.INTERP_BILINEAR)
					else:
						liststore[chemin][0] = gtk.gdk.pixbuf_new_from_file("img/app.ico").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
				elif liststore[chemin][9] == "Onglet":
					if icone != "":
						result = re.findall(".*/([^/]*)\.[^/\.]*$", icone)
						if not os.path.isfile('cache/' + result[0] + str(self.ArbreIconSize) + '.png'):
							if self.ArbreIconSize <= 32:
								imgonglet = Image.open('img/onglet32.png')
								icon = Image.open(FramaKiosk + "/FramaKioskPages/" + icone)
								mask = icon.convert("L")
								mask = mask.point(lambda i: i > 0 and 255)
								imgonglet.paste(icon, (8, 8), mask)
							else:
								imgonglet = Image.open('img/onglet' + str(self.ArbreIconSize) + '.png')
								icon = Image.open(FramaKiosk + "/FramaKioskPages/" + icone)
								mask = icon.convert("L")
								mask = mask.point(lambda i: i > 0 and 255)
								imgonglet.paste(icon, ((self.ArbreIconSize - 16) / 2, (self.ArbreIconSize - 16) / 2), mask)
							imgonglet.save('cache/' + result[0] + str(self.ArbreIconSize) + '.png')
						liststore[chemin][0] = gtk.gdk.pixbuf_new_from_file('cache/' + result[0] + str(self.ArbreIconSize) + '.png').scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
					else:
						liststore[chemin][0] = gtk.gdk.pixbuf_new_from_file("img/onglet32.png").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
		
	def OuvrirFenAPropos(self, widget):
		self.FenAPropos = gtk.AboutDialog()
		self.FenAPropos.connect("response", lambda d, r: d.destroy())
		self.FenAPropos.set_version(str(version))
		self.FenAPropos.set_copyright("Copyright ©2005-2009 Framakey")
		self.FenAPropos.set_comments("Personnalisez votre FramaKiosk en toute simplicité!")
		fichierlicence = open("licence.txt")
		licence = fichierlicence.read()
		fichierlicence.close()
		self.FenAPropos.set_license(licence)
		self.FenAPropos.set_wrap_license(True)
		self.FenAPropos.set_website("http://www.framakey.org/")
		self.FenAPropos.set_authors(('Roromis',))
		self.FenAPropos.set_logo(gtk.gdk.pixbuf_new_from_file('img/FramaKioskTune.png'))
		self.FenAPropos.set_program_name("FramaKioskTune")
		self.FenAPropos.show_all()
		
	def OuvrirAide(self, widget):
		webbrowser.open('doc/documentation.html')
	
	def MajIcones(self, iter = None):
		if iter == None:
			childiter = self.TreeStoreArbre.get_iter_first()
		else:
			childiter = self.TreeStoreArbre.iter_children(iter)

		while childiter != None:
			icone = self.TreeStoreArbre[childiter][3]
			type = self.TreeStoreArbre[childiter][9]
			if self.ArbreIconSize > 0:
				if type == "Onglet":
					if icone != "" and os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + icone):
						result = re.findall(".*/([^/\\\\]*)\.[^/\\\\\\.]*$", icone)
						if not os.path.isfile('cache/' + result[0] + str(self.ArbreIconSize) + '.png'):
							if self.ArbreIconSize <= 32:
								imgonglet = Image.open('img/onglet32.png')
								icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
								mask = icon.convert("L")
								mask = mask.point(lambda i: i > 0 and 255)
								imgonglet.paste(icon, (8, 8), mask)
							else:
								imgonglet = Image.open('img/onglet' + str(self.ArbreIconSize) + '.png')
								icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
								mask = icon.convert("L")
								mask = mask.point(lambda i: i > 0 and 255)
								imgonglet.paste(icon, ((self.ArbreIconSize - 16) / 2, (self.ArbreIconSize - 16) / 2), mask)
							imgonglet.save('cache/' + result[0] + str(self.ArbreIconSize) + '.png')
						self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file('cache/' + result[0] + str(self.ArbreIconSize) + '.png').scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
					else:
						self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file("img/onglet" + str(self.ArbreIconSize) + ".png").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
				elif type == "Application":
						if icone != "" and os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + icone):
							tmp = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
							if tmp.size[1] > tmp.size[0]:
								self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(int(tmp.size[0]/(tmp.size[1]/float(self.ArbreIconSize))),self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
							else:
								self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(self.ArbreIconSize,int(tmp.size[1]/(tmp.size[0]/float(self.ArbreIconSize))),gtk.gdk.INTERP_BILINEAR)
						else:
							self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file("img/app.ico").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
			else:
				self.TreeStoreArbre[childiter][0] = gtk.gdk.pixbuf_new_from_file("img/vide.gif")
			self.MajIcones(childiter)
			childiter = self.TreeStoreArbre.iter_next(childiter)
		
	def FenetreSetSensitive(self, sensitive, message = None):
		self.BarreMenus.set_sensitive(sensitive)
		self.BarreOutils.set_sensitive(sensitive)
		self.Arbre.set_sensitive(sensitive)
		if sensitive == False and message == None:
			self.BarreEtat.set_sensitive(False)
		elif message == None:
			self.BarreEtat.set_sensitive(True)
			self.BarreEtat.pop(1)
			self.BarreEtat.push(1, "FramaKioskTune 0.3")
		else:
			self.BarreEtat.set_sensitive(True)
			self.BarreEtat.pop(1)
			self.BarreEtat.push(1, message)
			
		
	def on_Enregistrer_clicked(self, widget):
		self.FenetreSetSensitive(False, "Enregistrement des modifications en cours...")
		thread = threading.Thread(None, self.threadGenerate, None, (), {})
		thread.start()
		
	def threadGenerate(self):
		self.GenererFramaKiosk()
		self.FenetreSetSensitive(True, "Modifications enregistrées")
		threading.Thread(None, self.threadStatusMessage, None, (), {"message":"Modifications enregistrées"}).start()
		
	def GenererFramaKiosk(self, widget = None):
		shutil.rmtree("FramaKioskPages", True)
		self.GenererPageFramaKiosk()
		if self.erreur == False:
			self.DeplacerFramaKioskPages("FramaKioskPages")
		shutil.rmtree("FramaKioskPages", True)
		
	def DeplacerFramaKioskPages(self, path):
		l = glob.glob(path + '/*')
		for i in l: 
			if os.path.isdir(i):
				if not os.path.isdir(self.FramaKiosk + "/" + i):
					os.mkdir(self.FramaKiosk + "/" + i)
				self.DeplacerFramaKioskPages(i)
			else: 
				if os.path.isfile(self.FramaKiosk + "/" + i):
					os.remove(self.FramaKiosk + "/" + i)
				shutil.move(i, self.FramaKiosk + "/" + i)
		
	def GenererPageFramaKiosk(self, iter = None):
		source = ""
		self.erreur = False
		if not os.path.isdir("FramaKioskPages"):
			os.mkdir("FramaKioskPages")
		
		if iter == None:
			childiter = self.TreeStoreArbre.get_iter_first()
			maintype = self.TreeStoreArbre[0][9]
			file = "pages/index.html"
			newfile = "FramaKioskPages/index.html"
			i = 0
			if maintype == "Onglet":
				while childiter != None:
					type = self.TreeStoreArbre[childiter][9]
					if type != 'Onglet':
						if self.erreur == False:
							DialogErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Il ne peut y avoir que des onglets sur la page index.html.")
							DialogErreur.run()
							DialogErreur.destroy()
							self.Erreur = True
					else:
						if i == 0:
							debut = '\t<li class="ui-tabs-selected"><a href="' + self.TreeStoreArbre[childiter][2] + '"><span>'
						else:
							debut = '<li><a href="' + self.TreeStoreArbre[childiter][2] + '"><span>'
						if self.TreeStoreArbre[childiter][3] != "":
							fin = '<img class="chtiticone" src="' + self.TreeStoreArbre[childiter][3] + '"/>' + self.TreeStoreArbre[childiter][1] + '</span></a></li>\n\t'
						else:
							fin = self.TreeStoreArbre[childiter][1] + '</span></a></li>\n\t'
						source += debut + fin
					self.GenererPageFramaKiosk(childiter)
					childiter = self.TreeStoreArbre.iter_next(childiter)
					i += 1
				filesrc = open(file, "r")
				source = string.replace(filesrc.read(), "%DATA%", source)
				filesrc.close()
				filesrc = open(newfile, "w")
				filesrc.write(source)
				filesrc.close()
			else:
				if self.erreur == False:
					DialogErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Il ne peut y avoir que des onglets sur la page index.html. Copiez toutes les applications situées à la racine du FramaKiosk dans un onglet.")
					DialogErreur.run()
					DialogErreur.destroy()
					self.Erreur = True
		else:
			childiter = self.TreeStoreArbre.iter_children(iter)
			if childiter != None:
				newfile = "FramaKioskPages/" + self.TreeStoreArbre[iter][2]
				maintype = self.TreeStoreArbre[childiter][9]
				if maintype == "Onglet":
					file = "pages/page-onglets.html"
					while childiter != None:
						type = self.TreeStoreArbre[childiter][9]
						if type != 'Onglet':
							if self.erreur == False:
								DialogErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Il ne peut y avoir des onglets et des applications dans la même page, déplacez les applications dans un sous-onglet.")
								DialogErreur.run()
								DialogErreur.destroy()
								self.Erreur = True
						else:
							if self.TreeStoreArbre[childiter][3] != "":
								source += '<li><a href="' + self.TreeStoreArbre[childiter][2] + '"><span><img class="chtiticone" src="' + self.TreeStoreArbre[childiter][3] + '"/>' + self.TreeStoreArbre[childiter][1] + '</span></a></li>\n\t'
							else:
								source += '<li><a href="' + self.TreeStoreArbre[childiter][2] + '"><span>' + self.TreeStoreArbre[childiter][1] + '</span></a></li>\n\t'
						self.GenererPageFramaKiosk(childiter)
						childiter = self.TreeStoreArbre.iter_next(childiter)
					filesrc = open(file, "r")
					source = string.replace(filesrc.read(), "%DATA%", source)
					filesrc.close()
					filesrc = open(newfile, "w")
					filesrc.write(source)
					filesrc.close()
					
				elif maintype == "Application" or maintype == "Séparateur":
					file = "pages/page-apps.html"
					while childiter != None:
						type = self.TreeStoreArbre[childiter][9]
						if type == 'Séparateur':
							source += '\n\t<div class="separator">' + self.TreeStoreArbre[childiter][1] + '</div>\n'
						elif type == 'Application':
							source += '\n\t<div class="application">\n\t\t<div class="icone"><a href="' + self.TreeStoreArbre[childiter][2] + '" title="' + self.TreeStoreArbre[childiter][4] + ' - ' + self.TreeStoreArbre[childiter][8] + '"><img alt="' + self.TreeStoreArbre[childiter][4] + '" src="' + self.TreeStoreArbre[childiter][3] + '" /></a></div>\n\t\t<div class="description">' + self.TreeStoreArbre[childiter][1] + '</div>\n\t</div>\n'
							sourcelch = '[Launch]\nExecuteFile=' + self.TreeStoreArbre[childiter][5] + '\nExecuteDirectory=' + self.TreeStoreArbre[childiter][7] + '\nExecuteParameters=' + self.TreeStoreArbre[childiter][6]
							result = re.findall("([^/\\\\]*)[/\\\\]", self.TreeStoreArbre[childiter][2])
							chemin = "FramaKioskPages/"
							for i in range(len(result)):
								if not os.path.isdir(chemin + result[i]):
									os.mkdir(chemin + result[i])
								chemin += result[i] + '/'
							filelch = open("FramaKioskPages/" + self.TreeStoreArbre[childiter][2], "w")
							filelch.write(sourcelch)
							filelch.close()
						else:
							if self.erreur == False:
								DialogErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Il ne peut y avoir des onglets et des applications dans la même page, déplacez les applications dans un sous-onglet.")
								DialogErreur.run()
								DialogErreur.destroy()
								self.Erreur = True
						childiter = self.TreeStoreArbre.iter_next(childiter)
					filesrc = open(file, "r")
					source = string.replace(filesrc.read(), "%DATA%", source)
					filesrc.close()
					filesrc = open(newfile, "w")
					filesrc.write(source)
					filesrc.close()
				
				else:
					if self.erreur == False:
						DialogErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Le type \"" + maintype + "\" est inconnu.")
						DialogErreur.run()
						DialogErreur.destroy()
						self.Erreur = True

	def GenererArbre(self, widget = None):
		self.BarreEtat.pop(1)
		self.BarreEtat.push(1, "Actualisation en cours...")
		if os.path.isfile('FramaKioskTune.cfg'):
			config = ConfigParser.ConfigParser()
			config.read('FramaKioskTune.cfg')

			self.FramaKiosk = config.get('FramaKiosk', 'FramaKioskPath')
			self.AppsDir = config.get('FramaKiosk', 'AppsPath')
		self.TreeStoreArbre.clear()
		if os.path.isfile(self.FramaKiosk + '/FramaKioskPages/index.html'):
			self.ChercherOnglets("index.html")
		else:
			self.FenErreur = gtk.MessageDialog(self.fenetre, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Le fichier \"" + self.FramaKiosk + "/FramaKioskPages/index.html\" n'existe pas. Modifiez le chemin du FramaKiosk dans les préférences.");
			result = self.FenErreur.run()
			self.FenErreur.destroy()
		self.BarreEtat.pop(1)
		self.BarreEtat.push(1, "FramaKioskTune 0.3")
	
	def ChercherOnglets(self, fichier, iter = None):
		page = open(self.FramaKiosk + "/FramaKioskPages/" + fichier, "r")
		sourcePage = page.read()
		page.close()
		newiter = None
		result = re.findall('<li( class="ui-tabs-selected"|)><a href="([^>]*)"><span>(<img class="chtiticone" src="([^>]*)"/>|)([^<]*)</span></a></li>', sourcePage)
		for onglet in result:
			newiter = self.AjouterOnglet(onglet[4], onglet[1], onglet[3], iter, newiter)
			self.ChercherOnglets(onglet[1], newiter)
			self.ChercherApplications(onglet[1], newiter)
		
	def ChercherApplications(self, fichier, iter = None):
		page = open(self.FramaKiosk + "/FramaKioskPages/" + fichier, "r")
		sourcePage = page.read()
		page.close()
		result = re.findall('((<div class="icone"><a href="([^>]*)" title="[^"]* - ([^>]*)"><img alt="([^"]*)" src="([^"]*)" /></a></div>\s*<div class="description">([^<]*)</div>)|(<div class="separator">([^<]*)</div>))', sourcePage)
		newiter = None
		for app in result:
			if app[1] != "":
				lch = open(self.FramaKiosk + "/FramaKioskPages/" + app[2], "r")
				sourceLch = lch.read()
				lch.close()
				resultLch = re.findall('ExecuteFile=(.*)\s*ExecuteDirectory=(.*)\s*ExecuteParameters=(.*)', sourceLch)
				newiter = self.AjouterApplication(app[6], app[2], app[5], app[4], resultLch[0][0], resultLch[0][2], resultLch[0][1], app[3], iter, newiter)
			elif app[7] != "":
				newiter = self.AjouterSeparateur(app[8], iter, newiter)
	
	def AjouterOnglet(self, nom, fichier, icone, parent = None, prec = None):
		if self.ArbreIconSize > 0:
			if icone != "":
				result = re.findall(".*/([^/\\\\]*)\.[^/\\\\\\.]*$", icone)
				if not os.path.isfile('cache/' + result[0] + str(self.ArbreIconSize) + '.png'):
					if not os.path.isdir('cache'):
						os.mkdir('cache')
					if self.ArbreIconSize <= 32:
						imgonglet = Image.open('img/onglet32.png')
						icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
						mask = icon.convert("L")
						mask = mask.point(lambda i: i > 0 and 255)
						imgonglet.paste(icon, (8, 8), mask)
					else:
						imgonglet = Image.open('img/onglet' + str(self.ArbreIconSize) + '.png')
						icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
						mask = icon.convert("L")
						mask = mask.point(lambda i: i > 0 and 255)
						imgonglet.paste(icon, ((self.ArbreIconSize - 16) / 2, (self.ArbreIconSize - 16) / 2), mask)
					imgonglet.save('cache/' + result[0] + str(self.ArbreIconSize) + '.png')
				iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file('cache/' + result[0] + str(self.ArbreIconSize) + '.png').scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR), nom, fichier, icone, "", "", "", "", "", "Onglet"])
			else:
				iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file("img/onglet" + str(self.ArbreIconSize) + ".png").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR), nom, fichier, icone, "", "", "", "", "", "Onglet"])
		else:
			iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file("img/vide.gif"), nom, fichier, icone, "", "", "", "", "", "Onglet"])
		return iter
	
	def ModifierOnglet(self, nom, fichier, icone, iter):
		self.TreeStoreArbre[iter][1] = nom
		self.TreeStoreArbre[iter][2] = fichier
		self.TreeStoreArbre[iter][3] = icone
		if self.ArbreIconSize > 0:
			if icone != "":
				result = re.findall(".*/([^/\\\\]*)\.[^/\\\\\\.]*$", icone)
				if not os.path.isfile('cache/' + result[0] + str(self.ArbreIconSize) + '.png'):
					if not os.path.isdir('cache'):
						os.mkdir('cache')
					if self.ArbreIconSize <= 32:
						imgonglet = Image.open('img/onglet32.png')
						icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
						mask = icon.convert("L")
						mask = mask.point(lambda i: i > 0 and 255)
						imgonglet.paste(icon, (8, 8), mask)
					else:
						imgonglet = Image.open('img/onglet' + str(self.ArbreIconSize) + '.png')
						icon = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
						mask = icon.convert("L")
						mask = mask.point(lambda i: i > 0 and 255)
						imgonglet.paste(icon, ((self.ArbreIconSize - 16) / 2, (self.ArbreIconSize - 16) / 2), mask)
					imgonglet.save('cache/' + result[0] + str(self.ArbreIconSize) + '.png')
				self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file('cache/' + result[0] + str(self.ArbreIconSize) + '.png').scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
			else:
				self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file("img/onglet" + str(self.ArbreIconSize) + ".png").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
		else:
			self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file("img/vide.gif")
		return iter
		
	def AjouterApplication(self, nom, fichier, icone, app, exe, parametres, dossier, desc, parent = None, prec = None):
		if self.ArbreIconSize > 0:
			if icone != "":
				tmp = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
				if tmp.size[1] > tmp.size[0]:
					iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(int(tmp.size[0]/(tmp.size[1]/float(self.ArbreIconSize))),self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR), nom, fichier, icone, app, exe, parametres, dossier, desc, "Application"])
				else:
					iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(self.ArbreIconSize,int(tmp.size[1]/(tmp.size[0]/float(self.ArbreIconSize))),gtk.gdk.INTERP_BILINEAR), nom, fichier, icone, app, exe, parametres, dossier, desc, "Application"])
			else:
				iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file("img/app.ico").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR), nom, fichier, icone, app, exe, parametres, dossier, desc, "Application"])
		else:
			iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file("img/vide.gif"), nom, fichier, icone, app, exe, parametres, dossier, desc, "Application"])
		return iter
	
	def ModifierApplication(self, nom, fichier, icone, app, exe, parametres, dossier, desc, iter):
		self.TreeStoreArbre[iter][1] = nom
		self.TreeStoreArbre[iter][2] = fichier
		self.TreeStoreArbre[iter][3] = icone
		self.TreeStoreArbre[iter][4] = app
		self.TreeStoreArbre[iter][5] = exe
		self.TreeStoreArbre[iter][6] = parametres
		self.TreeStoreArbre[iter][7] = dossier
		self.TreeStoreArbre[iter][8] = desc
		
		if self.ArbreIconSize > 0:
			if icone != "":
				tmp = Image.open(self.FramaKiosk + "/FramaKioskPages/" + icone)
				if tmp.size[1] > tmp.size[0]:
					self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(int(tmp.size[0]/(tmp.size[1]/float(self.ArbreIconSize))),self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
				else:
					self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file(self.FramaKiosk + "/FramaKioskPages/" + icone).scale_simple(self.ArbreIconSize,int(tmp.size[1]/(tmp.size[0]/float(self.ArbreIconSize))),gtk.gdk.INTERP_BILINEAR)
			else:
				self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file("img/app.ico").scale_simple(self.ArbreIconSize,self.ArbreIconSize,gtk.gdk.INTERP_BILINEAR)
		else:
			self.TreeStoreArbre[iter][0] = gtk.gdk.pixbuf_new_from_file("img/vide.gif")
		
		return iter
		
	def AjouterSeparateur(self, nom, parent = None, prec = None):
		iter = self.TreeStoreArbre.insert_after(parent, prec, [gtk.gdk.pixbuf_new_from_file("img/vide.gif"), nom, "", "", "", "", "", "", "", "Séparateur"])
		return iter
		
	def ModifierSeparateur(self, nom, iter):
		self.TreeStoreArbre[iter][1] = nom
		return iter
			
	def SetPref(self, pref):
		self.MaJKiosk = pref[2]
		self.Arbre.set_enable_tree_lines(pref[1])
		self.ArbreIconSize = pref[0]
		
		self.FramaKiosk = pref[3]
		self.AppsDir = pref[4]
		
		self.ColonneNom.set_visible(pref[5])
		self.ColonneFichier.set_visible(pref[6])
		self.ColonneIcone.set_visible(pref[7])
		self.ColonneApplication.set_visible(pref[8])
		self.ColonneExecutable.set_visible(pref[9])
		self.ColonneParametres.set_visible(pref[10])
		self.ColonneDossier.set_visible(pref[11])
		self.ColonneDescription.set_visible(pref[12])
		self.ColonneType.set_visible(pref[13])
		
		self.MajIcones()
		
	def threadStatusMessage(self, message, seconds = 2):
		self.BarreEtat.pop(1)
		self.BarreEtat.push(1, message)
		time.sleep(seconds)
		self.BarreEtat.pop(1)
		self.BarreEtat.push(1, "FramaKioskTune 0.3")
		
	def Proprietes(self, widget):
		selection = self.Arbre.get_selection()
		(modele, iter) = selection.get_selected()
		if iter != None:
			type = self.TreeStoreArbre[modele.get_path(iter)][9]
			if type == "Séparateur":
				FenetreSeparateur(iter, "Modifier", self, self.TreeStoreArbre[modele.get_path(iter)][1])
			elif type == "Onglet":
				FenetreOnglet(iter, self.FramaKiosk,"Modifier", self, self.TreeStoreArbre[modele.get_path(iter)][1], self.TreeStoreArbre[modele.get_path(iter)][2], self.TreeStoreArbre[modele.get_path(iter)][3])
			elif type == "Application":
				FenetreApplication(iter, self.FramaKiosk, self.AppsDir, "Modifier", self, self.TreeStoreArbre[modele.get_path(iter)][1], self.TreeStoreArbre[modele.get_path(iter)][2], self.TreeStoreArbre[modele.get_path(iter)][3], self.TreeStoreArbre[modele.get_path(iter)][4], self.TreeStoreArbre[modele.get_path(iter)][5], self.TreeStoreArbre[modele.get_path(iter)][6], self.TreeStoreArbre[modele.get_path(iter)][7], self.TreeStoreArbre[modele.get_path(iter)][8])
		else:
			threading.Thread(None, self.threadStatusMessage, None, (), {"message":"Sélectionnez un élément dans l'arbre"}).start()
			
	def on_FenPrincipale_destroy(self, widget):
		gtk.main_quit()


class FenetrePreferences:
	def __init__(self, main = False, parent = None):
		self.parent = parent
		self.main = main
		self.FenetrePreferences = gtk.Builder()
		self.FenetrePreferences.add_from_file('glade/pref.glade')
		
		self.parent.FenetreSetSensitive(False, "Modification des préférences")
		
		self.FenPreferences = self.FenetrePreferences.get_object("FenPreferences")
		self.FenPreferences.set_transient_for(self.parent.fenetre)
		self.CheminFramaKiosk = self.FenetrePreferences.get_object("CheminFramaKiosk")
		self.CheminApps = self.FenetrePreferences.get_object("CheminApps")
		#self.MaJKioskXml = self.FenetrePreferences.get_object("MaJKioskXml")
		self.AfficherLignes = self.FenetrePreferences.get_object("AfficherLignes")
		self.IconSize = self.FenetrePreferences.get_object("IconSize")
		self.CheckColonneNom = self.FenetrePreferences.get_object("CheckColonneNom")
		self.CheckColonneFichier = self.FenetrePreferences.get_object("CheckColonneFichier")
		self.CheckColonneIcone = self.FenetrePreferences.get_object("CheckColonneIcone")
		self.CheckColonneApp = self.FenetrePreferences.get_object("CheckColonneApp")
		self.CheckColonneExe = self.FenetrePreferences.get_object("CheckColonneExe")
		self.CheckColonneParametres = self.FenetrePreferences.get_object("CheckColonneParametres")
		self.CheckColonneDossier = self.FenetrePreferences.get_object("CheckColonneDossier")
		self.CheckColonneDesc = self.FenetrePreferences.get_object("CheckColonneDesc")
		self.CheckColonneType = self.FenetrePreferences.get_object("CheckColonneType")
		
		config = ConfigParser.ConfigParser()
		try:
			config.read('FramaKioskTune.cfg')
			self.CheminFramaKiosk.set_text(config.get('FramaKiosk', 'FramaKioskPath'))
			self.CheminApps.set_text(config.get('FramaKiosk', 'AppsPath'))
			#self.MaJKioskXml.set_active(False)
			self.AfficherLignes.set_active(eval(config.get('FramaKioskTune', 'DisplayLines')))
			if config.get('FramaKioskTune', 'IconSize') != 0:
				self.IconSize.set_active(eval(config.get('FramaKioskTune', 'IconSize'))/16)
			else:
				self.IconSize.set_active(0)
			self.CheckColonneNom.set_active(eval(config.get('FramaKioskTune', 'ColonneNom')))
			self.CheckColonneFichier.set_active(eval(config.get('FramaKioskTune', 'ColonneFichier')))
			self.CheckColonneIcone.set_active(eval(config.get('FramaKioskTune', 'ColonneIcone')))
			self.CheckColonneApp.set_active(eval(config.get('FramaKioskTune', 'ColonneApp')))
			self.CheckColonneExe.set_active(eval(config.get('FramaKioskTune', 'ColonneExe')))
			self.CheckColonneParametres.set_active(eval(config.get('FramaKioskTune', 'ColonneParametres')))
			self.CheckColonneDossier.set_active(eval(config.get('FramaKioskTune', 'ColonneDossier')))
			self.CheckColonneDesc.set_active(eval(config.get('FramaKioskTune', 'ColonneDesc')))
			self.CheckColonneType.set_active(eval(config.get('FramaKioskTune', 'ColonneType')))
		except:
			self.CheminFramaKiosk.set_text("../../../Framakey/FramaKiosk/")
			self.CheminApps.set_text("../../")
			#self.MaJKioskXml.set_active(False)
			self.AfficherLignes.set_active(False)
			self.IconSize.set_active(2)
			self.CheckColonneNom.set_active(True)
			self.CheckColonneFichier.set_active(True)
			self.CheckColonneIcone.set_active(True)
			self.CheckColonneApp.set_active(True)
			self.CheckColonneExe.set_active(True)
			self.CheckColonneParametres.set_active(True)
			self.CheckColonneDossier.set_active(True)
			self.CheckColonneDesc.set_active(True)
			self.CheckColonneType.set_active(False)
			
		self.FenPreferences.show_all()
		self.FenetrePreferences.connect_signals(self)
	
	def on_BoutonEnregistrer_clicked(self, widget):
		pref = [self.IconSize.get_active() * 16, self.AfficherLignes.get_active(), False, self.CheminFramaKiosk.get_text(), self.CheminApps.get_text(), self.CheckColonneNom.get_active(), self.CheckColonneFichier.get_active(), self.CheckColonneIcone.get_active(), self.CheckColonneApp.get_active(), self.CheckColonneExe.get_active(), self.CheckColonneParametres.get_active(), self.CheckColonneDossier.get_active(), self.CheckColonneDesc.get_active(), self.CheckColonneType.get_active()]
		
		if not os.path.isdir(pref[3]):
			self.FenErreur = gtk.MessageDialog(self.FenPreferences, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Le dossier \"" + pref[3] + "\" n'existe pas.");
			result = self.FenErreur.run()
			self.FenErreur.destroy()
		elif not os.path.isdir(pref[4]):
			self.FenErreur = gtk.MessageDialog(self.FenPreferences, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Le dossier \"" + pref[4] + "\" n'existe pas.");
			result = self.FenErreur.run()
			self.FenErreur.destroy()
		else:
			config = ConfigParser.RawConfigParser()
			config.add_section('FramaKiosk')
			config.set('FramaKiosk', 'FramaKioskPath', pref[3])
			config.set('FramaKiosk', 'AppsPath', pref[4])
			config.set('FramaKiosk', 'MaJKiosk', False)
			
			config.add_section('FramaKioskTune')
			config.set('FramaKioskTune', 'DisplayLines', pref[1])
			config.set('FramaKioskTune', 'IconSize', pref[0])
			
			config.set('FramaKioskTune', 'ColonneNom', pref[5])
			config.set('FramaKioskTune', 'ColonneFichier', pref[6])
			config.set('FramaKioskTune', 'ColonneIcone', pref[7])
			config.set('FramaKioskTune', 'ColonneApp', pref[8])
			config.set('FramaKioskTune', 'ColonneExe', pref[9])
			config.set('FramaKioskTune', 'ColonneParametres', pref[10])
			config.set('FramaKioskTune', 'ColonneDossier', pref[11])
			config.set('FramaKioskTune', 'ColonneDesc', pref[12])
			config.set('FramaKioskTune', 'ColonneType', pref[13])
			
			with open('FramaKioskTune.cfg', 'wb') as configfile:
				config.write(configfile)
				
			if not self.main:
				FenPrincipale.SetPref(pref)
			self.FenPreferences.destroy()
		
	def on_BoutonFermer_clicked(self, widget):
		self.FenPreferences.destroy()
	
	def on_FenPreferences_destroy(self, widget):
		self.parent.FenetreSetSensitive(True)
		if self.main:
			self.main = False
			gtk.main_quit()

class FenetreApplication:
	def __init__(self, iter, FramaKiosk, AppsDir, action = "Ajouter", parent = None, nom = "", fichier = "", icone = "", app = "", exe = "", parametres = "", dossier = "", description = ""):
		self.parent = parent
		self.iter = iter
		self.FramaKiosk = FramaKiosk
		self.action = action
		self.AppsDir = AppsDir
		self.FenetreApplication = gtk.Builder()
		self.FenetreApplication.add_from_file('glade/app.glade')
		
		self.parent.FenetreSetSensitive(False, "Modification d'une application")
		
		self.FenApp = self.FenetreApplication.get_object("FenApp")
		self.FenApp.set_transient_for(self.parent.fenetre)
		self.Nom = self.FenetreApplication.get_object("Nom")
		self.Fichier = self.FenetreApplication.get_object("Fichier")
		self.Icone = self.FenetreApplication.get_object("Icone")
		self.Application = self.FenetreApplication.get_object("Application")
		self.Exe = self.FenetreApplication.get_object("Executable")
		self.Parametres = self.FenetreApplication.get_object("Parametres")
		self.Dossier = self.FenetreApplication.get_object("Dossier")
		self.Description = self.FenetreApplication.get_object("Description")
		self.BoutonAjouter = self.FenetreApplication.get_object("BoutonAjouter")
		
		self.Nom.set_text(nom)
		self.Fichier.set_text(fichier)
		self.Icone.set_text(icone)
		self.Application.set_text(app)
		self.Exe.set_text(exe)
		self.Parametres.set_text(parametres)
		self.Dossier.set_text(dossier)
		self.Description.set_text(description)
		
		self.FenApp.show_all()
		self.FenetreApplication.connect_signals(self)
	
	def on_RemplirApp_clicked(self, widget = None):
		app = self.Application.get_text()
		if os.path.isfile(self.FramaKiosk + "/FramaKioskPages/img/apps/Portable" + app + ".png"):
			self.Fichier.set_text("img/Apps/Portable" + app + ".png")
		if os.path.isfile(self.FramaKiosk + "/FramaKioskPages/lch/apps/Portable" + app + ".lch"):
			self.Fichier.set_text("lch/apps/Portable" + app + ".lch")
			self.on_RemplirFichier_clicked(None)
		elif os.path.isfile(self.AppsDir + "/Portable" + app + "/Portable" + app + ".exe"): 
			self.Fichier.set_text("${cwd}/../../../Apps/Portable" + app + "/Portable" + app + ".exe")
			self.on_RemplirExe_clicked(None)
	
	def on_RemplirExe_clicked(self, widget = None, lanceur = True):
		chemin = string.replace(self.Exe.get_text(), "${cwd}", self.AppsDir + "/PortableFirefox/firefox")
		chemin = string.replace(chemin, "\\", "/")
		if os.path.isfile(chemin):
			result = re.findall('(.*[/\\\\])([^/\\\\]*)\.[^/\\\\\.]*$', chemin)
			if os.path.isfile(result[0][0] + result[0][1] + "Kiosk/" + result[0][1] + ".xml"):
				Kiosk = xml.etree.ElementTree.parse(result[0][0] + result[0][1] + "Kiosk/" + result[0][1] + ".xml")
				app = Kiosk.find("parent_name")
				icone = Kiosk.find("logo/small")
				nom = Kiosk.find("desc/subtitle")
				description = Kiosk.find("desc/content")
				if app != None:
					if app.text != None:
						self.Application.set_text(app.text)
					else:
						self.Application.set_text(string.replace(result[0][1], "Portable", ""))
				else:
					self.Application.set_text(string.replace(result[0][1], "Portable", ""))
				if os.path.isfile(self.FramaKiosk + "/FramaKioskPages/img/apps/" + result[0][1] + ".png"):
					self.Icone.set_text("img/apps/" + result[0][1] + ".png")
				elif icone != None:
					if icone.text != None:
						if os.path.isfile(result[0][0] + result[0][1] + "Kiosk/" + icone.text):
							shutil.move(result[0][0] + result[0][1] + "Kiosk/" + icone.text, self.FramaKiosk + "/FramaKioskPages/img/apps/" + result[0][1] + ".png")
							self.Icone.set_text("img/apps/" + result[0][1] + ".png")
				if nom != None:
					if nom.text != None:
						self.Nom.set_text(nom.text)
				if description != None:
					if description.text != None:
						self.Description.set_text(description.text)
			if lanceur and os.path.isfile(self.FramaKiosk + "/FramaKioskPages/lch/apps/" + result[0][1] + ".lch"):
				self.Fichier.set_text("lch/apps/" + result[0][1] + ".lch")
				self.on_RemplirFichier_clicked(None, False)
		
	def on_RemplirFichier_clicked(self, widget = None, exe = True):
		if os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + self.Fichier.get_text()):
			lch = open(self.FramaKiosk + "/FramaKioskPages/" + self.Fichier.get_text(), "r")
			sourceLch = lch.read()
			lch.close()
			result = re.findall('ExecuteFile=(.*)\s*ExecuteDirectory=(.*)\s*ExecuteParameters=(.*)', sourceLch)
			if exe:
				self.Exe.set_text(result[0][0])
				self.on_RemplirExe_clicked(None, False)
			self.Parametres.set_text(result[0][2])
			self.Dossier.set_text(result[0][1])
		else:
			self.FenErreur = gtk.MessageDialog(self.FenApp, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Le fichier \"FramaKioskPages/" + self.Fichier.get_text() + "\" n'existe pas.");
			result = self.FenErreur.run()
			self.FenErreur.destroy()
		
	def on_ParcourirFichier_clicked(self, widget):
		self.FenSelectionnerFichier = gtk.FileChooserDialog("Fichier de l'application", self.FenApp, gtk.FILE_CHOOSER_ACTION_SAVE, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		result = re.findall("^(.*)[/\\\\][^/\\\\]*$", self.Fichier.get_text())
		if result != []:
			self.FenSelectionnerFichier.set_current_folder(self.FramaKiosk + "/FramaKioskPages/" + result[0])
		else:
			self.FenSelectionnerFichier.set_current_folder(self.FramaKiosk + "/FramaKioskPages/")
		reponse = self.FenSelectionnerFichier.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\FramaKioskPages\\\\(.*)$", self.FenSelectionnerFichier.get_filename())
			if result != []:
				result[0] = string.replace(result[0], "\\", "/")
				self.Fichier.set_text(result[0])
			else:
				self.Fichier.set_text(self.FenSelectionnerFichier.get_filename())
		self.FenSelectionnerFichier.destroy()

	def on_ParcourirExe_clicked(self, widget):
		self.FenSelectionnerExe = gtk.FileChooserDialog("Exécutable", self.FenApp, gtk.FILE_CHOOSER_ACTION_OPEN, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		result = re.findall("^(.*)[/\\\\][^/\\\\]*$", self.Exe.get_text())
		if result != []:
			self.FenSelectionnerExe.set_current_folder(self.AppsDir + result[0])
		else:
			self.FenSelectionnerExe.set_current_folder(self.AppsDir)
		
		reponse = self.FenSelectionnerExe.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\((Apps|Framakey|Data)\\\\.*)$", self.FenSelectionnerExe.get_filename())
			if result != []:
				self.Exe.set_text(("${cwd}\\..\\..\\..\\" + result[0][0]))
			else:
				self.Exe.set_text(self.FenSelectionnerExe.get_filename())
		self.FenSelectionnerExe.destroy()

	def on_ParcourirDossier_clicked(self, widget):
		self.FenSelectionnerDossier = gtk.FileChooserDialog("Dossier", self.FenApp, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		self.FenSelectionnerDossier.set_current_folder(self.AppsDir + self.Dossier.get_text())
		
		reponse = self.FenSelectionnerDossier.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\((Apps|Framakey|Data)\\\\.*)$", self.FenSelectionnerDossier.get_filename())
			if result != []:
				self.Dossier.set_text("${cwd}\\..\\..\\..\\" + result[0][0])
			else:
				self.Dossier.set_text(self.FenSelectionnerDossier.get_filename())
		self.FenSelectionnerDossier.destroy()

	def on_ParcourirIcone_clicked(self, widget):
		self.FenSelectionnerIcone = gtk.FileChooserDialog("Icone", self.FenApp, gtk.FILE_CHOOSER_ACTION_OPEN, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		result = re.findall("^(.*)[/\\\\][^/\\\\]*$", self.Icone.get_text())
		if result != []:
			self.FenSelectionnerIcone.set_current_folder(self.FramaKiosk + "/FramaKioskPages/" + result[0])
		else:
			self.FenSelectionnerIcone.set_current_folder(self.FramaKiosk + "/FramaKioskPages/")
		
		reponse = self.FenSelectionnerIcone.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\FramaKioskPages\\\\(.*)$", self.FenSelectionnerIcone.get_filename())
			if result != []:
				result[0] = string.replace(result[0], "\\", "/")
				self.Icone.set_text(result[0])
			else:
				self.Icone.set_text(self.FenSelectionnerIcone.get_filename())
		self.FenSelectionnerIcone.destroy()
		
	def on_BoutonAjouter_clicked(self, widget):
		if not os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + self.Icone.get_text()):
			self.FenErreur = gtk.MessageDialog(self.FenApp, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "L'icone \"FramaKioskPages/" + self.Icone.get_text() + "\" n'existe pas. Veuillez en selectionner une autre.");
			result = self.FenErreur.run()
			self.FenErreur.destroy()
		else:
			if self.action == "Ajouter":
				FenPrincipale.AjouterApplication(self.Nom.get_text(), self.Fichier.get_text(), self.Icone.get_text(), self.Application.get_text(), self.Exe.get_text(), self.Parametres.get_text(), self.Dossier.get_text(), self.Description.get_text(), None, self.iter)
			else:
				FenPrincipale.ModifierApplication(self.Nom.get_text(), self.Fichier.get_text(), self.Icone.get_text(), self.Application.get_text(), self.Exe.get_text(), self.Parametres.get_text(), self.Dossier.get_text(), self.Description.get_text(), self.iter)
			self.FenApp.destroy()
		
	def on_BoutonAnnuler_clicked(self, widget):
		self.FenApp.destroy()
		
	def on_FenApp_destroy(self, widget):
		self.parent.FenetreSetSensitive(True)

class FenetreOnglet:
	def __init__(self, iter, FramaKiosk, action = "Ajouter", parent = None, nom = "", fichier = "", icone = "img/apps/icons/kompozer.bmp"):
		self.parent = parent
		self.iter = iter
		self.action = action
		self.FramaKiosk = FramaKiosk
		self.FenetreOnglet = gtk.Builder()
		self.FenetreOnglet.add_from_file('glade/onglet.glade')
		
		self.parent.FenetreSetSensitive(False, "Modification d'un onglet")
		
		self.FenNewOnglet = self.FenetreOnglet.get_object("FenNewOnglet")
		self.FenNewOnglet.set_transient_for(self.parent.fenetre)
		self.Nom = self.FenetreOnglet.get_object("Nom")
		self.Fichier = self.FenetreOnglet.get_object("Fichier")
		self.Icone = self.FenetreOnglet.get_object("Icone")
		self.BoutonAjouter = self.FenetreOnglet.get_object("BoutonAjouter")
		
		self.Nom.set_text(nom)
		self.Fichier.set_text(fichier)
		self.Icone.set_text(icone)
		
		self.FenNewOnglet.show_all()
		self.FenetreOnglet.connect_signals(self)
	
	def on_Nom_changed(self, widget):
		self.Fichier.set_text(string.lower(self.Nom.get_text()) + ".html")
		
	def on_ParcourirFichier_clicked(self, widget):
		self.FenSelectionnerFichier = gtk.FileChooserDialog("Fichier de l'onglet", self.FenNewOnglet, gtk.FILE_CHOOSER_ACTION_SAVE, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		result = re.findall("^(.*)[/\\\\][^/\\\\]*$", self.Fichier.get_text())
		if result != []:
			self.FenSelectionnerFichier.set_current_folder(self.FramaKiosk + "/FramaKioskPages/" + result[0])
		else:
			self.FenSelectionnerFichier.set_current_folder(self.FramaKiosk + "/FramaKioskPages/")
		reponse = self.FenSelectionnerFichier.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\FramaKioskPages\\\\(.*)$", self.FenSelectionnerFichier.get_filename())
			if result != []:
				self.Fichier.set_text(result[0])
			else:
				self.Fichier.set_text(self.FenSelectionnerFichier.get_filename())
		self.FenSelectionnerFichier.destroy()

	def on_ParcourirIcone_clicked(self, widget):
		self.FenSelectionnerIcone = gtk.FileChooserDialog("Icone", self.FenNewOnglet, gtk.FILE_CHOOSER_ACTION_OPEN, ((gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK)))
		result = re.findall("^(.*)[/\\\\][^/\\\\]*$", self.Icone.get_text())
		if result != []:
			self.FenSelectionnerIcone.set_current_folder(self.FramaKiosk + "/FramaKioskPages/" + result[0])
		else:
			self.FenSelectionnerIcone.set_current_folder(self.FramaKiosk + "/FramaKioskPages/")
		
		reponse = self.FenSelectionnerIcone.run()
		
		if reponse == gtk.RESPONSE_OK:
			result = re.findall(".*\\\\FramaKioskPages\\\\(.*)$", self.FenSelectionnerIcone.get_filename())
			if result != []:
				result[0] = string.replace(result[0], "\\", "/")
				self.Icone.set_text(result[0])
			else:
				result = re.findall(".*[/\\\\]([^/\\\\]*)$", self.FenSelectionnerIcone.get_filename())
				if not os.path.isfile("/FramaKioskPages/img/apps/icons/" + result[0]):
					shutil.copyfile(self.FenSelectionnerIcone.get_filename(), self.FramaKiosk + "/FramaKioskPages/img/apps/icons/" + result[0])
				self.Icone.set_text("img/apps/icons/" + result[0])
		self.FenSelectionnerIcone.destroy()
		
	def on_BoutonAjouter_clicked(self, widget):
		if self.Icone.get_text() != "" and not os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + self.Icone.get_text()):
			self.FenErreur = gtk.MessageDialog(self.FenNewOnglet, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "L'icone \"FramaKioskPages/" + self.Icone.get_text() + "\" n'existe pas. Veuillez en selectionner une autre.");
			reponse = self.FenErreur.run()
			self.FenErreur.destroy()
		else:
			if self.action == "Ajouter":
				iter = FenPrincipale.AjouterOnglet(self.Nom.get_text(), self.Fichier.get_text(), self.Icone.get_text(), None, self.iter)
				if os.path.isfile(self.FramaKiosk + "/FramaKioskPages/" + self.Fichier.get_text()):
					self.FenErreur = gtk.MessageDialog(self.FenNewOnglet, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, "Le fichier \"FramaKioskPages/" + self.Fichier.get_text() + "\" existe. Voulez vous importer son contenu?");
					reponse = self.FenErreur.run()
					
					if reponse == gtk.RESPONSE_YES:
						FenPrincipale.ChercherOnglets(self.Fichier.get_text(), iter)
						FenPrincipale.ChercherApplications(self.Fichier.get_text(), iter)
					
					self.FenErreur.destroy()
			else:
				FenPrincipale.ModifierOnglet(self.Nom.get_text(), self.Fichier.get_text(), self.Icone.get_text(), self.iter)
			self.FenNewOnglet.destroy()
		
	def on_BoutonAnnuler_clicked(self, widget):
		self.FenNewOnglet.destroy()
		
	def on_FenNewOnglet_destroy(self, widget):
		self.parent.FenetreSetSensitive(True)

class FenetreSeparateur:
	def __init__(self, iter, action = "Ajouter", parent = None, nom = ""):
		self.parent = parent
		self.iter = iter
		self.action = action
		self.FenetreSeparateur = gtk.Builder()
		self.FenetreSeparateur.add_from_file('glade/separateur.glade')
		
		self.parent.FenetreSetSensitive(False, "Modification d'un séparateur")
		
		self.FenNewSeparateur = self.FenetreSeparateur.get_object("FenNewSeparateur")
		self.FenNewSeparateur.set_transient_for(self.parent.fenetre)
		self.Nom = self.FenetreSeparateur.get_object("Nom")
		self.BoutonAjouter = self.FenetreSeparateur.get_object("BoutonAjouter")
		
		self.Nom.set_text(nom)
		
		self.FenNewSeparateur.show_all()
		self.FenetreSeparateur.connect_signals(self)
		
	def on_BoutonAjouter_clicked(self, widget):
		if self.action == "Ajouter":
			FenPrincipale.AjouterSeparateur(self.Nom.get_text(), None, self.iter)
		else:
			FenPrincipale.ModifierSeparateur(self.Nom.get_text(), self.iter)
		self.FenNewSeparateur.destroy()
		
	def on_BoutonAnnuler_clicked(self, widget):
		self.FenNewSeparateur.destroy()
		
	def on_FenNewSeparateur_destroy(self, widget):
		self.parent.FenetreSetSensitive(True)

class FenetrePrevisualisation:
	def __init__(self):
		self.FenPrev = gtk.Window()
		self.FenPrev.set_title("Prévisualisation")
		self.FenPrev.set_size_request(743, 515)
		self.FenPrev.set_icon(gtk.gdk.pixbuf_new_from_file("img/FramaKioskTune.ico"))
		
		self.Moz = gtkmozembed.MozEmbed()
		
		self.FenPrev.Add(self.Moz)
		self.Moz.load_url('http://forum.framasoft.org')

		
version = 0.3

if __name__ == "__main__":
	gtk.gdk.threads_init()
	gtk.gdk.threads_enter()
	if not os.path.isfile('FramaKioskTune.cfg'):
		FenetrePreferences(True)
		gtk.main()
	if os.path.isfile('FramaKioskTune.cfg'):
		
		config = ConfigParser.ConfigParser()
		config.read('FramaKioskTune.cfg')
		FramaKiosk = config.get('FramaKiosk', 'FramaKioskPath')
		AppsDir = config.get('FramaKiosk', 'AppsPath')

		pref = [eval(config.get('FramaKioskTune', 'IconSize')), eval(config.get('FramaKioskTune', 'DisplayLines')), eval(config.get('FramaKiosk', 'MajKiosk')), config.get('FramaKiosk', 'FramaKioskPath'), config.get('FramaKiosk', 'AppsPath'), eval(config.get('FramaKioskTune', 'ColonneNom')), eval(config.get('FramaKioskTune', 'ColonneFichier')), eval(config.get('FramaKioskTune', 'ColonneIcone')), eval(config.get('FramaKioskTune', 'ColonneApp')), eval(config.get('FramaKioskTune', 'ColonneExe')), eval(config.get('FramaKioskTune', 'ColonneParametres')), eval(config.get('FramaKioskTune', 'ColonneDossier')), eval(config.get('FramaKioskTune', 'ColonneDesc')), eval(config.get('FramaKioskTune', 'ColonneType'))]
		
		FenPrincipale = FenetrePrincipale(pref)
		gtk.main()
	gtk.gdk.threads_leave()
