Mise à jour de l'application avec interface graphique bien plus aboutie.HEADmaster

6 files changed, 414 insertions, 327 deletions

diff --git a/Redim/config.py b/Redim/config.py
index d618bd1..5d604f0 100644
--- a/Redim/config.py
+++ b/Redim/config.py
@@ -2,32 +2,42 @@
 ainsi que la gestion de la supression des fichiers anciennement décompressés
 par pyinstaller"""
 
-from sys import platform
 from os import mkdir, listdir, environ, getenv, system
 from os.path import isdir, join, getmtime, isfile
 from time import time
 from shutil import rmtree
+import sys
 import json
+import logging
+import traceback
 
 
 class Config():
-    """Gestion de l'enregistrement des choix de l'utilisateur"""
+    """Gestion de l'enregistrement des choix de l'utilisateur
+    """
     def __init__(self):
         self.base_configuration = {
-            "dimensions": [[500, 350], [900, 900]],
+            "version": 1.0,
+            "dimensions": [[500, 350], [800, 800]],
             "background": [255, 255, 255],
-            "format_final": ".webp",
+            "transparence": False,
             "formats_acceptes": (
+                "webp",
+                "png",
                 "jpg",
                 "jpeg",
-                "png",
                 "bmp",
-                "gif",
-                "webp"
-            )
+                "gif"
+            ),
+            "formats_possibles": (
+                "webp",
+                "png",
+                "jpg"
+            ),
+            "format_choisi": ""
         }
         self.user_profile = getenv("USERPROFILE")
-        if platform != "linux":
+        if sys.platform != "linux":
             self.json_path = join(
                 self.user_profile,
                 "AppData",
@@ -36,7 +46,7 @@ class Config():
             )
         else:
             self.json_path = "."
-        if platform != "linux":
+        if sys.platform != "linux":
             self.nettoyage_pyinstaller()
 
     def sauvegarde(self, configuration):
@@ -60,9 +70,36 @@ class Config():
             configuration = json.load(file_config)
         return configuration
 
+    def reset(self):
+        """Suppression et réenregistrement de la configuration par défaut si
+        le dossier de configuration existe
+        """
+        if isdir(self.json_path):
+            rmtree(self.json_path)
+            self.sauvegarde(self.base_configuration)
+
+    @staticmethod
+    def excepthook(type, value, error_traceback):
+        """Système de journalisation en cas de plantage.
+        """
+        logging.error(
+            "\nType: " + type.__name__ + "\n"
+            + "Info: " + str(value) + "\n\n"
+            + "".join(traceback.format_tb(error_traceback))
+            + "\n==============================="
+        )
+        print(
+            "\nTraceback:\n\n"
+            + "Type: " + type.__name__ + "\n"
+            + "Info: " + str(value) + "\n\n"
+            + "".join(traceback.format_tb(error_traceback)) + "\n"
+        )
+        sys.exit(1)
+
     @staticmethod
     def nettoyage_pyinstaller():
-        """Supression des fichiers anciennement décompressés par pyinstaller"""
+        """Supression des fichiers anciennement décompressés par pyinstaller
+        """
         for i in listdir(environ["TMP"]):
             if i.startswith("_MEI")\
                 and isdir(i)\
@@ -73,6 +110,7 @@ class Config():
 
     @staticmethod
     def redimensionnement_fenetre():
-        """Redimensionne la fenetre du CMD sous windows"""
-        if platform != "linux":
+        """Redimensionne la fenetre du CMD sous windows
+        """
+        if sys.platform != "linux":
             system("mode con: cols=70 lines=35")
diff --git a/Redim/core.py b/Redim/core.py
index 8590d03..879a54f 100644
--- a/Redim/core.py
+++ b/Redim/core.py
@@ -7,11 +7,16 @@ from os.path import isfile, isdir, join
 from PIL.Image import ANTIALIAS
 from PIL.Image import new as image_new
 from PIL.Image import open as image_open
+from PyQt5.QtCore import QThread, pyqtSignal
 
 
-class Redim():
+class Redim(QThread):
     """Classe principale de Redim, travail sur les photos"""
+    _progress_bar_value = pyqtSignal(int)
+    _travail_sur_value = pyqtSignal(str)
+
     def __init__(self):
+        super().__init__()
         self.__character_underscore = (" ", "-")
         self.__character_indesirable = (
             "(", ")", "[", "]", "{", "}", "'", "#", "¨",
@@ -20,17 +25,18 @@ class Redim():
         )
         self.__adverbes_multplicatifs = (
             "_bis", "_ter", "_quater", "_quinquies",
-            "_sexies", "_septies"
+            "_sexies", "_septies", "_octies", "_nonies",
+            "_decies"
         )
 
-    def rennomage(self, origine_nom, larg, format_final):
+    def rennomage(self, origine_nom, larg, format_choisi):
         """Formatage du nom en retirant tous ces charactères hideux"""
         nouveau_nom = origine_nom
         for i in self.__character_indesirable:
             nouveau_nom = nouveau_nom.replace(i, "")
         for i in self.__character_underscore:
             nouveau_nom = nouveau_nom.replace(i, "_")
-        return nouveau_nom.lower() + "_modif_" + str(larg) + format_final
+        return nouveau_nom.lower() + "_modif_" + str(larg) + format_choisi
 
     @staticmethod
     def listage(dossier, larg, formats_acceptes):
@@ -73,12 +79,19 @@ class Redim():
             img = img.resize((larg, nouvelle_haut), ANTIALIAS)
         return img
 
-    def main(self, dossier, configuration):
+    def main(self, dossier, configuration, transparency=False):
         """Fonction principale, execute toutes les method dans l'ordre
         pour sauvegarder la photos aux bonnes dimensions, au bon format,
         et sans alpha
         """
         for loop in range(len(configuration["dimensions"])):
+            print(
+                "\n[-] travail pour",
+                str(configuration["dimensions"][loop][0]),
+                "x",
+                str(configuration["dimensions"][loop][1]),
+                "px :"
+            )
             if dossier != "":
                 if isdir(dossier):
                     liste, destination = self.listage(
@@ -87,19 +100,11 @@ class Redim():
                         configuration["formats_acceptes"]
                     )
                 else:
-                    print("\n[ERREUR] : Le dossier n'existe plus.")
-                    return
+                    print("    >>>ERREUR<<< : Le dossier n'existe plus.")
             else:
-                print("\n[ERREUR] : Aucun dossier selectionne.")
-                return
-            print(
-                "\n[-] travail pour",
-                str(configuration["dimensions"][loop][0]),
-                "x",
-                str(configuration["dimensions"][loop][1]),
-                "px :"
-            )
-            for nom in liste:
+                print("    >>>ERREUR<<< : Aucun dossier selectionne.")
+            for index, nom in enumerate(liste):
+                self._travail_sur_value.emit(nom[1])
                 print("    [+] Travail sur :", nom[1])
                 img = image_open(nom[0])
                 print(
@@ -109,7 +114,8 @@ class Redim():
                     img.size[1],
                     "px"
                 )
-                if nom[1].rsplit(".", 1)[-1] in ("png", "webp"):
+                if nom[1].rsplit(".", 1)[-1] in ("png", "webp") \
+                        and not configuration["transparence"]:
                     img = self.suppression_de_alpha(
                         img,
                         configuration["background"]
@@ -129,7 +135,7 @@ class Redim():
                 nouveau_nom = self.rennomage(
                     nom[1].rsplit(".", 1)[0],
                     configuration["dimensions"][loop][0],
-                    configuration["format_final"]
+                    configuration["format_choisi"]
                 )
                 fond = image_new(
                     "RGB",
@@ -139,6 +145,8 @@ class Redim():
                     ),
                     tuple(configuration["background"])
                 )
+                if configuration["transparence"]:
+                    fond.putalpha(0)
                 fond.paste(
                     img,
                     (
@@ -152,10 +160,19 @@ class Redim():
                     nom_deja_present = nouveau_nom
                     iteration = 0
                     while isfile(join(destination, nom_deja_present)):
+                        if iteration == 9:
+                            self._travail_sur_value.emit("")
+                            self._progress_bar_value.emit(0)
+                            return 1
                         nom_deja_present = nouveau_nom.rsplit(".", 1)[0]\
                             + self.__adverbes_multplicatifs[iteration]\
-                            + configuration["format_final"]
+                            + configuration["format_choisi"]
                         iteration += 1
                     fond.save(join(destination, nom_deja_present))
                 else:
                     fond.save(join(destination, nouveau_nom))
+                self._progress_bar_value.emit(
+                    100 / len(liste) / len(configuration["dimensions"])
+                    * (loop * len(liste) + (index + 1))
+                )
+        return 0
\ No newline at end of file
diff --git a/Redim/main.py b/Redim/main.py
index 74b9375..c9f55db 100644
--- a/Redim/main.py
+++ b/Redim/main.py
@@ -1,78 +1,338 @@
-"""Fichier principal de Redim"""
-
 import sys
-from PyQt5.QtWidgets import QFileDialog, QWidget, QApplication
-from ui import Ui
-from core import Redim
+from os.path import join
 from config import Config
+from core import Redim
+from PyQt5 import QtWidgets, QtCore, QtGui
 
 
-def main():
-    """Function principale de Redim, instanciation des classes
-    et exécution des choix de l'utilisateur dans le menu principal
+class Ajout_taille(QtWidgets.QDialog):
+    """Fenêtre pour rajout d'une taille
     """
