Condividi tramite

Funzionalità delle finestre

  • Articolo

Questa panoramica illustra le funzionalità delle finestre, ad esempio tipi di finestra, stati, dimensioni e posizione.

Tipi di finestre

Questa sezione contiene gli argomenti seguenti che descrivono i tipi di finestra.

Finestre sovrapposte

Una finestra sovrapposta è una finestra di primo livello (finestra non figlio) con una barra del titolo, un bordo e un'area client; è destinato a fungere da finestra principale di un'applicazione. Può anche avere un menu finestra, ridurre al minimo e massimizzare i pulsanti e scorrere le barre. Una finestra sovrapposta usata come finestra principale include in genere tutti questi componenti.

Specificando lo stile WS_OVERLAPPED o WS_OVERLAPPEDWINDOW nella funzione CreateWindowEx , un'applicazione crea una finestra sovrapposta. Se si usa lo stile WS_OVERLAPPED , la finestra ha una barra del titolo e un bordo. Se si usa lo stile WS_OVERLAPPEDWINDOW , la finestra ha una barra del titolo, il bordo del ridimensionamento, il menu della finestra e ridurre al minimo e massimizzare i pulsanti.

Finestre popup

Una finestra popup è un tipo speciale di finestra sovrapposta usata per le finestre di dialogo, le finestre di messaggio e altre finestre temporanee visualizzate all'esterno della finestra principale di un'applicazione. Le barre del titolo sono facoltative per le finestre popup; in caso contrario, le finestre popup sono uguali a finestre sovrapposte dello stile WS_OVERLAPPED .

Si crea una finestra popup specificando lo stile di WS_POPUP in CreateWindowEx. Per includere una barra del titolo, specificare lo stile WS_CAPTION . Usare lo stile WS_POPUPWINDOW per creare una finestra popup con un bordo e un menu finestra. Lo stile WS_CAPTION deve essere combinato con lo stile WS_POPUPWINDOW per rendere visibile il menu della finestra.

Windows figlio

Una finestra figlio ha lo stile WS_CHILD ed è limitato all'area client della finestra padre. Un'applicazione usa in genere finestre figlio per dividere l'area client di una finestra padre in aree funzionali. Si crea una finestra figlio specificando lo stile WS_CHILD nella funzione CreateWindowEx .

Una finestra figlio deve avere una finestra padre. La finestra padre può essere una finestra sovrapposta, una finestra popup o anche un'altra finestra figlio. Specificare la finestra padre quando si chiama CreateWindowEx. Se si specifica lo stile WS_CHILD in CreateWindowEx ma non si specifica una finestra padre, il sistema non crea la finestra.

Una finestra figlio ha un'area client, ma nessun'altra funzionalità, a meno che non siano richieste in modo esplicito. Un'applicazione può richiedere una barra del titolo, un menu finestra, ridurre al minimo e massimizzare i pulsanti, un bordo e le barre di scorrimento per una finestra figlio, ma una finestra figlio non può avere un menu. Se l'applicazione specifica un handle di menu, quando registra la classe finestra del figlio o crea la finestra figlio, l'handle di menu viene ignorato. Se non viene specificato alcun stile di bordo, il sistema crea una finestra senza bordo. Un'applicazione può usare finestre figlio senza bordi per dividere l'area client di una finestra padre mantenendo le divisioni invisibili all'utente.

Questa sezione illustra gli aspetti seguenti delle finestre figlio:

Posizionamento

Il sistema posiziona sempre una finestra figlio rispetto all'angolo superiore sinistro dell'area client della finestra padre. Nessuna parte di una finestra figlio non viene mai visualizzata all'esterno dei bordi della finestra padre. Se un'applicazione crea una finestra figlio maggiore della finestra padre o posiziona una finestra figlio in modo che alcune o tutte le finestre figlio si estendono oltre i bordi del padre, il sistema clip la finestra figlio; ovvero, la parte esterna all'area client della finestra padre non viene visualizzata. Le azioni che influiscono sulla finestra padre possono influire anche sulla finestra figlio, come indicato di seguito.

Finestra padre Finestra figlio
Eliminata Eliminato prima che la finestra padre venga eliminata.
Nascosto Nascosto prima che la finestra padre sia nascosta. Una finestra figlio è visibile solo quando la finestra padre è visibile.
Trasferito Spostato con l'area client della finestra padre. La finestra figlio è responsabile della pittura dell'area client dopo lo spostamento.
Mostrato Visualizzato dopo la visualizzazione della finestra padre.

 

Ritaglio

Il sistema non ritaglia automaticamente una finestra figlio dall'area client della finestra padre. Ciò significa che la finestra padre disegna sulla finestra figlio se esegue qualsiasi disegno nella stessa posizione della finestra figlio. Tuttavia, il sistema ritaglia la finestra figlio dall'area client della finestra padre se la finestra padre ha lo stile WS_CLIPCHILDREN . Se la finestra figlio viene ritagliata, la finestra padre non può disegnare.

Una finestra figlio può sovrapporsi ad altre finestre figlio nella stessa area client. Una finestra figlio che condivide la stessa finestra padre di una o più finestre figlio viene chiamata finestra di pari livello. Le finestre di pari livello possono disegnare tra loro nell'area client dell'altro, a meno che una delle finestre figlio non abbia lo stile WS_CLIPSIBLINGS . Se una finestra figlio ha questo stile, qualsiasi parte della finestra di pari livello che si trova all'interno della finestra figlio viene ritagliata.

Se una finestra ha lo stile WS_CLIPCHILDREN o WS_CLIPSIBLINGS , si verifica una leggera perdita delle prestazioni. Ogni finestra occupa le risorse di sistema, quindi un'applicazione non deve usare in modo indiscriminato le finestre figlio. Per ottenere prestazioni ottimali, un'applicazione che deve dividere logicamente la finestra principale deve eseguire questa operazione nella procedura della finestra principale anziché usando finestre figlio.

Relazione con la finestra padre

Un'applicazione può modificare la finestra padre di una finestra figlio esistente chiamando la funzione SetParent . In questo caso, il sistema rimuove la finestra figlio dall'area client della finestra padre precedente e la sposta nell'area client della nuova finestra padre. Se SetParent specifica un handle NULL , la finestra desktop diventa la nuova finestra padre. In questo caso, la finestra figlio viene disegnata sul desktop, all'esterno dei bordi di qualsiasi altra finestra. La funzione GetParent recupera un handle nella finestra padre di una finestra figlio.

La finestra padre relinquise una parte dell'area client in una finestra figlio e la finestra figlio riceve tutto l'input da questa area. La classe finestra non deve essere la stessa per ognuna delle finestre figlio della finestra padre. Ciò significa che un'applicazione può riempire una finestra padre con finestre figlio che sembrano diverse e eseguire attività diverse. Ad esempio, una finestra di dialogo può contenere molti tipi di controlli, ogni finestra figlio che accetta diversi tipi di dati dall'utente.

