AMIGAcoordinamento di Andrea de Prisco

Programmare in C su Amiga (30)di Dario de Judicibus (MC2120)

La versione 7.3 di Intuition non mette a disposizione delprogrammatore un set di funzioni ad alto livello per la gestione deicontrolli, ma fornisce una serie di strutture che permette di definirepraticamente una varietà infinita di oggetti da usare nelle interfacceutente. In questa puntata incominceremo a vedere come si puòconcretizzare questa grande potenzialità in un insieme di funzioni emacro che rendano più semplice definire e gestire vari tipi di controlli

Introduzione

Nella scorsa puntata abbiamo parlatodi pulsanti. Abbiamo visto come si de-finiscono, abbiamo descritto i tipi prin-cipali e ne abbiamo mostrato l'utilizzo.Abbiamo inoltre visto come lntuition cidia una grande flessibilità nella definizio-ne di questi controlli, ma nel contempocostringa il programmatore a gestiretutta una serie di parametri, la cui ma-nutenzione può risultare pesante qualo-ra si desideri modificare l'aspetto del-l'interfaccia utente che si sta disegnan-do. Se ad esempio abbiamo deciso divisualizzare un pulsante con su scrittolista, bisognerà fornire ad lntuition, frale altre cose, una larghezza per il pul-sante sufficiente a far entrare tale pa-rola nell'area di selezione. Se ad un cer-to punto decidiamo di modificare il te-sto del pulsante in lista ..., ci toccheràmodificare tale valore e, se il pulsante inquestione si trova in mezzo ad altri pul-santi, ricentrarlo diversamente se nonaddirittura spostare di una decina di pi-xel gli altri. Il tutto potrebbe richiedereun paio di compilazioni fintanto che nonsi è raggiunto il risultato voluto. Natu-ralmente esistono dei programmi che cipermettono di fare questo direttamenteper mezzo di una interfaccia grafica, perpoi generare il codice finale, ma a que-sto punto non si parla più di program-mazione, ma di CASE, cioè ComputerAided Software Engineering. Un altroaspetto della questione è che se si de-vono definire molti controlli, è necessa-rio definire molte strutture, e questo au-menta le dimensioni del programma.Potrebbe risultare conveniente allora al-locare le strutture necessarie in mododinamico, e magari deallocarle quandonon ci servono più. Se stiamo scrivendoun programmino semplice con qualchemenu, un paio di quadri ed una finestra,

248

la cosa non è poi così importante, mase quello che stiamo scrivendo è unprogramma complesso la cosa è un po'differente. Un programma che gira in unsistema multitasking deve essere moltoeducato. Ad esempio non deve tenersiper sé più memoria di quanta glieneserva.

Abbiamo già visto, quando parlavamodi menu, come si possano allocare di-namicamente le strutture necessarie al-la definizione delle voci. In quel casousammo la funzione AllocRemember(),poiché in tal modo ci liberavamo dellanecessità di tener traccia dei singoliblocchi di memoria allocati in più ripre-se, e potevamo liberare tutta la memo-ria allocata fino a quel momento conun'unica chiamata alla FreeRemem-ber(). Questa volta torneremo ad usarele funzioni più classiche AllocMem() eFreeMem(), in quanto vogliamo aver lapossibilità di allocare e liberare singoliblocchi di memoria, associati ognuno adun ben definito pulsante.

Opereremo in modo analogo a quan-to già fatto con il programma scheletro.Anzi, useremo proprio tale struttura, op-portunamente modificata, per costruireil nostro programma di gestione deicontrolli. In pratica struttureremo il no-stro programma in tre parti:

gdgmain.c

che rappresenterà il programma princi-pale, e conterrà il codice di definizionedella finestra, dei menu e dei controlli,di gestione degli eventi trasmessi da ln-tuition, delle eccezioni e dei messaggi(analogamente a quanto facevasklmain.c).

gdgprocs.c

che conterrà le varie funzioni e macro di

servizio per la definizione dei controlli ela loro gestione (analogamente a quellerelative ai menu e contenute in sklpro-cs.c);

gdgusrh.c

che conterrà le costanti, i tipi, le strut-ture ed i prototipi necessari al program-ma per la definizione e la gestione deicontrolli, e che serve a generare la ta-bella simbolica gdgusrh.sym (analoga-mente a come si faceva con sklusrh.c).

Ovviamente continueremo a fare usodella sklprocs.c e della sklusrh.symper la parte relativa ai menu, ma questolo vedremo nella prossima puntata.

