# Glade Turbo-Start

Copyright © 2000 by Compaq Computer Corporation

Copyright © 2000 by Fabrizio Stefani (traduzione italiana)

# Glade Turbo-Start

Qui c'è quanto basta per incominciare. Raccomando anche di leggere la Glade FAQ, che è compresa nella distribuzione, e di guardare le schermate.

## Compilare Glade

Se siete utenti Linux che usano i Compaq Alpha, come me, dovrete compilare `Glade` per la vostra piattaforma. I file `README` e `INSTALL` che accompagnano `Glade` sono piuttosto buoni. Leggeteli e seguitene le indicazioni. La sottodirectory `doc` contiene anch'essa dei file utili; in particolare `manual.txt`.

C'era un problema nella compilazione di `Glade` v0.5.7 per Linux RedHat 6.1 per Alpha: la compilazione falliva durante la creazione della roba rigurdante il natural language support (NLS) nella sottodirectory `po`. Disabilitando il NLS è andato tutto a posto.

Cercate nelle future distribuzioni di Linux per Alpha se contengono una versione precompilata di `Glade`.

## Eseguire Glade

Se `Glade` è nel path (ad esempio se è stato installato in `/usr/local/bin`), allora è sufficiente digitare glade per lanciarlo dalla shell.

`Glade` mostra tre finestre:

- La finestra principale di Glade (file/opzioni/crea sorgente)

- L'Editor delle proprietà

- La Palette

Usate la finestra Progetto per aprire un progetto esistente o per crearne uno nuovo. Suggerisco di cambiare alcune impostazioni nella finestra di dialogo Opzioni progetto che si apre dal menu File. Ad esempio, probabilmente vorrete cambiare la `Directory del progetto` e il `Nome del progetto` nella scheda `Generale`. `Directory del progetto` e `Nome del progetto` cambieranno di conseguenza. La scheda `Opzioni C` controlla la generazione del codice C, compresi i nomi di certi file generati appositamente:

- Funzioni di creazione dell'interfaccia — (`interface.c`, `interface.h`)

- Funzioni di callback e di gestione dei segnali — (`callbacks.c`, `callbacks.h`)

- Funzioni di supporto — (`support.c`, `support.h`)

Come notato nella Glade FAQ, le vostre funzioni di gestione dei segnali sono nei file sorgente dei callback e nei file di supporto.

Cliccando sul pulsante Crea sorgente, o scegliendo Genera codice sorgente dal menu File si chiederà a `Glade` di generare il codice C.

## La Palette

La Palette mostra i widget disponibili per il progetto dell'interfaccia utente. Questi sono divisi in tre categorie:

- GTK+ Basic

- GTK+ Additional

- Gnome

L'icona con la finestra, che si trova nell'angolo in alto a sinistra, è quel che serve per cominciare. Cliccateci su per creare una nuova finestra. `Glade` disegnerà la nuova finestra e potrete scegliere altri widget dalla Palette per aggiungerli alla finestra.

`Glade` usa dei "riquadri" per organizzare e tracciare i widget. Se volete aggiungere alla vostra finestra più di un widget (e probabilmente lo vorrete), selezionate ed inserite dei riquadri nella finestra. Potete scegliere tra:

- Riquadro orizzontale

- Riquadro verticale

- Tabella

- Posizioni fisse

- Gruppo di pulsanti orizzontale

- Gruppo di pulsanti verticale

I riquadri possono essere annidati per creare delle strutture di aspetto complesso. Quando create riquadri orizzontali o verticali vi verrà chiesto quante righe o colonne (suddivisioni) volete.

Una volta che i riquadri sono stati piazzati potrete metterci dentro widget specifici, come etichette, o pulsanti, o altri widget ancora più complessi. Osservate che `Glade` "raggruppa" i widget in una disposizione che fa risparmiare un sacco di lavoro noioso. Quando selezionate un widget la finestra Proprietà ne mostrerà le proprietà correnti, come il nome del widget stesso. La scheda `Segnali` nell'Editor delle proprietà è il posto in cui attaccare al widget le funzioni di gestione dei segnali.

Il progetto d'esempio che ho creato possiede una finestra divisa in due parti usando la disposizione a Riquadri verticali. Il riquadro in alto contiene una barra dei menu, mentre quello in basso è a sua volta diviso in due parti (destra e sinistra) usando un Riquadro orizzontale. La barra dei menu contiene i menu File e Aiuto, entrambi contenenti delle voci. La parte sinistra della Divisione orizzontale contiene una Finestra di scorrimento che, a sua volta, contiene un viewport con dentro un widget albero. La parte destra invece contiene un widget schedario con tre schede.

L'albero dei widget può essere visto scegliendo Mostra albero dei widget nel menu Vista nella finestra principale di `Glade`. L'albero dei widget della mia applicazione d'esempio ha la seguente struttura:

- Window (Finestra)

  - Vertical Box (Riquadro verticale)

    - Menu Bar (Barra dei menu)

    - Horizontal Box (Riquadro orizzontale)

      - Scrolled Window (Finestra di scorrimento)

        - Viewport

          - Tree (Albero)

      - Notebook (Schedario)

