import tkinter as tk

root = tk.Tk()

# Titolo della finestra
root.title("La mia prima app")

# Dimensioni: larghezza x altezza
root.geometry("500x350")

# Posizione: 500x350 partendo da (100, 100)
root.geometry("500x350+100+100")

# Colore di sfondo
root.configure(bg="#f0f0f0")

# Impedisci il ridimensionamento
root.resizable(False, False)

# Dimensione minima
root.minsize(300, 200)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Hello World!")
root.geometry("400x200")

# Crea una Label
label = tk.Label(
    root,                          # contenitore padre
    text="Ciao, Tkinter! 👋",
    font=("Arial", 20, "bold"),  # (font, dimensione, stile)
    fg="#2563eb",                  # colore testo (foreground)
    bg="#eff6ff"                   # colore sfondo
)

# Mostra la label nella finestra
label.pack(pady=50)

root.mainloop()

import tkinter as tk

def saluta():
    print("Bottone cliccato!")

root = tk.Tk()
root.geometry("300x200")

btn = tk.Button(
    root,
    text="Clicca qui!",
    command=saluta,          # funzione da chiamare al click
    bg="#2563eb",
    fg="white",
    font=("Arial", 12),
    padx=20,
    pady=8,
    relief="flat",           # stile bordo: flat, raised, sunken
    cursor="hand2"          # cursore al passaggio del mouse
)
btn.pack(pady=60)

root.mainloop()

import tkinter as tk

root = tk.Tk()

# Crea l'Entry
entry = tk.Entry(root, width=30, font=("Arial", 14))
entry.pack(pady=20)

# Testo placeholder manuale
entry.insert(0, "Scrivi qualcosa...")

def leggi_testo():
    testo = entry.get()        # legge il valore
    print(f"Hai scritto: {testo}")

def svuota():
    entry.delete(0, tk.END)    # cancella tutto

tk.Button(root, text="Leggi", command=leggi_testo).pack()
tk.Button(root, text="Svuota", command=svuota).pack()

root.mainloop()

import tkinter as tk

root = tk.Tk()

# Checkbutton — variabile collegata BooleanVar
var_check = tk.BooleanVar()
check = tk.Checkbutton(root, text="Accetta termini", variable=var_check)
check.pack()

# Radiobutton — variabile collegata StringVar
var_radio = tk.StringVar(value="python")
tk.Radiobutton(root, text="Python", variable=var_radio, value="python").pack()
tk.Radiobutton(root, text="Java",   variable=var_radio, value="java").pack()
tk.Radiobutton(root, text="C++",    variable=var_radio, value="cpp").pack()

def mostra():
    print(var_check.get(), var_radio.get())

tk.Button(root, text="Mostra selezione", command=mostra).pack(pady=10)
root.mainloop()

import tkinter as tk

root = tk.Tk()

# Crea il Text (larghezza in caratteri, altezza in righe)
txt = tk.Text(root, width=40, height=8, font=("Consolas", 12))
txt.pack(padx=10, pady=10)

# Inserisci testo da codice
txt.insert(tk.END, "Prima riga\nSeconda riga\n")

# Leggi tutto il contenuto
contenuto = txt.get("1.0", tk.END)   # "1.0" = riga 1, colonna 0

# Leggi una riga specifica
riga2 = txt.get("2.0", "2.end")

# Cancella tutto
txt.delete("1.0", tk.END)

# Rendi il testo di sola lettura
txt.config(state=tk.DISABLED)

root.mainloop()

import tkinter as tk

root = tk.Tk()

# Frame con listbox + scrollbar
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)

scrollbar = tk.Scrollbar(frame, orient="vertical")
lb = tk.Listbox(frame, height=6, yscrollcommand=scrollbar.set,
               selectmode=tk.SINGLE)  # o tk.MULTIPLE
scrollbar.config(command=lb.yview)

lb.pack(side="left")
scrollbar.pack(side="right", fill="y")

# Aggiungi elementi
linguaggi = ["Python", "Java", "C++", "JavaScript", "Go", "Rust"]
for lang in linguaggi:
    lb.insert(tk.END, lang)

def leggi_selezione():
    idx = lb.curselection()    # tupla degli indici selezionati
    if idx:
        print(lb.get(idx[0]))   # testo dell'elemento selezionato

tk.Button(root, text="Mostra selezionato",
         command=leggi_selezione).pack(pady=6)

root.mainloop()

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Combobox")

# ── Combobox base ──
# values = lista delle voci nel menù a tendina
regioni = ["Lombardia", "Lazio", "Veneto",
           "Campania", "Toscana", "Sicilia"]

ttk.Label(root, text="Seleziona regione:").pack(pady=5)
combo = ttk.Combobox(root, values=regioni, width=20)
combo.set("Scegli...")      # testo iniziale
combo.pack(pady=5)

# ── Combobox in sola lettura (non modificabile) ──
combo_ro = ttk.Combobox(root,
    values=["Python", "JavaScript", "C#", "Java"],
    state="readonly",       # l'utente può SOLO scegliere dalla lista
    width=20
)
combo_ro.current(0)          # seleziona voce all'indice 0
combo_ro.pack(pady=5)

# ── Leggere il valore selezionato ──
def on_select(event):
    valore = combo.get()
    indice = combo.current()    # indice nella lista (-1 se digitato)
    print(f"Selezionato: {valore} (indice {indice})")

# evento <<ComboboxSelected>> scatta quando si sceglie una voce
combo.bind("<<ComboboxSelected>>", on_select)

# ── Aggiornare la lista dinamicamente ──
def aggiungi_voce():
    combo["values"] = list(combo["values"]) + ["Sardegna"]

ttk.Button(root, text="Aggiungi Sardegna",
           command=aggiungi_voce).pack(pady=5)

root.mainloop()

import tkinter as tk

root = tk.Tk()

# side: TOP (default), BOTTOM, LEFT, RIGHT
tk.Label(root, text="In alto",   bg="#fca5a5").pack(side="top",    fill="x", pady=5)
tk.Label(root, text="Sinistra", bg="#86efac").pack(side="left",   fill="y", padx=5)
tk.Label(root, text="Destra",   bg="#93c5fd").pack(side="right",  fill="y", padx=5)
tk.Label(root, text="Centro",   bg="#fde68a").pack(expand=True)

# fill: "x", "y", "both", None
# expand: True/False — occupa spazio extra disponibile

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Form con Grid")

# Etichette — colonna 0
tk.Label(root, text="Nome:").grid(row=0, column=0, sticky="e", padx=10, pady=8)
tk.Label(root, text="Email:").grid(row=1, column=0, sticky="e", padx=10, pady=8)
tk.Label(root, text="Età:").grid(row=2, column=0,  sticky="e", padx=10, pady=8)

# Entry — colonna 1
nome  = tk.Entry(root, width=25)
email = tk.Entry(root, width=25)
eta   = tk.Entry(root, width=25)

nome.grid(row=0, column=1, pady=8)
email.grid(row=1, column=1, pady=8)
eta.grid(row=2,  column=1, pady=8)

# Bottone su 2 colonne
tk.Button(root, text="Invia").grid(row=3, column=0, columnspan=2, pady=12)

# sticky: "n","s","e","w" o combinazioni "nsew" — allineamento
# columnspan: unisce più colonne

root.mainloop()

tk.Label(root, text="Precisione assoluta").place(x=100, y=50)

# oppure con percentuali
tk.Label(root, text="Centrato").place(relx=0.5, rely=0.5, anchor="center")

import tkinter as tk

root = tk.Tk()
contatore = [0]  # lista per mutabilità in closure

lbl = tk.Label(root, text="Clic: 0", font=("Arial", 16))
lbl.pack(pady=20)

def incrementa():
    contatore[0] += 1
    lbl.config(text=f"Clic: {contatore[0]}")

tk.Button(root, text="Clicca!", command=incrementa).pack()
root.mainloop()

import tkinter as tk

root = tk.Tk()
lbl = tk.Label(root, text="Interagisci!", font=("Arial", 14))
lbl.pack(pady=30, padx=30)

# Evento click sinistro del mouse
def al_click(event):
    lbl.config(text=f"Click su ({event.x}, {event.y})")

# Tasto premuto sulla tastiera
def al_tasto(event):
    lbl.config(text=f"Tasto: {event.keysym}")

# Mouse sopra il widget
def al_hover(event):
    lbl.config(bg="#dbeafe")

def al_leave(event):
    lbl.config(bg="SystemButtonFace")

root.bind("<Button-1>", al_click)   # click sinistro
root.bind("<Key>",      al_tasto)   # qualsiasi tasto
lbl.bind("<Enter>",   al_hover)   # mouse entra
lbl.bind("<Leave>",   al_leave)   # mouse esce

root.mainloop()

def cambia_colore(widget, colore):
    widget.config(bg=colore)

# ✅ Corretto — usa lambda
tk.Button(root, text="Rosso",
         command=lambda: cambia_colore(label, "red")).pack()

# ❌ Sbagliato — chiama subito la funzione
tk.Button(root, text="Verde",
         command=cambia_colore(label, "green")).pack()

import tkinter as tk

root = tk.Tk()

# StringVar collegata all'Entry
nome_var = tk.StringVar()
entry = tk.Entry(root, textvariable=nome_var)
entry.pack(pady=10)

# Label che mostra il valore automaticamente
lbl = tk.Label(root, textvariable=nome_var, fg="blue")
lbl.pack()

# Modificare la variabile da codice
def imposta():
    nome_var.set("Mario Rossi")  # aggiorna entry e label!

