Finestre di dialogo Informazioni

  • Articolo

Esistono molte funzioni, messaggi e controlli predefiniti per creare e gestire le finestre di dialogo, rendendo così più semplice sviluppare l'interfaccia utente per un'applicazione. Questa panoramica descrive le funzioni e i messaggi della finestra di dialogo e spiega come usarli per creare e usare le finestre di dialogo.

Questa panoramica include gli argomenti seguenti:

Per altre informazioni sulle finestre di dialogo comuni, vedere Libreria di finestre di dialogo comuni.

Quando usare una finestra di dialogo

La maggior parte delle applicazioni usa le finestre di dialogo per richiedere informazioni aggiuntive per le voci di menu che richiedono l'input utente. L'uso di una finestra di dialogo è l'unico modo consigliato per recuperare l'input da un'applicazione. Ad esempio, una tipica voce di menu Open richiede che il nome di un file venga aperto, quindi un'applicazione deve usare una finestra di dialogo per richiedere all'utente il nome. In questi casi, l'applicazione crea la finestra di dialogo quando l'utente fa clic sulla voce di menu e elimina la finestra di dialogo immediatamente dopo che l'utente fornisce le informazioni.

Molte applicazioni usano anche finestre di dialogo per visualizzare informazioni o opzioni mentre l'utente funziona in un'altra finestra. Ad esempio, le applicazioni di elaborazione delle parole usano spesso una finestra di dialogo con un'opzione di ricerca di testo. Mentre l'applicazione cerca il testo, la finestra di dialogo rimane sullo schermo. L'utente può quindi tornare alla finestra di dialogo e cercare di nuovo la stessa parola; o l'utente può modificare la voce nella finestra di dialogo e cercare una nuova parola. Le applicazioni che usano finestre di dialogo in questo modo in genere creano una quando l'utente fa clic sulla voce di menu e continua a visualizzarla per tutto il tempo in cui l'applicazione viene eseguita o fino a quando l'utente chiude esplicitamente la finestra di dialogo.

Per supportare i diversi modi in cui le applicazioni usano le finestre di dialogo, sono disponibili due tipi di finestra di dialogo: modale e senza modalità. Una finestra di dialogo modale richiede all'utente di fornire informazioni o annullare la finestra di dialogo prima di consentire all'applicazione di continuare. Le applicazioni usano finestre di dialogo modali in combinazione con le voci di menu che richiedono informazioni aggiuntive prima di poter procedere. Una finestra di dialogo senza modalità consente all'utente di fornire informazioni e tornare all'attività precedente senza chiudere la finestra di dialogo. Le finestre di dialogo modali sono più semplici da gestire rispetto alle finestre di dialogo senza modalità perché vengono create, eseguono l'attività e vengono eliminate chiamando una singola funzione.

Per creare una finestra di dialogo modale o senza modalità, un'applicazione deve fornire un modello di finestra di dialogo per descrivere lo stile e il contenuto della finestra di dialogo; l'applicazione deve anche fornire una procedura di dialogo per eseguire attività. Il modello della finestra di dialogo è una descrizione binaria della finestra di dialogo e i controlli che contiene. Lo sviluppatore può creare questo modello come risorsa da caricare dal file eseguibile dell'applicazione o creato in memoria durante l'esecuzione dell'applicazione. La procedura della finestra di dialogo è una funzione di callback definita dall'applicazione che il sistema chiama quando ha input per la finestra di dialogo o le attività per l'esecuzione della finestra di dialogo. Anche se una procedura della finestra di dialogo è simile a una procedura di finestra, non ha le stesse responsabilità.

Un'applicazione crea in genere una finestra di dialogo usando la funzione DialogBox o CreateDialog . DialogBox crea una finestra di dialogo modale; CreateDialog crea una finestra di dialogo senza modalità. Queste due funzioni caricano un modello di finestra di dialogo dal file eseguibile dell'applicazione e creano una finestra popup che corrisponde alle specifiche del modello. Esistono altre funzioni che creano una finestra di dialogo usando modelli in memoria; passano informazioni aggiuntive alla procedura della finestra di dialogo quando viene creata la finestra di dialogo.

Le finestre di dialogo appartengono in genere a una classe finestra predefinita ed esclusiva. Il sistema usa questa classe di finestra e la relativa procedura della finestra corrispondente per le finestre di dialogo modali e modeless. Quando viene chiamata la funzione, crea la finestra per la finestra di dialogo, nonché le finestre per i controlli nella finestra di dialogo, quindi invia messaggi selezionati alla procedura della finestra di dialogo. Mentre la finestra di dialogo è visibile, la routine finestra predefinita gestisce tutti i messaggi, l'elaborazione di alcuni messaggi e il passaggio di altri alla procedura della finestra di dialogo in modo che la procedura possa eseguire attività. Le applicazioni non hanno accesso diretto alla classe o alla procedura finestra predefinita, ma possono usare il modello di finestra di dialogo e la procedura della finestra di dialogo per modificare lo stile e il comportamento di una finestra di dialogo.

