Realizzare un visualizzatore di immagini con Lazarus è un ottimo esercizio per prendere confidenza con la programmazione di applicazioni desktop. In un unico progetto si imparano a utilizzare componenti fondamentali come TImage, TOpenDialog, TButton e TLabel, oltre a gestire file, eventi ed eccezioni.

Creare un visualizzatore di immagini con Lazarus.

Pubblicato il: 12-7-2026

Ultima Modifica: 12-7-2026

Introduzione

Uno dei progetti più interessanti per chi inizia a programmare con Lazarus consiste nella realizzazione di un semplice visualizzatore di immagini.

Un programma di questo tipo permette di imparare ad utilizzare molti componenti fondamentali dell'ambiente di sviluppo, come pulsanti, menu, finestre di dialogo e controlli grafici.

Al termine di questo tutorial avrai realizzato un'applicazione in grado di:

🖼️ aprire un'immagine dal disco;
📂 scegliere il file tramite una finestra di dialogo;
🔍 adattare automaticamente l'immagine alla finestra;
📋 visualizzare alcune informazioni sul file aperto;
🔄 aprire immagini diverse senza riavviare il programma.

Pur essendo un progetto semplice, introduce tecniche che ritroverai in applicazioni molto più complesse.

Come funzionerà il programma

Il nostro visualizzatore seguirà questo semplice schema.

+------------------------------------------------------+
|                  Visualizzatore                      |
+------------------------------------------------------+
|                                                      |
|                 [ Area immagine ]                    |
|                                                      |
|                                                      |
+------------------------------------------------------+
| Apri | Chiudi | Informazioni                         |
+------------------------------------------------------+

L'utente premerà il pulsante Apri, selezionerà un'immagine e questa verrà visualizzata immediatamente.

Creare un nuovo progetto

Apri Lazarus e seleziona:

File

↓

Nuovo

↓

Application

Verrà creata una nuova finestra vuota.

Salva subito il progetto in una cartella dedicata, ad esempio:

VisualizzatoreImmagini

Componenti da inserire

Dalla Palette dei componenti aggiungi:

Componente	Nome consigliato	Utilizzo
TImage	Image1	Visualizza l'immagine
TButton	BtnApri	Apre il file
TButton	BtnChiudi	Chiude il programma
TLabel	LabelInfo	Mostra il nome del file
TOpenDialog	OpenDialog1	Selezione delle immagini

La finestra potrebbe avere un aspetto simile al seguente.

+------------------------------------------------------+
|                                                      |
|                    Image1                            |
|                                                      |
|                                                      |
+------------------------------------------------------+

Nome file

[Apri]      [Chiudi]

Configurare il componente TImage

Nel Object Inspector imposta alcune proprietà.

Align = alClient

Stretch = True

Proportional = True

Center = True

Queste impostazioni permettono all'immagine di:

occupare tutta la finestra;
mantenere le proporzioni originali;
essere centrata automaticamente.

Il risultato sarà molto più gradevole.

Configurare OpenDialog

Nel componente OpenDialog1 imposta il filtro.

File immagine|*.bmp;*.jpg;*.jpeg;*.png;*.gif

In questo modo verranno mostrati soltanto i principali formati grafici.

Aprire un'immagine

Facendo doppio clic sul pulsante Apri, Lazarus genera automaticamente l'evento OnClick.

Inserisci il seguente codice.

procedure TForm1.BtnApriClick(Sender: 
			TObject);
begin
  if OpenDialog1.Execute then
  
			begin
    Image1.Picture.LoadFromFile(
      
			OpenDialog1.FileName);

    LabelInfo.Caption 
			:=
      ExtractFileName(
      
			OpenDialog1.FileName);
  end;
end;

Il funzionamento è molto semplice.

Viene aperta la finestra di selezione.
L'utente sceglie un file.
L'immagine viene caricata.
Il nome del file viene visualizzato nella finestra.

Chiudere il programma

Il pulsante Chiudi richiede una sola istruzione.

procedure 
			TForm1.BtnChiudiClick(Sender: TObject);
begin
  Close;

			end;

L'applicazione verrà terminata immediatamente.

Caricare automaticamente l'ultima immagine

Un piccolo miglioramento consiste nel ricordare l'ultimo file aperto.

È sufficiente memorizzare il percorso in un file INI o in un file di configurazione.

All'avvio:

Legge il file INI

↓

Trova il nome dell'immagine

↓

La visualizza automaticamente