Una considerazione importante. Co-struire un set di funzioni e di macro perla gestione dei controlli [toolbox. tool-kitJ. richiede la necessità di definire unaserie di standard, cioè di regole per ladefinizione dei vari oggetti.

Questo vuoi dire porre delle limitazio-ni al programmatore che usa questistrumenti, ma in compenso aumentanotevolmente la flessibilità del program-ma e riduce i tempi di manutenzione.D'altra parte chi programma può sem-pre decidere di fare a meno di questistrumenti a tornare a programmare, percosì dire in modo nativo, rinunciandoperò così, ai vantaggi che essi fornisco-no. In pratica si tratta di decidere checosa ci interessa di più: se la flessibilitàdel programma, o quella degli strumen-ti.

Più cose uno strumento permette difare, più informazioni il programmatoredeve fornire e più sono le interrleazionitra i vari oggetti nel programma. Questorende il programma più difficile da man-tenere in quanto anche un minimo cam-biamento può richiedere la modifica ditutta una serie di elementi ad esso col-legati. Viceversa, riducendo le possibi-lità ed utilizzando strumenti di alto livel-lo, cioè non atomici, il programma risul-ta più flessibile nei confronti di eventualivariazioni, e quindi meno costoso damantenere.

Chi ad esempio ha iniziato a program-mare con la versione 2.0 di lntuition, dif-ficilmente accetterà di tornare a pro-grammare con la 1.3. Ma vediamo tuttociò in pratica.

MCmicrocomputer n. 104 - febbraio 1991

Funzioni e macro

In figura 1 sono riportate le varie di-chiarative su cui si basano le proceduredi gestione dei pulsanti. Torneremo piùvolte su questo file. Per il momento dia-mo un'occhiata ai prototipi delle funzio-ni. Abbiamo quattro funzioni:

CreateButtonOServe a definire in modo dinamico un

pulsante a rilascio automatico o manua-le. Restituisce il puntatore al pulsante.

DeleteButtonORimuove il pulsante creato con la

CreateButtonO e libera tutta la memo-ria allocata per quel pulsante.

DisplayGadgetOVisualizza un pulsante aggiungendolo

alla lista dei controlli relativi ad un certocontenitore (finestra o quadro).

RefreshWindowORestaura una finestra e tutti i controlli

in essa contenuti.

A queste si aggiungono cinque ma-ero, e cioè:

CreateAutoButtonOServe a definire in modo dinamico un

pulsante a rilascio automatico. Restitui-sce il puntatore al pulsante.

DeleteAutoButtonORimuove il pulsante creato con la

CreateAutoButton() e libera tutta lamemoria allocata per quel pulsante.

CreateToggleButtonO

AMIGA

Serve a definire in modo dinamico unpulsante a rilascio manuale. Restituisceil puntatore al pulsante.

DeleteToggleButtonORimuove il pulsante creato con la

CreateToggleButton() e libera tutta lamemoria allocata per quel pulsante.

ToggleButtonStatusOCambia lo stato di selezione di un pul-

sante a rilascio manuale.

Vediamo quali sono i criteri alla basedel disegno proposto.

Innanzi tutto tutte le funzioni e le ma-ero descritte seguono le raccomandazio-ni della Commodore relativamente allagestione dei pulsanti. Esse peraltro nonfanno parte del sistema operativo, né diquello attuale, né della versione 2.0, e

** Programmare in C su A.iga (c) 1991 Dario de Judicibus - Roma (I)

I··_w •• _•• __•• _••• _•••• _•••••••••• *••• _••••••••••••••• *.*.* ••• *** ••• ********

**.. -- -- - -,.- - -- - -- - --- --- - ----- - - --- --- -- ---- ..._-_.-. --.- ----- --- -- - -- ---,** Definizioni da precolpilare per generare la tabella GDGUSRH.SYM

••••••••••••••••••• ** •••••••••••• *•••• *********** *** ••••• *****.* *** ********'

f*Costanti

*f'define TDGGlEON 1'defi ne TDGGlEOFF O'define AUTOOUTTONCLASS Ox0001'define TOGGlEBUTTDNCLASS BxBOB2

f*Tipi

, •• ** •••• *.**** •••• ******** •••• *.********.*** •••• *** •••••••••••••• *••• *** •••** Program.are in C su A.igo (c) 1991 Dorio de Judicibus - Roma (I) **

-._------.----.-----------------------------------.--.---------------- .*Scheletro di un progra.e di gestione dei controlli

Questo file contiene le procedure di tipo generale utilizzatedal progra •• a principale. Questa suddivisione peraette unulteriore rispar.io di tellpo in fase di cOllpilazione. dato chequeste procedure vengono di solito .odificate .alto piùrarallente di quelle del prograllllia principale. In particolarequesto file contiene le procedure di gestione dei controlli.

Queste procedure sono autosufficienti ma vanno cOllpilate selllpre conl 'opzione ~Hskl.sy., in .odo da util izzare gl i headers precolllpilat1.

•• t ••••• _--_._._._*-_._._*._----******************************************* I*f

typedef struct Gadgettypedef struct Border

typedef struct Container{

struct Windo'w *Wi"struct Requester *r;

IGDG;IBRD; f*

Costanti*f

'define EDGl «USHDRT) O)'define PDINTER(type,base,offset) (type *)«UBYTE *)(base)+(offset»'define SWAPPENS(penA,penB,te.p) {te.p • penA, penA' penB, penB • te.p;}

f*** Macro*f

'define GDGMEM {MENF ClEARIMEMF CHIP}'define .ITXTl(itxt) IntuiTextlength((itxt»

/* Questa struttura fa da base ai testi (controlli)*/

/* Penne per' i1 tratto e per lo sfondo * //* Modo grafico e spostamento dal bordo sinistro *//* Sposta.ento da l bordo superi ore * //* Font usato, se diverso da quello di sisteM.. *//* Testo (da riempire) *//* Eventuale struttura successiva */

}ICNT;

typedef struct UsrButton{

USHORT Nullber;USHORT Size;

}UBUT;

f*U Macro di servizio*f

Idefine CreateAutoButton(id,txt,cont,x,y) \CreateButton( (id), (txt) , {cont), (x), {y} ,AUTDBUTTONCLASS,TDGGlEOFF}

'define Del eteAutoButton{b,c} Del eteButton«b), (c)Idefine CreateToggl eButton(id, txt ,cont ,x,y, status) \

CreateButton«id), (txt), (cont), (x), (y), TOGGlEBUTTDNCLASS,(status»'define Del eteToggl eButton(b,c) Del eteButton «b) ,(c»'define ToggleButtonStatus(b) (BOOl)({b}->F1ags & SElECTED)

f*** Prototipi dell e funzioni di servizio

*'IGDG *CreateButton (USHORT, char *, ICNT *, SHORT, SHORT, USHORT, BODl );void DeleteButton (IGDG *, ICNT * );void DisplayGadget ( IGDG *, ICNT * );void RefreshWindow ( struct Window *);

f*** Strutture .ode 11 o*f

ITXT textModel •{

l, O,JAMl, 5,O,NUll,HUll,NUll

);

IBRD rectModel •{

o, a,1, a, JAM1,s,NUll,NUll

};

/* Questa struttura fa da base ai bordi

/* Posizione rispetto il contenitore/* Penne (tratto e sfondo) e modo grafico/* Numero di punt i per il rettangolo/* Vettore delle coordinate/* Eventuale struttura successiva

*f

·*f*f*f*f*f

Figura 1 - gdgusrh. c.

MCmicrocomputer n. 104 - febbraio 1991

Figura 2 - gdgprocs.c: definizioni.

249

AMIGA

non sono descritte in alcun manuale olibro di programmazione su lntuition. Sitratta di procedure da me scritte appostaper questa rubrica e quindi seguono unaimpostazione personale che può o menoessere condivisa. Per questo motivo ri-tengo importante vedere il perché di de-terminate scelte, in modo che, se essenon rispecchiano quelle che sono le vo-stre esigenze, possiate avere una chiaraindicazione di cosa e come modificare ilcodice qui riportato.

Per prima cosa, se un certo parametropuò essere generato automaticamentedal programma sulla base dei dati forniti,od in base ad una serie di criteri stan-dard, esso è eliminato dalla lista di quelliche il programmatore deve specificare,riducendo così consistentemente il nu-mero di informazioni da fornire diretta-mente alle varie funzioni.

Secondo. Le strutture necessarie alladefinizione dei vari controlli sono tutteallocate dinamicamente, in modo da ren-dere le dimensioni del programma indi-pendenti dal numero di controlli che es-so utilizza.

Tre. Pur non essendo il disegno pro-priamente object-based, ho cercato dieliminare nella definizione dei controllil'utilizzo di variabili globali. Se una infor-mazione relativa ad un controllo deve po-ter essere utilizzata da un'altra procedu-ra o dal programma principale, tale in-formazione deve essere incapsulata nelcontrollo stesso. Per far ciò ho utilizzatola possibilità che Intuition mette a dispo-sizione dei programmatori di agganciarein fondo alla struttura Gadget una strut-tura utente, definibile a piacere.

Quattro. Ogni tipo di controllo deveavere un set di funzioni per crearlo e di-struggerlo, ed eventualmente un set difunzioni per gestirne il comportamento,se questo non è gestito direttamente dalntuition. D'altra parte, dato che lo stes-so tipo di funzione per vari tipi di controllipuò richiedere più meno le stesse ope-razioni, queste sono raggruppate in sin-gole funzioni relative a più controlli, salvopoi fornire delle macro che differenzianola funzione a seconda delle varie tipo-logie. Cinque. Le varie funzioni devonoessere indipendenti dal tipo di conteni-tore usato per il controllo (finestra o qua-dro), e dal posizionamento del controllonel contenitore (corpo o bordo della fi-nestra). Per questo motivo si è separatala funzione che crea il controllo, da quellache lo visualizza nel corpo di una fine-stra.

CreateButton()Questa funzione (vedi figura 3) serve

a creare dinamicamente un pulsante a

250

rilascio automatico o manuale. Vediamo-la in dettaglio.

Essa riceve come dati in ingresso set-te parametri:

idl'identificativo del pulsante;

txtil testo da visualizzare nel pulsante;

containeril puntatore ad una struttura contenitore(vedi più avanti);

x, yla posizione nel contenitore del pulsante(più avanti sono spiegati in dettaglio i va-lori che tali coordinate possono assume-re, ed il loro significato);

classil tipo di pulsante, se cioè a rilascio au-tomatico o manuale;

onofflo stato iniziale del pulsante (significativosolo per i pulsanti a rilascio manuale).

Per l'occasione ho definito una nuovastruttura, chiamata Container. Questastruttura, definita in gdgusrh.c (vedi fi-gura 1), contiene il puntatore al conte-nitore del pulsante ed alla finestra a cuiesso è associato, se è un quadro. Ov-viamente, se il contenitore è una fine-stra, il puntatore al quadro è nullo.

Per prima cosa la funzione alloca un'a-rea di memoria che poi suddivide in ottoaree dati. In questo modo si evita di al-locare e poi liberare ogni singola area da-ti. Le otto aree sono rispettivamente:• una struttura Gadget• una struttura IntuiText• quattro strutture Border• due vettori da cinque coordinate l'u-no.

Si associa quindi, per comodità, unpuntatore ad ogni area dati, utilizzando lamacro POINTER definita nella parte di-chiarativa della gdgprocs.c. Questa ma-cro permette di definire un puntatore diqualunque tipo a partire da un altro pun-tatore, non necessariamente dello stes-so tipo, e da uno spostamento in byte[offset] rispetto a quest'ultimo.

A questo punto si definiscono queicampi della struttura Gadget che nonvanno calcolati, come l'identificativo delcontrollo ed il tipo di controllo (cioè unpulsante). Se poi si tratta di un pulsantea rilascio automatico, chiederemo cheemetta solo eventi di tipo GADGETUP,altrimenti dovrà emettere solo eventi ditipo GADGETDOWN, come già spiega-to nella scorsa puntata. In quest'ultimocaso, ovviamente, il pulsante sarà a ri-lascio manuale (TOGGlESElECT). Inol-tre i pulsanti definiti qui sono visualizzatiutilizzando dei bordi, e non delle imma-gini. La tecnica di evidenziazione saràinoltre quella a bordi alternati. Associa-

mo quindi al controllo i puntatori a duedelle quattro strutture bordo preceden-temente definite ed alla struttura Intui-Text. In seguito ne definiremo il conte-nuto.

Vi ricordate quel puntatore disponibileai programmatori per estendere la strut-tura Gadget a seconda delle esigenzedel programmaì Bene, assegniamo a ta-le puntatore una struttura chiamataUsrButton, definita in gdgusrh.c (figura1), e che, per il momento contiene il nu-mero di pulsanti associati a questo con-trollo, e le dimensioni dell'area di me-moria allocata per tutte le strutture re-lative allo stesso.

Il primo valore ci servirà quando de-finiremo dei gruppi, cioè più controlli le-gati logicamente insieme, come i pulsan-ti mutualmente esclusivi. Il secondo cipermetterà di liberare tutta la memoriaallocata con un'unica chiamata, comevedremo più avanti. Chiameremo questaarea, area dati privata del pulsante. Pro-prio nell'ottica di definire in seguito grup-pi di controlli, o controlli multipli, cioècontrolli differenti costruiti in modo daformare un unico controllo, non useremosempre la tecnica di definire una singolacatena di controlli utilizzando il campoNextGadget, ma useremo tale tecnicasolo per legare fra loro controlli appar-tenenti allo stesso gruppo.

A questo punto inizia la parte che de-finisce i restanti campi in modo automa-tico. Innanzi tutto se il pulsante fa partedi un quadro o se deve essere selezio-nato in partenza, vengono modificati op-portunamente i relativi campi già definitiprecedentemente. Quindi si definisce lastruttura IntuiText. Questo viene fattocopiando nell'area dati assegnata a talestruttura, una struttura modello definitain precedenza. Quindi si assegna il testoda visualizzare nel pulsante, e se ne cal-cola altezza e larghezza. A questo puntosi calcola il centraggio del testo nel pul-sante, lasciando un bordo a destra e si-nistra pari ad un ottavo della lunghezzadel testo, e sopra e sotto uno spazio pariad un terzo dell'altezza del testo. Ovvia-mente ognuno può scegliersi i valori chevuole. Per quello che mi riguarda, pre-ferisco definirli proporzionalmente al te-sto stesso, in modo da ottenere un ri-sultato esteticamente proporzionato alfont usato ed alla lunghezza del testo. Danotare che l'altezza del testo è ricavatada uno dei campi della struttura Win-dow in modo dinamico, mentre per lalunghezza viene usata la IntuiTextlen-ght().

Per quello che riguarda invece la po-sizione del pulsante nel contenitore, hodeciso di utilizzare un criterio differenteda quello utilizzato dal sistema. Uno de-gli aspetti più delicati nel disegno di unainterfaccia è infatti quello di definire laposizione dei singoli controlli, in modo daottenere un aspetto esteticamente ac-cettabile, funzionai mente pratico e, se

MCmicrocomputer n. 104 - febbraio 1991

/ •••••••••••••••••••••••••• 11: •• ******.** ••• * •••••••••••••• *** •••••• *.**.*****

•• treateButtonO FUNZIONE Versione 1.00

Funzione fornita: crea dinamicalllente un pul sante a rilasciomanuale.

/*El selezionato in partenza 1

*/if (onoff) Gdg->Flags I· SElECTEO

'*

User lellorizza in Size la .eloria util izzata **

GAOGETOOWNper la classe AUTOBUnONCLASSGAOGETUP per la classe TOGGlEBUTTONCLASS

call1pi variabil i della struttura Gadget

"" 1 + 2*Txt->leftEdge ;"" h + 2*Txt->TopEdge ;

/* Copia il prototipo del controllo *//* Copia 11 testo vero e propri o *//* lunghezza del testo *//* Altezza del testo *//* Ascissa del testo nel controllo *//* Ordinata del testo nel controllo */

Associa al pulsante il suo testo*/

*Txt - textModel ;Txt->IText • (UBYTE*)txt1 • ITXTl(Txt) ;h • container->w->RPort->TxHeightTxt->leftEdge = 1/8Txt->TopEdge = h/3 ;

'*U Alloca i*/Gdg->WidthGdg->Height

puntatore al pulsante

identificativo del pulsantetesto del pulsantecontenitore (finestra e/o quadro)posizione del pulsante nel contenitoreclasse del pulsante (Hpo rnaso;o)stato iniziale del pulsante

Gdg

idtxtcontainerx, yclassonoff

Dati in uscita:

Eventi eless i:

Dati globali:

Dati in ingresso:

/*Per rendere più selRpl lce la vita al prograllllatore, se un callponegativo, lo considerialllo una coordinata rispetto al bordo delcontrollo PIU' VICINO a quello da cui si parte a lIisurare.

/ •••. il bordo sinistro */

••••••••••••• **. * •• *•• * •• *.**** *.*.** **.* ••• *•• *•• *.*.*.***********. ******* /I&OG *CreateButton(id, txt,container,x,y,class,onoff)

USHORTid ;char *txt ;ICHT *containerSHORTx, y ;USHORTc1assBOOl onoff

(/*

Allocheremo otto aree dati:

*/if (x > a)(

x +- container->w->8orderleftGdg->leftEdge • x

}else

/* Ascissa rispetto ad ••• *'

x -= container->w->8orderRightGdg->leftEdge • x - Gdg->Width /* ••• il bordo destro */Gdg->F1ags 1= GRElRIGHT ;

}if (y > a) /* Ordinata rispetto ad... */(

una struttura Gadgetuna struttura IntuiTextquattro strutture Border

-- due vettori da cinque coordinate

*/IGOG *GdgITXT *Txt18RO *Inn8rdUns, *lnnBrdSel, *OutBrdUns, *OutBrdSelU8UT *User ;SHORT ·lnnCoord, *OutCoord ;USHORT GdgSize, TxtSize, 8rdSize, CrdSize, UsrSize, TotSizeUBYTESwapPenSHORTi, 1, h ;

/*** Calcola le dimensioni delle varie aree*/

GdgSize = sizeof(IGOG)TxtSize = sizeof(ITXT)BrdSize = sizeof(IBRO)CrdSize • sizeof(SHORT)*10UsrSize - sizeof(UBUT) ;TotSize •• GdgSize + TxtSize + 4*BrdSize + 2*CrdSize + UsrSize

y +"" container->w->BorderTopGdg->TopEdge • y ;

)else

y -- container->w->BorderBotto.Gdg->TopEdge = y - Gdg->HeightGdg->Flags 1- GRElBOTTOH;

/*Definisci le strutture bordo

*/*InnBrdUns • rectHodel*InnBrdSel • rectModel*OutBrdUns - rectHodel*OutBrdSel - rectHodel

/* ••• i l bordo superi ore * /

/* ••• il bordo inferiore */

GdgSize)TxtSize)BrdSize)BrdSize)BrdSize)BrdSize)CrdSize)CrdSize)