Finestra del proprietario della finestra di dialogo

La maggior parte delle finestre di dialogo ha una finestra proprietario (o più semplicemente, un proprietario). Quando si crea la finestra di dialogo, l'applicazione imposta il proprietario specificando l'handle della finestra del proprietario. Il sistema usa il proprietario per determinare la posizione della finestra di dialogo nell'ordine Z in modo che la finestra di dialogo sia sempre posizionata sopra il proprietario. Inoltre, il sistema può inviare messaggi alla procedura della finestra del proprietario, notificando gli eventi nella finestra di dialogo.

Il sistema nasconde o elimina automaticamente la finestra di dialogo ogni volta che il proprietario è nascosto o distrutto. Ciò significa che la procedura della finestra di dialogo non richiede alcuna elaborazione speciale per rilevare le modifiche allo stato della finestra del proprietario.

Poiché la finestra di dialogo tipica viene usata insieme a una voce di menu, la finestra proprietario è in genere la finestra contenente il menu. Anche se è possibile creare una finestra di dialogo senza proprietario, non è consigliabile. Ad esempio, quando una finestra di dialogo modale non ha alcun proprietario, il sistema non disabilita alcuna delle altre finestre dell'applicazione e consente all'utente di continuare a eseguire operazioni nelle altre finestre, sconfiggendo lo scopo della finestra di dialogo modale.

Quando una finestra di dialogo senza modalità non ha alcun proprietario, il sistema non nasconde né elimina la finestra di dialogo quando altre finestre dell'applicazione vengono nascoste o eliminate. Anche se questo non supera lo scopo della finestra di dialogo senza modalità, è necessario che l'applicazione esegue un'elaborazione speciale per assicurarsi che la finestra di dialogo sia nascosta e eliminata in momenti appropriati.

Finestre di messaggio

Una finestra di messaggio è una finestra di dialogo speciale che un'applicazione può usare per visualizzare messaggi e richiedere un input semplice. Una finestra di messaggio contiene in genere un messaggio di testo e uno o più pulsanti. Un'applicazione crea la finestra di messaggio usando la funzione MessageBox o MessageBoxEx , specificando il testo e il numero e i tipi di pulsanti da visualizzare. Si noti che attualmente non esiste alcuna differenza tra il funzionamento di MessageBox e MessageBoxEx .

Anche se la finestra di messaggio è una finestra di dialogo, il sistema accetta il controllo completo della creazione e della gestione della finestra di messaggio. Ciò significa che l'applicazione non fornisce un modello di finestra di dialogo e una procedura di dialogo. Il sistema crea il proprio modello in base al testo e ai pulsanti specificati per la finestra di messaggio e fornisce la propria procedura di finestra di dialogo.

Una finestra di messaggio è una finestra di dialogo modale e il sistema lo crea usando le stesse funzioni interne usate da DialogBox . Se l'applicazione specifica una finestra del proprietario quando si chiama MessageBox o MessageBoxEx, il sistema disabilita il proprietario. Un'applicazione può anche indirizzare il sistema per disabilitare tutte le finestre di primo livello appartenenti al thread corrente specificando il valore MB_TASKMODAL durante la creazione della finestra di dialogo.

Il sistema può inviare messaggi al proprietario, ad esempio WM_CANCELMODE e WM_ENABLE, così come quando si crea una finestra di dialogo modale. La finestra del proprietario deve eseguire tutte le azioni richieste da questi messaggi.

Una finestra di dialogo modale deve essere una finestra popup con un menu finestra, una barra del titolo e un bordo spesso; ovvero, il modello della finestra di dialogo deve specificare gli stili WS_POPUP, WS_SYSMENU, WS_CAPTION eDS_MODALFRAME . Anche se un'applicazione può designare lo stile WS_VISIBLE , il sistema visualizza sempre una finestra di dialogo modale indipendentemente dal fatto che il modello della finestra di dialogo specifica lo stile WS_VISIBLE . Un'applicazione non deve creare una finestra di dialogo modale con lo stile WS_CHILD . Una finestra di dialogo modale con questo stile si disabilita, impedendo che qualsiasi input successivo raggiunga l'applicazione.

