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

questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo…

  1. User

    questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo stesso file, quando compare la gui di selezione riporta il nome del file inerente all'adempimento, ma dovrebbe comunque riportare il nome file attribuito al primo savataggio

  2. Assistant

    Capito, sembra che tu stia usando una GUI per un "Salva con nome" e vuoi che ogni volta che apri la finestra di dialogo Salva con nome per lo stesso file, venga mostrato il nome del file che hai salvato la prima volta, non il nome "standard" legato ad un'altra variabile o dato.

    Senza vedere il codice esatto, ti posso però dare indicazioni generali su come gestire questo comportamento.


    Problema comune

    Quando apri il dialogo "Salva con nome" più volte, il nome iniziale suggerito è impostato da un valore fisso o variabile non aggiornato, che non tiene conto del nome usato nel primo salvataggio.


    Come si risolve in linea generale

    1. Memorizza il percorso e nome file appena salvati:
      Quando fai il primo salvataggio (sia salva sia "salva con nome"), devi salvare in una variabile (ad es. ultimo_nome_file) il path completo o almeno il file name.

    2. Quando riapri il dialogo "salva con nome", imposta il valore della finestra con questa variabile ultimo_nome_file
      Se questa variabile è valorizzata (cioè hai salvato già una volta), usa quel nome come nome di default accanto ad esempio al percorso.


    Un esempio in Python con Tkinter

    Ecco uno scheletro di esempio per chiarire:

    import tkinter as tk
    from tkinter import filedialog
    
    class App:
        def __init__(self, root):
            self.root = root
            self.ultimo_nome_file = None  # Qui memorizzi il nome salvato
    
            btn_salva = tk.Button(root, text="Salva con nome", command=self.salva_con_nome)
            btn_salva.pack()
    
        def salva_con_nome(self):
            # Usa il nome file usato la prima volta, se c'è
            initialfile = None
            if self.ultimo_nome_file is not None:
                # estraiamo solo il nome file (no percorso)
                import os
                initialfile = os.path.basename(self.ultimo_nome_file)
            
            # Chiedo il file da salvare, con il nome file di default
            file_path = filedialog.asksaveasfilename(initialfile=initialfile,
                                                     defaultextension=".txt",
                                                     filetypes=[("Text files", "*.txt"), ("All files", "*.*")])
            if file_path:
                # Qui fai salva
                with open(file_path, "w") as f:
                    f.write("…")  # esempio contenuto
    
                self.ultimo_nome_file = file_path  # aggiorno nome salvato
    
    root = tk.Tk()
    app = App(root)
    root.mainloop()
    

    Riassumendo

    • Prima volta, ultimo_nome_file è None → la finestra parte con il nome standard (eventualmente ancora vuoto o "adempimento")
    • Dopo il primo salvataggio, aggiorno ultimo_nome_file con il file salvato
    • La finestra "Salva con nome" apre con quel nome file preimpostato, sempre quello ultimo usato, non un nome predefinito fisso.

    Se vuoi posso darti una mano più precisa se mi posti il tuo codice attuale.

    Fammi sapere!

  3. User

    questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo stesso file, quando compare la gui di selezione riporta il nome del file inerente all'adempimento, ma dovrebbe comunque riportare il nome file attribuito al primo savataggio 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('<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)
                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.")

  4. Assistant

    Grazie per il codice completo, ora è più chiara la situazione.


    Riassunto del problema

    Nel tuo monitoraggio, quando apri la GUI custom custom_save_gui per la seconda volta per lo stesso file, il campo Nome file: nella GUI riporta il nome "classico" legato all'adempimento (es. da DB), anziché il nome del file effettivamente usato nella prima volta (qui memorizzato in unique_id_to_save_data).


    Dove si genera il problema

    Nel pezzo chiave:

    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)
    

    All’interno di custom_save_gui() tu poi fai questa cosa per impostare var_filename:

    var_filename = tk.StringVar(value=default_name)
    

    Tuttavia, subito dopo nel aggiorna_percorso() (chiamato all'inizio), sovrascrivi var_filename con:

    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)
    

    Noti che nome_file è quel campo preso direttamente dal DB tramite:

    preselected_adempimento_cod = ...
    ...
    ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get())
    nome_file = ademp_selezionato[3]
    

    Quindi, anche se passi default_name come nome file già valorizzato con quello del primo salvataggio, subito dopo nel binding della GUI, questa variabile viene sovrascritta da nome_file preso da DB, tornando così al nome "originale".


    Come risolvere


    Soluzione 1: Passare il percorso completo del file salvato e far usare quello nella GUI

    Nei parametri che chiami custom_save_gui, passi default_name e initial_folder.

    Invece di passare semplicemente default_name preso da unique_id_to_save_data, potresti passare anche quel percorso come parametro aggiuntivo per il nome file finale da utilizzare senza sovrascrivere in aggiorna_percorso().

    Oppure modifica il codice di aggiorna_percorso per usare come priorità il file salvato precedentemente, e se non c’è allora passa il nome da DB.


    Implementazione pratica

    Puoi aggiungere un parametro opzionale saved_full_path a custom_save_gui(), così:

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

    E poi modifica aggiorna_percorso() in questo modo:

    def aggiorna_percorso(*args):
        try:
            ...
            ...
    
            # Impostiamo filename preferendo il percorso salvato
            if saved_full_path:
                filename = os.path.basename(saved_full_path)
            else:
                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
    

    Modifica nella chiamata dentro monitor_save_dialog

    Cambia:

    result = custom_save_gui(ext, [], default_name, initial_folder)
    

    in

    result = custom_save_gui(ext, [], default_name, initial_folder, saved_full_path=saved_path)
    

    Riassunto modifiche centrali

    # Dentro custom_save_gui aggiungi il parametro saved_full_path:
    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None):
        ...
        def aggiorna_percorso(*args):
            ...
            if saved_full_path:
                filename = os.path.basename(saved_full_path)
            else:
                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)
    

    E nel tuo monitor_save_dialog:

    result = custom_save_gui(ext, [], default_name, initial_folder, saved_full_path=saved_path)
    

    Perché questa soluzione funziona?

    • saved_full_path rappresenta il percorso del file usato nel primo salvataggio, quindi la GUI lo mostra sempre come nome predefinito.
    • Solo se non hai effettuato un primo salvataggio (saved_full_path=None), la GUI usa il nome del file definito in archivio DB (nome_file).
    • In questo modo eviti che aggiorna_percorso() sovrascriva il campo "Nome file" ignorando il nome effettivo appena salvato.

    Se vuoi posso aiutarti ad applicare queste modifiche direttamente nel tuo codice.
    Fammi sapere!

  5. User

    cosi poi non funziona più in automatico con il db

  6. Assistant

    Hai ragione: la modifica proposta — ovvero usare sempre il percorso salvato — impedirebbe che la GUI si aggiorni automaticamente se cambi l’adempimento o l’azienda (che serve per ricavare il percorso / nome file dal DB).


    Occorre un compromesso:

    • se c’è un percorso salvato valido e l’utente non cambia adempimento né azienda, la GUI mostra il nome salvato,
    • se invece cambia adempimento o azienda, la GUI deve aggiornarsi in automatico col nome da DB (e cartella da DB).

    Come fare?

    Passo 1: memorizzare lo stato "iniziale"

    All’avvio, quando si inizia la finestra, salvo i codici preselected_azienda_cod e preselected_adempimento_cod.

    Passo 2: modifica la callback aggiorna_percorso in modo che:

    • se l’azienda o l’adempimento cambiano rispetto a quelli pre-selezionati, allora carico nome file da DB,
    • se invece sono quelli originali e c’è un file salvato, uso il nome salvato.

    Esempio di implementazione:

    All’interno di custom_save_gui:

    # all'inizio di custom_save_gui
    preselected_azienda_cod_orig = preselected_azienda_cod
    preselected_adempimento_cod_orig = preselected_adempimento_cod
    saved_full_path = saved_full_path  # parametro passato
    
    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)
    
            # Se l'azienda o l'adempimento sono cambiati rispetto all'originale,
            # prendiamo il nome da DB, altrimenti teniamo il nome salvato
            if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path:
                filename = nome_file if nome_file.strip() else default_name
            else:
                # utilizza il nome del file salvato
                filename = os.path.basename(saved_full_path)
    
            if not filename.lower().endswith(default_ext.lower()):
                filename += default_ext
    
            var_filename.set(filename)
        except StopIteration:
            pass
    

    In questo modo:

    • Alla prima apertura (o se cambio azienda/adempimento), la GUI carica nome e cartella dal DB, quindi aggiornamento automatico;
    • Alla seconda apertura per lo stesso file (senza cambiare azienda/adempimento), la GUI mostra il nome salvato la prima volta (exact match);
    • Se cambio la selezione nella GUI, allora torna a caricare tutto da DB;

    In conclusione

    • Lasci invocare custom_save_gui con parametro saved_full_path=saved_path come suggerito prima;
    • Dentro custom_save_gui, modifica aggiorna_percorso con la logica sopra;
    • Così non perdi l’aggiornamento automatico dal DB quando si cambiano azienda/adempimento.

    Se vuoi, posso prepararti un patch pronta da inserire.
    Fammi sapere!

  7. User

    con la tua modifica la gui non compare più

  8. Assistant

    Perfetto, grazie per il feedback dettagliato.

    Di solito quando la GUI non compare più per una modifica come quella, il motivo più frequente è che la funzione aggiorna_percorso va in eccezione — e dato che gli errori in tkinter in callback di solito non vengono stampati in console ma interrompono l’esecuzione, la finestra può letteralmente risultare “bloccata” o “mancante”.


    Come procedere nel debug?

    1. Inserisci un blocco try/except interno all’interno della funzione aggiorna_percorso per catturare eventuali eccezioni e stamparle, ad esempio così:
    def aggiorna_percorso(*args):
        try:
            # codice esistente qui sotto...
            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)
    
            if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path:
                filename = nome_file if nome_file.strip() else default_name
            else:
                filename = os.path.basename(saved_full_path)
    
            if not filename.lower().endswith(default_ext.lower()):
                filename += default_ext
    
            var_filename.set(filename)
    
        except Exception as e:
            print("Errore in aggiorna_percorso:", e)
    

    Questo serve a capire se qualche valore è None o c’è qualche errore nell’accesso a variabili.


    Altri punti da verificare:

    • Sei certo che le variabili preselected_azienda_cod_orig e preselected_adempimento_cod_orig siano inizializzate correttamente fuori dalla funzione e visibili dentro a aggiorna_percorso?
      Se sono variabili locali a custom_save_gui(), dentro aggiorna_percorso potresti doverle dichiarare con nonlocal o passarle via closure correttamente.

    • Verifica che il parametro saved_full_path sia passato correttamente e non sia None (o almeno gestito se None).


    Esempio completo di come definire aggiorna_percorso con closure di variabili:

    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None):
        ...
        preselected_azienda_cod_orig = preselected_azienda_cod
        preselected_adempimento_cod_orig = preselected_adempimento_cod
    
        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)
    
                if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path:
                    filename = nome_file if nome_file.strip() else default_name
                else:
                    filename = os.path.basename(saved_full_path)
    
                if not filename.lower().endswith(default_ext.lower()):
                    filename += default_ext
    
                var_filename.set(filename)
            except Exception as e:
                print("Errore in aggiorna_percorso:", e)
    

    Alternativa più sicura: passare le variabili come parametri alle funzioni

    Un modo ancora più sicuro è quello di definire aggiorna_percorso con tutte le variabili necessarie legate tramite parametri predefiniti, ad esempio:

    def aggiorna_percorso(*args,
                          aziende=aziende,
                          adempimenti=adempimenti,
                          var_azienda=var_azienda,
                          var_adempimento=var_adempimento,
                          var_folder=var_folder,
                          var_filename=var_filename,
                          default_ext=default_ext,
                          default_name=default_name,
                          saved_full_path=saved_full_path,
                          preselected_azienda_cod_orig=preselected_azienda_cod,
                          preselected_adempimento_cod_orig=preselected_adempimento_cod):
        try:
            # corpo funzione
            ...
        except Exception as e:
            print("Errore in aggiorna_percorso:", e)
    

    Probabile causa specifica del blocco:

    Il problema più frequente è che preselected_azienda_cod o preselected_adempimento_cod siano None, quindi la condizione:

    if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path
    

    va a dare accesso a variabili None non paragonabili coerentemente, oppure saved_full_path è None e non trattato.


    Ti consiglio quindi:

    • Aggiungi stampa di debug sulla prima riga della funzione:
    print(f"Debug aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}")
    print(f"preselected_azienda_cod_orig={preselected_azienda_cod_orig}, preselected_adempimento_cod_orig={preselected_adempimento_cod_orig}")
    print(f"saved_full_path={saved_full_path}")
    
    • E vedi cosa viene stampato prima che la GUI sparisca. Se vedi errore, correggi.

    Riassunto

    1. Inserisci try/except + stampe di debug in aggiorna_percorso.
    2. Verifica che variabili esterne - specialmente preselected_azienda_cod_orig e preselected_adempimento_cod_orig - siano correttamente definite nel contesto della funzione callback.
    3. Se serve, passale come argomento predefinito a aggiorna_percorso per "chiarire" il loro scope.
    4. Se vuoi, incollami errori esatti che vedi in output o comportamenti, ti aiuto a fare debug più preciso.

    Se vuoi, ti invio un codice aggiornato completo con queste correzioni per la funzione custom_save_gui.
    Fammi sapere!

  9. User

    non compare la nostra gui

  10. Assistant

    Capito, la GUI proprio non compare, quindi probabilmente l’applicazione si blocca prima che root.mainloop() venga chiamato o la finestra è subito chiusa.


    Passi fondamentali per risolvere

    Verifica 1 - Eventuali errori silenti

    Prima di tutto, assicurati che eventuali eccezioni durante l'inizializzazione della GUI non blocchino l'apertura.

    Inserisci all'inizio della funzione custom_save_gui (subito dopo def custom_save_gui(...)):

    try:
        import traceback
    except ImportError:
        pass
    
    try:
        # tutto il codice di custom_save_gui dentro questo try
        root = tk.Tk()
        # ... resto del codice ...
    except Exception as e:
        print("ERRORE in custom_save_gui:", e)
        try:
            traceback.print_exc()
        except Exception:
            pass
        return None, None, None
    

    In questo modo se c'è un errore durante la creazione della GUI, lo vedrai.


    Verifica 2 - Stampo cosa succede all'entrata ed in aggiorna_percorso

    Subito dentro custom_save_gui:

    print("custom_save_gui: avviata")
    print(f"Parametri: default_ext={default_ext}, default_name={default_name}, initial_folder={initial_folder}, saved_full_path={saved_full_path}")
    

    E dentro aggiorna_percorso:

    def aggiorna_percorso(*args):
        try:
            print(f"aggiorna_percorso eseguita: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}")
            # Resto del codice...
        except Exception as e:
            print("Errore in aggiorna_percorso:", e)
    

    Verifica 3 - Controlla come definisci preselected_azienda_cod_orig, ecc.

    Nel tuo codice hai:

    preselected_azienda_cod = None
    preselected_adempimento_cod = None
    # poi eventualmente li valorizzi da DB.
    

    Quando usi questi dentro aggiorna_percorso devono essere dichiarati come variabili esterne o passati come argomenti.
    Per sicurezza fai così in custom_save_gui:

    preselected_azienda_cod_orig = preselected_azienda_cod
    preselected_adempimento_cod_orig = preselected_adempimento_cod
    

    Subito prima di aggiorna_percorso, così hanno valore definito.


    Verifica 4 - Passa tutte le variabili usate nella closure come parametri di default

    Questo è il modo più stabile in tkinter per evitare problemi di scope:

    def aggiorna_percorso(*args,
        aziende=aziende,
        adempimenti=adempimenti,
        var_azienda=var_azienda,
        var_adempimento=var_adempimento,
        var_folder=var_folder,
        var_filename=var_filename,
        default_ext=default_ext,
        default_name=default_name,
        saved_full_path=saved_full_path,
        preselected_azienda_cod_orig=preselected_azienda_cod_orig,
        preselected_adempimento_cod_orig=preselected_adempimento_cod_orig):
        
        try:
            print(f"aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}")
            # codice già noto precedentemente ...
        except Exception as e:
            print("Errore in aggiorna_percorso:", e)
    

    Verifica 5 - root.attributes("-topmost", True) potrebbe nascondere la finestra

    In rari casi il flag -topmost può far aprire finestre "sotto" o problemi di focus.

    Per debug prova a togliere/modificare:

    # root.attributes("-topmost", True)
    

    oppure metti dopo root.focus_force() anche:

    root.deiconify()
    root.lift()
    

    Codice esempio minimo con modifica corretta

    Ti propongo un esempio minimo e funzionante della parte GUI con gestione saved_full_path e debug che puoi incollare e provare standalone dalla tua funzione:

    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None):
        import tkinter as tk
        from tkinter import ttk, messagebox, filedialog
        import os
        import sqlite3
    
        print("custom_save_gui: avviata")
        print(f"default_ext={default_ext}, default_name={default_name}, initial_folder={initial_folder}, saved_full_path={saved_full_path}")
    
        root = tk.Tk()
        root.title("Salvataggio personalizzato")
        root.geometry("700x250")
        # root.attributes("-topmost", True)  # Prova a commentare questo se GUI non appare
    
        # Dummy dati simulati (sostituisci con fetch tuoi dal DB)
        aziende = [(1, "Azienda Alfa"), (2, "Azienda Beta")]
        adempimenti = [
            (101, "Adempimento Uno", "cartella1", "nomefile1.txt"),
            (102, "Adempimento Due", "cartella2", "nomefile2.txt"),
        ]
    
        var_azienda = tk.StringVar(value=aziende[0][1])
        var_adempimento = tk.StringVar(value=adempimenti[0][1])
        var_folder = tk.StringVar(value=initial_folder or os.getcwd())
        var_filename = tk.StringVar(value=default_name)
    
        preselected_azienda_cod_orig = aziende[0][0]
        preselected_adempimento_cod_orig = adempimenti[0][0]
    
        def aggiorna_percorso(*args,
                            aziende=aziende,
                            adempimenti=adempimenti,
                            var_azienda=var_azienda,
                            var_adempimento=var_adempimento,
                            var_folder=var_folder,
                            var_filename=var_filename,
                            default_ext=default_ext,
                            default_name=default_name,
                            saved_full_path=saved_full_path,
                            preselected_azienda_cod_orig=preselected_azienda_cod_orig,
                            preselected_adempimento_cod_orig=preselected_adempimento_cod_orig):
            try:
                print(f"aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}")
    
                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
    
                full_folder_path = os.path.join(os.getcwd(), cartella_salvataggio)
                var_folder.set(full_folder_path)
    
                if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path:
                    filename = nome_file if nome_file.strip() else default_name
                else:
                    filename = os.path.basename(saved_full_path)
    
                if not filename.lower().endswith(default_ext.lower()):
                    filename += default_ext
    
                var_filename.set(filename)
    
            except Exception as e:
                print("Errore in aggiorna_percorso:", e)
    
        combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly')
        combo_aziende.pack(padx=10, pady=10, fill='x')
    
        combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly')
        combo_adempimenti.pack(padx=10, pady=10, fill='x')
    
        tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10)
        folder_entry = tk.Entry(root, textvariable=var_folder, width=80)
        folder_entry.pack(padx=10, pady=5, fill="x")
    
        tk.Label(root, text="Nome file:").pack(anchor='w', padx=10)
        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=root.destroy)
        btn_conferma.pack(pady=10)
    
        var_azienda.trace_add('write', aggiorna_percorso)
        var_adempimento.trace_add('write', aggiorna_percorso)
    
        # Avvio aggiornamento iniziale
        aggiorna_percorso()
    
        filename_entry.focus_set()
        root.focus_force()
        root.mainloop()
    
        # Qui ritorna valori fittizi per esempio
        full_path = os.path.normpath(os.path.join(var_folder.get(), var_filename.get()))
        azienda_cod = next(a[0] for a in aziende if a[1] == var_azienda.get())
        ademp_cod = next(a[0] for a in adempimenti if a[1] == var_adempimento.get())
    
        return full_path, azienda_cod, ademp_cod
    

    Prova a eseguire questo codice da solo.

    Se funzionerà, allora il problema è altrove nel contesto.


    Conclusione

    • Inserisci stampe di debug ovunque
    • Gestisci eccezioni nel callback della GUI aggiorna_percorso
    • Assicurati che i valori usati siano definiti e non None
    • Verifica il flag -topmost
    • Prova codice ridotto isolato come sopra

    Se vuoi, ti aiuto a integrare step by step.
    Fammi sapere!

  11. User

    preselected_azienda_cod_orig = preselected_azienda_cod preselected_adempimento_cod_orig = preselected_adempimento_cod

    se la selezione avviene dopo come lo gestisci

  12. Assistant

    Ottima domanda: se le variabili preselected_azienda_cod e preselected_adempimento_cod vengono valorizzate dopo, cioè non subito all’apertura della GUI ma dopo una chiamata a DB o altro, bisogna gestire questo scenario per usare correttamente il "valore originale" di partenza.


    Perché serve memorizzare i valori "originali"?

    Il meccanismo che ti ho suggerito in precedenza si basa sul confronto dei valori attuali di combo-box con quelli iniziali per decidere se usare il nome passato da salvataggio precedente o il nome da DB:

    • Se l’utente non cambia azienda/adempimento: mostri nome salvato
    • Se l’utente cambia: mostri nuovo nome da DB

    Quindi il valore "originario" va stabilito una volta sola, all’avvio, per poter fare il confronto.


    Se la selezione arriva dopo?

    Hai alcune opzioni pratiche:

    Opzione 1: Memorizza "al volo" al primo aggiornamento

    All’avvio della GUI la variabile preselected_azienda_cod potrebbe essere None.
    In aggiorna_percorso puoi fare così:

    # Dentro custom_save_gui, fuori aggiorna_percorso
    preselected_azienda_cod_orig = None
    preselected_adempimento_cod_orig = None
    
    def aggiorna_percorso(*args):
        nonlocal preselected_azienda_cod_orig, preselected_adempimento_cod_orig
    
        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 = ademp_selezionato[0]
    
            # Se non ancora valorizzati, li imposto ora come valori originali
            if preselected_azienda_cod_orig is None:
                preselected_azienda_cod_orig = codice_az
            if preselected_adempimento_cod_orig is None:
                preselected_adempimento_cod_orig = codice_ad
    
            # Ora proseguo con la logica precedente...
    
            if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path:
                filename = ademp_selezionato[3] if ademp_selezionato[3].strip() else default_name
            else:
                filename = os.path.basename(saved_full_path)
    
            if not filename.lower().endswith(default_ext.lower()):
                filename += default_ext
    
            var_filename.set(filename)
    
        except Exception as e:
            print("Errore in aggiorna_percorso:", e)
    

    Vantaggi:

    • La prima volta che la funzione è chiamata preselected_... vengono settati ai valori correnti della selezione.
    • I successivi confronti sono comparazioni contro questi valori “a regime”.
    • Funziona anche se la selezione prevista arriva dopo qualche secondo (ad esempio caricamenti DB).

    Opzione 2: Forzare il valore originario prima di aprire la GUI

    Se sai che per esempio preselected_azienda_cod e preselected_adempimento_cod possono arrivare solo dopo una chiamata al DB asincrona o successiva, aspetta di averli prima di aprire la GUI, es:

    while preselected_azienda_cod is None or preselected_adempimento_cod is None:
        time.sleep(0.1)
    # ora avvia custom_save_gui con questi valori già definiti.
    
    ...
    
    # Oppure passa già dentro custom_save_gui i valori originari come parametro aggiuntivo
    

    Opzione 3: Passa esplicitamente valori originari validi a custom_save_gui

    Modifica la signature di custom_save_gui:

    def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None,
                        preselected_azienda_cod_orig=None, preselected_adempimento_cod_orig=None):
        ...
    

    E dentro aggiorna_percorso in questo modo:

    def aggiorna_percorso(*args):
        ...
        if preselected_azienda_cod_orig is None:
            # Se non disponibile prendo valore dalla combinazione corrente (o altra logica)
            preselected_azienda_cod_orig = codice_az
        if preselected_adempimento_cod_orig is None:
            preselected_adempimento_cod_orig = codice_ad
    
        # il resto come sopra
    

    Consiglio

    Se la selezione predefinita arriva dopo l’apertura GUI, in generale meglio far partire la GUI solo dopo che le informazioni siano disponibili, o almeno passare esplicitamente i valori originali per evitare ambiguità.

    Se ciò non è possibile, l’opzione 1 con memorizzazione “al volo” è comunque abbastanza funzionale e semplice da implementare.


    Se vuoi posso aiutarti con la modifica del codice completo in base alla soluzione che preferisci. Fammi sapere!

  13. User

    la tua logica non funziona, perche poi richiede anche il percorso. la cosa più sensata è salvare il nome fil in una varibale e qualora si faccia più volte salva con nome usa sempre lo stesso nome per quel file

  14. Assistant

    Perfetto, grazie per la precisazione!

    Hai ragione: se il tuo obiettivo è più semplice — ovvero che alla seconda (e successive) chiamate di "salva con nome" per lo stesso file venga riproposto sempre lo stesso nome file usato al primo salvataggio, indipendentemente da azienda o adempimento — allora:


    La soluzione più semplice:

    • Mantieni in memoria (ad esempio in unique_id_to_save_data) il percorso (o solo il nome file) associato a quel unique_id (cioè a quel processo o flusso di lavoro).

    • Quando richiami la GUI, se questo valore è presente, passa quel nome/file salvato come valore iniziale da mostrare (in var_filename).

    • Semplicemente evita di sovrascrivere quel valore con il nome preso dal DB.


    Esempio di modifica essenziale

    In monitor_save_dialog(), quando chiami custom_save_gui(), passa:

    saved_path = unique_id_to_save_data.get(unique_id)  # percorso completo
    
    default_name = None
    initial_folder = None
    if saved_path:
        initial_folder = os.path.dirname(saved_path)
        default_name = os.path.basename(saved_path)
        ext = detect_default_extension(process_name)
        if not default_name.lower().endswith(ext.lower()):
            default_name += ext
    else:
        ext = detect_default_extension(process_name)
        default_name = "file" + ext
    

    Quindi chiami:

    result = custom_save_gui(ext, [], default_name, initial_folder)
    

    Nel custom_save_gui()

    NON sovrascrivere più il valore var_filename dentro la funzione aggiorna_percorso()!

    Invece di fare:

    filename = nome_file if nome_file.strip() else default_name
    var_filename.set(filename)
    

    fai solo:

    # Solo all'avvio (all'inizio di custom_save_gui)
    var_filename = tk.StringVar(value=default_name)
    # e in aggiorna_percorso NON modificare più var_filename
    

    O più semplicemente toglie la riga che sovrascrive la variabile con il nome da DB.


    Perché funziona?

    • Il nome passato come default_name è sempre quello originario salvato (se esiste), quindi la GUI parte sempre da quel nome.

    • Non viene più sostituito in automatico in base ad azienda/adempimento.


    Codice riassuntivo semplificato in custom_save_gui

    var_filename = tk.StringVar(value=default_name)  # Impostato solo all'inizio, mai più modificato
    
    def aggiorna_percorso(*args):
        try:
            # aggiorna solo var_folder e altre cose, ma NON var_filename
            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())
            cartella_salvataggio = ademp_selezionato[2]
    
            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)
    
        except Exception:
            pass
    

    In sintesi:

    • L’impostazione ed eventuale aggiornamento del nome file è solo all’inizio con il nome già salvato.

    • Successive modifiche alla combo di azienda / adempimento non cambiano il nome file.


    Se vuoi posso anche prepararti un esempio di patch completa da integrare.


    Dimmi se ti va bene così!

  15. User

    COSA FA QUESTA parte di codice : 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)
    
  16. Assistant

    Questa parte di codice:

    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)
    

    fa le seguenti cose:

    1. Seleziona il nome file da usare (filename):

      • Controlla se la variabile nome_file (solitamente il nome file predefinito preso dal database o da qualche fonte) contiene una stringa non vuota (usando il metodo .strip() che rimuove spazi bianchi agli estremi).
      • Se nome_file non è vuoto, allora filename viene impostato a nome_file.
      • Altrimenti (nome_file è vuoto o costituito da soli spazi), filename viene impostato a default_name (un nome file di default passato alla funzione).
    2. Verifica ed eventualmente aggiunge l’estensione al nome file:

      • Controlla se il nome file (filename) termina già con l’estensione default_ext (ignorando maiuscole/minuscole).
      • Se non termina con default_ext, l’estensione viene aggiunta alla fine del nome file.
    3. Imposta il valore della variabile Tkinter var_filename:

      • var_filename è una StringVar che controlla il contenuto di un campo di testo (ad es. la casella di testo dove mostrare/modificare il nome del file nella GUI).
      • Con var_filename.set(filename) aggiorna quel campo con il nome file appena calcolato.

    In sintesi:

    • Imposto un nome file da mostrare, scegliendo tra quello “standard” (nome_file) o uno di default
    • Controllo che il nome file abbia l’estensione giusta, la aggiungo se manca
    • Aggiorno il campo testo della GUI con quel nome file

    Se vuoi, posso aiutarti anche a rivedere questa logica per farla più robusta o più adatta al tuo caso d’uso!