#! /usr/bin/python2.7
# coding: utf8

##########################################################################
#########                      dPluzz+  v1.7.10                   ########
#########                                                         ########
#########                 licence : open source (GPL)             ########
#########                           @gaara                        ########
#########                           Lulux3                        ########
#########                      yoggic@wanadoo.fr                  ########
######### http://forum.ubuntu-fr.org/viewtopic.php?id=1559861&p=1 ########
##########################################################################

import pygtk
pygtk.require('2.0')
import gtk
import gtk.gdk
import gobject
import subprocess
import shutil
import os
import glob
import vte
import time
from datetime import date
import sys
import re
import urllib
from bs4 import BeautifulSoup
import platform
import fnmatch
import json
import urllib2
import textwrap
from collections import defaultdict
import math
import cairo
import unicodedata
from pprint import pprint
import pango
import requests
import unidecode  ## python-unidecode


# extraction de(s) argument(s)
arguments = sys.argv
nbr_arg = len(sys.argv)-1

version = "1.7.10"
versioncli = "1.5.3"

usage = """
  ------   dPluzz v """ + version + """   ------
  Téléchargement des vidéos Pluzz et C+

            --MODE GUI--
           dpluzz <option>
                 ou
               dpluzz
        Options disponibles:
       -h --help: Cette aide
       -d --debug: Debug mode

     -- MODE TERMINAL v """ + versioncli + """ --
  usage: dpluzz-cli [OPTIONS] [-u|--url] URL
Pour en savoir plus: dpluzz-cli -h|--help 

"""

class bcolors:
    HEADER = '\033[95m'
    NEW = '\033[55m'
    OKBLUE = '\033[94m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    
if nbr_arg == 0:
   debug = 0
   pass
elif nbr_arg == 1:
   arg1 = sys.argv[1]
   if arg1 == "-d" or arg1 == "--debug":
     print bcolors.WARNING + "dPluzz Mode Debug" + bcolors.ENDC
     debug = 1
     pass
   elif arg1 == "-h" or arg1 == "--help":
     print usage
     exit()
   elif arg1 != "-d" or arg1 != '-h' or arg1 != "--help" or arg1 != "--debug":
     print bcolors.WARNING + "Veuillez vérifier votre syntaxe" + bcolors.ENDC
     print usage
     exit()
elif nbr_arg >= 1:
   print usage
   exit()

    