def leggi():
    print(nome_var.get())         # legge il valore

tk.Button(root, text="Imposta", command=imposta).pack()
tk.Button(root, text="Leggi",   command=leggi).pack()

root.mainloop()

import tkinter as tk

root = tk.Tk()
testo = tk.StringVar()

# Callback chiamata ogni volta che la var cambia
def on_change(*args):
    val = testo.get()
    lunghezza.config(text=f"Caratteri: {len(val)}")

# "w" = write (quando viene scritto)
testo.trace("w", on_change)

tk.Entry(root, textvariable=testo, width=30).pack(pady=10)
lunghezza = tk.Label(root, text="Caratteri: 0")
lunghezza.pack()

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Finestra Principale")

def apri_finestra():
    top = tk.Toplevel(root)         # finestra secondaria
    top.title("Finestra Secondaria")
    top.geometry("300x150")
    top.transient(root)             # legata alla finestra padre
    top.grab_set()                   # blocca la finestra padre (modale)

    tk.Label(top, text="Ciao dalla finestra secondaria!").pack(pady=20)
    tk.Button(top, text="Chiudi", command=top.destroy).pack()

    root.wait_window(top)             # aspetta che si chiuda

tk.Button(root, text="Apri finestra", command=apri_finestra).pack(pady=50)
root.mainloop()

from tkinter import messagebox, simpledialog, filedialog

# Messaggi
messagebox.showinfo("Info", "Operazione completata!")
messagebox.showwarning("Attenzione", "Controlla i dati")
messagebox.showerror("Errore", "Qualcosa è andato storto")

# Domanda sì/no — restituisce True/False
risposta = messagebox.askyesno("Conferma", "Vuoi continuare?")

# Input di testo
nome = simpledialog.askstring("Input", "Come ti chiami?")
eta  = simpledialog.askinteger("Input", "Quanti anni hai?")

# Apri file
percorso = filedialog.askopenfilename(
    title="Seleziona file",
    filetypes=[("File di testo", "*.txt"), ("Tutti", "*.*")]
)

# Salva file
salva = filedialog.asksaveasfilename(defaultextension=".txt")

import tkinter as tk
from tkinter import messagebox

root = tk.Tk()

# Barra del menu principale
menubar = tk.Menu(root)

# Menu File
file_menu = tk.Menu(menubar, tearoff=0)
file_menu.add_command(label="Nuovo",    accelerator="Ctrl+N")
file_menu.add_command(label="Apri",     accelerator="Ctrl+O")
file_menu.add_separator()
file_menu.add_command(label="Esci", command=root.quit)
menubar.add_cascade(label="File", menu=file_menu)

# Menu Aiuto
help_menu = tk.Menu(menubar, tearoff=0)
help_menu.add_command(label="Info",
    command=lambda: messagebox.showinfo("Info", "v1.0"))
menubar.add_cascade(label="Aiuto", menu=help_menu)

root.config(menu=menubar)
root.mainloop()

import tkinter as tk
from tkinter import messagebox

class Calcolatrice:
    def __init__(self, root):
        self.root = root
        self.root.title("🧮 Calcolatrice")
        self.root.geometry("320x480")
        self.root.resizable(False, False)
        self.root.configure(bg="#1e1e2e")

        # Stato interno
        self.espressione = ""
        self.display_var = tk.StringVar(value="0")
        self.nuovo_numero = True  # dopo un operatore

        self.crea_display()
        self.crea_tasti()
        self.bind_tastiera()

# Avvia l'applicazione
if __name__ == "__main__":
    root = tk.Tk()
    app = Calcolatrice(root)
    root.mainloop()

import tkinter as tk

class Calcolatrice:
    def __init__(self, root):
        self.root = root
        self.root.title("🧮 Calcolatrice")
        self.root.geometry("320x480")
        self.root.resizable(False, False)
        self.root.configure(bg="#1e1e2e")
        self.espressione = ""
        self.display_var = tk.StringVar(value="0")
        self.nuovo_numero = True
        self.crea_display()
        self.crea_tasti()
        self.bind_tastiera()

    def crea_display(self):
        f = tk.Frame(self.root, bg="#1e1e2e")
        f.pack(fill="x", padx=12, pady=12)
        self.lbl_expr = tk.Label(f, text="", font=("Consolas",12),
            fg="#6c7086", bg="#1e1e2e", anchor="e")
        self.lbl_expr.pack(fill="x")
        tk.Label(f, textvariable=self.display_var, font=("Consolas",36,"bold"),
            fg="#cdd6f4", bg="#1e1e2e", anchor="e").pack(fill="x")
        tk.Frame(self.root, bg="#313244", height=1).pack(fill="x", padx=12)

    def crea_tasti(self):
        layout = [
            ("C",0,0,1,"fn"),(  "±",0,1,1,"fn"),("%",0,2,1,"op"),("÷",0,3,1,"op"),
            ("7",1,0,1,"num"),("8",1,1,1,"num"),("9",1,2,1,"num"),("×",1,3,1,"op"),
            ("4",2,0,1,"num"),("5",2,1,1,"num"),("6",2,2,1,"num"),("-",2,3,1,"op"),
            ("1",3,0,1,"num"),("2",3,1,1,"num"),("3",3,2,1,"num"),("+",3,3,1,"op"),
            ("0",4,0,2,"num"),(".",4,2,1,"num"),("=",4,3,1,"eq"),
        ]
        C = {"num":("#313244","#45475a"),"op":("#f38ba8","#eba0ac"),
             "fn":("#45475a","#585b70"), "eq":("#a6e3a1","#94e2d5")}
        f = tk.Frame(self.root, bg="#1e1e2e")
        f.pack(fill="both", expand=True, padx=12, pady=12)
        [f.columnconfigure(i,weight=1) for i in range(4)]
        [f.rowconfigure(i,weight=1) for i in range(5)]
        for (t,r,c,s,tipo) in layout:
            bg,hov = C[tipo]
            fg = "#1e1e2e" if tipo in ("eq","op") else "#cdd6f4"
            b = tk.Button(f, text=t, font=("Consolas",18,"bold"),
                bg=bg,fg=fg,activebackground=hov,relief="flat",bd=0,
                cursor="hand2",command=lambda x=t: self.premi(x))
            b.grid(row=r,column=c,columnspan=s,sticky="nsew",padx=3,pady=3)
            b.bind("<Enter>",lambda e,b=b,h=hov: b.config(bg=h))
            b.bind("<Leave>",lambda e,b=b,n=bg: b.config(bg=n))

    def premi(self, t):
        if t == "C":
            self.espressione = ""; self.display_var.set("0")
            self.lbl_expr.config(text=""); self.nuovo_numero = True
        elif t == "±":
            try: self.display_var.set(str(-float(self.display_var.get())))
            except: pass
        elif t == "%":
            try: self.display_var.set(str(float(self.display_var.get())/100))
            except: pass
        elif t == "=":
            try:
                expr = (self.espressione+self.display_var.get()).replace("×","*").replace("÷","/")
                self.lbl_expr.config(text=expr+" =")
                r = eval(expr)
                self.display_var.set(str(int(r) if r==int(r) else r))
                self.espressione = ""; self.nuovo_numero = True
            except ZeroDivisionError:
                self.display_var.set("Errore: ÷0"); self.espressione = ""
            except:
                self.display_var.set("Errore"); self.espressione = ""
        elif t in "+-×÷":
            self.espressione += self.display_var.get()+t
            self.lbl_expr.config(text=self.espressione); self.nuovo_numero = True
        else:
            if self.nuovo_numero:
                self.display_var.set(t); self.nuovo_numero = False
            else:
                v = self.display_var.get()
                if t=="." and "." in v: return
                self.display_var.set(t if v=="0" and t!="." else v+t)

    def bind_tastiera(self):
        for k in "0123456789.":
            self.root.bind(f"<{k}>", lambda e,t=k: self.premi(t))
        self.root.bind("<Return>",   lambda e: self.premi("="))
        self.root.bind("<Escape>",   lambda e: self.premi("C"))
        self.root.bind("<plus>",     lambda e: self.premi("+"))
        self.root.bind("<minus>",    lambda e: self.premi("-"))
        self.root.bind("<asterisk>", lambda e: self.premi("×"))
        self.root.bind("<slash>",    lambda e: self.premi("÷"))

if __name__ == "__main__":
    root = tk.Tk()
    Calcolatrice(root)
    root.mainloop()

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Widget ttk")
root.geometry("400x300")

# ttk.Button — aspetto nativo
ttk.Button(root, text="Bottone ttk").pack(pady=10)

# ttk.Entry
ttk.Entry(root, width=25).pack(pady=5)

# ttk.Combobox — menù a tendina
combo = ttk.Combobox(root, values=["Python", "Java", "C++"])
combo.set("Seleziona linguaggio")
combo.pack(pady=5)

# ttk.Progressbar
pb = ttk.Progressbar(root, length=200, mode="determinate")
pb.pack(pady=10)
pb["value"] = 65  # 65%

# ttk.Scale — slider
ttk.Scale(root, from_=0, to=100, orient="horizontal").pack(pady=5)

# ttk.Notebook — schede/tab
nb = ttk.Notebook(root)
tab1 = ttk.Frame(nb)
tab2 = ttk.Frame(nb)
nb.add(tab1, text="Scheda 1")
nb.add(tab2, text="Scheda 2")
nb.pack(expand=True, fill="both", pady=10)