Una finestra figlio ha una sola finestra padre, ma un padre può avere qualsiasi numero di finestre figlio. Ogni finestra figlio, a sua volta, può avere finestre figlio. In questa catena di finestre ogni finestra figlio viene chiamata finestra discendente della finestra padre originale. Un'applicazione usa la funzione IsChild per individuare se una determinata finestra è una finestra figlio o una finestra discendente di una determinata finestra padre.

La funzione EnumChildWindows enumera le finestre figlio di una finestra padre. Quindi, EnumChildWindows passa l'handle a ogni finestra figlio a una funzione di callback definita dall'applicazione. Le finestre discendenti della finestra padre specificata vengono enumerate anche.

Messaggi

Il sistema passa i messaggi di input di una finestra figlio direttamente alla finestra figlio; i messaggi non vengono passati attraverso la finestra padre. L'unica eccezione è se la finestra figlio è stata disabilitata dalla funzione EnableWindow . In questo caso, il sistema passa tutti i messaggi di input che sarebbero passati alla finestra figlio alla finestra padre. In questo modo la finestra padre consente di esaminare i messaggi di input e abilitare la finestra figlio, se necessario.

Una finestra figlio può avere un identificatore intero univoco. Gli identificatori di finestra figlio sono importanti quando si riguardano le finestre di controllo. Un'applicazione indirizza l'attività di un controllo inviando i messaggi. L'applicazione usa l'identificatore della finestra figlio del controllo per indirizzare i messaggi al controllo. Inoltre, un controllo invia messaggi di notifica alla finestra padre. Un messaggio di notifica include l'identificatore della finestra figlio del controllo, usato dall'elemento padre per identificare il controllo inviato al messaggio. Un'applicazione specifica l'identificatore della finestra figlio per altri tipi di finestre figlio impostando il parametro hMenu della funzione CreateWindowEx su un valore anziché su un handle di menu.

Finestre a livelli

L'uso di una finestra a livelli può migliorare significativamente le prestazioni e gli effetti visivi per una finestra con una forma complessa, anima la forma o vuole usare effetti di fusione alfa. Il sistema compone automaticamente e riintende le finestre a livelli e le finestre delle applicazioni sottostanti. Di conseguenza, le finestre a livelli vengono rese uniformemente, senza il flickering tipico di aree di finestra complesse. Inoltre, le finestre a livelli possono essere parzialmente translucenti, ovvero alfa-blended.

Per creare una finestra a livelli, specificare lo stile della finestra estesa WS_EX_LAYERED quando si chiama la funzione CreateWindowEx oppure chiamare la funzione SetWindowLong per impostare WS_EX_LAYERED dopo la creazione della finestra. Dopo la chiamata CreateWindowEx , la finestra a livelli non diventerà visibile fino a quando la funzione SetLayeredWindowAttributes o UpdateLayeredWindow è stata chiamata per questa finestra.

Nota

A partire da Windows 8, è possibile usare WS_EX_LAYERED con finestre figlio e finestre di primo livello. Le versioni precedenti di Windows supportano WS_EX_LAYERED solo per le finestre di primo livello.

 

Per impostare il livello di opacità o la chiave di colore di trasparenza per una finestra a livelli specificata, chiamare SetLayeredWindowAttributes. Dopo la chiamata, il sistema può comunque chiedere alla finestra di disegnare quando viene visualizzata o ridimensionata la finestra. Tuttavia, poiché il sistema archivia l'immagine di una finestra a livelli, il sistema non chiederà alla finestra di disegnare se le parti di esso vengono rivelate come risultato delle finestre relative si spostano sul desktop. Le applicazioni legacy non devono ristrutturare il codice di disegno se vogliono aggiungere effetti di translucenza o trasparenza per una finestra, perché il sistema reindirizza la pittura di finestre denominata SetLayeredWindowAttributes nella memoria fuori schermo e la ricompone per ottenere l'effetto desiderato.

Per animazioni più veloci ed efficienti o se è necessario per pixel alfa, chiamare UpdateLayeredWindow. UpdateLayeredWindow deve essere usato principalmente quando l'applicazione deve specificare direttamente la forma e il contenuto di una finestra a livelli, senza usare il meccanismo di reindirizzamento fornito dal sistema tramite SetLayeredWindowAttributes. Inoltre, l'uso di UpdateLayeredWindow usa direttamente la memoria in modo più efficiente, perché il sistema non necessita della memoria aggiuntiva necessaria per archiviare l'immagine della finestra reindirizzata. Per garantire l'efficienza massima nelle finestre di animazione, chiamare UpdateLayeredWindow per modificare la posizione e le dimensioni di una finestra a livelli. Si noti che dopo aver chiamato SetLayeredWindowAttributes , le chiamate UpdateLayeredWindow successive non avranno esito negativo fino a quando il bit di stile a livelli non viene cancellato e impostato di nuovo.

Il test di hit test di una finestra a livelli si basa sulla forma e sulla trasparenza della finestra. Ciò significa che le aree della finestra con chiave colore o il cui valore alfa è zero consentiranno ai messaggi del mouse. Tuttavia, se la finestra a livelli ha lo stile della finestra estesa WS_EX_TRANSPARENT , la forma della finestra a livelli verrà ignorata e gli eventi del mouse verranno passati ad altre finestre sotto la finestra a livelli.

Message-Only Windows

Una finestra di solo messaggio consente di inviare e ricevere messaggi. Non è visibile, non ha alcun ordine z, non può essere enumerato e non riceve messaggi di trasmissione. La finestra invia semplicemente messaggi.

Per creare una finestra di solo messaggio, specificare la costante HWND_MESSAGE o un handle in una finestra di sola messaggio esistente nel parametro hWndParent della funzione CreateWindowEx . È anche possibile modificare una finestra esistente in una finestra solo messaggio specificando HWND_MESSAGE nel parametro hWndNewParent della funzione SetParent .

Per trovare finestre di solo messaggio, specificare HWND_MESSAGE nel parametro hwndParent della funzione FindWindowEx . Inoltre, FindWindowEx cerca finestre solo messaggi e finestre di primo livello se i parametri hwndParent e hwndChildAfter sono NULL.

Relazioni tra finestre

Esistono molti modi in cui una finestra può essere correlata all'utente o a un'altra finestra. Una finestra può essere una finestra di proprietà, una finestra in primo piano o una finestra di sfondo. Una finestra ha anche un ordine z rispetto ad altre finestre. Per altre informazioni, vedere gli argomenti seguenti:

Primo piano e Windows in background

Ogni processo può avere più thread di esecuzione e ogni thread può creare finestre. Il thread che ha creato la finestra con cui l'utente sta attualmente lavorando viene chiamato thread di primo piano e la finestra viene chiamata finestra in primo piano. Tutti gli altri thread sono thread in background e le finestre create dai thread in background sono chiamate finestre in background.