La Barra dei menu e lo Schedario possono essere espansi ulteriormente per vedere i singoli menu, le voci dei menu, le pagine, ecc. L'albero dei widget è un modo comodo per scorrere ed esaminare come sono organizzati i widget.

## Editor dei menu

Dopo aver messo un widget Barra dei menu usate il pulsante sinistro per selezionarlo. Usate il pulsante destro sulla Barra dei menu per far apparire un menu con dei comandi. Scegliendo la voce Modifica Menu `Glade` mostrerà l'Editor dei Menu. Qui è possibile definire la struttura dei menu della vostra applicazione.

Cliccate su pulsante Aggiungi per aggiungere un nuovo menu o una nuova voce di menu. Cambiate a vostro piacimento i campi `Etichetta` e `Nome`. `Etichetta` indica il testo che verrà mostrato nel menu o nella barra dei menu. Il Nome verrà usato per costruire un gestore di segnale. Il campo `Gestore` verrà aggiornato quando viene cambiato il `Nome`. Il nome del gestore incomincia con "on_" e finisce con "_activate", come in `on_open_project_activate`. Usate le frecce destra e sinistra per creare dei livelli nelle voci di menu. I rientri rispecchieranno la gerarchia dei menu.

Cliccate sul pulsante `Applica` per far apparire l'attuale configurazione dei menu nella finestra di modifica. Potete giocherellare con le voci di menu per trovarne la disposizione migliore.

## Generazione del codice

Quando la finestra è come la volevate, cliccate sul pulsante Crea sorgenti per generare il codice. `Glade` genera anche le informazioni per `autoconf`, facilitando la compilazione sulla vostra piattaforma. Per un progetto semplice verranno creati i seguenti file e directory:

- `AUTHORS` — Vuoto, necessario per aderire alle convenzioni GNU

- `NEWS` — Vuoto, necessario per aderire alle convenzioni GNU

- `README` — Vuoto, necessario per aderire alle convenzioni GNU

- `Makefile.am` — Usate `automake` con questo file per produrre il `Makefile.in`

- `acconfig.h` — informazioni per `Autoconf`

- `autogen.sh` — Lanciate questo per compilare l'applicazione

- `configure.in` — Serve ad `autoconf` per produrre uno script di configurazione (configure)

- `macros/` — Macro (m4) relative alla compilazione

- `pm.glade` — Il file `Glade` del progetto dell'applicazione

- `po/` — File di supporto per la localizzazione (NLS)

- `src/` — File sorgenti dell'applicazione

- `stamp-h.h` — Data/ora (timestamp)

La sottodirectory `src` contiene i file sorgente dell'applicazione; sei di essi sono già stati citati:

- Funzioni di creazione dell'interfaccia — (`interface.c`, `interface.h`)

- Funzioni di callback e di gestione dei segnali — (`callbacks.c`, `callbacks.h`)

- Funzioni di supporto — (`support.c`, `support.h`)

`Glade` genera anche `main.c`. `Glade` *non* sovrascrive i seguenti file:

- `main.c`

- `callbacks.h`

- `callbacks.c`

Siete liberi di modificarli. `callbacks.c` contiene le funzioni (troncate) di gestione dei segnali che rispondono alle azioni degli utenti. È qui che dovete agganciare il codice della vostra applicazione.

Per prepararvi alla compilazione dell'applicazione battete autogen.sh al prompt della shell. `Autoconf` creerà le informazioni di configurazione e verranno generati i makefile. Ora date make per la compilazione vera e propria. `Make` lavorerà ricorsivamente nel processo di compilazione lasciando infine il programma eseguibile nella sottodirectory `src`.

## Prendere confidenza

Ecco qualcosa da provare per prenere confidenza con `Glade`.

Editate `callbacks.c` ed aggiungete delle `printf` alle funzioni di gestione dei segnali. Rifate il make dell'applicazione, eseguitela e guardate i messaggi che appaiono quando vengono invocate le funzioni di gestione dei segnali, in risposta alle azioni dei widget.

La finestra della vostra applicazione, così come appare la prima volta, potrebbe essere troppo piccola (la mia sicuramente lo era). Aprite il progetto `Glade` e cliccate sull'icona del widget window (finestra) nella finestra principale di `Glade`. Andate nella scheda `Widget` dell'Editor delle proprietà e cambiate i campi `Larghezza` e `Altezza predefinita` per aggiustare le dimensioni della finestra. Rigenerate il codice sorgente C e compilate l'applicazione. Lanciate di nuovo l'applicazione e congratulatevi con voi stessi per l'ottimo lavoro!

## E poi?

Dovrebbe essere possibile arrivare fino a questo punto senza conoscere nulla di GTK+. Il passo successivo è di imparare qualcosa di GTK (in particolar modo riguardo i widget più complessi, come gli alberi) e incominciare a riempire gli spezzoni.

## Autori

`Glade` è stato scritto da Damon Chaplin (`<glade@glade.gnome.org>`). Questa guida è stata scritta da Paul J. Drongowski (`<paul.drongowski@compaq.com>`). La conversione in DocBook è stata fatta da Dan Mueth (`<d-mueth@uchicago.edu>`).

Traduzione italiana di Fabrizio Stefani (`<fstef@it.gnome.org>`). Per favore, inviare commenti e suggerimenti riguardanti questa traduzione al suddetto indirizzo.