root.mainloop()

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.configure(bg="#1a1a2e")

# Crea oggetto Style
style = ttk.Style()

# Scegli un tema di base
print(style.theme_names())  # ('winnative', 'clam', 'alt', 'default', ...)
style.theme_use("clam")       # tema più personalizzabile

# Personalizza il Button
style.configure(
    "Accent.TButton",      # nome stile personalizzato
    background="#7c6af7",
    foreground="white",
    font=("Syne", 12, "bold"),
    padding=(12, 6),
    borderwidth=0
)
style.map("Accent.TButton",
    background=[("active", "#9b8bff")]  # hover
)

# Applica lo stile
ttk.Button(root, text="Bottone Accent",
          style="Accent.TButton").pack(pady=30)

# Personalizza Label
style.configure("Dark.TLabel",
    background="#1a1a2e",
    foreground="#cdd6f4",
    font=("Consolas", 14)
)
ttk.Label(root, text="Label scura",
         style="Dark.TLabel").pack()

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Canvas Demo")

# Crea il canvas
canvas = tk.Canvas(root, width=500, height=400, bg="#1e1e2e")
canvas.pack()

# Rettangolo: (x1,y1, x2,y2)
canvas.create_rectangle(50, 50, 150, 120,
    fill="#7c6af7", outline="#9b8bff", width=2)

# Ovale/Cerchio
canvas.create_oval(200, 50, 320, 170,
    fill="#a6e3a1", outline="white")

# Linea
canvas.create_line(50, 200, 450, 200,
    fill="#f38ba8", width=3, dash=(10, 5))

# Poligono (triangolo)
canvas.create_polygon(250, 230, 200, 320, 300, 320,
    fill="#f7a26a", outline="white", width=2)

# Testo sul canvas
canvas.create_text(250, 370,
    text="Canvas Tkinter!",
    font=("Consolas", 16, "bold"),
    fill="#cdd6f4")

root.mainloop()

import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(root, width=400, height=300, bg="#1e1e2e")
canvas.pack()

# L'ID viene restituito alla creazione
cerchio = canvas.create_oval(150, 100, 250, 200, fill="#7c6af7")

def sposta():
    # Sposta di 10px a destra e 5px in basso
    canvas.move(cerchio, 10, 5)

def cambia_colore():
    canvas.itemconfig(cerchio, fill="#f38ba8")

def elimina():
    canvas.delete(cerchio)

def pulisci_tutto():
    canvas.delete("all")  # cancella TUTTO

tk.Button(root, text="Sposta",        command=sposta).pack(side="left", padx=4)
tk.Button(root, text="Cambia colore", command=cambia_colore).pack(side="left", padx=4)
tk.Button(root, text="Elimina",      command=elimina).pack(side="left", padx=4)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Mini Paint")

colore_attuale = ["#7c6af7"]
spessore = [4]
prev_x = prev_y = [None]

canvas = tk.Canvas(root, width=600, height=400, bg="white", cursor="crosshair")
canvas.pack()

def disegna(event):
    if prev_x[0] is not None:
        canvas.create_line(
            prev_x[0], prev_y[0], event.x, event.y,
            fill=colore_attuale[0], width=spessore[0],
            capstyle=tk.ROUND, smooth=True
        )
    prev_x[0], prev_y[0] = event.x, event.y

def reset_prev(event):
    prev_x[0] = prev_y[0] = None

canvas.bind("<B1-Motion>", disegna)
canvas.bind("<ButtonRelease-1>", reset_prev)

# Barra strumenti colori
barra = tk.Frame(root, bg="#f0f0f0")
barra.pack(fill="x")

colori = ["#7c6af7", "#f38ba8", "#a6e3a1", "#f7a26a", "black", "white"]
for c in colori:
    tk.Button(barra, bg=c, width=3,
             command=lambda x=c: colore_attuale.__setitem__(0, x)).pack(side="left", padx=2, pady=4)

tk.Button(barra, text="🗑 Pulisci",
         command=lambda: canvas.delete("all")).pack(side="right", padx=8)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Palla Rimbalzante")

canvas = tk.Canvas(root, width=500, height=400, bg="#1e1e2e")
canvas.pack()

# Posizione e velocità
x, y = 250, 200
dx, dy = 4, 3
r = 25

palla = canvas.create_oval(x-r, y-r, x+r, y+r, fill="#7c6af7", outline="")

def anima():
    global x, y, dx, dy

    x += dx
    y += dy

    # Rimbalzo sui bordi
    if x - r <= 0 or x + r >= 500: dx = -dx
    if y - r <= 0 or y + r >= 400: dy = -dy

    # Aggiorna posizione
    canvas.coords(palla, x-r, y-r, x+r, y+r)

    # Chiama se stessa ogni 16ms (~60fps)
    root.after(16, anima)

anima()  # avvia il loop
root.mainloop()

from tkinter import ttk
import tkinter as tk

root = tk.Tk()
valore = tk.DoubleVar()
pb = ttk.Progressbar(root, variable=valore, maximum=100, length=300)
pb.pack(pady=30, padx=30)

lbl = tk.Label(root, text="0%", font=("Consolas", 14))
lbl.pack()

def avanza():
    v = valore.get()
    if v < 100:
        valore.set(v + 1)
        lbl.config(text=f"{int(v+1)}%")
        root.after(30, avanza)
    else:
        lbl.config(text="✅ Completato!")

tk.Button(root, text="Avvia caricamento",
    command=lambda: [valore.set(0), avanza()]).pack(pady=10)

root.mainloop()

import sqlite3

# Connessione (crea il file se non esiste)
conn = sqlite3.connect("rubrica.db")
cur = conn.cursor()

# CREATE — crea la tabella
cur.execute("""
    CREATE TABLE IF NOT EXISTS contatti (
        id    INTEGER PRIMARY KEY AUTOINCREMENT,
        nome  TEXT NOT NULL,
        email TEXT,
        tel   TEXT
    )
""")

# INSERT — aggiungi un contatto
cur.execute("INSERT INTO contatti (nome, email, tel) VALUES (?, ?, ?)",
           ("Mario Rossi", "[email protected]", "333-1234567"))

# SELECT — leggi tutti i contatti
cur.execute("SELECT * FROM contatti")
righe = cur.fetchall()
for riga in righe:
    print(riga)

# UPDATE
cur.execute("UPDATE contatti SET tel=? WHERE nome=?",
           ("333-9999999", "Mario Rossi"))

# DELETE
cur.execute("DELETE FROM contatti WHERE id=?", (1,))

conn.commit()   # salva le modifiche
conn.close()    # chiudi la connessione

import tkinter as tk
from tkinter import ttk, messagebox
import sqlite3

class RubricaApp:
    def __init__(self, root):
        self.root = root
        self.root.title("📒 Rubrica")
        self.root.geometry("620x480")
        self.root.configure(bg="#f8fafc")
        self.init_db()
        self.crea_ui()
        self.carica_contatti()

    def init_db(self):
        # Inizializza il database
        self.conn = sqlite3.connect("rubrica.db")
        self.cur = self.conn.cursor()
        self.cur.execute("""
            CREATE TABLE IF NOT EXISTS contatti (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nome TEXT NOT NULL,
                email TEXT, tel TEXT
            )""")
        self.conn.commit()

    def crea_ui(self):
        # Frame form in alto
        form = tk.LabelFrame(self.root, text=" Nuovo Contatto ",
                               font=("Arial",10,"bold"), bg="#f8fafc")
        form.pack(fill="x", padx=16, pady=12)

        etichette = ["Nome:", "Email:", "Telefono:"]
        self.campi = {}
        for i, et in enumerate(etichette):
            tk.Label(form, text=et, bg="#f8fafc").grid(row=i, column=0, sticky="e", padx=8, pady=5)
            chiave = et[:-1].lower()
            e = ttk.Entry(form, width=30)
            e.grid(row=i, column=1, pady=5, padx=4)
            self.campi[chiave] = e

        btn_frame = tk.Frame(form, bg="#f8fafc")
        btn_frame.grid(row=3, column=0, columnspan=2, pady=8)
        tk.Button(btn_frame, text="➕ Aggiungi", command=self.aggiungi,
            bg="#7c6af7", fg="white", relief="flat", padx=12).pack(side="left", padx=4)
        tk.Button(btn_frame, text="🗑 Elimina selezionato", command=self.elimina,
            bg="#f38ba8", fg="white", relief="flat", padx=12).pack(side="left", padx=4)

        # Tabella contatti (Treeview)
        cols = ("ID", "Nome", "Email", "Telefono")
        self.tree = ttk.Treeview(self.root, columns=cols,
                                   show="headings", height=12)
        for c in cols:
            self.tree.heading(c, text=c)
            self.tree.column(c, width=60 if c=="ID" else 160)
        self.tree.pack(fill="both", expand=True, padx=16, pady=4)

    def carica_contatti(self):
        for i in self.tree.get_children():
            self.tree.delete(i)
        self.cur.execute("SELECT * FROM contatti ORDER BY nome")
        for riga in self.cur.fetchall():
            self.tree.insert("", tk.END, values=riga)

    def aggiungi(self):
        nome  = self.campi["nome"].get().strip()
        email = self.campi["email"].get().strip()
        tel   = self.campi["telefono"].get().strip()
        if not nome:
            messagebox.showwarning("Attenzione", "Il nome è obbligatorio!")
            return
        self.cur.execute("INSERT INTO contatti (nome,email,tel) VALUES (?,?,?)",
                         (nome, email, tel))
        self.conn.commit()
        for e in self.campi.values(): e.delete(0, tk.END)
        self.carica_contatti()

    def elimina(self):
        sel = self.tree.selection()
        if not sel:
            messagebox.showinfo("Info", "Seleziona un contatto da eliminare")
            return
        id_cont = self.tree.item(sel[0])["values"][0]
        if messagebox.askyesno("Conferma", "Eliminare questo contatto?"):
            self.cur.execute("DELETE FROM contatti WHERE id=?", (id_cont,))
            self.conn.commit()
            self.carica_contatti()