Ogni thread ha un livello di priorità che determina la quantità di tempo di CPU ricevuto dal thread. Anche se un'applicazione può impostare il livello di priorità dei thread, normalmente il thread in primo piano ha un livello di priorità leggermente superiore rispetto ai thread in background. Poiché ha una priorità maggiore, il thread in primo piano riceve più tempo di CPU rispetto ai thread in background. Il thread in primo piano ha una priorità di base normale pari a 9; un thread in background ha una priorità di base normale pari a 7.

L'utente imposta la finestra in primo piano facendo clic su una finestra oppure usando la combinazione di tasti ALT+TAB o ALT+ESC. Per recuperare un handle nella finestra in primo piano, usare la funzione GetForegroundWindow . Per verificare se la finestra dell'applicazione è la finestra in primo piano, confrontare l'handle restituito da GetForegroundWindow a quello della finestra dell'applicazione.

Un'applicazione imposta la finestra di primo piano usando la funzione SetForegroundWindow .

Il sistema limita i processi che possono impostare la finestra di primo piano. Un processo può impostare la finestra di primo piano solo se:

  • Tutte le condizioni seguenti sono vere:
    • Il processo che chiama SetForegroundWindow appartiene a un'applicazione desktop, non a un'app UWP o a un'app di Windows Store progettata per Windows 8 o 8.1.
    • Il processo in primo piano non ha disabilitato le chiamate a SetForegroundWindow tramite una chiamata precedente alla funzione LockSetForegroundWindow .
    • Il timeout del blocco in primo piano è scaduto (vedere SPI_GETFOREGROUNDLOCKTIMEOUT in SystemParametersInfo).
    • Nessun menu è attivo.
  • Inoltre, almeno una delle seguenti condizioni è vera:
    • Il processo chiamante è il processo in primo piano.
    • Il processo di chiamata è stato avviato dal processo in primo piano.
    • Attualmente non esiste alcuna finestra in primo piano e quindi nessun processo in primo piano.
    • Il processo chiamante ha ricevuto l'ultimo evento di input.
    • Il processo in primo piano o il processo chiamante viene eseguito il debug.

È possibile che un processo venga negato il diritto di impostare la finestra in primo piano anche se soddisfa queste condizioni.

Un processo che può impostare la finestra di primo piano può abilitare un altro processo per impostare la finestra di primo piano chiamando la funzione AllowSetForegroundWindow o chiamando la funzione BroadcastSystemMessage con il flag di BSF_ALLOWSFW . Il processo in primo piano può disabilitare le chiamate a SetForegroundWindow chiamando la funzione LockSetForegroundWindow .

Windows di proprietà

Una finestra popup o sovrapposta può essere di proprietà di un'altra finestra sovrapposta o popup. La proprietà inserisce diversi vincoli in una finestra.

  • Una finestra di proprietà è sempre superiore al suo proprietario nell'ordine z.
  • Il sistema elimina automaticamente una finestra di proprietà quando il proprietario viene distrutto.
  • Una finestra di proprietà è nascosta quando il proprietario viene ridotto al minimo.

Solo una finestra popup o sovrapposta può essere una finestra proprietario; una finestra figlio non può essere una finestra proprietario. Un'applicazione crea una finestra di proprietà specificando l'handle della finestra del proprietario come parametro hwndParent di CreateWindowEx quando crea una finestra con lo stile WS_OVERLAPPED o WS_POPUP . Il parametro hwndParent deve identificare una finestra sovrapposta o popup. Se hwndParent identifica una finestra figlio, il sistema assegna la proprietà alla finestra padre di primo livello della finestra figlio. Dopo aver creato una finestra di proprietà, un'applicazione non può trasferire la proprietà della finestra a un'altra finestra.

Le finestre di dialogo e le finestre di messaggio sono di proprietà per impostazione predefinita. Un'applicazione specifica la finestra del proprietario quando si chiama una funzione che crea una finestra di dialogo o una finestra di messaggio.

Un'applicazione può usare la funzione GetWindow con il flag di GW_OWNER per recuperare un handle al proprietario di una finestra.

Ordine Z

L'ordine z di una finestra indica la posizione della finestra in uno stack di finestre sovrapposte. Questo stack di finestre è orientato lungo un asse immaginario, l'asse z, estendendosi verso l'esterno dallo schermo. La finestra nella parte superiore dell'ordine z si sovrappone a tutte le altre finestre. La finestra nella parte inferiore dell'ordine z viene sovrapposta a tutte le altre finestre.

Il sistema gestisce l'ordine z in un singolo elenco. Aggiunge finestre all'ordine z in base al fatto che siano finestre di primo livello, finestre di primo livello o finestre figlio. Una finestra superiore si sovrappone a tutte le altre finestre non superiore, indipendentemente dal fatto che sia la finestra attiva o in primo piano. Una finestra superiore ha lo stile WS_EX_TOPMOST . Tutte le finestre più in alto vengono visualizzate nell'ordine z prima di qualsiasi finestra non superiore. Una finestra figlio viene raggruppata con il relativo padre in ordine z.

Quando un'applicazione crea una finestra, il sistema lo inserisce nella parte superiore dell'ordine z per le finestre dello stesso tipo. È possibile usare la funzione BringWindowToTop per portare una finestra nella parte superiore dell'ordine z per le finestre dello stesso tipo. È possibile riorganizzare l'ordine z usando le funzioni SetWindowPos e DeferWindowPos .

L'utente modifica l'ordine z attivando una finestra diversa. Il sistema posiziona la finestra attiva nella parte superiore dell'ordine z per le finestre dello stesso tipo. Quando una finestra si trova nella parte superiore dell'ordine z, quindi eseguire le finestre figlio. È possibile usare la funzione GetTopWindow per cercare tutte le finestre figlio di una finestra padre e restituire un handle alla finestra figlio più alta in ordine z. La funzione GetNextWindow recupera un handle nella finestra successiva o precedente in z-order.

Finestra Mostra stato

In qualsiasi momento, una finestra può essere attiva o inattiva; nascosto o visibile; e ridotto al minimo, ingrandita o ripristinata. Queste qualità vengono definite collettivamente come stato della finestra. Gli argomenti seguenti illustrano lo stato della finestra:

Finestra attiva

Una finestra attiva è la finestra di primo livello dell'applicazione con cui l'utente sta attualmente lavorando. Per consentire all'utente di identificare facilmente la finestra attiva, il sistema lo inserisce nella parte superiore dell'ordine z e modifica il colore della barra del titolo e del bordo ai colori delle finestre attive definite dal sistema. Solo una finestra di primo livello può essere una finestra attiva. Quando l'utente usa una finestra figlio, il sistema attiva la finestra padre di primo livello associata alla finestra figlio.

