thonny-ikode 1.0.2__py3-none-any.whl

thonny_ikode-1.0.2.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: thonny-ikode
+Version: 1.0.2
+Summary: Thonny plugin by IKODE: generate PyQt5 loadUi code and preview Qt Designer .ui forms
+Author-email: Bejaoui Dhia <admin@ikode.tn>
+Maintainer-email: IKODE <admin@ikode.tn>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://ikode.tn
+Keywords: thonny,thonny-plugin,PyQt5,Qt Designer,education,IKODE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: X11 Applications
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: French
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: thonny>=4.0
+Provides-Extra: preview
+Requires-Dist: Pillow; extra == "preview"
+Dynamic: license-file
+
+# thonny-ikode
+
+Thonny plugin by IKODE for working with PyQt5 and Qt Designer `.ui` files.
+
+## Features
+
+- **PyQt** button (`Ctrl+Shift+B`): pick a `.ui` file, choose the form variable name, and generate the `loadUi` code with a `*_click` handler for every `QPushButton`.
+- **Éléments UI** button: interactive live preview of a `.ui` form. Hover a widget to highlight it, click to copy `form.widgetName`.
+- **Tools > Oublier le nom du formulaire**: resets the remembered form name.
+
+## Install
+
+From Thonny: *Tools > Open system shell*, then:
+
+```
+pip install thonny-ikode
+```
+
+or from this folder / a wheel:
+
+```
+pip install .
+pip install thonny_ikode-1.0.2-py3-none-any.whl
+```
+
+Optional (sharper image previews): `pip install Pillow`
+
+Restart Thonny afterwards.
+
+## Notes
+
+- Generated code needs `PyQt5` in the interpreter used to run scripts.
+- On startup the plugin sets the working folder to `Desktop/IKODE` and does not reopen previous files.
+
+## Build
+
+```
+python -m pip install build
+python -m build
+```

thonny_ikode-1.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+thonny_ikode-1.0.2.dist-info/licenses/LICENSE,sha256=Tcxk4taP5vz_Yn3tjrYqSUN2cJxsNhqs_XMOquEpcfc,942
+thonnycontrib/ikode/__init__.py,sha256=njPomNx-MG7d-SRfGeQJsTjQxj709CImwWWA4BCd3cA,48911
+thonnycontrib/ikode/res/logo.png,sha256=cmVSlHt2Ak8VDQ6r6IMjsBBx3ZECUxDkYmJIoGlny-Y,106009
+thonnycontrib/ikode/res/qt_16.png,sha256=zRGwNxrYXruCHJTbv85ki1RWwbU0jTO_rC_APqzUV2I,732
+thonnycontrib/ikode/res/qt_32.png,sha256=SxhSrjvi9r8EeRt90HhJcsKzN9r2uaPEkHLNc_h3Bow,1272
+thonny_ikode-1.0.2.dist-info/METADATA,sha256=mE_LDh-anUPO6bRbr8rbcT0hdn9U0vs7oU5gWgImAIk,2212
+thonny_ikode-1.0.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+thonny_ikode-1.0.2.dist-info/top_level.txt,sha256=thF9WQtY_lcNKOOR4SQeeWLAVWb4i8XhdGC7pEMAOHY,14
+thonny_ikode-1.0.2.dist-info/RECORD,,

thonny_ikode-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

thonny_ikode-1.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Bejaoui Dhia / IKODE (admin@ikode.tn). All rights reserved.
+
+This software ("thonny-ikode") is provided free of charge for personal and
+educational use with the Thonny IDE.
+
+You MAY:
+  - install and use it on any number of computers, including school labs;
+  - share the unmodified package (as downloaded from PyPI or ikode.tn).
+
+You MAY NOT, without prior written permission from IKODE (admin@ikode.tn):
+  - modify, decompile, or create derivative works from it;
+  - remove or alter the IKODE name, logo, credits, or copyright notices;
+  - sell, sublicense, or redistribute it as part of another product.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL IKODE
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM THE USE OF
+THE SOFTWARE.

thonny_ikode-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+thonnycontrib

thonnycontrib/ikode/__init__.py