Un'applicazione crea una finestra di dialogo modale usando la funzione DialogBox o DialogBoxIndirect. DialogBox richiede il nome o l'identificatore di una risorsa contenente un modello di finestra di dialogo; DialogBoxIndirect richiede un handle per un oggetto memory contenente un modello di finestra di dialogo. Le funzioni DialogBoxParam e DialogBoxIndirectParam creano anche finestre di dialogo modali; sono identici alle funzioni indicate in precedenza, ma passano un parametro specificato alla procedura della finestra di dialogo quando viene creata la finestra di dialogo.

Quando si crea la finestra di dialogo modale, il sistema lo rende la finestra attiva. La finestra di dialogo rimane attiva finché la finestra di dialogo chiama la funzione EndDialog o il sistema attiva una finestra in un'altra applicazione. Né l'utente né l'applicazione possono rendere attiva la finestra del proprietario fino a quando non viene eliminata la finestra di dialogo modale.

Quando la finestra del proprietario non è già disabilitata, il sistema disabilita automaticamente la finestra e tutte le finestre figlio appartenenti a esso quando crea la finestra di dialogo modale. La finestra proprietario rimane disabilitata fino a quando la finestra di dialogo non viene eliminata. Anche se una finestra di dialogo potrebbe potenzialmente abilitare la finestra del proprietario in qualsiasi momento, l'abilitazione del proprietario elimina lo scopo della finestra di dialogo modale e non è consigliabile. Quando la procedura della finestra di dialogo viene eliminata, il sistema abilita di nuovo la finestra del proprietario, ma solo se la finestra di dialogo modale ha causato la disabilitazione del proprietario.

Quando il sistema crea la finestra di dialogo modale, invia il messaggio WM_CANCELMODE alla finestra (se presente) che acquisisce l'input del mouse. Un'applicazione che riceve questo messaggio deve rilasciare l'acquisizione del mouse in modo che l'utente possa spostare il mouse nella finestra di dialogo modale. Poiché il sistema disabilita la finestra del proprietario, tutto l'input del mouse viene perso se il proprietario non riesce a rilasciare il mouse al momento della ricezione di questo messaggio.

Per elaborare i messaggi per la finestra di dialogo modale, il sistema avvia il proprio ciclo di messaggi, prendendo il controllo temporaneo della coda di messaggi per l'intera applicazione. Quando il sistema recupera un messaggio che non è esplicitamente per la finestra di dialogo, invia il messaggio alla finestra appropriata. Se recupera un messaggio di WM_QUIT , pubblica nuovamente il messaggio nella coda dei messaggi dell'applicazione in modo che il ciclo di messaggi principale dell'applicazione possa eventualmente recuperare il messaggio.

Il sistema invia il messaggio WM_ENTERIDLE alla finestra del proprietario ogni volta che la coda dei messaggi dell'applicazione è vuota. L'applicazione può usare questo messaggio per eseguire un'attività in background mentre la finestra di dialogo rimane sullo schermo. Quando un'applicazione usa il messaggio in questo modo, l'applicazione deve restituire spesso il controllo , ad esempio usando la funzione PeekMessage , in modo che la finestra di dialogo modale possa ricevere qualsiasi input dell'utente. Per impedire che la finestra di dialogo modale invii i messaggi WM_ENTERIDLE , l'applicazione può specificare lo stile DS_NOIDLEMSG durante la creazione della finestra di dialogo.

Un'applicazione elimina definitivamente una finestra di dialogo modale usando la funzione EndDialog . Nella maggior parte dei casi, la procedura della finestra di dialogo chiama EndDialog quando l'utente fa clic su Chiudi dal menu della finestra della finestra di dialogo o fa clic sul pulsante OK o Annulla nella finestra di dialogo. La finestra di dialogo può restituire un valore tramite la funzione DialogBox (o altre funzioni di creazione) specificando un valore quando si chiama la funzione EndDialog . Il sistema restituisce questo valore dopo aver distrutto la finestra di dialogo. La maggior parte delle applicazioni usa questo valore restituito per determinare se la finestra di dialogo ha completato correttamente l'attività o è stata annullata dall'utente. Il sistema non restituisce il controllo dalla funzione che crea la finestra di dialogo finché la routine della finestra di dialogo non ha chiamato la funzione EndDialog .

Finestre di dialogo senza modalità

Una finestra di dialogo senza modalità deve essere una finestra popup con un menu finestra, una barra del titolo e un bordo sottile; ovvero il modello della finestra di dialogo deve specificare gli stili di WS_POPUP, WS_CAPTION, WS_BORDER e WS_SYSMENU . Il sistema non visualizza automaticamente la finestra di dialogo a meno che il modello non specifichi lo stile WS_VISIBLE .