Solo una finestra di primo livello nel sistema è attiva alla volta. L'utente attiva una finestra di primo livello facendo clic su di essa (o una delle finestre figlio) oppure usando la combinazione di tasti ALT+ESC o ALT+TAB. Un'applicazione attiva una finestra di primo livello chiamando la funzione SetActiveWindow . Altre funzioni possono causare l'attivazione di una finestra di primo livello diversa, tra cui SetWindowPos, DeferWindowPos, SetWindowPlacement e DestroyWindow. Anche se un'applicazione può attivare una finestra di primo livello diversa in qualsiasi momento, per evitare confusione con l'utente, dovrebbe farlo solo in risposta a un'azione dell'utente. Un'applicazione usa la funzione GetActiveWindow per recuperare un handle nella finestra attiva.

Quando l'attivazione viene modificata da una finestra di primo livello di un'applicazione alla finestra principale di un'altra, il sistema invia un messaggio di WM_ACTIVATEAPP a entrambe le applicazioni, notificandole la modifica. Quando l'attivazione viene modificata in una finestra di primo livello diversa nella stessa applicazione, il sistema invia entrambi i messaggi WM_ACTIVATE .

Windows disabilitato

È possibile disabilitare una finestra. Una finestra disabilitata non riceve alcun input da tastiera o mouse dall'utente, ma può ricevere messaggi da altre finestre, da altre applicazioni e dal sistema. Un'applicazione disabilita in genere una finestra per impedire all'utente di usare la finestra. Ad esempio, un'applicazione può disabilitare un pulsante push in una finestra di dialogo per impedire all'utente di sceglierlo. Un'applicazione può abilitare una finestra disabilitata in qualsiasi momento; l'abilitazione di una finestra ripristina l'input normale.

Per impostazione predefinita, una finestra viene abilitata al momento della creazione. Un'applicazione può specificare lo stile WS_DISABLED , tuttavia, per disabilitare una nuova finestra. Un'applicazione abilita o disabilita una finestra esistente usando la funzione EnableWindow . Il sistema invia un messaggio WM_ENABLE a una finestra quando lo stato abilitato sta per cambiare. Un'applicazione può determinare se una finestra è abilitata usando la funzione IsWindowEnabled .

Quando una finestra figlio è disabilitata, il sistema passa i messaggi di input del mouse del figlio alla finestra padre. L'elemento padre usa i messaggi per determinare se abilitare la finestra figlio. Per altre informazioni, vedere Input del mouse.

Solo una finestra alla volta può ricevere l'input della tastiera; tale finestra viene detto di avere lo stato attivo della tastiera. Se un'applicazione usa la funzione EnableWindow per disabilitare una finestra dello stato attivo da tastiera, la finestra perde lo stato attivo della tastiera oltre a essere disabilitata. EnableWindow imposta quindi lo stato attivo della tastiera su NULL, ovvero nessuna finestra ha lo stato attivo. Se una finestra figlio o un'altra finestra discendente ha lo stato attivo della tastiera, la finestra discendente perde lo stato attivo quando la finestra padre è disabilitata. Per altre informazioni, vedere Input da tastiera.

Visibilità finestra

Una finestra può essere visibile o nascosta. Il sistema visualizza una finestra visibile sullo schermo. Nasconde una finestra nascosta non disegnandola. Se una finestra è visibile, l'utente può fornire input alla finestra e visualizzarne l'output. Una finestra nascosta è disabilitata. Può elaborare messaggi dal sistema o da altre finestre ma non può elaborare input di utenti o visualizzare output. Un'applicazione imposta lo stato di visibilità di una finestra durante la creazione della finestra. In seguito, l'applicazione può modificare lo stato di visibilità.

Una finestra è visibile quando lo stile WS_VISIBLE è impostato per la finestra. Per impostazione predefinita, la funzione CreateWindowEx crea una finestra nascosta a meno che l'applicazione non specifichi lo stile WS_VISIBLE . In genere, un'applicazione imposta lo stile WS_VISIBLE dopo aver creato una finestra per mantenere i dettagli del processo di creazione nascosto dall'utente. Ad esempio, un'applicazione può mantenere nascosta una nuova finestra mentre personalizza l'aspetto della finestra. Se lo stile WS_VISIBLE viene specificato in CreateWindowEx, il sistema invia il messaggio di WM_SHOWWINDOW alla finestra dopo aver creato la finestra, ma prima di visualizzarlo.

Un'applicazione può determinare se una finestra è visibile usando la funzione IsWindowVisible . Un'applicazione può visualizzare (rendere visibile) o nascondere una finestra usando la funzione ShowWindow, SetWindowPos, DeferWindowPos o SetWindowPlacement o SetWindowLong . Queste funzioni mostrano o nascondono una finestra impostando o rimuovendo lo stile WS_VISIBLE per la finestra. Inviano anche il messaggio WM_SHOWWINDOW alla finestra prima di visualizzarlo o nasconderlo.

Quando viene ridotta al minimo una finestra del proprietario, il sistema nasconde automaticamente le finestre di proprietà associate. Analogamente, quando viene ripristinata una finestra proprietario, il sistema visualizza automaticamente le finestre di proprietà associate. In entrambi i casi, il sistema invia il messaggio di WM_SHOWWINDOW alle finestre di proprietà prima di nasconderle o mostrarle. Occasionalmente, un'applicazione potrebbe dover nascondere le finestre di proprietà senza dover ridurre al minimo o nascondere il proprietario. In questo caso, l'applicazione usa la funzione ShowOwnedPopups . Questa funzione imposta o rimuove lo stile WS_VISIBLE per tutte le finestre di proprietà e invia il messaggio WM_SHOWWINDOW alle finestre di proprietà prima di nasconderle o mostrarle. Nascondere una finestra del proprietario non ha alcun effetto sullo stato di visibilità delle finestre di proprietà.

Quando una finestra padre è visibile, le finestre figlio associate sono visibili anche. Analogamente, quando la finestra padre è nascosta, le finestre figlio sono nascoste. La riduzione al minimo della finestra padre non ha effetto sullo stato di visibilità delle finestre figlio; ovvero, le finestre figlio vengono ridotte al minimo insieme all'elemento padre, ma lo stile WS_VISIBLE non viene modificato.

Anche se una finestra ha lo stile WS_VISIBLE , l'utente potrebbe non essere in grado di visualizzare la finestra sullo schermo; altre finestre possono sovrapporsi completamente o potrebbero essere state spostate oltre il bordo dello schermo. Inoltre, una finestra figlio visibile è soggetta alle regole di ritaglio stabilite dalla relazione padre-figlio. Se la finestra padre della finestra non è visibile, non sarà visibile. Se la finestra padre si sposta oltre il bordo dello schermo, la finestra figlio viene spostata anche perché una finestra figlio viene disegnata rispetto all'angolo superiore sinistro dell'elemento padre. Ad esempio, un utente può spostare la finestra padre contenente la finestra figlio abbastanza lontano dal bordo dello schermo che l'utente potrebbe non essere in grado di visualizzare la finestra figlio, anche se la finestra figlio e la relativa finestra padre hanno entrambi lo stile WS_VISIBLE .