-    app = QApplication([])
-    widget = QWidget()
-    config = Config()
-    redim = Redim()
-    config.redimensionnement_fenetre()
-    while True:
-        configuration = config.lecture()
-        tui = Ui(configuration)
-        tui.affichage_banner()
-        tui.affichage_menu()
-        choix = input(
-            "[>] Choix (numero) : "
-        )
-        while True:
-            tui.affichage_banner()
-            if choix.strip() == "1":
-                dossier = QFileDialog.getExistingDirectory(
-                    widget,
-                    "Sélectionner le dossier sur lequel travailler."
-                )
-                redim.main(dossier, configuration)
-                tui.affichage_fin()
-                break
-            if choix.strip() == "5":
-                tui.affichage_banner()
-                configuration["dimensions"] = tui.question_taille(
-                    configuration["dimensions"]
+    def __init__(self, config):
+        super(Ajout_taille, self).__init__()
+        self.setWindowTitle("Ajout d'une dimension")
+        logo = join("Ressources", "icon.ico")
+        self.setWindowIcon(QtGui.QIcon(logo))
+        self.config = config
+        self.ajout = False
+        texte_larg = QtWidgets.QLabel("Largeur:")
+        self.edit_larg = QtWidgets.QLineEdit()
+        texte_haut = QtWidgets.QLabel("Hauteur:")
+        self.edit_haut = QtWidgets.QLineEdit()
+        self.layout_btn = QtWidgets.QHBoxLayout()
+        btn_ajouter = QtWidgets.QPushButton("Ajouter")
+        btn_ajouter.clicked.connect(self.valider)
+        self.layout_main = QtWidgets.QVBoxLayout()
+        self.layout_groupbox = QtWidgets.QVBoxLayout()
+        self.layout_taille = QtWidgets.QHBoxLayout()
+        self.groupbox_main = QtWidgets.QGroupBox("Ajout d'une dimension (en pixel)")
+        self.groupbox_main.setLayout(self.layout_groupbox)
+        self.layout_taille.addWidget(texte_larg)
+        self.layout_taille.addWidget(self.edit_larg)
+        self.layout_taille.addWidget(texte_haut)
+        self.layout_taille.addWidget(self.edit_haut)
+        self.layout_btn.addStretch()
+        self.layout_btn.addWidget(btn_ajouter)
+        self.layout_btn.addStretch()
+        self.layout_groupbox.addLayout(self.layout_taille)
+        self.layout_main.addWidget(self.groupbox_main)
+        self.layout_main.addStretch()
+        self.layout_main.addLayout(self.layout_btn)
+        self.setLayout(self.layout_main)
+
+    def valider(self):
+        if self.edit_larg.text().isdigit() and self.edit_haut.text().isdigit():
+            self.config["dimensions"].append(
+                    [int(self.edit_larg.text()), int(self.edit_haut.text())]
                 )
-                config.sauvegarde(configuration)
-                tui.affichage_fin()
-                break
-            if choix.strip() == "6":
-                tui.affichage_banner()
-                configuration["background"] = tui.question_background(
-                    configuration["background"]
+            self.ajout = True
+            self.accept()
+        else:
+            QtWidgets.QMessageBox.warning(self, "Erreur", "Entrée incorrecte")
+
+
+class Gui(QtWidgets.QMainWindow):
+    def __init__(self):
+        super(Gui, self).__init__()
+        self.redim = Redim()
+        self.config = Config()
+        self.configuration = self.config.lecture()
+        self.choix_dimensions = [[], []]
+        logo = join("Ressources", "icon.ico")
+        self.setWindowIcon(QtGui.QIcon(logo))
+        menu = self.menuBar()
+        menu_options = menu.addMenu("Options")
+        btn_reset = QtWidgets.QAction("Reset des paramètres", self)
+        btn_reset.triggered.connect(self.reset)
+        btn_apropos = QtWidgets.QAction("A propos", self)
+        btn_apropos.triggered.connect(self.a_propos)
+        menu_options.addAction(btn_reset)
+        menu_options.addAction(btn_apropos)
+        self.setWindowTitle("Redim")
+        self.home()
+
+    def home(self):
+        self.layout_main = QtWidgets.QVBoxLayout()
+        # Layout Sélection dossier
+        self.edit_source = QtWidgets.QLineEdit("Aucun dossier sélectionné.")
+        self.edit_source.setReadOnly(True)
+        btn_source = QtWidgets.QPushButton("Sélection dossier")
+        btn_source.clicked.connect(self.selection_dossier)
+        self.groupbox_source = QtWidgets.QGroupBox(
+                "Sélection du dossier source"
                 )
-                config.sauvegarde(configuration)
-                tui.affichage_fin()
-                break
-            if choix.strip() == "7":
-                tui.affichage_banner()
-                configuration["format_final"] = tui.question_format_final(
-                    configuration["formats_acceptes"]
+        self.layout_source = QtWidgets.QHBoxLayout()
+        self.layout_source.addWidget(self.edit_source)
+        self.layout_source.addWidget(btn_source)
+        # Layout Configuration
+        self.combobox_taille_1 = QtWidgets.QComboBox(self)
+        self.combobox_taille_2 = QtWidgets.QComboBox(self)
+        self.update_dimensions()
+        self.combobox_taille_1.activated[str].connect(self.choix_combobox_1)
+        self.combobox_taille_2.activated[str].connect(self.choix_combobox_2)
+        btn_modif_taille = QtWidgets.QPushButton("Ajout taille")
+        btn_modif_taille.clicked.connect(self.ajout_taille)
+        self.edit_red = QtWidgets.QLineEdit()
+        self.edit_green = QtWidgets.QLineEdit()
+        self.edit_blue = QtWidgets.QLineEdit()
+        if self.configuration["transparence"]:
+            self.edit_red.setReadOnly(True)
+            self.edit_green.setReadOnly(True)
+            self.edit_blue.setReadOnly(True)
+        else:
+            self.edit_red.setText(str(self.configuration["background"][0]))
+            self.edit_green.setText(str(self.configuration["background"][0]))
+            self.edit_blue.setText(str(self.configuration["background"][0]))
+        self.checkbox_transparency = QtWidgets.QCheckBox(
+                "Conserver la transparence."
+            )
+        self.checkbox_transparency.stateChanged.connect(
+                self.update_checkbox_transparency
+            )
+        if self.configuration["transparence"]:
+            self.checkbox_transparency.setCheckState(QtCore.Qt.Checked)
+        self.cb_format = QtWidgets.QComboBox(self)
+        if self.configuration["transparence"]:
+            self.cb_format.addItem(".webp")
+            self.cb_format.addItem(".png")
+        else:
+            for i in self.configuration["formats_possibles"]:
+                self.cb_format.addItem(".{0}".format(i))
+        self.layout_config = QtWidgets.QHBoxLayout()
+        self.groupbox_taille = QtWidgets.QGroupBox("Choix Dimensions")
+        self.layout_taille = QtWidgets.QVBoxLayout()
+        self.layout_taille.addStretch()
+        self.layout_taille.addWidget(self.combobox_taille_1)
+        self.layout_taille.addWidget(self.combobox_taille_2)
+        self.layout_taille.addWidget(btn_modif_taille)
+        self.groupbox_taille.setLayout(self.layout_taille)
+        self.layout_config.addWidget(self.groupbox_taille)
+        self.layout_config.addStretch()       
+        self.groupbox_rgb = QtWidgets.QGroupBox("RGB")
+        self.layout_rgb = QtWidgets.QVBoxLayout()
+        self.layout_rgb.addStretch()
+        self.layout_edit_rgb = QtWidgets.QHBoxLayout()
+        self.layout_edit_rgb.addWidget(self.edit_red)
+        self.layout_edit_rgb.addWidget(self.edit_green)
+        self.layout_edit_rgb.addWidget(self.edit_blue)
+        self.layout_rgb.addLayout(self.layout_edit_rgb)
+        self.layout_rgb.addWidget(self.checkbox_transparency)
+        self.layout_rgb.addStretch()
+        self.groupbox_rgb.setLayout(self.layout_rgb)
+        self.layout_config.addWidget(self.groupbox_rgb)
+        self.layout_config.addStretch()
+        self.groupbox_format = QtWidgets.QGroupBox("Choix format de sortie")
+        self.layout_format = QtWidgets.QVBoxLayout()
+        self.layout_format.addStretch()
+        self.layout_format.addWidget(self.cb_format)
+        self.layout_format.addStretch()
+        self.groupbox_format.setLayout(self.layout_format)
+        self.layout_config.addWidget(self.groupbox_format)
+        self.layout_config.addStretch()
+        # Layout Validation
+        self.progressbar_validation = QtWidgets.QProgressBar()
+        self.progressbar_validation.setMaximum(100)
+        self.nom_fichier_en_cour = QtWidgets.QLabel("Travail sur:")
+        btn_validation = QtWidgets.QPushButton("Convertir")
+        btn_validation.clicked.connect(self.valider)
+        self.groupbox_validation = QtWidgets.QGroupBox("Validation")
+        self.layout_validation = QtWidgets.QHBoxLayout()
+        self.layout_validation.addWidget(self.progressbar_validation)
+        self.layout_validation.addWidget(self.nom_fichier_en_cour)
+        self.layout_validation.addStretch()
+        self.layout_validation.addWidget(btn_validation)
+        # Layout Main
+        self.mainWidget = QtWidgets.QWidget()
+        self.layout_main.addStretch()
+        self.groupbox_source.setLayout(self.layout_source)
+        self.layout_main.addWidget(self.groupbox_source)
+        self.layout_main.addStretch()
+        self.layout_main.addLayout(self.layout_config)
+        self.layout_main.addStretch()
+        self.groupbox_validation.setLayout(self.layout_validation)
+        self.layout_main.addWidget(self.groupbox_validation)
+        self.layout_main.addStretch()
+        self.mainWidget.setLayout(self.layout_main)
+        self.setCentralWidget(self.mainWidget)
+        self.show()
+
+    def selection_dossier(self, choix):
+        self.dossier = QtWidgets.QFileDialog.getExistingDirectory(
+            self,
+            "Sélectionner le dossier sur lequel travailler."
+        )
+        if self.dossier != "":
+            self.edit_source.setText(self.dossier)
+        else:
+            self.edit_source.setText("Aucun dossier sélectionné.")
+
+    def choix_combobox_1(self, choix):
+        self.choix_dimensions[0] = [int(i) for i in choix.split("x")]
+
+    def choix_combobox_2(self, choix):
+        self.choix_dimensions[1] = [int(i) for i in choix.split("x")]
+
+    def ajout_taille(self):
+        ajout_taille_gui = Ajout_taille(self.configuration)
+        ajout_taille_gui.exec()
+        if ajout_taille_gui.ajout:
+            self.config.sauvegarde(ajout_taille_gui.config)
+            self.configuration = self.config.lecture()
+            self.update_dimensions()
+
+    def update_dimensions(self):
+        for i in range(self.combobox_taille_1.count()):
+            self.combobox_taille_1.removeItem(0)
+            self.combobox_taille_2.removeItem(0)
+        for i in self.configuration["dimensions"]:
+            self.combobox_taille_1.addItem("{0}x{1}".format(i[0], i[1]))
+            self.combobox_taille_2.addItem("{0}x{1}".format(i[0], i[1]))
+        self.combobox_taille_1.setCurrentIndex(self.combobox_taille_1.count() - 2)
+        self.choix_dimensions[0] = [
+                int(i) for i in self.combobox_taille_1.currentText().split("x")
+            ]
+        self.combobox_taille_2.setCurrentIndex(self.combobox_taille_1.count() - 1)
+        self.choix_dimensions[1] = [
+                int(i) for i in self.combobox_taille_2.currentText().split("x")
+            ]
+
+    def update_checkbox_transparency(self, value):
+        if (QtCore.Qt.Checked == value):
+            if not self.configuration["transparence"]:
+                self.configuration["transparence"] = True
+                self.config.sauvegarde(self.configuration)
+                self.edit_red.setReadOnly(True)
+                self.edit_red.setText("")
+                self.edit_green.setReadOnly(True)
+                self.edit_green.setText("")
+                self.edit_blue.setReadOnly(True)
+                self.edit_blue.setText("")
+                for i in range(self.cb_format.count()):
+                    self.cb_format.removeItem(0)
+                self.cb_format.addItem(".webp")
+                self.cb_format.addItem(".png")
+        else:
+            self.configuration["transparence"] = False
+            self.config.sauvegarde(self.configuration)
+            self.edit_red.setReadOnly(False)
+            self.edit_red.setText(str(self.configuration["background"][0]))
+            self.edit_green.setReadOnly(False)
+            self.edit_green.setText(str(self.configuration["background"][1]))
+            self.edit_blue.setReadOnly(False)
+            self.edit_blue.setText(str(self.configuration["background"][2]))
+            for i in range(self.cb_format.count()):
+                self.cb_format.removeItem(0)
+            for i in self.configuration["formats_possibles"]:
+                self.cb_format.addItem(".{0}".format(i))
+
+    def update_progress_bar(self, value):
+        self.progressbar_validation.setValue(value)
+
+    def update_nom_travail_fichier(self, value):
+        self.nom_fichier_en_cour.setText("Travail sur: %s" % value)
+
+    def valider(self):
+        self.configuration["format_choisi"] = self.cb_format.currentText()
+        print(self.configuration)
+        if not self.configuration["transparence"]:
+            rgb_background = []
+            rgb_background.append(self.edit_red.text())
+            rgb_background.append(self.edit_green.text())
+            rgb_background.append(self.edit_blue.text())
+            for i, j in enumerate(rgb_background):
+                if j.isdigit():
+                    rgb_background[i] = int(j)
+                else:
+                    QtWidgets.QMessageBox.warning(
+                            self,
+                            "Erreur",
+                            "Entrée RGB incorrecte"
+                            )
+                    return
+            if rgb_background != self.configuration["background"]:
+                self.configuration["background"] = rgb_background
+                self.config.sauvegarde(self.configuration)
+        if hasattr(self, "dossier"):
+            configFinal = self.configuration
+            self.configuration["dimensions"] = self.choix_dimensions
+            self.redim._progress_bar_value.connect(self.update_progress_bar)
+            self.redim._travail_sur_value.connect(
+                    self.update_nom_travail_fichier
+                    )
+            returncode_redim = self.redim.main(self.dossier, configFinal)
+            if returncode_redim == 0:
+                QtWidgets.QMessageBox.information(
+                        self,
+                        "Redim",
+                        "redimensionnement terminé!"
+                        )
+            elif returncode_redim == 1:
+                QtWidgets.QMessageBox.warning(
+                    self,
+                    "Erreur",
+                    "Plus de 10 fichiers ont le même nom dans le répertoire final.\
+                    <br>Veuillez renommer vos fichiers originaux ou renommer les précédentes conversions."
+                    )
+        else:
+            QtWidgets.QMessageBox.warning(
+                    self,
+                    "Erreur",
+                    "Veuillez sélectionner un dossier"
+                    )
+
+    def reset(self):
+        self.config.reset()
+        self.configuration = self.config.lecture()
+        self.choix_dimensions = [[], []]
+        self.update_dimensions()
+        self.checkbox_transparency.setCheckState(0)
+        self.update_checkbox_transparency(0)
+        QtWidgets.QMessageBox.information(
+                self,
+                "Reset des paramètres",
+                "Les paramètres ont été réinitialisés."
                 )
-                config.sauvegarde(configuration)
-                tui.affichage_fin()
-                break
-            if choix.strip() == "8":
-                tui.affichage_banner()
-                print("\n[-] Reset des parametres.")
-                config.sauvegarde(config.base_configuration)
-                tui.affichage_fin()
-                break
-            if choix.strip() == "9":
-                tui.reset_screen()
-                sys.exit(0)
-            else:
-                tui.affichage_banner()
-                print("\n[-] Reponse invalide .")
-                tui.affichage_fin()
-                break
+
+    def a_propos(self):
+        QtWidgets.QMessageBox.information(
+            self,
+            "A propos",
+            "Logiciel de redimensionnement d'image.\
+            <br>Version: %s\
+            <br>Auteur: Debulois Quentin\
+            <br>Copyright: \
+            <a href='https://www.gnu.org/licenses/gpl-3.0.txt'>GNU GPLv3</a>\
+            <br>Code source: \
+            <a href='https://git.debulois.fr/redim/'>git.debulois.fr/redim</a>" % self.configuration["version"]
+            )
 
 
 if __name__ == "__main__":
+    def main():
+        """Démarrage de l'app
+        """
+        app = QtWidgets.QApplication(sys.argv)
+        GUI = Gui()
+        sys.exit(app.exec_())
+
     main()
diff --git a/Redim/ui.py b/Redim/ui.py
deleted file mode 100644
index 593ee81..0000000
--- a/Redim/ui.py
+++ /dev/null
@@ -1,142 +0,0 @@
-"""Contient toute la partie 'TUI' de Redim"""
-
-from os import system
-from sys import platform
-
-
-class Ui:
-    """Gestion de l'interaction avec l'utilisateur"""
-    def __init__(self, configuration):
-        self.banner = (
-            "\n  ____                 _                 ____   ____ \n",
-            "|  _ \\ _ __ ___ _ __ (_)_   _ _ __ ___ |  _ \\ / ___|\n",
-            "| |_) | '__/ _ \\ '_ \\| | | | | '_ ` _ \\| |_) | |    \n",
-            "|  __/| | |  __/ | | | | |_| | | | | | |  __/| |___ \n",
-            "|_|   |_|  \\___|_| |_|_|\\__,_|_| |_| |_|_|    \\____|\n",
-            "\n######################################################\n",
-            "\n[-] tailles (lxh): {0}".format(
-                ", ".join(map(
-                    str,
-                    ["x".join(map(str, configuration["dimensions"][i]))
-                     for i in range(len(configuration["dimensions"]))]
-                ))
-            ),
-            "\n[-] rgb background:", configuration["background"],
-            "\n[-] formats acceptes:", configuration["formats_acceptes"],
-            "\n[-] format de sortie:", configuration["format_final"],
-            "\n\n######################################################"
-        )
-        self.menu = (
-            "\n[-] Que faire?\n",
-            "\n   (1) -> Conversions",
-            "\n   (5) -> Modification des tailles",
-            "\n   (6) -> Modification du RGB",
-            "\n   (7) -> Modification du format de sortie",
-            "\n   (8) -> Reset des parametres",
-            "\n   (9) -> Quitter\n"
-        )
-
-    def affichage_banner(self):
-        """Reset de l'écran + affichage de la 'banner'"""
-        self.reset_screen()
-        print(*self.banner)
-
-    def affichage_menu(self):
-        """Affichage du menu principal"""
-        print(*self.menu)
-
-    @staticmethod
-    def question_taille(configuration):
-        """Récupère largeur & hauteur pour chaques tailles
-        enregistrées dans la configuration initiale
-        """
-        texte = [
-            "    [>] Largeur: ",
-            "    [>] Hauteur: "
-        ]
-        tailles = []
-        for i in range(len(configuration)):
-            print("\n[-] Taille {0!s}:".format(i + 1))
-            dimensions = []
-            for j in texte:
-                while True:
-                    reponse = input(j)
-                    try:
-                        reponse = int(reponse.strip())
-                        if 5 < reponse < 5000:
-                            dimensions.append(reponse)
-                            break
-                        print("    [ERREUR] La valeur trop petite"
-                              " ou trop grande.")
-                    except ValueError:
-                        print("    [ERREUR] La valeur entree"
-                              " n'est pas un chiffre.")
-            tailles.append(dimensions)
-        return tailles
-
-    @staticmethod
-    def question_background(configuration):
-        """Récupère 3 valeurs entre 0 & 255 pour la couleur qui servira
-        en remplissage si les photos sont redimensionnées ou avec alpha
-        """
-        texte = [
-            "    [>] Valeur Rouge: ",
-            "    [>] Valeur Vert: ",
-            "    [>] Valeur Bleu: "
-        ]
-        background = []
-        print(
-            "\n[-] Modification de la couleur"
-            " du background (Valeur RGB 0-255):\n"
-        )
-        for i in range(len(configuration)):
-            while True:
-                reponse = input(texte[i])
-                try:
-                    reponse = int(reponse.strip())
-                    if 0 <= reponse < 256:
-                        background.append(reponse)
-                        break
-                    print("    [ERREUR] La valeur trop petite"
-                          " ou trop grande.")
-                except ValueError:
-                    print("    [ERREUR] La valeur entree"
-                          " n'est pas un chiffre.")
-        return background
-
-    @staticmethod
-    def question_format_final(configuration):
-        """Récupère le choix de sortie en fonction des formats
-        acceptés dans la configuration initiale
-        """
-        print("\n[-] Modification du format de sortie:\n")
-        for pos, i in enumerate(configuration[1:]):
-            print(
-                "    ("
-                + str(pos + 1)
-                + ") ->",
-                i
-            )
-        while True:
-            reponse = input("\n[>] Choix (numero) : ")
-            try:
-                reponse = int(reponse.strip())
-                if 0 < reponse <= len(configuration[1:]):
-                    format_final = "." + configuration[reponse]
-                    return format_final
-                print("[ERREUR] Choix en dehors des possibilites.")
-            except ValueError:
-                print("[ERREUR] La valeur entree n'est pas un chiffre.")
-
-    @staticmethod
-    def affichage_fin():
-        """Bête appuye sur entrer pour continuer"""
-        input("\n[-] fin, appuyer sur \'entrer\' pour continuer.")
-
-    @staticmethod
-    def reset_screen():
-        """Reset de l'écran, cls pour CMD windows"""
-        if platform != "linux":
-            system("cls")
-        else:
-            system("clear")
diff --git a/redim.iss b/redim.iss
deleted file mode 100644
index 45bb206..0000000
--- a/redim.iss
+++ /dev/null
@@ -1,48 +0,0 @@
-; Script generated by the Inno Setup Script Wizard.

-; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!

-

-#define MyAppName "Redim"

-#define MyAppVersion "1.0"

-#define MyAppPublisher "Quentin Inc."

-#define MyAppURL "https://debulois.fr"

-#define MyAppExeName "Redim.exe"

-

-[Setup]

-; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications.

-; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)

-AppId={{FCF826D1-36CE-4A3B-89DB-6621254B66CE}

-AppName={#MyAppName}

-AppVersion={#MyAppVersion}

-;AppVerName={#MyAppName} {#MyAppVersion}

-AppPublisher={#MyAppPublisher}

-AppPublisherURL={#MyAppURL}

-AppSupportURL={#MyAppURL}

-AppUpdatesURL={#MyAppURL}

-DefaultDirName={autopf}\{#MyAppName}

-DisableProgramGroupPage=yes

-; Uncomment the following line to run in non administrative install mode (install for current user only.)

-;PrivilegesRequired=lowest

-OutputBaseFilename=Redim_1.0_setup

-SetupIconFile=C:\Users\Utilisateur\Desktop\redim\Redim\Ressources\icon.ico

-Compression=lzma

-SolidCompression=yes

-WizardStyle=modern

-

-[Languages]

-Name: "french"; MessagesFile: "compiler:Languages\French.isl"

-

-[Tasks]

-Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked

-

-[Files]

-Source: "C:\Users\Utilisateur\Desktop\redim\dist\Redim\Redim.exe"; DestDir: "{app}"; Flags: ignoreversion

-Source: "C:\Users\Utilisateur\Desktop\redim\dist\Redim\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs

-; NOTE: Don't use "Flags: ignoreversion" on any shared system files

-

-[Icons]

-Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"

-Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon

-

-[Run]

-Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent

-

diff --git a/redim.spec b/redim.spec
deleted file mode 100644
index 782416d..0000000
--- a/redim.spec
+++ /dev/null
@@ -1,38 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-

-

-block_cipher = None

-

-

-a = Analysis(['Redim\\main.py'],

-             pathex=[],

-             binaries=[],

-             datas=[],

-             hiddenimports=['Pillow'],

-             hookspath=[],

-             runtime_hooks=[],

-             excludes=[],

-             win_no_prefer_redirects=False,

-             win_private_assemblies=False,

-             cipher=block_cipher,

-             noarchive=False)

-pyz = PYZ(a.pure, a.zipped_data,

-             cipher=block_cipher)

-exe = EXE(pyz,

-          a.scripts,

-          [],

-          exclude_binaries=True,

-          name='Redim',

-          debug=False,

-          bootloader_ignore_signals=False,

-          strip=False,

-          upx=True,

-          console=True,

-          icon='Redim/Ressources/icon.ico' )

-coll = COLLECT(exe,

-               a.binaries,

-               a.zipfiles,

-               a.datas,

-               strip=False,

-               upx=True,

-               upx_exclude=[],

-               name='Redim')