Un'applicazione crea una finestra di dialogo senza modalità usando la funzione CreateDialog o CreateDialogIndirect . CreateDialog richiede il nome o l'identificatore di una risorsa contenente un modello di finestra di dialogo; CreateDialogIndirect richiede un handle per un oggetto memoria contenente un modello di finestra di dialogo. Altre due funzioni, CreateDialogParam e CreateDialogIndirectParam, creano anche finestre di dialogo senza modalità; passano un parametro specificato alla procedura della finestra di dialogo quando viene creata la finestra di dialogo.

CreateDialog e altre funzioni di creazione restituiscono un handle di finestra alla finestra di dialogo. L'applicazione e la procedura della finestra di dialogo possono utilizzare questo handle per gestire la finestra di dialogo. Ad esempio, se WS_VISIBLE non è specificato nel modello di finestra di dialogo, l'applicazione può visualizzare la finestra di dialogo passando l'handle di finestra alla funzione ShowWindow .

Una finestra di dialogo senza modalità non disabilita né la finestra del proprietario né invia messaggi. Quando si crea la finestra di dialogo, il sistema lo rende la finestra attiva, ma l'utente o l'applicazione può modificare la finestra attiva in qualsiasi momento. Se la finestra di dialogo diventa inattiva, rimane sopra la finestra del proprietario nell'ordine Z, anche se la finestra del proprietario è attiva.

L'applicazione è responsabile del recupero e dell'invio di messaggi di input alla finestra di dialogo. Per la maggior parte delle applicazioni viene usato il ciclo di messaggi principale. Per consentire all'utente di passare a e selezionare i controlli usando la tastiera, tuttavia, l'applicazione deve chiamare la funzione IsDialogMessage . Per altre informazioni su questa funzione, vedere Interfaccia della tastiera della finestra di dialogo.

Una finestra di dialogo senza modalità non può restituire un valore all'applicazione come finestra di dialogo modale, ma la procedura della finestra di dialogo può inviare informazioni alla finestra di proprietario utilizzando la funzione SendMessage .

Un'applicazione deve eliminare tutte le finestre di dialogo senza modalità prima di terminare. Può eliminare definitivamente una finestra di dialogo senza modalità usando la funzione DestroyWindow . Nella maggior parte dei casi, la procedura della finestra di dialogo chiama DestroyWindow in risposta all'input dell'utente, ad esempio facendo clic sul pulsante Annulla . Se l'utente non chiude mai la finestra di dialogo in questo modo, l'applicazione deve chiamare DestroyWindow.

DestroyWindow invalida l'handle della finestra nella finestra di dialogo, pertanto tutte le chiamate successive alle funzioni che usano i valori di errore restituiti dall'handle. Per evitare errori, la procedura della finestra di dialogo deve notificare al proprietario che la finestra di dialogo è stata eliminata definitivamente. Molte applicazioni mantengono una variabile globale contenente l'handle nella finestra di dialogo. Quando la routine della finestra di dialogo elimina definitivamente la finestra di dialogo, imposta anche la variabile globale su NULL, a indicare che la finestra di dialogo non è più valida.

La procedura della finestra di dialogo non deve chiamare la funzione EndDialog per eliminare definitivamente una finestra di dialogo senza modalità.

Modelli di finestre di dialogo

Un modello di finestra di dialogo è costituito da dati binari che descrivono la finestra di dialogo, ne definiscono l'altezza, la larghezza, lo stile e i controlli contenuti. Per creare una finestra di dialogo, il sistema carica un modello di finestra di dialogo dalle risorse nel file eseguibile dell'applicazione o usa il modello passato in memoria globale dall'applicazione. In entrambi i casi, l'applicazione deve fornire un modello durante la creazione di una finestra di dialogo.

Uno sviluppatore crea risorse modello usando un compilatore di risorse o un editor di finestre di dialogo. Un compilatore di risorse converte una descrizione di testo in una risorsa binaria e un editor di finestre di dialogo salva una finestra di dialogo costruita in modo interattivo come risorsa binaria.

Nota

Una spiegazione di come creare risorse modello e aggiungerle al file eseguibile dell'applicazione esula dall'ambito di questa panoramica. Per altre informazioni sulla creazione di risorse modello e sull'aggiunta di tali risorse a un file eseguibile, vedere la documentazione fornita con gli strumenti di sviluppo delle applicazioni.

 