if __name__ == "__main__":
    root = tk.Tk()
    RubricaApp(root)
    root.mainloop()

# Struttura consigliata per app Tkinter medio-grandi
mia_app/
├── main.py            # entry point
├── model/
│   ├── __init__.py
│   └── database.py    # logica dati
├── view/
│   ├── __init__.py
│   ├── main_view.py   # finestra principale
│   └── dialogs.py     # finestre secondarie
├── controller/
│   ├── __init__.py
│   └── app_ctrl.py    # logica applicazione
└── assets/
    └── style.tcl      # tema personalizzato

import tkinter as tk
from tkinter import ttk
from view.main_view import MainView
from controller.app_ctrl import AppController

class Application(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("La Mia App")
        self.geometry("900x600")
        self.minsize(700, 450)

        # Applica tema ttk
        self.style = ttk.Style(self)
        self.style.theme_use("clam")
        self._configura_tema()

        # Crea controller (che crea la view)
        self.controller = AppController(self)

    def _configura_tema(self):
        self.style.configure(".",
            font=("Segoe UI", 10),
            background="#f0f2f5"
        )
        self.style.configure("TButton",
            padding=(10, 5),
            relief="flat",
            background="#1877f2",
            foreground="white"
        )
        self.style.map("TButton",
            background=[("active", "#166fe5"),
                        ("disabled", "#cccccc")]
        )

if __name__ == "__main__":
    app = Application()
    app.mainloop()

from tkinter import ttk

def applica_tema_scuro(root):
    style = ttk.Style(root)
    style.theme_use("clam")

    # Colori
    BG     = "#1e1e2e"
    BG2    = "#313244"
    FG     = "#cdd6f4"
    ACCENT = "#89b4fa"
    MUTED  = "#585b70"
    RED    = "#f38ba8"
    GREEN  = "#a6e3a1"

    # Sfondo globale
    style.configure(".",
        background=BG, foreground=FG,
        fieldbackground=BG2, troughcolor=BG2,
        selectbackground=ACCENT, selectforeground=BG,
        font=("Consolas", 10)
    )

    # Frame e Label
    style.configure("TFrame", background=BG)
    style.configure("TLabel", background=BG, foreground=FG)
    style.configure("TLabelframe", background=BG, foreground=ACCENT,
                    bordercolor=BG2)
    style.configure("TLabelframe.Label", background=BG,
                    foreground=ACCENT, font=("Consolas", 10, "bold"))

    # Button
    style.configure("TButton",
        background=BG2, foreground=FG,
        bordercolor=MUTED, padding=(8, 4), relief="flat")
    style.map("TButton",
        background=[("active", ACCENT), ("pressed", ACCENT)],
        foreground=[("active", BG)])

    # Accent Button
    style.configure("Accent.TButton",
        background=ACCENT, foreground=BG, font=("Consolas", 10, "bold"))
    style.map("Accent.TButton",
        background=[("active", "#74c7ec")])

    # Entry
    style.configure("TEntry",
        fieldbackground=BG2, foreground=FG,
        insertcolor=FG, bordercolor=MUTED, padding=5)
    style.map("TEntry",
        bordercolor=[("focus", ACCENT)])

    # Combobox
    style.configure("TCombobox",
        fieldbackground=BG2, foreground=FG,
        selectbackground=ACCENT, selectforeground=BG)

    # Notebook (tab)
    style.configure("TNotebook", background=BG, bordercolor=BG2)
    style.configure("TNotebook.Tab",
        background=BG2, foreground=MUTED, padding=(10, 4))
    style.map("TNotebook.Tab",
        background=[("selected", BG)],
        foreground=[("selected", ACCENT)])

    # Treeview
    style.configure("Treeview",
        background=BG2, foreground=FG,
        fieldbackground=BG2, rowheight=26)
    style.configure("Treeview.Heading",
        background=BG, foreground=ACCENT,
        font=("Consolas", 10, "bold"))
    style.map("Treeview",
        background=[("selected", ACCENT)],
        foreground=[("selected", BG)])

    # Progressbar
    style.configure("TProgressbar",
        troughcolor=BG2, background=ACCENT, thickness=8)

    # Scrollbar
    style.configure("TScrollbar",
        troughcolor=BG, background=MUTED, arrowcolor=MUTED)
    style.map("TScrollbar",
        background=[("active", ACCENT)])

    root.configure(bg=BG)
    return style

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.geometry("600x400")

# ── PanedWindow — pannelli ridimensionabili ──
paned = ttk.PanedWindow(root, orient="horizontal")
paned.pack(fill="both", expand=True)

left_frame = ttk.Frame(paned, width=200)
right_frame = ttk.Frame(paned)
paned.add(left_frame, weight=1)
paned.add(right_frame, weight=3)

# ── Spinbox — selettore numerico ──
ttk.Label(left_frame, text="Età:").pack(pady=5)
spinbox = ttk.Spinbox(left_frame, from_=1, to=120,
                       width=8, wrap=True)
spinbox.pack(pady=3)

# ── OptionMenu — menù a tendina semplice ──
lingua = tk.StringVar(value="Italiano")
ttk.Label(left_frame, text="Lingua:").pack(pady=5)
menu = ttk.OptionMenu(left_frame, lingua,
                        "Italiano", "Inglese", "Francese", "Spagnolo")
menu.pack(pady=3)

# ── Scale — slider ──
volume = tk.IntVar(value=50)
ttk.Label(left_frame, text="Volume:").pack(pady=5)
ttk.Scale(left_frame, from_=0, to=100,
          variable=volume, orient="horizontal").pack(pady=3, fill="x", padx=10)

# ── Text con scrollbar integrata ──
txt_frame = ttk.Frame(right_frame)
txt_frame.pack(fill="both", expand=True, padx=10, pady=10)

txt = tk.Text(txt_frame, wrap="word", font=("Consolas", 11))
scrollbar = ttk.Scrollbar(txt_frame, command=txt.yview)
txt.configure(yscrollcommand=scrollbar.set)

txt.pack(side="left", fill="both", expand=True)
scrollbar.pack(side="right", fill="y")

root.mainloop()

import tkinter as tk
from tkinter import ttk

class AppState:
    """Stato condiviso tra tutti i componenti."""
    def __init__(self):
        self.utente_loggato = None
        self.tema = "chiaro"
        self.lingua = "it"
        self._callbacks = {}   # osservatori per il pattern Observer

    def on_change(self, evento, callback):
        """Registra un listener per un evento di stato."""
        self._callbacks.setdefault(evento, []).append(callback)

    def emit(self, evento, data=None):
        """Notifica tutti i listener."""
        for cb in self._callbacks.get(evento, []):
            cb(data)

class MainApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.state = AppState()     # unica sorgente di verità
        self._crea_ui()

    def _crea_ui(self):
        lbl = ttk.Label(self, text="Nessun utente")
        lbl.pack(pady=20)

        # Ascolta cambiamenti di login
        self.state.on_change("login",
            lambda u: lbl.config(text=f"Benvenuto, {u}!"))

        ttk.Button(self, text="Simula login",
            command=lambda: self.state.emit("login", "Mario")).pack()

MainApp().mainloop()

import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(root, width=500, height=400, bg="#f0f2f5")
canvas.pack()

# Crea un rettangolo trascinabile
rect = canvas.create_rectangle(50, 50, 150, 100,
    fill="#1877f2", outline="#0d5bba", width=2)
label = canvas.create_text(100, 75, text="Trascina!", fill="white")

drag_data = {"x": 0, "y": 0}

def start_drag(event):
    drag_data["x"] = event.x
    drag_data["y"] = event.y

def do_drag(event):
    dx = event.x - drag_data["x"]
    dy = event.y - drag_data["y"]
    canvas.move(rect, dx, dy)
    canvas.move(label, dx, dy)
    drag_data["x"] = event.x
    drag_data["y"] = event.y

canvas.tag_bind(rect, "<Button-1>", start_drag)
canvas.tag_bind(rect, "<B1-Motion>", do_drag)
canvas.tag_bind(label, "<Button-1>", start_drag)
canvas.tag_bind(label, "<B1-Motion>", do_drag)

root.mainloop()

# Installa pyodbc
pip install pyodbc

# Installa anche pandas (opzionale, per visualizzare dati)
pip install pandas

# Su Windows: scarica il driver ODBC da Microsoft
# https://learn.microsoft.com/sql/connect/odbc/download-odbc-driver-for-sql-server

# Verifica driver installati
python -c "import pyodbc; print(pyodbc.drivers())"

import pyodbc

# ── Autenticazione Windows (Trusted Connection) ──
conn_str_windows = (
    "DRIVER={ODBC Driver 18 for SQL Server};"
    "SERVER=localhost;"          # o nome server/IP
    "DATABASE=MioDatabase;"
    "Trusted_Connection=yes;"
    "TrustServerCertificate=yes;"
)

# ── Autenticazione SQL (username/password) ──
conn_str_sql = (
    "DRIVER={ODBC Driver 18 for SQL Server};"
    "SERVER=192.168.1.100,1433;"  # IP,porta
    "DATABASE=MioDatabase;"
    "UID=sa;"
    "PWD=MiaPassword123!;"
    "TrustServerCertificate=yes;"
)

# Connessione
try:
    conn = pyodbc.connect(conn_str_windows)
    print("✅ Connesso a SQL Server!")
    cur = conn.cursor()

    # Versione SQL Server
    cur.execute("SELECT @@VERSION")
    print(cur.fetchone()[0])

except pyodbc.Error as e:
    print(f"❌ Errore: {e}")
finally:
    if "conn" in dir(): conn.close()

import pyodbc
from contextlib import contextmanager

class SQLServerManager:
    def __init__(self, server, database, uid=None, pwd=None):
        if uid:
            self.conn_str = (
                f"DRIVER={{ODBC Driver 18 for SQL Server}};"
                f"SERVER={server};DATABASE={database};"
                f"UID={uid};PWD={pwd};TrustServerCertificate=yes;"
            )
        else:
            self.conn_str = (
                f"DRIVER={{ODBC Driver 18 for SQL Server}};"
                f"SERVER={server};DATABASE={database};"
                f"Trusted_Connection=yes;TrustServerCertificate=yes;"
            )
        self._conn = None

    def connetti(self):
        self._conn = pyodbc.connect(self.conn_str, autocommit=False)
        return self

    def disconnetti(self):
        if self._conn:
            self._conn.close()

    def esegui(self, query, params=None):
        """Esegui INSERT/UPDATE/DELETE con commit automatico."""
        cur = self._conn.cursor()
        cur.execute(query, params or [])
        self._conn.commit()
        return cur

    def leggi(self, query, params=None):
        """Esegui SELECT e ritorna tutte le righe."""
        cur = self._conn.cursor()
        cur.execute(query, params or [])
        return cur.fetchall()

    def leggi_uno(self, query, params=None):
        cur = self._conn.cursor()
        cur.execute(query, params or [])
        return cur.fetchone()

    def crea_tabella(self):
        self.esegui("""
            IF NOT EXISTS (
                SELECT * FROM sysobjects
                WHERE name='Dipendenti' AND xtype='U'
            )
            CREATE TABLE Dipendenti (
                Id       INT IDENTITY(1,1) PRIMARY KEY,
                Nome     NVARCHAR(100) NOT NULL,
                Cognome  NVARCHAR(100) NOT NULL,
                Email    NVARCHAR(200) UNIQUE,
                Reparto  NVARCHAR(100),
                Stipendio DECIMAL(10,2),
                DataAssunzione DATE DEFAULT GETDATE()
            )
        """)

import tkinter as tk
from tkinter import ttk, messagebox
import pyodbc

class GestioneDipendenti(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("👥 Gestione Dipendenti")
        self.geometry("1000x600")
        self.configure(bg="#f8fafc")

        # Connessione DB
        self.db = SQLServerManager("localhost", "AziendaDB")
        try:
            self.db.connetti()
            self.db.crea_tabella()
        except Exception as e:
            messagebox.showerror("DB Error", f"Connessione fallita:\n{e}")
            self.destroy(); return

        # Variabili form
        self.var_nome     = tk.StringVar()
        self.var_cognome  = tk.StringVar()
        self.var_email    = tk.StringVar()
        self.var_reparto  = tk.StringVar()
        self.var_stipendio = tk.StringVar()
        self.var_cerca    = tk.StringVar()
        self.id_selezionato = None

        self._build_ui()
        self._carica_dati()

        # Cerca in tempo reale
        self.var_cerca.trace("w", lambda *_: self._carica_dati())

        self.protocol("WM_DELETE_WINDOW", self._chiudi)

    def _build_ui(self):
        # ── Toolbar in cima ──
        toolbar = tk.Frame(self, bg="#1877f2", height=46)
        toolbar.pack(fill="x"); toolbar.pack_propagate(False)

        tk.Label(toolbar, text="👥 Gestione Dipendenti",
               fg="white", bg="#1877f2",
               font=("Segoe UI", 13, "bold")).pack(side="left", padx=16)

        # Cerca
        tk.Label(toolbar, text="🔍", bg="#1877f2", fg="white").pack(side="right", padx=(0,4))
        ttk.Entry(toolbar, textvariable=self.var_cerca, width=20).pack(side="right", pady=8, padx=4)

        # ── Layout principale ──
        main = tk.Frame(self, bg="#f8fafc")
        main.pack(fill="both", expand=True, padx=16, pady=16)

        # Form a sinistra
        form = tk.LabelFrame(main, text=" 📝 Dipendente ",
                              font=("Segoe UI", 10, "bold"), bg="#f8fafc")
        form.pack(side="left", fill="y", padx=(0,12), ipadx=10, ipady=6)

        campi = [("Nome", self.var_nome), ("Cognome", self.var_cognome),
                 ("Email", self.var_email), ("Reparto", self.var_reparto),
                 ("Stipendio", self.var_stipendio)]

        for i, (lbl, var) in enumerate(campi):
            tk.Label(form, text=lbl+":", bg="#f8fafc",
                    anchor="w").grid(row=i, column=0, sticky="w", pady=4)
            ttk.Entry(form, textvariable=var, width=22).grid(
                row=i, column=1, pady=4, padx=6)

        # Bottoni azione
        btn_frame = tk.Frame(form, bg="#f8fafc")
        btn_frame.grid(row=len(campi), column=0, columnspan=2, pady=12)

        for (txt, cmd, bg) in [
            ("➕ Aggiungi",  self._aggiungi,  "#42b72a"),
            ("✏️ Modifica",  self._modifica,  "#1877f2"),
            ("🗑️ Elimina",  self._elimina,   "#fa383e"),
            ("🔄 Reset",    self._reset_form,"#65676b")
        ]:
            tk.Button(btn_frame, text=txt, command=cmd,
                bg=bg, fg="white", relief="flat",
                padx=10, pady=5, cursor="hand2").pack(fill="x", pady=2)

        # Tabella a destra
        cols = ("ID", "Nome", "Cognome", "Email", "Reparto", "Stipendio")
        self.tree = ttk.Treeview(main, columns=cols, show="headings")
        for c, w in zip(cols, [50, 120, 120, 200, 100, 90]):
            self.tree.heading(c, text=c)
            self.tree.column(c, width=w, anchor="center")

        vsb = ttk.Scrollbar(main, orient="vertical", command=self.tree.yview)
        self.tree.configure(yscrollcommand=vsb.set)
        self.tree.pack(side="left", fill="both", expand=True)
        vsb.pack(side="left", fill="y")

        self.tree.bind("<<TreeviewSelect>>", self._seleziona)

    def _carica_dati(self):
        cerca = self.var_cerca.get().strip()
        if cerca:
            q = ("SELECT Id, Nome, Cognome, Email, Reparto, Stipendio "
                 "FROM Dipendenti WHERE Nome LIKE ? OR Cognome LIKE ? OR Reparto LIKE ? "
                 "ORDER BY Cognome")
            righe = self.db.leggi(q, (f"%{cerca}%",)*3)
        else:
            righe = self.db.leggi(
                "SELECT Id, Nome, Cognome, Email, Reparto, Stipendio FROM Dipendenti ORDER BY Cognome")
        for i in self.tree.get_children(): self.tree.delete(i)
        for r in righe:
            self.tree.insert("", tk.END, values=(
                r.Id, r.Nome, r.Cognome, r.Email,
                r.Reparto, f"€{r.Stipendio:,.2f}" if r.Stipendio else ""
            ))

    def _seleziona(self, event):
        sel = self.tree.selection()
        if not sel: return
        vals = self.tree.item(sel[0])["values"]
        self.id_selezionato = vals[0]
        self.var_nome.set(vals[1])
        self.var_cognome.set(vals[2])
        self.var_email.set(vals[3] or "")
        self.var_reparto.set(vals[4] or "")
        self.var_stipendio.set(vals[5].replace("€","").replace(",","") if vals[5] else "")

    def _aggiungi(self):
        if not self.var_nome.get() or not self.var_cognome.get():
            messagebox.showwarning("Attenzione", "Nome e Cognome obbligatori!"); return
        try:
            self.db.esegui(
                "INSERT INTO Dipendenti (Nome,Cognome,Email,Reparto,Stipendio) VALUES (?,?,?,?,?)",
                (self.var_nome.get(), self.var_cognome.get(),
                 self.var_email.get() or None,
                 self.var_reparto.get() or None,
                 float(self.var_stipendio.get()) if self.var_stipendio.get() else None))
            self._carica_dati(); self._reset_form()
        except Exception as e:
            messagebox.showerror("Errore", str(e))

    def _modifica(self):
        if not self.id_selezionato:
            messagebox.showinfo("Info", "Seleziona un dipendente dalla tabella"); return
        try:
            self.db.esegui(
                "UPDATE Dipendenti SET Nome=?,Cognome=?,Email=?,Reparto=?,Stipendio=? WHERE Id=?",
                (self.var_nome.get(), self.var_cognome.get(),
                 self.var_email.get() or None, self.var_reparto.get() or None,
                 float(self.var_stipendio.get()) if self.var_stipendio.get() else None,
                 self.id_selezionato))
            self._carica_dati(); self._reset_form()
        except Exception as e:
            messagebox.showerror("Errore", str(e))

    def _elimina(self):
        if not self.id_selezionato:
            messagebox.showinfo("Info", "Seleziona un dipendente"); return
        if messagebox.askyesno("Conferma", "Eliminare questo dipendente?"):
            self.db.esegui("DELETE FROM Dipendenti WHERE Id=?", (self.id_selezionato,))
            self._carica_dati(); self._reset_form()

    def _reset_form(self):
        for v in [self.var_nome, self.var_cognome, self.var_email,
                   self.var_reparto, self.var_stipendio]:
            v.set("")
        self.id_selezionato = None

    def _chiudi(self):
        self.db.disconnetti()
        self.destroy()

if __name__ == "__main__":
    GestioneDipendenti().mainloop()

# ── JOIN tra tabelle ──
query_join = """
    SELECT d.Nome, d.Cognome, r.NomeReparto, r.Budget
    FROM Dipendenti d
    INNER JOIN Reparti r ON d.Reparto = r.Id
    WHERE r.Budget > 100000
    ORDER BY d.Cognome
"""

# ── Aggregazioni ──
query_stats = """
    SELECT
        Reparto,
        COUNT(*)         AS NumDipendenti,
        AVG(Stipendio)   AS StipendioMedio,
        MAX(Stipendio)   AS StipendioMax,
        SUM(Stipendio)   AS CostoTotale
    FROM Dipendenti
    GROUP BY Reparto
    HAVING COUNT(*) > 2
    ORDER BY CostoTotale DESC
"""

# ── Paginazione (SQL Server 2012+) ──
pagina = 1
per_pagina = 20
query_page = f"""
    SELECT * FROM Dipendenti
    ORDER BY Id
    OFFSET {(pagina-1) * per_pagina} ROWS
    FETCH NEXT {per_pagina} ROWS ONLY
"""

# ── Transazione esplicita ──
try:
    cur = conn.cursor()
    cur.execute("BEGIN TRANSACTION")
    cur.execute("UPDATE Conti SET Saldo = Saldo - ? WHERE Id = ?", (500, 1))
    cur.execute("UPDATE Conti SET Saldo = Saldo + ? WHERE Id = ?", (500, 2))
    conn.commit()        # salva SOLO se entrambe OK
    print("✅ Trasferimento riuscito")
except:
    conn.rollback()     # annulla tutto se errore
    print("❌ Transazione annullata")

import pyodbc

conn = pyodbc.connect(conn_str)
cur = conn.cursor()

# ── Chiamare una Stored Procedure senza parametri ──
cur.execute("EXEC sp_GetAllDipendenti")
righe = cur.fetchall()

# ── Con parametri di input ──
cur.execute("EXEC sp_GetDipendentiByReparto @Reparto=?", ("IT",))
righe = cur.fetchall()

# ── Con parametro di output ──
cur.execute("""
    DECLARE @Totale INT;
    EXEC sp_ContaDipendenti @Reparto=?, @Totale=@Totale OUTPUT;
    SELECT @Totale;
""", ("IT",))
totale = cur.fetchval()
print(f"Dipendenti IT: {totale}")

# ── Esempio: creare una SP direttamente da Python ──
cur.execute("""
    IF OBJECT_ID('sp_GetDipendentiByReparto') IS NOT NULL
        DROP PROCEDURE sp_GetDipendentiByReparto
""")
cur.execute("""
    CREATE PROCEDURE sp_GetDipendentiByReparto
        @Reparto NVARCHAR(100)
    AS
    BEGIN
        SELECT Id, Nome, Cognome, Email, Stipendio
        FROM Dipendenti
        WHERE Reparto = @Reparto
        ORDER BY Cognome, Nome
    END
""")
conn.commit()

import pyodbc
from tkinter import messagebox

def esegui_sicuro(conn, query, params=None):
    """Wrapper con gestione errori completa."""
    try:
        cur = conn.cursor()
        cur.execute(query, params or [])
        conn.commit()
        return True, cur
    except pyodbc.IntegrityError as e:
        conn.rollback()
        # Violazione UNIQUE, FK, NOT NULL ecc.
        messagebox.showerror("Errore dati",
            f"Dato duplicato o non valido:\n{e.args[1]}")
        return False, None
    except pyodbc.OperationalError as e:
        conn.rollback()
        # Connessione persa, timeout ecc.
        messagebox.showerror("Errore connessione",
            f"Problema con il database:\n{e.args[1]}\n\nRiprova tra poco.")
        return False, None
    except pyodbc.ProgrammingError as e:
        conn.rollback()
        # Errore SQL (tabella non trovata, sintassi ecc.)
        messagebox.showerror("Errore SQL", str(e))
        return False, None

# Codici di errore SQL Server comuni
ERRORI_SQL = {
    2627: "Valore duplicato: esiste già un record con questi dati",
    547:  "Violazione chiave esterna: riferimento non valido",
    515:  "Campo obbligatorio mancante (NOT NULL)",
    208:  "Tabella non trovata",
    4060: "Database non trovato o accesso negato",
    18456:"Login fallito — credenziali errate",
}

def descrivi_errore(e):
    if hasattr(e, "args") and e.args:
        codice = e.args[0]
        return ERRORI_SQL.get(codice, str(e))
    return str(e)

import csv, os
from tkinter import filedialog, messagebox
from datetime import datetime

def esporta_csv(righe, intestazioni, titolo="dati"):
    """Esporta dati in CSV con dialogo salvataggio."""
    nome_default = f"{titolo}_{datetime.now().strftime('%Y%m%d_%H%M')}.csv"
    percorso = filedialog.asksaveasfilename(
        defaultextension=".csv",
        initialfile=nome_default,
        filetypes=[("CSV", "*.csv"), ("Tutti", "*.*")]
    )
    if not percorso: return
    with open(percorso, "w", newline="", encoding="utf-8-sig") as f:
        writer = csv.writer(f, delimiter=";")
        writer.writerow(intestazioni)
        writer.writerows(righe)
    messagebox.showinfo("Esportazione",
        f"✅ {len(righe)} righe esportate in:\n{percorso}")
    os.startfile(percorso)   # apre il file (Windows)

# Installa openpyxl per Excel: pip install openpyxl
try:
    import openpyxl
    from openpyxl.styles import Font, PatternFill, Alignment

    def esporta_excel(righe, intestazioni, titolo="report"):
        percorso = filedialog.asksaveasfilename(
            defaultextension=".xlsx",
            initialfile=f"{titolo}.xlsx",
            filetypes=[("Excel", "*.xlsx")]
        )
        if not percorso: return
        wb = openpyxl.Workbook()
        ws = wb.active
        ws.title = titolo

        # Intestazioni con stile
        header_fill = PatternFill("solid", fgColor="1877F2")
        for col, nome in enumerate(intestazioni, 1):
            cell = ws.cell(1, col, nome)
            cell.font = Font(bold=True, color="FFFFFF")
            cell.fill = header_fill
            cell.alignment = Alignment(horizontal="center")

        # Dati
        for r, riga in enumerate(righe, 2):
            for c, val in enumerate(riga, 1):
                ws.cell(r, c, val)

        # Larghezza colonne automatica
        for col in ws.columns:
            max_w = max(len(str(c.value or "")) for c in col)
            ws.column_dimensions[col[0].column_letter].width = min(max_w + 4, 40)

        wb.save(percorso)
        os.startfile(percorso)
except ImportError:
    print("Installa openpyxl per esportare in Excel: pip install openpyxl")

# Struttura del progetto finale
gestionale/
├── main.py                  # entry point e Application
├── config.py                # stringa connessione, costanti
├── db/
│   ├── manager.py           # SQLServerManager
│   ├── dipendenti_repo.py   # CRUD Dipendenti
│   └── reparti_repo.py      # CRUD Reparti
├── ui/
│   ├── main_window.py       # finestra principale con menu
│   ├── dipendenti_tab.py    # scheda gestione dipendenti
│   ├── reparti_tab.py       # scheda gestione reparti
│   ├── report_tab.py        # scheda report e grafici
│   └── login_dialog.py      # finestra di login
├── utils/
│   ├── esporta.py           # CSV / Excel
│   ├── validazioni.py       # controllo dati form
│   └── tema.py              # tema ttk personalizzato
└── assets/
    └── icone/               # file .png per toolbar

import tkinter as tk
from tkinter import ttk, messagebox
import pyodbc
from db.manager import SQLServerManager
from ui.main_window import MainWindow
from ui.login_dialog import LoginDialog
from utils.tema import applica_tema
from config import SERVER, DATABASE

class GestionaleApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.withdraw()          # nasconde finestra durante login
        self.title("Gestionale Aziendale")
        self.geometry("1200x700")
        self.minsize(900, 550)

        applica_tema(self)

        # Login
        login = LoginDialog(self)
        self.wait_window(login)

        if not getattr(login, "confermato", False):
            self.destroy(); return

        # Connessione DB
        try:
            self.db = SQLServerManager(
                SERVER, DATABASE,
                uid=login.uid, pwd=login.pwd
            ).connetti()
        except pyodbc.Error as e:
            messagebox.showerror("Connessione",
                f"Impossibile connettersi al database:\n{e}")
            self.destroy(); return

        # Mostra finestra principale
        self.deiconify()
        MainWindow(self, self.db)
        self.protocol("WM_DELETE_WINDOW", self._chiudi)

    def _chiudi(self):
        if messagebox.askyesno("Esci", "Chiudere il gestionale?"):
            if hasattr(self, "db"): self.db.disconnetti()
            self.destroy()

if __name__ == "__main__":
    GestionaleApp().mainloop()

import tkinter as tk
from tkinter import ttk
import matplotlib
matplotlib.use('TkAgg')                    # backend Tkinter
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import (
    FigureCanvasTkAgg,
    NavigationToolbar2Tk              # toolbar zoom/pan integrata
)
import numpy as np

root = tk.Tk()
root.title("Grafico Tkinter")
root.geometry("900x600")
root.configure(bg="#1e1e2e")

# 1. Crea la Figure Matplotlib
fig = Figure(figsize=(9, 5), dpi=100,
              facecolor="#1e1e2e")
ax = fig.add_subplot(111)
ax.set_facecolor("#181825")

# 2. Disegna il grafico
x = np.linspace(0, 10, 200)
ax.plot(x, np.sin(x), color="#89b4fa", linewidth=2, label="sin(x)")
ax.plot(x, np.cos(x), color="#a6e3a1", linewidth=2, label="cos(x)")
ax.set_title("Funzioni Trigonometriche", color="#cdd6f4")
ax.set_xlabel("x", color="#a6adc8")
ax.set_ylabel("y", color="#a6adc8")
ax.tick_params(colors="#a6adc8")
ax.legend(facecolor="#313244", labelcolor="#cdd6f4")
ax.grid(alpha=0.2, color="#45475a")

# 3. Embedding in Tkinter
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack(fill="both", expand=True)

# 4. Toolbar opzionale (zoom, pan, salva)
toolbar = NavigationToolbar2Tk(canvas, root)
toolbar.update()

root.mainloop()

import numpy as np

# Dati vendite mensili (Gen → Dic)
mesi = ['Gen','Feb','Mar','Apr','Mag','Giu',
        'Lug','Ago','Set','Ott','Nov','Dic']
vendite_A = [120,135,148,162,155,170,
             180,165,175,190,210,225]
vendite_B = [95, 102,118,125,140,138,
             152,160,158,172,185,195]

ax.plot(mesi, vendite_A, 'o-', color="#89b4fa",
        linewidth=2, markersize=5, label="Prodotto A")
ax.plot(mesi, vendite_B, 's-', color="#a6e3a1",
        linewidth=2, markersize=5, label="Prodotto B")

# Area riempita sotto la curva
ax.fill_between(mesi, vendite_A, alpha=0.1, color="#89b4fa")

ax.set_title("Trend Vendite Mensili", color="#cdd6f4", fontsize=14)
ax.set_xlabel("Mese", color="#a6adc8")
ax.set_ylabel("Vendite (k€)", color="#a6adc8")
ax.legend()
ax.grid(axis="y", alpha=0.2)

reparti  = ['Nord', 'Sud', 'Est', 'Ovest', 'Centro']
fatturato = [340, 210, 180, 420, 290]
obiettivo = [300, 250, 200, 380, 310]

x = np.arange(len(reparti))
w = 0.35                                  # larghezza barra

bars1 = ax.bar(x - w/2, fatturato, w,
               label="Reale", color="#89b4fa")
bars2 = ax.bar(x + w/2, obiettivo, w,
               label="Obiettivo", color="#313244")

# Etichette sopra le barre
ax.bar_label(bars1, fmt='%dk', color="#cdd6f4", fontsize=8)

ax.set_xticks(x)
ax.set_xticklabels(reparti)
ax.set_title("Fatturato vs Obiettivo (k€)")

settori = ['Tech', 'Finance', 'Health', 'Energy', 'Retail']
quote   = [35, 20, 18, 15, 12]
colori  = ['#89b4fa', '#a6e3a1', '#f38ba8', '#fab387', '#94e2d5']

wedges, texts, autotexts = ax.pie(
    quote,
    labels=settori,
    colors=colori,
    autopct='%1.0f%%',
    pctdistance=0.75,
    startangle=90,
    wedgeprops=dict(width=0.6,       # crea effetto donut
                    edgecolor='#1e1e2e',
                    linewidth=2)
)

# Stile testi
for text in texts:
    text.set_color("#cdd6f4")
for autotext in autotexts:
    autotext.set_color("#1e1e2e")
    autotext.set_fontweight("bold")

ax.set_title("Quote di Mercato", color="#cdd6f4")

np.random.seed(42)
n = 150
investimento = np.random.uniform(0, 100, n)
profitto     = investimento * 0.8 + np.random.normal(0, 12, n)
colori_pts   = np.random.uniform(0, 1, n)   # colore per categoria
dimensioni   = np.random.uniform(20, 200, n)  # dimensione punto

scatter = ax.scatter(
    investimento, profitto,
    c=colori_pts,          # colore da array (colormap automatica)
    s=dimensioni,          # dimensione punti
    cmap='plasma',
    alpha=0.7,
    edgecolors='none'
)

# Linea di regressione
z = np.polyfit(investimento, profitto, 1)
p = np.poly1d(z)
x_line = np.linspace(investimento.min(), investimento.max(), 100)
ax.plot(x_line, p(x_line), '--', color="#f9e2af", linewidth=2)

ax.set_title("Investimento vs Profitto")
ax.set_xlabel("Investimento (k€)")
ax.set_ylabel("Profitto (k€)")
fig.colorbar(scatter, ax=ax, label="Categoria")

import tkinter as tk
from tkinter import ttk
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import numpy as np

# ── Palette colori ──────────────────────────────
BG      = "#0d0d0d"
SURFACE = "#1a1a1a"
SIDEBAR = "#111111"
ACCENT  = "#00bcd4"
TEXT    = "#e0e0e0"
MUTED   = "#555555"
COLORS  = ["#00bcd4","#4caf50","#ff9800","#e91e63","#9c27b0"]

plt.rcParams.update({
    "figure.facecolor": SURFACE,
    "axes.facecolor":   "#141414",
    "axes.edgecolor":   "#333",
    "axes.labelcolor":  MUTED,
    "text.color":       TEXT,
    "xtick.color":      MUTED,
    "ytick.color":      MUTED,
    "grid.color":       "#222",
    "grid.alpha":       0.5,
    "font.family":      "sans-serif",
    "font.size":        9,
})

class Dashboard(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Dashboard Matplotlib – Tkinter Desktop App")
        self.configure(bg=BG)
        self.state("zoomed")            # finestra massimizzata
        self.vista_corrente = tk.StringVar(value="Dashboard")
        self._build_layout()
        self._show_view("Dashboard")

    # ── Layout principale ────────────────────────
    def _build_layout(self):
        # Sidebar sinistra
        self.sidebar = tk.Frame(self, bg=SIDEBAR, width=180)
        self.sidebar.pack(side="left", fill="y")
        self.sidebar.pack_propagate(False)

        # Logo
        tk.Label(self.sidebar, text="◆", fg=ACCENT, bg=SIDEBAR,
                font=("Arial", 24)).pack(pady=(20,4))
        tk.Label(self.sidebar, text="DATA DASH", fg=TEXT, bg=SIDEBAR,
                font=("Arial", 13, "bold")).pack()
        tk.Label(self.sidebar, text="Matplotlib + Tkinter",
                fg=MUTED, bg=SIDEBAR, font=("Arial", 8)).pack(pady=(0,16))

        # Separatore
        tk.Frame(self.sidebar, bg="#222", height=1).pack(fill="x", padx=16)

        # Voci di navigazione
        tk.Label(self.sidebar, text="GRAFICI", fg=MUTED, bg=SIDEBAR,
                font=("Arial", 8), anchor="w").pack(
                fill="x", padx=16, pady=(16,4))

        self.nav_buttons = {}
        voci = [
            ("■", "Dashboard"),
            ("—", "Linee"),
            ("▮", "Barre"),
            ("●", "Torta"),
            ("·", "Scatter"),
            ("▒", "Istogramma"),
            ("~", "Area"),
        ]
        for icona, nome in voci:
            btn = tk.Button(
                self.sidebar, text=f"  {icona}  {nome}",
                fg=TEXT, bg=SIDEBAR, activebackground="#1e1e1e",
                activeforeground=ACCENT, relief="flat",
                font=("Arial", 11), anchor="w",
                command=lambda n=nome: self._show_view(n)
            )
            btn.pack(fill="x", padx=8, pady=1)
            self.nav_buttons[nome] = btn

        # Versione
        tk.Label(self.sidebar, text="v2.0 • matplotlib",
                fg=MUTED, bg=SIDEBAR, font=("Arial", 7)).pack(
                side="bottom", pady=10)

        # Area principale
        self.main = tk.Frame(self, bg=BG)
        self.main.pack(side="right", fill="both", expand=True)

        # Header
        header = tk.Frame(self.main, bg=BG)
        header.pack(fill="x", padx=20, pady=12)
        self.title_lbl = tk.Label(header, text="Dashboard",
            fg=TEXT, bg=BG, font=("Arial", 20, "bold"))
        self.title_lbl.pack(side="left")

        # Badge librerie
        for lib in ["Matplotlib", "NumPy", "Tkinter"]:
            tk.Label(header, text=lib, fg=ACCENT, bg=BG,
                    font=("Arial", 8)).pack(side="right", padx=4)

        # Canvas container
        self.canvas_frame = tk.Frame(self.main, bg=BG)
        self.canvas_frame.pack(fill="both", expand=True, padx=10)

    # ── Navigazione ─────────────────────────────
    def _show_view(self, nome):
        # Evidenzia bottone attivo
        for n, btn in self.nav_buttons.items():
            btn.config(bg="#1e1e1e" if n==nome else SIDEBAR,
                       fg=ACCENT if n==nome else TEXT)
        self.title_lbl.config(text=nome)

        # Pulisce canvas precedente
        for w in self.canvas_frame.winfo_children():
            w.destroy()

        # Costruisce il grafico
        metodo = getattr(self, f"_view_{nome.lower()}", self._view_dashboard)
        fig = metodo()

        canvas = FigureCanvasTkAgg(fig, master=self.canvas_frame)
        canvas.draw()
        canvas.get_tk_widget().pack(fill="both", expand=True)

    # ── Vista Dashboard (6 grafici) ──────────────
    def _view_dashboard(self):
        fig, axes = plt.subplots(3, 2, figsize=(14, 9))
        fig.tight_layout(pad=3.0)
        np.random.seed(42)
        mesi = ['Gen','Mar','Mag','Lug','Set','Nov']

        # Linee
        ax = axes[0][0]
        for i, c in enumerate(COLORS[:3]):
            ax.plot(mesi, np.random.randint(80,200,6), 'o-',
                   color=c, label=chr(65+i), linewidth=1.8)
        ax.set_title("Trend Vendite Mensili"); ax.legend(); ax.grid(True)

        # Barre
        ax = axes[0][1]
        reg = ['Nord','Sud','Est','Ovest','Centro']
        fat = [340,210,180,420,290]; obj = [300,250,200,380,310]
        x = np.arange(5); w=0.35
        ax.bar(x-w/2, fat, w, color=ACCENT, label="Reale")
        ax.bar(x+w/2, obj, w, color="#333", label="Obiettivo")
        ax.set_xticks(x); ax.set_xticklabels(reg)
        ax.set_title("Fatturato vs Obiettivo (k€)"); ax.legend()

        # Torta donut
        ax = axes[1][0]
        ax.pie([35,20,18,15,12],
              labels=['Tech','Finance','Health','Energy','Retail'],
              colors=COLORS, autopct='%1.0f%%',
              wedgeprops=dict(width=0.6, edgecolor=SURFACE, linewidth=2))
        ax.set_title("Quote di Mercato")

        # Scatter
        ax = axes[1][1]
        inv = np.random.uniform(0,100,150)
        pro = inv * 0.8 + np.random.normal(0,12,150)
        sc = ax.scatter(inv, pro, c=np.random.rand(150),
                        s=np.random.uniform(20,200,150),
                        cmap='plasma', alpha=0.7)
        z=np.polyfit(inv,pro,1); p=np.poly1d(z)
        ax.plot(np.sort(inv), p(np.sort(inv)), '--', color="#f9e2af", lw=2)
        ax.set_title("Investimento vs Profitto")
        fig.colorbar(sc, ax=ax)

        # Istogramma
        ax = axes[2][0]
        vals = np.clip(np.random.normal(7.2,1.5,500), 0, 10)
        ax.hist(vals, bins=20, color="#cba6f7", edgecolor=SURFACE, alpha=0.85)
        ax.axvline(vals.mean(),   color="#f38ba8", lw=2, linestyle="--",
                   label=f"Media {vals.mean():.1f}")
        ax.axvline(np.median(vals), color="#a6e3a1", lw=2, linestyle=":",
                   label=f"Mediana {np.median(vals):.1f}")
        ax.set_title("Soddisfazione Clienti (0-10)"); ax.legend()

        # Area stackplot
        ax = axes[2][1]
        t = np.linspace(0, 4*np.pi, 300)
        A = 0.5+0.5*np.sin(t*0.8)
        B = 0.5+0.5*np.sin(t*0.8+np.pi/3)
        C = 0.5+0.5*np.sin(t*0.8+2*np.pi/3)
        ax.stackplot(t, A, B, C, labels=['A','B','C'],
                    colors=[ACCENT,"#4caf50","#555"], alpha=0.8)
        ax.set_title("Segnale Multi-canale"); ax.legend(loc="upper right")

        return fig

    # ── Viste singole ───────────────────────────
    def _view_linee(self):
        fig, ax = plt.subplots(figsize=(12,7))
        mesi = ['Gen','Feb','Mar','Apr','Mag','Giu',
                'Lug','Ago','Set','Ott','Nov','Dic']
        np.random.seed(1)
        for i,c in enumerate(COLORS[:3]):
            y = np.random.randint(80,220,12)
            ax.plot(mesi,y,'o-',color=c,lw=2,ms=5,label=f"Serie {i+1}")
            ax.fill_between(mesi,y,alpha=0.05,color=c)
        ax.set_title("Trend Annuale",fontsize=14); ax.legend(); ax.grid(True)
        return fig

    def _view_barre(self):
        fig, ax = plt.subplots(figsize=(12,7))
        cat = ['Q1','Q2','Q3','Q4']
        for i,c in enumerate(COLORS[:3]):
            ax.bar(np.arange(4)+i*0.25, np.random.randint(100,500,4),
                  0.25, color=c, label=f"Prodotto {i+1}")
        ax.set_xticks(np.arange(4)+0.25); ax.set_xticklabels(cat)
        ax.set_title("Vendite per Trimestre",fontsize=14); ax.legend()
        return fig

    def _view_torta(self):
        fig, ax = plt.subplots(figsize=(10,8))
        ax.pie([30,25,20,15,10],
              labels=['A','B','C','D','E'], colors=COLORS,
              autopct='%1.1f%%', startangle=90,
              wedgeprops=dict(width=0.55,edgecolor=SURFACE,linewidth=2),
              textprops=dict(color=TEXT))
        ax.set_title("Distribuzione Portfolio",fontsize=14)
        return fig

    def _view_scatter(self):
        fig, ax = plt.subplots(figsize=(12,7))
        np.random.seed(5)
        for c in COLORS:
            x = np.random.normal(50,20,80)
            y = x * 0.7 + np.random.normal(0,10,80)
            ax.scatter(x,y,color=c,alpha=0.6,s=60)
        ax.set_title("Correlazione Multi-cluster",fontsize=14)
        ax.set_xlabel("Variabile X"); ax.set_ylabel("Variabile Y")
        return fig

    def _view_istogramma(self):
        fig, ax = plt.subplots(figsize=(12,7))
        np.random.seed(7)
        dati = np.clip(np.random.normal(7,2,1000),0,10)
        ax.hist(dati,bins=30,color=COLORS[4],edgecolor=SURFACE,alpha=0.9)
        ax.axvline(dati.mean(),color=COLORS[2],lw=2,linestyle="--",
                   label=f"μ={dati.mean():.2f}")
        ax.set_title("Distribuzione NPS",fontsize=14); ax.legend()
        return fig

    def _view_area(self):
        fig, ax = plt.subplots(figsize=(12,7))
        t = np.linspace(0,4*np.pi,400)
        segnali = [np.0.5+np.0.5*np.sin(t*0.8+i*np.pi/3) for i in range(4)]
        ax.stackplot(t,*segnali,
                    labels=[f"Canale {i+1}" for i in range(4)],
                    colors=COLORS, alpha=0.75)
        ax.set_title("Segnali Multi-canale",fontsize=14)
        ax.legend(loc="upper right")
        return fig

if __name__ == "__main__":
    Dashboard().mainloop()

import tkinter as tk
import matplotlib; matplotlib.use('TkAgg')
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import numpy as np
from collections import deque

root = tk.Tk()
root.title("Monitoraggio CPU (Simulato)")
root.configure(bg="#0d0d0d")

fig = Figure(figsize=(10, 4), dpi=100, facecolor="#141414")
ax  = fig.add_subplot(111)
ax.set_facecolor("#0d0d0d")
ax.set_ylim(0, 100)
ax.set_ylabel("CPU %", color="#aaa")
ax.tick_params(colors="#555")
ax.grid(alpha=0.15, color="#333")

canvas = FigureCanvasTkAgg(fig, master=root)
canvas.get_tk_widget().pack(fill="both", expand=True)

# Buffer circolare (ultimi 60 campioni)
N = 60
dati_cpu = deque([0] * N, maxlen=N)
linea, = ax.plot([], [], color="#00bcd4", linewidth=1.5)
fill  = [None]

def aggiorna():
    # Simula valore CPU (sostituire con psutil.cpu_percent())
    nuovo = np.random.uniform(10, 90)
    dati_cpu.append(nuovo)

    x = list(range(N))
    y = list(dati_cpu)

    linea.set_data(x, y)
    ax.set_xlim(0, N - 1)

    if fill[0]:
        fill[0].remove()
    fill[0] = ax.fill_between(x, y, alpha=0.15, color="#00bcd4")

    canvas.draw_idle()                  # più efficiente di draw()
    root.after(500, aggiorna)           # aggiorna ogni 500ms

aggiorna()
root.mainloop()

from tkinter import filedialog

def salva_grafico(fig):
    percorso = filedialog.asksaveasfilename(
        defaultextension=".png",
        filetypes=[
            ("PNG Image",  "*.png"),
            ("PDF",         "*.pdf"),
            ("SVG Vector",  "*.svg"),
            ("JPEG",        "*.jpg"),
        ],
        initialfile="grafico"
    )
    if percorso:
        fig.savefig(
            percorso,
            dpi=150,               # risoluzione alta stampa
            bbox_inches="tight",   # nessun bordo bianco extra
            facecolor=fig.get_facecolor()
        )
        from tkinter import messagebox
        messagebox.showinfo("Salvato", f"✅ Grafico salvato:\n{percorso}")

# Aggiungi bottone salva in Tkinter
tk.Button(root, text="💾 Salva PNG",
         command=lambda: salva_grafico(fig)).pack(pady=6)