Ci sono due tipi di dialog: quello "modeless", creato con /dialog comandi, e quello "modal", creato con l'identificatore $dialog().

Dialog modeless
La sintassi è:

/dialog -mdtsonkcvie nome [table] [x y w h] [testo]

-m Crea un dialog modeless usando "table"
-a Usato con -m apre il dialog nella finestra attiva
-x Chiude il dialog
-d Apre il dialog sul desktop, da usare con -m
-t Imposta il titolo del dialog. Es. /dialog -t nome testo
-s Imposta la grandezza e la posizione del dialog. Es. /dialog -s nome x y w h
-r Centra il dialog
-bp Interpreta la grandezza del dialog come dbu o pixels
-o Imposta il dialog sopra a tutte le altre finestre
-n Il contrario di -o
-k Simula la pressione del bottone OK
-c Simula la pressione del bottone CANCEL
-v Imposta il dialog come finestra attiva
-ie Minimizza/Ripristina il dialog se creato sul desktop

Dove "table" rappresenta il nome assegnato al dialog durante la sua costruzione, e "nome" il nome che verrà assegnato al dialog.

L'identificatore $dialog()
Questo identificatore è usato per la creazione di modal dialogs. Quando un dialog di questo tipo è aperto, non è possibile accedere ad altre finestre, per questo motivo si consiglia di utilizzarlo solo per ricevere input all'entrata di un utente, o funzioni simili.

%risultato = $dialog(nome,table[,parent])

"nome" è il nome assegnato al dialog, "table" è il nome assegnatogli durante la sua costruzione, e "parent" indica il luogo dove il dialog è situato. Il parent può essere:
il nome di una finestra
-1 La finestra del desktop
-2 La finestra principale del mIRC
-3 La finestra attiva
-4 Il dialog aperto, se nessun dialog è aperto viene impostata di default la -3

Nota. Questo tipo di dialog non può essere richiamato da un evento dei remote script.

È possibile usare anche l'identificatore $dialog(nome,N) per elencare qualsiasi dialog aperto, in cui N restituisce la "posizione" del dialog. $dialog() supporta le seguenti proprietà:

x,y,w,h Restituisce la grandezza e la posizione del dialog.
cw,ch Restituisce la larghezza e l'altezza dell'area del client del dialog.
title Restituisce il titolo del dialog.
Modal Restituisce il valore $true se il dialog è modal, altrimenti $false.
table Restituisce il dialog table se questo è usato nel dialog.
ok Se esiste restituisce l'id del bottone ok
cancel Se esiste restituisce l'id del bottone cancel
result Se esiste restituisce l'id del bottone result
focus Restuisce l'id dell'oggetto focalizzato
tab Restituisce l'id del tab visualizzato
active Restituisce $true se il dialog è la finestra attiva, altrimenti $false

Passiamo ora alla costruzione di un dialog.

dialog [-l] nome {
title "titolo"
icon filename, index
size x y w h
option type (dbu, pixels, notheme)
text "testo", id, x y w h, style (right, center, nowrap)
edit "testo", id, x y w h, style (right, center, multi, pass, read, return, hsbar, vsbar,
autohs, autovs, limit N)
button "testo", id, x y w h, style (default, ok, cancel, flat, multi)
check "testo", id, x y w h, style (left, push, 3state)
radio "testo", id, x y w h, style (left, push)
box "testo", id, x y w h, style
scroll "testo", id, x y w h, style (top left bottom right horizontal range N N)
list id, x y w h, style (sort, extsel, size, vsbar, hsbar)
combo id, x y w h, style (sort, edit, drop, size, vsbar, hsbar)
icon id, x y w h, filename, index, style (noborder top left bottom right)
link "testo", id, x y w h
tab "testo", id, x y w h
tab "testo", id
menu "testo", menuid [, menuid]
item "testo", id [, menuid]
item break, id [, menuid]
}

