Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

mi dai questo script commentandolo nel codice: import time import threading import…

  1. User

    mi dai questo script commentandolo nel codice:

    import time import threading import tkinter as tk from tkinter import ttk, filedialog, messagebox import psutil from pywinauto import Application import win32gui import win32con import win32process import os import ctypes import uuid import sqlite3

    Per tray icon import pystray from PIL import Image, ImageDraw

    DB_FILE = 'gestione_aziende_adempimenti.db'

    Globals pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() exit_flag = False

    Tray icon functions def create_image(): width = 16 height = 16 color1 = "black" color2 = "white" image = Image.new('RGB', (width, height), color1) dc = ImageDraw.Draw(image) dc.rectangle([(width // 4, height // 4), (width * 3 // 4, height * 3 // 4)], fill=color2) return image

    def on_quit(icon, item): global exit_flag exit_flag = True icon.stop()

    def setup_tray_icon(): icon = pystray.Icon("SaveAsMonitor") icon.icon = create_image() icon.title = "SaveAs Monitor" icon.menu = pystray.Menu(pystray.MenuItem("Esci", on_quit)) return icon

    def hide_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_HIDE)

    def show_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_SHOW)

    def bring_to_front(hwnd): try: win32gui.SetForegroundWindow(hwnd) except Exception: pass

    DB functions def fetch_aziende_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice, denominazione FROM aziende ORDER BY denominazione") rows = c.fetchall() conn.close() return rows

    def fetch_adempimenti_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice_adempimento, descrizione, cartella_salvataggio, IFNULL(nome_file,'') FROM adempimenti ORDER BY descrizione") rows = c.fetchall() conn.close() return rows

    def fetch_file_by_path(percorso): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute('SELECT codice_azienda, codice_adempimento FROM files WHERE percorso_file = ?', (percorso,)) row = c.fetchone() conn.close() return row

    def inserisci_file_db(codice_azienda, codice_adempimento, percorso_file): conn = sqlite3.connect(DB_FILE) c = conn.cursor() try: c.execute("INSERT INTO files (codice_azienda, codice_adempimento, percorso_file) VALUES (?, ?, ?)", (codice_azienda, codice_adempimento, percorso_file)) conn.commit() except sqlite3.IntegrityError:

    Ignora duplicati oppure aggiorna se vuoi

    pass finally: conn.close()

    Custom save GUI def custom_save_gui(default_ext, file_types, default_name, initial_folder=None): root = tk.Tk() root.title("Salvataggio personalizzato") root.geometry("700x250") root.attributes("-topmost", True)

    selezionato = {'full_path': None} cancelled = {'value': True}

    aziende = fetch_aziende_for_gui() adempimenti = fetch_adempimenti_for_gui()

    var_azienda = tk.StringVar() var_adempimento = tk.StringVar() var_folder = tk.StringVar() var_filename = tk.StringVar(value=default_name)

    full_path = None if initial_folder and default_name: full_path = os.path.normpath(os.path.join(initial_folder, default_name))

    preselected_azienda_cod = None preselected_adempimento_cod = None if full_path: found = fetch_file_by_path(full_path) if found: preselected_azienda_cod, preselected_adempimento_cod = found

    def get_azienda_name(cod): for a in aziende: if a[0] == cod: return a[1] return ""

    def get_adempimento_name(cod): for a in adempimenti: if a[0] == cod: return a[1] return ""

    var_azienda.set(get_azienda_name(preselected_azienda_cod) if preselected_azienda_cod else (aziende[0][1] if aziende else "")) var_adempimento.set(get_adempimento_name(preselected_adempimento_cod) if preselected_adempimento_cod else (adempimenti[0][1] if adempimenti else ""))

    def aggiorna_percorso(*args): try: azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0]

        ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get())
        codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato
    
        conn = sqlite3.connect(DB_FILE)
        c = conn.cursor()
        c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,))
        root_path = c.fetchone()
        conn.close()
        root_path = root_path[0] if root_path else os.getcwd()
    
        full_folder_path = os.path.join(root_path, cartella_salvataggio)
        os.makedirs(full_folder_path, exist_ok=True)
    
        var_folder.set(full_folder_path)
    
        filename = nome_file if nome_file.strip() else default_name
        if not filename.lower().endswith(default_ext.lower()):
            filename += default_ext
    
        var_filename.set(filename)
    except StopIteration:
        pass
    

    def scegli_cartella_manual(): folder_selected = filedialog.askdirectory(initialdir=var_folder.get() or os.getcwd()) if folder_selected: var_folder.set(folder_selected)

    def conferma(event=None): folder = var_folder.get() filename = var_filename.get() if not folder or not filename: messagebox.showerror("Errore", "Cartella e nome file sono obbligatori") return selezionato['full_path'] = os.path.normpath(os.path.join(folder, filename)) cancelled['value'] = False root.destroy()

    def on_close(): cancelled['value'] = True root.destroy()

    tk.Label(root, text="Azienda:").pack(anchor='w', padx=10, pady=(10, 0)) combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly') combo_aziende.pack(fill='x', padx=10)

    tk.Label(root, text="Adempimento:").pack(anchor='w', padx=10, pady=(10, 0)) combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly') combo_adempimenti.pack(fill='x', padx=10)

    tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10, pady=(10, 0)) folder_entry = tk.Entry(root, textvariable=var_folder, width=80) folder_entry.pack(side='left', padx=(10, 0), pady=5, fill='x', expand=True) btn_folder = tk.Button(root, text="Scegli cartella", command=scegli_cartella_manual) btn_folder.pack(side='left', padx=10, pady=5)

    tk.Label(root, text="Nome file:").pack(anchor='w', padx=10, pady=(10, 0)) filename_entry = tk.Entry(root, textvariable=var_filename, width=80) filename_entry.pack(padx=10, pady=5, fill="x")

    btn_conferma = tk.Button(root, text="Conferma", command=conferma) btn_conferma.pack(pady=10)

    root.protocol("WM_DELETE_WINDOW", on_close)

    aggiorna_percorso() var_azienda.trace_add('write', aggiorna_percorso) var_adempimento.trace_add('write', aggiorna_percorso)

    filename_entry.bind('', conferma) folder_entry.bind('', conferma)

    filename_entry.focus_set() root.focus_force() root.mainloop()

    if cancelled['value']: return None, None, None

    return selezionato['full_path'],
    next(a[0] for a in aziende if a[1] == var_azienda.get()),
    next(a[0] for a in adempimenti if a[1] == var_adempimento.get()) #---- Funzioni ausiliarie usate dal monitoraggio ----

    def click_button_fallback_hwnd(hwnd_button): try: win32gui.SendMessage(hwnd_button, win32con.BM_CLICK, 0, 0) except Exception: pass

    def enumerate_child_windows(hwnd): children = [] def enum_proc(child_hwnd, param): param.append(child_hwnd) return True win32gui.EnumChildWindows(hwnd, enum_proc, children) return children

    def detect_default_extension(process_name): process_name = process_name.lower() if process_name else ""

    mapping = { "winword.exe": ".docx", "excel.exe": ".xlsx", "powerpnt.exe": ".pptx", "onenote.exe": ".one", "msaccess.exe": ".accdb", "outlook.exe": ".pst", "swriter.exe": ".odt", "scalc.exe": ".ods", "simpress.exe": ".odp", "soffice.bin": ".odt", "acrord32.exe": ".pdf", "acrobat.exe": ".pdf", "photoshop.exe": ".psd", "illustrator.exe": ".ai", "chrome.exe": ".html", "firefox.exe": ".html", "msedge.exe": ".html", "opera.exe": ".html", "brave.exe": ".html", "notepad.exe": ".txt", "notepad++.exe": ".txt", "sublime_text.exe": ".txt", "code.exe": ".txt", "vim.exe": ".txt", "mspaint.exe": ".png", "paint.exe": ".png", "gimp.exe": ".xcf", "inkscape.exe": ".svg", "vlc.exe": ".m3u", "audacity.exe": ".aup", "spotify.exe": ".dat", "7z.exe": ".7z", "winrar.exe": ".rar", "winzip.exe": ".zip", "wordpad.exe": ".rtf", "calc.exe": ".txt", }

    return mapping.get(process_name, ".dat") def wait_for_modal_dialog_closed(pid, parent_hwnd, timeout=30): keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"] user32 = ctypes.windll.user32 end_time = time.time() + timeout

    while time.time() < end_time and not exit_flag: found = False

    def enum_windows_callback(hwnd, lParam):
        if not user32.IsWindowVisible(hwnd):
            return True
        style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE)
        if not (style & win32con.WS_POPUP):
            return True
        owner = user32.GetWindow(hwnd, win32con.GW_OWNER)
        if owner != parent_hwnd:
            return True
        length = user32.GetWindowTextLengthW(hwnd)
        buffer = ctypes.create_unicode_buffer(length + 1)
        user32.GetWindowTextW(hwnd, buffer, length + 1)
        title = buffer.value.lower()
        for k in keywords:
            if k in title:
                nonlocal found
                found = True
                return False
        return True
    
    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.c_int)
    user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
    
    if not found:
        return
    time.sleep(0.3)
    

    def is_modal_confirm_window(hwnd, parent_hwnds): user32 = ctypes.windll.user32

    if not win32gui.IsWindowVisible(hwnd): return False

    style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE) if not (style & win32con.WS_POPUP): return False

    owner = user32.GetWindow(hwnd, win32con.GW_OWNER) if owner not in parent_hwnds: return False

    title_length = user32.GetWindowTextLengthW(hwnd) if title_length == 0: return False

    buffer = ctypes.create_unicode_buffer(title_length + 1) user32.GetWindowTextW(hwnd, buffer, title_length + 1) title = buffer.value.lower()

    keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"]

    for k in keywords: if k in title: return True

    return False def enum_save_dialog_windows(windows, save_windows): main_dialog_hwnds = set() for hwnd in windows: if win32gui.IsWindowVisible(hwnd): title = win32gui.GetWindowText(hwnd) if title and ("save as" in title.lower() or "salva con nome" in title.lower()): main_dialog_hwnds.add(hwnd) for hwnd in windows: if hwnd in main_dialog_hwnds: pid = win32process.GetWindowThreadProcessId(hwnd)[1] if not is_modal_confirm_window(hwnd, main_dialog_hwnds): save_windows[hwnd] = pid

    def get_unique_id_for_pid(pid): if pid not in pid_to_unique_id: pid_to_unique_id[pid] = str(uuid.uuid4()) return pid_to_unique_id[pid]

    def monitor_save_dialog(process_name, app, pid, hwnd): global handled_hwnds, pid_to_unique_id, unique_id_to_save_data

    unique_id = get_unique_id_for_pid(pid)

    print(f"[{process_name}] Monitoraggio HWND {hwnd} PID {pid} con unique_id {unique_id} avviato") gui_shown = False handled_hwnds.add(hwnd)

    try: dlg = app.window(handle=hwnd)

    while dlg.exists() and not exit_flag:
        if not dlg.is_visible():
            time.sleep(0.3)
            continue
    
        if not gui_shown:
            wait_for_modal_dialog_closed(pid, hwnd)
            hide_window(hwnd)
    
            saved_path = unique_id_to_save_data.get(unique_id)
    
            ext = detect_default_extension(process_name)
            default_name = "file" + ext
    
            if saved_path:
                initial_folder = os.path.dirname(saved_path)
                default_name = os.path.basename(saved_path)
                if not default_name.lower().endswith(ext.lower()):
                    default_name += ext
            else:
                initial_folder = None
    
            result = custom_save_gui(ext, [], default_name, initial_folder)
            if result is None or result[0] is None:
                selected_path = None
                codice_az_salvato = None
                codice_ad_salvato = None
            else:
                selected_path, codice_az_salvato, codice_ad_salvato = result
    
            gui_shown = True
    
            if selected_path is not None:
                normalized_path = os.path.normpath(selected_path)
                unique_id_to_save_data[unique_id] = normalized_path
    
                show_window(hwnd)
                bring_to_front(hwnd)
                time.sleep(0.1)
    
                filename_edit = dlg.child_window(class_name="Edit")
                fixed_path = normalized_path.replace('/', '\\')
                filename_edit.set_edit_text(fixed_path)
    
                children = enumerate_child_windows(hwnd)
                btn_hwnd = None
                for ch in children:
                    text = win32gui.GetWindowText(ch)
                    cls = win32gui.GetClassName(ch)
                    if cls == 'Button' and ('salva' in text.lower() or 'save' in text.lower()):
                        btn_hwnd = ch
                        break
    
                if btn_hwnd:
                    try:
                        btn = dlg.child_window(handle=btn_hwnd)
                        btn.click_input()
                        wait_for_modal_dialog_closed(pid, hwnd)
                        if codice_az_salvato and codice_ad_salvato:
                            inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
                    except Exception as e:
                        print(f"{process_name}: click_input() non riuscito: {e}. Uso fallback BM_CLICK")
                        click_button_fallback_hwnd(btn_hwnd)
                        wait_for_modal_dialog_closed(pid, hwnd)
                        if codice_az_salvato and codice_ad_salvato:
                            inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
            else:
                print(f"{process_name}: GUI annullata, chiudo finestra dialog")
                win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
                break
    
        time.sleep(0.5)
        dlg = app.window(handle=hwnd)
    
    print(f"[{process_name}] Finestra HWND {hwnd} chiusa, termina monitoraggio")
    

    except Exception as e: print(f"{process_name} - Errore monitoraggio dialog: {e}")

    if hwnd in handled_hwnds: handled_hwnds.remove(hwnd) print(f"{process_name}: HWND {hwnd} rimosso da gestiti") Riporto qui solo il main loop e l'avvio icon tray come nel tuo script originale def main_loop(): global handled_hwnds, exit_flag, pid_to_unique_id, unique_id_to_save_data pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() monitored_hwnds = {}

    while not exit_flag: all_hwnds = [] win32gui.EnumWindows(lambda hwnd, param: param.append(hwnd), all_hwnds)

    save_windows = {}
    enum_save_dialog_windows(all_hwnds, save_windows)
    
    for hwnd in list(monitored_hwnds.keys()):
        if not win32gui.IsWindow(hwnd) or hwnd not in save_windows:
            monitored_hwnds.pop(hwnd)
            if hwnd in handled_hwnds:
                handled_hwnds.remove(hwnd)
    
    for hwnd, pid in save_windows.items():
        if hwnd in handled_hwnds:
            continue
    
        try:
            proc = psutil.Process(pid)
            proc_name = proc.name()
        except Exception:
            proc_name = "sconosciuto"
    
        try:
            app = Application().connect(process=pid)
            t = threading.Thread(target=monitor_save_dialog, args=(proc_name, app, pid, hwnd), daemon=True)
            t.start()
            monitored_hwnds[hwnd] = t
            print(f"[Main] Avviato monitor PID {pid} HWND {hwnd} ({proc_name})")
        except Exception as e:
            print(f"[Main] Errore connessione PID {pid} HWND {hwnd}: {e}")
    
    time.sleep(2)
    

    E infine, l'avvio if name == "main": icon = setup_tray_icon() main_thread = threading.Thread(target=main_loop, daemon=True) main_thread.start() icon.run() print("Terminazione in corso...") exit_flag = True main_thread.join(timeout=5) print("Chiusura completata.")

  2. Assistant

    Certo! Ti fornisco il codice da te inviato con commenti dettagliati per ogni parte, in modo da spiegare il funzionamento di ciascuna sezione e funzione.

    import time
    import threading
    import tkinter as tk
    from tkinter import ttk, filedialog, messagebox
    import psutil
    from pywinauto import Application
    import win32gui
    import win32con
    import win32process
    import os
    import ctypes
    import uuid
    import sqlite3
    
    # Per tray icon
    import pystray
    from PIL import Image, ImageDraw
    
    
    # Nome file DB SQLite usato per archiviare dati aziende, adempimenti e files
    DB_FILE = 'gestione_aziende_adempimenti.db'
    
    
    # Variabili globali per la gestione dello stato di monitoraggio
    pid_to_unique_id = {}           # mappa PID processo -> unique_id univoco (UUID string)
    unique_id_to_save_data = {}     # mappa unique_id -> ultimo percorso salvato (path completo)
    handled_hwnds = set()           # set di HWND (handle finestra) già gestiti
    exit_flag = False               # flag globale di uscita, per terminare il ciclo principale
    
    
    # --------------------------------------------------
    # Funzioni per l'icona nella system tray (barra di sistema)
    # --------------------------------------------------
    
    def create_image():
        """Crea una piccola immagine per l'icona della tray"""
        width = 16
        height = 16
        color1 = "black"
        color2 = "white"
        image = Image.new('RGB', (width, height), color1)  # sfondo nero
        dc = ImageDraw.Draw(image)
        # Disegna un rettangolo bianco al centro
        dc.rectangle([(width // 4, height // 4), (width * 3 // 4, height * 3 // 4)], fill=color2)
        return image
    
    
    def on_quit(icon, item):
        """Callback menu tray per uscire dal programma"""
        global exit_flag
        exit_flag = True
        icon.stop()   # ferma icona tray
    
    
    def setup_tray_icon():
        """Configura e restituisce l'icona da usare nella tray con menu 'Esci'"""
        icon = pystray.Icon("SaveAsMonitor")
        icon.icon = create_image()
        icon.title = "SaveAs Monitor"
        icon.menu = pystray.Menu(pystray.MenuItem("Esci", on_quit))
        return icon
    
    
    # --------------------------------------------------
    # Funzioni per gestione finestre (win32)
    # --------------------------------------------------
    
    def hide_window(hwnd):
        """Nasconde una finestra data dall'handle HWND"""
        win32gui.ShowWindow(hwnd, win32con.SW_HIDE)
    
    
    def show_window(hwnd):
        """Mostra una finestra data dall'handle HWND"""
        win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
    
    
    def bring_to_front(hwnd):
        """Porta una finestra in primo piano"""
        try:
            win32gui.SetForegroundWindow(hwnd)
        except Exception:
            # Ignora eventuali errori (es. permessi)
            pass
    
    
    # --------------------------------------------------
    # Funzioni di interazione con il database SQLite
    # --------------------------------------------------
    
    def fetch_aziende_for_gui():
        """Estrae dal DB tutte le aziende (codice e denominazione), ordinate per denominazione"""
        conn = sqlite3.connect(DB_FILE)
        c = conn.cursor()
        c.execute("SELECT codice, denominazione FROM aziende ORDER BY denominazione")
        rows = c.fetchall()
        conn.close()
        return rows
    
    
    def fetch_adempimenti_for_gui():
        """Estrae dal DB tutti gli adempimenti, compresi dati cartella salvataggio e nome file"""
        conn = sqlite3.connect(DB_FILE)
        c = conn.cursor()
        c.execute("SELECT codice_adempimento, descrizione, cartella_salvataggio, IFNULL(nome_file,'') FROM adempimenti ORDER BY descrizione")
        rows = c.fetchall()
        conn.close()
        return rows
    
    
    def fetch_file_by_path(percorso):
        """Controlla nel DB se esiste un record di file con il percorso dato. Restituisce dati se trovato."""
        conn = sqlite3.connect(DB_FILE)
        c = conn.cursor()
        c.execute('SELECT codice_azienda, codice_adempimento FROM files WHERE percorso_file = ?', (percorso,))
        row = c.fetchone()
        conn.close()
        return row
    
    
    def inserisci_file_db(codice_azienda, codice_adempimento, percorso_file):
        """Inserisce il file salvato nel DB, ignorando duplicati"""
        conn = sqlite3.connect(DB_FILE)
        c = conn.cursor()
        try:
            c.execute("INSERT INTO files (codice_azienda, codice_adempimento, percorso_file) VALUES (?, ?, ?)", 
                      (codice_azienda, codice_adempimento, percorso_file))
            conn.commit()
        except sqlite3.IntegrityError:
            # Se il record è duplicato, si ignora oppure si può gestire un aggiornamento
            pass
        finally:
            conn.close()
    
    
    # --------------------------------------------------
    # GUI personalizzata per la finestra di "Salva con nome"
    # --------------------------------------------------
    
    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None):
        """
        Mostra una GUI personalizzata che permette di scegliere azienda, adempimento, cartella e nome file.
    
        :param default_ext: estensione file predefinita (es. '.docx')
        :param file_types: lista di tuple estensione/descrizione (non usata qui esplicitamente)
        :param default_name: nome file base da proporre
        :param initial_folder: cartella di partenza per selezione file
        :return: (full_path completo, codice azienda, codice adempimento) oppure None se cancellato
        """
    
        root = tk.Tk()
        root.title("Salvataggio personalizzato")
        root.geometry("700x250")
        root.attributes("-topmost", True)  # porta in primo piano la finestra
    
    
        # Dizionario usato per passare valori tra funzioni interne
        selezionato = {'full_path': None}
        cancelled = {'value': True}  # indica se la GUI è stata annullata
    
        # Prendo dati da DB
        aziende = fetch_aziende_for_gui()
        adempimenti = fetch_adempimenti_for_gui()
    
        # Variabili tkinter per binding valori widget
        var_azienda = tk.StringVar()
        var_adempimento = tk.StringVar()
        var_folder = tk.StringVar()
        var_filename = tk.StringVar(value=default_name)
    
        full_path = None
        if initial_folder and default_name:
            full_path = os.path.normpath(os.path.join(initial_folder, default_name))
    
        preselected_azienda_cod = None
        preselected_adempimento_cod = None
        # Se esiste un file preesistente, scelgo predeterminate opzioni nella GUI
        if full_path:
            found = fetch_file_by_path(full_path)
            if found:
                preselected_azienda_cod, preselected_adempimento_cod = found
    
        # Funzione acronimo per nome azienda data il codice
        def get_azienda_name(cod):
            for a in aziende:
                if a[0] == cod:
                    return a[1]
            return ""
    
        # Funzione acronimo per nome adempimento dato il codice
        def get_adempimento_name(cod):
            for a in adempimenti:
                if a[0] == cod:
                    return a[1]
            return ""
    
        # Settaggio valori di default per le combo box
        var_azienda.set(get_azienda_name(preselected_azienda_cod) if preselected_azienda_cod else (aziende[0][1] if aziende else ""))
        var_adempimento.set(get_adempimento_name(preselected_adempimento_cod) if preselected_adempimento_cod else (adempimenti[0][1] if adempimenti else ""))
    
        def aggiorna_percorso(*args):
            """
            Aggiorna la cartella di destinazione e il nome file predefinito in base alle scelte azienda e adempimento.
            """
            try:
                # Trova azienda selezionata da stringa
                azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get())
                codice_az = azienda_selezionata[0]
    
                # Trova adempimento selezionato
                ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get())
                codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato
    
                # Ottengo root path azienda da DB, se non esiste uso corrente
                conn = sqlite3.connect(DB_FILE)
                c = conn.cursor()
                c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,))
                root_path = c.fetchone()
                conn.close()
                root_path = root_path[0] if root_path else os.getcwd()
    
                # Costruisco percorso completo cartella
                full_folder_path = os.path.join(root_path, cartella_salvataggio)
                os.makedirs(full_folder_path, exist_ok=True)  # creo cartella se non esiste
    
                var_folder.set(full_folder_path)
    
                # Nome file da usare: se presente nome_file dal DB, altrimenti default passato
                filename = nome_file if nome_file.strip() else default_name
                # Controlla estensione, la aggiunge se mancante
                if not filename.lower().endswith(default_ext.lower()):
                    filename += default_ext
    
                var_filename.set(filename)
            except StopIteration:
                # Se non trova combo selezionata corretto non succede nulla
                pass
    
        def scegli_cartella_manual():
            """Permette all'utente di scegliere manualmente una cartella, aggiorna campo."""
            folder_selected = filedialog.askdirectory(initialdir=var_folder.get() or os.getcwd())
            if folder_selected:
                var_folder.set(folder_selected)
    
        def conferma(event=None):
            """Funzione chiamata quando l'utente conferma la selezione (clicca Conferma o [Enter])"""
            folder = var_folder.get()
            filename = var_filename.get()
            if not folder or not filename:
                messagebox.showerror("Errore", "Cartella e nome file sono obbligatori")
                return
            selezionato['full_path'] = os.path.normpath(os.path.join(folder, filename))
            cancelled['value'] = False
            root.destroy()
    
        def on_close():
            """Callback se l'utente chiude la finestra (tasto X)"""
            cancelled['value'] = True
            root.destroy()
    
        # Costruisco la finestra GUI con etichette, combobox, entry e pulsanti
        tk.Label(root, text="Azienda:").pack(anchor='w', padx=10, pady=(10, 0))
        combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly')
        combo_aziende.pack(fill='x', padx=10)
    
        tk.Label(root, text="Adempimento:").pack(anchor='w', padx=10, pady=(10, 0))
        combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly')
        combo_adempimenti.pack(fill='x', padx=10)
    
        tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10, pady=(10, 0))
        folder_entry = tk.Entry(root, textvariable=var_folder, width=80)
        folder_entry.pack(side='left', padx=(10, 0), pady=5, fill='x', expand=True)
        btn_folder = tk.Button(root, text="Scegli cartella", command=scegli_cartella_manual)
        btn_folder.pack(side='left', padx=10, pady=5)
    
        tk.Label(root, text="Nome file:").pack(anchor='w', padx=10, pady=(10, 0))
        filename_entry = tk.Entry(root, textvariable=var_filename, width=80)
        filename_entry.pack(padx=10, pady=5, fill="x")
    
        btn_conferma = tk.Button(root, text="Conferma", command=conferma)
        btn_conferma.pack(pady=10)
    
        root.protocol("WM_DELETE_WINDOW", on_close)
    
        # Collegamenti per aggiornare percorso ogni volta che cambia azienda o adempimento
        aggiorna_percorso()
        var_azienda.trace_add('write', aggiorna_percorso)
        var_adempimento.trace_add('write', aggiorna_percorso)
    
        # Bind tasti Invio per confermare
        filename_entry.bind('<Return>', conferma)
        folder_entry.bind('<Return>', conferma)
    
        filename_entry.focus_set()
        root.focus_force()
        root.mainloop()
    
        # Se annullato restituisco nulla
        if cancelled['value']:
            return None, None, None
    
        # Altrimenti restituisco percorso completo, codice azienda e codice adempimento
        return selezionato['full_path'], \
               next(a[0] for a in aziende if a[1] == var_azienda.get()), \
               next(a[0] for a in adempimenti if a[1] == var_adempimento.get())
    
    
    # --------------------------------------------------
    # Funzioni ausiliarie usate da monitoraggio salvataggi
    # --------------------------------------------------
    
    def click_button_fallback_hwnd(hwnd_button):
        """Fallback metodo per 'cliccare' il pulsante se click_input pywinauto fallisce: manda messaggio BM_CLICK"""
        try:
            win32gui.SendMessage(hwnd_button, win32con.BM_CLICK, 0, 0)
        except Exception:
            pass
    
    
    def enumerate_child_windows(hwnd):
        """Restituisce la lista degli HWND figli di una finestra data"""
        children = []
    
        def enum_proc(child_hwnd, param):
            param.append(child_hwnd)
            return True
        win32gui.EnumChildWindows(hwnd, enum_proc, children)
        return children
    
    
    def detect_default_extension(process_name):
        """
        Ritorna estensione file predefinita in base al nome processo (es. programma che lancia la finestra di salvataggio)
        """
        process_name = process_name.lower() if process_name else ""
    
        mapping = {
            "winword.exe": ".docx",
            "excel.exe": ".xlsx",
            "powerpnt.exe": ".pptx",
            "onenote.exe": ".one",
            "msaccess.exe": ".accdb",
            "outlook.exe": ".pst",
            "swriter.exe": ".odt",
            "scalc.exe": ".ods",
            "simpress.exe": ".odp",
            "soffice.bin": ".odt",
            "acrord32.exe": ".pdf",
            "acrobat.exe": ".pdf",
            "photoshop.exe": ".psd",
            "illustrator.exe": ".ai",
            "chrome.exe": ".html",
            "firefox.exe": ".html",
            "msedge.exe": ".html",
            "opera.exe": ".html",
            "brave.exe": ".html",
            "notepad.exe": ".txt",
            "notepad++.exe": ".txt",
            "sublime_text.exe": ".txt",
            "code.exe": ".txt",
            "vim.exe": ".txt",
            "mspaint.exe": ".png",
            "paint.exe": ".png",
            "gimp.exe": ".xcf",
            "inkscape.exe": ".svg",
            "vlc.exe": ".m3u",
            "audacity.exe": ".aup",
            "spotify.exe": ".dat",
            "7z.exe": ".7z",
            "winrar.exe": ".rar",
            "winzip.exe": ".zip",
            "wordpad.exe": ".rtf",
            "calc.exe": ".txt",
        }
    
        return mapping.get(process_name, ".dat")  # default ".dat" se sconosciuto
    
    
    def wait_for_modal_dialog_closed(pid, parent_hwnd, timeout=30):
        """
        Attende la chiusura di eventuali finestre modali di conferma collegate a 'parent_hwnd' del processo con pid.
    
        La funzione cerca finestre popup con titoli che contengono parole chiave tipo conferma o sovrascrivi.
        Se trova una finestra simile, aspetta che venga chiusa oppure fino al timeout.
        """
        keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"]
        user32 = ctypes.windll.user32
        end_time = time.time() + timeout
    
        while time.time() < end_time and not exit_flag:
            found = False
    
            def enum_windows_callback(hwnd, lParam):
                if not user32.IsWindowVisible(hwnd):
                    return True
                style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE)
                # Deve essere popup
                if not (style & win32con.WS_POPUP):
                    return True
                owner = user32.GetWindow(hwnd, win32con.GW_OWNER)
                if owner != parent_hwnd:
                    return True
                length = user32.GetWindowTextLengthW(hwnd)
                buffer = ctypes.create_unicode_buffer(length + 1)
                user32.GetWindowTextW(hwnd, buffer, length + 1)
                title = buffer.value.lower()
                for k in keywords:
                    if k in title:
                        nonlocal found
                        found = True
                        return False
                return True
    
            EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.c_int)
            user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
    
            if not found:
                # Nessuna finestra modale di conferma aperta, esco
                return
    
            time.sleep(0.3)
    
    
    def is_modal_confirm_window(hwnd, parent_hwnds):
        """
        Controlla se la finestra hwnd è una finestra modale di conferma secondo criteri simili alla funzione above.
    
        'parent_hwnds' è lista di potenziali finestre "principali" da cui tale modale dovrebbe derivare.
        """
    
        user32 = ctypes.windll.user32
    
        if not win32gui.IsWindowVisible(hwnd):
            return False
    
        style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE)
        if not (style & win32con.WS_POPUP):
            return False
    
        owner = user32.GetWindow(hwnd, win32con.GW_OWNER)
        if owner not in parent_hwnds:
            return False
    
        title_length = user32.GetWindowTextLengthW(hwnd)
        if title_length == 0:
            return False
    
        buffer = ctypes.create_unicode_buffer(title_length + 1)
        user32.GetWindowTextW(hwnd, buffer, title_length + 1)
        title = buffer.value.lower()
    
        keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"]
    
        for k in keywords:
            if k in title:
                return True
    
        return False
    
    
    def enum_save_dialog_windows(windows, save_windows):
        """
        Data la lista di finestre HWND passa, trova quali sono dialog di 'Salva con nome' visibili.
    
        Riempie il dizionario save_windows con map hwnd -> pid processo.
    
        Aggiunge alla lista main_dialog_hwnds le finestre padre trovate
        """
        main_dialog_hwnds = set()
        for hwnd in windows:
            if win32gui.IsWindowVisible(hwnd):
                title = win32gui.GetWindowText(hwnd)
                if title and ("save as" in title.lower() or "salva con nome" in title.lower()):
                    main_dialog_hwnds.add(hwnd)
    
        for hwnd in windows:
            if hwnd in main_dialog_hwnds:
                pid = win32process.GetWindowThreadProcessId(hwnd)[1]
                # Verifico che la finestra non sia una modale di conferma
                if not is_modal_confirm_window(hwnd, main_dialog_hwnds):
                    save_windows[hwnd] = pid
    
    
    def get_unique_id_for_pid(pid):
        """
        Ritorna un UUID unico associato a quel PID.
    
        Se non presente, ne crea uno e lo salva in mappa globale.
        """
        if pid not in pid_to_unique_id:
            pid_to_unique_id[pid] = str(uuid.uuid4())
        return pid_to_unique_id[pid]
    
    
    def monitor_save_dialog(process_name, app, pid, hwnd):
        """
        Funzione principale che monitora una finestra dialog di salvataggio (hwnd) per un processo dato (pid).
    
        Mostra la GUI personalizzata per selezionare azienda/adempimento/file.
        Usa pywinauto per interagire con la finestra Save As, imposta percorso e clicca Salva.
        Inserisce info file nel DB.
        """
    
        global handled_hwnds, pid_to_unique_id, unique_id_to_save_data
    
        unique_id = get_unique_id_for_pid(pid)
    
        print(f"[{process_name}] Monitoraggio HWND {hwnd} PID {pid} con unique_id {unique_id} avviato")
        gui_shown = False
        handled_hwnds.add(hwnd)
    
        try:
            dlg = app.window(handle=hwnd)
    
            # Ciclo finché la finestra c'è e non mi viene chiesto di uscire
            while dlg.exists() and not exit_flag:
                if not dlg.is_visible():
                    time.sleep(0.3)
                    continue
    
                if not gui_shown:
                    # Attendo che finestre modali come conferme di sovrascrittura vengano chiuse
                    wait_for_modal_dialog_closed(pid, hwnd)
    
                    # Nascondo la finestra Save As per mostrare la GUI personalizzata e non confondere utente
                    hide_window(hwnd)
    
                    saved_path = unique_id_to_save_data.get(unique_id)
    
                    ext = detect_default_extension(process_name)
                    default_name = "file" + ext
    
                    if saved_path:
                        initial_folder = os.path.dirname(saved_path)
                        default_name = os.path.basename(saved_path)
                        # Assicuro che il nome finisca con estensione corretta
                        if not default_name.lower().endswith(ext.lower()):
                            default_name += ext
                    else:
                        initial_folder = None
    
                    # Mostra la GUI save personalizzata
                    result = custom_save_gui(ext, [], default_name, initial_folder)
                    if result is None or result[0] is None:
                        selected_path = None
                        codice_az_salvato = None
                        codice_ad_salvato = None
                    else:
                        selected_path, codice_az_salvato, codice_ad_salvato = result
    
                    gui_shown = True
    
                    if selected_path is not None:
                        normalized_path = os.path.normpath(selected_path)
                        unique_id_to_save_data[unique_id] = normalized_path
    
                        # Mostro la finestra Save As di nuovo e la porto in primo piano
                        show_window(hwnd)
                        bring_to_front(hwnd)
                        time.sleep(0.1)
    
                        # Prendo il campo edit per il path/nome file e lo setto
                        filename_edit = dlg.child_window(class_name="Edit")
                        fixed_path = normalized_path.replace('/', '\\')  # Windows path style
                        filename_edit.set_edit_text(fixed_path)
    
                        # Cerco il pulsante Salva tra i figli, testo con "salva" o "save"
                        children = enumerate_child_windows(hwnd)
                        btn_hwnd = None
                        for ch in children:
                            text = win32gui.GetWindowText(ch)
                            cls = win32gui.GetClassName(ch)
                            if cls == 'Button' and ('salva' in text.lower() or 'save' in text.lower()):
                                btn_hwnd = ch
                                break
    
                        if btn_hwnd:
                            try:
                                # Uso pywinauto per cliccare
                                btn = dlg.child_window(handle=btn_hwnd)
                                btn.click_input()
                                # Attendo eventuali dialog modali di conferma, poi inserisco record DB
                                wait_for_modal_dialog_closed(pid, hwnd)
                                if codice_az_salvato and codice_ad_salvato:
                                    inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
                            except Exception as e:
                                print(f"{process_name}: click_input() non riuscito: {e}. Uso fallback BM_CLICK")
                                # Se click_input fallisce, mando messaggio di click a basso livello
                                click_button_fallback_hwnd(btn_hwnd)
                                wait_for_modal_dialog_closed(pid, hwnd)
                                if codice_az_salvato and codice_ad_salvato:
                                    inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
                    else:
                        # Utente ha annullato la GUI personalizzata, chiudo dialog Save As
                        print(f"{process_name}: GUI annullata, chiudo finestra dialog")
                        win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
                        break
    
                time.sleep(0.5)
                dlg = app.window(handle=hwnd)  # aggiorno riferimento finestra (necessario pywinauto)
    
            print(f"[{process_name}] Finestra HWND {hwnd} chiusa, termina monitoraggio")
    
        except Exception as e:
            print(f"{process_name} - Errore monitoraggio dialog: {e}")
    
        # Rimuovo hwnd dal set gestiti
        if hwnd in handled_hwnds:
            handled_hwnds.remove(hwnd)
            print(f"{process_name}: HWND {hwnd} rimosso da gestiti")
    
    
    # --------------------------------------------------
    # Ciclo principale di monitoraggio
    # --------------------------------------------------
    
    def main_loop():
        """
        Ciclo infito (finché exit_flag non diventa True) che cerca finestre di dialog Save As aperte,
        avvia un thread monitor per ognuna misconosciuta, termina thread di dialog chiuse.
    
        Gestisce la mappatura hwnd->thread dei monitor attivi.
        """
    
        global handled_hwnds, exit_flag, pid_to_unique_id, unique_id_to_save_data
        pid_to_unique_id = {}
        unique_id_to_save_data = {}
        handled_hwnds = set()
        monitored_hwnds = {}  # dizionario hwnd -> thread monitor
    
        while not exit_flag:
            all_hwnds = []
            # Enumero tutte le finestre di sistema aperte (HWND)
            win32gui.EnumWindows(lambda hwnd, param: param.append(hwnd), all_hwnds)
    
            save_windows = {}
            # Cerco quelle di tipo "Salva con nome"
            enum_save_dialog_windows(all_hwnds, save_windows)
    
            # Pulisci monitor di finestre chiuse
            for hwnd in list(monitored_hwnds.keys()):
                if not win32gui.IsWindow(hwnd) or hwnd not in save_windows:
                    monitored_hwnds.pop(hwnd)
                    if hwnd in handled_hwnds:
                        handled_hwnds.remove(hwnd)
    
            # Per ogni finestra salva nuova, se non ancora gestita, avvio monitor in thread separato
            for hwnd, pid in save_windows.items():
                if hwnd in handled_hwnds:
                    continue  # già gestita
    
                try:
                    proc = psutil.Process(pid)
                    proc_name = proc.name()
                except Exception:
                    proc_name = "sconosciuto"
    
                try:
                    # Connetto con pywinauto all'app via PID
                    app = Application().connect(process=pid)
                    t = threading.Thread(target=monitor_save_dialog, args=(proc_name, app, pid, hwnd), daemon=True)
                    t.start()
                    monitored_hwnds[hwnd] = t
                    print(f"[Main] Avviato monitor PID {pid} HWND {hwnd} ({proc_name})")
                except Exception as e:
                    print(f"[Main] Errore connessione PID {pid} HWND {hwnd}: {e}")
    
            time.sleep(2)  # aspetta 2 secondi prima di nuovo ciclo
    
    
    # --------------------------------------------------
    # Avvio sistema tray + ciclo monitoraggio
    # --------------------------------------------------
    
    if __name__ == "__main__":
        icon = setup_tray_icon()  # setto icona tray
        main_thread = threading.Thread(target=main_loop, daemon=True)  # avvio thread monitoraggio
        main_thread.start()
        icon.run()  # avvio loop icona tray (bloccante, gestisce menu tray)
        print("Terminazione in corso...")
        exit_flag = True  # segnala al ciclo main_loop di uscire
        main_thread.join(timeout=5)  # attende termine thread
        print("Chiusura completata.")
    

    Spiegazione generale

    • Il programma monitora finestre di dialogo di tipo "Salva con nome" su Windows.
    • Quando rileva un nuovo dialog di salvataggio, apre una GUI personalizzata dall’utente per selezionare azienda, adempimento, cartella e nome file.
    • Poi imposta in modo automatico il percorso e il nome file nella finestra originaria e conferma il salvataggio.
    • Infine salva l’informazione di salvataggio in un database SQLite.
    • L'app è gestita in background, con icona nella tray per terminare il monitoraggio.

    Se vuoi posso aiutarti anche a strutturare il DB o qualsiasi altra modifica!

  3. User

    questo codice non mi apre la gui personalizzata perchè?

    import time import threading import tkinter as tk from tkinter import ttk, filedialog, messagebox import psutil from pywinauto import Application import win32gui import win32con import win32process import os import ctypes import uuid import sqlite3

    Per tray icon

    import pystray from PIL import Image, ImageDraw

    DB_FILE = 'gestione_aziende_adempimenti.db'

    Globals

    pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() exit_flag = False

    Tray icon functions

    def create_image(): width = 16 height = 16 color1 = "black" color2 = "white" image = Image.new('RGB', (width, height), color1) dc = ImageDraw.Draw(image) dc.rectangle([(width // 4, height // 4), (width * 3 // 4, height * 3 // 4)], fill=color2) return image

    def on_quit(icon, item): global exit_flag exit_flag = True icon.stop()

    def setup_tray_icon(): icon = pystray.Icon("SaveAsMonitor") icon.icon = create_image() icon.title = "SaveAs Monitor" icon.menu = pystray.Menu(pystray.MenuItem("Esci", on_quit)) return icon

    def hide_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_HIDE)

    def show_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_SHOW)

    def bring_to_front(hwnd): try: win32gui.SetForegroundWindow(hwnd) except Exception: pass

    DB functions

    def fetch_aziende_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice, denominazione FROM aziende ORDER BY denominazione") rows = c.fetchall() conn.close() return rows

    def fetch_adempimenti_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice_adempimento, descrizione, cartella_salvataggio, IFNULL(nome_file,'') FROM adempimenti ORDER BY descrizione") rows = c.fetchall() conn.close() return rows

    def fetch_file_by_path(percorso): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute('SELECT codice_azienda, codice_adempimento FROM files WHERE percorso_file = ?', (percorso,)) row = c.fetchone() conn.close() return row

    def inserisci_file_db(codice_azienda, codice_adempimento, percorso_file): conn = sqlite3.connect(DB_FILE) c = conn.cursor() try: c.execute("INSERT INTO files (codice_azienda, codice_adempimento, percorso_file) VALUES (?, ?, ?)", (codice_azienda, codice_adempimento, percorso_file)) conn.commit() except sqlite3.IntegrityError: # Ignora duplicati oppure aggiorna se vuoi pass finally: conn.close()

    Custom save GUI

    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None):

    root = tk.Tk()
    root.title("Salvataggio personalizzato")
    root.geometry("700x250")
    root.attributes("-topmost", True)
    
    selezionato = {'full_path': None}
    cancelled = {'value': True}
    
    aziende = fetch_aziende_for_gui()
    adempimenti = fetch_adempimenti_for_gui()
    
    var_azienda = tk.StringVar()
    var_adempimento = tk.StringVar()
    var_folder = tk.StringVar()
    var_filename = tk.StringVar(value=default_name)
    
    full_path = None
    if initial_folder and default_name:
        full_path = os.path.normpath(os.path.join(initial_folder, default_name))
    
    preselected_azienda_cod = None
    preselected_adempimento_cod = None
    if full_path:
        found = fetch_file_by_path(full_path)
        if found:
            preselected_azienda_cod, preselected_adempimento_cod = found
    
    def get_azienda_name(cod):
        for a in aziende:
            if a[0] == cod:
                return a[1]
        return ""
    
    def get_adempimento_name(cod):
        for a in adempimenti:
            if a[0] == cod:
                return a[1]
        return ""
    
    var_azienda.set(get_azienda_name(preselected_azienda_cod) if preselected_azienda_cod else (aziende[0][1] if aziende else ""))
    var_adempimento.set(get_adempimento_name(preselected_adempimento_cod) if preselected_adempimento_cod else (adempimenti[0][1] if adempimenti else ""))
    
    def aggiorna_percorso(*args):
        global filename
        filename = none
        try:
            azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get())
            codice_az = azienda_selezionata[0]
    
            ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get())
            codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato
    
            conn = sqlite3.connect(DB_FILE)
            c = conn.cursor()
            c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,))
            root_path = c.fetchone()
            conn.close()
            root_path = root_path[0] if root_path else os.getcwd()
    
            full_folder_path = os.path.join(root_path, cartella_salvataggio)
            os.makedirs(full_folder_path, exist_ok=True)
    
            var_folder.set(full_folder_path)
    
            filename = nome_file if nome_file.strip() else default_name
            if not filename.lower().endswith(default_ext.lower()):
                filename += default_ext
    
            var_filename.set(filename)
            
        except StopIteration:
            pass
    
    def scegli_cartella_manual():
        folder_selected = filedialog.askdirectory(initialdir=var_folder.get() or os.getcwd())
        if folder_selected:
            var_folder.set(folder_selected)
    
    def conferma(event=None):
        folder = var_folder.get()
        filename = var_filename.get()
        if not folder or not filename:
            messagebox.showerror("Errore", "Cartella e nome file sono obbligatori")
            return
        selezionato['full_path'] = os.path.normpath(os.path.join(folder, filename))
        cancelled['value'] = False
        root.destroy()
    
    def on_close():
        cancelled['value'] = True
        root.destroy()
    
    tk.Label(root, text="Azienda:").pack(anchor='w', padx=10, pady=(10, 0))
    combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly')
    combo_aziende.pack(fill='x', padx=10)
    
    tk.Label(root, text="Adempimento:").pack(anchor='w', padx=10, pady=(10, 0))
    combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly')
    combo_adempimenti.pack(fill='x', padx=10)
    
    tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10, pady=(10, 0))
    folder_entry = tk.Entry(root, textvariable=var_folder, width=80)
    folder_entry.pack(side='left', padx=(10, 0), pady=5, fill='x', expand=True)
    btn_folder = tk.Button(root, text="Scegli cartella", command=scegli_cartella_manual)
    btn_folder.pack(side='left', padx=10, pady=5)
    
    tk.Label(root, text="Nome file:").pack(anchor='w', padx=10, pady=(10, 0))
    filename_entry = tk.Entry(root, textvariable=var_filename, width=80)
    filename_entry.pack(padx=10, pady=5, fill="x")
    
    btn_conferma = tk.Button(root, text="Conferma", command=conferma)
    btn_conferma.pack(pady=10)
    
    root.protocol("WM_DELETE_WINDOW", on_close)
    
    aggiorna_percorso()
    var_azienda.trace_add('write', aggiorna_percorso)
    var_adempimento.trace_add('write', aggiorna_percorso)
    
    filename_entry.bind('<Return>', conferma)
    folder_entry.bind('<Return>', conferma)
    
    filename_entry.focus_set()
    root.focus_force()
    root.mainloop()
    
    if cancelled['value']:
        return None, None, None
    
    return selezionato['full_path'], \
           next(a[0] for a in aziende if a[1] == var_azienda.get()), \
           next(a[0] for a in adempimenti if a[1] == var_adempimento.get())
    

    #---- Funzioni ausiliarie usate dal monitoraggio ----

    def click_button_fallback_hwnd(hwnd_button): try: win32gui.SendMessage(hwnd_button, win32con.BM_CLICK, 0, 0) except Exception: pass

    def enumerate_child_windows(hwnd): children = [] def enum_proc(child_hwnd, param): param.append(child_hwnd) return True win32gui.EnumChildWindows(hwnd, enum_proc, children) return children

    def detect_default_extension(process_name): process_name = process_name.lower() if process_name else ""

    mapping = {
        "winword.exe": ".docx",
        "excel.exe": ".xlsx",
        "powerpnt.exe": ".pptx",
        "onenote.exe": ".one",
        "msaccess.exe": ".accdb",
        "outlook.exe": ".pst",
        "swriter.exe": ".odt",
        "scalc.exe": ".ods",
        "simpress.exe": ".odp",
        "soffice.bin": ".odt",
        "acrord32.exe": ".pdf",
        "acrobat.exe": ".pdf",
        "photoshop.exe": ".psd",
        "illustrator.exe": ".ai",
        "chrome.exe": ".html",
        "firefox.exe": ".html",
        "msedge.exe": ".html",
        "opera.exe": ".html",
        "brave.exe": ".html",
        "notepad.exe": ".txt",
        "notepad++.exe": ".txt",
        "sublime_text.exe": ".txt",
        "code.exe": ".txt",
        "vim.exe": ".txt",
        "mspaint.exe": ".png",
        "paint.exe": ".png",
        "gimp.exe": ".xcf",
        "inkscape.exe": ".svg",
        "vlc.exe": ".m3u",
        "audacity.exe": ".aup",
        "spotify.exe": ".dat",
        "7z.exe": ".7z",
        "winrar.exe": ".rar",
        "winzip.exe": ".zip",
        "wordpad.exe": ".rtf",
        "calc.exe": ".txt",
    }
    
    return mapping.get(process_name, ".dat")
    

    def wait_for_modal_dialog_closed(pid, parent_hwnd, timeout=30): keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"] user32 = ctypes.windll.user32 end_time = time.time() + timeout

    while time.time() < end_time and not exit_flag:
        found = False
    
        def enum_windows_callback(hwnd, lParam):
            if not user32.IsWindowVisible(hwnd):
                return True
            style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE)
            if not (style & win32con.WS_POPUP):
                return True
            owner = user32.GetWindow(hwnd, win32con.GW_OWNER)
            if owner != parent_hwnd:
                return True
            length = user32.GetWindowTextLengthW(hwnd)
            buffer = ctypes.create_unicode_buffer(length + 1)
            user32.GetWindowTextW(hwnd, buffer, length + 1)
            title = buffer.value.lower()
            for k in keywords:
                if k in title:
                    nonlocal found
                    found = True
                    return False
            return True
    
        EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.c_int)
        user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
    
        if not found:
            return
        time.sleep(0.3)
    

    def is_modal_confirm_window(hwnd, parent_hwnds): user32 = ctypes.windll.user32

    if not win32gui.IsWindowVisible(hwnd):
        return False
    
    style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE)
    if not (style & win32con.WS_POPUP):
        return False
    
    owner = user32.GetWindow(hwnd, win32con.GW_OWNER)
    if owner not in parent_hwnds:
        return False
    
    title_length = user32.GetWindowTextLengthW(hwnd)
    if title_length == 0:
        return False
    
    buffer = ctypes.create_unicode_buffer(title_length + 1)
    user32.GetWindowTextW(hwnd, buffer, title_length + 1)
    title = buffer.value.lower()
    
    keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"]
    
    for k in keywords:
        if k in title:
            return True
    
    return False
    

    def enum_save_dialog_windows(windows, save_windows): main_dialog_hwnds = set() for hwnd in windows: if win32gui.IsWindowVisible(hwnd): title = win32gui.GetWindowText(hwnd) if title and ("save as" in title.lower() or "salva con nome" in title.lower()): main_dialog_hwnds.add(hwnd) for hwnd in windows: if hwnd in main_dialog_hwnds: pid = win32process.GetWindowThreadProcessId(hwnd)[1] if not is_modal_confirm_window(hwnd, main_dialog_hwnds): save_windows[hwnd] = pid

    def get_unique_id_for_pid(pid): if pid not in pid_to_unique_id: pid_to_unique_id[pid] = str(uuid.uuid4()) return pid_to_unique_id[pid]

    def monitor_save_dialog(process_name, app, pid, hwnd): global handled_hwnds, pid_to_unique_id, unique_id_to_save_data

    unique_id = get_unique_id_for_pid(pid)
    
    print(f"[{process_name}] Monitoraggio HWND {hwnd} PID {pid} con unique_id {unique_id} avviato")
    gui_shown = False
    handled_hwnds.add(hwnd)
    
    
    try:
        dlg = app.window(handle=hwnd)
        
    
        while dlg.exists() and not exit_flag:
            if not dlg.is_visible():
                time.sleep(0.3)
                continue
    
            if not gui_shown:
                wait_for_modal_dialog_closed(pid, hwnd)
                
    
                saved_path = unique_id_to_save_data.get(unique_id)
    
                ext = detect_default_extension(process_name)
                default_name = "file" + ext
    
                if saved_path:
                    initial_folder = os.path.dirname(saved_path)
                    default_name = os.path.basename(saved_path)
                    if not default_name.lower().endswith(ext.lower()):
                        default_name += ext
                else:
                    initial_folder = None
    
                result = custom_save_gui(ext, [], default_name, initial_folder)
                if result is None or result[0] is None:
                    selected_path = None
                    codice_az_salvato = None
                    codice_ad_salvato = None
                else:
                    selected_path, codice_az_salvato, codice_ad_salvato = result
    
                gui_shown = True
    
                if selected_path is not None:
                    normalized_path = os.path.normpath(selected_path)
                    unique_id_to_save_data[unique_id] = normalized_path
    
                    show_window(hwnd)
                    bring_to_front(hwnd)
                    time.sleep(0.1)
    
                    filename_edit = dlg.child_window(class_name="Edit")
                    fixed_path = normalized_path.replace('/', '\\')
                    filename_edit.set_edit_text(fixed_path)
    
                    children = enumerate_child_windows(hwnd)
                    btn_hwnd = None
                    for ch in children:
                        text = win32gui.GetWindowText(ch)
                        cls = win32gui.GetClassName(ch)
                        if cls == 'Button' and ('salva' in text.lower() or 'save' in text.lower()):
                            btn_hwnd = ch
                            break
    
                    if btn_hwnd:
                        try:
                            btn = dlg.child_window(handle=btn_hwnd)
                            btn.click_input()
                            wait_for_modal_dialog_closed(pid, hwnd)
                            if codice_az_salvato and codice_ad_salvato:
                                inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
                        except Exception as e:
                            print(f"{process_name}: click_input() non riuscito: {e}. Uso fallback BM_CLICK")
                            click_button_fallback_hwnd(btn_hwnd)
                            wait_for_modal_dialog_closed(pid, hwnd)
                            if codice_az_salvato and codice_ad_salvato:
                                inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path)
                else:
                    print(f"{process_name}: GUI annullata, chiudo finestra dialog")
                    win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
                    break
    
            time.sleep(0.5)
            dlg = app.window(handle=hwnd)
    
        print(f"[{process_name}] Finestra HWND {hwnd} chiusa, termina monitoraggio")
    
    except Exception as e:
        print(f"{process_name} - Errore monitoraggio dialog: {e}")
    
    if hwnd in handled_hwnds:
        handled_hwnds.remove(hwnd)
        print(f"{process_name}: HWND {hwnd} rimosso da gestiti")
    

    Riporto qui solo il main loop e l'avvio icon tray come nel tuo script originale

    def main_loop(): global handled_hwnds, exit_flag, pid_to_unique_id, unique_id_to_save_data pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() monitored_hwnds = {}

    while not exit_flag:
        all_hwnds = []
        win32gui.EnumWindows(lambda hwnd, param: param.append(hwnd), all_hwnds)
    
        save_windows = {}
        enum_save_dialog_windows(all_hwnds, save_windows)
    
        for hwnd in list(monitored_hwnds.keys()):
            if not win32gui.IsWindow(hwnd) or hwnd not in save_windows:
                monitored_hwnds.pop(hwnd)
                if hwnd in handled_hwnds:
                    handled_hwnds.remove(hwnd)
    
        for hwnd, pid in save_windows.items():
            if hwnd in handled_hwnds:
                continue
    
            try:
                proc = psutil.Process(pid)
                proc_name = proc.name()
            except Exception:
                proc_name = "sconosciuto"
    
            try:
                app = Application().connect(process=pid)
                t = threading.Thread(target=monitor_save_dialog, args=(proc_name, app, pid, hwnd), daemon=True)
                t.start()
                monitored_hwnds[hwnd] = t
                print(f"[Main] Avviato monitor PID {pid} HWND {hwnd} ({proc_name})")
            except Exception as e:
                print(f"[Main] Errore connessione PID {pid} HWND {hwnd}: {e}")
    
        time.sleep(2)
    

    E infine, l'avvio

    if name == "main": icon = setup_tray_icon() main_thread = threading.Thread(target=main_loop, daemon=True) main_thread.start() icon.run() print("Terminazione in corso...") exit_flag = True main_thread.join(timeout=5) print("Chiusura completata.")

  4. Assistant

    Il motivo principale per cui la GUI personalizzata non si apre è che stai chiamando custom_save_gui() da un thread in background, non dal thread principale di Tkinter.

    Perché succede?

    • Tkinter non supporta chiamate da thread diversi da quello principale (main thread/addestramento GUI).
    • Se chiami Tk() o mainloop() da un thread secondario, la finestra potrebbe non apparire, oppure il programma si blocca o fallisce silenziosamente.

    Come risolvere?

    • Devi creare/eseguire la GUI solo nel thread principale.
    • Se il codice di monitoraggio gira su un thread separato, devi utilizzare un meccanismo di comunicazione (ad es. una coda/thread queue) per chiedere al thread principale di mostrare la finestra.
    • Oppure devi far partire il thread di monitoraggio dal thread principale stesso (idem il ciclo principale), ma senza mai chiamare GUI in thread in background.

    Correzioni specifiche al tuo codice

    Nel tuo codice, la funzione monitor_save_dialog() gira su un thread worker e chiama custom_save_gui() al suo interno.

    Questa chiamata è il problema, perché dentro custom_save_gui chiami tk.Tk() e root.mainloop(), e questo va fatto in main thread.


    Come fare una prova rapida?

    Metti custom_save_gui in main thread prima di avviare i thread di monitoraggio, ad esempio nel blocco if __name__ == '__main__': fai una prova chiamata a custom_save_gui e verifica che la GUI si apra correttamente.


    Esempio di comunicazione semplificata

    1. Crea una coda thread-safe (queue.Queue()) condivisa
    2. Nel thread di monitoraggio metti nella coda la richiesta di apertura GUI con i parametri
    3. Nel thread principale, nel ciclo (o con root.after), controlli la coda e se c’è una richiesta, apri la GUI qui, nel main thread

    Codice esemplificativo (aggiunta principale)

    import queue
    
    # Coda globale per richieste GUI
    gui_request_queue = queue.Queue()
    
    def monitor_save_dialog(...):
        # quando devi aprire la GUI, invece di chiamarla direttamente:
        gui_request_queue.put((ext, [], default_name, initial_folder))
        # poi aspetti il risultato (ad es. altra queue o evento)
        # per scopo dimostrativo qua potresti utilizzare:
        result = gui_request_queue.get()  # supponendo che GUI scriva il risultato
    
    def main_loop():
        # dentro al ciclo principale (o in thread principale) controlla la coda:
        while not exit_flag:
            ...
            # Controlla se ci sono richieste GUI da mostrare
            try:
                params = gui_request_queue.get_nowait()
            except queue.Empty:
                pass
            else:
                # Mostra GUI con i parametri nel main thread
                result = custom_save_gui(*params)
                gui_request_queue.put(result)  # restituisci risultato al worker
            ...
    

    Altre note importanti:

    • In custom_save_gui hai scritto filename = none (con la "n" minuscola), devi scrivere filename = None (Python è case sensitive).
    • Assicurati che tutte le variabili global dichiarate (ad es. global filename) siano usate/necessarie.
    • Se la GUI deve apparire sopra tutte le altre, oltre a -topmost puoi provare a chiamare root.lift().

    In sintesi:

    • Non puoi chiamare tk.Tk() + mainloop() da thread secondario!
    • Devi trasferire chiamata GUI nel main thread usando meccanismo tipo queue o simili.
    • Oppure usare un'altra libreria thread-safe o multiprocess.

    Se vuoi, posso aiutarti a riscrivere la parte GUI in modo thread-safe, basta chiedere!