L'utente ritroverà l'ultima immagine aperta senza doverla selezionare nuovamente.

Visualizzare il percorso completo

Oltre al nome del file possiamo mostrare anche il percorso.

LabelInfo.Caption :=

			OpenDialog1.FileName;

Esempio:

C:\Foto\Vacanze\Mare.jpg

Controllare se il file esiste

if FileExists(OpenDialog1.FileName) 
			then
begin
  Image1.Picture.LoadFromFile(
    
			OpenDialog1.FileName);
end;

È sempre buona norma verificare che il file sia presente.

In questo modo si evitano errori se il file è stato eliminato o spostato.

Gestire gli errori

Può accadere che l'utente selezioni un file danneggiato o non supportato.

È consigliabile utilizzare un blocco try...except.

try
  
			Image1.Picture.LoadFromFile(
    
			OpenDialog1.FileName);
except
  on E: Exception do
    
			ShowMessage(
      'Errore durante il 
			caricamento:' +
      LineEnding +
      
			E.Message);
end;

L'applicazione continuerà a funzionare anche in caso di problemi.

Visualizzare le dimensioni dell'immagine

Possiamo leggere le dimensioni direttamente dal componente Picture.

LabelInfo.Caption :=

			IntToStr(Image1.Picture.Width) +
' x ' +

			IntToStr(Image1.Picture.Height);

Risultato:

1920 x 1080 pixel

Aggiungere uno Zoom

Una semplice funzione di zoom può essere ottenuta modificando la proprietà Stretch.

Schema:

100%

↓

150%

↓

200%

↓

50%

Per uno zoom più avanzato si possono utilizzare componenti grafici dedicati o intervenire sulle dimensioni del controllo TImage.

Aprire immagini con un doppio clic

È possibile associare i file immagine al programma.

Lo schema sarà il seguente.

Doppio clic su una foto

↓

Windows avvia il programma

↓

L'immagine viene caricata

Questa funzionalità richiede la registrazione dell'applicazione come programma predefinito per i formati desiderati.

Creare una barra degli strumenti

Per rendere il programma più gradevole si può aggiungere un componente TToolBar.

Esempio:

+------------------------------------------------------+

📂 Apri

💾 Salva

🔍 Zoom +

🔎 Zoom -

ℹ Informazioni

+------------------------------------------------------+

L'interfaccia apparirà più moderna e intuitiva.

Inserire un menu

Anche il componente TMainMenu è molto utile.

Una possibile struttura è:

File

   Apri

   Chiudi

Visualizza

   Zoom +

   Zoom -

?

   Informazioni

L'utente potrà utilizzare sia il menu che i pulsanti.

Formati supportati

Lazarus supporta numerosi formati grafici.

Tra i più comuni troviamo:

🖼️ BMP
📸 JPEG
🌄 PNG
🎨 GIF
🖌️ ICO
🪟 XPM

Altri formati possono essere aggiunti utilizzando librerie dedicate.

Miglioramenti possibili

Una volta completato il progetto, puoi aggiungere numerose funzionalità.

⏭️ immagine successiva e precedente;
📂 apertura di un'intera cartella;
🖱️ trascinamento (Drag & Drop);
🔍 zoom con la rotella del mouse;
🖥️ modalità a schermo intero;
🌙 tema chiaro e scuro;
🖼️ presentazione automatica (slideshow);
⭐ elenco delle immagini preferite;
🗂️ miniature delle immagini;
🖨️ stampa della foto visualizzata.

Questi miglioramenti trasformano un semplice esercizio in un'applicazione molto più completa.

Buone pratiche

Durante lo sviluppo di un visualizzatore di immagini è consigliabile:

verificare sempre l'esistenza del file prima del caricamento;
gestire le eccezioni con try...except;
mantenere le proporzioni delle immagini utilizzando la proprietà Proportional;
evitare di caricare immagini troppo grandi senza controllarne le dimensioni, per non consumare inutilmente memoria;
separare il codice dedicato all'interfaccia grafica da quello che gestisce il caricamento dei file, così da rendere il progetto più ordinato e facile da mantenere.

Conclusione

Una volta acquisite queste basi sarà semplice espandere il programma aggiungendo nuove funzionalità, come lo zoom avanzato, la rotazione delle immagini, la stampa, la navigazione tra le fotografie e persino la modifica delle immagini. Con pochi componenti e qualche decina di righe di codice è possibile realizzare un'applicazione utile e rappresentativa delle potenzialità offerte da Lazarus e Free Pascal.