PEDI, Python Editeur

1. Introduction

Le programme PEDI est une application de type éditeur de texte créée à l’aide de Tkinter (bibliothèque d’interface graphique de Python). Elle est principalement conçue pour éditer des fichiers Python, avec des fonctionnalités telles que l’ouverture de plusieurs fichiers dans des onglets, la coloration syntaxique, la gestion de sessions précédentes, et une fenêtre de recherche pour le texte. Ce programme supporte également les raccourcis clavier pour des actions courantes comme la sauvegarde et la recherche.

2. Fonctionnalités

Édition de texte multi-onglets : possibilité d’ouvrir plusieurs fichiers simultanément, chaque fichier étant affiché dans un onglet distinct.
Coloration syntaxique : basée sur la syntaxe Python, elle colore les mots-clés, chaînes, commentaires, et nombres pour faciliter la lecture du code.
Recherche dans le texte : possibilité de rechercher du texte dans un fichier ouvert avec surlignage des occurrences trouvées.
Sauvegarde automatique de session : les fichiers ouverts sont mémorisés et restaurés lors de la prochaine ouverture du programme.
Sauvegarde et ouverture de fichiers : possibilité de sauvegarder un fichier spécifique ou tous les fichiers ouverts. L’utilisateur peut également ouvrir de nouveaux fichiers.
Gestion de la géométrie de la fenêtre : la taille et la position de la fenêtre sont sauvegardées et restaurées.
Raccourcis clavier : certains raccourcis (comme Ctrl+S pour sauvegarder, Ctrl+F pour rechercher) facilitent l’usage du programme.

3. Structure du Programme

3.1. Classe principale : `TextEditor`

La classe TextEditor hérite de tk.Tk et gère l’ensemble de la logique de l’application. Voici une vue d’ensemble des méthodes principales de la classe.

3.2. Méthodes principales

3.2.1. `init(self)`

Le constructeur initialise l’interface principale :

Charge les paramètres de configuration via load_config().
Initialise les onglets avec ttk.Notebook pour gérer plusieurs fichiers ouverts.
Charge la géométrie de la fenêtre depuis un fichier de configuration JSON.
Active les raccourcis clavier pour la sauvegarde (Ctrl+S) et la recherche (Ctrl+F).

3.2.2. `load_config(self)`

Charge les paramètres de la fenêtre depuis un fichier config.ini. Par exemple, le titre de la fenêtre est paramétrable.

3.2.3. `search_text(self, search_term)`

Recherche et surligne un terme dans le fichier ouvert. Le texte trouvé est mis en surbrillance avec un fond jaune.

3.2.4. `open_search_window(self)`

Ouvre une fenêtre secondaire permettant à l’utilisateur d’entrer un terme à rechercher. Le champ de saisie reçoit automatiquement le focus.

3.2.5. `save_window_geometry(self)` et `load_window_geometry(self)`

Ces deux méthodes permettent de sauvegarder et restaurer la taille et la position de la fenêtre dans un fichier JSON. Cela permet à l’application de rétablir la disposition précédente lors de l’ouverture suivante.

3.2.6. `new_file(self)`

Crée un nouvel onglet vide, prêt pour la saisie d’un nouveau fichier.

3.2.7. `open_file(self, filepath=None)`

Ouvre un fichier existant sélectionné par l’utilisateur et en affiche le contenu dans un nouvel onglet. Le fichier est ajouté à la liste des fichiers ouverts, et sa syntaxe est automatiquement colorée.

3.2.8. `save_file(self, tab_id)`

Sauvegarde le contenu d’un onglet donné dans le fichier associé. Si aucun fichier n’est associé, une boîte de dialogue de sauvegarde est présentée à l’utilisateur.

3.2.9. `save_all(self)`

Sauvegarde tous les fichiers ouverts dans l’éditeur. Si certains fichiers ont été modifiés mais pas encore sauvegardés, une boîte de dialogue apparaît pour confirmer la sauvegarde.

3.2.10. `close_tab(self, tab_id)`

Ferme un onglet et demande à l’utilisateur de sauvegarder les modifications si nécessaire.

3.2.11. `colorize_syntax(self, text_widget)`

Applique la coloration syntaxique au texte de l’onglet actuel. Utilise Pygments pour colorer les commentaires, chaînes, mots-clés, et autres éléments du code Python.

3.2.12. `load_last_session(self)` et `save_session(self)`