Per creare una finestra di dialogo senza usare risorse modello, è necessario creare un modello in memoria e passarlo alla funzione CreateDialogIndirectParam o DialogBoxIndirectParam oppure alla macro CreateDialogIndirect o DialogBoxIndirect .

Un modello di finestra di dialogo in memoria è costituito da un'intestazione che descrive la finestra di dialogo, seguita da uno o più blocchi aggiuntivi di dati che descrivono ognuno dei controlli nella finestra di dialogo. Il modello può usare il formato standard o il formato esteso. In un modello standard, l'intestazione è una struttura DLGTEMPLATE seguita da matrici a lunghezza variabile aggiuntive; e i dati per ogni controllo sono costituiti da una struttura DLGITEMTEMPLATE seguita da matrici a lunghezza variabile aggiuntive. In un modello di finestra di dialogo esteso l'intestazione usa il formato DLGTEMPLATEEX e le definizioni dei controlli usano il formato DLGITEMTEMPLATEEX .

È possibile creare un modello di memoria allocando un oggetto memoria globale e riempindolo con le definizioni di intestazione e controllo standard o estese. Un modello di memoria è identico in forma e contenuto a una risorsa modello. Molte applicazioni che usano modelli di memoria usano prima la funzione LoadResource per caricare una risorsa modello in memoria, quindi modificare la risorsa caricata per creare un nuovo modello di memoria. Per altre informazioni sulla creazione di un modello di finestra di dialogo in memoria, vedere Modelli in memoria.

Le sezioni seguenti descrivono gli stili, le misure e altri valori usati in un modello di finestra di dialogo.

Stili modello finestra di dialogo

Ogni modello di finestra di dialogo specifica una combinazione di valori di stile che definiscono l'aspetto e le caratteristiche della finestra di dialogo. I valori di stile possono essere stili di finestra, ad esempio WS_POPUP e WS_SYSMENU e stili delle finestre di dialogo, ad esempio DS_MODALFRAME. Il numero e il tipo di stili per un modello dipendono dal tipo e dallo scopo della finestra di dialogo. Per un elenco di valori, vedere Stili finestra di dialogo.

Il sistema passa tutti gli stili di finestra specificati nel modello alla funzione CreateWindowEx durante la creazione della finestra di dialogo. Il sistema può passare uno o più stili estesi a seconda degli stili delle finestre di dialogo specificati. Ad esempio, quando il modello specifica DS_MODALFRAME, il sistema usa WS_EX_DLGMODALFRAME durante la creazione della finestra di dialogo.

La maggior parte delle finestre di dialogo sono finestre popup con un menu della finestra e una barra del titolo. Pertanto, il modello tipico specifica gli stili WS_POPUP, WS_SYSMENU e WS_CAPTION . Il modello specifica anche uno stile di bordo: WS_BORDER per le finestre di dialogo senza modalità e DS_MODALFRAME per le finestre di dialogo modali. Un modello può specificare un tipo di finestra diverso da popup (ad esempio WS_OVERLAPPED) se crea una finestra personalizzata anziché una finestra di dialogo.

Il sistema visualizza sempre una finestra di dialogo modale indipendentemente dal fatto che venga specificato lo stile WS_VISIBLE . Quando il modello per una finestra di dialogo senza modalità specifica lo stile WS_VISIBLE , il sistema visualizza automaticamente la finestra di dialogo al momento della creazione. In caso contrario, l'applicazione è responsabile della visualizzazione della finestra di dialogo tramite la funzione ShowWindow .

Misurazioni delle finestre di dialogo

Ogni modello di finestra di dialogo contiene misure che specificano la posizione, la larghezza e l'altezza della finestra di dialogo e i controlli contenuti. Queste misurazioni sono indipendenti dal dispositivo, quindi un'applicazione può usare un singolo modello per creare la stessa finestra di dialogo per tutti i tipi di dispositivi di visualizzazione. Ciò garantisce che una finestra di dialogo abbia le stesse proporzioni e aspetto su tutti gli schermi nonostante risoluzioni e proporzioni diverse tra gli schermi.

Le misurazioni in un modello di finestra di dialogo vengono specificate nelle unità modello di dialogo. Per convertire le misure da unità modello di dialogo a unità schermo (pixel), utilizzare la funzione MapDialogRect , che tiene conto del tipo di carattere utilizzato dalla finestra di dialogo e converte correttamente un rettangolo da unità modello di dialogo in pixel. Per le finestre di dialogo che usano il tipo di carattere di sistema, è possibile usare la funzione GetDialogBaseUnits per eseguire manualmente i calcoli di conversione, anche se l'uso di MapDialogRect è più semplice.