@@ -0,0 +1,1213 @@
+__version__ = "1.0.2"
+
+import os
+import re
+import subprocess
+import keyword
+import tempfile
+import tkinter as tk
+import webbrowser
+from tkinter import messagebox, ttk
+from thonny import get_workbench
+from thonny.languages import tr
+from thonny.ui_utils import select_sequence,askopenfilename
+
+
+from xml.dom import minidom
+global qt_ui_file
+qt_ui_file =""
+qt_form_name = ""
+FORM_NAME_OPTION = "tunisiaschools.form_name"
+_toolbar_logo_path = None
+_live_preview_dialog = None
+
+
+def _make_toolbar_logo(logo_path):
+    global _toolbar_logo_path
+    if _toolbar_logo_path and os.path.isfile(_toolbar_logo_path):
+        return _toolbar_logo_path
+    try:
+        logo = tk.PhotoImage(file=logo_path)
+        factor = max(1, (logo.width() + 23) // 24, (logo.height() + 23) // 24)
+        if factor == 1:
+            return logo_path
+        small_logo = logo.subsample(factor, factor)
+        icon_path = os.path.join(tempfile.gettempdir(), "thonny_tunisiaschools_logo_24.png")
+        small_logo.write(icon_path, format="png")
+        _toolbar_logo_path = icon_path
+        return icon_path
+    except (tk.TclError, OSError):
+        return logo_path
+
+
+def ask_form_name(parent):
+    workbench = get_workbench()
+    saved_form_name = workbench.get_option(FORM_NAME_OPTION, "")
+    if saved_form_name:
+        return saved_form_name
+
+    dialog = tk.Toplevel(parent)
+    dialog.title("Nom du formulaire")
+    dialog.resizable(False, False)
+    dialog.transient(parent)
+    dialog.configure(bg="#f4f6fb")
+
+    parent.update_idletasks()
+    screen_width = dialog.winfo_screenwidth()
+    screen_height = dialog.winfo_screenheight()
+    width = min(410, screen_width - 32)
+    height = screen_height - 64
+
+    card = tk.Frame(dialog, bg="white", padx=20, pady=16)
+    card.pack(fill="both", expand=True, padx=10, pady=10)
+    tk.Label(
+        card, text="Nom du formulaire", bg="white", fg="#172033",
+        font=("Segoe UI", 17, "bold")
+    ).pack(anchor="w")
+    tk.Label(
+        card, text="Choisissez le nom de la variable Python à générer.",
+        bg="white", fg="#667085", font=("Segoe UI", 10),
+        wraplength=width - 80, justify="left"
+    ).pack(anchor="w", pady=(4, 10))
+
+    name_var = tk.StringVar(value="win")
+    name_entry = ttk.Entry(card, textvariable=name_var, font=("Segoe UI", 11))
+    name_entry.pack(fill="x", ipady=7)
+    remember_var = tk.BooleanVar(value=False)
+    tk.Checkbutton(
+        card, text="Ne plus me demander (réutiliser ce nom)",
+        variable=remember_var, bg="white", fg="#344054",
+        activebackground="white", selectcolor="white",
+        font=("Segoe UI", 9), cursor="hand2"
+    ).pack(anchor="w", pady=(8, 0))
+    error_label = tk.Label(card, text="", bg="white", fg="#c0392b", font=("Segoe UI", 9))
+    error_label.pack(anchor="w", pady=(5, 0))
+
+    result = {"name": None}
+
+    def validate_form_name(show_success=False):
+        form_name = name_var.get().strip()
+        is_valid = form_name.isidentifier() and not keyword.iskeyword(form_name)
+        if is_valid:
+            error_label.config(
+                text="Nom valide." if show_success else "", fg="#27864a"
+            )
+        else:
+            error_label.config(
+                text="Entrez un nom de variable Python valide.", fg="#c0392b"
+            )
+        return is_valid
+
+    def submit(event=None):
+        form_name = name_var.get().strip()
+        if not validate_form_name():
+            name_entry.focus_set()
+            return
+        result["name"] = form_name
+        if remember_var.get():
+            workbench.set_option(FORM_NAME_OPTION, form_name)
+        dialog.destroy()
+
+    name_var.trace_add("write", lambda *_args: validate_form_name(show_success=True))
+
+    buttons = tk.Frame(card, bg="white")
+    buttons.pack(fill="x", pady=(10, 0))
+    tk.Button(
+        buttons, text="Annuler", command=dialog.destroy, relief="flat",
+        bg="#eef1f6", fg="#344054", activebackground="#e2e7ef",
+        font=("Segoe UI", 10), padx=15, pady=8, cursor="hand2"
+    ).pack(side="right")
+    tk.Button(
+        buttons, text="Confirmer", command=submit, relief="flat",
+        bg="#3659d9", fg="white", activebackground="#2948bc",
+        activeforeground="white", font=("Segoe UI", 10, "bold"),
+        padx=16, pady=8, cursor="hand2"
+    ).pack(side="right", padx=(0, 9))
+
+    dialog.update_idletasks()
+    actual_width = min(max(width, dialog.winfo_reqwidth()), screen_width - 32)
+    actual_height = min(max(270, dialog.winfo_reqheight()), height)
+    x = parent.winfo_rootx() + (parent.winfo_width() - actual_width) // 2
+    y = parent.winfo_rooty() + (parent.winfo_height() - actual_height) // 2
+    x = min(max(x, 0), screen_width - actual_width)
+    y = min(max(y, 0), screen_height - actual_height)
+    dialog.geometry(f"{actual_width}x{actual_height}+{x}+{y}")
+    dialog.minsize(min(actual_width, 340), min(actual_height, 240))
+
+    dialog.bind("<Return>", submit)
+    dialog.bind("<Escape>", lambda event: dialog.destroy())
+    dialog.protocol("WM_DELETE_WINDOW", dialog.destroy)
+    dialog.grab_set()
+    name_entry.focus_set()
+    parent.wait_window(dialog)
+    return result["name"]
+
+
+def confirm_replace_editor(parent):
+    dialog = tk.Toplevel(parent)
+    dialog.title("Remplacer le contenu ?")
+    dialog.resizable(False, False)
+    dialog.transient(parent)
+    dialog.configure(bg="#f4f6fb")
+
+    card = tk.Frame(dialog, bg="white", padx=22, pady=18)
+    card.pack(fill="both", expand=True, padx=10, pady=10)
+    tk.Label(
+        card, text="L’éditeur n’est pas vide", bg="white", fg="#172033",
+        font=("Segoe UI", 15, "bold")
+    ).pack(anchor="w")
+    tk.Label(
+        card,
+        text="Effacer son contenu et insérer le code du formulaire ?",
+        bg="white", fg="#667085", font=("Segoe UI", 10),
+        wraplength=340, justify="left"
+    ).pack(anchor="w", pady=(7, 16))
+
+    result = {"replace": False}
+
+    def accept():
+        result["replace"] = True
+        dialog.destroy()
+
+    buttons = tk.Frame(card, bg="white")
+    buttons.pack(fill="x")
+    tk.Button(
+        buttons, text="Non, conserver", command=dialog.destroy,
+        relief="flat", bg="#eef1f6", fg="#344054",
+        activebackground="#e2e7ef", font=("Segoe UI", 10),
+        padx=13, pady=8, cursor="hand2"
+    ).pack(side="right")
+    tk.Button(
+        buttons, text="Effacer et insérer", command=accept,
+        relief="flat", bg="#3659d9", fg="white",
+        activebackground="#2948bc", activeforeground="white",
+        font=("Segoe UI", 10, "bold"), padx=14, pady=8,
+        cursor="hand2"
+    ).pack(side="right", padx=(0, 8))
+
+    dialog.update_idletasks()
+    width, height = dialog.winfo_reqwidth(), dialog.winfo_reqheight()
+    screen_width, screen_height = dialog.winfo_screenwidth(), dialog.winfo_screenheight()
+    x = parent.winfo_rootx() + (parent.winfo_width() - width) // 2
+    y = parent.winfo_rooty() + (parent.winfo_height() - height) // 2
+    x = min(max(x, 0), screen_width - width)
+    y = min(max(y, 0), screen_height - height)
+    dialog.geometry(f"{width}x{height}+{x}+{y}")
+    dialog.bind("<Escape>", lambda event: dialog.destroy())
+    dialog.protocol("WM_DELETE_WINDOW", dialog.destroy)
+    dialog.grab_set()
+    parent.wait_window(dialog)
+    return result["replace"]
+
+
+def _widget_property(widget, property_name):
+    for prop in widget.getElementsByTagName("property"):
+        if prop.parentNode is widget and prop.getAttribute("name") == property_name:
+            for value_node in prop.childNodes:
+                if value_node.nodeType == value_node.ELEMENT_NODE:
+                    return "".join(
+                        child.data for child in value_node.childNodes
+                        if child.nodeType in (child.TEXT_NODE, child.CDATA_SECTION_NODE)
+                    ).strip()
+    return ""
+
+
+def _widget_preview_colors(widget):
+    stylesheet = _widget_property(widget, "styleSheet")
+    colors = {}
+    for property_name, option in (("background-color", "background"), ("color", "foreground")):
+        match = re.search(
+            rf"(?:^|;)\s*{property_name}\s*:\s*(#[0-9a-fA-F]{{3,12}}|rgba?\([^)]*\)|[a-zA-Z]+)",
+            stylesheet,
+            re.IGNORECASE,
+        )
+        if match:
+            value = match.group(1).strip().lower()
+            if value.startswith("rgb"):
+                channels = re.findall(r"\d+(?:\.\d+)?", value)
+                if len(channels) >= 3:
+                    rgb = [max(0, min(255, round(float(channel)))) for channel in channels[:3]]
+                    colors[option] = "#%02x%02x%02x" % tuple(rgb)
+            elif value.startswith("#"):
+                digits = value[1:]
+                if len(digits) == 3:
+                    digits = "".join(character * 2 for character in digits)
+                elif len(digits) == 4:
+                    digits = "".join(character * 2 for character in digits[1:])
+                elif len(digits) == 8:
+                    digits = digits[2:]
+                elif len(digits) == 12:
+                    digits = digits[::4]
+                if len(digits) == 6:
+                    colors[option] = "#" + digits
+            elif value in {
+                "black", "white", "red", "green", "blue", "yellow", "cyan",
+                "magenta", "gray", "grey", "orange", "purple", "pink",
+                "navy", "teal", "lime", "silver", "maroon", "olive",
+            }:
+                colors[option] = value
+    return colors
+
+
+def _widget_font_size(widget, default_size=9):
+    font_spec = _widget_property(widget, "styleSheet")
+    match = re.search(r"font:\s*[^;]*?(\d+(?:\.\d+)?)pt", font_spec)
+    if match:
+        try:
+            return float(match.group(1))
+        except ValueError:
+            pass
+    return default_size
+
+
+def _list_widget_items(widget):
+    values = []
+    for node in widget.childNodes:
+        if getattr(node, "tagName", None) != "item":
+            continue
+        for prop in node.getElementsByTagName("property"):
+            if prop.getAttribute("name") == "text":
+                strings = prop.getElementsByTagName("string")
+                if strings and strings[0].firstChild:
+                    values.append(strings[0].firstChild.data)
+    return values
+
+
+def _resolve_preview_image(widget, base_directory):
+    image_path = _widget_property(widget, "pixmap").strip()
+    if not image_path or image_path.startswith(":/"):
+        return None
+    if image_path.startswith("file://"):
+        image_path = image_path[7:]
+    if not os.path.isabs(image_path):
+        image_path = os.path.join(base_directory, image_path)
+    image_path = os.path.normpath(image_path)
+    return image_path if os.path.isfile(image_path) else None
+
+
+def _loaded_ui_path(source_text, editor_path):
+    match = re.search(
+        r"\bloadUi\s*\(\s*(['\"])(.*?)\1",
+        source_text,
+        re.DOTALL,
+    )
+    if not match:
+        return None
+    referenced_path = match.group(2).strip()
+    if not referenced_path:
+        return None
+    if not os.path.isabs(referenced_path):
+        editor_directory = os.path.dirname(editor_path) if editor_path else ""
+        candidates = [
+            os.path.join(editor_directory, referenced_path) if editor_directory else "",
+            os.path.join(os.getcwd(), referenced_path),
+        ]
+    else:
+        candidates = [referenced_path]
+    for candidate in candidates:
+        if candidate and os.path.isfile(candidate):
+            return os.path.normpath(candidate)
+    return None
+
+
+def _widget_geometry(widget):
+    for prop in widget.getElementsByTagName("property"):
+        if prop.parentNode is not widget or prop.getAttribute("name") != "geometry":
+            continue
+        rects = prop.getElementsByTagName("rect")
+        if not rects:
+            continue
+        rect = rects[0]
+        values = {}
+        for key in ("x", "y", "width", "height"):
+            nodes = rect.getElementsByTagName(key)
+            if nodes and nodes[0].firstChild:
+                try:
+                    values[key] = int(nodes[0].firstChild.data)
+                except ValueError:
+                    values[key] = 0
+        if "width" in values and "height" in values:
+            return values
+    return None
+
+
+def _widget_parent(widget):
+    node = widget.parentNode
+    while node is not None:
+        if getattr(node, "tagName", None) == "widget":
+            return node
+        node = node.parentNode
+    return None
+
+
+def _layout_items(layout):
+    items = []
+    for node in layout.childNodes:
+        if getattr(node, "tagName", None) != "item":
+            continue
+        child = next(
+            (entry for entry in node.childNodes
+             if getattr(entry, "tagName", None) in ("widget", "layout", "spacer")),
+            None,
+        )
+        if child is not None:
+            items.append((node, child))
+    return items
+
+
+def _layout_margins(layout):
+    values = {}
+    for prop in layout.getElementsByTagName("property"):
+        if prop.parentNode is not layout:
+            continue
+        name = prop.getAttribute("name")
+        if name in ("leftMargin", "topMargin", "rightMargin", "bottomMargin", "spacing"):
+            numbers = prop.getElementsByTagName("number")
+            if numbers and numbers[0].firstChild:
+                try:
+                    values[name] = int(numbers[0].firstChild.data)
+                except ValueError:
+                    pass
+    return values
+
+
+def _widget_size_hint(widget):
+    geometry = _widget_geometry(widget) or {}
+    width = geometry.get("width", 0)
+    height = geometry.get("height", 0)
+    minimum = widget.getElementsByTagName("minimumSize")
+    if minimum:
+        for key in ("width", "height"):
+            nodes = minimum[0].getElementsByTagName(key)
+            if nodes and nodes[0].firstChild:
+                try:
+                    value = int(nodes[0].firstChild.data)
+                    if key == "width":
+                        width = max(width, value)
+                    else:
+                        height = max(height, value)
+                except ValueError:
+                    pass
+    text = _widget_property(widget, "text")
+    style = _widget_property(widget, "styleSheet")
+    font_match = re.search(r"font:\s*[^;]*?(\d+(?:\.\d+)?)pt", style)
+    font_px = float(font_match.group(1)) * 4 / 3 if font_match else 14
+    text_width = max(24, int(len(text) * font_px * 0.56 + 18))
+    kind = widget.getAttribute("class")
+    defaults = {
+        "QLabel": (text_width, int(font_px + 8)),
+        "QLineEdit": (110, int(font_px + 14)),
+        "QComboBox": (110, int(font_px + 14)),
+        "QPushButton": (max(80, text_width + 16), int(font_px + 18)),
+        "QCheckBox": (text_width + 18, int(font_px + 8)),
+        "QRadioButton": (text_width + 18, int(font_px + 8)),
+        "QListWidget": (160, 120),
+    }
+    default_width, default_height = defaults.get(kind, (90, 28))
+    return max(width, default_width), max(height, default_height)
+
+
+def _layout_widget_rects(container):
+    """Approximate Qt box-layout placement using item order and size hints."""
+    container_geometry = _widget_geometry(container) or {}
+    width = container_geometry.get("width", 320)
+    height = container_geometry.get("height", 240)
+    layouts = []
+    for layout in container.getElementsByTagName("layout"):
+        node = layout.parentNode
+        nested_layout = False
+        while node is not None and node is not container:
+            if getattr(node, "tagName", None) == "layout":
+                nested_layout = True
+                break
+            node = node.parentNode
+        if node is container and not nested_layout:
+            layouts.append(layout)
+    if not layouts:
+        return {}
+    rects = {}
+
+    def measure(entry):
+        if entry.tagName == "widget":
+            return _widget_size_hint(entry)
+        children = _layout_items(entry)
+        if not children:
+            return 20, 20
+        sizes = [measure(child) for _item, child in children]
+        vertical = "VBox" in entry.getAttribute("class")
+        spacing = _layout_margins(entry).get("spacing", 6)
+        layout_margin = 18 if entry is layouts[0] else 0
+        if vertical:
+            return max(size[0] for size in sizes) + layout_margin, sum(size[1] for size in sizes) + spacing * (len(sizes) - 1) + layout_margin
+        return sum(size[0] for size in sizes) + spacing * (len(sizes) - 1) + layout_margin, max(size[1] for size in sizes) + layout_margin
+
+    def place(layout, x, y, area_width, area_height):
+        children = _layout_items(layout)
+        if not children:
+            return
+        margins = _layout_margins(layout)
+        default_margin = 9 if layout is layouts[0] else 0
+        left_margin = margins.get("leftMargin", default_margin)
+        top_margin = margins.get("topMargin", default_margin)
+        right_margin = margins.get("rightMargin", default_margin)
+        bottom_margin = margins.get("bottomMargin", default_margin)
+        spacing = margins.get("spacing", 6)
+        inner_x = x + left_margin
+        inner_y = y + top_margin
+        inner_width = max(area_width - left_margin - right_margin, 1)
+        inner_height = max(area_height - top_margin - bottom_margin, 1)
+        vertical = "VBox" in layout.getAttribute("class")
+        hints = [measure(child) for _item, child in children]
+        available = (inner_height if vertical else inner_width) - spacing * (len(children) - 1)
+        preferred = [size[1] if vertical else size[0] for size in hints]
+        total_preferred = sum(preferred)
+        stretch_weights = []
+        for item, child in children:
+            stretch_node = item.getElementsByTagName("property")
+            stretch = 0
+            for prop in stretch_node:
+                if prop.parentNode is item and prop.getAttribute("name") == "stretch":
+                    numbers = prop.getElementsByTagName("number")
+                    if numbers and numbers[0].firstChild:
+                        try:
+                            stretch = int(numbers[0].firstChild.data)
+                        except ValueError:
+                            pass
+            expandable = (
+                child.tagName == "layout"
+                or child.getAttribute("class") in (
+                    "QLineEdit", "QComboBox", "QListWidget", "QTextEdit",
+                    "QPlainTextEdit", "QPushButton",
+                )
+            )
+            stretch_weights.append(stretch if stretch else (1 if expandable and not vertical else 0))
+        extra = max(available - total_preferred, 0)
+        weights_total = sum(stretch_weights)
+        sizes = [
+            max(1, preferred[index] + (
+                extra * stretch_weights[index] / weights_total if weights_total else 0
+            ))
+            for index in range(len(children))
+        ]
+        if total_preferred > available and total_preferred:
+            sizes = [max(1, available * value / total_preferred) for value in preferred]
+        cursor = inner_y if vertical else inner_x
+        for index, (_item, child) in enumerate(children):
+            child_size = sizes[index]
+            if vertical:
+                child_x, child_y = inner_x, cursor
+                child_width, child_height = inner_width, child_size
+            else:
+                child_x, child_y = cursor, inner_y
+                child_width, child_height = child_size, inner_height
+            if child.tagName == "widget":
+                rects[child] = {
+                    "x": child_x, "y": child_y,
+                    "width": child_width, "height": child_height,
+                }
+            else:
+                place(child, child_x, child_y, child_width, child_height)
+            cursor += child_size + spacing
+
+    place(layouts[0], 0, 0, width, height)
+    return rects
+
+
+def _draw_form_preview(canvas, root_widget, preview_widgets, on_hover=None, on_click=None):
+    canvas.delete("all")
+    canvas._preview_images = []
+    canvas.update_idletasks()
+    available_width = max(canvas.winfo_width(), 240)
+    available_height = max(canvas.winfo_height(), 180)
+    root_geometry = _widget_geometry(root_widget) or {}
+    widget_right = max(
+        (item["geometry"].get("x", 0) + item["geometry"].get("width", 0)
+         for item in preview_widgets if item["geometry"]),
+        default=0,
+    )
+    widget_bottom = max(
+        (item["geometry"].get("y", 0) + item["geometry"].get("height", 0)
+         for item in preview_widgets if item["geometry"]),
+        default=0,
+    )
+    form_width = max(root_geometry.get("width", 480), widget_right + 12, 320)
+    form_height = max(root_geometry.get("height", 320), widget_bottom + 12, 220)
+    margin = min(10, max(3, int(min(available_width, available_height) * 0.015)))
+    titlebar_height = 26
+    form_area_width = max(available_width - margin * 2, 1)
+    form_area_height = max(available_height - margin * 2 - titlebar_height, 1)
+    scale = min(
+        form_area_width / form_width,
+        form_area_height / form_height,
+    )
+    detail_scale = max(0.5, scale)
+    text_size = max(6, min(24, int(round(9 * min(scale, 2.4)))))
+    rendered_width = form_width * scale
+    rendered_height = form_height * scale
+    root_colors = _widget_preview_colors(root_widget)
+    left = margin + max((form_area_width - rendered_width) / 2, 0)
+    top = margin + max((form_area_height - rendered_height) / 2, 0)
+
+    canvas.create_rectangle(
+        left + 3, top + 5, left + rendered_width + 3,
+        top + rendered_height + titlebar_height + 5,
+        fill="#cbd5e1", outline=""
+    )
+    canvas.create_rectangle(
+        left, top, left + rendered_width, top + rendered_height + titlebar_height,
+        fill=root_colors.get("background", "#ffffff"),
+        outline="#d7dee9", width=1
+    )
+    canvas.create_rectangle(
+        left, top, left + rendered_width, top + titlebar_height,
+        fill="#f8fafc", outline=""
+    )
+    canvas.create_rectangle(
+        left, top + titlebar_height - 3, left + rendered_width,
+        top + titlebar_height, fill="#5578e8", outline=""
+    )
+    canvas.create_text(
+        left + 13, top + titlebar_height / 2,
+        text=(_widget_property(root_widget, "windowTitle") or
+              root_widget.getAttribute("class") or "Form Preview"),
+        anchor="w", fill="#1e293b", font=("Segoe UI", 10, "bold")
+    )
+    for offset, color in enumerate(("#f28b82", "#fbbc04", "#34a853")):
+        canvas.create_oval(
+            left + rendered_width - 44 + offset * 13, top + 12,
+            left + rendered_width - 36 + offset * 13, top + 20,
+            fill=color, outline=""
+        )
+
+    if not preview_widgets:
+        canvas.create_text(
+            left + rendered_width / 2,
+            top + titlebar_height + rendered_height / 2,
+            text="Aucun widget à prévisualiser", fill="#98a2b3",
+            font=("Segoe UI", text_size)
+        )
+        return
+
+    content_top = top + titlebar_height
+    fallback_index = 0
+    for item in preview_widgets:
+        geometry = item["geometry"]
+        if geometry:
+            x = geometry.get("x", 0) * scale
+            y = geometry.get("y", 0) * scale
+            widget_width = max(geometry.get("width", 110) * scale, 1)
+            widget_height = max(geometry.get("height", 30) * scale, 1)
+        else:
+            fallback_index += 1
+            x = 14 * scale
+            y = (16 + (fallback_index - 1) * 44) * scale
+            widget_width = min(form_width - 28, 180) * scale
+            widget_height = 30 * scale
+
+        x1 = min(max(left + x, left + 4), left + rendered_width - 4)
+        y1 = min(max(content_top + y, content_top + 4),
+             content_top + rendered_height - 4)
+        x2 = min(x1 + widget_width, left + rendered_width - 5)
+        y2 = min(y1 + widget_height, content_top + rendered_height - 5)
+        if x2 - x1 < 2 or y2 - y1 < 2:
+            continue
+        widget_type = item["type"]
+        name = item["name"]
+        widget = item.get("widget")
+        widget_font_size = max(
+            5,
+            min(
+                28,
+                int(round(_widget_font_size(widget) * scale))
+                if widget is not None
+                else max(5, min(text_size, int(max(y2 - y1, 1) * 0.55))),
+            ),
+        )
+        caption = (item["text"] or item["placeholder"]).replace("&", "")
+        if widget_type in ("QListWidget", "Line"):
+            caption = item["text"].replace("&", "")
+        if widget_type == "QComboBox" and not caption:
+            combo_items = item.get("list_items", [])
+            caption = combo_items[0] if combo_items else ""
+        label = caption or name
+        if widget_type in ("QLineEdit", "QTextEdit", "QPlainTextEdit", "QComboBox", "QListWidget", "Line"):
+            label = caption
+        available_text_width = max(x2 - x1 - 14, 1)
+        max_label_chars = max(1, int(available_text_width / 5.5))
+        if len(label) > max_label_chars:
+            label = label[:max_label_chars - 1] + "…"
+        colors = _widget_preview_colors(widget) if widget is not None else {}
+        border = "#c5cedd"
+        fill = colors.get("background", "#ffffff")
+        foreground = colors.get("foreground", "#334155")
+        tag = f"widget-{name}"
+        hover_area = canvas.create_rectangle(
+            x1, y1, x2, y2, fill="#f8faff", outline="",
+            tags=(tag, f"hover-area-{name}")
+        )
+        hover_shapes = []
+
+        if widget_type == "QLabel":
+            image_path = item.get("image_path")
+            image_rendered = False
+            if image_path:
+                try:
+                    from PIL import Image, ImageTk
+
+                    with Image.open(image_path) as source_image:
+                        source_image = source_image.convert("RGBA")
+                        image_width = max(1, int(x2 - x1 - 4))
+                        image_height = max(1, int(y2 - y1 - 4))
+                        resampling = getattr(Image, "Resampling", Image).LANCZOS
+                        source_image.thumbnail(
+                            (image_width, image_height), resampling
+                        )
+                        preview_image = ImageTk.PhotoImage(
+                            source_image, master=canvas
+                        )
+                    canvas._preview_images.append(preview_image)
+                    canvas.create_image(
+                        (x1 + x2) / 2, (y1 + y2) / 2,
+                        image=preview_image, anchor="center", tags=(tag,)
+                    )
+                    image_rendered = True
+                except (ImportError, OSError, tk.TclError, ValueError):
+                    pass
+            if not image_rendered:
+                canvas.create_text(
+                    x1 + 4, (y1 + y2) / 2, text=label, anchor="w",
+                    width=max(x2 - x1 - 8, 1), fill=foreground,
+                    font=("Segoe UI", widget_font_size), tags=(tag,)
+                )
+        elif widget_type in ("QCheckBox", "QRadioButton"):
+            indicator_size = min(
+                14 * detail_scale,
+                max(y2 - y1 - 4, 2),
+                max(x2 - x1 - 4, 2),
+            )
+            indicator_inset = max((y2 - y1 - indicator_size) / 2, 1)
+            label_space = max(x2 - x1 - indicator_size - 8, 1)
+            if widget_type == "QRadioButton":
+                checkbox_shape = canvas.create_oval(
+                    x1 + 2, y1 + indicator_inset,
+                    x1 + 2 + indicator_size, y1 + indicator_inset + indicator_size,
+                    fill="#ffffff", outline="#94a3b8", width=1, tags=(tag,)
+                )
+            else:
+                checkbox_shape = canvas.create_rectangle(
+                    x1 + 2, y1 + indicator_inset,
+                    x1 + 2 + indicator_size, y1 + indicator_inset + indicator_size,
+                    fill="#ffffff", outline="#94a3b8", width=1, tags=(tag,)
+                )
+            hover_shapes.append((checkbox_shape, "#ffffff", "#bfdbfe"))
+            label_x = x1 + indicator_size + 6
+            canvas.create_text(
+                label_x, (y1 + y2) / 2, text=label, anchor="w",
+                width=label_space, fill=foreground,
+                font=("Segoe UI", widget_font_size), tags=(tag,)
+            )
+        elif widget_type in ("QLineEdit", "QTextEdit", "QPlainTextEdit", "QComboBox"):
+            input_shape = canvas.create_rectangle(
+                x1, y1, x2, y2, fill=fill, outline=border,
+                width=1, tags=(tag,)
+            )
+            hover_shapes.append((input_shape, "#ffffff", "#bfdbfe"))
+            text_width = max(
+                x2 - x1 - (22 if widget_type == "QComboBox" else 14), 1
+            )
+            canvas.create_text(
+                x1 + 7, (y1 + y2) / 2, text=label, anchor="w",
+                width=text_width, fill=foreground if caption else "#94a3b8",
+                font=("Segoe UI", widget_font_size), tags=(tag,)
+            )
+            if widget_type == "QComboBox":
+                canvas.create_text(x2 - 10, (y1 + y2) / 2, text="⌄",
+                                   fill="#667085", font=("Segoe UI", 9), tags=(tag,))
+        elif widget_type == "QListWidget":
+            list_shape = canvas.create_rectangle(
+                x1, y1, x2, y2, fill=fill, outline=border,
+                width=1, tags=(tag,)
+            )
+            hover_shapes.append((list_shape, fill, "#f1f5ff"))
+            rows = item.get("list_items", [])
+            row_height = max(22 * scale, (y2 - y1) / max(len(rows), 1))
+            for row_index, row_text in enumerate(rows):
+                row_y = y1 + row_index * row_height
+                if row_y + row_height > y2:
+                    break
+                if row_index:
+                    canvas.create_line(
+                        x1 + 1, row_y, x2 - 1, row_y,
+                        fill="#edf0f5", width=1, tags=(tag,)
+                    )
+                canvas.create_text(
+                    x1 + 8, row_y + row_height / 2, text=row_text,
+                    anchor="w", width=max(x2 - x1 - 16, 1),
+                    fill=foreground, font=("Segoe UI", widget_font_size), tags=(tag,)
+                )
+        elif widget_type == "Line":
+            orientation = _widget_property(widget, "orientation") if widget is not None else ""
+            if "Vertical" in orientation:
+                center_x = (x1 + x2) / 2
+                line_shape = canvas.create_line(
+                    center_x, y1, center_x, y2,
+                    fill="#94a3b8", width=max(1, scale), tags=(tag,)
+                )
+            else:
+                center_y = (y1 + y2) / 2
+                line_shape = canvas.create_line(
+                    x1, center_y, x2, center_y,
+                    fill="#94a3b8", width=max(1, scale), tags=(tag,)
+                )
+            hover_shapes.append((line_shape, "#94a3b8", "#5578e8"))
+        elif widget_type == "QProgressBar":
+            progress_track = canvas.create_rectangle(
+                x1, y1, x2, y2, fill="#e2e8f0", outline="", tags=(tag,)
+            )
+            progress_fill = canvas.create_rectangle(
+                x1, y1, x1 + (x2 - x1) * .62, y2,
+                fill="#6481e8", outline="", tags=(tag,)
+            )
+            hover_shapes.extend((
+                (progress_track, "#e2e8f0", "#bfdbfe"),
+                (progress_fill, "#6481e8", "#93b4fb"),
+            ))
+            canvas.create_text(
+                (x1 + x2) / 2, (y1 + y2) / 2, text=label,
+                width=max(x2 - x1 - 8, 1), fill="#334155",
+                font=("Segoe UI", widget_font_size), tags=(tag,)
+            )
+        elif widget_type == "QPushButton":
+            button_fill = colors.get("background", "#eef2f7")
+            button_text = colors.get("foreground", "#334155")
+            button_shape = canvas.create_rectangle(
+                x1, y1, x2, y2, fill=button_fill, outline="#cbd5e1",
+                width=1, tags=(tag,)
+            )
+            hover_shapes.append((button_shape, button_fill, "#dce7ff"))
+            canvas.create_text(
+                (x1 + x2) / 2, (y1 + y2) / 2, text=label,
+                width=max(x2 - x1 - 12, 1), fill=button_text,
+                font=("Segoe UI", widget_font_size, "bold"), tags=(tag,)
+            )
+        else:
+            widget_shape = canvas.create_rectangle(
+                x1, y1, x2, y2, fill=fill, outline=border,
+                width=1, tags=(tag,)
+            )
+            hover_shapes.append((widget_shape, "#ffffff", "#bfdbfe"))
+            canvas.create_text(
+                (x1 + x2) / 2, (y1 + y2) / 2, text=label,
+                width=max(x2 - x1 - 12, 1), fill="#334155",
+                font=("Segoe UI", widget_font_size), tags=(tag,)
+            )
+
+        hover_outline = canvas.create_rectangle(
+            x1, y1, x2, y2, fill="", outline="", width=3,
+            tags=(tag, f"hover-outline-{name}")
+        )
+
+        def highlight_widget(
+            _event, active, background=hover_area,
+            outline=hover_outline, shapes=tuple(hover_shapes)
+        ):
+            canvas.itemconfigure(
+                background, fill="#dce8ff" if active else "#f8faff"
+            )
+            canvas.itemconfigure(
+                outline, outline="#2458e8" if active else ""
+            )
+            for shape, normal_fill, hover_fill in shapes:
+                canvas.itemconfigure(shape, fill=hover_fill if active else normal_fill)
+
+        canvas.tag_bind(
+            tag, "<Enter>",
+            lambda event, widget_name=name, highlight=highlight_widget: (
+                highlight(event, True), on_hover(widget_name)
+            ) if on_hover else highlight(event, True)
+        )
+        canvas.tag_bind(
+            tag, "<Button-1>",
+            lambda event, widget_name=name: on_click(widget_name)
+            if on_click else (on_hover(widget_name) if on_hover else "")
+        )
+        canvas.tag_bind(
+            tag, "<Leave>",
+            lambda event, highlight=highlight_widget: highlight(event, False)
+        )
+
+
+def show_ui_elements():
+    global qt_ui_file, qt_form_name, _live_preview_dialog
+    parent = get_workbench()
+    if _live_preview_dialog is not None:
+        try:
+            if _live_preview_dialog.winfo_exists():
+                _live_preview_dialog.destroy()
+        except tk.TclError:
+            pass
+        _live_preview_dialog = None
+
+    try:
+        ui_document = None
+        display_name = ""
+        source_ui_path = None
+        editor = parent.get_editor_notebook().get_current_editor()
+        editor_path = None
+        editor_text = ""
+        if editor is not None:
+            for attr in ("get_filename", "get_file_path"):
+                get_path = getattr(editor, attr, None)
+                if callable(get_path):
+                    editor_path = get_path()
+                    if editor_path:
+                        break
+
+            editor_text = editor.get_code_view().text.get("1.0", "end-1c")
+            if "<ui" in editor_text and "</ui>" in editor_text:
+                candidate = minidom.parseString(editor_text.encode("utf-8"))
+                if candidate.documentElement.tagName == "ui":
+                    ui_document = candidate
+                    if editor_path:
+                        qt_ui_file = editor_path
+                        source_ui_path = editor_path
+                        display_name = os.path.basename(editor_path)
+                    else:
+                        display_name = "Interface ouverte dans l’éditeur"
+
+            # Some Thonny editor implementations don't expose the .ui buffer
+            # as XML text. If the active tab is a UI file, load that opened file.
+            if (
+                ui_document is None
+                and editor_path
+                and os.path.splitext(editor_path)[1].lower() == ".ui"
+            ):
+                qt_ui_file = editor_path
+                source_ui_path = editor_path
+                ui_document = minidom.parse(editor_path)
+                display_name = os.path.basename(editor_path)
+
+            if ui_document is None:
+                loaded_ui_path = _loaded_ui_path(editor_text, editor_path)
+                if loaded_ui_path:
+                    qt_ui_file = loaded_ui_path
+                    source_ui_path = loaded_ui_path
+                    ui_document = minidom.parse(loaded_ui_path)
+                    display_name = os.path.basename(loaded_ui_path)
+
+        # Prefer the exact interface selected in the plugin even when there
+        # is no current editor. Generated loadUi calls can use a relative path.
+        if ui_document is None and qt_ui_file:
+            remembered_path = os.path.abspath(qt_ui_file)
+            if os.path.isfile(remembered_path):
+                qt_ui_file = remembered_path
+                source_ui_path = remembered_path
+                ui_document = minidom.parse(remembered_path)
+                display_name = os.path.basename(remembered_path)
+
+        # If the active editor is not showing a .ui document, ask for a file
+        # on every preview launch. This picker choice is temporary; the UI
+        # selected by “Ajouter code” or found in loadUi remains remembered.
+        if ui_document is None:
+            source_ui_path = askopenfilename(
+                filetypes=[("Fichiers UI", ".ui"), (tr("Tous les fichiers"), ".*")],
+                parent=parent,
+            )
+            if not source_ui_path:
+                return
+            ui_document = minidom.parse(source_ui_path)
+            display_name = os.path.basename(source_ui_path)
+
+        ui_widgets = list(ui_document.getElementsByTagName("widget"))
+        if not ui_widgets:
+            raise ValueError("Le fichier ne contient aucun widget Qt.")
+        root_widget = ui_widgets[0]
+        preview_widgets = []
+        layout_rects = {
+            widget: _layout_widget_rects(widget) for widget in ui_widgets
+        }
+        for widget in ui_widgets:
+            widget_name = widget.getAttribute("name") or "(sans nom)"
+            widget_type = widget.getAttribute("class") or "Type inconnu"
+            geometry = _widget_geometry(widget)
+            parent_widget = _widget_parent(widget)
+            if geometry is None and parent_widget is not None:
+                geometry = layout_rects.get(parent_widget, {}).get(widget)
+            if widget is not root_widget and geometry:
+                geometry = dict(geometry)
+                parent_node = parent_widget
+                while parent_node is not None and parent_node is not root_widget:
+                    parent_geometry = _widget_geometry(parent_node)
+                    if parent_geometry is None:
+                        ancestor = _widget_parent(parent_node)
+                        parent_geometry = layout_rects.get(ancestor, {}).get(parent_node, {})
+                    geometry["x"] += parent_geometry.get("x", 0)
+                    geometry["y"] += parent_geometry.get("y", 0)
+                    parent_node = _widget_parent(parent_node)
+            item = {
+                "name": widget_name,
+                "type": widget_type,
+                "geometry": geometry,
+                "text": _widget_property(widget, "text"),
+                "placeholder": _widget_property(widget, "placeholderText"),
+                "widget": widget,
+                "image_path": _resolve_preview_image(
+                    widget,
+                    os.path.dirname(source_ui_path) if source_ui_path else os.getcwd(),
+                ),
+                "list_items": _list_widget_items(widget),
+            }
+            has_layout = bool(widget.getElementsByTagName("layout"))
+            if widget is not root_widget and not (
+                widget_type == "QWidget" and has_layout
+            ):
+                preview_widgets.append(item)
+    except Exception as error:
+        messagebox.showerror(
+            "Formulaire UI illisible",
+            f"Impossible de lire le fichier :\n{error}",
+            parent=parent,
+        )
+        return
+
+    dialog = tk.Toplevel(parent)
+    _live_preview_dialog = dialog
+    dialog.title("Aperçu live du formulaire")
+    dialog.transient(parent)
+    dialog.configure(bg="#edf1f7")
+    dialog.update_idletasks()
+    screen_width = dialog.winfo_screenwidth()
+    screen_height = dialog.winfo_screenheight()
+    root_geometry = _widget_geometry(root_widget) or {}
+    ui_width = max(
+        root_geometry.get("width", 480),
+        max(
+            (item["geometry"].get("x", 0) + item["geometry"].get("width", 0)
+             for item in preview_widgets if item["geometry"]),
+            default=0,
+        ) + 12,
+    )
+    ui_height = max(
+        root_geometry.get("height", 320),
+        max(
+            (item["geometry"].get("y", 0) + item["geometry"].get("height", 0)
+             for item in preview_widgets if item["geometry"]),
+            default=0,
+        ) + 12,
+    )
+    max_width = max(480, min(1040, screen_width - 24))
+    max_height = max(360, screen_height - 36)
+    width = min(max(760, ui_width + 40), max_width)
+    height = min(max(620, ui_height + 120), max_height)
+    x = parent.winfo_rootx() + (parent.winfo_width() - width) // 2
+    y = parent.winfo_rooty() + (parent.winfo_height() - height) // 2
+    x = min(max(x, 0), screen_width - width)
+    y = min(max(y, 0), screen_height - height)
+    dialog.geometry(f"{width}x{height}+{x}+{y}")
+    dialog.minsize(min(720, width), min(480, height))
+
+    card = tk.Frame(dialog, bg="#f8fafc", padx=10, pady=8)
+    card.pack(fill="both", expand=True, padx=5, pady=5)
+    header = tk.Frame(card, bg="#f8fafc")
+    header.pack(fill="x", pady=(0, 5))
+    logo_path = os.path.join(os.path.dirname(__file__), "res", "logo.png")
+    try:
+        try:
+            from PIL import Image, ImageTk
+
+            source_logo = Image.open(logo_path).convert("RGBA")
+            source_logo.thumbnail((76, 76), Image.Resampling.LANCZOS)
+            preview_logo = ImageTk.PhotoImage(source_logo, master=dialog)
+        except ImportError:
+            # Keep the original pixels rather than producing a jagged Tk
+            # subsample when Pillow is unavailable.
+            preview_logo = tk.PhotoImage(file=logo_path, master=dialog)
+        logo_label = tk.Label(
+            header, image=preview_logo, bg="#f8fafc", cursor="hand2"
+        )
+        logo_label.pack(side="right", padx=(12, 2), pady=2)
+        logo_label.bind(
+            "<Button-1>", lambda _event: webbrowser.open("https://ikode.tn", new=2)
+        )
+        dialog.preview_logo = preview_logo
+    except tk.TclError:
+        pass
+    heading = tk.Frame(header, bg="#f8fafc")
+    heading.pack(side="left", fill="x", expand=True)
+    tk.Label(
+        heading, text="APERÇU INTERACTIF", bg="#f8fafc", fg="#4565c7",
+        font=("Segoe UI", 9, "bold")
+    ).pack(anchor="w")
+    tk.Label(
+        heading, text=display_name, bg="#f8fafc",
+        fg="#172033", font=("Segoe UI", 15, "bold")
+    ).pack(anchor="w", pady=(3, 0))
+    tk.Label(
+        heading, text="Survolez un élément pour le repérer · Cliquez pour copier son nom",
+        bg="#f8fafc", fg="#64748b", font=("Segoe UI", 9)
+    ).pack(anchor="w", pady=(3, 0))
+    preview_canvas = tk.Canvas(
+        card, bg="#eef2f7", highlightthickness=1,
+        highlightbackground="#dce3ed", bd=0
+    )
+    preview_canvas.pack(fill="both", expand=True)
+    hovered_name = tk.StringVar(
+        value="Prêt · Sélectionnez un composant dans l’aperçu"
+    )
+    tk.Label(
+        card, textvariable=hovered_name, bg="#edf2ff", fg="#294cae",
+        font=("Segoe UI", 9, "bold"), anchor="w", padx=12, pady=7,
+        highlightthickness=1, highlightbackground="#dce5ff"
+    ).pack(fill="x", pady=(4, 0))
+
+    def show_hovered_widget(widget_name):
+        widget = next(
+            (item for item in preview_widgets if item["name"] == widget_name),
+            None,
+        )
+        widget_type = widget["type"] if widget else "Widget"
+        hovered_name.set(f"{widget_name}  ·  {widget_type}  ·  Cliquez pour copier")
+
+    def copy_widget_name(widget_name):
+        form_name = qt_form_name or parent.get_option(FORM_NAME_OPTION, "win")
+        qualified_name = f"{form_name}.{widget_name}"
+        try:
+            dialog.clipboard_clear()
+            dialog.clipboard_append(qualified_name)
+            hovered_name.set(f"Nom copié : {qualified_name}")
+        except tk.TclError:
+            hovered_name.set(f"Élément sélectionné : {qualified_name}")
+
+    redraw_job = {"id": None}
+
+    def redraw_preview():
+        redraw_job["id"] = None
+        _draw_form_preview(
+            preview_canvas, root_widget, preview_widgets,
+            show_hovered_widget, copy_widget_name
+        )
+
+    def schedule_preview_redraw(_event=None):
+        if redraw_job["id"] is not None:
+            try:
+                dialog.after_cancel(redraw_job["id"])
+            except tk.TclError:
+                pass
+        redraw_job["id"] = dialog.after(35, redraw_preview)
+
+    preview_canvas.bind("<Configure>", schedule_preview_redraw)
+
+    _draw_form_preview(
+        preview_canvas, root_widget, preview_widgets,
+        show_hovered_widget, copy_widget_name
+    )
+
+    def close_preview(event=None):
+        global _live_preview_dialog
+        if _live_preview_dialog is dialog:
+            _live_preview_dialog = None
+        try:
+            dialog.destroy()
+        except tk.TclError:
+            pass
+
+    dialog.bind("<Escape>", close_preview)
+    dialog.protocol("WM_DELETE_WINDOW", close_preview)
+    parent.wait_window(dialog)
+
+
+def add_pyqt_code():
+    global qt_ui_file, qt_form_name
+    btnstxt = ""
+    mytxt = ""
+    path = askopenfilename(
+                filetypes=[("Fichiers UI", ".ui"), (tr("Tous les fichiers"), ".*")], parent=get_workbench()
+            )
+    if path:
+        form_name = ask_form_name(get_workbench())
+        if form_name is None:
+            return
+        qt_form_name = form_name
+
+        qt_ui_file = os.path.abspath(path)
+        file = minidom.parse(qt_ui_file)
+        widgets = file.getElementsByTagName('widget')
+        for w in widgets:
+            if w.attributes['class'].value == "QPushButton" : #Bouton
+                btnstxt = btnstxt + form_name+"."+w.attributes['name'].value +".clicked.connect ( "+  w.attributes['name'].value +"_click )\n"
+                mytxt = mytxt + "def "+  w.attributes['name'].value +"_click():\n    pass\n" 
+
+        generated_code = (
+            '#Updated By IKODE\n#Credits : Mr Selmen Arous\n' + 'from PyQt5.uic import loadUi\n'+
+            'from PyQt5.QtWidgets import *\n'+
+            '\n'+mytxt+'\n'+
+            'app = QApplication([])\n'+
+            form_name+' = loadUi (".'+ path[path.rfind("/"):] +'")\n'+
+            form_name+'.show()\n'+
+            btnstxt+'\n'
+            'app.exec_()'
+            )
+        editor = get_workbench().get_editor_notebook().get_current_editor()
+        if editor is None:
+            return
+        text = editor.get_code_view().text
+        if text.get("1.0", "end-1c").strip() and not confirm_replace_editor(get_workbench()):
+            return
+        text.delete("1.0", "end")
+        text.insert("1.0", generated_code)
+
+
+def forget_form_name():
+    get_workbench().set_option(FORM_NAME_OPTION, "")
+
+
+def load_plugin():
+
+    image_path = os.path.join(os.path.dirname(__file__), "res", "qt_16.png")
+    logo_image_path = os.path.join(os.path.dirname(__file__), "res", "logo.png")
+    toolbar_logo_path = _make_toolbar_logo(logo_image_path)
+
+    get_workbench().add_command(
+        "selmen_command",
+        "tools",
+        tr("Ajouter code PyQt5"),
+        add_pyqt_code,
+        default_sequence=select_sequence("<Control-Shift-B>", "<Command-Shift-B>"),
+        include_in_toolbar=True,
+        caption="PyQt",
+        image=image_path
+    )
+
+    get_workbench().add_command(
+        "show_ui_elements_command",
+        "tools",
+        tr("Afficher les éléments du formulaire UI"),
+        show_ui_elements,
+        include_in_toolbar=True,
+        caption="Éléments UI",
+        image=toolbar_logo_path,
+    )
+
+    get_workbench().add_command(
+        "forget_form_name_command",
+        "tools",
+        tr("Oublier le nom du formulaire"),
+        forget_form_name,
+    )
+
+    # Dossier de sauvegarde : Desktop/IKODE
+    desktop = os.path.join(os.path.expanduser("~"), "Desktop")
+    cwd = os.path.join(desktop, "IKODE")
+    if os.path.exists(cwd) and not os.path.isdir(cwd):
+        cwd = os.path.join(desktop, "IKODE_QT")
+        suffix = 2
+        while os.path.exists(cwd) and not os.path.isdir(cwd):
+            cwd = os.path.join(desktop, f"IKODE_QT_{suffix}")
+            suffix += 1
+    os.makedirs(cwd, exist_ok=True)
+    get_workbench().set_local_cwd(cwd)
+
+    # Ne pas ouvrir les derniers fichiers
+
+    get_workbench().set_option("file.current_file", "")
+    get_workbench().set_option("file.open_files", "")