Ces méthodes permettent de restaurer les fichiers ouverts lors de la session précédente (stockés dans un fichier session.pkl) et de sauvegarder la liste des fichiers ouverts à la fermeture du programme.

3.2.13. `on_closing(self)`

Méthode appelée lors de la fermeture de la fenêtre. Elle sauvegarde les fichiers, la session actuelle, et la géométrie de la fenêtre avant de fermer l’application.

3.3. Gestion des événements

Les événements sont gérés via des bindings sur les widgets Tkinter :

Raccourcis clavier (Ctrl+S, Ctrl+F).
Défilement des lignes avec la molette de la souris.
Gestion des modifications : l’interface signale les modifications des fichiers avec une étoile (*) dans le nom de l’onglet.

3.4. Sauvegarde et ouverture de fichiers

Le programme utilise filedialog pour ouvrir et sauvegarder des fichiers :

Lors de l’ouverture de fichier, l’utilisateur peut choisir parmi des types spécifiques (.py ou tous les fichiers).
Lors de la sauvegarde, un fichier de destination est demandé si le fichier n’a pas encore été enregistré.

Le programme pedi utilise plusieurs modules et bibliothèques externes, ainsi que des bibliothèques intégrées de Python. Voici un récapitulatif des dépendances :

a. Dépendances internes à Python

Ces bibliothèques sont fournies par défaut avec toute installation de Python.

tkinter : La bibliothèque standard pour créer des interfaces graphiques en Python.
- tk.Tk, ttk.Notebook, filedialog, messagebox : Utilisés pour la création de la fenêtre principale, des onglets, des boîtes de dialogue de fichiers, et des boîtes de message.
os : Utilisé pour des opérations de gestion de fichiers et de répertoires, comme la récupération du chemin du fichier.
json : Utilisé pour lire et écrire des fichiers de configuration en format JSON, notamment pour sauvegarder/restaurer la géométrie de la fenêtre.
pickle : Utilisé pour sérialiser et désérialiser les objets Python, notamment pour sauvegarder/restaurer la session de fichiers ouverts.
re : Utilisé pour la gestion de recherches de texte avec des expressions régulières.
configparser : Utilisé pour lire les fichiers de configuration .ini qui permettent de définir certains paramètres (comme le titre de la fenêtre).

b. Dépendances externes

Ces bibliothèques doivent être installées séparément, car elles ne sont pas incluses par défaut avec Python.

pygments : Bibliothèque externe pour la coloration syntaxique. Elle fournit les lexers nécessaires pour identifier et colorer les différentes parties du code Python.
- PythonLexer : Utilisé pour analyser et tokeniser le code Python.
- Token : Utilisé pour appliquer la coloration syntaxique en fonction des types de jetons (mots-clés, chaînes, commentaires, etc.).

c. Installation des dépendances externes

Les dépendances externes comme Pygments doivent être installées avec pip :

Shell

pip install pygments

d. Fichier `config.ini`

Ce programme attend l’existence d’un fichier config.ini pour configurer certains aspects, comme le titre de la fenêtre. Voici un exemple minimal de ce fichier :

Plain Text

[settings]
window_title = "Votre projet"

4. SOURCE

Python

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import os,json,pickle,re,configparser
from pygments import lex
from pygments.lexers import PythonLexer
from pygments.token import Token

