Éditeur de Schémas Électroniques

Cet éditeur permet de créer et modifier des schémas électroniques de manière interactive. Il offre une interface graphique intuitive pour manipuler des composants et leurs connexions.
Fonctionnalités Principales

Gestion des Fichiers

📂 Charger un schéma existant
💾 Sauvegarder le schéma en cours
📥 Importer des composants depuis la bibliothèque
📤 Exporter des composants vers la bibliothèque
Manipulation des Composants

➕ Ajouter un nouveau composant
❌ Supprimer un composant existant
🖱️ Déplacer les composants par glisser-déposer
Gestion des Broches

⚡ Ajouter une nouvelle broche à un composant
🗑️ Supprimer une broche existante
🔗 Créer des connexions entre les broches
✂️ Supprimer des connexions
Interface Utilisateur

Barre de Menu

La barre de menu contient les options principales :
Menu Fichier : Pour charger, sauvegarder et gérer les schémas
Barre d’Outils

La barre d’outils offre un accès rapide aux fonctions principales :
Boutons de gauche : Ajout et connexion
Boutons de droite : Suppression
Zone de Travail

Canevas blanc pour le dessin du schéma
Support du glisser-déposer pour les composants
Affichage visuel des connexions
Utilisation

Création d’un Composant

Cliquer sur le bouton ➕
Saisir le nom du composant
Définir ses dimensions
Positionner le composant sur le canevas
Ajout de Broches

Sélectionner un composant
Cliquer sur le bouton ⚡
Configurer la broche (nom, type, position)
Création de Connexions

Activer le mode connexion 🔗
Cliquer sur la première broche
Cliquer sur la deuxième broche
Gestion de la Bibliothèque

Exporter : Sauvegarder un composant comme modèle
Importer : Réutiliser un modèle existant
Sauvegarde et Chargement

Les schémas sont sauvegardés au format JSON
Les modèles sont stockés dans le dossier ‘modeles’
Configuration de la fenêtre sauvegardée dans ‘config.json’
Notes Techniques

Développé en Python avec Tkinter
Structure orientée objet
Gestion des événements souris pour l’interaction
Système de coordonnées pour le positionnement
Source

Python
import tkinter as tk
from tkinter import ttk, filedialog, colorchooser, messagebox
from dataclasses import dataclass
from typing import List, Optional, Tuple
import math
import json
import re
import os


@dataclass
class Pin:
    x: float
    y: float
    parent: 'Component'
    is_input: bool = True
    connected_to: Optional['Pin'] = None
    name: str = "Pin"
    connection_color: str = "blue"  # Default connection color