SWAPPENS(Out BrdUns ->front Pen, OutBrdUns ->BackPen, Swap Pen)SWAPPENS(InnBrdSel->FrontPen, InnBrdSe l->BackPen, SwapPen)

if (cla •••• TOGGlEBUTTONCLASS) /* Pulsante a rilascio •• nuale *'(

Inn8rdUns->frontPen - 2; /* Se il pulsante non è selezionato usa un */InnBrdSe l->frontPen - 2; /* colore d i verso da quello dei pulsant i a * /OutBrdUns->FrontPen = B; /* rilascio automatico. Se è selezionato usa */OutBrdSel->FrontPen - 2; /* un doppio bordo per evidenziarlo Ileglio. */

/*Alloca llIemoria per il pulsante e le strutture collegate

*/Gdg • (IGOG *)A11ocMe.(TotSize, GOGMEN);if (Gdg •• NUll) return(NUll) ;Txt • POINTER( ITXT, Gdg,InnBrdUns • POINTER( IBRO, Txt,InnBrdSel - POINTER( IBRO, InnBrdUns,OutBrdUns • POINTER( IBRO, InnBrdSel,OutBrdSel • POINTER( IBRO, OutBrdUns,InnCoord • POINTER(SHORT,OutBrdSel,OutCoord • POINTER(SHORT, InnCoordUser • POINTER( UBUT, OutCoord ,

if (cl a •••• AUTOBUTTONCLASS)(

/* Pulsante a rilascio autolDatico */

/*U Assegna i campi fissi della struttura &adget*/

Gdg->NextGadget • NUll ; /* Questo è un controllo singolo */Gdg->GadgetiO • id ; /* Identif;cativo del controllo *'Gdg->GadgetType • BOOlGAOGET /* Tipo di controllo */Gdg->F1ags • GAOGHIMAGE /* Dato che è evidenziato da un bordo */if (class "'•• AUTOBUTTOHCLASS) /* Se è a rilascio t1utolllatico, allora */

Gdg->Activation '"' RELVERIFY; /*.i interessa sapere se riltlsciato */if (class •• TOGGlEBUnONCLASS) /* Se è a rilascio •• nua1e, allora *'

Gdg->Activation = GAOGIMMEDIATE/* .i interessa sapere quando pre.uto */I TOGGlESElECT;/* (pulsante a rilascio •• nua1e) *'

Gdg->HutualExclude :z NULl /* Hon utilizzato per sicurezza -- */Gdg->SpecialInfo '" NUll ; /* Hon utilizzato -- per sicurezza -- */Gdg->GadgetText = Txt ;Gdg->GadgetRender = (APTR)InnBrdUns ;Gdg->SelectRender = (APTR)InnBrdSe1 ;Gdg->UserOata - (APTR)User /* Questa è una struttura di servizio */User->Size '" TotSi ze /* Qui metto quanta le.oria ho preso * /User->Nulllber - 1 ; /* Numero di pulsanti nel gruppo * /

/*U Il pulsante fa parte di un quadro 1*/

if (container->r) Gdg->GadgetType I· REQGAOGET

Inn8~Uns->NextBorder •. OutBrdUnsInnBrdSel->Next8order '" OutBrdSelOutBrdUns->NextBorder • NUllOutBrdSe1->NextBorder • NUll

Inn8rdUns->XY '" InnCoordInn8rdSel->XY '" InnCoordOut8rdUns->XY • OutCoordOutBrdSel->XY • OutCoord

/*Definisci i vettori di coordinate

*/InnCoord[Z] - Gdg->Width - l; InnCoord[4]' Gdg->Width - l ;InnCoord[5] • Gdg->Height - l ; InnCoord[7] • Gdg->Height - l ;

for (;=B; i<10; i++)OutCoord[i] • InnCoord[i] , (InnCoord[i] 1 l -l)

/*Fatto. Il pul sante è pronto.

*/return (Gdg)

F(gura 3 - gdgprocs.c: CreateButton().

MCmicrocomputer n. 104 - febbraio 1991 251

AMIGA

'******************************************************** ••.•.•*** ••• *********** CreateAutoButtonO MACRO VersioRe 1.66 **

•.• Funzione fornita: crea dina.ica.ente un pulsante a rilascioauto.at ieD.

** Funzione fornita: cancella dina.icalente un pulsante a rilascioautolati eD.

** Dati in ingresso: buttoR pURtatore al pulsllntecontainer contenitore (finestra e/o quadro)

/***************************************************************************** De1eteButtonO FUNZIONE Versione 1.66 **

** Dati in uscita: nessuno

** Dati in ingresso: idtxtcontainerx, y

** Dati in uscita: Gdg

** Dati globali: User

**H Eventi elessi: GADGETUP

identificativo del pulsantetesto del pulsantecontenitore (finestra e/o quadro)posizione del pulsante nel contenitore

pURtatore al pulsante

.e.orizza in Size la .e.aria util izzata ••

•• Dati globali:** .

User ricava da Sile la .e.oria util izzata .*******.*.*********** ••••••••••••••••••••••••••••••••• ********************.

.***** ••• *.***********.*** •• ******** •• **.************.*****.**.************ 1void Delete8utton (button ,container)

IGDG*buttoR ;ICNT*container ;

•• Definita in: gdgusrh.c**** Ndefine CreateAuto8utton(id,txt,cont,x,y) \

CreateButton( (id), (txt). (cont). (x), (y) ,AUTDBUnONCLASS.TOGGLEOFF)

{

1*.* Rimuovi il pulsante dal. contenitore*1

(void) RellloveGli st (container->w, button, l)RefreshWindow(container->w) ;

****** **********************.***************************** ••• **. *.********* 1

Figura 5 - gdgprocs.c: CreateAuto8utton().

1*•• Cancella la Ilelloria per il pulsante e le strutture collegate*1

FreeHe.(button, « (UBUT *) (button->UserData) )->Size»

**".*""** •• ******** •• "•• "••• *•• ****** •• ***** •• ********* ••• *** •• ***.**" ••••••

.* Ndefine De1eteAutoButton(b,c) De1eteButton«b),(c»)

"* Definita in: gdgusrh.c**

** ••••••••• *.* •••••••••• *••• *•• *.".*** ••• ****.******* •••• *.*.*.*******.* **·1

ricava da Size la .e.oria util izzata

un errore. Provate a capire qual è. Larisposta nella prossima puntata.

L'unico controllo che non viene effet-tuato automaticamente è che il pulsante,così posizionato, entri effettivamentenella finestra. Questo è importante spe-cialmente se la finestra che lo contienepuò essere ristretta dall'utente. In que-sto caso sta al programmatore gestiredirettamente il problema.

Come già detto in precedenza, i pul-santi sono disegnati utilizzando un bor-do, così come un bordo alternato è uti-lizzato per l'evidenziazione. Ho deciso didefinire uno standard sia per il colore deibordi, che per la forma degli stessi. Ve-diamo quale, premesso che il colore difondo è «o» mentre il testo è reso conil colore « 1».

Il bordo normale per i pulsanti a rila-scio automatico è formato da un rettan-golo tracciato con il colore « 1» delle di-mensioni dell'area di selezione, inscritto

nessuno

User

** Dati in ingresso: buttoR puntato re al pulsantecontainer contenitore (finestra elo quadro)

"* Dati in uscita:

.* Funzione fornita: cancella dina.ica.ente un pulsante a rilascioautolDatico. !

.* Dati globali:

1*·**·····················*·*·····*··**·***···**********.**************".*."** De1eteAutoButtonO MACRO Versione 1.66 **

Figura 6 - gdgprocs.c: ~DeleteAuto8utton().

~Figura 4 - gdgprocs.c.·Delete8utton().

da quello inferiore della finestra, e sot-trarre il tutto dalle dimensioni della fi-nestra stessa, come si può vedere in fi-gura 12. Per ovviare a ciò, la Create-ButtonO si comporta nel modo seguen-te:

Se le ascisse sono positive, si riferi-scono alla distanza del bordo sinistro delpulsante dal bordo sinistro del conteni-tore, se sono negative, si riferiscono alladistanza del bordo destro del pulsantedal bordo destro del contenitore. Ana-logamente, se le ordinate sono positive,allora si riferiscono alla distanza del bor-do superiore del pulsante dal bordo su-periore del contenitore, se sono nega-tive, si riferiscono alla distanza del bordoinferiore del pulsante dal bordo inferioredel contenitore.

In aggiunta a questo, la distanza vienecalcolata già tenendo conto delle dimen-sioni dei bordi stessi. A questo riguardoil codice della Create Butto nO contiene

possibile, intuitivo. Molti hanno l'abitu-dine di disegnare i vari elementi dell'in-terfaccia su un foglio di carta millime-trata o, in mancanza di un generatore au-tomatico di codice, sullo schermo permezzo di un prodotto tipo OPaint od an-che un CAD. Si tratta comunque di unprocesso elaborato, di fatto eccessivo senon si sta sviluppando un grosso pro-getto, e che richiede tempo e pazienza.All'altro estremo c'è la tecnica ad occhio,in cui si danno le coordinate degli oggettiin modo approssimato, per poi modifi-carie leggermente ad ogni compilazione,fintanto che non si è ottenuto il risultatovoluto. Questo processo è più rapido segli oggetti sono pochi, e sfrutta il fattoche comunque, nel processo di sviluppodi un programma, è necessario spessoricompilare più volte un programma acausa dei vari errori che immancabilmen-te esso contiene e che vanno quindi eli-minati. Questa seconda tecnica è suffi-cientemente accurata se si definisce laposizione relativamente ad un altro og-getto vicino, e se questa non dipendedalle dimensioni dell'oggetto.

Supponiamo ora di avere un pulsantecon su scritto Premini! Se lo vogliamoposizionare in alto a sinistra nel corpo diuna finestra, possiamo definire le coor-dinate dell'origine del pulsante (10,10).ad esempio, assumendo di avere una fi-nestra abbastanza larga ed alta. Ma selo vogliamo posizionare nell'angolo inbasso a destra? Allora bisogna calcolarela lunghezza e l'altezza del pulsante, ag-giungervi la distanza che lo stesso deveavere rispettivamente dal bordo destro e

252 MCmicrocomputer n. 104 - febbraio 1991

AMIGA

/************************************************************~**************** CreateToggleButtonO MACRO Versione l.ee **

** Funzione fornita: crea dinalicamente un pulsante a rilascio.anuale.

/***************************************************************************

** Funzione fornita: cancella dina.icalllente un pulsante a ril,asciolIanua1e. I

** Dati in uscita: nessuno

** DeleteToggleButtonO

**Versione 1.80

puntatore al pulsantecontenitore (finestra e/o quadro)

MACRO

buttoncontainer

** Dati in ingresso:**

puntatore al pulsante

identificativo del pulsantetesto del pulsantecontenitore (finestra e/o quadrd.)posizione del pulsante nel contenitorestato iniziale del pulsante

.e.orizza in Size la .e.oria util izzata **

** Dati in ingresso: idtxtcontainerx, yonoH

** Dati in uscita: Gdg

** Dati globali: User**** [venti emessi: GADGHDIMl

**************************************************************************** ** Dati globali:**

User ricava da Size la leloria util izzata

** Definita in: gdgusrh.c

** Ndefine CreateToggle8utton(id,txt,cont,x,y,status) \** . CreateButton«id), (txt), (cont), (x), (y), TOGGLEBUTTONCLASS,(status»** ******************************************.,)********************************** /

** Definita in: gdgusrh.c**** 'define DeleteToggleButton(b,c) DeleteButton«b),(c»

***************************************************-********************** /

Figura 7 - gdgprocs.C: CreateToggleButtonl!. Figura 8 - gdgprocs.c: DeleteToggleButtonl!.

in un rettangolo di colore «O» appena diun pixel più grande. Quello alternato èinvece formato da un rettangolo traccia-to con il colore «O» delle dimensioni del-l'area di selezione, inscritto in un rettan-golo di colore «1» appena di un pixel piùgrande. La necessità di utilizzare duebordi bicolore invertiti, nasce dal fattoche, come diremo più avanti, i pulsantisono disegnati nella stessa bitmap dellafinestra, e quindi è necessario aggiun-gere al rettangolo visibile del bordo, unrettangolo dello stesso colore dello sfon-do che cancelli il rettangolo visibile delbordo alternato (e viceversa, ovviamen-te).

Il bordo normale per i pulsanti a rila-scio manuale è formato da un rettangolotracciato con il colore «2» delle dimen-sioni dell'area di selezione, inscritto in unrettangolo di colore «O» appena di un pi-xel più grande. Quello alternato è inveceformato da due rettangoli, entrambi di-segnati con il colore «2», uno dentro l'al-tro, in modo da rendere lo stesso ret-tangolo del bordo normale con un trattopiù spesso. Il motivo di tale scelta è ilseguente. Innanzi tutto così l'utente sasubito se il pulsante è a rilascio auto-matico o manuale, in quanto essi usanocolori differenti per i bordi. Inoltre, nelcaso dei pulsanti a rilascio manuale, de-ve essere immediato all'utente se unpulsante è nello stato selezionato o me-no.

Ora, mentre per i pulsanti a rilascio au-tomatico il risultato finale è quello di ve-dere il bordo del pulsante allargarsi e poirestringersi quando l'utente lo selezionacon il mouse, per quelli a rilascio ma-nuale, due bordi dello stesso spessoreche differiscono di poco nelle dimensioninon sono certo un modo di evidenziare

chiaramente in quale stato si trova il pul-sante. Ecco il perché del doppio bordocolorato per questo tipo di pulsanti. Pro-vare per credere.

I bordi sono quindi quattro per ognitipo di pulsante raggruppati a due a due.Anche in questo caso, ho utilizzato unbordo come modello da copiare prima dieffettuare le variazioni descritte.

A questo punto il gioco è fatto, e lafunzione restituisce il puntatore al pun-sante così definito.

DeleteButton()Questa funzione (vedi figura 4) di-

strugge un pulsante creato con la fun-zione precedente. Esso rimuove prima ilpulsante della lista dei controlli associatialla finestra, quindi restaura la finestrastessa (corpo e bordo) ed i controlli ri-masti. A questo punto, utilizzando l'in-formazione contenuta nella struttura pri-vata del pulsante, libera in un sol colpotutta la memoria relativa al controllo, in-dipendentemente dal modo in cui essaera suddivisa. Questo è corretto solo se,come in questo caso, tutte le strutturecontenute nell'area liberata sono refe-renziate solo all'interno dell'area stessa.In caso contrario è necessario prima an-nullare tutti i puntatori di strutture ester-ne che al momento della deallocazionestiano ancora puntando all'interno del-l'area da rendere di nuovo disponibile alsistema.

Notate che questa tecnica permette dimodificare la CreateButton() aggiun-gendo nuove strutture all'area di memo-ria allocata dinamicamente, od esten-dendo quelle attualmente definite, sen-za dover modificare conseguentementela funzione DeleteButton(), dato che

l'informazione della memoria allocata èincapsulata nell'oggetto stesso. Questoè uno dei vantaggi dell'adozione di tec-niche basate sugli oggetti [object-ba-sed]. che trova la sua massima espres-sione nella metodologia 00 [object-o-rientedj, in cui l'allocazione e la deallo-cazione degli oggetti è del tutto traspa-rente al programmatore, ed ogni oggettoracchiude in sé sia la procedura che i datiche lo riguardano.

Naturalmente qui ci stiamo ancoramuovendo secondo uno stile procedu-ra/e, e quindi «classico». Anche così, tut-tavia, possiamo utilizzare alcune tecni-che di questo tipo, che ci fanno rispar-miare molto tempo, sia in fase di pro-grammazione che di manutenzione delcodice.

DisplayGadget()Questa funzione (vedi figura 10) ag-

giunge un controllo al contenitore e quin-di lo visualizza. Come si può facilmentevedere, essa non è strettamente legataai pulsanti, né serve solo per i controllidirettamente associati ad una finestra.Grazie all'utilizzo della più generale strut-tura Container, essa può essere utiliz-zata anche per aggiungere un controlload un quadro, purché appunto il secondopuntatore di questa struttura non sia nul-lo.

Refresh Window()Questa funzione (vedi figura 11) serve

a ripristinare quella parte della finestrache possa essere stata danneggiata daun controllo appena rimosso. Infatti, alcontrario di quello che succede in altrisistemi, come il Presentation Manager

MCmicrocomputer n. 104 - febbraio 1991 253

AMIGA

Versione 1.88FUNZIONE/1l ••• ********************,***************************,* •• '*""•• *-.'!!.__ ••••••••••

00H RefreshWi ndow() .0.* Funzione fornita: restaura una finestra e tutti i control1 i in essa

contenuti.

•• Dati in ingress.o: Wl" puntatore a11a fi "estra/_'Il_.*_ ••• *. * ••••••• * •••••• * •••••••••••••••• * •••••• * ••••••••• _. __••• * ••• *H ToggleButtonStatus() MACRO Versione 1.88 00

H

ritorna lo stato di un pulsante a rilascio .anuale*._._ ..• * ••••• __*••••• *••••••••• _. __•••• __*_••.••• _*--*-*--* •••• 1< ••••.•• - •.• - * Ivoid RefreshWindow(win)

struct Window ·Wl"

** Funzione fornita:

*- Dati 1n ingresso: button puntatore al pulsante

** Dati in uscita: nessuno

*******************************************************.****** ••••••••• *••••

00 Definita in: gdgusrh.c00

00 Dati in uscita:

00 Dati globali:00

status

User

TOGGlEONoppuro TOGGUOFF

ricaYI da Sile la .e.oria util izzata

IGDG ·first ;

SetRast(win->RPort,8); ,. Ridipingia.o 10 sfondo della finestra *'RefreshWindowFra.e(win) ; ,. Ricostruia.o i bordi che abbia.o distrutto .,first '""win->FirstGadget ;,. Pri.o controllo per questa finestra .,if (first) 1*Restaura tutti i controlli *1

(void)RefreshGlist(first,win,NUll, [DGl) ;

00 'define ToggleButtonStatus(b) (BOOl)«b)->Flags & SElECHO)00

•• * •••••••••••••••••••••••••••••••••••••••••••••••••.••••••••••••••••••••••• 1Figura 11 - gdgprocs.C: RefreshWindowO.

Figura 9 - gdgprocs.c: ToggleButtonStatusO.

•• Funzione fornita: aggiunge 11 controllo al contenitore e quindi 10•• visualizza

•• Dati in ingresso: gadget puntato re al controllocontainer contenitore (finestra elo quadro)

--x-I Prni.i! IQui il calcolo è intuitivo,essendo X ed Y la distanzatra i bordi della finestrae quelli del pulsante piùvicini al contorno dellafinestra stessa .

la posizione e calcolatarispetto l'origine delcontenitore.

FUNZIONE00 Olsp layGadget O00

1···················*··*··········*··***·*······*·····*••••••• ****** •• ** ••••Versione l.OO ••

/0

•••• *••• *•• * •••••• * •••• *.***.**.*.**.***** ** ***.** ** **. ** •••••••• *.** *••• *·1

I

~w - (

Y'H-(h+y)

X.W-(w+x)

Qui i valori più facili davi sua 1i zzare sarebbero xed y, .entre quelli che sidevono fornire ad lntuitionsono X ed Y, ricavabl1 i nel.odo seguente:

nessuno•• Dati in uscita:

Aggiungi 11 pulsante al contenitoreo/

(void)AddGl i st (contai ner->w ,gadget, [DGL, 1, contai ner->r)RefreshGL i st (gadget, container->w I conta iner->r ,1) ;

void OlsplayGadget(gadgot ,containor)IGOG °gadget ;ICNT ·container ;

Figura lO - gdgprocs.c: DisplayGadgetO. Figura 12 - Posizionamento classico di un pulsante.

dell'OS/2, i pulsanti non sono mantenutiin una bitmap separata, come avvieneanche nell'Amiga per i menu, ma sonodisegnati nella stessa bitmap della fine-stra. Quindi quando si toglie un pulsantedal corpo di una finestra, il disegno delbordo, o l'immagine utilizzata rimango-no.

Ovviamente il vero pulsante, cioè l'a-rea di selezione, non c'è più. t neces-sario allora ripristinare a mano l'area inquestione, anche se si sta lavorando conuna finestra a restauro automatico.

Per far questo abbiamo usato unatecnica brutale, che ridipinge lo sfondodella finestra, quindi ricostruisce i bordidistrutti da questa operazione e rivisua-lizza tutti i controlli ancora associati adessa.

Questo in quanto, a meno di non uti-

lizzare una finestra GZZ, anche i bordi,come gli altri controlli posizionati nel cor-po della finestra, fanno parte della stessabitmap.

Ovviamente voi potete scrivervi unafunzione più sofisticata, oppure gestire iltutto nelle funzioni CreateButtonO eDeleteButtonO.

Ad esempio, se volete visualizzare unpulsante in una finestra che contieneuna immagine, senza rovinare la stessa,potete estendere la struttura privata alpulsante aggiungendovi un puntatore adun'area di memoria grande come il pul-sante e con lo stesso numero di pianidella finestra, trasferirvi lì l'area che deveessere ricoperta dal pulsante e, al mo-mento di rimuovere il pulsante, ritrasfe-rire nella finestra l'area coperta. Magaripotreste provarci come esercizio.

CreateAutoButton()

Questa macro (vedi figura 5) permettedi chiamare la funzione CreateButtonOgià predisposta per la creazione di unpulsante a rilascio automatico.

DeleteAutoButton()

Questa macro (vedi figura 6) permettedi chiamare la funzione DeleteButton Ogià predisposta per la rimozione di unpulsante a rilascio automatico.

Create ToggleButton()

Questa macro (vedi figura 7) permettedi chiamare la funzione CreateButtonOgià predisposta per la creazione di unpulsante a rilascio manuale.

254 MCmicrocomputer n. 104 - febbraio 1991

Delete ToggleButton()Questa macro (vedi figura 8) permette

di chiamare la funzione DeleteButton()già predisposta per la rimozione di unpulsante a rilascio manuale.

ToggieButton5tatus()Questa macro (vedi figura 9) permette

di invertire lo stato di selezione di un pul-sante a rilascio manuale. Va utilizzata,come vedremo nella prossima puntata,nella procedura di gestione degli eventiemessi dai pulsanti a rilascio manuale, oda quelli a rilascio automatico e che fan-

no parte di un gruppo di pulsanti mu-tualmente esclusivi.

ConclusioneBene. Penso che adesso abbiate ma-

teriale a sufficienza per costruirvi il vo-stro set di funzioni per la definizione deipulsanti.

Provate a creare nuovi tipi di pulsantie magari provate a modificare le funzioniproposte in modo da usare immagini an-ziché bordi, magari seguendo lo stile delWorkBench 2.0.

Mi spiace di dover escludere da que-sta puntata la rubrica Casella Postale, an-

AMIGA

che perché ho ricevuto moltissime let-tere e molti messaggi via MC-Link. Pur-troppo lo spazio è quello che è, e pensoche sarebbe stato pesante spezzettarel'argomento di questa puntata su duenumeri di Me.

Ci rivediamo con le vostre lettere nellaprossima puntata.

A presto, quindi.

La scheda tecnicaEcco i quattro comandi dell'AmigaOos 1.3 di questo me-se, a partire da SETDATE.

NotaNella scorsa puntata avevo promesso di parlare delle carat-

teristiche di rientranza e di riusabilità dei programmi. Per ragionidi spazio non mi è stato possibile includere l'argomento suddettoin questa puntata. Cercherò di metterlo nella prossima. Mi scusocon i lettori per questo cambiamento, peraltro dettato da incon-testabili necessità editoriali.

LEGENDA

<parametro> parametro da specificare

[<opzione>] parametro opz; ona le

{<opz-rip>} parametro opziona1e che può essere ripetuto n volte

... serie che può essere continuata

I separatore per una 1 ;sta di opzioni di cui una almeno VAspecificata .-'.

/A indica che il parametro DEVEessere specifiu.to

/K indica che quella deteminata parola chiave VA specificatase s; vuol e usare l'opzione ad essa oIssociata

/S indica una parola chiave da specificare per attivarel' operazi one ad essa associata

Comando: SETDATE

Formato: SETDATE<file>l<indirizzario> [<dat»] [<ora>]

Sintassi: SETDATE "FILE/A,DATE, TINE"

Scopo: Cambia la data e l'ora associata ad un file od un indirhzario

Speci f iche: Al contrari o de 11 a vers i one precedente, non è più necessari ospecificare uno zero nella data, se il giorno è compreso fraI e 9 inclusi. Se non sono forniti nè la data nè l'ora, ilcomando ut;lizza come valori quelli correnti, cioè quellidell'orologio del s istell\a (touch].

Esempio: SETDATE fr.d 15-Har-1999 12:27

Comando: SETENV

Formato: SETENV<variabile> <valore>

Sintassi: SETENV "NAHE/A,STRINC"

Scopo: Serve a specificare il valore di una varhbile di sisteu

Sp.cifich.: Serve ad associare ad una variabile globale un detenlinatovalore, a cambiarne uno precedenteMente specificato, od •.rimuovere la variabile stessa. Nella versione 1.3 questevariabil i sana .e1IOrizzate nel disco RAM: sotto l' indirhzarioWenvlt, al quale va assegnato 11 identificativo EHV:. In seguitoENV: diventerà un Ithand1erw vero e propria. la variabile vienerimossa se non si specifica alcun valore, anche se, per ora, i!nome della variabile rhnane in RAH:env. Se il valore contienespazi o caratteri speciali interpretabili da CLI o da SHEll,bisogna includere il valore f.ra doppie virgolette.l'utente può anche MOdificare la Wstartup-sequencelt in lIOdo daassociare ENV: ad un altro indirinario, anche s·u disco fisso,ma non è consig1 bbile per ragioni di prestazioni.

Esempio: SETENVDictionary SYS:WP/l •• /itol iano.dct

Comando: SETPATCN

Formato: SETPATCH[R]

Sintassi: SETPATCH"R/S"

Scopo: Fiss~ alcuni proble.i nelle ROM1.2 ed 1.3 del KickStort

Specifiche: Deve essere 1andato COMePRIMAistruzione della procedura"startup.sequeneelt, e penaette di fissare .1 cuni prob1 •• iesistenti nelle ROMdel KickStart 1.2 ~d 1.3 e che non potreb-bero altri.enti essere eliminati se non sostituendo le stesse.I bachi riguardano la Di spl ayAlert O , i vettorj delle eccezio-ni mat •••• tich. d.l 68099, D.1e~.L.y.rs(), .d Ali ocEntry().l'opzione R va usata in quei sistelli con 1Mb di lIellOria CHI'per evitare effetti eollaterali sulla rudrive.device.

Comando: SKIP

formato: SKIP «edichetta» [8ACK]

Sintassi: SKIP "LA8EL,BACK/S"

Scopo: Salto incondizionato al1'edichetta specificata.

Specifiche: Comando da ut il tzzare solo nelle Nero di si stellél (SCRIPT).Opera un salto incondizionato all' istruzione lAS identificatadall'edichetta fornita, o .da una edichett. nulla, se non ne èstata speciHcata alcuna. la ricerca avviene a partire dallaistruzione corrente. Se è stata specificata l'opzione BACK, 1.ricerc,l avviene dalla prima istruzione della lUcra, a "no chequesta non contenga comandi EXECUTE.In tal caso, il •• ltoall' indietro non va oltre all' istruzione che chi .•.• EXECUTE.

Esempio: SKIP pippo

MCmicrocomputer n. 104 - febbraio 1991 255.