class TextEditor(tk.Tk):
    def __init__(self):
        super().__init__()
        self.load_config()
        self.title(self.window_title)
        self.geometry("800×600")
        self.tab_control = ttk.Notebook(self)
        self.tab_control.pack(expand=1, fill="both")
        self.open_files = {} 
        self.load_window_geometry()
        self.load_last_session()
        self.protocol("WM_DELETE_WINDOW", self.on_closing)
        self.tab_size = 4  
        self.bind("<Control-s>", self.save_current_file)
        self.bind("<Control-f>", lambda event: self.open_search_window())

    def load_config(self):
        config = configparser.ConfigParser()
        config.read('config.ini')
        self.window_title = "PEDI, Projet [ "+config.get('settings', 'window_title', fallback='?')+" ]"

    def search_text(self, search_term):
        tab = self.tab_control.select()
        text_widget = self.get_text_widget(self.nametowidget(tab))
        if not hasattr(self, 'last_search_pos') or not self.last_search_term == search_term:
            self.last_search_pos = '1.0'  
            self.last_search_term = search_term  
        text_widget.tag_remove('highlight', '1.0', tk.END)
        if search_term:
            start_pos = text_widget.search(search_term, self.last_search_pos, stopindex=tk.END)
            if not start_pos:  
                start_pos = text_widget.search(search_term, '1.0', stopindex=tk.END)
            if start_pos:  
                end_pos = f"{start_pos}+{len(search_term)}c"
                text_widget.tag_add('highlight', start_pos, end_pos)
                text_widget.tag_config('highlight', background='yellow', foreground='black')
                text_widget.mark_set("insert", start_pos)
                text_widget.see(start_pos)
                self.update_line_numbers(text_widget, self.nametowidget(tab).line_numbers)
                self.last_search_pos = end_pos
   
    def open_search_window(self):
        if hasattr(self, 'search_window') and self.search_window.winfo_exists():
            self.search_window.lift()
            return
        self.search_window = tk.Toplevel(self)
        self.search_window.title("Recherche")
        x = self.winfo_x()   
        y = self.winfo_y()   
        self.search_window.geometry(f"+{x}+{y}")
        tk.Label(self.search_window, text="Rechercher:").pack(side="left", padx=10, pady=10)
        search_entry = tk.Entry(self.search_window)
        search_entry.pack(side="left", padx=10, pady=10)
        search_entry.focus_set()
        search_button = tk.Button(self.search_window, text="Rechercher", command=lambda: self.search_text(search_entry.get()))
        search_button.pack(side="left", padx=10, pady=10)
        search_entry.bind("<Return>", lambda event: self.search_text(search_entry.get()))
 
    def save_window_geometry(self):
        geometry = self.geometry() 
        with open("window_config.json", "w") as config_file:
            json.dump({"geometry": geometry}, config_file)

    def load_window_geometry(self):
        if os.path.exists("window_config.json"):
            with open("window_config.json", "r") as config_file:
                config = json.load(config_file)
                geometry = config.get("geometry")
                if geometry:
                    self.geometry(geometry) 

    def new_file(self):
        tab = self.create_tab("Nouveau fichier")
        self.open_files[tab] = None  
        self.tab_control.select(tab) 

    def open_file(self, filepath=None):
        if filepath is None:
            initial_dir = self.get_app_directory()  
            filepath = filedialog.askopenfilename(initialdir=initial_dir,filetypes=[("Python Files", "*.py"), ("All Files", "*.*")])
            if not filepath:
                return
        if filepath in self.open_files.values():
            messagebox.showinfo("Info", "Ce fichier est deja ouvert.")
            return
        with open(filepath, "r") as file:
            content = file.read()
        tab = self.create_tab(os.path.basename(filepath))
        self.open_files[tab] = filepath
        text_widget = self.get_text_widget(tab)
        text_widget.insert(tk.END, content)
        text_widget.edit_modified(False)  
        self.colorize_syntax(text_widget)
        self.tab_control.select(tab)  

    def create_tab(self, title):
        tab = ttk.Frame(self.tab_control)
        self.tab_control.add(tab, text=title)
        frame = tk.Frame(tab)
        frame.pack(fill='both', expand=True)
        line_numbers = tk.Text(frame, width=4, padx=4, takefocus=0, border=0,background='lightgrey', state='disabled', wrap='none')
        line_numbers.pack(side='left', fill='y')
        text_widget = tk.Text(frame, wrap="none", undo=True)
        text_widget.pack(side='right', fill='both', expand=True)
        y_scroll = ttk.Scrollbar(frame, orient="vertical", command=text_widget.yview)
        y_scroll.pack(side="right", fill="y")
        text_widget.configure(yscrollcommand=y_scroll.set)
        line_numbers.configure(yscrollcommand=y_scroll.set)
        x_scroll = ttk.Scrollbar(tab, orient="horizontal", command=text_widget.xview)
        x_scroll.pack(side="bottom", fill="x")
        text_widget.configure(xscrollcommand=x_scroll.set)
        tab.text_widget = text_widget
        tab.line_numbers = line_numbers
        text_widget.bind("<KeyRelease>", lambda event: self.on_text_change(event, text_widget, line_numbers))
        text_widget.bind("<Button-1>", lambda event: self.on_text_change(event, text_widget, line_numbers))
        text_widget.bind("<MouseWheel>", lambda event: self.on_scroll(event, text_widget, line_numbers))
        text_widget.bind("<Configure>", lambda event: self.update_line_numbers(text_widget, line_numbers))
        text_widget.bind("<Tab>", self.on_tab_press)  
        self.update_line_numbers(text_widget, line_numbers)
        return tab

    def on_tab_press(self, event):
        """Remplace la touche Tab par 4 espaces."""
        text_widget = self.focus_get()
        if isinstance(text_widget, tk.Text):
            text_widget.insert(tk.INSERT, ' ' * self.tab_size)
            return "break"

    def get_text_widget(self, tab):
        """Récupère le widget Text associé à un onglet donné."""
        return tab.text_widget

    def save_file(self, tab_id):
        """Sauvegarde le contenu d'un onglet dans un fichier."""
        tab = self.nametowidget(tab_id)
        filepath = self.open_files.get(tab)
        if not filepath:
            initial_dir = self.get_app_directory()  
            filepath = filedialog.asksaveasfilename(initialdir=initial_dir,defaultextension=".py", filetypes=[("Python Files", "*.py"), ("All Files", "*.*")])
            if not filepath:
                return
        content = self.get_text_widget(tab).get(1.0, tk.END)
        with open(filepath, "w",encoding="utf-8") as file:
            file.write(content)
        self.open_files[tab] = filepath
        self.tab_control.tab(tab, text=os.path.basename(filepath))
        tab_text = self.tab_control.tab(tab_id, "text").rstrip(" *")
        self.tab_control.tab(tab_id, text=tab_text)

    def save_all(self):
        for tab in self.open_files:
            text_widget = self.get_text_widget(tab)
            if text_widget.edit_modified():
                answer = messagebox.askyesnocancel("Fichier modifie", f"Le fichier '{self.tab_control.tab(tab, 'text')}' a ete modifie. Voulez-vous le sauvegarder ?")
                if answer is None:
                    return
                elif answer:
                    self.save_file(self.tab_control.index(tab))
                else:
                    continue

    def save_current_file(self, event=None):
        current_tab = self.tab_control.select()
        self.save_file(current_tab)

    def update_line_numbers(self, text_widget, line_numbers):
        line_numbers.config(state='normal')
        line_numbers.delete('1.0', 'end')
        start_line = int(text_widget.index("@0,0").split('.')[0])
        end_line = int(text_widget.index("@0,%s" % (text_widget.winfo_height())).split('.')[0])
        line_numbers_str = "\n".join(str(i) for i in range(start_line, end_line + 1))
        line_numbers.insert('1.0', line_numbers_str)
        line_numbers.config(state='disabled')

    def close_tab(self, tab_id):
        tab = self.nametowidget(tab_id)
        text_widget = self.get_text_widget(tab)
        if text_widget.edit_modified():
            answer = messagebox.askyesnocancel("Fichier modifie", "Le fichier a ete modifie. Voulez-vous sauvegarder ?")
            if answer is None:
                return  
            elif answer:
                self.save_file(tab_id)  
        self.open_files.pop(tab, None)
        self.tab_control.forget(tab)

    def colorize_syntax(self, text_widget):
        content = text_widget.get(1.0, tk.END)
        text_widget.mark_set("range_start", "1.0")
        text_widget.mark_set("range_end", "1.0")
        lexer = PythonLexer()
        for token, value in lex(content, lexer):
            start_pos = text_widget.search(value, "range_start", tk.END, nocase=False, regexp=False)
            if start_pos:
                end_pos = f"{start_pos}+{len(value)}c"
                text_widget.tag_add(str(token), start_pos, end_pos)
                color = "black"
                if token in Token.Comment:
                    color="red"
                elif token in Token.String:
                    color = "green" if value.startswith('"""') else "orange"
                elif token in Token.Keyword:
                    color = "blue"
                elif token in Token.Number:
                    color="magenta"    
                text_widget.tag_config(str(token), foreground=color)
                text_widget.mark_set("range_start", end_pos)
  
    def get_app_directory(self):
        return os.path.dirname(os.path.abspath(__file__))  
    
    def load_last_session(self):
        if os.path.exists("session.pkl"):
            with open("session.pkl", "rb") as f:
                open_files = pickle.load(f)
            for filepath in open_files:
                if filepath and os.path.exists(filepath): 
                    self.open_file(filepath)
                else:
                    self.new_file()  
    
    def save_session(self):
        with open("session.pkl", "wb") as f:
            pickle.dump(list(self.open_files.values()), f)

    def on_closing(self):
        self.save_all()
        self.save_session()
        self.save_window_geometry()
        self.destroy()

    def on_text_change(self, event, text_widget, line_numbers):
        self.update_line_numbers(text_widget, line_numbers)
        self.colorize_syntax(text_widget)
        if text_widget.edit_modified():
            tab_id = self.tab_control.index("current")
            tab_text = self.tab_control.tab(tab_id, "text")
            if not tab_text.endswith("*"):
                self.tab_control.tab(tab_id, text=tab_text + " *")
            text_widget.edit_modified(False) 
        
    def on_scroll(self, event, text_widget, line_numbers):
        self.update_line_numbers(text_widget, line_numbers)
        if event.num == 4:
            text_widget.yview_scroll(-1, "units")
        elif event.num == 5:
            text_widget.yview_scroll(1, "units")