Cerchiamo di fare un po' di chiarezza:
Innanzi tutto inserendo lo switch -l all'inizio del codice, si renderà il dialog accessibile solo ad altri script scritti nello stesso file.
Per creare un dialog si usa il prefisso dialog seguito dal nome del dialog. In questo caso il nostro si chiama nome (e poi dicono che non ho fantasia…). Text è un qualsiasi testo inserito, id il numero che identifica un controllo (button, check, list, ecc.), x y w h la posizione e la grandezza del controllo e style una combinazione di parole che andranno a costituire le "caratteristiche" del controllo. Vediamo quali sono e a cosa servono questi styles:

Styles
disable disabilita il controllo
hile nasconde il controllo
gruop avvio di un gruppo
result identifica il controllo con un valore che sarà usato come valore di ritorno dallo script quando l'utente premerà il tasto OK.
left allineamento a sinistra (anche di immagini)
right allineamento a destra (anche di immagini)
center allineamento centrato
multi casella di testo multilinea
pass casella di testo password (criptata in asterischi *)
read casella di testo in sola lettura
return casella di testo con a capo automatico (in caselle di testo multilinea)
hsbar barra di scorrimento orizzontale
vsbar barra di scorrimento verticale
autohs barra di scorrimento orizzontale automatica
autovs barra di scorrimento verticale automatica
limit N casella di testo con numero di caratteri limitato ad N caratteri
default pulsante di comando predefinito
ok pulsante di comando con valore modale "Ok"
cancel pulsante di comando con valore modale "Annulla"
push check o radio button con aspetto di pulsante button
3state check button a 3 stati (checked, unchecked, grayed)
sort listbox ordinata alfabeticamente
extsel listbox a selezione multipla
size listbox ad altezza auto-adattata
edit combobox con casella di testo editabile
drop combobox con listbox a discesa
noborder immagine senza bordo
top immagine allineata in alto
bottom immagine allineata in alto

Ogni controllo può utilizzare determinati styles, questi sono riportati nella costruzione del dialog nome (sopra) accanto ad ogni controllo e situati nelle parentesi.

TAB
La definizione associata al primo tab specifica la grandezza di questo; tutti gli altri avranno le dimensioni del primo. È possibile associare un controllo ad un tab, aggiungendo alla fine della sintassi del controllo lo style tab seguito a sua volta dal rispettivo id.

dialog provatab {
title "mIRC"
size -1 -1 110 100
option dbu

tab "m", 1, 5 5 100 90
tab "I", 2
tab "R", 3
tab "C", 4

button "m sta per ...BOH!", 11, 30 50 50 24, ok tab 1
button "I sta per Internet", 12, 30 50 50 24, tab 2
button "R sta per Relay", 13, 30 50 50 24, tab 3
button "C sta per Chat", 14, 30 50 50 24, tab 4
}

Ed ora dalla riga di comando scriviamo /dialog -m provatab provatab

Menu
Si possono anche aggiungere menu e sottomenu al dialog come segue:

dialog provamenu {
menu "text", <menuid> [, menuid]
item "text", <id> [, menuid]
item break, <id> [, menuid]
}

Se non viene specificato il menuid per l'item, verrà usato l'ultimo menuid usato/creato nel menu/item precedente.

dialog provamenu {
title "mIRC"
size -1 -1 110 100
option dbu

menu "&File", 60
item "&Nuovo", 70

menu "&Carica", 80, 60
item "&Script", 90

item break, 100
item "&Utenti", 110
item "&Variabili", 120

item "&Togli", 130, 60

item break, 140

item "&Salva", 150
item "&Salva come...", 160
item "Salva &tutto", 170

item break, 180

item "Salva && &esci", 190, ok
item "&Annulla", 200, cancel
}



Con "/dialog -m provamenu provamenu" (senza le virgolette) attiveremo il nostro dialog. D'ora in poi ricordatevi che per visualizzare un esempio dovrete digitare dalla riga di comando /dialog -m nomedialog nomedialog