class dPluzz():
     
      
      def ffmpeg_actif(self, widget, donnees=None):
          if self.check.get_active():
             self.option_ffmpeg = "ffmpeg True"
          if self.check_av.get_active():
             self.option_ffmpeg = "ffmpeg False"
          
      def set_encodeur_mp3(self, widget, donnees=None):
          if self.radio_encodeur_mp3.get_active():
             self.option_mp3 = "mp3 True"
          
      def set_encodeur_aac(self, widget, donnees=None):
          if self.radio_encodeur_aac.get_active():
             self.option_mp3 = "mp3 False"
      
      def set_encodeur_video(self, widget, donnees=None):
          if self.radio_encodeur_copy.get_active():
             self.option_encodeur_video = "copy"
          if self.radio_encodeur_x264.get_active():
             self.option_encodeur_video = "x264"
      
      def radio_conteneur_video_mkv(self, widget, donnees=None):
          if self.radio_codec_video_mkv.get_active():
             self.option_conteneur_video = "mkv"
    
      def radio_conteneur_video_mp4(self, widget, donnees=None):
          if self.radio_codec_video_mp4.get_active():
             self.option_conteneur_video = "mp4"
             
      def set_mode_sstitre(self, widget, donnees=None):
          if self.radio_mode_sstitre_srt.get_active():
             self.option_mode_sstitre = "srt"
          if self.radio_mode_sstitre_ass.get_active():
             self.option_mode_sstitre = "ass"
          if self.radio_mode_sstitre_mux.get_active():
             self.option_mode_sstitre = "mux"
          while gtk.events_pending():
               gtk.main_iteration()
          
      def pre_download(self, dPluzz, donnees=None): 
          term = self.v
          page_num = self.notebook.get_current_page()
          if page_num == 0:
             self.chaine = "Pluzz"
             self.barre = self.pbar
          elif page_num == 1:
             self.chaine = "Canal"
             self.barre = self.pbar_canal
          elif page_num == 2:
             self.chaine = "Multi"
             self.barre = self.pbar_multi
          self.percent = 0
          self.bouton_vider.set_sensitive(False)
          self.cli = "/usr/share/dPluzz/dPluzz-cli.sh"
          if self.chaine == "Pluzz":
              adresse = self.champ.get_text()
              if adresse == '' and self.dict_adresse != [[],[]]:
                 for listadr in self.dict_adresse:
                    for adr in listadr:
                       adresse = adr
              valide = ["https://www.france.tv/"]
          elif self.chaine == "Canal":
              adresse = self.champ_adr_canal.get_text()
              valide = ["http://www.canalplus.fr"]
          elif self.chaine == "Multi":
              adresse = self.champ_multi.get_text()
              valide = ["www.nrj12.fr", "replay.gulli.fr", "francetvinfo.fr", "www.france.tv", "dailymotion.com", "http://www.6play.fr/", "publicsenat.fr", "http://www.lcp.fr/", "arte.tv", "c8.fr", "cstar.fr", "itele.fr", "d8.tv", "d17.tv", "6play.fr", "nrj-play.fr", "lequipe.fr", "numero23.fr", "tv5mondeplus.com", "tv5mondeplusafrique.com"]
          while gtk.events_pending():
               gtk.main_iteration()
          for v in valide:
            if not v in adresse:
              compatible = False
            else: 
              compatible = True 
              break  
          self.champ.set_icon_from_stock(1, gtk.STOCK_STOP)
          while gtk.events_pending():
                 gtk.main_iteration()
          self.iterdebut = self.buffertexte.get_end_iter()
          if compatible == False: 
             if self.chaine == "Pluzz":
                  self.buffertexte.set_text('')
                  self.message = 'Veuillez entrer une adresse valide,\ncommençant par "https://www.france.tv/"'
             elif self.chaine == "Multi":
                  self.message = "Veuillez entrer une adresse valide parmi les chaines proposées !"
             elif self.chaine == "Canal":
                  self.message = 'Veuillez entrer une adresse valide,\ncommençant par "http://www.canalplus.fr"'
             self.titre_fenetre = "Erreur"
             self.fenetre_message(self)
          else:    
             self.liste_adresse = []
             if self.chaine == "Pluzz" and self.dict_adresse != [[],[]]:
                for listadr in self.dict_adresse:
                    for adr in listadr:
                       self.liste_adresse.append(adr)
             else: 
                self.liste_adresse = [adresse]
             self.download(self)
              
      def download(self, dPluzz, donnees=None): 
                 try:
                    self.fenetre_sstitre.destroy()
                 except:
                    pass
                 self.choix_sstitre = self.choix_sstitre.replace(' ','')
                 if self.choix_vo == "voFalse":
                    vo = ''
                 else:
                    vo = '--vo'
                 if self.choix_sstitre == "sstitreFalse":
                    st = ''
                    stlang = ''
                 else:
                    st = '--subtitle-lang'
                    stlang = 'vf'
                 if self.option_encodeur_video == "copy":
                    vid_cont_codec = '--video-codec'
                    codec = 'copy'
                 else:
                    vid_cont_codec = '--video-codec'
                    codec = "libx264"
                 if self.option_conteneur_video == "mkv":
                    vid_cont_cmd = ''
                    vid_cont = ''
                 else:
                    vid_cont_cmd = '--video-container'
                    vid_cont = 'mp4'
                 if self.choix_sstitre == "sstitreTrue":
                    mod_stt_cmd = '--subtitle-mode'
                    mod_sst = self.option_mode_sstitre
                 else:
                    mod_stt_cmd = ''
                    mod_sst = ''
                 if self.choix_suppr_video == "garder_videoTrue":
                    clean = '--no-cleaning'
                 else:
                    clean = ''    
                 if self.option_ffmpeg == "ffmpegTrue" or self.option_ffmpeg == "ffmpeg True":
                    moteur = '-f'
                 else:
                    moteur = ''
                 if self.option_mp3 == "mp3True":
                    codec_aud = 'mp3'
                 else:
                    codec_aud = 'aac'
                 self.bouton8.set_sensitive(False)
                 for adr in self.liste_adresse[:]:
                    self.adresse_en_cours = adr
                    self.barre.set_text("Démarrage, veuillez patienter...")
                    self.child_pid = self.v.fork_command("clear")
                    self.champ.set_icon_from_stock(1, gtk.STOCK_APPLY)
                    dest = self.rep + "/"
                    self.annul = 0
                    self.time = 0
                    self.temps_val = 'init'
                    self.barre.set_fraction(0)
                    if debug == 1:
                        v = "-v"
                        ess = "-> Pour avoir un retour complet du téléchargement, veuillez essayer cette ligne dans un terminal:"
                    else:
                        v = ""
                    interpreter = '/bin/bash' 
                    list_com = [interpreter, self.cli, vid_cont_codec, codec, vid_cont_cmd, vid_cont, clean, moteur, st, stlang, mod_stt_cmd, mod_sst, vo, '--audio-codec', codec_aud, '-d', dest, '-u', self.adresse_en_cours]
                    list_com2 = []
                    for com in list_com:
                        if com != '':
                           list_com2.append(com)
                    self.child_pid = self.v.fork_command(None, list_com2)
                    if self.child_pid == -1:
                        self.child_pid = self.v.fork_command("/bin/bash", list_com2)
                    if debug == 1:
                       print bcolors.WARNING
                       pprint(list_com2)
                       print bcolors.ENDC
                       #while not os.path.exists(self.home + '/.cache/dPluzz/log/debug.log'):
                       #   time.sleep(1)
                       #with open(self.home + '/.cache/dPluzz/log/debug.log', "r") as log:
                       #   adresse_vid = log.read(200)
                       #   adresse_vid = adresse_vid.replace("\n", "")
                       #   if adresse_vid == " " or adresse_vid == "":
                       #      print bcolors.WARNING + ess + bcolors.ENDC
                       #      print bcolors.HEADER + "ping -c 5 www.pluzz.fr" + "\n" + bcolors.ENDC
                       #   else:
                       #      print bcolors.WARNING + ess + bcolors.ENDC
                       #      print bcolors.HEADER + "ffmpeg -y -i " + adresse_vid + " -vcodec copy -acodec copy " + dest + "essai.mkv" + "\n" + bcolors.ENDC
                       #   log.close()
                    
                    #self.progress(self, dPluzz)
                    #self.barre.set_text("Démarrage, veuillez patienter...")
                    self.barre.set_fraction(0)
                    while gtk.events_pending():
                        gtk.main_iteration()
                    self.bouton8.set_sensitive(False)
                    self.bouton9.set_sensitive(False)
                    self.bouton_annul.set_sensitive(True)
                    self.bouton_annul_multi.set_sensitive(True)
                    self.bouton_an_canal.set_sensitive(True)
                    self.champ.set_editable(False)
                    while self.child_pid != 1:
                       time.sleep(0.5)
                       while gtk.events_pending():
                           gtk.main_iteration()
                    try:
                       self.liste_adresse.remove(adr)
                    except:
                       pass
                    if self.liste_adresse != []:
                            g = 0
                            while g < 65:
                                self.barre.pulse()
                                while gtk.events_pending():
                                    gtk.main_iteration()
                                time.sleep(0.1)
                                g = g+1
                       
                    elif self.annul == 1:
                            self.barre.set_text("Annulé")
                            self.barre.set_fraction(0)
                            while gtk.events_pending():
                                gtk.main_iteration()

                    # suppression de l'adresse à la fin de chaque téléchargement
                    for adresse in self.liste_adresse:
                            if self.liste_adresse.index(adresse) == 0:
                                self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                                self.buffertexte_liste.set_text(adresse + '\n')
                            else:
                                self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                                self.buffertexte_liste.insert(self.iterdebut_liste, adresse + '\n')
                    if self.liste_adresse == []:
                            self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                            self.buffertexte_liste.set_text("")
                            self.champ.set_text("")
                            self.bouton_vider.set_sensitive(True)
                            self.vider(self)
                    if self.liste_adresse == []:
                            self.bouton8.set_sensitive(True)
                            self.bouton9.set_sensitive(True)
                 
      def dwld_continue(self, dPluzz, donnees=None): 
                  self.fenetre_sstitre.hide()
                  #self.check_sub.set_active(False)
                  self.bouton8.set_sensitive(True)
                  self.bouton9.set_sensitive(True)
                  self.bouton_vider.set_sensitive(True)
                     
      def preterm(self, dPluzz, donnees=None):
          if hasattr(self, 'term_has_executed'): 
              self.term_has_executed = True
              return
          else:
              try:
                 del self.term_has_executed
              except: pass
              self.term(self)
          
      def term(self, dPluzz, donnees=None):
          text = str(self.v.get_text(lambda *a: True).rstrip())
          if debug == 1:
              print text
          lignes = text.split("\n")
          for l in lignes:
              text = l
              if 'Cette vidéo est a priori vérrouillée' in l:
                 self.barre.set_text("Vidéo protégée par DRM")
                 self.term_has_executed = True
                 self.message = "Il semble que cette vidéo soit protégée par DRM." + "\n" + "Il est impossible de la télécharger pour des raisons de droits d'auteur."
                 self.titre_fenetre = "Impossible de télécharger"
                 self.fenetre_message(self)
                 break
          self.percent_float = 0
          if 'Obtention des informations' in text:
              self.barre.set_fraction(0)
              self.barre.set_text("Démarrage...")
          if "Téléchargement" in text and self.percent_float == 0:
              self.barre.set_text("Téléchargement...")
          if "Progression" in text:
              line = text.rsplit("Progression:",1)[1]
              line = line.replace(' ','')
              line = line.replace('%','')
              try:
                 self.percent_float = float(line)
                 entier = int(round(self.percent_float))
                 self.percent_float = self.percent_float/100
                 self.barre.set_text("Téléchargement: " + str(entier) + "%")
                 self.barre.set_fraction(self.percent_float)
                 self.percent = self.percent_float
              except:
                 pass 
          if "Réessayer plus tard" in text:
              self.barre.set_text("Erreur")
              self.bouton8.set_sensitive(True)
              self.bouton9.set_sensitive(True)
          if 'Succès !' in text:
              self.percent_float = 1
              self.percent = 100
              self.barre.set_fraction(1)
              self.barre.set_text("Terminé !")
          if 'Échec !' in text:
              self.barre.set_text("Échec du téléchargement")
          if 'zone géographique bloquée' in text:
              self.barre.set_text("Zone géographique bloquée")
          if "cookies' supprimé" in text and self.percent == 0:
              self.barre.set_text("Échec du téléchargement")
          #while gtk.events_pending():
              #gtk.main_iteration()
      
      def verif(self, dPluzz, donnees=None):        
          self.champ.set_editable(True)
          self.bouton8.set_sensitive(True)
          self.bouton9.set_sensitive(True)
          self.bouton_apercu_multi.set_sensitive(True)
          self.bouton_apercu_pluzz.set_sensitive(True)
          self.bouton_ap_canal.set_sensitive(True)
          self.percent = self.percent*100
          try:
              if self.percent >= 100:
                  self.barre.set_fraction(1)
              elif self.annul == 0 and self.percent == 0:
                  self.barre.set_fraction(0)
          except IOError as e:
              print e
              pass
          while gtk.events_pending():
              gtk.main_iteration()
          if self.annul == 0:
             if self.percent != 0 and len(self.liste_adresse) == 1:
                if self.environ == "XFCE" or self.environ == "LXDE":
                   titre = "'dPluzz+'"
                else:
                   titre = "'>dPluzz+'"
                cmd = 'notify-send ' + titre + ' --icon "/usr/share/icons/dPluzz-ico.png" -t 3000 "Téléchargement terminé"'
                p = subprocess.call(cmd, shell=True)
             self.bouton_annul.set_sensitive(False)
             self.bouton_an_canal.set_sensitive(False)
             self.child_pid = 1
             if self.arg != "" and self.arg != "rien":
                self.nom_fichier(self, dPluzz)
          elif self.percent < 99:
                 if self.annul == 0:
                    self.barre.set_text("Interrompu")
                    while gtk.events_pending():
                     gtk.main_iteration()
                 if self.percent != 0:
                    if self.environ == "XFCE" or self.environ == "LXDE":
                       titre = "'dPluzz+'"
                    else:
                       titre = "'dPluzz+'"
                    cmd = 'notify-send ' + titre + ' --icon "/usr/share/icons/dPluzz-ico.png" -t 10000 "Le téléchargement a été interrompu !"'
                    p = subprocess.call(cmd, shell=True)
                    self.child_pid = 1
                 self.annul = 1
                 
      def copy_term(self, dPluzz, donnees=None):
          text = str(self.v.get_text(lambda *a: True).rstrip())
          clipboard = gtk.Clipboard()
          clipboard.set_text(text, -1)
          
      def pre_recherche(self, completion, model, iter):         
         if debug == 1:
             print "Cliquez sur Rechercher"
         
      def fenetre_patientez(self, dPluzz, donnees=None):
          time.sleep(0.5)
          if self.patienter == 1:
                self.window_patienter = gtk.Window(gtk.WINDOW_POPUP)
                self.window_patienter.connect('size-allocate', self.reshaperect2)
                self.window_patienter.set_transient_for(self.fenetre)
                self.window_patienter.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
                main_vbox = gtk.VBox(False, 1) 
                
                self.window_patienter.add(main_vbox)
                hbox = gtk.HBox(False, 0)
        
                etiquette = gtk.Label("")
                text = "\n"+"""<big><b>  Recherche en cours... </b></big>"""+"\n"
                etiquette.set_markup(text)
                etiquette.set_alignment(0.5, 0.5)
                etiquette.set_justify(gtk.JUSTIFY_CENTER)
        
                main_vbox.pack_start(etiquette, True, True)
        
                self.screen_patientez = self.window_patienter.get_screen()
                colormap = self.screen_patientez.get_rgba_colormap()
                if (colormap is not None and self.screen_patientez.is_composited()):
                    self.window_patienter.set_colormap(colormap)
                self.window_patienter.set_app_paintable(True)
                self.window_patienter.connect("expose-event", self.area_draw2)
                self.window_patienter.show_all()
          elif self.patienter == 0:
                time.sleep(0.5)
                self.window_patienter.destroy()
      
      def reshaperect2(self, obj, allocation):    
        w,h = allocation.width, allocation.height
        bitmap = gtk.gdk.Pixmap(None, w, h, 1)
        fg = gtk.gdk.Color(pixel=0)
        bg = gtk.gdk.Color(pixel=-1)
        fg_gc = bitmap.new_gc(foreground=fg, background=bg)
        bitmap.draw_rectangle(fg_gc, True, 0, 0, w, h)
        padding=2
        rounded=10
        cr = bitmap.cairo_create()
        cr.set_source_rgb(0,0,0)
        cr.move_to(0+padding+rounded, 0+padding)
        cr.line_to(w-padding-rounded, 0+padding)
        cr.arc(w-padding-rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.line_to(w-padding, h-padding-rounded)
        cr.arc(w-padding-rounded, h-padding-rounded, rounded, 0, math.pi/2)
        cr.line_to(0+padding+rounded, h-padding)
        cr.arc(0+padding+rounded, h-padding-rounded, rounded, math.pi+math.pi/2, math.pi)
        cr.line_to(0+padding, 0+padding+rounded)
        cr.arc(0+padding+rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.fill()
        self.window_patienter.shape_combine_mask(bitmap, 0, 0)
        self.window_patienter.show()
        
      def area_draw2(self, widget, event):
        cr = widget.get_window().cairo_create()
        cr.set_source_rgba(1, 1, 1, 1)
        cr.set_operator(cairo.OPERATOR_SOURCE)
        cr.paint()
        cr.set_operator(cairo.OPERATOR_OVER)
        return False
              
      def recherche(self, dPluzz, donnees=None):
          self.patienter = 1
          self.fenetre_patientez(self)
          i = 0
          for func in self.list_fonct:
              self.bouton[i].hide()
              self.label[i].hide()
              self.img[i].hide()
              i+=1
          self.champ_recherche_pluzz.set_progress_fraction(0)
          self.pos_clic = []
          if self.choix_taillehl == "petite False":             
             i = 0
             for func in self.list_fonct:
                self.bouton[i].disconnect_by_func(self.list_fonct[i])
                self.bouton[i].set_active(False)
                self.bouton[i].connect("clicked", self.list_fonct[i])
                i += 1
             if self.num_objets_clic != []:
                for i in range(0, len(self.list_fonct)):
                   self.img[i].hide()
                   self.bouton[i].hide()
                   self.label[i].hide()
             self.url_list_pre = []
             if self.dict_adresse == [[],[]]:
                self.vider(self)
          elif self.choix_taillehl == "petite True":
             if len(self.liste_mots) == 1:
                self.liste_mots = []
             for row in self.liststore:
                self.liststore.remove(row.iter)
          self.choice = []
          self.champ.set_text("")
          self.champ.set_icon_from_stock(1, gtk.STOCK_INFO)
          self.iterdebut = self.buffertexte.get_end_iter()
          self.buffertexte.set_text("")
          try:
             self.barre.set_text("")
             self.barre.set_fraction(0)
             while gtk.events_pending():
                gtk.main_iteration()
          except:
             pass
          while gtk.events_pending():
             gtk.main_iteration()
          expression = self.champ_recherche_pluzz.get_text()
          emission = expression
          expression = expression.replace(' ','-')
          expression = expression.replace(',','')
          expression = expression.replace(':','')
          expression = expression.replace('?','')
          expression = expression.replace('!','')
          expression = expression.replace("'",'-')
          expression = expression.strip(',.').lower()
          expression = expression.replace('é','e')
          expression = expression.replace('à','a')
          expression = expression.replace('ê','e')
          expression = expression.replace('ï','i')
          expression = expression.replace('ë','e')
          expression = expression.replace('ô','o')
          expression = expression.replace('ö','o')
          expression = expression.replace('ä','a')
          expression = expression.replace('è','e')
          expression = expression.replace('ç','c')
          expression = expression.replace('ù','u')
          expression = expression.replace('--','-')
          
          list_lien_trouve=[]
          for lien in self.liens_accueil:
              if expression[0:10] in lien:
                  lien_trouve = expression[0:10]
                  list_lien_trouve.append(lien)
              else:
                  lien = "pas trouvé"
              if 'html' in lien:
                  for n in range(5):
                    lien_trouve = lien.split(str(n), 1)[0]
                  list_lien_trouve.append(lien_trouve)
                  
          list_lien_trouve = list(set(list_lien_trouve))
          self.url_list_pre = list_lien_trouve
          mots = expression.split(' ')
          self.liste_mots.append(expression)
          self.nbre_mot = len(self.liste_mots)          
          if expression == "":
             self.iterdebut = self.buffertexte.get_end_iter()
             self.buffertexte.set_text("Vous devez remplir le champ!")
          expression = expression.replace("'"," ")
          
          self.links = {}
          self.titre_mem = []
          self.bouton_mem = []
          self.mem_ID = []
          self.list_url = []
          self.list_link_image = []
          self.list_titres = []
          self.image_mem = []
          self.list_emission = []
          self.list_url_verif = []
          
          lien2 = ""
          n=0
          i=0
          for url in list_lien_trouve:
            if "films" in url:
                self.champ.set_text("Cette vidéo est un film payant")
                break
            try:
                f = requests.get(url)
                soup = BeautifulSoup(f.text,"lxml")
                result = soup.findAll('a')
                if len(result) == 0:
                    self.champ.set_text("Aucun résultat")
                self.index1 = 0
                self.index2 = 0
                expression = unicode(expression)
                expression = unidecode.unidecode(expression)
                expression = expression.replace(' ','-')
                expression = expression.lower()
            
                def affichage(locals, donnees=None):
                    self.loader = gtk.gdk.PixbufLoader()
                    def taille(locals):
                        self.loader.set_size(80, 80)
                        self.loader.write(self.response.read())
                        self.loader.close()
                    opener = urllib2.build_opener()
                    opener.addheaders = [('User-agent', 'Mozilla/5.0')]
                    self.response = opener.open(link_image, self.home + "/.cache/dPluzz/img/" + str(nom_img))
                    taille(locals)
                    self.img[i].set_from_pixbuf(self.loader.get_pixbuf())
                    self.label[i].set_justify(gtk.JUSTIFY_CENTER)
                    titre_t = '-' + emission + '-' + '\n' + titre
                    if len(titre_t) > 31:
                        titre_a = ' '.join(titre_t[:31+1].split(' ')[0:-1])
                        titre_b = titre_t.replace(titre_a,'')
                        if len(titre_b) > 31:
                            titre_b = ' '.join(titre_b[:28+1].split(' ')[0:-1]) + '...'
                        self.label[i].set_text(titre_a + "\n" + titre_b)
                    else:
                        self.label[i].set_text(titre_t)
                    self.boite_img[i].show()
                    self.bouton[i].show()
                    self.label[i].show()
                    self.img[i].show()
                    while gtk.events_pending():
                        gtk.main_iteration()
             
                for x in result:
                        if expression in str(x):
                            try:
                                lien_brut = x['href']
                            except:
                                break
                            
                            if lien_brut[0:1] == '/' and lien_brut[0:2] != '//':
                                lien_video = 'https://www.france.tv'+lien_brut
                            elif 'http://sport' in lien_brut:
                                lien_brut = lien_brut.replace('http', 'https')
                                lien_video = lien_brut
                            else:
                                lien_video = "https:"+lien_brut
                            if not 'mailto' in lien_video and not 'facebook' in lien_video and not 'twitter' in lien_video and not '#' in lien_video and not 'casting-events' in lien_video and not 'instagram' in lien_video:
                                verif = requests.get(lien_video)
                                soup_verif = BeautifulSoup(verif.text,"lxml")
                                result_verif = soup_verif.findAll(['a', 'div', 'p', 'span', 'img', 'title'],attrs={"class":u"label label_xs label_xs_long label_blue w_130 brown_b mb_15"})
                                if len(lien_trouve) == 1:
                                    result_verif = lien_trouve
                                for y in result_verif:
                                    if "disponible" in str(y):
                                        if not any(lien_video in s for s in self.list_url_verif):
                                            result_data = soup.findAll(['a', 'div', 'p', 'span', 'img', 'title'])
                                            try:
                                                titre = x['title']
                                            except:
                                                titre = expression
                                            try:
                                                a = x.find_all('img')
                                                for y in a:
                                                    link_image = "https:"+str(a[0]['data-flickity-lazyload'])
                                                    if link_image:
                                                        break
                                            except:
                                                link_image = 'https://www.france.tv/images/placeholder-800x800.png'
                                            nom_img = titre.replace(" ","_")
                                            nom_img = "img_" + str(self.index1) + nom_img[:10] + ".jpg"
                                            self.nom_img = nom_img
                                            self.list_url_verif.append(lien_video)
                                            self.list_url.append(lien_video)
                                            self.list_titres.append(titre)
                                            self.image_mem.append(nom_img)
                                            #self.mem_ID.append(self.id)
                                            self.list_emission.append(emission)
                                            if self.choix_taillehl == "petite False":
                                                affichage(self)
                                            else:
                                                self.liststore.append([emission])
                                                self.emission = emission
                                                pass
                                            i+=1   
                        else:
                            pass
            except IOError as e:
                 print e
                 pass
                 self.iterdebut = self.buffertexte.get_end_iter()
                 self.buffertexte.set_text("Il y a eu une erreur.")
          self.patienter = 0
          self.fenetre_patientez(self)

      def result_recherche(self, dPluzz, donnees=None):
         try:
            if self.choix_taillehl == "petite False":
               for i in range(0, 41):
                  self.bouton[i].set_active(False)  
               pos = self.position
               #print pos
               
               url = self.list_url[pos]
               titre = self.list_titres[pos]
               emission = self.list_emission[pos]
               
               #print emission, titre, url
               self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
               self.buffertexte_liste.insert(self.iterdebut_liste, "Non disponible")
               self.buffertexte.set_text("Non disponible")
               
            else:
               #pprint(self.list_emission)
               #pprint(self.list_url)
               emission = self.liste.get_active_text()
               i=0
               for e in self.list_emission:
                   if emission == e:
                       pos = i
                   i = i+1    
               url = self.list_url[pos]
            self.champ.set_text(url)   
         except IOError as e:
               print e
               pass
      
      def infos(self, dPluzz, donnees=None):
          if self.dict_adresse == [] or self.dict_adresse == [[],[]]:
             self.position = 0
             #self.champ_recherche_pluzz.set_text("ATTENTION: Téléchargement multiple impossible dans ce mode")
             adresse0 = self.champ.get_text()
             if not 'https://france.tv/' in adresse0:
                self.champ.set_text("Vous devez remplir le champ de l'adresse!")
             else:
                for k in self.dict_adresse:
                   k.append(adresse0)
                   break
                self.detail(self)
                time.sleep(0.5)
                self.aff_liste(self)
          else:
             fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
             fenetre.set_position(gtk.WIN_POS_CENTER)    
          
             #Titre et icone
             fenetre.set_title('Aide')
             fenetre.set_default_size(300, 100)
             fenetre.set_border_width(10)
             fenetre.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
          
             #boite et texte
             box = gtk.HBox()
             fenetre.add(box)#, True, True, 0)
             #text = """ATTENTION,\nCe mode ne permet pas le téléchargement multiple.\nVeuillez vider la liste pour continuer."""
             etiquette = gtk.Label (text)
             etiquette.set_alignment(0.05, 0.5)
             etiquette.set_justify(gtk.JUSTIFY_CENTER)
             box.pack_start(etiquette, True, True, 0)
             etiquette.show()
          
             box.show()
             fenetre.show() 
             
      def vo(self,widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_vo=choix
          
      def soustitre(self,widget, donnees=None):
          try:
             self.choix_sstitre = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
             if self.choix_sstitre == "sstitre True":
                self.radio_mode_sstitre_mux.set_sensitive(True)
                self.radio_mode_sstitre_ass.set_sensitive(True)
                self.radio_mode_sstitre_srt.set_sensitive(True)
                self.radio_mode_sstitre_srt.set_active(True)
             elif self.choix_sstitre == "sstitre False":
                self.option_mode_sstitre = 'aucun'
                self.radio_mode_sstitre_srt.set_active(False)
                self.radio_mode_sstitre_ass.set_active(False)
                self.radio_mode_sstitre_mux.set_active(False)
                while gtk.events_pending():
                   gtk.main_iteration()
                self.radio_mode_sstitre_mux.set_sensitive(False)
                self.radio_mode_sstitre_ass.set_sensitive(False)
                self.radio_mode_sstitre_srt.set_sensitive(False)
          except:
             pass 
          
      def soustitre_malent(self,widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_sstitre_malent=choix
                   
      def detail(self, dPluzz, donnees=None):
          self.bouton8.set_sensitive(True)
          self.bouton9.set_sensitive(True)
          self.iterdebut = self.buffertexte.get_end_iter()
          self.buffertexte.set_text("")
          if self.choix_taillehl == "petite True":
             pos = self.liste.get_active()
             try:
                adresse = self.url_list_pre[pos]
             except:
                adresse = self.champ.get_text()
          if self.choix_taillehl == "petite False":
             pos = self.position
             try:
                adresse = self.url_list_pre[pos]
             except:
                adresse = self.champ.get_text()
          # trouver l'adresse du json
          if adresse != '':
             try:
                ID = self.id_list[pos]
             except:
                ID = re.search('%s(.*)%s' % (",", ".html"), adresse).group(1)
             adresse_json = "http://webservices.france.tv/tools/getInfosOeuvre/v2/?idDiffusion=" + ID + "&catalogue=Pluzz&callback=webserviceCallback_" + ID
             try:
                # télécharger le json 
                json_obj = urllib.URLopener()
                json_obj.addheaders = [("User-Agent", "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:44.0) Gecko/20100101 Firefox/44.0")]
                json_obj.retrieve(adresse_json, self.home + "/.cache/dPluzz/file.json")
          
                #ouvrir le fichier
                myFile = open(self.home + "/.cache/dPluzz/file.json", "r")
                json_line = myFile.read()
                myFile.close()
          
                # nettoyage json
                json_line = json_line.replace("webserviceCallback_"+ID+"(","")
                json_line = (repr(json_line))
                json_line = json_line[1:-2]
                json_line = json_line.replace("\\'","'")
             
                data = json.loads(json_line)
             
                # Tri et Affichage des infos
                genre = data["genre"]
                synopsis = data["synopsis"]
                sous_titre = data["sous_titre"]
                duree = data["duree"]
                episode = data["episode"]
                chaine = data["chaine"]
                saison = data["saison"]
                titre = data["titre"]
                diffusion = data["diffusion"]["date_debut"]
                code_programme = data["code_programme"]

                def unicodize(seg):
                	if re.match(r'\\u[0-9a-f]{4}', seg):
                		return seg.decode('unicode-escape')
                	return seg.decode('utf-8')
  
                replaced_genre = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',genre))
                replaced_synopsis = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',synopsis))
                replaced_sous_titre = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',sous_titre))
                replaced_duree = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',duree))
                replaced_chaine = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',chaine))
                replaced_titre = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',titre))
                replaced_code_programme = (unicodize(seg) for seg in re.split(r'(\\u[0-9a-f]{4})',code_programme))
          
                genre = (''.join(replaced_genre))
                synopsis = (''.join(replaced_synopsis))
                sous_titre = (''.join(replaced_sous_titre))
                duree = (''.join(replaced_duree))
                chaine = (''.join(replaced_chaine))
                titre = (''.join(replaced_titre))
                self.code_programme = (''.join(replaced_code_programme))
                diffusion = diffusion.replace("\\", "")
             
                drm = data["videos"][0]["drm"]
                if drm == True:
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.textview.set_justification(gtk.JUSTIFY_CENTER)
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.buffertexte.set_text("ATTENTION: Il est possible que cette vidéo soit protégée par DRM.")
                	self.textview.set_justification(gtk.JUSTIFY_LEFT)
                self.iterdebut = self.buffertexte.get_end_iter()
                if drm != True:
                    self.buffertexte.set_text(" -Programme: " + titre)
                elif drm == True:
                    self.buffertexte.insert(self.iterdebut, "\n" + " -Programme: " + titre)
                self.iterdebut = self.buffertexte.get_end_iter()
                self.buffertexte.insert(self.iterdebut, "\n" + " -Chaine: " + chaine)
                self.iterdebut = self.buffertexte.get_end_iter()
                self.buffertexte.insert(self.iterdebut, "\n" + " -Genre: " + genre)
                if sous_titre != "":
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.buffertexte.insert(self.iterdebut, "\n" + " -Sous titre: " + sous_titre)
                	self.sous_titre = sous_titre
                	self.sous_titre = sous_titre
                else:
                	self.sous_titre = ""
                if saison != None:
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.buffertexte.insert(self.iterdebut, "\n" + " -Saison: " + str(saison))
                	if saison < 10:
                		saison = "0" + str(saison)
                	self.saison = 'S' + str(saison)
                else:
                	self.saison = ""
                if episode != None:
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.buffertexte.insert(self.iterdebut, "\n" + " -Épisode: " + str(episode))
                	if episode < 10:
                		episode = "0" + str(episode)
                	self.episode = 'E' + str(episode)
                else:
                	self.episode = ""
                if synopsis != "":
                	synopsis = synopsis.replace('\\n', '\n')
                	self.iterdebut = self.buffertexte.get_end_iter()
                	self.buffertexte.insert(self.iterdebut, "\n" + " -Synopsis: " + synopsis)
          
                self.iterdebut = self.buffertexte.get_end_iter()
                self.buffertexte.insert(self.iterdebut, "\n" + " -Diffusé le " + diffusion[:10] + " à" + diffusion[10:16])
                    
                self.iterdebut = self.buffertexte.get_end_iter()
                self.buffertexte.insert(self.iterdebut, "\n" + " -Durée: " + duree)
                self.heure = diffusion[10:16]
                list_detail = [ID, titre, sous_titre, diffusion, self.heure, self.episode, self.saison]
                for listadresse in self.dict_adresse:
                	for adr in listadresse:
                		if adr == adresse:
                		   for obj in list_detail:
                			self.liste_details[adresse].append(obj)
             except IOError as e:
                 if debug == 1:
                     print bcolors.FAIL
                     print e
                     print bcolors.ENDC
                 self.message = """Le service est indisponible""" + "\n" + "(http error 404)." + "\n" + "La vidéo ne pourra pas être renommée."
                 self.titre_fenetre = """Service indisponible"""
                 self.fenetre_message(self)
                 
      def fenetre_message(self,widget, donnees=None):         
         self.window_message = gtk.Window(gtk.WINDOW_TOPLEVEL)
         self.window_message.set_position(gtk.WIN_POS_CENTER)    
         self.window_message.set_title(self.titre_fenetre)
         self.window_message.set_default_size(200, 150)
         self.window_message.set_border_width(10)
         self.window_message.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
         box = gtk.VBox()
         self.window_message.add(box)
         etiquette = gtk.Label (self.message)
         etiquette.set_alignment(0, 0.8)
         etiquette.set_justify(gtk.JUSTIFY_CENTER)
         box.pack_start(etiquette, True, True, 0)
         etiquette.show()
         box.show()
         box_btn = gtk.HButtonBox()
         box.add(box_btn)
         bouton_continue = gtk.Button("OK")
         bouton_continue.connect("clicked", self.kill_fenetre_message, "bouton A")
         box_btn.pack_start(bouton_continue, True, True, 0)
         bouton_continue.show()
         box_btn.show()
         self.window_message.show()
             
      def kill_fenetre_message(self,widget, donnees=None):
         try:
             del self.term_has_executed
             if self.message == "Il semble que cette vidéo soit protégée par DRM." + "\n" + "Il est impossible de la télécharger pour des raisons de droits d'auteur.":
                 self.child_pid = self.v.fork_command("clear")
         except:
             pass
         self.window_message.destroy()       
             
      def supprim_adr(self,widget, donnees=None):
         if self.dict_adresse[1] == []:
            del self.dict_adresse[0][-1]
         elif self.dict_adresse[1] != []:
            del self.dict_adresse[-1][-1]
         self.aff_liste(self)
         if self.dict_adresse == [[],[]]:
            self.vider(self)
         
      def aff_liste(self, dPluzz, donnees=None):
         for listadr in self.dict_adresse:
            if self.dict_adresse.index(listadr) == 0:
               for adr in listadr:
                  if listadr.index(adr) == 0:
                     self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                     self.buffertexte_liste.set_text(adr + '\n')
                  else:
                     self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                     self.buffertexte_liste.insert(self.iterdebut_liste, adr + '\n')
                     self.iterdebut = self.buffertexte.get_end_iter()
                     self.buffertexte.set_text("")
            if self.dict_adresse.index(listadr) == 1:
                     for adr in listadr:
                        self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                        self.buffertexte_liste.insert(self.iterdebut_liste, adr + '\n')
         if self.dict_adresse == [] or self.dict_adresse == [[],[]]:
                   self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
                   self.buffertexte_liste.set_text("")
                   self.champ.set_text("")
      
      def dossier(self, choixdossier, donnees=None):
          self.selectdossier = gtk.FileChooserDialog(title="Sélection du dossier de réception",
                                        buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
          self.selectdossier.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
          filtre = gtk.FileFilter()
          filtre.set_name("Folder")
          filtre.add_pattern("*")
          self.selectdossier.add_filter(filtre)
          reponse = self.selectdossier.run()
          if reponse == gtk.RESPONSE_OK:
              self.choixdossier(self, reponse)
              self.selectdossier.destroy()
          elif reponse == gtk.RESPONSE_CANCEL:
              self.selectdossier.destroy()
          
      def choixdossier(self, image, w):
          self.rep = self.selectdossier.get_filename() 
          self.bouton8.set_sensitive(True)
          self.bouton9.set_sensitive(True)
          self.champ.set_text("")
          self.champ_dossier_reception.set_text(self.rep)
          
      def suppr_video(self, widget, donnees=None):
          self.choix_suppr_video = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_suppr_video = self.choix_suppr_video.replace(" ", "")
          
      def ok_arg(self, widget, donnees=None):
          self.arg = self.champ_arg.get_text()
          if self.arg != '' and (not '%' in self.arg or ' ' in self.arg):
             self.info_arg(self, dPluzz)
             if self.choix_notif == "notifTrue":
                cmd = 'notify-send --icon "/usr/share/icons/dPluzz-ico.png" "Il y a une erreur dans la syntaxe des arguments"'
                p = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
          elif self.arg == '':
             if self.choix_notif == "notifTrue":
                cmd = 'notify-send --icon "/usr/share/icons/dPluzz-ico.png" "Les arguments sont supprimés"'
                p = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
          else:
             if self.choix_notif == "notifTrue":
                cmd = 'notify-send --icon "/usr/share/icons/dPluzz-ico.png" "Les arguments sont validés"'
                p = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
      
      def nom_fichier(self, dPluzz, donnees=None):
          try:
             if self.annul == 0 and (self.dict_adresse != [[],[]]):
                # lecture du terminal
                text = str(self.v.get_text(lambda *a: True).rstrip())
                lignes = text.split("\n")
                for l in lignes:
                    if "Code :" in l:
                        code = l
                    if "Destination" in l:
                        chemin_nom = l
                tmp = code.replace(' ', '')
                tmp2 = chemin_nom.replace(' ', '')
                code = tmp.split("Code:",1)[1]
                chemin_nom = tmp2.split("Destination(saufsimodifiéeparleGUI):",1)[1]
                self.chemin_vid = chemin_nom
                N = code
                self.adresse = self.adresse_en_cours
                self.ID = self.adresse[-14:]
                self.ID = self.ID.replace('.html', '')
                self.ID = self.ID.replace('_', '')
                self.chemin_vid = self.rep + "/"
                
                # récupérer les données de la vidéo en cours
                for adresse in self.liste_adresse:
                   if adresse == self.adresse:
                      for detail in self.liste_details[adresse]:
                         if self.ID in detail and self.ID in adresse:
                            titre = self.liste_details[adresse][1]
                            sous_titre = self.liste_details[adresse][2]
                            self.diffusion = self.liste_details[adresse][3]
                            self.heure = self.liste_details[adresse][4]
                            self.episode = self.liste_details[adresse][5]
                            self.saison = self.liste_details[adresse][6]
                            break
                         else:
                            titre = self.liste_details[adresse][1]
                            sous_titre = self.liste_details[adresse][2]
                            self.diffusion = self.liste_details[adresse][3]
                            self.heure = self.liste_details[adresse][4]
                            self.episode = self.liste_details[adresse][5]
                            self.saison = self.liste_details[adresse][6] 

                # déterminer la date actuelle
                today = str(date.today())
                jour = today[8:10]
                mois = today[5:7]
                annee = today[0:4]
             
                #choix extension
                if self.option_conteneur_video == "mkv":
                   ext = ".mkv"
                if self.option_conteneur_video == "mp4":    
                   ext = ".mp4"
                   
                # remplacer l'argument par les données
                nouveau_nom = self.arg
                if self.chaine == "Pluzz":
                   nouveau_nom = nouveau_nom.replace('%E', self.episode)
                   nouveau_nom = nouveau_nom.replace('%S', self.saison)
                   nouveau_nom = nouveau_nom.replace('%N', titre)
                   self.heure = self.heure.replace(' ','')
                elif self.chaine == "Canal":
                   try:
                      self.diffusion = self.publication
                   except:
                      self.diffusion = ''
                      self.publication = ''
                   try:
                      N = self.titre
                   except:
                      self.titre = ''
                   try:
                      self.description
                   except:
                      self.description = N
                   try:
                      sous_titre = self.sous_titre
                   except:
                      sous_titre = ''
                   try:
                      self.heure
                   except:
                      self.heure = ''
                   nouveau_nom = nouveau_nom.replace('%E', '')
                   nouveau_nom = nouveau_nom.replace('%S', '')
                   self.ID = self.ID.replace('=', '')
                   nouveau_nom = nouveau_nom.replace('%N', N)
             
                nouveau_nom = nouveau_nom.replace('%st', sous_titre)   
                nouveau_nom = nouveau_nom.replace('%ID', self.ID)
                nouveau_nom = nouveau_nom.replace('%h', self.heure)
                nouveau_nom = nouveau_nom.replace('%j', self.diffusion[:2])
                nouveau_nom = nouveau_nom.replace('%m', self.diffusion[3:5])
                nouveau_nom = nouveau_nom.replace('%a', self.diffusion[6:10])
                nouveau_nom = nouveau_nom.replace('%J', jour)
                nouveau_nom = nouveau_nom.replace('%M', mois)
                nouveau_nom = nouveau_nom.replace('%A', annee)
                nouveau_nom = nouveau_nom.replace('/', '-')
                nouveau_nom = '_'.join(filter(None, nouveau_nom.split('_')))  # supprimer les doubles
                self.nouveau_chemin_nom = self.chemin_vid + nouveau_nom + ext
                
                if os.path.isfile(self.nouveau_chemin_nom) == False: 
                   self.nouveau_chemin_nom = self.chemin_vid + nouveau_nom + ext
                else:
                   self.nouveau_chemin_nom = self.chemin_vid + nouveau_nom + '(2)' + ext
                if debug == 1:
                   print bcolors.WARNING + "Fichier renommé:" + self.nouveau_chemin_nom + bcolors.ENDC
                
                os.rename(chemin_nom, self.nouveau_chemin_nom)
          except:
              print "Le renommage du fichier n'a pas pu se réaliser"
          if "True" in self.choix_sstitre:
             try:
                self.nouveau_chemin_sub = self.nouveau_chemin_nom[:-3].strip() + "srt"
                ancien_sub = chemin_nom.replace(ext, '.srt')
                nouveau_sub =  self.nouveau_chemin_sub
                os.rename(ancien_sub, nouveau_sub)
             except:
                pass
                print "Le renommage des sous-titres n'a pas pu se réaliser" 
          
      def lire(self, widget, donnees=None):
          if self.option_conteneur_video == "mkv":
             ext = "/*.mkv"
          if self.option_conteneur_video == "mp4":    
             ext = "/*.mp4"
          if ext == "/*.mp4" and self.child_pid != 1:
             self.message = "Impossible de lire une vidéo mp4 en cours de téléchargement." + "\n" + "Veuillez réessayer plus tard, ou choisissez mkv dans les options."
             self.titre_fenetre = "Impossible de lire"
             self.bouton_apercu_multi.set_sensitive(False)
             self.bouton_apercu_pluzz.set_sensitive(False)
             self.bouton_ap_canal.set_sensitive(False)
             self.fenetre_message(self)
          else:    
             try:
                if self.annul == 1:
                   if self.chaine == "Pluzz":
                      self.iterdebut = self.buffertexte.get_end_iter()
                      self.buffertexte.set_text("La vidéo semble être supprimée, mais cliquez sur Ouvrir pour vérifier !")
                   else:
                      self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
                      self.buffertexte_canal.set_text("La vidéo semble être supprimée, mais cliquez sur Ouvrir pour vérifier !")
                else:
                   fichier = max(glob.iglob(self.rep + ext), key=os.path.getctime)
                   emission = fichier
                   if self.command_text != "":    
                      self.command_text = self.command_text.decode('utf-8')
                      command = (self.lecteur, self.command_text, emission)
                   else:
                      command = (self.lecteur, emission)
                   try:
                      proc = subprocess.Popen(command, shell=False)
                   except:
                      pass
             except IOError as e:
                if debug == 1:
                   print e
                if self.chaine == "Pluzz":
                   self.iterdebut = self.buffertexte.get_end_iter()
                   self.buffertexte.set_text("La vidéo est impossible à lire.")
                else:
                   self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
                   self.buffertexte_canal.set_text("La vidéo est impossible à lire.")
      
      def coller(self, widget, donnees=None):
          clipboard = gtk.Clipboard()
          data = clipboard.wait_for_contents('UTF8_STRING')
          text = data.get_text()
          page_num = self.notebook.get_current_page()
          if page_num == 0:
             self.champ.set_text(text)
          elif page_num == 1:
             pass
          elif page_num == 2:
             self.champ_multi.set_text(text)
          
      def cancel(self, dPluzz, donnees=None):
          if self.annul == 0:
             cmd = 'pkill -TERM -P' + " " + str(self.child_pid)
             subprocess.Popen(cmd, shell=True)
             self.percent = 0
             self.annul = 1
             self.barre.set_text("Annulé")
             while gtk.events_pending():
                gtk.main_iteration()
             self.champ.set_editable(True)
             self.bouton8.set_sensitive(True)
             self.bouton9.set_sensitive(True)
             self.child_pid = 1
             if self.environ == "XFCE" or self.environ == "LXDE":
                titre = "'dPluzz+'"
             else:
                titre = "'dPluzz+'"
             cmd = 'notify-send ' + titre + ' --icon "/usr/share/icons/dPluzz-ico.png" -t 10000 "Le téléchargement a été interrompu !"'
             p = subprocess.call(cmd, shell=True)
             if self.choix_suppr_video == "garder_videoFalse":
                #suppression de la video
                if self.option_conteneur_video == "mkv":
                   ext = "/*.mkv"
                if self.option_conteneur_video == "mp4":    
                   ext = "/*.mp4"
                if self.option_mode_sstitre == "srt" and self.choix_sstitre == "sstitreTrue":
                   fichier_sub = max(glob.iglob(self.rep + "/*.srt"), key=os.path.getctime)
                   os.remove(fichier_sub) 
             try:
                fichier_video = max(glob.iglob(self.rep + ext), key=os.path.getctime)
                os.remove(fichier_video)
             except:
                pass
          
      def result_lecteur(self, widget, donnees=None):
          self.lecteur = self.liste2.get_active_text()
          self.lecteur = self.lecteur.lower()
          
      def haut_larg(self,widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_taille=choix
          
      def bordure(self,widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_bordure=choix
          
      def vider(self,widget, donnees=None):
          if self.choix_taillehl == "petite False":
             for i in range(0, 29):
                self.bouton[i].set_active(False)
          self.dict_adresse = [[],[]]
          self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
          self.buffertexte_liste.set_text("")
          self.champ.set_text("")
          self.nbre_mot = 1
          self.liste_mots = []
          self.pos_clic = []
          self.liste_details = defaultdict(list)
      
###################################  PARTIE CANAL +  #####################################    
      
      def rub_actif(self, widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.rubrique=choix
          if self.rubrique == "rub True":
               self.rubrique = True
          elif self.rubrique == "rub False":
               self.rubrique = False
          while gtk.events_pending():
                     gtk.main_iteration()

      def recherche_rub_canal(self, dPluzz, donnees=None):
          self.champ_adr_canal.set_text("")
          try:
             for row in self.liststore_canal_rub:
                 self.liststore_canal_rub.remove(row.iter)
          except:
             pass
          try:
             for row in self.liststore_canal:
                 self.liststore_canal.remove(row.iter)
          except:
             pass
          self.mot_canal = self.champ_rech_canal.get_text()
          if self.rubrique == True:
              cat = "2"
          elif self.rubrique == False:
              cat = "1"
          self.url_canal = "http://www.canalplus.fr/pid3330-c-recherche.html?rechercherSite=" + self.mot_canal + "&categorie=" + cat
          try:
             f = urllib.urlopen(self.url_canal)
             self.feuille_canal = f.read()
             f.close()
          except: 
             self.champ_rech_canal.set_text("La recherche a échoué")
             pass
          links = {}
          soup = BeautifulSoup(self.feuille_canal, "html.parser")
          list_rub_canal = []
          for link in soup.select('a[href^=http://www.canalplus.fr/]'):
              title = link.get_text().strip()      
              if title and 'LIVE' not in title and 'EXCLU' not in title and 'Tweet' not in title:
                 url = link['href']
                 if debug == 1:
                    #couleurs dispo:  HEADER  OKBLUE  OKGREEN WARNING FAIL ENDC          
                    print bcolors.OKBLUE + "URL RUBRIQUE:",url + bcolors.ENDC
                 list_rub_canal.append(url)
                 links.setdefault(url, []).append(title)
          self.list_rub_canal = list_rub_canal
          self.choice_rub = [' '.join(v + [k.rsplit(',')[-1]]) for k, v in links.items()]   
          self.choice_rub = [s.replace('\t', '') for s in self.choice_rub]
          self.choice2_rub = [val.rsplit(None, 1)[0] for val in self.choice_rub]
          new = []
          for rubrique in self.choice2_rub:
              if len(rubrique) > 100:
                  rubrique = rubrique[:100] + "..."
              new.append(rubrique)
          self.choice2_rub = new
          if self.rubrique == True:
              for rubrique in self.choice2_rub:
                 self.liststore_canal_rub.append([rubrique])
          elif self.rubrique == False:
                 self.result_recherche_canal_rub(self, dPluzz)

      def result_recherche_canal_rub(self, dPluzz, donnees=None):
          self.champ_adr_canal.set_text("")
          self.champ_adr_canal.set_icon_from_stock(1, gtk.STOCK_DIALOG_INFO)
          try:  
                for row in self.liststore_canal:
                    self.liststore_canal.remove(row.iter)
                if self.rubrique == True:
                    result = self.liste_canal_rub.get_active_text()[:3]
                    for url_canal in self.choice_rub:
                       if result in url_canal:
                           url_rubrique = url_canal
                           url_rubrique = url_rubrique.split()[-1]
                    try:
                       f = urllib.urlopen(url_rubrique)
                       self.sous_feuille_canal = f.read()
                       f.close()
                    except: 
                       self.champ_adr_canal.set_text("La recherche a échoué")
                       pass
                    links = {}
                    soup = BeautifulSoup(self.sous_feuille_canal, "html.parser")
                    list_link_canal = []
                    self.mot_canal = self.mot_canal.replace(' ','-')
                    for link in soup.select('a[href^=http://www.canalplus.fr/]'):
                        title = link.get_text().strip()
                        if title and 'LIVE' not in title and 'EXCLU' not in title and 'Tweet' not in title:
                           url = link['href']
                           if debug == 1 and self.mot_canal in url and 'live' not in url:
                              #couleurs dispo:  HEADER  OKBLUE  OKGREEN WARNING FAIL ENDC          
                              print bcolors.OKGREEN + "URL VIDEO:",url + bcolors.ENDC
                           if self.mot_canal in url and 'live' not in url:
                              list_link_canal.append(url)
                              links.setdefault(url, []).append(title)
                    self.list_link_canal = list_link_canal
                    self.choice_canal = [' '.join(v + [k.rsplit(',')[-1]]) for k, v in links.items()]        
                    self.choice_canal = [s.replace('\t', '') for s in self.choice_canal]
                    self.choice_canal = [s.replace('video', '') for s in self.choice_canal]
                    self.choice2_canal = [val.rsplit(None, 1)[0] for val in self.choice_canal]  
                    new = []
                    for lien_video in self.choice2_canal:
                        if len(lien_video) > 100:
                            lien_video = lien_video[:100]
                        lien_video = lien_video.replace("\n","")
                        new.append(lien_video)
                    self.choice2_canal = new
                    self.liststore_canal.append([lien_video])
                    self.choice2_canal.sort()
                    new=[]
                    for i in reversed(self.choice2_canal):
                        new.append(i)
                    self.choice2_canal = new 
                    for lien_video in self.choice2_canal:
                        lien_video = lien_video.replace("\n","")
                        self.liststore_canal.append([lien_video])
                else:
                    for lien_video in self.choice2_rub:
                        lien_video = lien_video.replace("video","")
                        lien_video = lien_video.replace("\n","")
                        self.liststore_canal.append([lien_video])
          except:
             pass
      
      def result_recherche_canal(self, dPluzz, donnees=None):
        try:  
          if self.rubrique == True:
              self.result = self.liste_canal.get_active_text()
          elif self.rubrique == False:
              self.result = self.liste_canal.get_active_text()
              self.choice_canal = self.choice_rub
              self.list_link_canal = self.list_rub_canal
          try:
              for x in self.choice_canal:
                  if self.result in x:
                       self.result = x
          except:
              pass
          if self.result != None: 
              ID = self.result[-9:]
              for url in self.list_link_canal:
                  if ID in url: 
                      adresse = url
          try:
              self.champ_adr_canal.set_text(adresse)  # affichage de l'adresse correspondante
              self.chaine = "Canal"
              if "pid" in adresse:
                  self.champ_adr_canal.set_icon_from_stock(1, gtk.STOCK_APPLY)
              else:
                  self.champ_adr_canal.set_icon_from_stock(1, gtk.STOCK_STOP)
              if debug == 1:
                  print bcolors.WARNING + "\nURL VIDEO SELECTIONNEE:",adresse + bcolors.ENDC
              self.detail_canal(self)
          except:
              pass
        except:
            pass  
      
      def detail_canal(self, dPluzz, donnees=None):
          self.bouton8.set_sensitive(True)
          self.bouton9.set_sensitive(True)
          self.iterdebut = self.buffertexte.get_end_iter()
          self.buffertexte.set_text("")
          adresse = self.champ_adr_canal.get_text()
          try:
             del image
          except:
             pass
          # trouver l'adresse du json
          ID = adresse[-7:]
          adresse_json = "http://service.canal-plus.com/video/rest/getVideos/cplus/" + ID + "?format=json"
          self.ID = ID
          
          if debug == 1:
             print bcolors.WARNING
             print "ID:", ID
             print "ADR JSON:", adresse_json
             print "ADR VIDEO:", adresse
             print "\n"
          
          # télécharger le json
          json_obj = urllib.URLopener()
          json_obj.retrieve(adresse_json, self.home + "/.cache/dPluzz/file.json")
          
          #ouvrir le fichier
          myFile = open(self.home + "/.cache/dPluzz/file.json", "r")
          json_line = myFile.read(5000)
          myFile.close()
                    
          data = json.loads(json_line)
          if debug == 1:
             #couleurs dispo:  HEADER  OKBLUE  OKGREEN WARNING FAIL ENDC          
             print bcolors.FAIL + "DATA VIDEO:" + bcolors.ENDC
             pprint(data)
             print bcolors.FAIL + "FIN DATA" + bcolors.ENDC
          
          # Tri et Affichage des infos
          description = data["INFOS"]["DESCRIPTION"]
          publication = data["INFOS"]["PUBLICATION"]["DATE"]
          heure = data["INFOS"]["PUBLICATION"]["HEURE"]
          image = data["MEDIA"]["IMAGES"]["GRAND"]
          titre = data["INFOS"]["TITRAGE"]["TITRE"]
          sous_titre = data["INFOS"]["TITRAGE"]["SOUS_TITRE"]
          
          if description != "":
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.set_text(" -Description: " + description)
          else:
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.set_text(" Pas d'informations")
          if titre != "":  
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.insert(self.iterdebut_canal, "\n" + " -Titre: " + titre)
          if sous_titre != "":  
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.insert(self.iterdebut_canal, "\n" + " -Sous-titre: " + sous_titre)
          if publication != "":  
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.insert(self.iterdebut_canal, "\n" + " -Date de publication: " + publication)
          if heure != "":  
             self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
             self.buffertexte_canal.insert(self.iterdebut_canal, "\n" + " -Heure de publication: " + heure)
          if image != "":
             self.response=urllib2.urlopen(image, self.home + "/.cache/dPluzz/img/" + "imagec.jpg")
             self.loader = gtk.gdk.PixbufLoader()
          
          def taille(locals):
              if self.choix_taillehl == "petite False":
                 self.loader.set_size(213, 120)
              else:
                 self.loader.set_size(128, 72)
              self.loader.write(self.response.read())
              self.loader.close()
          taille(locals)
          if image != "":
             self.img_canal.set_from_pixbuf(self.loader.get_pixbuf())
          else:
              self.img_canal.set_from_pixbuf(None)
          self.description = description
          self.publication = publication
          self.titre = titre
          self.sous_titre = sous_titre
          self.heure = heure
          self.ID = ID
          
      def progress_canal(self, dPluzz, donnees=None):
          try:
              percent = self.percent
          except:
              percent = 0
          if percent == 0:
              dPluzz.pbar.set_fraction(0)
              while gtk.events_pending():
                 gtk.main_iteration()
          pourc = float(percent)/100
          if pourc > 1:
              pourc = 1
          dPluzz.pbar.set_fraction(float(pourc))
          dPluzz.pbar.set_text("Téléchargement: " + str(percent) + ' %')
          while gtk.events_pending():
               gtk.main_iteration()
          self.percent = percent
      
      def coller_canal(self, widget, donnees=None):
          clipboard = gtk.Clipboard()
          data = clipboard.wait_for_contents('UTF8_STRING')
          text = data.get_text()
          self.champ_adr_canal.set_text(text)


##################################  PARTIES COMMUNES  ##################################

      def notification(self, widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_notif=choix
          self.choix_notif = self.choix_notif.replace(' ','')
          
      def essai_notification(self, widget, donnees=None): 
          cmd = 'notify-send "dPluzz" --icon "/usr/share/icons/dPluzz-ico.png" -t 3000 "Essai réussi !"'
          p = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
          out, err = p.communicate()
          errcode = p.returncode
          if errcode != 0:
             print "Code erreur:", errcode
          if "/bin/sh: 1: notify-send: not found" in err:
             print "Vous devez installer le paquet 'libnotify-bin'"
             self.fenetre_install = gtk.Window(gtk.WINDOW_TOPLEVEL)
             self.fenetre_install.set_position(gtk.WIN_POS_CENTER)    
             self.fenetre_install.set_title('Manque une dépendance')
             self.fenetre_install.set_default_size(200, 100)
             self.fenetre_install.set_border_width(10)
             self.fenetre_install.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
             box = gtk.VBox()
             self.fenetre_install.add(box)
             text = """➤ Vous devez installer le paquet 'libnotify-bin'.\nVoulez-vous l'installer maintenant ?"""
             etiquette = gtk.Label (text)
             etiquette.set_alignment(0.05, 0.5)
             etiquette.set_justify(gtk.JUSTIFY_CENTER)
             box.pack_start(etiquette, True, True, 0)
             etiquette.show()
             box.show()
             box_btn = gtk.HButtonBox()
             box.add(box_btn)
             bouton_oui = gtk.Button("Oui", gtk.STOCK_YES)
             bouton_oui.connect("clicked", self.install_notify, "bouton A")
             box_btn.pack_start(bouton_oui, True, True, 0)
             bouton_oui.show()
             bouton_non = gtk.Button("Non", gtk.STOCK_NO)
             bouton_non.connect("clicked", self.install_notify_no, "bouton A")
             box_btn.pack_start(bouton_non, True, True, 0)
             bouton_non.show()
             box_btn.show()
             self.fenetre_install.show()
      
      def install_notify(self, dPluzz, donnees=None):
          print "Installation du paquet requis..."
          self.notebook.set_current_page(2)
          self.fenetre_install.destroy()
          self.check_notif.set_active(True)
          term = self.v
          self.child_pid = term.fork_command("clear")
          term.fork_command (command='/bin/sh', argv=['/bin/sh','-c', 'echo "Installation du paquet..."\nsudo apt-get install libnotify-bin\necho "Installation terminée."'])
                    
      def install_notify_no(self, dPluzz, donnees=None):
          self.fenetre_install.destroy()
          
      def command_v(self, widget, donnees=None):
          self.choix_comm = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.comm(self, widget)
      
      def comm(self, widget, donnees=None):
          if self.choix_comm == "command True":
              self.option_command = 1
              try:
                  self.champ_arg_lecteur.set_sensitive(True)
                  self.command_text = self.champ_arg_lecteur.get_text()
              except:
                  pass
              
          if self.choix_comm == "command False":
              self.option_command = 0
              self.command_text = ""
              try:
                  self.champ_arg_lecteur.set_sensitive(False)
              except:
                  pass

      def champ_command(self, widget, donnees=None):
          self.command_text = self.champ_arg_lecteur.get_text() 
      
      def ok_commande(self, widget, donnees=None):
          self.command_text = self.champ_arg_lecteur.get_text()
      
      def info(a, b, dPluzz, donnees=None):
          fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
          fenetre.set_position(gtk.WIN_POS_CENTER)    
          
          #Titre et icone
          fenetre.set_title('Aide')
          fenetre.set_default_size(300, 100)
          fenetre.set_border_width(10)
          fenetre.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
          
          #boite et texte
          box = gtk.HBox()
          fenetre.add(box)#, True, True, 0)
          text = """➤ L'adresse de la vidéo peut-être récupérée par le moteur de recherche (si disponible),\nou peut être directement collée dans le champ de l'adresse\nsi le moteur ne trouve pas ce que vous cherchez."""
          etiquette = gtk.Label (text)
          etiquette.set_alignment(0.05, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          box.pack_start(etiquette, True, True, 0)
          etiquette.show()
          
          def kill_fenetre(self, donnees=None):
             fenetre.destroy()
          
          # Nouvelle boite pour le bouton ok
          boite_btn_ok = gtk.VButtonBox()
          boite_btn_ok.set_layout(gtk.BUTTONBOX_END)
          #fenetre.add(boite_btn_ok)
          box.pack_start(boite_btn_ok, True, True, 0)
          boite_btn_ok.show()
          
          bouton_continue = gtk.Button("OK")
          bouton_continue.connect("clicked", kill_fenetre, "bouton A")
          boite_btn_ok.pack_start(bouton_continue, True, True, 0)
          bouton_continue.show()
          
          box.show()
          
          fenetre.show()
      
      def info_arg(a, b, dPluzz, donnees=None):
          fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
          fenetre.set_position(gtk.WIN_POS_CENTER)    
          
          #Titre et icone
          fenetre.set_title('Aide')
          fenetre.set_default_size(200, 400)
          fenetre.set_border_width(10)
          fenetre.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
          
          #boite et texte
          box = gtk.HBox()
          fenetre.add(box)#, True, True, 0)
          text = """➤ Le fichier reçu peut-être renommé selon ces paramètres:\n==========\n%N -> nom initial de la vidéo\n---\n%h -> heure de diffusion\n%j -> jour de diffusion\n%m -> mois de diffusion\n%a -> année de diffusion\n---\n%S -> saison\n%E -> épisode\n%st -> sous-titre\n%ID -> ID de la vidéo\n---\n%H -> heure de création du fichier\n%J -> jour de création du fichier\n%M -> mois de création du fichier\n%A -> année de création du fichier\n==========\n➤ L'ordre de ces paramètres est libre, le nombre aussi.\nIl est possible d'ajouter des signes entre les arguments,\nmais les espaces seront supprimés.\nExemple: %N_%S_%E_diff.%j-%m-%a\n\n➤ Les paramètres ne seront indiqués\nque s'ils sont disponibles!\n\n➤ Si cette case est vide, le nom du fichier sera sous la forme\n%N_%ID"""
          etiquette = gtk.Label (text)
          etiquette.set_alignment(0.05, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          box.pack_start(etiquette, True, True, 0)
          etiquette.show()
          
          box.show()
          fenetre.show()
          
      def info_liste(self, widget, donnees=None):
          fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
          fenetre.set_position(gtk.WIN_POS_CENTER)    
          
          #Titre et icone
          fenetre.set_title('dpluzz')
          fenetre.set_default_size(100, 100)
          fenetre.set_border_width(10)
          fenetre.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
          
          #boite et texte
          box = gtk.VBox()
          fenetre.add(box)
          text = """ Le nombre de recherche est limité.\nPour continuer, veuillez télécharger la liste\ndéjà mémorisée,ou videz la liste."""
          etiquette = gtk.Label (text)
          etiquette.set_alignment(0.05, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          box.pack_start(etiquette, True, True, 0)
          etiquette.show()
          
          def valid(locals, donnees=None):
             try:
                del self.liste_mots[-1]
             except:
                pass
             fenetre.destroy()
          
          # boite pour le bouton ok
          boite_ok = gtk.HButtonBox()
          boite_ok.set_border_width(0)
          box.pack_start(boite_ok)
          boite_ok.show()
          
          #bouton ok
          bouton = gtk.Button("A", gtk.STOCK_OK)
          bouton.connect("clicked", valid, "bouton ok")
          boite_ok.pack_start(bouton)
          bouton.show()
          
          box.show()
          fenetre.show()
          
      def taille(self, widget, donnees=None):
          choix = "%s %s" % (donnees, (False, True)[widget.get_active()]) 
          self.choix_taillehl=choix
          if self.choix_taillehl == "petite True":
              self.h = 475
              while gtk.events_pending():
                     gtk.main_iteration()
          elif self.choix_taillehl == "petite False":
              self.h = 790
              while gtk.events_pending():
                     gtk.main_iteration()
          
      def dossier_r(self, widget, donnees=None):
          if not os.path.exists(self.rep + "/.folder"):
             os.makedirs(self.rep + "/.folder")
          cmd = "xdg-open $(dirname " + self.rep + "/.folder)"
          subprocess.call(cmd, shell=True)
          
      def destroy(self, widget, donnees=None):
          self.option_ffmpeg = self.option_ffmpeg.replace(" ", "")
          self.option_mkv = self.option_mkv.replace(" ", "")
          self.choix = self.choix.replace(' ','')
          self.option_mp3 = self.option_mp3.replace(' ','')
          self.choix_taille = self.choix_taille.replace(' ','')
          self.choix_taille = self.choix_taille.replace('/','')
          self.choix_bordure = self.choix_bordure.replace(' ','')
          self.choix_vo = self.choix_vo.replace(' ','')
          self.choix_sstitre = self.choix_sstitre.replace(' ','')
          if self.rep == "Veuillez choisir un dossier":
             self.rep = self.home
          if "tailleTrue" in self.choix_taille:
             size = self.fenetre.get_size()
          else:
             size = ""
          self.arg = self.arg.replace(' ','')
          if self.arg == "":
             self.arg = "rien"
          conf_size = str(size)
          conf_size = conf_size.replace(' ', '')
          options = self.rep + "\n" + self.option_ffmpeg + "\n" + self.lecteur + "\n" + self.option_mkv + "\n" + str(self.h) + "\n" + str(self.option_mp3) + "\n" + str(self.option_command) + "\n" + self.choix_taille + '/' + conf_size + "\n" + self.choix_notif + "\n" + self.arg + "\n" + self.choix_bordure + "\n" + self.choix_vo + "\n" + self.choix_sstitre + "\n" + self.option_encodeur_video + "\n" + self.option_conteneur_video + "\n" + self.option_mode_sstitre + "\n" + self.command_text + "\n" + self.choix_suppr_video
          myfile = open(self.home + "/.config/dPluzz/dPluzz.conf", "w")
          data2 = myfile.write(options)
          myfile.close()
          filelist = glob.glob(self.home + "/.cache/dPluzz/img/*")
          for f in filelist:
              os.remove(f)
          try:
             os.remove(self.home + '/.cache/dPluzz/log/debug.log')
          except:
             pass  
          list_of_files = os.listdir(self.rep)
          for each_file in list_of_files:
             if each_file.startswith('wget'):
                print 'Suppression de ' + each_file + '...'
                try:
                   os.remove(self.rep + '/' + each_file)
                except: pass
          print "Merci d'utiliser dPluzz+ ! :)"
          gtk.main_quit()
          exit() 
      
      
#################################   PARTIE GRAPHIQUE   ##################################
      def set_pluzz(self):
          a=0
          self.page = self.notebook.get_nth_page(0)
          
          # Creation de la boite (recherche, champ, bouton rechercher)
          self.boite_rech = gtk.VBox()
          self.page.add(self.boite_rech)
          
          # entourage
          cadre = gtk.Frame("Recherche")
          self.boite_rech.add(cadre)
          self.boite_rech.show()
          
          #création du tableau
          tableau = gtk.Table(rows=3, columns=7, homogeneous=False)
          tableau.get_row_spacing(0)
          cadre.add(tableau)
          tableau.show()
          cadre.show()
         
          etiquette = gtk.Label ("Rechercher dans France.tv:")
          etiquette.set_alignment(0.8, 0.5)
          tableau.attach(etiquette, 1, 2, 0, 1, xpadding=22, ypadding=0)
          etiquette.show()
          
          #champ de la recherche:
          self.champ_recherche_pluzz = gtk.Entry()
          self.champ_recherche_pluzz.set_max_length(200)
          self.champ_recherche_pluzz.set_width_chars(40)
          self.champ_recherche_pluzz.connect("activate", self.recherche, self.champ_recherche_pluzz)
          self.champ_recherche_pluzz.set_text("")
          tableau.attach(self.champ_recherche_pluzz, 2, 3, 0, 1, xpadding=10, ypadding=0)
          #self.champ_recherche_pluzz.set_sensitive(False)
          #self.champ_recherche_pluzz.set_text("La recherche n'est plus disponible pour le moment !")
          self.champ_recherche_pluzz.set_text("")
          self.champ_recherche_pluzz.show()
          
          
          self.completion = gtk.EntryCompletion()
          self.champ_recherche_pluzz.set_completion(self.completion)
          liststore = gtk.ListStore(str)
          self.completion.set_model(liststore)
          pixbufcell = gtk.CellRendererPixbuf()
          self.completion.set_text_column(0)
          self.index = 0
          self.text_completion = ""
                    
          url_page_accueil_pluzz = "https://france.tv"
          f = urllib.urlopen(url_page_accueil_pluzz + "/")
          page_accueil_pluzz = f.read()
          f.close()
          soup = str(BeautifulSoup(page_accueil_pluzz, "html.parser"))
          #root = fromstring(soup)
          #new_soup = (tostring(root, pretty_print=True).strip())
          new_soup = soup
          new_soup = BeautifulSoup(new_soup, "html.parser")
          adresse = {}
          self.mots = []
          self.liens_accueil = []
          
          for link in new_soup.find_all(['a']):
             title = link.get_text().strip()
             titleList_ban = ["actualités & société","séries & fictions","accueil","en direct","jeux & divertissements","vie quotidienne","tout voir","Aide", "Accessibilité", "iphone" , "android", "windows", "applications", "RSS", "Devenir annonceur", "Recrutement", "Mentions légales", "CGU", "Gestion Cookies", "Politique de confidentialité", "Fermer la fenetre", "Contact", "Fermer", "A-Z", "Toutes les émissions", "Les + regardés", "Dernière chance", "Tous publics", "Sous-titré", "Depuis l'étranger", "Qui sommes-nous ?", "Sous-titrés", "En replay", "En direct", "Confidentialité", "Newsletters", "Actualités régions", "Le programme TV", "La Boutique", "Francetv.fr", "1ère", "Replay / Direct", "Vidéo à la demande", "Grand quiz FranceTV Sport Rétro 2014", "La 1ère", "France 2", "France 3", "France 4", "France 5", "France Ô", "Pluzz", "Pluzz VàD", "Francetv Info", "Francetv Sport", "France Télévisions", "Education", "Nouvelles Ecritures", "francetv education", "Zouzous", "Ludo", "Geopolis", "Culturebox", "leclub francetv", "Pluzz", "Page 19", 'Gestion des cookies', "Pourquoi s'inscrire ?", 'Espace confidentialité', 'CGV', 'sport', 'spectacles & culture', 'films', 'enfants', 'documentaires', 'chaînes', 'la 1ère', 'catégories', 'documentaires', 'enfants', 'films', 'aide & contact', 'confidentialité', 'newsletters', '5J', '25J', '1J', '6J', '1J', '2J', '3J', '4J', '7J', '8J', '9J', '+30J', 'Contactez nous', 'toutes-les-emissions', 'replay-videos', 'les émissions de france 2', 'les émissions de france 3', 'les émissions de france 4', 'les émissions de france 5', 'les émissions de france Ô','replay france 2', 'replay france 3', 'replay france 4', 'replay france 5', 'replay france Ô', 'mes reprises de lecture', 'sélectionné par france tv slash', 'direct franceinfo:', 'direct france 2', 'direct france 3', 'direct france 4', 'direct france 5', 'direct france Ô', 'franceinfo:']
             
             if all(title != x for x in titleList_ban):
                lien = link['href']
                lien = lien.replace("http:","https:")
                if not "https:" in lien: 
                    lien = "https:" + lien
                if lien != 'https:/' and not ' ' in lien and lien != 'https:#' and not 'culturebox' in lien and not 'mailto' in lien and not 'facebook' in lien:
                    self.liens_accueil.append(lien)
                title = title.replace('  ',' ')
                title = title.replace('france 5', '')
                title = title.replace('france 4', '')
                title = title.replace('france 3', '')
                title = title.replace('france 2', '')
                title = title.replace('france Ô', '')
                title = title.replace('€', '')
                title = title.replace('2017', '')
                title = title.replace('2016', '')
                title = title.replace('2018', '')
                title = title.replace('2015', '')
                title = ' '.join(title.split())
                title = title.split("|", 1)[0] #enlever après |
                title = title.split('J ', 1)[-1] #enlever avant J
                while title[-1:] == ' ' or title[-1:] == '-':
                      title = title[:-1]
                title = title.replace('\n','')
                self.mots.append(title)
                
          self.liens_accueil = list(set(self.liens_accueil))
          #pprint(self.liens_accueil)
          self.mots= list(set(self.mots))
          
          for self.text_completion in self.mots:
             if len(self.text_completion) < 50 and len(self.text_completion) != 0:
                liststore.append([self.text_completion])
          self.completion.connect("match-selected", self.pre_recherche)
          
          # Nouvelle boite pour le bouton rechercher
          self.boite_rech2 = gtk.HButtonBox()
          self.boite_rech2.set_border_width(0)
          self.boite_rech2.set_layout(gtk.BUTTONBOX_START)
          tableau.attach(self.boite_rech2, 5, 6, 0, 1, xpadding=0, ypadding=0)
          self.boite_rech2.show()
          
          #bouton rechercher
          self.bouton3 = gtk.Button("A", gtk.STOCK_FIND)
          self.bouton3.connect("clicked", self.recherche, "bouton B")
          self.boite_rech2.pack_start(self.bouton3, False, False, 0)
          self.bouton3.set_sensitive(True)
          self.bouton3.show()
          
          etiquette = gtk.Label ("ou")
          etiquette.set_alignment(0.5, 0.5)
          self.boite_rech2.pack_start(etiquette, True, False, 0)
          etiquette.show()
          
          #lien
          lien = gtk.LinkButton("https://www.france.tv",label="https://www.france.tv/")
          self.boite_rech2.pack_start(lien, True, False, 0)
          lien.set_alignment(0, 0.5)
          lien.show()
          
          #création du tableau dans 3eme ligne
          tableau3 = gtk.Table(rows=1, columns=8, homogeneous=True)
          tableau.attach(tableau3, 0, 8, 2, 3)#, xpadding=10, ypadding=2)
          tableau3.show()
          
          #Etiquette
          etiquette = gtk.Label ("Adresse de la vidéo Pluzz:")
          etiquette.set_alignment(0.8, 0.5)
          tableau3.attach(etiquette, 0, 2, 0, 1, xpadding=0, ypadding=0)
          etiquette.show()
          
          #champ de l'adresse
          self.champ = gtk.Entry()
          self.champ.set_max_length(300)
          self.champ.set_width_chars(20)
          self.champ.connect("activate", self.detail, self.champ)
          if self.rep == "Veuillez choisir un dossier":
              self.champ.set_text("Premier démarrage? Veuillez choisir un dossier de réception dans les options svp")
          else:
              self.champ.set_text("")
          tableau3.attach(self.champ, 2, 7, 0, 1, xpadding=10, ypadding=2)
          self.champ.set_icon_from_stock(1, gtk.STOCK_INFO)
          self.champ.set_icon_activatable(1, True)
          self.champ.connect("icon-release", self.info)
          self.champ.show()
          
          # Nouvelle boite pour le bouton coller
          boite_col = gtk.HButtonBox()
          boite_col.set_border_width(0)
          tableau3.attach(boite_col, 7, 8, 0, 1, xpadding=0, ypadding=0)
          boite_col.show()
          
          # bouton coller
          bouton_coller_pluzz = gtk.Button("A", gtk.STOCK_PASTE)
          bouton_coller_pluzz.connect("clicked", self.coller, "bouton coller")
          boite_col.pack_start(bouton_coller_pluzz)
          bouton_coller_pluzz.show()
          
          # Nouvelle boite pour le bouton infos
          boite_col = gtk.HButtonBox()
          boite_col.set_border_width(0)
          tableau3.attach(boite_col, 8, 9, 0, 1, xpadding=0, ypadding=0)
          boite_col.show()
          
          # bouton infos
          bouton5 = gtk.Button("A", gtk.STOCK_INFO)
          bouton5.connect("clicked", self.infos, "bouton infos")
          boite_col.pack_start(bouton5)
          #bouton5.set_sensitive(False)
          #bouton5.show()
          
          if self.choix_taillehl == "petite False":
             def on_button_scroll_event(button, event):
                if event.direction == gtk.gdk.SCROLL_UP:
                   vscroll.emit("move-slider", gtk.SCROLL_PAGE_UP)
                if event.direction == gtk.gdk.SCROLL_DOWN:
                   vscroll.emit("move-slider", gtk.SCROLL_PAGE_DOWN)
             
             self.boite_result = gtk.VBox()
             self.boite_rech.add(self.boite_result)
             self.boite_result.show()
             
             # boutons/images
             self.tableau_img = gtk.Table(rows=7, columns=8, homogeneous=False)
             self.tableau_img.get_row_spacing(0)
             viewport = gtk.Viewport()
             viewport.set_border_width(3)
             viewport.set_shadow_type(gtk.SHADOW_ETCHED_IN)
             viewport.set_size_request(1000, 200)
             if self.environ == 'Unity' or self.environ == 'LXDE':
                viewport.set_size_request(1080, 200)
             vadjustment = viewport.get_vadjustment()
             vscroll = gtk.VScrollbar(vadjustment)
             viewport.connect("scroll-event", on_button_scroll_event)
             self.boite_result.add(viewport)
             viewport.show()
             ligne = 0
             colonne = 0
             self.img = [gtk.Image() for l in xrange(42)]
             self.label = [gtk.Label ("")for m in xrange(42)]
             self.bouton = [gtk.ToggleButton() for n in xrange(42)]
             self.boite_img = [gtk.VButtonBox() for n in xrange(42)]
             self.list_fonct = []
             for i in range(0, 42):
                def result(locals, i=i):
                   self.position = i
                   self.result_recherche(self)
                self.list_fonct.append(result)
             self.list_fonct_init = self.list_fonct
             i=0
             for image in self.img:   
                self.bouton[i].add(self.img[i])
                self.bouton[i].connect("clicked", self.list_fonct[i])
                self.boite_img[i].add(self.bouton[i])
                if i != 0 and i != 6 and i != 12 and i != 18 and i != 24 and i != 30 and i != 36 and i!= 42:
                   colonne = colonne + 1
                if i == 6:
                   ligne = 2
                   colonne = 0
                if i == 12:
                   ligne = 4
                   colonne = 0
                if i == 18:
                   ligne = 6
                   colonne = 0
                if i == 24:
                   ligne = 8
                   colonne = 0
                if i == 30:
                   ligne = 10
                   colonne = 0
                if i == 36:
                   ligne = 12
                   colonne = 0
                if i == 42:
                   ligne = 14
                   colonne = 0
                self.tableau_img.attach(self.boite_img[i], colonne, colonne+1, ligne, ligne+1, xpadding=10, ypadding=2)
                self.tableau_img.attach(self.label[i], colonne, colonne+1, ligne+1, ligne+2, xpadding=5, ypadding=0)
                self.boite_img[i].show()
                self.label[i].show()
                self.img[i].show()
                self.bouton[i].hide()
                i = i + 1
             self.tableau_img.attach(vscroll, 6, 7, 0, 12, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK)
             viewport.add(self.tableau_img)
             self.tableau_img.show()
             vscroll.show()
          
          else: #Menu déroulant
             if self.rep == "Veuillez choisir un dossier":
                self.liststore = gtk.ListStore(gobject.TYPE_STRING) #, gtk.gdk.Pixbuf)
                self.liste_url = ["        Cliquer ici après la recherche"]
                try:
                   for item1 in self.liste_url:
                       self.liststore.append([item1]) #, item1])
                except:
                   pass
             else:
                self.liststore = gtk.ListStore(gobject.TYPE_STRING) #, gtk.gdk.Pixbuf)
                self.liste_url = []    
                try:
                   for item in self.liste_url:
                       self.liststore.append([item])
                except:
                   print "Echec ajout dans liste"
                   pass
             cell = gtk.CellRendererText()
             self.liste = gtk.ComboBox(self.liststore)
             self.liste.pack_start(cell, True)
             self.liste.add_attribute(cell, "text", 0)
             #renderer = gtk.CellRendererPixbuf()
             #self.liste.pack_start(renderer, False)
             #self.liste.add_attribute(renderer, "pixbuf", 1)
             self.liste.set_active(0)
             tableau.attach(self.liste, 0, 8, 1, 2, xpadding=10, ypadding=2)
             self.liste.connect("changed", self.result_recherche)
             self.liste.show()
          
          # boite H détails + liste
          self.boite_detail_liste = gtk.HBox()
          self.boite_rech.add(self.boite_detail_liste)
          self.boite_detail_liste.show()
          
          # entourage détails
          cadre_detail = gtk.Frame("Détails de la vidéo")
          self.boite_detail_liste.add(cadre_detail)
          #cadre_detail.show()
          
          #création du tableau détail
          tableau2 = gtk.Table(rows=1, columns=1, homogeneous=False)
          cadre_detail.add(tableau2)
          #tableau2.show()
     
          #textview détails
          self.fd = gtk.ScrolledWindow()
          tableau2.attach(self.fd, 0, 1, 0, 1, xpadding=10, ypadding=5)
          self.fd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
          self.textview = gtk.TextView()
          self.textview.set_editable(False)
          self.textview.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color("#F2F2F2"))
          self.textview.set_wrap_mode(gtk.WRAP_WORD)
          self.textview.set_cursor_visible(True)
          self.textview.set_justification(gtk.JUSTIFY_LEFT)
          self.buffertexte = self.textview.get_buffer()
          self.edition = self.textview.get_editable()
          self.iterdebut = self.buffertexte.get_end_iter()
          self.buffertexte.set_text("")
          self.fd.add(self.textview)
          self.fd.show()
          #self.textview.show()   
             
          # entourage liste
          cadre_liste = gtk.Frame("Liste de téléchargement")
          self.boite_detail_liste.add(cadre_liste)
          #cadre_liste.show()
          
          #création du tableau liste
          tableau_liste = gtk.Table(rows=3, columns=10, homogeneous=False)
          cadre_liste.add(tableau_liste)
          #tableau_liste.show()
          
          #textview liste
          self.fd_liste = gtk.ScrolledWindow()
          tableau_liste.attach(self.fd_liste, 0, 10, 0, 2, xpadding=10, ypadding=5)
          self.fd_liste.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
          self.textview_liste = gtk.TextView()
          self.textview_liste.set_editable(False)
          self.textview_liste.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color("#F2F2F2"))
          self.textview_liste.set_wrap_mode(gtk.WRAP_WORD)
          self.textview_liste.set_cursor_visible(True)
          self.textview_liste.set_justification(gtk.JUSTIFY_LEFT)
          if (self.h >= 500 and self.environ == "Unity") or (self.h >= 500 and self.environ == "LXDE"):
             self.textview.set_size_request(-1, 200)
          elif (self.h <= 100 and self.environ == "Unity") or (self.h <= 100 and self.environ == "LXDE"):
             self.textview.set_size_request(-1, 150)
          self.buffertexte_liste = self.textview_liste.get_buffer()
          self.edition_liste = self.textview_liste.get_editable()
          self.iterdebut_liste = self.buffertexte_liste.get_end_iter()
          self.buffertexte_liste.set_text("")
          self.fd_liste.add(self.textview_liste)
          self.fd_liste.show()
          #self.textview_liste.show()
          
          # Nouvelle boite pour le bouton vider la liste
          boite_vider = gtk.HButtonBox()
          boite_vider.set_border_width(0)
          tableau_liste.attach(boite_vider, 4, 6, 2, 3, xpadding=0, ypadding=0)
          #boite_vider.show()
          
          if self.choix_taillehl == "petite True":
              #bouton vider la liste
              self.bouton_vider = gtk.Button("Supprimer l'adresse") #, gtk.STOCK_SAVE)       
              self.bouton_vider.connect("clicked", self.supprim_adr, "bouton vider_liste")
              boite_vider.pack_start(self.bouton_vider)
              self.bouton_vider.set_sensitive(True)
              #self.bouton_vider.show()
          
          #bouton vider la liste
          self.bouton_vider = gtk.Button("Vider la liste") #, gtk.STOCK_SAVE)       
          self.bouton_vider.connect("clicked", self.vider, "bouton vider_liste")
          boite_vider.pack_start(self.bouton_vider)
          self.bouton_vider.set_sensitive(True)
          #self.bouton_vider.show()
             
          # entourage téléchargement
          if self.environ == "Unity":
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=False)
          else:
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=True)
          if self.choix_taillehl == "petite False":
             cadre3 = gtk.Frame("Téléchargement")
             self.boite_rech.add(cadre3)
             cadre3.show()
             cadre3.add(tableau3)
          else:
             self.boite_rech.add(tableau3)
          tableau3.get_row_spacing(0)
          tableau3.show()
          
          # Bouton télécharger
          self.bouton8 = gtk.Button("Télécharger ! ") #, gtk.STOCK_SAVE)       
          self.bouton8.connect("clicked", self.pre_download, "bouton download")
          tableau3.attach(self.bouton8, 0, 4, 0, 2, xpadding=5, ypadding=2)
          self.bouton8.show()
          #if self.rep == "Veuillez choisir un dossier":
          #    self.bouton8.set_sensitive(False)
          
          #Barre de progression
          self.pbar = gtk.ProgressBar()
          self.pbar.show()     
          if self.h == 100 and self.environ == "Unity":
             tableau3.attach(self.pbar, 0, 1, 2, 3, xpadding=5, ypadding=4)
          else:
             tableau3.attach(self.pbar, 0, 1, 2, 3, xpadding=5, ypadding=4)
          self.pbar.set_text("Téléchargement: 0 %")
          self.pbar.show()
          
          # Bouton aperçu
          self.bouton_apercu_pluzz = gtk.Button("Lire", gtk.STOCK_MEDIA_PLAY)
          self.bouton_apercu_pluzz.connect("clicked", self.lire, "bouton C")
          tableau3.attach(self.bouton_apercu_pluzz, 1, 2, 2, 3, xpadding=5, ypadding=2)
          self.bouton_apercu_pluzz.show()
          
          # Bouton dossier de réception
          self.bouton_dos = gtk.Button("Ouvrir le dossier", gtk.STOCK_OPEN)
          self.bouton_dos.connect("clicked", self.dossier_r, "bouton E")
          tableau3.attach(self.bouton_dos, 2, 3, 2, 3, xpadding=5, ypadding=2)
          self.bouton_dos.show()
          
          # Bouton annuler
          self.bouton_annul = gtk.Button("Annuler le téléchargement", gtk.STOCK_CANCEL)
          self.bouton_annul.connect("clicked", self.cancel, "bouton D")
          tableau3.attach(self.bouton_annul, 3, 4, 2, 3, xpadding=5, ypadding=2)
          self.bouton_annul.set_sensitive(False)
          self.bouton_annul.show()
      
      def set_canal(self):
          self.page_canal = self.notebook.get_nth_page(1)
          alignment = gtk.Alignment(0,0)
          alignment.show()
              
          # Creation de la boite (recherche, champ, bouton rechercher)
          self.boite_rech = gtk.VBox()
          self.page_canal.add(self.boite_rech)
          self.boite_rech.show()
          
          # entourage
          cadre = gtk.Frame("")
          self.boite_rech.add(cadre)
          cadre.show()
          
          #création du tableau
          tableau = gtk.Table(rows=4, columns=8, homogeneous=True)
          tableau.get_row_spacing(0)
          cadre.add(tableau)
          tableau.show()
          
          etiquette = gtk.Label ("Recherchez votre vidéo sur le site MyCanal:")
          etiquette.set_alignment(0.5, 0.5)
          tableau.attach(etiquette, 3, 5, 0, 1)
          etiquette.show()
          
          #lien
          lien = gtk.LinkButton("https://www.mycanal.fr/",label="https://www.mycanal.fr/")
          tableau.attach(lien, 5, 7, 0, 1)
          #self.boite_rech2.pack_start(lien, True, False, 0)
          lien.set_alignment(0.5, 0.5)
          lien.show()
          
          #champ de la recherche:
          self.champ_rech_canal = gtk.Entry()
          self.champ_rech_canal.set_max_length(200)
          self.champ_rech_canal.set_width_chars(17)
          self.champ_rech_canal.connect("activate", self.recherche_rub_canal, self.champ_rech_canal)
          self.champ_rech_canal.set_text("")
          tableau.attach(self.champ_rech_canal, 2, 6, 0, 1, xpadding=10, ypadding=2)
          #self.champ_rech_canal.show()
          
          # Nouvelle boite pour le bouton rechercher
          boite_rech2 = gtk.HButtonBox()
          boite_rech2.set_border_width(0)
          boite_rech2.set_layout(gtk.BUTTONBOX_START)
          tableau.attach(boite_rech2, 6, 8, 0, 1, xpadding=10, ypadding=2)
          #boite_rech2.show()
          
          #bouton rechercher
          bouton3 = gtk.Button("A", gtk.STOCK_FIND)
          bouton3.connect("clicked", self.recherche_rub_canal, "bouton B")
          boite_rech2.pack_start(bouton3)
          #bouton3.show()
          
          #case rubrique
          if self.choix_taillehl == "petite False":
              self.check_rub = gtk.CheckButton("Chercher dans les rubriques")
          if self.choix_taillehl == "petite True":
              self.check_rub = gtk.CheckButton("Rubriques")
          self.check_rub.connect("toggled", self.rub_actif, "rub")
          self.check_rub.set_alignment(0.5, 0.5)
          tableau.attach(self.check_rub, 5, 8, 1, 2, xpadding=10, ypadding=2)
          self.check_rub.set_active(True)
          #self.check_rub.show()
          
          #Rubriques
          self.result = None
          self.liste_url_canal_rub = ["Rubriques"]
          self.liststore_canal_rub = gtk.ListStore(gobject.TYPE_STRING)
          for item in self.liste_url_canal_rub:
              self.liststore_canal_rub.append([item])
          cell = gtk.CellRendererText()
          self.liste_canal_rub = gtk.ComboBox(self.liststore_canal_rub)
          self.liste_canal_rub.pack_start(cell, True)
          self.liste_canal_rub.add_attribute(cell, "text", 0)
          self.liste_canal_rub.set_active(0)
          tableau.attach(self.liste_canal_rub, 0, 8, 1, 2, xpadding=10, ypadding=2)
          self.liste_canal_rub.connect("changed", self.result_recherche_canal_rub)
          #self.liste_canal_rub.show()
          
          #Résultat de la recherche
          self.liste_url_canal = ["Vidéos"]
          self.liststore_canal = gtk.ListStore(gobject.TYPE_STRING)
          for item in self.liste_url_canal:
              self.liststore_canal.append([item])
          cell = gtk.CellRendererText()
          self.liste_canal = gtk.ComboBox(self.liststore_canal)
          self.liste_canal.pack_start(cell, True)
          self.liste_canal.add_attribute(cell, "text", 0)
          self.liste_canal.set_active(0)
          tableau.attach(self.liste_canal, 0, 8, 2, 3, xpadding=10, ypadding=2)
          self.liste_canal.connect("changed", self.result_recherche_canal)
          #self.liste_canal.show()

          etiquette = gtk.Label ("Adresse de la vidéo Canal+:")
          etiquette.set_alignment(0.5, 0.5)
          tableau.attach(etiquette, 0, 2, 1, 3, xpadding=10, ypadding=2)
          etiquette.show()
          
          #champ de l'adresse
          self.champ_adr_canal = gtk.Entry()
          self.champ_adr_canal.set_max_length(300)
          self.champ_adr_canal.set_width_chars(60)
          self.champ_adr_canal.connect("activate", self.detail_canal, self.champ_adr_canal)
          if self.rep == "Veuillez choisir un dossier":
              self.champ_adr_canal.set_text("Premier démarrage? Veuillez choisir un dossier de réception dans les options svp")
          else:
              self.champ_adr_canal.set_text("")
          tableau.attach(self.champ_adr_canal, 2, 7, 1, 3, xpadding=10, ypadding=2)
          self.champ_adr_canal.set_icon_from_stock(1, gtk.STOCK_DIALOG_INFO)
          self.champ_adr_canal.set_icon_activatable(1, True)
          self.champ_adr_canal.connect("icon-release", self.info)
          self.champ_adr_canal.show()
          
          # Nouvelle boite pour le bouton coller
          boite_col = gtk.HButtonBox()
          boite_col.set_border_width(5)
          tableau.attach(boite_col, 7, 8, 1, 3, xpadding=0, ypadding=0)
          boite_col.show()
          
          # bouton coller
          bouton_coller_canal = gtk.Button("A", gtk.STOCK_PASTE)
          bouton_coller_canal.connect("clicked", self.coller_canal, "bouton coller")
          boite_col.pack_start(bouton_coller_canal)
          bouton_coller_canal.show()
          
          if self.environ == "Unity" and self.h == 100:
             pass
          else:
             # entourage détails
             cadre2 = gtk.Frame("Détails de la vidéo")
             self.boite_rech.add(cadre2)
             #cadre2.show()
          
          #création du tableau 2
          tableau_text = gtk.Table(rows=2, columns=4, homogeneous=True)
          if self.environ == "Unity" and self.h == 100:
             self.boite_rech.add(tableau_text)
          else:
             cadre2.add(tableau_text)
          #tableau_text.show()
     
          #textview
          self.fd_canal = gtk.ScrolledWindow()
          self.fd_canal.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
          self.textview_canal = gtk.TextView()
          self.textview_canal.set_size_request(-1, 40)
          self.textview_canal.set_editable(False)
          self.textview_canal.set_wrap_mode(gtk.WRAP_WORD)
          self.textview_canal.set_cursor_visible(True)
          self.textview_canal.set_justification(gtk.JUSTIFY_LEFT)
          self.buffertexte_canal = self.textview_canal.get_buffer()
          self.edition_canal = self.textview_canal.get_editable()
          self.iterdebut_canal = self.buffertexte_canal.get_end_iter()
          self.buffertexte_canal.set_text("")
          self.fd_canal.add(self.textview_canal)
          if self.environ == "Unity" and self.h == 100:
             pass
          else:
             self.fd_canal.show()
          self.textview_canal.show()   
          
          self.boite_txt_canal = gtk.HBox()
          self.boite_txt_canal.pack_start(self.fd_canal)
          self.boite_txt_canal.show()
          
          if self.choix_taillehl == "petite False":
             tableau_text.attach(self.boite_txt_canal, 0, 3, 0, 2, xpadding=10, ypadding=35)
          else:
             tableau_text.attach(self.boite_txt_canal, 0, 3, 0, 2, xpadding=10, ypadding=5)

          #image
          self.img_canal = gtk.Image()
          self.img_canal.set_from_pixbuf(None)
          self.boite_img_canal = gtk.VButtonBox()
          self.boite_img_canal.pack_start(self.img_canal)
          self.boite_img_canal.show()
          self.img_canal.show()
          
          if self.choix_taillehl == "petite False":
             tableau_text.attach(self.boite_img_canal, 3, 4, 0, 2, xpadding=10, ypadding=5)
          else:
             tableau_text.attach(self.boite_img_canal, 3, 4, 0, 2, xpadding=0, ypadding=5)
          
          if self.choix_taillehl == "petite False":
             # entourage
             cadre2 = gtk.Frame("Téléchargement")
             self.boite_rech.add(cadre2)
             cadre2.show()
          
          #création du tableau
          if self.environ == "Unity" and self.h == 100:
             tableau2 = gtk.Table(rows=3, columns=4, homogeneous=False)
          else:
             tableau2 = gtk.Table(rows=3, columns=4, homogeneous=True)
          tableau2.get_row_spacing(0)
          if self.choix_taillehl == "petite False":
             cadre2.add(tableau2)
          else:
             self.boite_rech.add(tableau2)
          tableau2.show()
          
          # Bouton télécharger
          self.bouton9 = gtk.Button("Télécharger ! ")       
          self.bouton9.connect("clicked", self.pre_download, "bouton download_canal")
          if self.environ == "Unity" and self.h == 100:
             tableau2.attach(self.bouton9, 0, 4, 1, 2, xpadding=5, ypadding=2)
          else:
             tableau2.attach(self.bouton9, 0, 4, 0, 2, xpadding=5, ypadding=2)
          if self.choix_taillehl == "petite False":
              self.bouton9.set_size_request(1, 50)
          self.bouton9.show()
          if self.rep == "Veuillez choisir un dossier":
              self.bouton9.set_sensitive(False)
          self.bouton9.show()
          
          # Centrage et taille de la barre
          align = gtk.Alignment(0.5, 0.5, 0.5, 0.5)
          tableau2.attach(align, 0, 1, 2, 3, xpadding=5, ypadding=4)
          align.show()
          
          #Barre de progression
          self.pbar_canal = gtk.ProgressBar()
          tableau2.attach(self.pbar_canal, 0, 1, 2, 3, xpadding=5, ypadding=4)
          self.pbar_canal.set_text("Téléchargement: 0 %")
          self.timer0 = gobject.timeout_add (100, self.progress_canal, self)
          self.pbar_canal.show()

          # Bouton aperçu
          self.bouton_ap_canal = gtk.Button("Aperçu de la vidéo", gtk.STOCK_MEDIA_PLAY)
          self.bouton_ap_canal.connect("clicked", self.lire, "bouton C")
          tableau2.attach(self.bouton_ap_canal, 1, 2, 2, 3, xpadding=5, ypadding=2)
          self.bouton_ap_canal.show()

          # Bouton dossier de réception
          self.bouton_dos_canal = gtk.Button("Ouvrir le dossier", gtk.STOCK_OPEN)
          self.bouton_dos_canal.connect("clicked", self.dossier_r, "bouton E")
          tableau2.attach(self.bouton_dos_canal, 2, 3, 2, 3, xpadding=5, ypadding=2)
          self.bouton_dos_canal.show()
          
          # Bouton annuler
          self.bouton_an_canal = gtk.Button("Annuler le téléchargement", gtk.STOCK_CANCEL)
          self.bouton_an_canal.connect("clicked", self.cancel, "bouton D")
          tableau2.attach(self.bouton_an_canal, 3, 4, 2, 3, xpadding=5, ypadding=2)
          self.bouton_an_canal.set_sensitive(False)
          self.bouton_an_canal.show()

      def set_multi_chaine(self):
          self.multi_chaine = self.notebook.get_nth_page(2)
          alignment = gtk.Alignment(0,0)
          alignment.show()
          #self.boite_pluzz = self.notebook.get_nth_page(2)
          #alignment = gtk.Alignment(0,0)
          
          # Nouvelle boite pour l'icone
          boite = gtk.VBox(False, 0)
          self.multi_chaine.add(boite)
          boite.show()
          
          # Chargement de l'icone
          image = "/usr/share/icons/dPluzz-ico.png"
          img = gtk.Image()
          img.set_from_file(image)
          img.show()
          
          #texte vide
          etiquette = gtk.Label("")
          text = """ """
          etiquette.set_markup(text)
          etiquette.set_alignment(0.5, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          boite.pack_start(etiquette, True, False, 0)
          etiquette.show()
          
          # Ajout de l'image dans la fenetre et affichage
          boite.add(img)
          
          #texte
          etiquette = gtk.Label("")
          text = """<b>Téléchargement multi-chaines:</b>\n\nC8, CStar, iTélé, NRJ12, Cherie25, Gulli, TV5 Monde (+Afrique)\n France Info (TV), Arte (+7, Concert), LCP-AN, Public Sénat, M6, W9, 6ter, Numéro23, L'Équipe, Dailymotion\n\n Collez ici une adresse web correspondant à une vidéo d'une de ces chaines, puis téléchargez:\n\n"""
          etiquette.set_markup(text)
          etiquette.set_alignment(0.5, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          boite.pack_start(etiquette, True, False, 0)
          etiquette.show()
          
          # Creation de la boite
          self.boite_rech = gtk.VBox()
          self.multi_chaine.add(self.boite_rech)
          
          # entourage
          cadre = gtk.Frame("Recherche")
          self.boite_rech.add(cadre)
          self.boite_rech.show()
          
          # entourage téléchargement
          if self.environ == "Unity":
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=False)
          else:
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=True)
          if self.choix_taillehl == "petite False":
             cadre3 = gtk.Frame("")
             self.boite_rech.add(cadre3)
             cadre3.show()
             cadre3.add(tableau3)
          else:
             self.boite_rech.add(tableau3)
          tableau3.get_row_spacing(0)
          tableau3.show()
          
          #Etiquette
          etiquette = gtk.Label ("Adresse de la vidéo:")
          etiquette.set_alignment(0.8, 0.5)
          tableau3.attach(etiquette, 0, 2, 0, 1, xpadding=0, ypadding=0)
          etiquette.show()
          
          #champ de l'adresse
          self.champ_multi = gtk.Entry()
          self.champ_multi.set_max_length(300)
          self.champ_multi.set_width_chars(20)
          self.champ_multi.connect("activate", self.detail, self.champ_multi)
          if self.rep == "Veuillez choisir un dossier":
              self.champ_multi.set_text("Premier démarrage? Veuillez choisir un dossier de réception dans les options svp")
          else:
              self.champ_multi.set_text("")
          tableau3.attach(self.champ_multi, 2, 7, 0, 1, xpadding=10, ypadding=2)
          self.champ_multi.set_icon_from_stock(1, gtk.STOCK_DIALOG_INFO)
          self.champ_multi.set_icon_activatable(1, True)
          self.champ_multi.connect("icon-release", self.info)
          self.champ_multi.show()
          
          # Nouvelle boite pour le bouton coller
          boite_col = gtk.HButtonBox()
          boite_col.set_border_width(0)
          tableau3.attach(boite_col, 7, 8, 0, 1, xpadding=0, ypadding=0)
          boite_col.show()
          
          # bouton coller
          bouton_coller_multi = gtk.Button("A", gtk.STOCK_PASTE)
          bouton_coller_multi.connect("clicked", self.coller, "bouton coller")
          boite_col.pack_start(bouton_coller_multi)
          bouton_coller_multi.show()
          
          # entourage téléchargement
          if self.environ == "Unity":
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=False)
          else:
             tableau3 = gtk.Table(rows=3, columns=4, homogeneous=True)
          if self.choix_taillehl == "petite False":
             cadre3 = gtk.Frame("")
             self.boite_rech.add(cadre3)
             cadre3.show()
             cadre3.add(tableau3)
          else:
             self.boite_rech.add(tableau3)
          tableau3.get_row_spacing(0)
          tableau3.show()
          
          # Bouton télécharger
          self.bouton8 = gtk.Button("Télécharger ! ") #, gtk.STOCK_SAVE)       
          self.bouton8.connect("clicked", self.pre_download, "bouton download")
          tableau3.attach(self.bouton8, 0, 4, 0, 2, xpadding=5, ypadding=2)
          self.bouton8.show()
          if self.rep == "Veuillez choisir un dossier":
              self.bouton8.set_sensitive(False)
          
          #Barre de progression
          self.pbar_multi = gtk.ProgressBar()
          self.pbar_multi.show()     
          if self.h == 100 and self.environ == "Unity":
             tableau3.attach(self.pbar_multi, 0, 1, 2, 3, xpadding=5, ypadding=4)
          else:
             tableau3.attach(self.pbar_multi, 0, 1, 2, 3, xpadding=5, ypadding=4)
          self.pbar_multi.set_text("Téléchargement: 0 %")
          self.pbar_multi.show()
          
          # Bouton aperçu
          self.bouton_apercu_multi = gtk.Button("Lire", gtk.STOCK_MEDIA_PLAY)
          self.bouton_apercu_multi.connect("clicked", self.lire, "bouton C")
          tableau3.attach(self.bouton_apercu_multi, 1, 2, 2, 3, xpadding=5, ypadding=2)
          self.bouton_apercu_multi.show()
          
          # Bouton dossier de réception
          self.bouton_dos = gtk.Button("Ouvrir le dossier", gtk.STOCK_OPEN)
          self.bouton_dos.connect("clicked", self.dossier_r, "bouton E")
          tableau3.attach(self.bouton_dos, 2, 3, 2, 3, xpadding=5, ypadding=2)
          self.bouton_dos.show()
          
          # Bouton annuler
          self.bouton_annul_multi = gtk.Button("Annuler le téléchargement", gtk.STOCK_CANCEL)
          self.bouton_annul_multi.connect("clicked", self.cancel, "bouton D")
          tableau3.attach(self.bouton_annul_multi, 3, 4, 2, 3, xpadding=5, ypadding=2)
          self.bouton_annul_multi.set_sensitive(False)
          self.bouton_annul_multi.show()
          
      def terminal(self):
          self.page_terminal = self.notebook.get_nth_page(3)
          alignment = gtk.Alignment(0,0)
          alignment.show()
              
          self.boite_term = gtk.VBox()
          self.page_terminal.add(self.boite_term)
          self.boite_term.show()
          
          def on_button_scroll_event(button, event):
             if event.direction == gtk.gdk.SCROLL_UP:
                vscroll.emit("move-slider", gtk.SCROLL_PAGE_UP)
             if event.direction == gtk.gdk.SCROLL_DOWN:
                vscroll.emit("move-slider", gtk.SCROLL_PAGE_DOWN)
          
          #création du tableau
          tableau2 = gtk.Table(rows=10, columns=10, homogeneous=False)
          self.boite_term.add(tableau2)
          tableau2.show()
          
          #Terminal
          self.v = vte.Terminal()
          audible = 0
          visible = 0
          self.v.set_emulation('xterm')
          self.v.set_audible_bell(audible)
          self.v.set_visible_bell(visible)
          self.v.connect ("child-exited", lambda term: self.verif(self, dPluzz))
          self.v.connect("contents-changed", self.preterm)
          if self.choix_taillehl == "petite False":
             self.v.set_size(40,20)
          if self.choix_taillehl == "petite True":
             self.v.set_size(40,5)
          self.v.set_encoding("UTF-8")
          self.v.copy_clipboard()
          self.v.set_cursor_blinks(False) 
          self.v.set_scroll_on_output(True)
          self.v.set_scroll_on_keystroke(True)
          #self.v.connect("scroll-event", on_button_scroll_event)
          self.v.set_scrollback_lines(5000)
          
          # font for terminal
          font = pango.FontDescription()
          if "openSUSE" in self.release:
             font.set_family("Oxygen Mono")
          else:
             font.set_family("Ubuntu Mono")
          if self.environ == "Unity":
             font.set_size(11 * pango.SCALE) # font size
          else:
             font.set_size(12 * pango.SCALE)
          font.set_weight(pango.WEIGHT_NORMAL)
          font.set_stretch(pango.STRETCH_NORMAL)
          self.v.set_font_full(font, True)
          
          scroll = gtk.ScrolledWindow()
          scroll.set_policy(1,0)
          scroll.add(self.v)
          tableau2.attach(scroll, 0, 10, 0, 9, xpadding=0, ypadding=0)
          
          scroll.show()
          vadjustment = scroll.get_vadjustment()
          vscroll = gtk.VScrollbar(vadjustment)
          
          # Nouvelle boite pour le bouton copier
          boite_copy = gtk.VButtonBox()
          tableau2.attach(boite_copy, 0, 10, 9, 10, xpadding=0, ypadding=0)
          boite_copy.show()
          
          #bouton copier
          bouton_copy = gtk.Button("A", gtk.STOCK_COPY)
          bouton_copy.connect("clicked", self.copy_term, "bouton B")
          boite_copy.pack_end(bouton_copy, True, True, 0)
          bouton_copy.show()
          
          self.v.show()
          
      def set_options(self):
          self.boite_option = self.notebook.get_nth_page(4)
          alignment = gtk.Alignment(0,0)
          alignment.show()
          
          # entourage
          cadre = gtk.Frame("Général")
          cadre.set_label_align(0.5, 0.5)
          self.boite_option.add(cadre)
          cadre.show()
          
          #création d'un tableau
          tableau = gtk.Table(rows=4, columns=3, homogeneous=True)
          cadre.add(tableau)
          tableau.show()
          
          etiquette = gtk.Label ("Dossier de réception:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau.attach(etiquette, 0, 1, 0, 1)
          etiquette.show()
          
          #champ du dossier
          self.champ_dossier_reception = gtk.Entry()
          self.champ_dossier_reception.set_max_length(200)
          self.champ_dossier_reception.set_width_chars(65)
          if self.choix_taillehl == "petite True":
             self.champ_dossier_reception.connect("activate", self.dossier, self.liste)
          self.champ_dossier_reception.set_text(self.rep)
          self.champ_dossier_reception.show()
          tableau.attach(self.champ_dossier_reception, 1, 2, 0, 1, xpadding=5, ypadding=0)
          self.champ_dossier_reception.show()
              
          # Nouvelle boite pour le bouton parcourir 
          boite = gtk.HButtonBox()
          boite.set_layout(gtk.BUTTONBOX_START) 
          tableau.attach(boite, 2, 3, 0, 1)
          boite.show()
          
          # Bouton parcourir
          bouton_dos = gtk.Button("Parcourir...")       
          bouton_dos.connect("clicked", self.dossier, "bouton dossier")
          boite.pack_start(bouton_dos, False, False, 1)
          bouton_dos.show()
          
          #etiquette choix taille
          etiquette = gtk.Label ("Fenêtre principale:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau.attach(etiquette, 0, 1, 1, 2)
          
          # case de la taille de la fenêtre
          self.check_taille = gtk.CheckButton("Compacter la fenêtre (redémarrer dPluzz)")     
          self.check_taille.connect("toggled", self.taille, "petite")
          self.check_taille.set_alignment(0, 0)
          tableau.attach(self.check_taille, 1, 3, 1, 2, xpadding=20, ypadding=0)
          if self.choix_taillehl == "petite True":
              self.check_taille.set_active(True)
          self.check_taille.show()
          
          # case de la taille
          self.check_max = gtk.CheckButton("Sauvegarder les dimensions de la fenêtre")     
          self.check_max.connect("toggled", self.haut_larg, "taille")
          self.check_max.set_alignment(0, 0)
          tableau.attach(self.check_max, 1, 3, 2, 3, xpadding=20, ypadding=0)
          if "tailleTrue" in self.choix_taille:
              self.check_max.set_active(True)
          self.check_max.show()
          
          # case de la taille
          self.check_bord = gtk.CheckButton("Supprimer les bordures (KDE)")     
          self.check_bord.connect("toggled", self.bordure, "bord")
          self.check_bord.set_alignment(0, 0)
          tableau.attach(self.check_bord, 1, 2, 3, 4, xpadding=20, ypadding=0)
          if "bordTrue" in self.choix_bordure:
              self.check_bord.set_active(True)
          self.check_bord.show()
          
          #etiquette suppression fichier
          etiquette = gtk.Label ("Bouton Annuler / Dl interrompu:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau.attach(etiquette, 0, 1, 4, 5)
          etiquette.show()
          
          # case de la suppression du fichier
          self.check_mkv = gtk.CheckButton("Ne pas supprimer le fichier")     
          self.check_mkv.connect("toggled", self.suppr_video, "garder_video")
          self.check_mkv.set_alignment(0.5, 0.5)
          tableau.attach(self.check_mkv, 1, 2, 4, 5, xpadding=20, ypadding=0)
          if self.option_mkv == "mkvTrue":
             self.check_mkv.set_active(True)
          if self.choix_suppr_video == 'garder_videoTrue':
             self.check_mkv.set_active(True) 
          self.check_mkv.show()   

          #etiquette renommage
          etiquette = gtk.Label ("Renommer le fichier reçu:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau.attach(etiquette, 0, 1, 5, 6)
          etiquette.show()
          
          # Nouvelle boite pour le champ
          boite_arg = gtk.HButtonBox()
          boite_arg.set_layout(gtk.BUTTONBOX_START) 
          tableau.attach(boite_arg, 1, 2, 5, 6, xpadding=20, ypadding=0)
          boite_arg.show()
          
          #champ du renommage
          self.champ_arg = gtk.Entry()
          self.champ_arg.set_max_length(100)
          self.champ_arg.set_width_chars(25)
          self.champ_arg.connect("activate", self.ok_arg)
          if self.arg == "rien":
              self.champ_arg.set_text("")
          else:
              self.champ_arg.set_text(str(self.arg))
          self.champ_arg.set_sensitive(True)
          self.champ_arg.set_icon_from_stock(1, gtk.STOCK_DIALOG_INFO)
          self.champ_arg.set_icon_activatable(1, True)
          self.champ_arg.connect("icon-release", self.info_arg)
          self.champ_arg.show()
          boite_arg.pack_start(self.champ_arg, True, True, 0)
          
          # Nouvelle boite pour le bouton ok
          boite_arg_ok = gtk.HButtonBox()
          boite_arg_ok.set_layout(gtk.BUTTONBOX_START) 
          tableau.attach(boite_arg_ok, 2, 3, 5, 6, xpadding=0, ypadding=0)
          boite_arg_ok.show()
          
          # Bouton ok
          bouton_val_com = gtk.Button("OK")       
          bouton_val_com.connect("clicked", self.ok_arg, "bouton val_arg")
          boite_arg_ok.pack_end(bouton_val_com, True, True, 0)
          bouton_val_com.show()

          #etiquette notification
          etiquette = gtk.Label ("Notification quand Dl terminé / interrompu:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau.attach(etiquette, 0, 1, 6, 7)
          etiquette.show()
          
          # case de notification
          self.check_notif = gtk.CheckButton("Activer la notification")     
          self.check_notif.connect("toggled", self.notification, "notif")
          self.check_notif.set_alignment(0.5, 0.5)
          tableau.attach(self.check_notif, 1, 2, 6, 7, xpadding=20, ypadding=0)
          if self.choix_notif == "notifTrue":
             self.check_notif.set_active(True)
          else:
             self.check_notif.set_active(False)
          self.check_notif.show()
          
          # Nouvelle boite pour le bouton essai
          boite_btn_essai = gtk.HButtonBox()
          boite_btn_essai.set_layout(gtk.BUTTONBOX_START) 
          tableau.attach(boite_btn_essai, 2, 3, 6, 7, xpadding=0, ypadding=0)
          boite_btn_essai.show()
          
          # Bouton ok
          bouton_essai = gtk.Button("Essayer la notification")       
          bouton_essai.connect("clicked", self.essai_notification, "bouton notification")
          boite_btn_essai.pack_start(bouton_essai, False, False, 1)
          bouton_essai.show()
          
          # entourage 2
          cadre2 = gtk.Frame("Options vidéo")
          cadre2.set_label_align(0.5, 0.5)
          self.boite_option.add(cadre2)
          cadre2.show()
          
          #création du tableau 2
          tableau2 = gtk.Table(rows=4, columns=5, homogeneous=False)
          cadre2.add(tableau2)
          tableau2.show()
          
          #etiquette choix lecteur
          etiquette = gtk.Label ("Encodeur:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 0, 1, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour les boutons radio
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 1, 3, 0, 1, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # boutons radio encodeur
          self.radio = gtk.RadioButton(None, "encodeur")
          
          # case de ffmpeg
          self.check = gtk.RadioButton(self.radio, "FFmpeg")     
          self.check.connect("toggled", self.ffmpeg_actif, "ffmpeg")
          self.check.set_alignment(1, 0)
          boite_vo.pack_start(self.check, False, False, 1)
          self.check.show()
          
          # case de avconv
          self.check_av = gtk.RadioButton(self.radio, "AvConv")
          self.check_av.connect("toggled", self.ffmpeg_actif, "ffmpeg")
          self.check_av.set_alignment(0, 1)
          boite_vo.pack_start(self.check_av, False, False, 1)
          
          #distrib = platform.dist()
          if self.release == ('Ubuntu', '12.04', 'precise'):
             self.check.set_active(True)
          elif self.release == ('Ubuntu', '13.10', 'saucy'):
             self.check.set_active(True)
          elif self.release == ('Ubuntu', '14.04', 'trusty'):
             self.check.set_active(False)
          elif self.release == ('Ubuntu', '14.10', 'utopic'):
             self.check.set_active(False)
          elif self.release == ('Ubuntu', '18.10', 'bionic'):
             self.check.set_active(True)
          elif "openSUSE" in self.release:
             self.check.set_active(True)
          if self.option_ffmpeg == "ffmpegTrue":
                 self.check.set_active(True)
          elif self.option_ffmpeg == "ffmpegFalse":
                 self.check_av.set_active(True)
          self.check_av.show()
          
          #etiquette codec
          etiquette = gtk.Label ("Codec vidéo:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 1, 2, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour les boutons radio
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 1, 2, 1, 2, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # boutons codec
          self.radio_conteneur_video = gtk.RadioButton(None, "conteneur_video")
          
          # case de copy
          self.radio_codec_video_mkv = gtk.RadioButton(self.radio_conteneur_video, "mkv")     
          self.radio_codec_video_mkv.connect("toggled", self.radio_conteneur_video_mkv, "mkv")
          self.radio_codec_video_mkv.set_alignment(1, 0)
          boite_vo.pack_start(self.radio_codec_video_mkv, False, False, 1)
          self.radio_codec_video_mkv.show()
          
          # case de mp4
          self.radio_codec_video_mp4 = gtk.RadioButton(self.radio_conteneur_video, "mp4")     
          self.radio_codec_video_mp4.connect("toggled", self.radio_conteneur_video_mp4, "mp4")
          self.radio_codec_video_mp4.set_alignment(0, 1)
          boite_vo.pack_start(self.radio_codec_video_mp4, False, False, 1)
          self.radio_codec_video_mp4.show()
          
          if self.option_conteneur_video == "mkv":
             self.radio_codec_video_mkv.set_active(True)
          if self.option_conteneur_video == "mp4":
             self.radio_codec_video_mp4.set_active(True)
          
          #etiquette conteneur
          etiquette = gtk.Label ("Conteneur vidéo:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 2, 3, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour les boutons radio
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 1, 2, 2, 3, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # boutons codec
          self.radio_encodeur_video = gtk.RadioButton(None, "codec_video")
          
          # case de copy
          self.radio_encodeur_copy = gtk.RadioButton(self.radio_encodeur_video, "Matroska (copy)")     
          self.radio_encodeur_copy.connect("toggled", self.set_encodeur_video, "copy")
          self.radio_encodeur_copy.set_alignment(1, 0)
          boite_vo.pack_start(self.radio_encodeur_copy, False, False, 1)
          self.radio_encodeur_copy.show()
          
          # case de x264
          self.radio_encodeur_x264 = gtk.RadioButton(self.radio_encodeur_video, "x264 (expérimental)")     
          self.radio_encodeur_x264.connect("toggled", self.set_encodeur_video, "x264")
          self.radio_encodeur_x264.set_alignment(0, 1)
          boite_vo.pack_start(self.radio_encodeur_x264, False, False, 1)
          self.radio_encodeur_x264.show()
          
          if self.option_encodeur_video == "copy":
             self.radio_encodeur_copy.set_active(True)
          if self.option_encodeur_video == "x264":
             self.radio_encodeur_x264.set_active(True)
          
          #etiquette VO
          etiquette = gtk.Label ("Sous titres & VO:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 3, 4, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour la case
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 1, 3, 3, 4, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # case de la VO
          self.case_vo = gtk.CheckButton("Télécharger la VO (si possible)")     
          self.case_vo.connect("toggled", self.vo, "vo")
          self.case_vo.set_alignment(0, 0.5)
          if self.choix_vo == "voTrue":
              self.case_vo.set_active(True)
          if self.choix_vo == "voFalse":
              self.case_vo.set_active(False)
          boite_vo.pack_start(self.case_vo, False, False, 1)
          self.case_vo.show()
          
          # case des sous titres
          self.case_sstitre = gtk.CheckButton("Télécharger les sous titres")     
          self.case_sstitre.connect("toggled", self.soustitre, "sstitre")
          self.case_sstitre.set_alignment(0, 0.5)
          if self.choix_sstitre == "sstitreTrue":
              self.case_sstitre.set_active(True)
          if self.choix_sstitre == "sstitreFalse":
              self.case_sstitre.set_active(False)
          boite_vo.pack_start(self.case_sstitre, False, False, 1)
          self.case_sstitre.show()
          
          # case des sous titres
          #self.case_command = gtk.CheckButton("Malentendants")     
          #self.case_command.connect("toggled", self.soustitre_malent, "sstitre_malent")
          #self.case_command.set_alignment(0, 0.5)
          #if self.option_command == 1:
          #    self.case_command.set_active(True)
          #if self.command_text == "":
          #    self.case_command.set_active(False)
          #boite_vo.pack_start(self.case_command, False, False, 1)
          #self.case_command.show()
          
          #etiquette conteneur
          etiquette = gtk.Label ("Type:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 2, 3, 3, 4, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour les boutons radio
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 3, 4, 3, 4, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # boutons codec
          self.radio_mode_sstitre = gtk.RadioButton(None, "codec_video")
          
          # case de srt
          self.radio_mode_sstitre_srt = gtk.RadioButton(self.radio_mode_sstitre, "srt")     
          self.radio_mode_sstitre_srt.connect("toggled", self.set_mode_sstitre, "srt")
          self.radio_mode_sstitre_srt.set_alignment(1, 0)
          boite_vo.pack_start(self.radio_mode_sstitre_srt, False, False, 1)
          self.radio_mode_sstitre_srt.show()
          
          # case de ass
          self.radio_mode_sstitre_ass = gtk.RadioButton(self.radio_mode_sstitre, "ass")     
          self.radio_mode_sstitre_ass.connect("toggled", self.set_mode_sstitre, "ass")
          self.radio_mode_sstitre_ass.set_alignment(0, 1)
          boite_vo.pack_start(self.radio_mode_sstitre_ass, False, False, 1)
          self.radio_mode_sstitre_ass.show()
          
          # case de mux
          self.radio_mode_sstitre_mux = gtk.RadioButton(self.radio_mode_sstitre, "mux")     
          self.radio_mode_sstitre_mux.connect("toggled", self.set_mode_sstitre, "mux")
          self.radio_mode_sstitre_mux.set_alignment(0, 1)
          boite_vo.pack_start(self.radio_mode_sstitre_mux, False, False, 1)
          self.radio_mode_sstitre_mux.show()
          
          if self.choix_sstitre == "sstitreFalse":
              self.radio_mode_sstitre_mux.set_sensitive(False)
              self.radio_mode_sstitre_ass.set_sensitive(False)
              self.radio_mode_sstitre_srt.set_sensitive(False)
              self.radio_mode_sstitre_srt.set_active(False)
              self.radio_mode_sstitre_ass.set_active(False)
              self.radio_mode_sstitre_mux.set_active(False)
          else:
              if self.option_mode_sstitre == "srt":
                 self.radio_mode_sstitre_srt.set_active(True)
              if self.option_mode_sstitre == "ass":
                 self.radio_mode_sstitre_ass.set_active(True)
              if self.option_mode_sstitre == "mux":
                 self.radio_mode_sstitre_mux.set_active(True)
          
          #etiquette choix lecteur
          etiquette = gtk.Label ("Lecteur vidéo:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 4, 5, xpadding=10, ypadding=0)

          # Nouvelle boite pour le choix lecteur
          boite = gtk.HButtonBox()
          boite.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite, 1, 2, 4, 5, xpadding=10, ypadding=0)
          boite.show()
          
          #choix lecteur
          try:
              myFile = open(self.home + '/.config/dPluzz/dPluzz.conf', "r")
              self.config = myFile.read(150)
              myFile.close()
              splitted = self.config.splitlines()
              self.lecteur = splitted[2]
          except:    
              self.lecteur = "mplayer"	  
          apps = []
          apps.append("mplayer")
          for root, dirs, files in os.walk('/usr/share/applications/'):
              for filename in files:
                  if ".desktop" in filename:
                    try:  
                       with open(os.path.join(root, filename), "r") as auto:
                          a = auto.read(50000)
                          if "player" in a.lower() and "video" in a.lower() and "media" in a.lower():
                              if "nodisplay=true" not in a.lower() and "clementine" not in a.lower():
                                  app = filename.replace(".desktop", "")
                                  apps.append(app)
                    except:
                       pass  
          lecteurs = apps
          self.liststore2 = gtk.ListStore(gobject.TYPE_STRING)
          for self.item in lecteurs:
              self.liststore2.append([self.item])
          cell = gtk.CellRendererText()
          self.liste2 = gtk.ComboBox(self.liststore2)
          self.liste2.pack_start(cell, True)
          self.liste2.add_attribute(cell, "text", 0)
          for pos, item in enumerate(apps):
               if item == self.lecteur:
                   self.liste2.set_active(pos)
          boite.add(self.liste2)
          self.liste2.connect("changed", self.result_lecteur)
          self.liste2.show()
          
          # Nouvelle boite pour la case
          boite2 = gtk.HButtonBox()
          boite2.set_layout(gtk.BUTTONBOX_END) 
          tableau2.attach(boite2, 1, 2, 4, 5, xpadding=0, ypadding=0)
          boite2.show()
          
          # case de Argument(s) du lecteur
          self.case_command = gtk.CheckButton("Argument(s) du lecteur:")     
          self.case_command.connect("toggled", self.command_v, "command")
          self.case_command.set_alignment(0.5, 0.5)
          if self.option_command == 1:
              self.case_command.set_active(True)
          if self.command_text == "":
              self.case_command.set_active(False)
          boite2.pack_start(self.case_command, False, False, 1)
          self.case_command.show()
          
          # Nouvelle boite pour le champ
          boite3 = gtk.HButtonBox()
          boite3.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite3, 2, 3, 4, 5, xpadding=0, ypadding=0)
          boite3.show()
          
          #champ de la commande
          self.champ_arg_lecteur = gtk.Entry()
          self.champ_arg_lecteur.set_max_length(150)
          self.champ_arg_lecteur.set_width_chars(15)
          self.champ_arg_lecteur.connect("activate", self.champ_command)
          if self.option_command == 0:
              self.champ_arg_lecteur.set_sensitive(False)
              self.champ_arg_lecteur.set_text(self.command_text)
          else:
              self.champ_arg_lecteur.set_sensitive(True)
              self.champ_arg_lecteur.set_text(str(self.command_text))
          boite3.pack_start(self.champ_arg_lecteur, False, False, 1)
          self.champ_arg_lecteur.show()
          
          # Nouvelle boite pour le bouton ok
          boite4 = gtk.HButtonBox()
          boite4.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite4, 3, 4, 4, 5, xpadding=0, ypadding=0)
          boite4.show()
          
          # Bouton ok
          bouton_val_com = gtk.Button("OK")       
          bouton_val_com.connect("clicked", self.ok_commande, "bouton val_com")
          boite4.pack_start(bouton_val_com, False, False, 1)
          bouton_val_com.show()
          
          #etiquette
          etiquette = gtk.Label ("Codec audio:")
          etiquette.set_alignment(1, 0.5)
          etiquette.show()
          tableau2.attach(etiquette, 0, 1, 5, 6, xpadding=10, ypadding=0)
          etiquette.show()
          
          # Nouvelle boite pour les boutons radio
          boite_vo = gtk.HButtonBox()
          boite_vo.set_layout(gtk.BUTTONBOX_START) 
          tableau2.attach(boite_vo, 1, 3, 5, 6, xpadding=10, ypadding=0)
          boite_vo.show()
          
          # boutons radio codec
          self.radio_encodeur_audio = gtk.RadioButton(None, "Codec audio")
          
          # case de ffmpeg
          self.radio_encodeur_aac = gtk.RadioButton(self.radio_encodeur_audio, "AAC")     
          self.radio_encodeur_aac.connect("toggled", self.set_encodeur_aac, "mp3")
          self.radio_encodeur_aac.set_alignment(1, 0)
          boite_vo.pack_start(self.radio_encodeur_aac, False, False, 1)
          self.radio_encodeur_aac.show()
          
          # case de avconv
          self.radio_encodeur_mp3 = gtk.RadioButton(self.radio_encodeur_audio, "mp3")     
          self.radio_encodeur_mp3.connect("toggled", self.set_encodeur_mp3, "mp3")
          self.radio_encodeur_mp3.set_alignment(1, 0)
          boite_vo.pack_start(self.radio_encodeur_mp3, False, False, 1)
          self.radio_encodeur_mp3.show()
          
          if self.option_mp3 == "mp3True":
             self.radio_encodeur_mp3.set_active(True)
          if self.option_mp3 == "mp3False":
             self.radio_encodeur_aac.set_active(True)
          
      def set_about(self):
          self.boite_about = self.notebook.get_nth_page(5)
          alignment = gtk.Alignment(0,0)
          
          # Nouvelle boite pour l'icone
          boite = gtk.VBox(False, 0)
          self.boite_about.add(boite)
          boite.show()

          # Chargement de l'icone
          image = "/usr/share/icons/dPluzz-ico.png"
          img = gtk.Image()
          img.set_from_file(image)
          img.show()
         
          # Ajout de l'image dans la fenetre et affichage
          self.boite_about.add(img)
          
          #texte
          etiquette = gtk.Label("")
          text = """<big><b>dPluzz+ version """ + version + """</b></big> \n
          \n<b>Moteur Pluzz version """ + versioncli + """\n\n</b> Melixgaro, Matthieugoua\nAvec la participation de nierdz et Hizoka\n<b>Moteur Canal+ / TNT:</b> Melixgaro\n<b>Interface pyGTK:</b> Gaara\nAvec la participation de Lulux3\n\nLicence: GPL\n© 2014 - 2017"""
          etiquette.set_markup(text)
          etiquette.set_alignment(0.5, 0.5)
          etiquette.set_justify(gtk.JUSTIFY_CENTER)
          self.boite_about.pack_start(etiquette, True, False, 0)
          etiquette.show()
          
          # Nouvelle boite pour le lien
          boite_txt = gtk.VBox(True, 0)
          self.boite_about.add(boite_txt)
          boite_txt.show()
          
          #lien
          lien = gtk.LinkButton("http://forum.ubuntu-fr.org/viewtopic.php?id=1559861&p=1",label="http://forum.ubuntu-fr.org/viewtopic.php?id=1559861&p=1")
          boite_txt.pack_start(lien, True, False, 0)
          lien.set_alignment(0.5, 0.5)
          lien.show()
          
          self.page.pack_start(alignment, False, False, 0)
         
      def insert_notebook(self):
          self.notebook = gtk.Notebook()
          for idx, self.page in enumerate(["Pluzz", "Canal+", "TNT", "Terminal", "Options", "À propos"]):
              vbox = gtk.VBox(False)
              if self.choix_taillehl == "petite False":
                  vbox.set_border_width(10)
              if self.choix_taillehl == "petite True":
                  vbox.set_border_width(5)
              self.notebook.append_page(vbox)
              pg = self.notebook.get_nth_page(idx)
              self.notebook.set_tab_label_text(pg, self.page)
              self.notebook.show()
          self.set_pluzz()
          self.set_canal()
          self.set_multi_chaine()
          self.set_options()
          self.set_about()
          self.terminal()
          self.box.pack_start(self.notebook)
          if self.choix_taillehl == "petite False":
              self.box.set_size_request(350, 560)    
          if self.choix_taillehl == "petite True":
              self.box.set_size_request(700, 400)    
          self.box.show()
          self.page.show()
          self.page_canal.show()
          self.multi_chaine.show()
          self.page_terminal.show()
          self.boite_option.show()
          self.boite_about.show()
          
      def __init__(self):   
          #import os
          os.environ["CDP"] = "False"
          self.home = os.getenv("HOME")
          self.choix = "ffmpegFalse"
          self.option_mkv = "mkvFalse"
          self.option_mp3 = "mp3False"
          self.l = 1100
          self.h = 650
          self.option_command = 0
          self.command = 0
          self.command_text = ""
          self.index = 0
          self.arg = "rien"
          self.environ = os.environ.get('XDG_CURRENT_DESKTOP')
          self.release = platform.dist()
          if self.release == ('', '', ''):
             self.release = open('/etc/os-release','r').read().split('\n')[5].split('.')
             for a in self.release:
                 self.release = a
          if debug == 1:
             print "DISTRIBUTION:", self.release
             print "ENVIRONNEMENT:", self.environ
             print "Version du programme:", version
             print "Version du moteur:", versioncli
          self.http_error = 0
          self.choix_taille = "tailleFalse"
          self.choix_notif = "notifFalse"
          self.choix_bordure = 'bordFalse'
          self.liste_adresse, self.liste_mots = [], []
          self.dict_adresse = [[],[]]
          self.liste_details = defaultdict(list)
          self.nbre_mot = 1
          self.mem_ID = ""
          self.titre_mem, self.image_mem, self.list_fonct = [], [], []
          self.nbr = []
          self.num_objets_clic = []
          self.tri = "defaut"
          self.choix_sstitre = "sstitreFalse"
          self.choix_vo = "voFalse"
          self.option_conteneur_video = "mkv"
          self.option_mode_sstitre = "srt"
          self.option_encodeur_video = "copy"
          self.child_pid = 1
          self.annul = 0
          self.choix_suppr_video = "garder_videoFalse"
          try:
              os.mkdir(self.home + "/.cache/dPluzz")
          except:
              pass
          try:
              os.mkdir(self.home + "/.cache/dPluzz/img")
          except:
              pass
          try:
             os.mkdir(self.home + "/.config/dPluzz")
          except:
             pass
          try:
              myFile = open(self.home + '/.config/dPluzz/dPluzz.conf', "r")
              self.config = myFile.read(1500)
              myFile.close()
              splitted = self.config.splitlines()#un paramètre par ligne(nouveau format)
              if len(splitted) == 1: #fichier une seule ligne: ancien format
                  splitted = self.config.split()        
              self.rep = splitted[0]
              # démarrage normal
              try:
                  self.option_ffmpeg = splitted[1]
                  if not "ffmpeg" in self.option_ffmpeg:
                      self.option_ffmpeg = "ffmpegFalse"
              except:
                  self.option_ffmpeg = "ffmpegFalse"
              try:
                  self.lecteur = splitted[2]
              except:
                  self.lecteur = "mplayer"
              try:
                  self.option_mkv = splitted[3]
              except:
                  self.option_mkv = "mkvFalse"
              try:
                  self.h = int(splitted[4])
              except:
                  self.h = 650
              try:
                  self.option_mp3 = splitted[5]
              except:
                  self.option_mp3 = "mp3False"
              try:
                  self.option_command = int(splitted[6])
              except:
                  self.option_command = 0
              try:
                 self.choix_taille = splitted[7]
              except:
                 self.choix_taille = "tailleFalse"
              try:
                 self.choix_notif = splitted[8]
              except:
                 self.choix_notif = "notifFalse"
              try:
                 self.arg = splitted[9]
              except:
                 self.arg = "rien"
              try:
                 self.choix_bordure = splitted[10]
              except:
                 self.choix_bordure = "bordFalse"
              try:
                  self.choix_vo = splitted[11]
              except:
                  self.choix_vo = "voFalse"
              try:
                  self.choix_sstitre = splitted[12]
              except:
                  self.choix_sstitre = "sstitreFalse"
              try:
                  self.option_encodeur_video = splitted[13]
              except:
                  self.option_encodeur_video = "copy"
              try:
                  self.option_conteneur_video = splitted[14]
              except:
                  self.option_conteneur_video = "mkv"
              try:
                  self.option_mode_sstitre = splitted[15]
              except:
                  self.option_mode_sstitre = "srt"
              try:
                  self.command_text = splitted[16]
              except:
                  self.command_text = ""
              try:
                  self.choix_suppr_video = splitted[17]
              except:
                  self.choix_suppr_video = "garder_videoFalse"  
          except:
              self.rep = "Veuillez choisir un dossier"
              self.option_ffmpeg = "ffmpegFalse"
          self.fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)   
          if self.choix_bordure == "bordTrue":
             if self.environ == "LXDE":
                self.fenetre = gtk.Window(gtk.WINDOW_POPUP)
             self.fenetre.connect('size-allocate', self.reshaperect)
          
          #Titre et taille
          self.fenetre.set_title('dPluzz+')
          if self.h <= 500:
              self.choix_taillehl = "petite True"
              self.l = 825
          else:
              self.choix_taillehl = "petite False"
              self.h = 650
              if self.environ == "Unity":
                  self.l = 1100
          self.fenetre.set_position(gtk.WIN_POS_CENTER)
          if "tailleTrue" in self.choix_taille:
              size = self.choix_taille.replace("tailleTrue/", "")
              size = size.replace('(','')
              size = size.replace(')','')
              size = size.replace(',',' ')
              splitted = size.split()
              l = int(splitted[0])
              h = int(splitted[1])
              try:
                 self.fenetre.set_default_size(l, h)
              except:
                 self.fenetre.set_default_size(self.l, self.h)
          else:
              self.fenetre.set_default_size(self.l, self.h)
          
          self.fenetre.set_border_width(10)
          self.fenetre.set_size_request(self.l, self.h)
          self.fenetre.set_icon_from_file("/usr/share/icons/dPluzz-ico.png")
          self.fenetre.connect("delete_event", self.destroy)
          
          self.box = gtk.VBox(False, 0)
          if self.choix_taillehl == "petite False":
              if "bordFalse" in self.choix_bordure:
                 self.separateur = gtk.HSeparator()
                 self.separateur.set_size_request(400, 5)
                 self.box.pack_start(self.separateur, False, True, 5)
                 self.separateur.show()
          
              self.etiquette = gtk.Label("")
              if "bordFalse" in self.choix_bordure:
                 self.etiquette.set_markup("<b>Téléchargement des vidéos des replays TV</b>")
              else:
                 self.etiquette.set_markup("<b>dPluzz+  Téléchargement des vidéos des replays TV</b>")
              self.etiquette.set_alignment(0.5, 0.5)
              self.box.pack_start(self.etiquette, False, False, 0)
              self.etiquette.show()
          
              self.separateur = gtk.HSeparator()
              self.separateur.set_size_request(400, 5)
              self.box.pack_start(self.separateur, False, True, 5)
              self.separateur.show()
          else:
              self.etiquette = gtk.Label("")
              self.etiquette.set_markup("<b>dPluzz+  Téléchargement des vidéos des replays TV</b>")
              self.box.pack_start(self.etiquette, False, False, 0)
              self.etiquette.show()
          
          self.fenetre.add(self.box)
          self.insert_notebook()
          self.notebook.show()
          
          # Nouvelle boite pour le bouton quitter
          boite_quit = gtk.HButtonBox()
          self.box.add(boite_quit)
          if self.choix_taillehl == "petite False":
             boite_quit.set_border_width(0)
          else:
             boite_quit.set_border_width(0)
          boite_quit.set_layout(gtk.BUTTONBOX_END) 
          
          # Bouton quitter
          bouton = gtk.Button("Enregister et fermer", gtk.STOCK_QUIT)
          bouton.connect("clicked", self.destroy, "bouton B")
          boite_quit.set_homogeneous(True)
          boite_quit.set_size_request(-1, 0)
          boite_quit.pack_start_defaults(bouton)
          
          bouton.show()
          boite_quit.show()
          self.fenetre.show()

      def reshaperect(self, obj, allocation):    
        w,h = allocation.width, allocation.height
        bitmap = gtk.gdk.Pixmap(None, w, h, 1)
        fg = gtk.gdk.Color(pixel=0)
        bg = gtk.gdk.Color(pixel=-1)
        fg_gc = bitmap.new_gc(foreground=fg, background=bg)
        bitmap.draw_rectangle(fg_gc, True, 0, 0, w, h)
        padding=2
        rounded=5
        cr = bitmap.cairo_create()
        cr.set_source_rgb(0,0,0)
        cr.move_to(0+padding+rounded, 0+padding)
        cr.line_to(w-padding-rounded, 0+padding)
        cr.arc(w-padding-rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.line_to(w-padding, h-padding-rounded)
        cr.arc(w-padding-rounded, h-padding-rounded, rounded, 0, math.pi/2)
        cr.line_to(0+padding+rounded, h-padding)
        cr.arc(0+padding+rounded, h-padding-rounded, rounded, math.pi+math.pi/2, math.pi)
        cr.line_to(0+padding, 0+padding+rounded)
        cr.arc(0+padding+rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.fill()
        self.fenetre.shape_combine_mask(bitmap, 0, 0)
        self.fenetre.show()
      
class splashScreen():     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_POPUP)
        self.window.connect('size-allocate', self.reshaperect)
        self.window.set_position(gtk.WIN_POS_CENTER)
        main_vbox = gtk.VBox(False, 1) 
        
        etiquette = gtk.Label(" ")
        etiquette.set_alignment(0.5, 0.5)
        etiquette.set_justify(gtk.JUSTIFY_CENTER)
        main_vbox.add(etiquette)
        
        # Chargement de l'icone
        image = "/usr/share/icons/dPluzz-ico.png"
        img = gtk.Image()
        img.set_from_file(image)
        img.show()
        main_vbox.add(img)
                
        self.window.add(main_vbox)
        hbox = gtk.HBox(False, 0)
        
        etiquette = gtk.Label("")
        text = """<big><b>  dPluzz+ version """ + version + """  </b></big>\n\nChargement...\n"""
        if debug == 1:
            text = """<big><b>  dPluzz+ version """ + version + """  </b></big>\n\n<b>MODE DEBUG...</b>\n"""
        etiquette.set_markup(text)
        etiquette.set_alignment(0.5, 0.5)
        etiquette.set_justify(gtk.JUSTIFY_CENTER)
        
        main_vbox.pack_start(etiquette, True, True)
        
        self.screen = self.window.get_screen()
        colormap = self.screen.get_rgba_colormap()
        if (colormap is not None and self.screen.is_composited()):
            self.window.set_colormap(colormap)
        self.window.set_app_paintable(True)
        self.window.connect("expose-event", self.area_draw)
        self.window.show_all()
    
    def reshaperect(self, obj, allocation):    
        w,h = allocation.width, allocation.height
        bitmap = gtk.gdk.Pixmap(None, w, h, 1)
        fg = gtk.gdk.Color(pixel=0)
        bg = gtk.gdk.Color(pixel=-1)
        fg_gc = bitmap.new_gc(foreground=fg, background=bg)
        bitmap.draw_rectangle(fg_gc, True, 0, 0, w, h)
        padding=2
        rounded=10
        cr = bitmap.cairo_create()
        cr.set_source_rgb(0,0,0)
        cr.move_to(0+padding+rounded, 0+padding)
        cr.line_to(w-padding-rounded, 0+padding)
        cr.arc(w-padding-rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.line_to(w-padding, h-padding-rounded)
        cr.arc(w-padding-rounded, h-padding-rounded, rounded, 0, math.pi/2)
        cr.line_to(0+padding+rounded, h-padding)
        cr.arc(0+padding+rounded, h-padding-rounded, rounded, math.pi+math.pi/2, math.pi)
        cr.line_to(0+padding, 0+padding+rounded)
        cr.arc(0+padding+rounded, 0+padding+rounded, rounded, math.pi/2, 0)
        cr.fill()
        self.window.shape_combine_mask(bitmap, 0, 0)
        self.window.show()
        
    def area_draw(self, widget, event):
        cr = widget.get_window().cairo_create()
        cr.set_source_rgba(1, 1, 1, 1)
        cr.set_operator(cairo.OPERATOR_SOURCE)
        cr.paint()
        cr.set_operator(cairo.OPERATOR_OVER)
        return False
      
      
if __name__ == "__main__":
      
      splScr = splashScreen()
      while gtk.events_pending():
         gtk.main_iteration()
      time.sleep(1) 
      app = dPluzz()
      splScr.window.destroy() 
      gtk.main() 
      
      base = dPluzz()
      gtk.main()