if __name__ == "__main__":
    editor = TextEditor()
    menu_bar = tk.Menu(editor)
    file_menu = tk.Menu(menu_bar, tearoff=0)
    file_menu.add_command(label="Nouveau", command=editor.new_file)
    file_menu.add_command(label="Ouvrir", command=editor.open_file)
    file_menu.add_command(label="Enregistrer", command=lambda: editor.save_file(editor.tab_control.select()))
    file_menu.add_command(label="Enregistrer tout", command=editor.save_all)
    file_menu.add_separator()
    file_menu.add_command(label="Fermer l'onglet", command=lambda: editor.close_tab(editor.tab_control.select()))
    file_menu.add_separator()
    file_menu.add_command(label="Quitter", command=editor.on_closing)
    menu_bar.add_cascade(label="Fichier", menu=file_menu)
    editor.config(menu=menu_bar)
    editor.mainloop()

Grimeco

PEDI, Python Editeur

1. Introduction

2. Fonctionnalités

3. Structure du Programme

3.1. Classe principale : `TextEditor`

3.2. Méthodes principales

3.2.1. `init(self)`

3.2.2. `load_config(self)`

3.2.3. `search_text(self, search_term)`

3.2.4. `open_search_window(self)`

3.2.5. `save_window_geometry(self)` et `load_window_geometry(self)`