/did
Grazie a questo comando è possibile abilitare o disabilitare un oggetto, spuntare un check o viceversa, soprascrivere un menu item, ecc. ecc. ecc. Vediamo qualche esempio:

Per aggiungere un item ad un menu si può usare:
/did -a nome <menuid> <nuovoid> <testo>

Per inserire un item si usa:
/did -i nome <id> <nuovoid> <testo>
dove <id>

Dbu vs Pixels
Dbu fa si che la visualizzazione del dialog non dipenda dalla risoluzione usata da un utente; pixels invece interpreta il valore specificato in pixels. Gli identificatori $dbuw e $dbuh ne restituiscono il valore della larghezza e dell'altezza.

Ok, Cancel
Sono necessari per il funzionamento del dialog, infatti è necessario inserire all'interno del codice di quest'ultimo un bottone con uno di questi styles (Es. button "Chiudi" 1, 59 67 20 10, ok), che hanno la particolarità di chiudere il dialog.

Size
Size specifica la posizione e la grandezza del dialog secondo x y w h; dove x è la distanza dal lato sinistro dello schermo al vertice sinistro del dialog, y la distanza dal lato alto dello schermo al vertice sinistro del dialog, w e h la larghezza e l'altezza del dialog. Ponendo x e/o y con valore -1 il dialog verrà centrato.

Gli eventi del dialog
Ogni controllo per funzionare ha bisogno del rispettivo evento che si verificherà quando il primo verrà attivato. Ossia, se nel dialog abbiamo inserito un bottone; al premere di questo dovrà succedere qualcosa, altrimenti a che serve??? ;)

on 1:dialog:nomedialog:evento:id: {
echo $dname $devent $did
}

l'id della sintassi si riferisce all'id dell'ipotetico controllo che stiamo analizzando.
Gli eventi che possiamo utilizzare sono:

init Si riferisce all'apertura del dialog (una sorta di on start del dialog per capirci); il suo id è sempre 0.
close Quando un dialog è chiuso
edit Viene utilizzato per i controlli nei quali editiamo o modifichiamo un testo (editbox, combo box).
sclick Sta per un solo click, viene usato per i bottoni, radio, check, ecc.
dclick doppio click su un controllo (link, list/combo box)
menu simile ad sclick, ma specifico per gli item.

Anche il mouse ha i suoi eventi, che non sono associati a nessun controllo:

mouse movimento del mouse
sclick bottone sinistro premuto
uclick bottone sinistro alzato
dclick doppio click
rclick click bottone destro
drop drop click

Con l'identificatore $mouse è possibile ottenere la posizione del mouse.

Il comando /did
Grazie a questo comando è possibile modificare i valori dei controlli del dialog. La sintassi è:

/did -ftebvhnmcukradiogj nomedialog id [n] [text | filename]

-f focalizza il controllo
-t rende il controllo pulsante di default (enter)

-e abilita il controllo
-b disabilita il controllo
-v rende l'oggetto visibile
-h rende l'oggetto invisibile

-n abilita la editbox
-m disabilita la editbox

-c seleziona un checkbox/radiobutton o una linea di un list/combo.

-u inverso di -c
-k lavora con -cu, tiene le altre selezioni in un listbox.

-r cancella tutto il testo presente in un controllo
-a aggiunge una linea di testo alla fine
-d elimina la linea N
-i inserisce il testo nella linea N
-o sovrascrive la linea N con il testo specificato

-g inserisce una nuona icona/bmp/jpg al controllo icon specificato
/did -g nomedialog id [n] filename

-z resetta l'ampiezza dello scrollbar orizzontale nella listbox

-j ripristina un editbox

Se si vuole modificare più controlli simultaneamente gli id di questi devono essere separati da una virgola. Es. /did -b nomedialog 2,12,14,16

$did(nome,id)
Questa stringa viene usata generalmente per salvare i settaggi di un controllo, come il testo di un edit, il stato di un checkbox, ecc. Il parametro nome è opzionale. Vediamo ora le proprietà:

text: Restituisce il testo dell'oggetto. Scrivere $did(id).text o $did(id) è la stessa cosa.
len: Restituisce la lunghezza del testo (o della linea N se specificata). Es. $did(id,N).len
lines: Restituisce il numero delle linee
sel: Restituisce la posizione della linea selezionata. Se N è uguale a 0 restituisce il numero delle linee selezionate.
seltext: Restituisce la parte di testo selezionato, mentre in un listbox il testo dell'oggetto selezionato.
selstart: Restituisce il carattere iniziale selezionato nella linea dell'editbox
selend: Restituisce il carattere finale selezionato nella linea dell'editbox
edited: restituisce $true se il testo dell'editbox è stato modificato
state: Restituisce lo stato di un check o di un radio ( 0 = off, 1 = on, 2 = indeterminato) next: restituisce l'id dell'oggetto successivo ad esso secondo il tab order
prev: restituisce l'id dell'oggetto precedente ad esso secondo il tab order
visible: restituisce $true se l'oggetto è visibile, altrimenti $false
enabled: restituisce $true se l'oggetto è abilitato, altrimenti $false

Sezione Pratica Dialogs
Dopo aver analizzato l'aspetto teorico dei dialogs, è bene fare un po' di pratica. Creiamo insieme un dialogs per la gestione di "auto join", ossia un tools dal quale l'utente potrà scegliere i canali in cui entrare automaticamente una volta connesso ad un server. Andiamo nella sezione remote e cominciamo il nostro lavoro:

;::::::::::::::: DIALOG AUTO JOIN ::::::::::::::

dialog aj {
title " Auto Join"
size -1 -1 212 116
option pixels
list 1, 0 3 120 130
check "Attiva" 2, 124 4 80 16, push
edit "" 3, 124 24 80 18, center
button "Aggiungi" 4, 124 50 80 16
button "Elimina" 5, 124 70 80 16
button "Chiudi" 6, 124 96 80 16, ok
}

Creiamo ora un alias per semplificarci l'esecuzione del dialog:

alias autojoin { dialog -m aj aj }

Ora scrivendo /autojoin dalla riga comando visualizzeremo il nostro dialog



Una volta impostato graficamente il dialog, si lavora con gli eventi:

:::::::::::::::::::::: EVENTO INIT ::::::::::::::::::::::

on *:dialog:aj:init:0:{
var %rigo = 1 | while ($lines(aj.txt) >= %rigo) {
did -a aj 1 $read -l $+ %rigo aj.txt | inc %rigo
}
if (%aj != on) { did -b aj 1,3 } | else { did -c aj 2 | did -ra aj 2 Disattiva }
did -b aj 4,5
}