Finestre ridotte a icona, ingrandita e ripristinata

Una finestra ingrandita è una finestra con stile WS_MAXIMIZE . Per impostazione predefinita, il sistema visualizza una finestra ingrandita in modo da riempire lo schermo oppure, in caso di una finestra figlia, l'area client della finestra padre. Anche se le dimensioni di una finestra possono essere impostate sulla stessa dimensione di una finestra ingrandita, una finestra ingrandita è leggermente diversa. Il sistema sposta automaticamente la barra del titolo della finestra nella parte superiore della schermata o nella parte superiore dell'area client della finestra padre. Inoltre, il sistema disabilita il bordo di ridimensionamento della finestra e la funzionalità di posizionamento della finestra della barra del titolo (in modo che l'utente non possa spostare la finestra trascinando la barra del titolo).

Una finestra ridotta a icona è una finestra con lo stile WS_MINIMIZE . Per impostazione predefinita, il sistema riduce una finestra alle dimensioni del pulsante della barra delle attività e la sposta sulla barra delle attività. Una finestra ripristinata è una finestra che è stata restituita alla dimensione e alla posizione precedente, ovvero le dimensioni che era prima che fosse ridotta a icona o ingrandita.

Se un'applicazione specifica lo stile WS_MAXIMIZE o WS_MINIMIZE nella funzione CreateWindowEx , la finestra viene inizialmente ingrandita o ridotta al minimo. Dopo aver creato una finestra, un'applicazione può usare la funzione CloseWindow per ridurre al minimo la finestra. La funzione ArrangeIconicWindows dispone le icone sul desktop oppure dispone le finestre figlio ridotte a icona di una finestra padre nella finestra padre. La funzione OpenIcon ripristina una finestra ridotta a icona alla dimensione e alla posizione precedente.

La funzione ShowWindow può ridurre al minimo, massimizzare o ripristinare una finestra. Può anche impostare gli stati di visibilità e attivazione della finestra. La funzione SetWindowPlacement include le stesse funzionalità di ShowWindow, ma può eseguire l'override delle posizioni predefinite ridotte, ingrandita e ripristinata della finestra.

Le funzioni IsZoomed e IsIconic determinano rispettivamente se una finestra specificata è ingrandita o ridotta al minimo. La funzione GetWindowPlacement recupera le posizioni ridotte, ingrandita e ripristinate per la finestra e determina anche lo stato di visualizzazione della finestra.

Quando il sistema riceve un comando per ottimizzare o ripristinare una finestra ridotta a icona, invia alla finestra un messaggio di WM_QUERYOPEN . Se la routine della finestra restituisce FALSE, il sistema ignora il comando ingrandisce o ripristina.

Il sistema imposta automaticamente le dimensioni e la posizione di una finestra ingrandita sui valori predefiniti definiti dal sistema per una finestra ingrandita. Per eseguire l'override di queste impostazioni predefinite, un'applicazione può chiamare la funzione SetWindowPlacement o elaborare il messaggio WM_GETMINMAXINFO ricevuto da una finestra quando il sistema sta per massimizzare la finestra. WM_GETMINMAXINFO include un puntatore a una struttura MINMAXINFO contenente i valori usati dal sistema per impostare le dimensioni e la posizione ingrandita. La sostituzione di questi valori esegue l'override delle impostazioni predefinite.

Dimensioni della finestra e posizione

Le dimensioni e la posizione di una finestra vengono espresse come rettangolo di delimitazione, in base alle coordinate relative alla schermata o alla finestra padre. Le coordinate di una finestra di primo livello sono relative all'angolo superiore sinistro dello schermo; le coordinate di una finestra figlio sono relative all'angolo superiore sinistro della finestra padre. Un'applicazione specifica le dimensioni iniziali e la posizione della finestra quando crea la finestra, ma può modificare le dimensioni e la posizione della finestra in qualsiasi momento. Per altre informazioni, vedere Forme riempite.

Questa sezione contiene i seguenti argomenti:

Dimensioni predefinite e posizione

Un'applicazione può consentire al sistema di calcolare le dimensioni iniziali o la posizione di una finestra di primo livello specificando CW_USEDEFAULT in CreateWindowEx. Se l'applicazione imposta le coordinate della finestra su CW_USEDEFAULT e non ha creato altre finestre di primo livello, il sistema imposta la posizione della nuova finestra rispetto all'angolo superiore sinistro dello schermo; in caso contrario, imposta la posizione relativa alla posizione della finestra di primo livello creata più di recente dall'applicazione. Se i parametri di larghezza e altezza sono impostati su CW_USEDEFAULT, il sistema calcola le dimensioni della nuova finestra. Se l'applicazione ha creato altre finestre di primo livello, il sistema basa le dimensioni della nuova finestra sulle dimensioni della finestra più recente creata di recente. Se si specifica CW_USEDEFAULT quando si crea una finestra figlio o popup, il sistema imposta le dimensioni della finestra sulla dimensione minima predefinita.

Dimensioni rilevamento

Il sistema mantiene una dimensione minima e massima di rilevamento per una finestra dello stile WS_THICKFRAME ; una finestra con questo stile ha un bordo di ridimensionamento. La dimensione minima del rilevamento è la dimensione minima della finestra che è possibile produrre trascinando il bordo di ridimensionamento della finestra. Analogamente, le dimensioni massime di rilevamento sono le dimensioni massime della finestra che è possibile produrre trascinando il bordo di ridimensionamento.

Le dimensioni minime e massime di rilevamento di una finestra sono impostate sui valori predefiniti definiti dal sistema quando il sistema crea la finestra. Un'applicazione può individuare le impostazioni predefinite e eseguirne l'override elaborando il messaggio di WM_GETMINMAXINFO . Per altre informazioni, vedere Dimensioni e messaggi posizione.

Comandi di sistema

Un'applicazione con un menu finestra può modificare le dimensioni e la posizione di tale finestra inviando comandi di sistema. I comandi di sistema vengono generati quando l'utente sceglie i comandi dal menu della finestra. Un'applicazione può emulare l'azione dell'utente inviando un messaggio WM_SYSCOMMAND alla finestra. I comandi di sistema seguenti influiscono sulle dimensioni e sulla posizione di una finestra.

Comando Descrizione
SC_CLOSE Chiude la finestra. Questo comando invia un messaggio WM_CLOSE alla finestra. La finestra esegue tutti i passaggi necessari per pulire e distruggere se stesso.
SC_MAXIMIZE Ottimizza la finestra.
SC_MINIMIZE Riduce a icona la finestra.
SC_MOVE Sposta la finestra.
SC_RESTORE Ripristina una finestra ridotta a icona o ingrandita alla dimensione e alla posizione precedente.
SC_SIZE Avvia un comando dimensioni. Per modificare le dimensioni della finestra, usare il mouse o la tastiera.

 

Funzioni di dimensione e posizione

Dopo aver creato una finestra, un'applicazione può impostare le dimensioni o la posizione della finestra chiamando una delle diverse funzioni, tra cui SetWindowPlacement, MoveWindow, SetWindowPos e DeferWindowPos. SetWindowPlacement imposta la posizione ridotta a icona della finestra, la posizione ingrandita, la dimensione e la posizione ripristinata e mostra lo stato. Le funzioni MoveWindow e SetWindowPos sono simili; impostare entrambe le dimensioni o la posizione di una singola finestra dell'applicazione. La funzione SetWindowPos include un set di flag che influiscono sullo stato di visualizzazione della finestra; MoveWindow non include questi flag. Usare le funzioni BeginDeferWindowPos, DeferWindowPos e EndDeferWindowPos per impostare simultaneamente la posizione di una serie di finestre, tra cui le dimensioni, la posizione, la posizione nell'ordine z e visualizzare lo stato.

Un'applicazione può recuperare le coordinate del rettangolo di selezione di una finestra usando la funzione GetWindowRect . GetWindowRect riempie una struttura RECT con le coordinate dell'angolo superiore sinistro e inferiore destro della finestra. Le coordinate sono relative all'angolo superiore sinistro dello schermo, anche per una finestra figlio. La funzione ScreenToClient o MapWindowPoints esegue il mapping delle coordinate dello schermo del rettangolo di selezione della finestra figlio per coordinate relative all'area client della finestra padre.

La funzione GetClientRect recupera le coordinate dell'area client di una finestra. GetClientRect riempie una struttura RECT con le coordinate dell'angolo superiore sinistro e inferiore destro dell'area client, ma le coordinate sono relative all'area client stessa. Ciò significa che le coordinate dell'angolo superiore sinistro dell'area client sono sempre (0,0) e le coordinate dell'angolo inferiore destro sono la larghezza e l'altezza dell'area client.

La funzione CascadeWindows si estende a cascata nelle finestre sul desktop o in cascata le finestre figlio della finestra padre specificata. La funzione TileWindows riquadri le finestre sul desktop o riquadri delle finestre figlio della finestra padre specificata.

Dimensioni e messaggi di posizione

Il sistema invia il messaggio di WM_GETMINMAXINFO a una finestra la cui dimensione o posizione sta per cambiare. Ad esempio, il messaggio viene inviato quando l'utente fa clic su Sposta o Dimensioni dal menu della finestra o fa clic sul bordo di ridimensionamento o sulla barra del titolo; il messaggio viene inviato anche quando un'applicazione chiama SetWindowPos per spostare o ridimensionare la finestra. WM_GETMINMAXINFO include un puntatore a una struttura MINMAXINFO contenente le dimensioni e la posizione ottimizzata predefinita per la finestra, nonché le dimensioni minime e massime predefinite di rilevamento. Un'applicazione può eseguire l'override delle impostazioni predefinite elaborando WM_GETMINMAXINFO e impostando i membri appropriati di MINMAXINFO. Una finestra deve avere lo stile WS_THICKFRAME o WS_CAPTION per ricevere WM_GETMINMAXINFO. Una finestra con lo stile WS_THICKFRAME riceve questo messaggio durante il processo di creazione della finestra, nonché quando viene spostato o ridimensionato.

Il sistema invia il messaggio di WM_WINDOWPOSCHANGING a una finestra la cui dimensione, posizione, posizione nell'ordine z o mostra lo stato sta per cambiare. Questo messaggio include un puntatore a una struttura WINDOWPOS che specifica le nuove dimensioni della finestra, la posizione, la posizione nell'ordine z e lo stato mostra. Impostando i membri di WINDOWPOS, un'applicazione può influire sulle nuove dimensioni, la posizione e l'aspetto della finestra.

Dopo aver modificato le dimensioni di una finestra, la posizione, la posizione nell'ordine z o visualizzare lo stato, il sistema invia il messaggio di WM_WINDOWPOSCHANGED alla finestra. Questo messaggio include un puntatore a WINDOWPOS che informa la finestra della nuova dimensione, posizione, posizione nell'ordine z e mostra lo stato. L'impostazione dei membri della struttura WINDOWPOS passata con WM_WINDOWPOSCHANGED non ha alcun effetto sulla finestra. Una finestra che deve elaborare WM_SIZE e WM_MOVE messaggi deve passare WM_WINDOWPOSCHANGED alla funzione DefWindowProc ; in caso contrario, il sistema non invia messaggi WM_SIZE e WM_MOVE alla finestra.

Il sistema invia il messaggio WM_NCCALCSIZE a una finestra quando viene creata o ridimensionata la finestra. Il sistema usa il messaggio per calcolare le dimensioni dell'area client di una finestra e la posizione dell'area client rispetto all'angolo superiore sinistro della finestra. Una finestra passa in genere questo messaggio alla procedura di finestra predefinita; Tuttavia, questo messaggio può essere utile nelle applicazioni che personalizzano l'area non client di una finestra o conservano parti dell'area client quando la finestra viene ridimensionata. Per altre informazioni, vedere Disegno e disegno.

Animazione finestra

È possibile produrre effetti speciali quando si visualizzano o si nascondono finestre usando la funzione AnimateWindow . Quando la finestra viene animata in questo modo, il sistema eseguirà il roll, la diapositiva o dissolverà la finestra, a seconda dei flag specificati in una chiamata a AnimateWindow.

Per impostazione predefinita, il sistema usa l'animazione roll. Con questo effetto, la finestra appare aperta (che mostra la finestra) o il roll chiuso (nascondendo la finestra). È possibile utilizzare il parametro dwFlags per specificare se la finestra scorre orizzontalmente, verticalmente o diagonalmente.

Quando si specifica il flag di AW_SLIDE , il sistema usa l'animazione diapositiva. Con questo effetto, la finestra sembra scorrere in visualizzazione (che mostra la finestra) o scorrere fuori visualizzazione (nascondendo la finestra). È possibile utilizzare il parametro dwFlags per specificare se la finestra scorre orizzontalmente, verticalmente o diagonalmente.

Quando si specifica il flag di AW_BLEND , il sistema usa una dissolvenza alfa blended.

È anche possibile usare il flag AW_CENTER per far apparire una finestra in modo da comprimere verso l'interno o espandersi verso l'esterno.

Layout e mirroring delle finestre

Il layout della finestra definisce la disposizione degli oggetti GDI (Text e Windows Graphics Device Interface) in una finestra o in un contesto di dispositivo.The window layout define how text and Windows Graphics Device Interface (GDI) objects are layout out in a window or device context (DC). Alcune lingue, ad esempio inglese, francese e tedesco, richiedono un layout da sinistra a destra (LTR). Altre lingue, ad esempio arabo ed ebraico, richiedono il layout da destra a sinistra (RTL). Il layout della finestra si applica al testo, ma influisce anche sugli altri elementi GDI della finestra, tra cui bitmap, icone, posizione dell'origine, pulsanti, controlli albero a catena e se la coordinata orizzontale aumenta man mano che si passa a sinistra o a destra. Ad esempio, dopo che un'applicazione ha impostato il layout RTL, l'origine viene posizionata sul bordo destro della finestra o del dispositivo e il numero che rappresenta la coordinata orizzontale aumenta man mano che si sposta a sinistra. Tuttavia, non tutti gli oggetti sono interessati dal layout di una finestra. Ad esempio, il layout per finestre di dialogo, finestre di messaggio e contesti di dispositivo non associati a una finestra, ad esempio i controller di dominio di metafile e stampante, deve essere gestito separatamente. Le specifiche per queste informazioni sono indicate più avanti in questo argomento.

Le funzioni della finestra consentono di specificare o modificare il layout della finestra nelle versioni arabe ed ebraiche di Windows. Si noti che la modifica a un layout RTL (noto anche come mirroring) non è supportata per le finestre con lo stile CS_OWNDC o per un controller di dominio con la modalità grafica GM_ADVANCED.

Per impostazione predefinita, il layout della finestra è da sinistra a destra (LTR). Per impostare il layout della finestra RTL, chiamare CreateWindowEx con lo stile WS_EX_LAYOUTRTL. Per impostazione predefinita, anche una finestra figlio creata con lo stile WS_CHILD e con un parametro hWnd padre valido nella chiamata a CreateWindow o CreateWindowEx ha lo stesso layout del relativo elemento padre. Per disabilitare l'ereditarietà del mirroring in tutte le finestre figlio, specificare WS_EX_NOINHERITLAYOUT nella chiamata a CreateWindowEx. Nota, il mirroring non viene ereditato da finestre di proprietà (quelle create senza lo stile WS_CHILD ) o quelle create con il parametro hWnd padre in CreateWindowEx impostato su NULL. Per disabilitare l'ereditarietà del mirroring per una singola finestra, elaborare il messaggio WM_NCCREATE con GetWindowLong e SetWindowLong per disattivare il flag WS_EX_LAYOUTRTL . Questa elaborazione si aggiunge a qualsiasi altra elaborazione necessaria. Il frammento di codice seguente mostra come viene eseguita questa operazione.

SetWindowLong (hWnd, 
               GWL_EXSTYLE, 
               GetWindowLong(hWnd,GWL_EXSTYLE) & ~WS_EX_LAYOUTRTL))

