A un livello molto base (il mio) possiamo dire un'interfaccia grafica costruita con mui sarà data da come viene composta la taglist opportuna.
Ricapitolando quindi:
1) Definire un generico puntatore ad oggetto:
object *application1;
2) Questo puntatore conterrà tutta quella che è la descrizione della nostra interfaccia (finestre, pulsanti e così via) e le sue proprietà.
Il puntatore a oggetto è un puntatore generico per cui gli dobbiamo dire di volta in volta a che tipo di oggetto si deve conformare.
Non è imperativo però associare a un oggetto fisico (un gadget) della nostra interfaccia, un oggetto logico (un puntatore ben preciso). Questo perchè chi ha progettato mui l'ha resa talmente semplice che basterebbe, per creare un'interfaccia, darne solo la sua descrizione in termini di taglist: "cameriere per favore un'applicazione con una finestra, tre pulsanti in riga e due caserlle di testo incolonnate. provveda lei a sistemarli sul vassoio! grazie!"
Questo, scherzosamente è ciò che si può fare con mui.
Dove voglio andare a parare? Mettiamo che io voglia un'interfaccia con una riga di testo con su scritto "ciccio", un pulsante e un'altra riga di testo. La casella che contiene ciccio voglio che non faccia altro per tutto il programma: contenga la scritta ciccio e basta.
L'ultima riga di testo invece deve variare con le pressioni del pulsante: ad esempio tiene il totale delle pressioni del pulsante incrementandosi di uno ogni volta che lo premo.
Quindi della seconda casella di testo devo avere tutti gli elementi necessari per far si che la mia programmazione la faccia "variare". Dobbiamo allora poterla identificare in una qualche maniera. Domandiamoci: come facciamo a identificare, in maniera semplice semplice qualcosa? Chiamandola per nome! Ecco. Se associo il mio gadget (o oggetto fisico ad esempio una finestra o un programma) al puntatore oggetto che ha quel determinato nome avrò quegli elementi necessari per poter modificare quella casella. Non solo, ma quando prendo il puntatore generico ad oggetti (object *) e lo associo a un oggetto finestra piuttosto che applicazione o pulsante, avrò circoscritto il suo raggio d'azione e il sistema saprà di che tipo di oggetto si tratta, con tutte le conseguenze del caso.
Se lo associo a un gadget pulsante conterrà in sè tutte le caratteristiche proprie del pulsante, se una finestra una finestra e così via.
Ora è chiaro che ho bisogno di compiere quest'operazione per il pulsante e per la casella di testo che si incrementa. Per quella che nasce ciccio e muore ciccio, cioè non varia mai, non ho necessariamente bisogno di associarla a un oggetto logico per la semplice ragione che è tanto carina sulla mia interfaccia ma, di fatto, non è oggetto della mia elaborazione! Mui permette questo come dicevo: creare dei gadget a video senza bisogno di associarli a dei puntatori ad oggetto. Poi lasciamo stare che è bene farlo per altre ragioni, ad esempio l'ordine.

(Questo come appunto: puntatori, puntatori, puntatori. Ma che so sti puntatori? In breve? Sono variabili che contengono degli indirizzi di altre variabili. e proprio in virtù di questo, permettendo l'accesso diretto all'indirizzo di memoria dove si trova un determinato "oggetto" permettono di modificarlo. Si capisce perciò perchè è tanto importante conoscere il "tipo" di oggetto al quale il puntatore fa riferimento: cambia totalmente tutto. Non sto qua a entrare nello specifico ma internet è piena di tutorial, spiegazioni, dissertazioni e natura ultima dei puntatori. Quel che non capisco io ad esempio, in mui, ma credo in generale nella programmazione di amiga è quest'utilizzo disinvolto di puntatori a oggetti generici. Ma come al solito io sono un niubbo e del perchè si siano fatte determinate scelte non sono ancora ai livelli necessari per comprenderli. detto questo riprendiamo con mui)

Ritorniamo a noi. Come faccio ad associare il gadget (o oggetto fisico) all'oggetto puntatore?
Parlando dell'applicazione dobbiamo dirgli che è un puntatore ad oggetto applicazione:
application1= ApplicationObject,
3) definito questo, senza entrare nel merito delle singole tag, cosa manca al nostro programma per avere una scintillante interfaccia? Beh, sicuramente una finestra!
4) Ecco perchè dichiariamo un bel puntatore a oggetto ancora una volta:
object *window1;
5) Come per l'altro dobbiamo dirgli che non è un puntatore generico ma un puntatore ad oggetto finestra, per cui:
window1= WindowObject,
6) Anche qui ci sono una serie di tag.
7) Stesso procedimento per i singoli gadget: bottoni, caselle di testo e così via:
object *button1;
button1=SimpleButton(...),...

Mui però non si ferma qui:
Caoticamente facciamo un passo indietro:
La struttura di un'interfaccia mui è più o meno questa:
oggetto_applicazione:
oggetto_finestra1:
singoli gadget o gruppi di gadget
fine oggetto_finestra1;
eventuale finestra 2,3 o 4:
singoli gadget o gruppi di gadget
Fine oggetto finestra 2,3 o 4...
Fine applicazione.

Pranzo!!!