Il modello deve specificare le coordinate iniziali dell'angolo superiore sinistro della finestra di dialogo. In genere le coordinate sono relative all'angolo superiore sinistro dell'area client della finestra proprietario. Quando il modello specifica lo stile DS_ABSALIGN o la finestra di dialogo non ha un proprietario, la posizione è relativa all'angolo superiore sinistro dello schermo. Il sistema imposta questa posizione iniziale durante la creazione della finestra di dialogo, ma consente a un'applicazione di regolare la posizione prima di visualizzare la finestra di dialogo. Ad esempio, un'applicazione può recuperare le dimensioni della finestra proprietario, calcolare una nuova posizione che centra la finestra di dialogo nella finestra di proprietario e quindi impostare la posizione usando la funzione SetWindowPos .

Il modello deve specificare una larghezza e un'altezza della finestra di dialogo che non superano la larghezza e l'altezza dello schermo e garantisce che tutti i controlli si trovino all'interno dell'area client della finestra di dialogo. Anche se il sistema consente a una finestra di dialogo di avere qualsiasi dimensione, la creazione di una finestra di dialogo troppo piccola o troppo grande può impedire all'utente di fornire input, sconfiggendo lo scopo della finestra di dialogo. Molte applicazioni usano più di una finestra di dialogo quando è presente un numero elevato di controlli. In questi casi, la finestra di dialogo iniziale contiene in genere uno o più pulsanti che l'utente può scegliere di visualizzare la finestra di dialogo successiva.

Controlli finestra di dialogo

Il modello specifica la posizione, la larghezza, l'altezza, lo stile, l'identificatore e la classe finestra per ogni controllo nella finestra di dialogo. Il sistema crea ogni controllo passando questi dati alla funzione CreateWindowEx . I controlli vengono creati nell'ordine in cui sono specificati nel modello. Il modello deve specificare il numero, il tipo e l'ordine appropriati dei controlli per assicurarsi che l'utente possa immettere l'input necessario per completare l'attività associata alla finestra di dialogo.

Per ogni controllo, il modello specifica i valori di stile che definiscono l'aspetto e il funzionamento del controllo. Ogni controllo è una finestra figlio e pertanto deve avere lo stile WS_CHILD . Per assicurarsi che il controllo sia visibile quando viene visualizzata la finestra di dialogo, ogni controllo deve avere anche lo stile WS_VISIBLE . Altri stili di finestra di uso comune sono WS_BORDER per i controlli con bordi facoltativi, WS_DISABLED per i controlli che devono essere disabilitati quando la finestra di dialogo viene creata inizialmente e WS_TABSTOP e WS_GROUP per i controlli a cui è possibile accedere tramite la tastiera. Gli stili WS_TABSTOP e WS_GROUP vengono usati insieme all'interfaccia della tastiera della finestra di dialogo descritta più avanti in questo argomento.

Il modello può anche specificare stili di controllo specifici per la classe finestra del controllo. Ad esempio, un modello che specifica un controllo pulsante deve assegnare uno stile di controllo pulsante, ad esempio BS_PUSHBUTTON o BS_CHECKBOX. Il sistema passa gli stili di controllo alla routine della finestra di controllo tramite il messaggio WM_CREATE , consentendo alla routine di adattare l'aspetto e il funzionamento del controllo.

Il sistema converte le coordinate di posizione e le misure di larghezza e altezza dalle unità di base del dialogo ai pixel, prima di passarli a CreateWindowEx. Quando il sistema crea un controllo, specifica la finestra di dialogo come finestra padre. Ciò significa che il sistema interpreta sempre le coordinate di posizione del controllo come coordinate client, rispetto all'angolo superiore sinistro dell'area client della finestra di dialogo.

Il modello specifica la classe finestra per ogni controllo. Una finestra di dialogo tipica contiene controlli appartenenti alle classi predefinite della finestra di controllo, ad esempio il pulsante e le classi della finestra di controllo di modifica. In questo caso, il modello specifica le classi finestra specificando i valori atom predefiniti corrispondenti per le classi. Quando una finestra di dialogo contiene un controllo appartenente a una classe finestra di controllo personalizzata, il modello assegna al modello il nome della classe finestra registrata o il valore atom attualmente associato al nome.

Ogni controllo in una finestra di dialogo deve avere un identificatore univoco per distinguerlo da altri controlli. I controlli inviano informazioni alla routine della finestra di dialogo tramite WM_COMMAND messaggi, pertanto gli identificatori di controllo sono essenziali per la procedura per determinare quale controllo ha inviato un messaggio specificato. L'unica eccezione a questa regola è l'identificatore di controllo per i controlli statici. I controlli statici non richiedono identificatori univoci perché non inviano messaggi WM_COMMAND .