È possibile impostare il layout predefinito su RTL chiamando SetProcessDefaultLayout(LAYOUT_RTL). Tutte le finestre create dopo la chiamata verranno rispecchiate, ma le finestre esistenti non sono interessate. Per disattivare il mirroring predefinito, chiamare SetProcessDefaultLayout(0).

Nota, SetProcessDefaultLayout esegue il mirroring dei controller di dominio solo delle finestre con mirroring. Per eseguire il mirroring di qualsiasi controller di dominio, chiamare SetLayout(hdc, LAYOUT_RTL). Per altre informazioni, vedere la discussione sui contesti del dispositivo di mirroring non associati alle finestre, che verrà illustrata più avanti in questo argomento.

Anche le bitmap e le icone in una finestra con mirroring vengono rispecchiate per impostazione predefinita. Tuttavia, non tutti questi elementi devono essere speculari. Ad esempio, quelli con testo, un logo aziendale o un orologio analogico non devono essere speculari. Per disabilitare il mirroring delle bitmap, chiamare SetLayout con il bit LAYOUT_BITMAPORIENTATIONPRESERVED impostato in dwLayout. Per disabilitare il mirroring in un controller di dominio, chiamare SetLayout(hdc, 0).

Per eseguire una query sul layout predefinito corrente, chiamare GetProcessDefaultLayout. In caso di esito positivo, pdwDefaultLayout contiene LAYOUT_RTL o 0. Per eseguire query sulle impostazioni di layout del contesto di dispositivo, chiamare GetLayout. Al termine della restituzione, GetLayout restituisce un valore DWORD che indica le impostazioni di layout in base alle impostazioni del LAYOUT_RTL e ai bit LAYOUT_BITMAPORIENTATIONPRESERVED.