@dataclass
class Component:
    x: float
    y: float
    width: float = 100
    height: float = 60
    label: str = "Component"
    input_pins: List[Pin] = None
    output_pins: List[Pin] = None
    MIN_PIN_SPACING: float = 30  # Minimum space between pins
    MIN_LABEL_SPACING: float = 20  # Minimum space between labels

    def __hash__(self):
        return hash(self.label)

    def __eq__(self, other):
        if not isinstance(other, Component):
            return False
        return self.label == other.label

    def __post_init__(self):
        if self.input_pins is None:
            self.input_pins = []
        if self.output_pins is None:
            self.output_pins = []

    def get_pins_on_side(self, side: str) -> List[Pin]:
        pins = []
        for pin in self.input_pins + self.output_pins:
            if (
                (side == "left" and abs(pin.x – self.x) < 1) or
                (side == "right" and abs(pin.x – (self.x + self.width)) < 1) or
                (side == "top" and abs(pin.y – self.y) < 1) or
                (side == "bottom" and abs(pin.y – (self.y + self.height)) < 1)
            ):
                pins.append(pin)
        return sorted(pins, key=lambda p: p.y if side in ["left", "right"] else p.x)

    def calculate_pin_position(self, side: str) -> Tuple[float, float]:
        pins = self.get_pins_on_side(side)
        MARGIN = 20  # Margin from component edges
        DELTA = 30   # Fixed spacing between pins

        if side == "left":
            x = self.x
            y = self.y + MARGIN + (len(pins) * DELTA)
            return x, y
        elif side == "right":
            x = self.x + self.width
            y = self.y + MARGIN + (len(pins) * DELTA)
            return x, y
        else:  # top or bottom
            y = self.y if side == "top" else self.y + self.height
            x = self.x + MARGIN + (len(pins) * DELTA)
            return x, y

    def adjust_height(self):
        # Get all pins on all sides
        left_pins = self.get_pins_on_side("left")
        right_pins = self.get_pins_on_side("right")
        top_pins = self.get_pins_on_side("top")
        bottom_pins = self.get_pins_on_side("bottom")
        
        # Calculate required height based on vertical pins
        vertical_pins_count = max(len(left_pins), len(right_pins))
        required_height = 60  # Minimum height
        if vertical_pins_count > 0:
            # Ajuster la hauteur en fonction du nombre de broches
            # Utiliser un espacement plus optimal entre les broches
            required_height = vertical_pins_count * self.MIN_PIN_SPACING + 20  # Réduire la marge
        
        # Calculate required width based on horizontal pins
        horizontal_pins_count = max(len(top_pins), len(bottom_pins))
        required_width = 60  # Minimum width
        if horizontal_pins_count > 0:
            required_width = horizontal_pins_count * self.MIN_PIN_SPACING + 40  # Add margin
        
        # Update dimensions
        self.height = max(required_height, self.height)
        self.width = max(required_width, self.width)

    def add_pin(self, side: str, name: str, is_input: bool = True):
        x, y = self.calculate_pin_position(side)
        pin = Pin(x, y, self, is_input, name=name)
        
        if is_input:
            self.input_pins.append(pin)
        else:
            self.output_pins.append(pin)
            
        # Adjust component height after adding a pin
        self.adjust_height()

    def move(self, dx: float, dy: float):
        # Store original positions of pins relative to component
        pin_positions = []
        for pin in self.input_pins + self.output_pins:
            # Determine which side the pin is on
            if abs(pin.x – self.x) < 1:  # Left side
                side = "left"
                relative_pos = (pin.y – self.y) / self.height
            elif abs(pin.x – (self.x + self.width)) < 1:  # Right side
                side = "right"
                relative_pos = (pin.y – self.y) / self.height
            elif abs(pin.y – self.y) < 1:  # Top side
                side = "top"
                relative_pos = (pin.x – self.x) / self.width
            else:  # Bottom side
                side = "bottom"
                relative_pos = (pin.x – self.x) / self.width
            pin_positions.append((pin, side, relative_pos))

        # Update component position
        self.x += dx
        self.y += dy

        # Update pin positions while maintaining their relative positions
        for pin, side, relative_pos in pin_positions:
            if side == "left":
                pin.x = self.x
                pin.y = self.y + (relative_pos * self.height)
            elif side == "right":
                pin.x = self.x + self.width
                pin.y = self.y + (relative_pos * self.height)
            elif side == "top":
                pin.x = self.x + (relative_pos * self.width)
                pin.y = self.y
            else:  # bottom
                pin.x = self.x + (relative_pos * self.width)
                pin.y = self.y + self.height