Per consentire all'utente di chiudere la finestra di dialogo, il modello deve specificare almeno un pulsante di pressione e assegnargli l'IDCANCEL dell'identificatore di controllo. Per consentire all'utente di scegliere tra il completamento o l'annullamento dell'attività associata alla finestra di dialogo, il modello deve specificare due pulsanti di scelta, con l'etichetta OK e Annulla, rispettivamente con identificatori di controllo IDOK e IDCANCEL.

Un modello specifica anche i dati facoltativi di testo e creazione per un controllo. Il testo fornisce in genere etichette per i controlli pulsante o specifica il contenuto iniziale di un controllo testo statico. I dati di creazione sono uno o più byte di dati che il sistema passa alla routine della finestra di controllo durante la creazione del controllo. I dati di creazione sono utili per i controlli che richiedono più informazioni sul contenuto o sullo stile iniziali rispetto a quelli specificati da altri dati. Ad esempio, un'applicazione può usare i dati di creazione per impostare l'impostazione iniziale e l'intervallo per un controllo barra di scorrimento.

Menu Finestra di dialogo

Il sistema fornisce una finestra di dialogo a un menu della finestra quando il modello specifica lo stile WS_SYSMENU . Per evitare l'input inappropriato, il sistema disabilita automaticamente tutte le voci del menu, ad eccezione di Sposta e Chiudi. L'utente può fare clic su Sposta per spostare la finestra di dialogo. Quando l'utente fa clic su Chiudi, il sistema invia un messaggio WM_COMMAND alla procedura della finestra di dialogo con il parametro wParam impostato su IDCANCEL. Questo è identico al messaggio inviato dal pulsante Annulla quando l'utente lo fa clic. L'azione consigliata per questo messaggio consiste nel chiudere la finestra di dialogo e annullare l'attività richiesta.

Sebbene non siano consigliati altri menu nelle finestre di dialogo, un modello di finestra di dialogo può specificare un menu specificando l'identificatore o il nome di una risorsa di menu. In questo caso, il sistema carica la risorsa e crea il menu per la finestra di dialogo. Le applicazioni usano in genere identificatori di menu o nomi nei modelli quando si usano i modelli per creare finestre personalizzate anziché finestre di dialogo.

Tipi di carattere della finestra di dialogo

Il sistema utilizza la larghezza media del carattere della finestra di dialogo per calcolare la posizione e le dimensioni della finestra di dialogo. Per impostazione predefinita, il sistema disegna tutto il testo in una finestra di dialogo utilizzando il tipo di carattere SYSTEM_FONT .

Per specificare un tipo di carattere per una finestra di dialogo diversa dall'impostazione predefinita, è necessario creare la finestra di dialogo utilizzando un modello di finestra di dialogo. In una risorsa modello usare l'istruzione FONT. In un modello di finestra di dialogo impostare lo stile DS_SETFONT o DS_SHELLFONT e specificare una dimensione del punto e un nome di carattere tipografico. Anche se un modello di finestra di dialogo specifica un tipo di carattere in questo modo, il sistema utilizza sempre il tipo di carattere di sistema per il titolo della finestra di dialogo e i menu delle finestre di dialogo.

Quando la finestra di dialogo ha lo stile DS_SETFONT o DS_SHELLFONT , il sistema invia un messaggio WM_SETFONT alla routine della finestra di dialogo e a ogni controllo durante la creazione del controllo. La procedura della finestra di dialogo è responsabile del salvataggio dell'handle del tipo di carattere passato con il messaggio WM_SETFONT e della selezione dell'handle nel contesto del dispositivo di visualizzazione ogni volta che scrive il testo nella finestra. I controlli predefiniti eseguono questa operazione per impostazione predefinita.

Il tipo di carattere di sistema può variare tra versioni diverse di Windows. Per fare in modo che l'applicazione usi il tipo di carattere di sistema indipendentemente dal sistema in cui è in esecuzione, usare DS_SHELLFONT con il carattere tipografico MS Shell Dlg e usare la risorsa DIALOGEX anziché la risorsa DIALOG. Il sistema esegue il mapping di questo carattere tipografico in modo che la finestra di dialogo usi il tipo di carattere Tahoma. Si noti che DS_SHELLFONT non ha alcun effetto se il carattere tipografico non è MS Shell Dlg.

Modelli in memoria