Dopo aver creato una finestra, modificare il layout usando la funzione SetWindowLong . Ad esempio, ciò è necessario quando l'utente modifica la lingua dell'interfaccia utente di una finestra esistente da arabo o ebraico in tedesco. Tuttavia, quando si modifica il layout di una finestra esistente, è necessario invalidare e aggiornare la finestra per assicurarsi che il contenuto della finestra venga disegnato nello stesso layout. L'esempio di codice seguente è tratto dal codice di esempio che modifica il layout della finestra in base alle esigenze:

// Using ANSI versions of GetWindowLong and SetWindowLong because Unicode
// is not needed for these calls

lExStyles = GetWindowLongA(hWnd, GWL_EXSTYLE);

// Check whether new layout is opposite the current layout
if (!!(pLState -> IsRTLLayout) != !!(lExStyles & WS_EX_LAYOUTRTL))
{
    // the following lines will update the window layout

    lExStyles ^= WS_EX_LAYOUTRTL;        // toggle layout
    SetWindowLongA(hWnd, GWL_EXSTYLE, lExStyles);
    InvalidateRect(hWnd, NULL, TRUE);    // to update layout in the client area
}

Nel mirroring, è consigliabile considerare in termini di "vicino" e "lontano" anziché "sinistra" e "destra". In caso contrario, possono verificarsi problemi. Una pratica comune di codifica che causa problemi in una finestra con mirroring si verifica quando si esegue il mapping tra le coordinate dello schermo e le coordinate client. Ad esempio, le applicazioni usano spesso codice simile al seguente per posizionare un controllo in una finestra:

// DO NOT USE THIS IF APPLICATION MIRRORS THE WINDOW

// get coordinates of the window in screen coordinates
GetWindowRect(hControl, (LPRECT) &rControlRect);  

// map screen coordinates to client coordinates in dialog
ScreenToClient(hDialog, (LPPOINT) &rControlRect.left); 
ScreenToClient(hDialog, (LPPOINT) &rControlRect.right);

Ciò causa problemi nel mirroring perché il bordo sinistro del rettangolo diventa il bordo destro in una finestra con mirroring e viceversa. Per evitare questo problema, sostituire le chiamate ScreenToClient con una chiamata a MapWindowPoints come indicato di seguito:

// USE THIS FOR MIRRORING

GetWindowRect(hControl, (LPRECT) &rControlRect);
MapWindowPoints(NULL, hDialog, (LPPOINT) &rControlRect, 2)

Questo codice funziona perché, nelle piattaforme che supportano il mirroring, MapWindowPoints viene modificato per scambiare le coordinate del punto sinistro e destro quando viene eseguito il mirroring della finestra client. Per altre informazioni, vedere la sezione Osservazioni di MapWindowPoints.

Un'altra pratica comune che può causare problemi nelle finestre con mirroring consiste nel posizionare gli oggetti in una finestra client usando gli offset nelle coordinate dello schermo anziché le coordinate client. Ad esempio, il codice seguente usa la differenza nelle coordinate dello schermo come posizione x nelle coordinate client per posizionare un controllo in una finestra di dialogo.

// OK if LTR layout and mapping mode of client is MM_TEXT,
// but WRONG for a mirrored dialog 

RECT rdDialog;
RECT rcControl;

HWND hControl = GetDlgItem(hDlg, IDD_CONTROL);
GetWindowRect(hDlg, &rcDialog);             // gets rect in screen coordinates
GetWindowRect(hControl, &rcControl);
MoveWindow(hControl,
           rcControl.left - rcDialog.left,  // uses x position in client coords
           rcControl.top - rcDialog.top,
           nWidth,
           nHeight,
           FALSE);

Questo codice è corretto quando la finestra di dialogo ha layout da sinistra a destra e la modalità di mapping del client è MM_TEXT, perché la nuova posizione x nelle coordinate client corrisponde alla differenza tra i bordi sinistro del controllo e la finestra di dialogo nelle coordinate dello schermo. Tuttavia, in una finestra di dialogo con mirroring, sinistra e destra vengono invertiti, quindi è consigliabile usare MapWindowPoints come indicato di seguito:

RECT rcDialog;
RECT rcControl;

HWND hControl - GetDlgItem(hDlg, IDD_CONTROL);
GetWindowRect(hControl, &rcControl);

// MapWindowPoints works correctly in both mirrored and non-mirrored windows.
MapWindowPoints(NULL, hDlg, (LPPOINT) &rcControl, 2);

// Now rcControl is in client coordinates.
MoveWindow(hControl, rcControl.left, rcControl.top, nWidth, nHeight, FALSE)

Finestre di dialogo di mirroring e finestre di messaggio

Le finestre di dialogo e le finestre di messaggio non ereditano il layout, pertanto è necessario impostare il layout in modo esplicito. Per eseguire il mirroring di una finestra di messaggio, chiamare MessageBox o MessageBoxEx con l'opzione MB_RTLREADING. Per eseguire il layout di una finestra di dialogo da destra a sinistra, usare lo stile esteso WS_EX_LAYOUTRTL nella struttura del modello di dialogo DLGTEMPLATEEX. Le finestre delle proprietà sono un caso speciale di finestre di dialogo. Ogni scheda viene considerata come una finestra di dialogo separata, pertanto è necessario includere lo stile WS_EX_LAYOUTRTL in ogni scheda di cui si vuole eseguire il mirroring.

Contesti del dispositivo di mirroring non associati a una finestra

I controller di dominio non associati a una finestra, ad esempio metadati o controller di dominio della stampante, non ereditano il layout, pertanto è necessario impostare il layout in modo esplicito. Per modificare il layout del contesto di dispositivo, usare la funzione SetLayout .

La funzione SetLayout viene usata raramente con le finestre. In genere, le finestre ricevono un controller di dominio associato solo nell'elaborazione di un messaggio WM_PAINT . In alcuni casi, un programma crea un controller di dominio per una finestra chiamando GetDC. In entrambi i casi, il layout iniziale per il controller di dominio viene impostato da BeginPaint o GetDC in base al flag WS_EX_LAYOUTRTL della finestra.

I valori restituiti da GetWindowOrgEx, GetWindowExtEx, GetViewportOrgEx e GetViewportExtEx non sono interessati dalla chiamata a SetLayout.

Quando il layout è RTL, GetMapMode restituirà MM_ANISOTROPIC anziché MM_TEXT. La chiamata a SetMapMode con MM_TEXT funzionerà correttamente; è interessato solo il valore restituito da GetMapMode . Analogamente, la chiamata a SetLayout(hdc, LAYOUT_RTL) quando la modalità di mapping è MM_TEXT fa sì che la modalità di mapping segnalata cambi in MM_ANISOTROPIC.

Distruzione della finestra

In generale, un'applicazione deve eliminare tutte le finestre create. A tale scopo, usare la funzione DestroyWindow . Quando una finestra viene eliminata definitivamente, il sistema nasconde la finestra, se visibile e quindi rimuove i dati interni associati alla finestra. Ciò invalida l'handle di finestra, che non può più essere usato dall'applicazione.

Un'applicazione elimina molte delle finestre create subito dopo la loro creazione. Ad esempio, un'applicazione in genere elimina definitivamente una finestra di dialogo non appena l'applicazione ha un input sufficiente dall'utente per continuare l'attività. Un'applicazione alla fine elimina definitivamente la finestra principale dell'applicazione (prima di terminare).

Prima di eliminare una finestra, un'applicazione deve salvare o rimuovere i dati associati alla finestra e rilasciare tutte le risorse di sistema allocate per la finestra. Se l'applicazione non rilascia le risorse, il sistema libera tutte le risorse non liberate dall'applicazione.

L'eliminazione di una finestra non influisce sulla classe della finestra da cui viene creata la finestra. È comunque possibile creare nuove finestre usando tale classe e tutte le finestre esistenti di tale classe continuano a funzionare. L'eliminazione di una finestra distrugge anche le finestre discendenti della finestra. La funzione DestroyWindow invia un messaggio WM_DESTROY prima alla finestra, quindi alle finestre figlio e alle finestre discendenti. In questo modo, anche tutte le finestre discendenti della finestra distrutte vengono distrutte.

Una finestra con un menu finestra riceve un messaggio di WM_CLOSE quando l'utente fa clic su Chiudi. Elaborando questo messaggio, un'applicazione può richiedere conferma all'utente prima di eliminare la finestra. Se l'utente conferma che la finestra deve essere eliminata definitivamente, l'applicazione può chiamare la funzione DestroyWindow per eliminare definitivamente la finestra.

Se la finestra in fase di eliminazione definitiva è la finestra attiva, gli stati attivi e di stato attivo vengono trasferiti in un'altra finestra. La finestra che diventa la finestra attiva è la finestra successiva, come determinato dalla combinazione di tasti ALT+ESC. La nuova finestra attiva determina quindi quale finestra riceve lo stato attivo della tastiera.