class SchemaEditor(tk.Tk):
    def __init__(self):
        super().__init__()

        self.title("Schema Editor")
        
        # Load window configuration
        try:
            with open('config.json', 'r') as f:
                config = json.load(f)
                window_config = config['window']
                geometry = f"{window_config['width']}x{window_config['height']}+{window_config['x']}+{window_config['y']}"
                self.geometry(geometry)
        except:
            self.geometry("800×600")

        # Create menu bar
        self.menubar = tk.Menu(self)
        self.config(menu=self.menubar)

        # Create File menu
        self.file_menu = tk.Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="📁 Fichier", menu=self.file_menu)
        self.file_menu.add_command(label="📂 Charger un schéma", command=self.load_schema)
        self.file_menu.add_command(label="💾 Sauvegarder le schéma", command=self.save_schema)
        self.file_menu.add_separator()
        self.file_menu.add_command(label="📥 Importer composant", command=self.import_component)
        self.file_menu.add_command(label="📤 Exporter composant", command=self.export_component)

        # Create toolbar frame
        self.toolbar = ttk.Frame(self)
        self.toolbar.pack(side=tk.TOP, fill=tk.X)

        # Create left and right frames for toolbar buttons
        self.left_toolbar = ttk.Frame(self.toolbar)
        self.left_toolbar.pack(side=tk.LEFT, fill=tk.X)
        self.right_toolbar = ttk.Frame(self.toolbar)
        self.right_toolbar.pack(side=tk.RIGHT, fill=tk.X)

        def create_toolbar_button(icon, text, command, side='left'):
            parent = self.left_toolbar if side == 'left' else self.right_toolbar
            btn = ttk.Button(parent, text=icon, command=command)
            btn.pack(side=tk.LEFT, padx=5, pady=5)
            Tooltip(btn, text)
            return btn

        # Create toolbar buttons with icons and tooltips
        self.add_btn = create_toolbar_button('➕', 'Ajouter un composant', self.add_component_dialog, 'left')
        self.add_pin_btn = create_toolbar_button('⚡', 'Ajouter broche', self.add_pin_dialog, 'left')
        self.connect_btn = create_toolbar_button('🔗', 'Connecter broches', self.start_connection_mode, 'left')
        self.delete_connection_btn = create_toolbar_button('✂️', 'Supprimer un lien', self.start_delete_connection_mode, 'right')
        self.delete_pin_btn = create_toolbar_button('🗑️', 'Supprimer une broche', self.start_delete_pin_mode, 'right')
        self.delete_component_btn = create_toolbar_button('❌', 'Supprimer composant', self.start_delete_component_mode, 'right')

        #self.export_btn = ttk.Button(self.toolbar, text="Exporter composant", command=self.export_component)
        #self.export_btn.pack(side=tk.LEFT, padx=5, pady=5)

        #self.import_btn = ttk.Button(self.toolbar, text="Importer composant", command=self.import_component)
        #self.import_btn.pack(side=tk.LEFT, padx=5, pady=5)


        self.canvas = tk.Canvas(self, bg='white')
        self.canvas.pack(fill=tk.BOTH, expand=True)

        self.components: List[Component] = []
        self.selected_component = None
        self.drag_start = None
        self.connection_mode = False
        self.delete_connection_mode = False
        self.delete_pin_mode = False
        self.delete_component_mode = False
        self.first_pin = None
        
        # Variables pour mémoriser le dernier composant et côté sélectionnés
        self.last_selected_component = None
        self.last_selected_side = "left"

        # Bind mouse events
        self.canvas.bind('<Button-1>', self.on_click)
        self.canvas.bind('<B1-Motion>', self.on_drag)
        self.canvas.bind('<ButtonRelease-1>', self.on_release)
        
        # Bind window close event
        self.protocol("WM_DELETE_WINDOW", self.on_closing)
        
    def center_dialog(self, dialog):
        # Attendre que la fenêtre soit mise à jour pour obtenir sa taille réelle
        dialog.update()
        
        # Obtenir les dimensions de la fenêtre principale
        main_x = self.winfo_x()
        main_y = self.winfo_y()
        main_width = self.winfo_width()
        main_height = self.winfo_height()
        
        # Obtenir les dimensions de la fenêtre de dialogue
        dialog_width = dialog.winfo_width()
        dialog_height = dialog.winfo_height()
        
        # Calculer les coordonnées pour centrer la fenêtre de dialogue
        x = main_x + (main_width – dialog_width) // 2
        y = main_y + (main_height – dialog_height) // 2
        
        # Positionner la fenêtre de dialogue
        dialog.geometry(f"+{x}+{y}")

    def export_component(self):
        if not self.components:
            messagebox.showwarning("Attention", "Aucun composant n'est disponible pour l'export.")
            return

        # Créer la fenêtre de nom
        dialog = tk.Toplevel(self)
        dialog.title("Exporter le modèle")
        dialog.geometry("300×150")
        dialog.resizable(False, False)
        self.center_dialog(dialog)

        ttk.Label(dialog, text="Nom du modèle:").pack(pady=5)
        name_var = tk.StringVar()
        ttk.Entry(dialog, textvariable=name_var).pack(pady=5)

        def save_model():
            model_name = name_var.get()
            if not model_name:
                messagebox.showwarning("Attention", "Veuillez entrer un nom pour le modèle.")
                return

            # Créer le répertoire 'modeles' s'il n'existe pas
            os.makedirs('modeles', exist_ok=True)

            # Préparer les données du modèle avec tous les composants
            model_data = {
                'components': [{
                    'x': comp.x,
                    'y': comp.y,
                    'width': comp.width,
                    'height': comp.height,
                    'label': comp.label,
                    'input_pins': [{
                        'name': pin.name,
                        'is_input': pin.is_input,
                        'connection_color': pin.connection_color,
                        'side': 'left' if abs(pin.x – comp.x) < 1 else
                               'right' if abs(pin.x – (comp.x + comp.width)) < 1 else
                               'top' if abs(pin.y – comp.y) < 1 else 'bottom'
                    } for pin in comp.input_pins],
                    'output_pins': [{
                        'name': pin.name,
                        'is_input': pin.is_input,
                        'connection_color': pin.connection_color,
                        'side': 'left' if abs(pin.x – comp.x) < 1 else
                               'right' if abs(pin.x – (comp.x + comp.width)) < 1 else
                               'top' if abs(pin.y – comp.y) < 1 else 'bottom'
                    } for pin in comp.output_pins]
                } for comp in self.components]
            }

            # Sauvegarder le modèle
            file_path = os.path.join('modeles', f'{model_name}.json')
            with open(file_path, 'w') as f:
                json.dump(model_data, f, indent=4)

            dialog.destroy()
            #messagebox.showinfo("Succès", f"Le modèle a été exporté dans {file_path}")

        ttk.Button(dialog, text="Sauvegarder", command=save_model).pack(pady=10)
        ttk.Button(dialog, text="Annuler", command=dialog.destroy).pack(pady=5)

    def import_component(self):
        # Vérifier les composants disponibles
        os.makedirs('modeles', exist_ok=True)
        available_components = [f for f in os.listdir('modeles') if f.endswith('.json')]

        if not available_components:
            messagebox.showinfo("Information", "Aucun composant n'est disponible à l'import.")
            return

        # Créer la fenêtre de sélection
        dialog = tk.Toplevel(self)
        dialog.title("Importer un composant")
        dialog.geometry("300×400")
        dialog.resizable(False, False)
        self.center_dialog(dialog)

        ttk.Label(dialog, text="Sélectionnez un composant:").pack(pady=5)
        listbox = tk.Listbox(dialog, width=40, height=15)
        listbox.pack(pady=5, padx=5)

        for comp in available_components:
            listbox.insert(tk.END, comp[:-5])  # Afficher sans l'extension .json

        def load_component():
            if not listbox.curselection():
                messagebox.showwarning("Attention", "Veuillez sélectionner un composant.")
                return

            selected = listbox.get(listbox.curselection())
            with open(f'modeles/{selected}.json', 'r') as f:
                model_data = json.load(f)

            # Prendre le premier composant du modèle
            comp_data = model_data['components'][0]

            # Créer le nouveau composant
            new_comp = Component(
                x=100,  # Position par défaut
                y=100,
                width=comp_data['width'],
                height=comp_data['height'],
                label=comp_data['label']
            )

            # Ajouter les broches
            for pin_data in comp_data['input_pins']:
                pin = Pin(
                    x=0,  # La position sera calculée par calculate_pin_position
                    y=0,
                    parent=new_comp,
                    is_input=pin_data['is_input'],
                    name=pin_data['name'],
                    connection_color=pin_data['connection_color']
                )
                new_comp.input_pins.append(pin)

            for pin_data in comp_data['output_pins']:
                pin = Pin(
                    x=0,  # La position sera calculée par calculate_pin_position
                    y=0,
                    parent=new_comp,
                    is_input=pin_data['is_input'],
                    name=pin_data['name'],
                    connection_color=pin_data['connection_color']
                )
                new_comp.output_pins.append(pin)

            # Recalculer les positions des broches en respectant leur côté d'origine
            for i, pin in enumerate(new_comp.input_pins):
                side = comp_data['input_pins'][i]['side']  # Utiliser le côté sauvegardé
                x, y = new_comp.calculate_pin_position(side)
                pin.x, pin.y = x, y

            for i, pin in enumerate(new_comp.output_pins):
                side = comp_data['output_pins'][i]['side']  # Utiliser le côté sauvegardé
                x, y = new_comp.calculate_pin_position(side)
                pin.x, pin.y = x, y

            self.components.append(new_comp)
            #self.canvas.delete('all')
            for component in self.components:
                self.draw_component(component)

            dialog.destroy()
            #messagebox.showinfo("Succès", f"Le composant {selected} a été importé avec succès.")

        ttk.Button(dialog, text="Importer", command=load_component).pack(pady=10)
        ttk.Button(dialog, text="Annuler", command=dialog.destroy).pack(pady=5)

    def on_closing(self):
        # Ask user if they want to save the schema
        if self.components:
            response = messagebox.askyesnocancel("Sauvegarder", "Voulez-vous sauvegarder le schéma avant de quitter ?")
            if response is None:  # Cancel
                return
            if response:  # Yes
                self.save_schema()

        # Save window configuration
        geometry = self.geometry()
        match = re.match(r'(\d+)x(\d+)\+(\d+)\+(\d+)', geometry)
        if match:
            width, height, x, y = map(int, match.groups())
            config = {
                'window': {
                    'width': width,
                    'height': height,
                    'x': x,
                    'y': y
                }
            }
            with open('config.json', 'w') as f:
                json.dump(config, f, indent=4)
        
        self.destroy()

    def add_component_dialog(self):
        dialog = tk.Toplevel(self)
        dialog.title("Ajouter un composant")
        dialog.geometry("300×150")
        dialog.resizable(False, False)
        self.center_dialog(dialog)

        # Label input
        ttk.Label(dialog, text="Libellé du composant:").pack(pady=5)
        label_var = tk.StringVar(value="Component")
        ttk.Entry(dialog, textvariable=label_var).pack(pady=5)

        def add_component():
            x = 100  # Default position
            y = 100
            component = Component(x, y, label=label_var.get())
            self.components.append(component)
            self.canvas.delete('all')
            for component in self.components:
                self.draw_component(component)
            dialog.destroy()

        button_frame = ttk.Frame(dialog)
        button_frame.pack(pady=10, fill=tk.X)
        ttk.Button(button_frame, text="Ajouter", command=add_component).pack(side=tk.LEFT, padx=5, expand=True)
        ttk.Button(button_frame, text="Annuler", command=dialog.destroy).pack(side=tk.LEFT, padx=5, expand=True)

    def save_schema(self):
        file_path = filedialog.asksaveasfilename(defaultextension=".json",
                                                filetypes=[("JSON files", "*.json")])
        if file_path:
            schema_data = {
                'components': [
                    {
                        'x': comp.x,
                        'y': comp.y,
                        'width': comp.width,
                        'height': comp.height,
                        'label': comp.label,
                        'input_pins': [
                            {
                                'x': pin.x,
                                'y': pin.y,
                                'name': pin.name,
                                'is_input': pin.is_input,
                                'connection_color': pin.connection_color,
                                'connected_to': {
                                    'component_label': pin.connected_to.parent.label,
                                    'pin_name': pin.connected_to.name
                                } if pin.connected_to else None
                            } for pin in comp.input_pins
                        ],
                        'output_pins': [
                            {
                                'x': pin.x,
                                'y': pin.y,
                                'name': pin.name,
                                'is_input': pin.is_input,
                                'connection_color': pin.connection_color,
                                'connected_to': {
                                    'component_label': pin.connected_to.parent.label,
                                    'pin_name': pin.connected_to.name
                                } if pin.connected_to else None
                            } for pin in comp.output_pins
                        ]
                    } for comp in self.components
                ]
            }
            with open(file_path, 'w') as f:
                json.dump(schema_data, f, indent=4)

    def load_schema(self):
        file_path = filedialog.askopenfilename(filetypes=[("JSON files", "*.json")])
        if file_path:
            with open(file_path, 'r') as f:
                schema_data = json.load(f)
                self.components.clear()
                
                # First pass: Create all components and pins
                components_dict = {}
                for comp_data in schema_data['components']:
                    component = Component(
                        x=comp_data['x'],
                        y=comp_data['y'],
                        width=comp_data['width'],
                        height=comp_data['height'],
                        label=comp_data['label']
                    )
                    components_dict[comp_data['label']] = component
                    
                    # Load input pins
                    for pin_data in comp_data.get('input_pins', []):
                        pin = Pin(
                            x=pin_data['x'],
                            y=pin_data['y'],
                            parent=component,
                            is_input=pin_data['is_input'],
                            name=pin_data['name'],
                            connection_color=pin_data.get('connection_color', 'blue')
                        )
                        component.input_pins.append(pin)
                    
                    # Load output pins
                    for pin_data in comp_data.get('output_pins', []):
                        pin = Pin(
                            x=pin_data['x'],
                            y=pin_data['y'],
                            parent=component,
                            is_input=pin_data['is_input'],
                            name=pin_data['name'],
                            connection_color=pin_data.get('connection_color', 'blue')
                        )
                        component.output_pins.append(pin)
                    
                    self.components.append(component)
                
                # Second pass: Restore connections
                for comp_data in schema_data['components']:
                    component = components_dict[comp_data['label']]
                    
                    # Restore input pin connections
                    for pin_data, pin in zip(comp_data['input_pins'], component.input_pins):
                        if pin_data.get('connected_to'):
                            connected_comp = components_dict[pin_data['connected_to']['component_label']]
                            for other_pin in connected_comp.input_pins + connected_comp.output_pins:
                                if other_pin.name == pin_data['connected_to']['pin_name']:
                                    pin.connected_to = other_pin
                                    other_pin.connected_to = pin
                                    break
                    
                    # Restore output pin connections
                    for pin_data, pin in zip(comp_data['output_pins'], component.output_pins):
                        if pin_data.get('connected_to'):
                            connected_comp = components_dict[pin_data['connected_to']['component_label']]
                            for other_pin in connected_comp.input_pins + connected_comp.output_pins:
                                if other_pin.name == pin_data['connected_to']['pin_name']:
                                    pin.connected_to = other_pin
                                    other_pin.connected_to = pin
                                    break
                
                self.canvas.delete('all')
                for component in self.components:
                    self.draw_component(component)

    def add_component(self, x: float, y: float):
        component = Component(x, y)
        self.components.append(component)
        self.draw_component(component)

    def draw_component(self, component: Component):
        # Draw rectangle
        self.canvas.create_rectangle(
            component.x, component.y,
            component.x + component.width,
            component.y + component.height,
            fill='lightgray'
        )

        # Draw label
        self.canvas.create_text(
            component.x + component.width/2,
            component.y + component.height/2,
            text=component.label
        )

        # Draw pins
        for pin in component.input_pins:
            self.draw_pin(pin)
        for pin in component.output_pins:
            self.draw_pin(pin)

    def calculate_orthogonal_path(self, start_pin: Pin, end_pin: Pin) -> List[Tuple[float, float]]:
        # Calculate intermediate points for orthogonal routing
        points = [(start_pin.x, start_pin.y)]
        
        # Determine the direction of the pins
        start_side = ''
        end_side = ''
        
        # Determine start pin side
        if abs(start_pin.x – start_pin.parent.x) < 1:  # Left side
            start_side = 'left'
        elif abs(start_pin.x – (start_pin.parent.x + start_pin.parent.width)) < 1:  # Right side
            start_side = 'right'
        elif abs(start_pin.y – start_pin.parent.y) < 1:  # Top side
            start_side = 'top'
        else:  # Bottom side
            start_side = 'bottom'
            
        # Determine end pin side
        if abs(end_pin.x – end_pin.parent.x) < 1:  # Left side
            end_side = 'left'
        elif abs(end_pin.x – (end_pin.parent.x + end_pin.parent.width)) < 1:  # Right side
            end_side = 'right'
        elif abs(end_pin.y – end_pin.parent.y) < 1:  # Top side
            end_side = 'top'
        else:  # Bottom side
            end_side = 'bottom'
            
        # Calculate intermediate points based on pin sides
        if start_side in ['left', 'right'] and end_side in ['left', 'right']:
            mid_x = (start_pin.x + end_pin.x) / 2
            points.append((mid_x, start_pin.y))
            points.append((mid_x, end_pin.y))
        elif start_side in ['top', 'bottom'] and end_side in ['top', 'bottom']:
            mid_y = (start_pin.y + end_pin.y) / 2
            points.append((start_pin.x, mid_y))
            points.append((end_pin.x, mid_y))
        else:
            # For pins on perpendicular sides
            if start_side in ['left', 'right']:
                points.append((end_pin.x, start_pin.y))
            else:
                points.append((start_pin.x, end_pin.y))
                
        points.append((end_pin.x, end_pin.y))
        return points

    def draw_pin(self, pin: Pin):
        radius = 5
        self.canvas.create_oval(
            pin.x – radius, pin.y – radius,
            pin.x + radius, pin.y + radius,
            fill='black'
        )
        
        # Draw connection line if pin is connected
        if pin.connected_to:
            # Calculate orthogonal path
            path_points = self.calculate_orthogonal_path(pin, pin.connected_to)
            
            # Draw each segment of the path
            for i in range(len(path_points) – 1):
                line_id = self.canvas.create_line(
                    path_points[i][0], path_points[i][1],
                    path_points[i+1][0], path_points[i+1][1],
                    fill=pin.connection_color, width=2,
                    tags=('connection',)
                )
                # Bind click event to each line segment
                self.canvas.tag_bind(line_id, '<Button-1>', lambda e, p=pin: self.show_color_dialog(p))

        # Calculate label position based on pin side and spacing
        offset = pin.parent.MIN_LABEL_SPACING
        anchor = 'w'  # Default anchor
        text_x = pin.x
        text_y = pin.y

        # Determine which side the pin is on
        if abs(pin.x – pin.parent.x) < 1:  # Left side
            text_x = pin.x – offset
            anchor = 'e'
        elif abs(pin.x – (pin.parent.x + pin.parent.width)) < 1:  # Right side
            text_x = pin.x + offset
            anchor = 'w'
        elif abs(pin.y – pin.parent.y) < 1:  # Top side
            text_y = pin.y – offset
            anchor = 's'
            text_x = pin.x
        elif abs(pin.y – (pin.parent.y + pin.parent.height)) < 1:  # Bottom side
            text_y = pin.y + offset
            anchor = 'n'
            text_x = pin.x

        # Draw the pin label
        self.canvas.create_text(text_x, text_y, text=pin.name, anchor=anchor)

    def find_component_at(self, x: float, y: float) -> Optional[Component]:
        for component in self.components:
            if (component.x <= x <= component.x + component.width and
                component.y <= y <= component.y + component.height):
                return component
        return None

    def find_pin_at(self, x: float, y: float) -> Optional[Pin]:
        radius = 5
        for component in self.components:
            for pin in component.input_pins + component.output_pins:
                if (x – pin.x) ** 2 + (y – pin.y) ** 2 <= radius ** 2:
                    return pin
        return None

    def start_connection_mode(self):
        self.connection_mode = True
        self.first_pin = None
        self.canvas.config(cursor='crosshair')

    def start_delete_connection_mode(self):
        self.delete_connection_mode = True
        self.connection_mode = False
        self.canvas.config(cursor='crosshair')

    def delete_pin(self, pin: Pin):
        component = pin.parent
        if pin.connected_to:
            other_pin = pin.connected_to
            pin.connected_to = None
            other_pin.connected_to = None

        if pin.is_input:
            component.input_pins.remove(pin)
        else:
            component.output_pins.remove(pin)

        component.adjust_height()
        self.canvas.delete('all')
        for comp in self.components:
            self.draw_component(comp)

    def delete_connection(self, pin: Pin):
        if pin.connected_to:
            other_pin = pin.connected_to
            pin.connected_to = None
            other_pin.connected_to = None
            self.canvas.delete('all')
            for component in self.components:
                self.draw_component(component)

    def start_delete_pin_mode(self):
        self.delete_pin_mode = True
        self.delete_connection_mode = False
        self.connection_mode = False
        self.canvas.config(cursor='crosshair')

    def start_delete_component_mode(self):
        self.delete_component_mode = True
        self.connection_mode = False
        self.delete_connection_mode = False
        self.delete_pin_mode = False
        self.canvas.config(cursor='crosshair')

    def delete_component(self, component: Component):
        # Disconnect all pins
        for pin in component.input_pins + component.output_pins:
            if pin.connected_to:
                other_pin = pin.connected_to
                pin.connected_to = None
                other_pin.connected_to = None
        
        # Remove component from list
        self.components.remove(component)
        
        # Redraw canvas
        self.canvas.delete('all')
        for comp in self.components:
            self.draw_component(comp)

    def on_click(self, event):
        if self.delete_pin_mode:
            pin = self.find_pin_at(event.x, event.y)
            if pin:
                self.delete_pin(pin)
                self.delete_pin_mode = False
                self.canvas.config(cursor='')
            return

        if self.delete_connection_mode:
            pin = self.find_pin_at(event.x, event.y)
            if pin and pin.connected_to:
                self.delete_connection(pin)
                self.delete_connection_mode = False
                self.canvas.config(cursor='')
            return

        if self.connection_mode:
            pin = self.find_pin_at(event.x, event.y)
            if pin:
                if not self.first_pin:
                    self.first_pin = pin
                else:
                    # Connect any two pins regardless of their type
                    self.first_pin.connected_to = pin
                    pin.connected_to = self.first_pin
                    self.canvas.delete('all')
                    for component in self.components:
                        self.draw_component(component)
                    self.connection_mode = False
                    self.first_pin = None
                    self.canvas.config(cursor='')
            return

        if self.delete_component_mode:
            component = self.find_component_at(event.x, event.y)
            if component:
                self.delete_component(component)
                self.delete_component_mode = False
                self.canvas.config(cursor='')
            return

        self.selected_component = self.find_component_at(event.x, event.y)
        if self.selected_component:
            self.drag_start = (event.x, event.y)

    def on_drag(self, event):
        if self.selected_component and self.drag_start:
            dx = event.x – self.drag_start[0]
            dy = event.y – self.drag_start[1]
            self.selected_component.move(dx, dy)
            self.drag_start = (event.x, event.y)
            self.canvas.delete('all')
            for component in self.components:
                self.draw_component(component)

    def on_release(self, event):
        self.selected_component = None
        self.drag_start = None

    def add_pin_dialog(self):
        if not self.components:
            return
        
        dialog = tk.Toplevel(self)
        dialog.title("Ajouter une broche")
        dialog.geometry("300×350")
        dialog.resizable(False, True)
        self.center_dialog(dialog)

        # Component selection
        ttk.Label(dialog, text="Sélectionner un composant:").pack(pady=5)
        component_var = tk.StringVar()
        component_dropdown = ttk.Combobox(dialog, textvariable=component_var)
        component_dropdown['values'] = [comp.label for comp in self.components]
        component_dropdown.pack(pady=5)
        
        # Utiliser le dernier composant sélectionné s'il existe
        if self.last_selected_component and self.last_selected_component in [comp.label for comp in self.components]:
            component_dropdown.set(self.last_selected_component)
        elif self.components:
            component_dropdown.set(self.components[0].label)

        # Side selection
        ttk.Label(dialog, text="Côté:").pack(pady=5)
        side_var = tk.StringVar(value=self.last_selected_side)  # Utiliser le dernier côté sélectionné
        sides = [("Gauche", "left"), ("Droite", "right"), ("Haut", "top"), ("Bas", "bottom")]
        for text, value in sides:
            ttk.Radiobutton(dialog, text=text, variable=side_var, value=value).pack()

        # Pin name entry
        ttk.Label(dialog, text="Nom de la broche:").pack(pady=5)
        name_var = tk.StringVar(value="Pin")
        ttk.Entry(dialog, textvariable=name_var).pack(pady=5)

        def add_pin():
            try:
                selected_label = component_var.get()
                selected_side = side_var.get()
                
                # Mémoriser les sélections
                self.last_selected_component = selected_label
                self.last_selected_side = selected_side
                
                component = next(comp for comp in self.components if comp.label == selected_label)
                component.add_pin(selected_side, name_var.get(), True)
                self.canvas.delete('all')
                for comp in self.components:
                    self.draw_component(comp)
                dialog.destroy()
            except (ValueError, IndexError, StopIteration):
                pass

        button_frame = ttk.Frame(dialog)
        button_frame.pack(pady=10, fill=tk.X)
        ttk.Button(button_frame, text="Ajouter", command=add_pin).pack(side=tk.LEFT, padx=5, expand=True)
        ttk.Button(button_frame, text="Annuler", command=dialog.destroy).pack(side=tk.LEFT, padx=5, expand=True)

        # Update dialog size to fit content
        dialog.update()
        dialog.geometry(f"300x{dialog.winfo_reqheight()}")

    def show_color_dialog(self, pin: Pin):
        color = colorchooser.askcolor(color=pin.connection_color, title="Choisir la couleur de connexion")[1]
        if color:
            pin.connection_color = color
            if pin.connected_to:  # Check if pin is connected before accessing connection_color
                pin.connected_to.connection_color = color  # Update both ends of the connection
            self.canvas.delete('all')
            for component in self.components:
                self.draw_component(component)

    def calculate_wire_crossings(self):
        crossings = 0
        wires = []
        
        # Collect all wire segments
        for comp in self.components:
            for pin in comp.input_pins + comp.output_pins:
                if pin.connected_to:
                    wire = {
                        'x1': pin.x,
                        'y1': pin.y,
                        'x2': pin.connected_to.x,
                        'y2': pin.connected_to.y
                    }
                    wires.append(wire)
        
        # Check each pair of wires for intersection
        for i in range(len(wires)):
            for j in range(i + 1, len(wires)):
                w1, w2 = wires[i], wires[j]
                if self.do_wires_intersect(w1, w2):
                    crossings += 1
        return crossings
    
    def do_wires_intersect(self, w1, w2):
        # Line segment intersection check
        def ccw(A, B, C):
            return (C['y'] – A['y']) * (B['x'] – A['x']) > (B['y'] – A['y']) * (C['x'] – A['x'])
        
        A = {'x': w1['x1'], 'y': w1['y1']}
        B = {'x': w1['x2'], 'y': w1['y2']}
        C = {'x': w2['x1'], 'y': w2['y1']}
        D = {'x': w2['x2'], 'y': w2['y2']}
        
        return ccw(A,C,D) != ccw(B,C,D) and ccw(A,B,C) != ccw(A,B,D)
    

class Tooltip:
    def __init__(self, widget, text):
        self.widget = widget
        self.text = text
        self.tooltip = None
        self.widget.bind('<Enter>', self.show_tooltip)
        self.widget.bind('<Leave>', self.hide_tooltip)

    def show_tooltip(self, event=None):
        x, y, _, _ = self.widget.bbox("insert")
        x += self.widget.winfo_rootx() + 25
        y += self.widget.winfo_rooty() + 20

        self.tooltip = tk.Toplevel(self.widget)
        self.tooltip.wm_overrideredirect(True)
        self.tooltip.wm_geometry(f"+{x}+{y}")

        label = ttk.Label(self.tooltip, text=self.text, justify=tk.LEFT,
                         background="#ffffe0", relief=tk.SOLID, borderwidth=1)
        label.pack()

    def hide_tooltip(self, event=None):
        if self.tooltip:
            self.tooltip.destroy()
            self.tooltip = None

if __name__ == '__main__':
    if __name__ == "__main__":
        app = SchemaEditor()
        app.mainloop()
Grimeco