Un modello di finestra di dialogo in memoria è costituito da un'intestazione che descrive la finestra di dialogo, seguita da uno o più blocchi aggiuntivi di dati che descrivono ognuno dei controlli nella finestra di dialogo. Il modello può usare il formato standard o il formato esteso. In un modello standard, l'intestazione è una struttura DLGTEMPLATE seguita da matrici a lunghezza variabile aggiuntive. I dati per ogni controllo sono costituiti da una struttura DLGITEMTEMPLATE seguita da matrici a lunghezza variabile aggiuntive. In un modello di finestra di dialogo esteso l'intestazione usa il formato DLGTEMPLATEEX e le definizioni dei controlli usano il formato DLGITEMTEMPLATEEX .

Per distinguere un modello standard e un modello esteso, controllare i primi 16 bit di un modello di finestra di dialogo. In un modello esteso, il primo word è 0xFFFF; qualsiasi altro valore indica un modello standard.

Se si crea un modello di finestra di dialogo in memoria, è necessario assicurarsi che ognuna delle definizioni di controllo DLGITEMTEMPLATE o DLGITEMTEMPLATEEX sia allineata ai limiti DWORD . Inoltre, tutti i dati di creazione che seguono una definizione di controllo devono essere allineati su un limite DWORD . Tutte le altre matrici a lunghezza variabile in un modello di finestra di dialogo devono essere allineate ai limiti di WORD .

Intestazione modello

Sia nei modelli standard che estesi per le finestre di dialogo, l'intestazione include le informazioni generali seguenti:

  • Posizione e dimensioni della finestra di dialogo
  • Stili della finestra e della finestra di dialogo per la finestra di dialogo
  • Numero di controlli nella finestra di dialogo. Questo valore determina il numero di definizioni di controllo DLGITEMTEMPLATE o DLGITEMTEMPLATEEX nel modello.
  • Risorsa di menu facoltativa per la finestra di dialogo. Il modello può indicare che la finestra di dialogo non dispone di un menu oppure può specificare un valore ordinale o una stringa Unicode con terminazione Null che identifica una risorsa di menu in un file eseguibile.
  • Classe della finestra di dialogo. Può trattarsi della classe predefinita della finestra di dialogo o di un valore ordinale o di una stringa Unicode con terminazione Null che identifica una classe finestra registrata.
  • Stringa Unicode con terminazione Null che specifica il titolo per la finestra di dialogo. Se la stringa è vuota, la barra del titolo della finestra di dialogo è vuota. Se la finestra di dialogo non ha lo stile WS_CAPTION , il sistema imposta il titolo sulla stringa specificata ma non lo visualizza.
  • Se la finestra di dialogo ha lo stile DS_SETFONT , l'intestazione specifica le dimensioni del punto e il nome del carattere tipografico del tipo di carattere da utilizzare per il testo nell'area client e nei controlli della finestra di dialogo.

In un modello esteso, l'intestazione DLGTEMPLATEEX specifica anche le informazioni aggiuntive seguenti:

  • Identificatore del contesto della Guida della finestra di dialogo quando il sistema invia un messaggio di WM_HELP .
  • Se la finestra di dialogo ha lo stile DS_SETFONT o DS_SHELLFONT , l'intestazione specifica lo spessore del carattere e indica se il tipo di carattere è in corsivo.

Definizioni di controllo

Dopo l'intestazione del modello è presente una o più definizioni di controllo che descrivono i controlli della finestra di dialogo. Sia nei modelli standard che in quello esteso, l'intestazione della finestra di dialogo ha un membro che indica il numero di definizioni di controllo nel modello. In un modello standard ogni definizione di controllo è costituita da una struttura DLGITEMTEMPLATE seguita da matrici a lunghezza variabile aggiuntive. In un modello esteso, le definizioni dei controlli usano il formato DLGITEMTEMPLATEEX .

Sia nei modelli standard che in quello esteso, la definizione del controllo include le informazioni seguenti:

  • Posizione e dimensioni del controllo.
  • Stili di finestra e controllo per il controllo.
  • Identificatore del controllo.
  • Classe della finestra del controllo . Può trattarsi del valore ordinale di una classe di sistema predefinita o di una stringa Unicode con terminazione Null che specifica il nome di una classe finestra registrata.
  • Stringa Unicode con terminazione Null che specifica il testo iniziale del controllo o un valore ordinale che identifica una risorsa, ad esempio un'icona, in un file eseguibile.
  • Blocco facoltativo a lunghezza variabile dei dati di creazione. Quando il sistema crea il controllo, passa un puntatore a questi dati nel parametro lParam del messaggio WM_CREATE inviato al controllo.

In un modello esteso, la definizione del controllo specifica anche un identificatore di contesto della Guida per il controllo quando il sistema invia un messaggio di WM_HELP .