on the road to 0.7.4

1 files changed, 188 insertions, 194 deletions

diff --git a/macrofusion.py b/macrofusion.py
index e555edd..5275772 100755
--- a/macrofusion.py
+++ b/macrofusion.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
 
@@ -9,34 +9,32 @@ try:
     import os.path
     import subprocess
     import shutil
-    import gobject
     import time
     import threading   
     import multiprocessing
     import re
-    import ConfigParser
+    import configparser
     import operator
     import cairo
     import random
-    import pyexiv2
+    from gi.repository import Gdk, Gtk, GObject, GdkPixbuf, GExiv2
 except:    
     print('An error occured. Python or one of its sub modules is absent...\nIt would be wise to check your python installation.')
     sys.exit(1)    
 
 try:
-    import Image    
-    from PIL.ExifTags import TAGS
+    from PIL import Image
 except:
     print('Python Imaging Library is missing.')
 
-try:
-    import gtk
-    import gtk.glade
-    import pygtk
-    pygtk.require("2.0")
-except:
-    print('gtk2, pygtk or libglade is missing.')
-    sys.exit(1)
+#try:
+#    import gtk
+#    import Gtk.glade
+#    import pygtk
+#    pyGtk.require("2.0")
+#except:
+#    print('gtk2, pygtk or libglade is missing.')
+#    sys.exit(1)
 
 # Bad, bad, really bad coder... Global variables...
 global session_images_bak
@@ -50,8 +48,8 @@ __LICENSE__='GPL'
 __COPYRIGHT__='Dariusz Duma'
 __WEBSITE__='http://sourceforge.net/p/macrofusion'
 
-if os.path.exists('/usr/share/mfusion/ui/DOFuseInterface2.glade') \
-    and os.path.exists('/usr/share/mfusion/ui/Progress.glade') \
+if os.path.exists('/usr/share/mfusion/ui/ui.xml') \
+    and os.path.exists('/usr/share/mfusion/ui/progress.xml') \
     and os.path.exists('/usr/share/pixmaps/macrofusion.png') \
     and os.path.exists('/usr/share/mfusion/images/logoSplash.png'):
     # print ("System wide install!")
@@ -59,7 +57,7 @@ if os.path.exists('/usr/share/mfusion/ui/DOFuseInterface2.glade') \
     IMG = '/usr/share/pixmaps/'
     IMG2 = '/usr/share/mfusion/images/'
     UI = '/usr/share/mfusion/ui/'
-elif os.path.exists(sys.path[0] + "/ui/DOFuseInterface2.glade"):
+elif os.path.exists(sys.path[0] + "/ui/ui.xml"):
     # print ("Local run!")
     DIR = sys.path[0] + '/locale/'
     IMG = sys.path[0] + '/images/'
@@ -71,16 +69,16 @@ else:
     
 import locale
 import gettext
-for module in (gettext, gtk.glade):
-     module.bindtextdomain(APP, DIR)
-     module.textdomain(APP)
+#for module in (gettext, Gtk.glade):
+#     module.bindtextdomain(APP, DIR)
+#     module.textdomain(APP)
 locale.setlocale(locale.LC_ALL, '')
 #gettext.bindtextdomain(APP, DIR)
 #gettext.textdomain(APP)
 #gettext.install(APP)
 _ = gettext.gettext
     
-gobject.threads_init()        #Pour que les threads soient lancés au moment opportun.
+GObject.threads_init()        #Pour que les threads soient lancés au moment opportun.
 
 def toggled_cb(cell, path, user_data):
     model, column = user_data
@@ -91,15 +89,15 @@ def toggled_cb(cell, path, user_data):
 def creer_miniature(chemin,taille):
     outfile=donnees.previs_dossier + '/' + os.path.split(chemin)[1]
     try:
-        im = gtk.gdk.pixbuf_new_from_file_at_size(chemin, taille[0], taille[1])
-#        pb = gtk.gdk.pixbuf_new_from_file(chemin)
+        im = GdkPixbuf.Pixbuf.new_from_file_at_size(chemin, taille[0], taille[1])
+#        pb = Gtk.gdk.pixbuf_new_from_file(chemin)
 #	im = Interface.pixbuf2Image(Interface(),pb)
 #        im = Image.open(chemin)
 #        im.thumbnail(taille)
 #        im.save(outfile, "JPEG")
-        im.save(outfile, "jpeg", {"quality":"98"})
+        im.savev(outfile, "jpeg", [], [])
     except IOError:
-        print _("Generating %s thumbnail failed.") % chemin
+        print(_("Generating %s thumbnail failed.") % chemin)
     return outfile
 
 
@@ -143,7 +141,7 @@ class Interface:
     def __init__(self):
         
         # Set default icon
-        gtk.window_set_default_icon_from_file(IMG + 'macrofusion.png') 
+        # Gtk.window_set_default_icon_from_file(IMG + 'macrofusion.png') 
         
         self.cpus = multiprocessing.cpu_count()
         if not donnees.check_install("enfuse"):
@@ -152,123 +150,124 @@ class Interface:
 		        
         # Check cpus
         if self.cpus>1 and donnees.check_install("enfuse-mp"):
-            print _("Will use all the powers of your CPU!")
+            print(_("Will use all the powers of your CPU!"))
             self.enfuser = "enfuse-mp"
         else:  
             self.enfuser = "enfuse"
         
 	    #Set the Glade file