Questo evento, come spiegato precedentemente, si riferisce all'apertura del dialog; nel nostro caso impostiamo una variabile volante con il nome di %rigo e gli assegnamo il valore 1, con il comando while creiamo un ciclo che avrà termine solo quando la variabile %rigo restituirà lo stesso valore delle linee presenti nel file aj.txt ( while ($lines(aj.txt) >= %rigo) ).Ossia se in quest'ultimo ci sono 10 righe, while farà eseguire i comandi in esso contenuto (il codice all'interno delle due parentesi graffe) per 10 volte. Questi comandi non fanno altro che leggere la riga (specificata dalla variabile %rigo) e riportarla nel nostro dialog, per poi incrementare la variabile %rigo di 1 (did -a aj 1 $read -l $+ %rigo aj.txt | inc %rigo).
Eseguita questa parte di codice, mIRC controlla il valore della variabile %aj; se questo è diverso da ON disabilita i controlli 1 e 3; se invece non è diverso visualizza come selezionato il check "Attiva" e gli cambia il testo in "Disattiva" (if (%aj != on) { did -b aj 1,3 } | else { did -c aj 2 | did -ra aj 2 Disattiva }).
Infine disabilita gli oggetti 4 e 5 (did -b aj 4,5).

::::::::::::::::::: EVENTO SCLICK ::::::::::::::::::::::::

on *:dialog:aj:sclick:*:{
if ($did == 1) { if ($did(1).sel != $null) { did -e aj 5 } | else did -b aj 5 }
if ($did == 2) {
if ($did(2).state == 1) {
%aj = on | did -ra aj 2 Disattiva | did -e aj 1,3
if ($did(3) == $null) { did -b aj 4 } | else did -e aj 4
}
else { %aj = off | did -b aj 1,3,4,5 | did -ra aj 2 Attiva }
}
if ($did == 4) {
var %chan = $did(3)
if ($read(aj.txt,w,%chan)) { halt }
if (!$read(aj.txt,w,%chan)) { write aj.txt $did(3) | did -a aj 1 %chan }
}
if ($did == 5) {
var %p = $did(1,$did(1).sel).text
.write -ds $+ %p aj.txt | did -d aj 1 $did(1).sel
did -b aj 5
}
}

L'evento sclick si attiva ogni qual volta un controllo del dialog viene premuto. Nel codice trovate spesso "if ($did == N) { comandi }; questa condizione verifica solamente, attraverso l'ID, di quale controllo si tratta. Nel nostro esempio l'ID 1 appartiene al controllo LIST, il 2 al check ATTIVA, il 3 allo spazio editabile e via dicendo. Gli ID dei vari controlli sono impostati da noi durante la costruzione del dialog stesso:
list 1, 0 3 120 130
check "Attiva" 2, 124 4 80 16, push
Una volta cliccato col mouse sul pulsante ATTIVA (con ID 2), lo script andrà a cercare all'interno dell'evento sclick i comandi da eseguire. Vediamoli passo passo:

if ($did == 2) {
Controlla che i comandi da eseguire appartegono effettivamente al check ATTIVA.

if ($did(2).state == 1) {
%aj = on | did -ra aj 2 Disattiva | did -e aj 1,3
if ($did(3) != $null) did -e aj 4
}
Analizza lo stato del controllo check e se questo è uguale a 1, ossia ON, imposta la variabile %aj con il valore di ON, cancella il testo del check (did -r) e lo sostituisce con Disattiva (-a) per poi abilitare i controlli 1 e 3. Infine controlla se l'ID3 (l'edit) contiene valori al suo interno; se la risposta è affermativa abilita il pulsante AGGIUNGI.

else { %aj = off | did -b aj 1,3 | did -ra aj 2 Attiva }
Se lo stato del check non è 1 imposta la variabile %aj con il valore OFF, disabilita i controlli 1 e 3 e cambia il testo del check in ATTIVA.

Gli oggetti 4 e 5, ossia i pulsanti AGGIUNGI e ELIMINA, una volta abilitati hanno il compito di aggiungere o rimuovere un canale dalla lista. Il controllo 4, come visto, si comporta in conseguenza del valore dell'edit, mentre ELIMINA è infuenzato dai valori di LIST:
if ($did == 1) { if ($did(1).sel != $null) { did -e aj 5 } | else did -b aj 5 }
Se un valore è selezionato il pulsante ELIMINA viene abilitato, se non lo è, no:

if ($did == 4) {
var %chan = $did(3)
if ($read(aj.txt,w,%chan)) { halt }
if (!$read(aj.txt,w,%chan)) {
write aj.txt $did(3) | did -a aj 1 %chan
}
}
Questi sono i comandi che entrano in funzione una volta spinto il pulsante AGGIUNGI:
si imposta la variabile volante %chan con il testo scritto nell'edit; in seguito con l'identificatore $read si controlla se la parola è presente nel file aj.txt; e se questa non lo è viene aggiunta.

if ($did == 5) {
var %p = $did(1,$did(1).sel).text
.write -ds $+ %p aj.txt | did -d aj 1 $did(1).sel
did -b aj 5
}
}
Premendo il pulsante ELIMINA saranno attivati i comandi che cancellano il canale selezionato nella lista e dal file aj.txt.
Con var %p = $did(1,$did(1).sel).text si salva nella variabile volante %p il valore della selezione di LIST, nel nostro caso il nome del canale. In seguito attraverso il comando .write -ds $+ %p aj.txt, si elimina il canale dalla lista. Infine lo si cancella anche da quella del nostro dialog (did -d aj 1 $did(1).sel) e poi si disabilita il pulsante (did -b aj 5).