3.2.6. `new_file(self)`

3.2.7. `open_file(self, filepath=None)`

3.2.8. `save_file(self, tab_id)`

3.2.9. `save_all(self)`

3.2.10. `close_tab(self, tab_id)`

3.2.11. `colorize_syntax(self, text_widget)`

3.2.12. `load_last_session(self)` et `save_session(self)`

3.2.13. `on_closing(self)`

3.3. Gestion des événements

3.4. Sauvegarde et ouverture de fichiers

a. Dépendances internes à Python

b. Dépendances externes

c. Installation des dépendances externes

d. Fichier `config.ini`

4. SOURCE

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Ollama : Intégration de LLMs en local

Raspberry Radio Internet (Partie 1)

Laisser un commentaire Annuler la réponse

PEDI, Python Editeur

1. Introduction

2. Fonctionnalités

3. Structure du Programme

3.1. Classe principale : TextEditor

3.2. Méthodes principales

3.2.1. __init__(self)

3.2.2. load_config(self)

3.2.3. search_text(self, search_term)

3.2.4. open_search_window(self)

3.2.5. save_window_geometry(self) et load_window_geometry(self)

3.2.6. new_file(self)

3.2.7. open_file(self, filepath=None)

3.2.8. save_file(self, tab_id)

3.2.9. save_all(self)

3.2.10. close_tab(self, tab_id)

3.2.11. colorize_syntax(self, text_widget)

3.2.12. load_last_session(self) et save_session(self)

3.2.13. on_closing(self)

3.3. Gestion des événements

3.4. Sauvegarde et ouverture de fichiers

a. Dépendances internes à Python

b. Dépendances externes

c. Installation des dépendances externes

d. Fichier config.ini

4. SOURCE

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Ollama : Intégration de LLMs en local

Raspberry Radio Internet (Partie 1)

Laisser un commentaire Annuler la réponse

3.1. Classe principale : `TextEditor`

3.2.1. `init(self)`

3.2.2. `load_config(self)`

3.2.3. `search_text(self, search_term)`

3.2.4. `open_search_window(self)`

3.2.5. `save_window_geometry(self)` et `load_window_geometry(self)`

3.2.6. `new_file(self)`

3.2.7. `open_file(self, filepath=None)`

3.2.8. `save_file(self, tab_id)`

3.2.9. `save_all(self)`

3.2.10. `close_tab(self, tab_id)`

3.2.11. `colorize_syntax(self, text_widget)`

3.2.12. `load_last_session(self)` et `save_session(self)`

3.2.13. `on_closing(self)`

d. Fichier `config.ini`