-        self.gui=gtk.glade.XML(fname=UI + "DOFuseInterface2.glade", domain=APP)
+        self.gui = Gtk.Builder()
+        self.gui.add_from_file(UI + "ui.xml")
          
         #Dans la foulee on chope la fenetre principale, ca sert a rien c'est pour
         #montrer qu'on peut le faire c'est tout ^^
-        self.win=self.gui.get_widget("mainwindow")
+        self.win=self.gui.get_object("mainwindow")
         self.win.set_title('MacroFusion')
                 
         #On chope le reste, et ca, ca va servir...
-        self.listeimages = self.gui.get_widget("listeimages")  
-        self.buttonajoutfichiers = self.gui.get_widget("buttonajoutfichiers")
-        self.buttonenleverfichier = self.gui.get_widget("buttonenleverfichier")
-        self.statusbar = self.gui.get_widget("status1")
-        self.statusbar.push(1, _("CPU Cores: %s") % self.cpus)
-
-        self.hscaleexp = self.gui.get_widget("hscaleexp")
-        self.ajus_exp = gtk.Adjustment(value=1, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
+        self.listeimages = self.gui.get_object("listeimages")  
+        self.buttonajoutfichiers = self.gui.get_object("buttonajoutfichiers")
+        self.buttonenleverfichier = self.gui.get_object("buttonenleverfichier")
+        self.statusbar = self.gui.get_object("status1")
+        self.statusbar.push(1,(_("CPU Cores: %s") % self.cpus))
+
+        self.hscaleexp = self.gui.get_object("hscaleexp")
+        self.ajus_exp = Gtk.Adjustment(value=1, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
         self.hscaleexp.set_adjustment(self.ajus_exp)
-        self.spinbuttonexp = self.gui.get_widget("spinbuttonexp")
+        self.spinbuttonexp = self.gui.get_object("spinbuttonexp")
         self.spinbuttonexp.set_digits(1)
         self.spinbuttonexp.set_value(1)
         self.spinbuttonexp.set_adjustment(self.ajus_exp)
         
-        self.hscalecont = self.gui.get_widget("hscalecont")
-        self.ajus_cont = gtk.Adjustment(value=0, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
+        self.hscalecont = self.gui.get_object("hscalecont")
+        self.ajus_cont = Gtk.Adjustment(value=0, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
         self.hscalecont.set_adjustment(self.ajus_cont)
-        self.spinbuttoncont = self.gui.get_widget("spinbuttoncont")
+        self.spinbuttoncont = self.gui.get_object("spinbuttoncont")
         self.spinbuttoncont.set_digits(1)
         self.spinbuttoncont.set_value(0)
         self.spinbuttoncont.set_adjustment(self.ajus_cont)
         
-        self.hscalesat = self.gui.get_widget("hscalesat")
-        self.ajus_sat = gtk.Adjustment(value=0.2, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
+        self.hscalesat = self.gui.get_object("hscalesat")
+        self.ajus_sat = Gtk.Adjustment(value=0.2, lower=0, upper=1, step_incr=0.1, page_incr=0.1, page_size=0)
         self.hscalesat.set_adjustment(self.ajus_sat)
-        self.spinbuttonsat = self.gui.get_widget("spinbuttonsat")
+        self.spinbuttonsat = self.gui.get_object("spinbuttonsat")
         self.spinbuttonsat.set_digits(1)
         self.spinbuttonsat.set_value(0.2)
         self.spinbuttonsat.set_adjustment(self.ajus_sat)
         
-        self.hscalemu = self.gui.get_widget("hscalemu")
-        self.ajus_mu = gtk.Adjustment(value=0.5, lower=0, upper=1, step_incr=0.01, page_incr=0.1, page_size=0)
+        self.hscalemu = self.gui.get_object("hscalemu")
+        self.ajus_mu = Gtk.Adjustment(value=0.5, lower=0, upper=1, step_incr=0.01, page_incr=0.1, page_size=0)
         self.hscalemu.set_adjustment(self.ajus_mu)
-        self.spinbuttonmu = self.gui.get_widget("spinbuttonmu")
+        self.spinbuttonmu = self.gui.get_object("spinbuttonmu")
         self.spinbuttonmu.set_digits(2)
         self.spinbuttonmu.set_value(0.5)
         self.spinbuttonmu.set_adjustment(self.ajus_mu)
         
-        self.hscalesigma = self.gui.get_widget("hscalesigma")
-        self.ajus_sigma = gtk.Adjustment(value=0.2, lower=0, upper=1, step_incr=0.01, page_incr=0.1, page_size=0)
+        self.hscalesigma = self.gui.get_object("hscalesigma")
+        self.ajus_sigma = Gtk.Adjustment(value=0.2, lower=0, upper=1, step_incr=0.01, page_incr=0.1, page_size=0)
         self.hscalesigma.set_adjustment(self.ajus_sigma)
-        self.spinbuttonsigma = self.gui.get_widget("spinbuttonsigma")
+        self.spinbuttonsigma = self.gui.get_object("spinbuttonsigma")
         self.spinbuttonsigma.set_digits(2)
         self.spinbuttonsigma.set_value(0.2)
         self.spinbuttonsigma.set_adjustment(self.ajus_sigma)
         
-        self.buttonpreview = self.gui.get_widget("buttonpreview")
-        self.checkbuttontiff = self.gui.get_widget("checkbuttontiff")
-        self.checkbuttonjpeg = self.gui.get_widget("checkbuttonjpeg")
-        self.buttonfusion = self.gui.get_widget("buttonfusion")   
-        self.buttonbeforeafter = self.gui.get_widget("buttonbeforeafter")   
-        self.buttonedit = self.gui.get_widget("buttoneditw")
+        self.buttonpreview = self.gui.get_object("buttonpreview")
+        self.checkbuttontiff = self.gui.get_object("checkbuttontiff")
+        self.checkbuttonjpeg = self.gui.get_object("checkbuttonjpeg")
+        self.buttonfusion = self.gui.get_object("buttonfusion")   
+        self.buttonbeforeafter = self.gui.get_object("buttonbeforeafter")   
+        self.buttonedit = self.gui.get_object("buttoneditw")
         
-        self.imagepreview = self.gui.get_widget("imagepreview")
+        self.imagepreview = self.gui.get_object("imagepreview")
         self.imagepreview.set_from_file(IMG2 + "logoSplash.png")
         
-        self.progressbar = self.gui.get_widget("progressbar")
+        self.progressbar = self.gui.get_object("progressbar")
         
-        self.checkbuttonexif = self.gui.get_widget("checkbuttonexif")
+        self.checkbuttonexif = self.gui.get_object("checkbuttonexif")
 
         #valeurs des options et configurations :
-        self.check_pyramidelevel = self.gui.get_widget("check_pyramidelevel")
-        self.spinbuttonlevel = self.gui.get_widget("spinbuttonlevel")
-        self.check_hardmask = self.gui.get_widget("check_hardmask")
-        self.check_contwin = self.gui.get_widget("check_contwin")
-        self.spinbuttoncontwin = self.gui.get_widget("spinbuttoncontwin")
-        
-        self.check_courb = self.gui.get_widget("check_courb")
-        self.check_prctcourb = self.gui.get_widget("check_prctcourb")
-        self.spinbuttoncourb = self.gui.get_widget("spinbuttoncourb")
-        self.check_detecbord = self.gui.get_widget("check_detecbord")
-        self.spinbuttonEdge = self.gui.get_widget("spinbuttonEdge")
+        self.check_pyramidelevel = self.gui.get_object("check_pyramidelevel")
+        self.spinbuttonlevel = self.gui.get_object("spinbuttonlevel")
+        self.check_hardmask = self.gui.get_object("check_hardmask")
+        self.check_contwin = self.gui.get_object("check_contwin")
+        self.spinbuttoncontwin = self.gui.get_object("spinbuttoncontwin")
+        
+        self.check_courb = self.gui.get_object("check_courb")
+        self.check_prctcourb = self.gui.get_object("check_prctcourb")
+        self.spinbuttoncourb = self.gui.get_object("spinbuttoncourb")
+        self.check_detecbord = self.gui.get_object("check_detecbord")
+        self.spinbuttonEdge = self.gui.get_object("spinbuttonEdge")
         # self.spinbuttonEdge.set_value(self.conf.getint('prefs', 'w'))
         
-        self.spinbuttonLceS = self.gui.get_widget("spinbuttonLceS")
-        self.spinbuttonLceF = self.gui.get_widget("spinbuttonLceF")
-        self.check_lces = self.gui.get_widget("check_lces")
-        self.check_lcef = self.gui.get_widget("check_lcef")
-        
-        self.check_ciecam = self.gui.get_widget("check_ciecam")
-        self.check_desatmeth = self.gui.get_widget("check_desatmeth")
-        self.combobox_desatmet = self.gui.get_widget("combobox_desatmet")
-        self.spinbuttonlargeurprev = self.gui.get_widget("spinbuttonlargeurprev")
-        self.spinbuttonhauteurprev = self.gui.get_widget("spinbuttonhauteurprev")
-        self.checkbuttoncache = self.gui.get_widget("checkbuttoncache")
-        self.spinbuttoncache = self.gui.get_widget("spinbuttoncache")
-        self.checkbuttonbloc = self.gui.get_widget("checkbuttonbloc")
-        self.spinbuttonbloc = self.gui.get_widget("spinbuttonbloc")
-        self.checkbuttontaillefinale = self.gui.get_widget("checkbuttontaillefinale")
-        self.spinbuttonlargeurfinale = self.gui.get_widget("spinbuttonlargeurfinale")
-        self.spinbuttonhauteurfinale = self.gui.get_widget("spinbuttonhauteurfinale")
-        self.spinbuttonxoff = self.gui.get_widget("spinbuttonxoff")
-        self.spinbuttonyoff = self.gui.get_widget("spinbuttonyoff")
-        self.checkbuttonjpegorig = self.gui.get_widget("checkbuttonjpegorig")
-        self.hscalecomprjpeg = self.gui.get_widget("hscalecomprjpeg")
-        self.combtiff = self.gui.get_widget("combtiff")
-
-        self.checkbutton_a5_align = self.gui.get_widget("checkbutton_a5_align")
-        self.checkbutton_a5_crop = self.gui.get_widget("checkbutton_a5_crop")
-        self.checkbutton_a5_shift = self.gui.get_widget("checkbutton_a5_shift")
-        self.checkbutton_a5_field = self.gui.get_widget("checkbutton_a5_field")                
-        
-        self.entryedit_field = self.gui.get_widget("entry_editor")                
+        self.spinbuttonLceS = self.gui.get_object("spinbuttonLceS")
+        self.spinbuttonLceF = self.gui.get_object("spinbuttonLceF")
+        self.check_lces = self.gui.get_object("check_lces")
+        self.check_lcef = self.gui.get_object("check_lcef")
+        
+        self.check_ciecam = self.gui.get_object("check_ciecam")
+        self.check_desatmeth = self.gui.get_object("check_desatmeth")
+        self.combobox_desatmet = self.gui.get_object("combobox_desatmet")
+        self.spinbuttonlargeurprev = self.gui.get_object("spinbuttonlargeurprev")
+        self.spinbuttonhauteurprev = self.gui.get_object("spinbuttonhauteurprev")
+        self.checkbuttoncache = self.gui.get_object("checkbuttoncache")
+        self.spinbuttoncache = self.gui.get_object("spinbuttoncache")
+        self.checkbuttonbloc = self.gui.get_object("checkbuttonbloc")
+        self.spinbuttonbloc = self.gui.get_object("spinbuttonbloc")
+        self.checkbuttontaillefinale = self.gui.get_object("checkbuttontaillefinale")
+        self.spinbuttonlargeurfinale = self.gui.get_object("spinbuttonlargeurfinale")
+        self.spinbuttonhauteurfinale = self.gui.get_object("spinbuttonhauteurfinale")
+        self.spinbuttonxoff = self.gui.get_object("spinbuttonxoff")
+        self.spinbuttonyoff = self.gui.get_object("spinbuttonyoff")
+        self.checkbuttonjpegorig = self.gui.get_object("checkbuttonjpegorig")
+        self.hscalecomprjpeg = self.gui.get_object("hscalecomprjpeg")
+        self.combtiff = self.gui.get_object("combtiff")
+
+        self.checkbutton_a5_align = self.gui.get_object("checkbutton_a5_align")
+        self.checkbutton_a5_crop = self.gui.get_object("checkbutton_a5_crop")
+        self.checkbutton_a5_shift = self.gui.get_object("checkbutton_a5_shift")
+        self.checkbutton_a5_field = self.gui.get_object("checkbutton_a5_field")                
+        
+        self.entryedit_field = self.gui.get_object("entry_editor")                
         
         self.combobox_desatmet.set_active(0)
         self.combtiff.set_active(0)
@@ -285,7 +284,7 @@ class Interface:
             self.messageinthebottle(_("Hugin tools (align_image_stack) are missing !\n\n Cannot auto align images."))            
             
 # Read values from config
-        self.conf = ConfigParser.ConfigParser()
+        self.conf = configparser.ConfigParser()
         if os.path.isfile(donnees.enfuse_dossier + '/mfusion.cfg'):
             self.conf.read(donnees.enfuse_dossier + '/mfusion.cfg')
         if self.conf.has_option('prefs', 'pwidth'):
@@ -340,10 +339,11 @@ class Interface:
                 "on_buttonbeforeafter_pressed" : self.baswitch,
                 "on_buttonbeforeafter_released" : self.baswitch,
                 "on_entry_editor_activate" : self.check_editor,
-                "on_imagemenuitem10_activate" : self.apropos
+                "on_imagemenuitem10_activate" : self.apropos,
+                "on_hscaleexp_format_value" : self.apropos
                 }                 
         #Auto-connection des signaux       
-        self.gui.signal_autoconnect(dic)
+        self.gui.connect_signals(dic)
         
         #initialisation de la liste d'images a fusionner
         self.inittreeview()
@@ -360,7 +360,7 @@ class Interface:
     
     def check_editor(self, action):
         if not donnees.check_install(self.entryedit_field.get_text()):
-            Gui.messageinthebottle(_("No such application!\n\n Cannot find ") + self.entryedit_field.get_text() + _(".\n\n Revert to default value."))
+            Gui.messageinthebottle(_("No such application!\n\n Cannot find ") + self.entryedit_field.get_text() + (_(".\n\n Revert to default value.")))
             self.entryedit_field.set_text("gimp")
             return False
         return True
@@ -373,26 +373,26 @@ class Interface:
         
     def inittreeview(self):
         """initialisation de la liste d'images a importer"""
-        self.liststoreimport = gtk.ListStore(bool, str, str, gtk.gdk.Pixbuf, str)                    #création de la listestore qui contiendra les noms d'images
+        self.liststoreimport = Gtk.ListStore(bool, str, str, GdkPixbuf.Pixbuf, str)                    #création de la listestore qui contiendra les noms d'images
         self.listeimages.set_model(self.liststoreimport)                        #on donne la liststore au l'afficheur treeview
         self.listeimages.set_property('tooltip-column', 4)
         
-        self.colonneselect = gtk.TreeViewColumn('')                             #Premiere colonne :
+        self.colonneselect = Gtk.TreeViewColumn('')                             #Premiere colonne :
         self.listeimages.append_column(self.colonneselect)                      #on l'ajoute au TreeView
-        self.select=gtk.CellRendererToggle()                                    #On creer le cellrender pour avoir des boutons toggle
+        self.select=Gtk.CellRendererToggle()                                    #On creer le cellrender pour avoir des boutons toggle
         self.colonneselect.pack_start(self.select, True)                        #on met le cellrender dans la colonne
         self.colonneselect.add_attribute(self.select, 'active', 0)              #on met les boutons actifs par défaut
         
-        self.colonneimages = gtk.TreeViewColumn(_('Image'))                        #deuxieme colonne, titre 'Image'
+        self.colonneimages = Gtk.TreeViewColumn(_('Image'))                        #deuxieme colonne, titre 'Image'
         self.listeimages.append_column(self.colonneimages)                      #on rajoute la colonne dans le treeview
-        self.cell = gtk.CellRendererText()                                      #Ce sera des cellules de texte
+        self.cell = Gtk.CellRendererText()                                      #Ce sera des cellules de texte
         self.colonneimages.pack_start(self.cell, True)                          #que l'on met dans la colonne
         self.colonneimages.add_attribute(self.cell, 'text', 1)                  #et on specifie que c'est du texte simple
        
-        self.colonneimages2 = gtk.TreeViewColumn(_("Thumbnail"))                        #deuxieme colonne, titre 'Image'
+        self.colonneimages2 = Gtk.TreeViewColumn(_("Thumbnail"))                        #deuxieme colonne, titre 'Image'
         self.listeimages.append_column(self.colonneimages2)                      #on rajoute la colonne dans le treeview
-        self.cell2 = gtk.CellRendererPixbuf()                                      #Ce sera des cellules de texte
-        self.colonneimages2.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        self.cell2 = Gtk.CellRendererPixbuf()                                      #Ce sera des cellules de texte
+        self.colonneimages2.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
         self.colonneimages2.pack_start(self.cell2, True)                          #que l'on met dans la colonne
         self.colonneimages2.add_attribute(self.cell2, 'pixbuf', 3)
         self.cell2.set_property('visible', 1)
@@ -415,11 +415,11 @@ class Interface:
     def raffraichissementlisteimages(self):
         #self.listeimages.set_model(self.liststoreimport)
         self.treeselectionsuppr=self.listeimages.get_selection()                #pour récupérer quels fichiers sont selectionnés
-        self.treeselectionsuppr.set_mode(gtk.SELECTION_MULTIPLE)                #Pour pouvoir en selectionner plusieurs
+        self.treeselectionsuppr.set_mode(Gtk.SELECTION_MULTIPLE)                #Pour pouvoir en selectionner plusieurs
              
     def enlever(self, widget):
         self.treeselectionsuppr=self.listeimages.get_selection()                #pour récupérer quels fichiers sont selectionnés
-        self.treeselectionsuppr.set_mode(gtk.SELECTION_MULTIPLE)                #Pour pouvoir en selectionner plusieurs
+        self.treeselectionsuppr.set_mode(Gtk.SELECTION_MULTIPLE)                #Pour pouvoir en selectionner plusieurs
         (model, pathlist) = self.treeselectionsuppr.get_selected_rows()
         for i in pathlist:
             treeiter = model.get_iter(i)
@@ -433,14 +433,14 @@ class Interface:
         self.name=donnees.previs_dossier + "/" + "preview.jpg"
         item=0
         if len(self.liststoreimport)>0:
-            self.ref=zip(*self.liststoreimport)[0] 
+            self.ref=list(zip(*self.liststoreimport))[0] 
             for item2 in self.ref:
                 if item2:
                     item+=1
                     if item>1:
                         self.thread_preview = Thread_Preview(self.taille, self.get_options(), self.get_options_align(), self.liststoreimport) 
                         self.thread_preview.start()
-                        timer = gobject.timeout_add (100, self.pulsate)
+                        timer = GObject.timeout_add (100, self.pulsate)
                         break
         if item<=1:
             self.messageinthebottle(_("Please add or activate at least two images.\n\n Cannot do anything smart with the one or no image."))
@@ -463,8 +463,8 @@ class Interface:
                  "--exposure-sigma=" + str(self.spinbuttonsigma.get_value()),
                  "--saturation-weight=" + str(self.spinbuttonsat.get_value()),
                  "--contrast-weight=" + str(self.spinbuttoncont.get_value())]
-        if self.check_pyramidelevel.get_active():
-            options.append('-l ' + str(self.spinbuttonlevel.get_value_as_int()))
+        if self.check_pyramidelevel.get_active():            
+            options.append('--levels=' + str(self.spinbuttonlevel.get_value_as_int()))
         if self.check_hardmask.get_active():
             options.append('--hard-mask')
         if self.check_contwin.get_active():
@@ -517,10 +517,10 @@ class Interface:
 
     def baswitch(self, widget):
         if (not int(self.buttonbeforeafter.get_relief())) and (os.path.exists(donnees.previs_dossier + "/preview_.jpg")):
-            self.buttonbeforeafter.props.relief = gtk.RELIEF_NONE
+            self.buttonbeforeafter.props.relief = Gtk.ReliefStyle.NONE
             self.imagepreview.set_from_file(donnees.previs_dossier + "/preview_.jpg")
         elif os.path.exists(donnees.previs_dossier + "/preview_.jpg"):
-            self.buttonbeforeafter.props.relief = gtk.RELIEF_NORMAL
+            self.buttonbeforeafter.props.relief = Gtk.ReliefStyle.NORMAL
             self.imagepreview.set_from_file(donnees.previs_dossier + "/preview.jpg")
         
     def fusion(self,widget):
@@ -541,39 +541,27 @@ class Interface:
             return
         
     def messageinthebottle(self, message):
-        self.messaga=gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format=(message))
-        if self.messaga.run() == gtk.RESPONSE_OK:
+        self.messaga=Gtk.MessageDialog(parent=None, flags=0, type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK, message_format=(message))
+        if self.messaga.run() == Gtk.ResponseType.OK:
             self.messaga.destroy()
 
     def get_exif(self, fichier):
         tags2=''
-        tags={}
-        exifinfo=None
         try:
-            # im = Image.open(fichier)
-            im = pyexiv2.ImageMetadata(fichier)
-            im.read()
-
-#            if hasattr( im, '_getexif' ):
-#                exifinfo = im._getexif()
-#            if exifinfo != None:
-#                for tag, value in exifinfo.items():
-#                    decoded = TAGS.get(tag, tag)
-#                    tags[decoded] = value
-            tags_keys = im.exif_keys
-            if tags_keys != '':
-                if 'Exif.Image.Model' in tags_keys: 
-                    tags2=(_("<b>Model:</b> ") + str(im['Exif.Image.Model'].value) + "\n")
-                if 'Exif.Image.DateTimeOriginal' in tags_keys: 
-                    tags2+=(_("<b>Date:</b> ") + str(im['Exif.Image.DateTimeOriginal'].value) + "\n")
-                if 'Exif.Photo.FocalLength' in tags_keys:
-                    tags2+=(_("<b>Focal length:</b> ") + str(int(im['Exif.Photo.FocalLength'].value)) + "mm \n")
-                if 'Exif.Photo.FNumber' in tags_keys:
-                    tags2+=(_("<b>Aperture:</b> F/") + str(im['Exif.Photo.FNumber'].value) + "\n")
-                if 'Exif.Photo.ExposureTime' in tags_keys:
-                    tags2+=(_("<b>Exposure Time:</b> ") + str(im['Exif.Photo.ExposureTime'].value) + " s. \n")
+             im = GExiv2.Metadata(fichier)
+             tags_keys = im.get_exif_tags()
+             if 'Exif.Image.Model' in tags_keys:
+                 tags2 = (_("<i>Model:</i>\t\t\t") + im['Exif.Image.Model'] + "\n")
+             if 'Exif.Image.DateTimeOriginal' in tags_keys:
+                 tags2 += (_("<i>Date:</i>\t\t\t") + im['Exif.Image.DateTimeOriginal'] + "\n")
+             if 'Exif.Photo.FocalLength' in tags_keys:
+                 tags2 += (_("<i>Focal length:</i>\t\t") + im['Exif.Photo.FocalLength'] + "mm \n")
+             if 'Exif.Photo.FNumber' in tags_keys:
+                 tags2 += (_("<i>Aperture:</i>\t\t\tF/") + im['Exif.Photo.FNumber'] + "\n")
+             if 'Exif.Photo.ExposureTime' in tags_keys:
+                 tags2 += (_("<i>Exposure Time:</i>\t\t") + im['Exif.Photo.ExposureTime'] + " s. \n")
         except IOError:
-            print "failed to identify", file
+            print ("failed to identify", file)
         return tags2
                
     def enroute(self, issend):        
@@ -603,32 +591,32 @@ class Interface:
         self.fen=AproposFen()
         
     def save_settings(self):
-        conf = ConfigParser.ConfigParser()
+        conf = configparser.ConfigParser()
         conf.add_section('prefs')
         # conf.set('prefs', 'w', self.spinbuttonEdge.get_value_as_int())
-        conf.set('prefs', 'pwidth', self.spinbuttonlargeurprev.get_value_as_int())
-        conf.set('prefs', 'pheight', self.spinbuttonhauteurprev.get_value_as_int())
-        conf.set('prefs', 'cachebutton', self.checkbuttoncache.get_active())
-        conf.set('prefs', 'cachesize', self.spinbuttoncache.get_value_as_int())
-        conf.set('prefs', 'blocbutton', self.checkbuttonbloc.get_active())
-        conf.set('prefs', 'blocsize', self.spinbuttonbloc.get_value_as_int())
-        conf.set('prefs', 'outsize', self.checkbuttontaillefinale.get_active())
-        conf.set('prefs', 'outwidth', self.spinbuttonlargeurfinale.get_value_as_int())
-        conf.set('prefs', 'outheight', self.spinbuttonhauteurfinale.get_value_as_int())
-        conf.set('prefs', 'xoff', self.spinbuttonxoff.get_value_as_int())
-        conf.set('prefs', 'yoff', self.spinbuttonyoff.get_value_as_int())
-        conf.set('prefs', 'jpegdef', self.checkbuttonjpegorig.get_active())
-        conf.set('prefs', 'jpegcompr', int(self.hscalecomprjpeg.get_value()))
+        conf.set('prefs', 'pwidth', str(self.spinbuttonlargeurprev.get_value_as_int()))
+        conf.set('prefs', 'pheight', str(self.spinbuttonhauteurprev.get_value_as_int()))
+        conf.set('prefs', 'cachebutton', str(self.checkbuttoncache.get_active()))
+        conf.set('prefs', 'cachesize', str(self.spinbuttoncache.get_value_as_int()))
+        conf.set('prefs', 'blocbutton', str(self.checkbuttonbloc.get_active()))
+        conf.set('prefs', 'blocsize', str(self.spinbuttonbloc.get_value_as_int()))
+        conf.set('prefs', 'outsize', str(self.checkbuttontaillefinale.get_active()))
+        conf.set('prefs', 'outwidth', str(self.spinbuttonlargeurfinale.get_value_as_int()))
+        conf.set('prefs', 'outheight', str(self.spinbuttonhauteurfinale.get_value_as_int()))
+        conf.set('prefs', 'xoff', str(self.spinbuttonxoff.get_value_as_int()))
+        conf.set('prefs', 'yoff', str(self.spinbuttonyoff.get_value_as_int()))
+        conf.set('prefs', 'jpegdef', str(self.checkbuttonjpegorig.get_active()))
+        conf.set('prefs', 'jpegcompr', str(int(self.hscalecomprjpeg.get_value())))
         conf.set('prefs', 'tiffcomp', str(self.combtiff.get_active()))
         conf.set('prefs', 'exif', str(self.checkbuttonexif.get_active()))
-        conf.set('prefs', 'editor',  self.entryedit_field.get_text())
+        conf.set('prefs', 'editor',  str(self.entryedit_field.get_text()))
                 
         if not os.path.exists(donnees.enfuse_dossier):
             os.makedirs(donnees.enfuse_dossier)
-        conf.write(file(donnees.enfuse_dossier + '/mfusion.cfg', 'w'))
+        conf.write(open(donnees.enfuse_dossier + '/mfusion.cfg', 'w'))
 
                 # Also, save accel_map:
-        # gtk.accel_map_save(self.config_dir + '/accel_map')
+        # Gtk.accel_map_save(self.config_dir + '/accel_map')
 
         return
 
@@ -643,7 +631,7 @@ class Interface:
         self.badfiles=[]
         for fichier in self.fichiers:
             if re.search('\\.jpg$|\\.jpeg$|\\.tiff$|\\.tif$', fichier, flags=re.IGNORECASE):
-                pb = gtk.gdk.pixbuf_new_from_file(fichier)
+                pb = GdkPixbuf.Pixbuf.new_from_file(fichier)
                 im = self.pixbuf2Image(pb)
 #		im.save("welldone.jpg", "JPEG",quality=80)    
                 self.size=im.size
@@ -651,7 +639,7 @@ class Interface:
                 if not self.tags2:
                     self.tags2=''
                 self.tooltip=("\n" + _("<b>Filename:</b> ") + os.path.basename(fichier) + "\n"+_("<b>Resolution:</b> ") + str(str(self.size[0]) + "x" + str(self.size[1])) + "\n" + self.tags2)
-                self.liststoreimport.append([1,os.path.basename(fichier), fichier, gtk.gdk.pixbuf_new_from_file_at_size(fichier, 128, 128), self.tooltip])
+                self.liststoreimport.append([1,os.path.basename(fichier), fichier, GdkPixbuf.Pixbuf.new_from_file_at_size(fichier, 128, 128), self.tooltip])
             else:
                 self.badfiles.append(fichier)
         if len(self.badfiles)>0:
@@ -669,37 +657,39 @@ class Fenetre_Ouvrir:
     """La classe qui ouvre la fenetre de choix de fichiers, et qui retourne le ListStore par la methode get_model"""
     def __init__(self,model,bitajout):
         """Lance la fenetre de selection et créé la listsore a partir des fichiers selectionnés"""
-        self.filtre=gtk.FileFilter()
+        self.filtre=Gtk.FileFilter()
         self.filtre.add_mime_type("image/jpeg")
         self.filtre.add_mime_type("image/tiff")
         self.liststoreimport=model #on repart de l'ancien modele
         if bitajout:
-            self.fenetre_ouvrir = gtk.FileChooserDialog(_("Add images..."), 
+            self.fenetre_ouvrir = Gtk.FileChooserDialog(_("Add images..."), 
                                                         None, 
-                                                        gtk.FILE_CHOOSER_ACTION_OPEN,
-                                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
+                                                        Gtk.FileChooserAction.OPEN,
+                                                        #(Gtk.StockCancel, Gtk.ResponseCancel, Gtk.StockOpen, Gtk.ResponseOK))
+                                                        (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,Gtk.STOCK_OK, Gtk.ResponseType.OK))
             self.fenetre_ouvrir.set_select_multiple(True)
             self.fenetre_ouvrir.set_current_folder(donnees.default_folder)
             self.fenetre_ouvrir.set_filter(self.filtre)
             self.fenetre_ouvrir.use_preview = True
-            self.previewidget = gtk.Image()
+            self.previewidget = Gtk.Image()
             self.fenetre_ouvrir.set_preview_widget(self.previewidget)
             self.fenetre_ouvrir.connect("update-preview", self.update_thumb_preview, self.previewidget)
         else:
-            self.fenetre_ouvrir = gtk.FileChooserDialog(_("Open images..."), 
+            self.fenetre_ouvrir = Gtk.FileChooserDialog(_("Open images..."), 
                                                        None, 
-                                                       gtk.FILE_CHOOSER_ACTION_OPEN,
-                                                       (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
+                                                       Gtk.FileChooserAction.OPEN,
+                                                       #(Gtk.STOCK_CANCEL, Gtk.RESPONSE_CANCEL, Gtk.STOCK_OPEN, Gtk.RESPONSE_OK))
+                                                       (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,Gtk.STOCK_OK, Gtk.ResponseType.OK))
             self.fenetre_ouvrir.set_select_multiple(True) 
             self.fenetre_ouvrir.set_current_folder(donnees.default_folder)
             self.fenetre_ouvrir.set_filter(self.filtre)
             self.fenetre_ouvrir.use_preview = True
-            self.previewidget = gtk.Image()
+            self.previewidget = Gtk.Image()
             self.fenetre_ouvrir.set_preview_widget(self.previewidget)
             self.fenetre_ouvrir.connect("update-preview", self.update_thumb_preview, self.previewidget)
             self.liststoreimport.clear()     #On remet le model a 0 (oublie des anciennes images)
                  
-        if (self.fenetre_ouvrir.run() == gtk.RESPONSE_OK):
+        if (self.fenetre_ouvrir.run() == Gtk.ResponseType.OK):
             self.fichiers = self.fenetre_ouvrir.get_filenames()
             self.tags2=''
             self.badfiles=[]
@@ -714,7 +704,7 @@ class Fenetre_Ouvrir:
             return
         filename = file_chooser.get_preview_filename()
         try:
-            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(filename, 320, 320)
+            pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(filename, 320, 320)
             self.previewidget.set_from_pixbuf(pixbuf)
             self.have_preview = True
         except:
@@ -737,15 +727,15 @@ class Fenetre_Parcourir:
     """La classe qui ouvre la fenetre de choix pour enregistrer le fichier"""          
     def __init__(self):
         
-        self.fenetre_ouvrir = gtk.FileChooserDialog(_("Save file..."), 
+        self.fenetre_ouvrir = Gtk.FileChooserDialog(_("Save file..."), 
                                                         None, 
-                                                        gtk.FILE_CHOOSER_ACTION_SAVE,
-                                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK))
+                                                        Gtk.FileChooserAction.SAVE,
+                                                        (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK))                                                   
         self.fenetre_ouvrir.set_current_folder(donnees.default_folder)
         # self.fenetre_ouvrir.set_filename(donnees.default_file)
         self.fenetre_ouvrir.set_current_name('output.jpg')
         self.fenetre_ouvrir.set_do_overwrite_confirmation(True)
-        if (self.fenetre_ouvrir.run() == gtk.RESPONSE_OK):
+        if (self.fenetre_ouvrir.run() == Gtk.ResponseType.OK):
             self.resultat=self.fenetre_ouvrir.get_filename()
                     
         self.fenetre_ouvrir.destroy()
@@ -801,6 +791,8 @@ class Thread_Preview(threading.Thread):
             session_images_bak=images_a_align
             Gui.statusbar.pop(15)
         Gui.statusbar.push(15, _(":: Fusion photos..."))
+        print (self.options)
+
         command=[Gui.enfuser, "-o", donnees.previs_dossier + "/" + "preview.jpg"] + self.options + images_a_fusionner
         preview_process=subprocess.Popen(command, stdout=subprocess.PIPE)
         preview_process.wait()
@@ -814,20 +806,22 @@ class Thread_Preview(threading.Thread):
 class Progress_Fusion:
     def __init__(self, command, command_a, liste_aligned, issend):
         
-        self.progress = gtk.glade.XML(fname=UI + "Progress.glade", domain=APP) 
-        self.progress_win = self.progress.get_widget("dialog1")
-        self.progress_label = self.progress.get_widget("progress_label")
-        self.info_label = self.progress.get_widget("info_label")
-        self.progress_bar = self.progress.get_widget("progressbar1")
-        self.progress_stop_button = self.progress.get_widget("stop_button")
+        #self.progress = Gtk.glade.XML(fname=UI + "progress.xml", domain=APP)
+        self.progress = Gtk.Builder()
+        self.progress.add_from_file(UI + "progress.xml") 
+        self.progress_win = self.progress.get_object("dialog1")
+        self.progress_label = self.progress.get_object("progress_label")
+        self.info_label = self.progress.get_object("info_label")
+        self.progress_bar = self.progress.get_object("progressbar1")
+        self.progress_stop_button = self.progress.get_object("stop_button")
         self.dic1 = {"on_stop_button_clicked" : self.close_progress, 
                      "on_dialog1_destroy" : self.close_progress}
-        self.progress.signal_autoconnect(self.dic1)
+        self.progress.connect_signals(self.dic1)        
         self.info_label.set_text(_('Fusion images...'))
        
         self.thread_fusion = Thread_Fusion(command, command_a, liste_aligned, issend)                    #On prepare le thread qui va faire tout le boulot
         self.thread_fusion.start()                                     #On le lance
-        timer = gobject.timeout_add (100, self.pulsate)
+        timer = GObject.timeout_add (100, self.pulsate)
         
     def pulsate(self):
         if self.thread_fusion.isAlive():            #Tant que le thread est en cours, 
@@ -876,17 +870,17 @@ class Thread_Fusion(threading.Thread):
 
 class AproposFen:
     def __init__(self):
-        # self.about = gtk.glade.XML(donnees.install_dossier + "/Apropos.glade", domain=APP) 
-        # self.aboutdialog = self.about.get_widget("aboutdialog1")
-        self.aboutdialog = gtk.AboutDialog()
+        # self.about = Gtk.glade.XML(donnees.install_dossier + "/Apropos.glade", domain=APP) 
+        # self.aboutdialog = self.about.get_object("aboutdialog1")
+        self.aboutdialog = Gtk.AboutDialog()
         self.aboutdialog.set_name("MacroFusion")
         self.aboutdialog.set_modal(True)
-        self.aboutdialog.set_position(gtk.WIN_POS_CENTER)
+        self.aboutdialog.set_position(Gtk.WIN_POS_CENTER)
         self.aboutdialog.set_version(__VERSION__)
         self.aboutdialog.set_comments('A GTK Gui for the excellent Enfuse.\n Based on EnfuseGui by Chez Gholyo.\n\n2011 (c) Dariusz Duma\n<dhor@toxic.net.pl>')
         # self.aboutdialog.set_copyright(__COPYRIGHT__)
         self.aboutdialog.set_website(__WEBSITE__)
-        self.pixbuf=gtk.gdk.pixbuf_new_from_file(IMG + "macrofusion.png")
+        self.pixbuf=GdkPixbuf.Pixbuf.new_from_file(IMG + "macrofusion.png")
         self.aboutdialog.set_logo(self.pixbuf)
         self.aboutdialog.connect("response", self.close_about)
         self.aboutdialog.show()
@@ -911,4 +905,4 @@ if __name__ == "__main__":
 #        if len(Gui.liststoreimport)==0:
 #            Gui.messageinthebottle(_("\nCan work only with JPEG or TIFF files."))
 
-    gtk.main()                                                                 #The rest
+    Gtk.main()                                                                 #The rest