::::::::::::::::::::::::: EVENTO EDIT :::::::::::::::::::::::::

on *:dialog:aj:edit:3:{ if ($did(3) == $null) did -b aj 4 | else did -e aj 4 }

I valori degli oggetti editabili sono gestibili attraverso l'evento EDIT. Nel nostro caso usiamo questo evento per controllare le variazioni dell'edit, se questo assume un valore (quindi ci si scriviamo dentro), il pulsante AGGIUNGI sarà abilitato, se l'edit restituisce valore "nullo", il pulsante sarà disabilitato.

Ora il nostro Auto Join è completo, in quanto il suo compito è solo gestire la lista dei canali. Ma per chi volesse rendere attivo e completo il tutto basta che aggiunga:

on *:connect:{
if (%aj == on) && ($lines(aj.txt) >= 1) { .timeraj 1 3 alaj }
}
alias alaj {
var %i = 1 | while ($lines(aj.txt) >= %i) { var %chan = $read(aj.txt,%i) | j %chan | inc %i }
}

e se non presente nella sezione alias anche:
alias j { join #$$1 $2- }

Ripeto che quest'ultima parte non riguarda la costruzione del dialog, ma l'utilizzo del file .txt che attraverso il dialog viene gestito.

Ecco quindi il codice completo:

;--------------------------------- AUTO JOIN INIZIO CODICE-------------------------
alias autojoin { dialog -m aj aj }
dialog aj {
title " Auto Join"
size -1 -1 212 116
option pixels
list 1, 0 3 120 130
check "Attiva" 2, 124 4 80 16, push
edit "" 3, 124 24 80 18, center
button "Aggiungi" 4, 124 50 80 16
button "Elimina" 5, 124 70 80 16
button "Chiudi" 6, 124 96 80 16, ok
}

on *:dialog:aj:init:0:{
var %rigo = 1 | while ($lines(txt\aj.txt) >= %rigo) {
did -a aj 1 $read -l $+ %rigo txt\aj.txt | inc %rigo
}
if (%aj != on) { did -b aj 1,3 } | else { did -c aj 2 | did -ra aj 2 Disattiva }
did -b aj 4,5
}

on *:dialog:aj:sclick:*:{
if ($did == 1) { if ($did(1).sel != $null) { did -e aj 5 } | else did -b aj 5 }
if ($did == 2) {
if ($did(2).state == 1) {
%aj = on | did -ra aj 2 Disattiva | did -e aj 1,3
if ($did(3) != $null) did -e aj 4
}
else { %aj = off | did -b aj 1,3,4,5 | did -ra aj 2 Attiva }
}
if ($did == 4) {
var %chan = $did(3)
if ($read(txt\aj.txt,w,%chan)) { halt }
if (!$read(txt\aj.txt,w,%chan)) { write txt\aj.txt $did(3) | did -a aj 1 %chan }
}
if ($did == 5) {
var %p = $did(1,$did(1).sel).text
.write -ds $+ %p txt\aj.txt | did -d aj 1 $did(1).sel
did -b aj 5
}
}

on *:dialog:aj:edit:3:{ if ($did(3) == $null) did -b aj 4 | else did -e aj 4 }

on *:connect:{
if (%aj == on) && ($lines(txt\aj.txt) >= 1) { .timeraj 1 3 alaj }
}

alias alaj {
var %i = 1 | while ($lines(txt\aj.txt) >= %i) {
var %chan = $read(txt\aj.txt,%i)
j %chan | inc %i }
}

alias j { join #$$1 $2- }
;--------------------------------- AUTO JOIN FINE CODICE---------------------------