Condividi tramite

Funzionalità della finestra

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

Tipi di finestra

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 ingrandire i pulsanti e le barre di scorrimento. 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 utilizza 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, un bordo di ridimensionamento, un menu finestra e pulsanti di riduzione e ingrandimento.

Finestre popup

Una finestra popup è un tipo speciale di finestra sovrapposta usata per finestre di dialogo, 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 .

Per creare una finestra popup, specificare lo stile di WS_POPUP in CreateWindowEx. Per includere una barra del titolo, specificare lo stile WS_CAPTION . Utilizzare 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.

Finestre figlie

Una finestra figlio ha lo stile WS_CHILD ed è limitata 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. Per creare una finestra figlio, si specifica lo stile WS_CHILD nella funzione CreateWindowEx.

Una finestra figlia deve avere una finestra principale. La finestra padre può essere una finestra sovrapposta, una finestra popup o anche un'altra finestra figlio. Specificate la finestra padre quando chiamate 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 vengano richieste in modo esplicito. Un'applicazione può richiedere una barra del titolo, un menu finestra, ridurre al minimo e ingrandire 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, sia quando registra la classe della finestra figlia sia quando crea la finestra figlia, l'handle di menu viene ignorato. Se non viene specificato alcuno stile di bordo, il sistema crea una finestra senza bordi. Un'applicazione può usare finestre figlie senza bordi per dividere l'area cliente di una finestra padre mantenendo le divisioni invisibili all'utente.

In questa sezione si discutono i seguenti aspetti 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 viene mai visualizzata al di fuori dei bordi della finestra padre. Se un'applicazione crea una finestra figlio più grande della finestra padre o posiziona una finestra figlio in modo che alcune o tutte le finestre figlio si estendano oltre i bordi del padre, il sistema ritaglia 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 principale Finestra figlia
Distrutto Distrutto prima che la finestra padre venga distrutta.
Nascosto Nascosto prima che la finestra padre venga nascosta. Una finestra figlio è visibile solo quando la finestra padre è visibile.
Trasferito Spostato insieme all'area client della finestra padre. La finestra figlio è responsabile del ridisegno 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 sopra la finestra figlia qualora esegua un disegno nella stessa posizione della finestra figlia. 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 sopra di essa.

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 sorella. Le finestre di pari livello possono disegnare l'una nell'area client dell'altra, a meno che una delle finestre figlio non abbia lo stile WS_CLIPSIBLINGS . Se una finestra figlia ha questo stile, viene ritagliata qualsiasi parte di una finestra sorella che si trova all'interno della finestra figlia.

Se una finestra ha lo stile WS_CLIPCHILDREN o WS_CLIPSIBLINGS , si verifica una lieve perdita di prestazioni. Ogni finestra occupa risorse di sistema, quindi un'applicazione non deve usare finestre figlie senza criterio. Per ottenere prestazioni ottimali, un'applicazione che deve dividere logicamente la finestra principale deve eseguire questa operazione nella routine della finestra principale anziché usare 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 figlia 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, al di fuori dei bordi di qualsiasi altra finestra. La funzione GetParent recupera un handle alla finestra padre di una finestra figlia.

La finestra padre rinuncia a una parte della sua area client a una finestra figlia, affinché la finestra figlia riceva tutto l'input da quest'area. La classe finestra non deve essere la stessa per ogni finestra figlia della finestra padre. Ciò significa che un'applicazione può riempire una finestra padre con finestre figlio che hanno un aspetto diverso ed eseguire attività diverse. Ad esempio, una finestra di dialogo può contenere molti tipi di controlli, ognuno dei quali è una finestra figlio che accetta tipi diversi di dati dall'utente.

Una finestra figlia ha una sola finestra padre, ma una finestra padre può avere un numero qualsiasi di finestre figlie. Ogni finestra figlio, a sua volta, può avere finestre figli. In questa catena di finestre ogni finestra figlio viene chiamata finestra discendente della finestra padre originale. Un'applicazione usa la funzione IsChild per determinare 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. EnumChildWindows passa quindi l'handle a ciascuna finestra figlia a una funzione di callback definita dall'applicazione. Vengono enumerate anche le finestre discendenti della finestra principale specificata.

Messages

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

Una finestra figlia può avere un identificatore univoco intero. Gli identificatori di finestra figlio sono importanti quando si utilizzano finestre di controllo. Un'applicazione indirizza l'attività di un controllo inviando i messaggi. L'applicazione usa l'identificatore della finestra figlia 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, che il genitore utilizza per identificare quale controllo ha inviato il 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 più livelli

L'uso di una finestra a più livelli può migliorare significativamente le prestazioni e gli effetti visivi per una finestra con una forma complessa, animarne la forma o desidera utilizzare effetti di fusione alfa. Il sistema compone e riavforma automaticamente le finestre sovrapposte e le finestre delle applicazioni sottostanti. Di conseguenza, il rendering delle finestre a livelli viene eseguito senza problemi, senza lo sfarfallio tipico delle aree di finestra complesse. Inoltre, le finestre a più livelli possono essere parzialmente traslucenti, ovvero alfa-miscelate.

Per creare una finestra a più 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 a CreateWindowEx , la finestra a più livelli non diventa visibile finché non viene chiamata la funzione SetLayeredWindowAttributes o UpdateLayeredWindow per questa finestra.

Annotazioni

A partire da Windows 8, WS_EX_LAYERED può essere usato 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 del colore di trasparenza per una determinata finestra a più livelli, chiamare SetLayeredWindowAttributes. Dopo la chiamata, il sistema potrebbe comunque chiedere alla finestra di disegnare quando viene visualizzata o ridimensionata la finestra. Tuttavia, poiché il sistema archivia l'immagine di una finestra a più livelli, il sistema non chiederà alla finestra di disegnare se le parti di esso vengono rivelate in seguito a spostamenti di finestre relative sul desktop. Le applicazioni legacy non devono ristrutturare il codice di disegno se desiderano aggiungere effetti di traslucidanza o trasparenza per una finestra, perché il sistema reindirizza il disegno di finestre chiamate SetLayeredWindowAttributes nella memoria fuori schermo e la ricompone per ottenere l'effetto desiderato.

Per un'animazione più veloce ed efficiente o se è necessario alfa per pixel, chiama UpdateLayeredWindow. UpdateLayeredWindow deve essere usato principalmente quando l'applicazione deve fornire direttamente la forma e il contenuto di una finestra a più 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 la massima efficienza nelle finestre di animazione, chiama UpdateLayeredWindow per modificare la posizione e le dimensioni di una finestra a più livelli. Si noti che, dopo aver chiamato SetLayeredWindowAttributes , le chiamate successive di UpdateLayeredWindow avranno esito negativo finché il bit dello stile di sovrapposizione non viene cancellato e impostato di nuovo.

L'hit testing di una finestra a più livelli si basa sulla forma e sulla trasparenza della finestra. Ciò significa che le aree della finestra che utilizzano la chiave cromatica o il cui valore alfa è zero consentiranno ai messaggi del mouse di passare. Tuttavia, se la finestra a più 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 più livelli.

Finestre solo messaggi

Una finestra di solo messaggio consente di inviare e ricevere messaggi. Non è visibile, non dispone di un 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 nel parametro hWndParent della funzione CreateWindowEx . È anche possibile modificare una finestra esistente in una finestra di sola messaggio specificando HWND_MESSAGE nel parametro hWndNewParent della funzione SetParent .

Per trovare finestre solo messaggi, 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:

Finestre in primo piano e 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 in 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 denominate finestre di sfondo.

Ogni thread ha un livello di priorità che determina la quantità di tempo di CPU ricevuta dal thread. Anche se un'applicazione può impostare il livello di priorità dei thread, in genere il thread in primo piano ha un livello di priorità leggermente superiore rispetto ai thread in background. Poiché ha una priorità più alta, 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 utilizzando 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 con quello della finestra dell'applicazione.

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

Il sistema limita i processi che possono impostare la finestra in primo piano. Un processo può impostare la finestra in 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 per il blocco della finestra in primo piano è scaduto (vedere SPI_GETFOREGROUNDLOCKTIMEOUT in SystemParametersInfo).
    • Nessun menu è attivo.
  • Inoltre, almeno una delle condizioni seguenti è vera:
    • Il processo chiamante è il processo in primo piano.
    • Il processo chiamante è stato avviato dal processo in primo piano.
    • Attualmente non è presente alcuna finestra in primo piano e pertanto non esiste alcun processo in primo piano.
    • Il processo chiamante ha ricevuto l'ultimo evento di input.
    • Il processo in primo piano o il processo chiamante viene sottoposto a debug.

È possibile che a un processo sia negato il diritto di impostare la finestra in primo piano pur soddisfacendo queste condizioni.

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

Windows di proprietà

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

  • Una finestra di proprietà è sempre sopra il suo proprietario nell'ordine z.
  • Il sistema elimina automaticamente una finestra di proprietà quando il proprietario viene eliminato definitivamente.
  • Una finestra di proprietà viene nascosta quando il proprietario è ridotto a icona.

Solo una finestra sovrapposta o pop-up può essere una finestra proprietaria; una finestra figlio non può essere una finestra proprietaria. 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 genitore di primo livello della finestra figlio. Dopo aver creato una finestra di proprietà, un'applicazione non può trasferire la proprietà della finestra in un'altra finestra.

Le finestre di dialogo e messaggio sono finestre di proprietà per impostazione predefinita. Un'applicazione specifica la finestra di 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 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, che si estende verso l'esterno dello schermo. La finestra nella parte superiore dell'ordine z si sovrappone a tutte le altre finestre. La finestra nella parte inferiore dell'ordine z si sovrappone a tutte le altre finestre.

Il sistema mantiene l'ordine z in un unico elenco. Aggiunge finestre all'ordine z in base al fatto che siano finestre in primo piano, finestre di primo livello o finestre figlio. Una finestra superiore si sovrappone a tutte le altre finestre non in primo piano, indipendentemente dal fatto che si tratti della 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 la sua finestra padre nell'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 all'inizio dell'ordine z per le finestre dello stesso tipo. È possibile ridisporre 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 arriva in cima all'ordine z, anche le sue finestre figlie lo fanno. È 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 ordine z.

Mostra stato finestra

In un dato momento, una finestra può essere attiva o inattiva; nascosta o visibile; e ridotta a icona, ingrandita o ripristinata. Queste qualità vengono definite collettivamente come stato di visualizzazione della finestra. Gli argomenti seguenti illustrano lo stato di visualizzazione 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 posiziona nella parte superiore dell'ordine z e modifica il colore della barra del titolo e il bordo ai colori della finestra attiva definiti dal sistema. Solo una finestra di primo livello può essere una finestra attiva. Quando l'utente utilizza 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 su una delle finestre figlio) oppure utilizzando 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 all'utente, deve 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 passa da una finestra di primo livello di un'applicazione alla finestra di primo livello di un'altra, il sistema invia un messaggio di WM_ACTIVATEAPP a entrambe le applicazioni, notificando loro la modifica. Quando l'attivazione viene modificata in un'altra finestra di primo livello nella stessa applicazione, il sistema invia a entrambe le finestre un messaggio di WM_ACTIVATE .

Windows disabilitato

Una finestra può essere disabilitata. Una finestra disabilitata non riceve 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 di scelta 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 di WM_ENABLE a una finestra quando il relativo stato abilitato sta per cambiare. Un'applicazione può determinare se una finestra è abilitata tramite la funzione IsWindowEnabled .

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

Solo una finestra alla volta può ricevere l'input da tastiera; si dice che la finestra abbia il focus tastiera. Se un'applicazione utilizza la funzione EnableWindow per disabilitare una finestra con stato attivo della tastiera, la finestra perde lo stato attivo della tastiera oltre a essere disabilitata. EnableWindow quindi imposta il focus della tastiera su NULL, il che significa che nessuna finestra ha il focus. Se una finestra figlio o un'altra finestra discendente ha il focus della tastiera, la finestra discendente perde il focus quando la finestra principale è 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 visualizzare l'output della finestra. Se una finestra è nascosta, è effettivamente disabilitata. Una finestra nascosta può elaborare i messaggi dal sistema o da altre finestre, ma non può elaborare l'input dall'utente o visualizzare l'output. Un'applicazione imposta lo stato di visibilità di una finestra durante la creazione della finestra. Successivamente, l'applicazione può modificare lo stato di visibilità.

Una finestra è visibile quando viene impostato lo stile di WS_VISIBLE 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 all'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 WM_SHOWWINDOW alla finestra dopo la creazione della finestra, ma prima di visualizzarlo.

Un'applicazione può determinare se una finestra è visibile tramite 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 una finestra del proprietario viene ridotta a icona, il sistema nasconde automaticamente le finestre di proprietà associate. Analogamente, quando viene ripristinata una finestra di proprietario, il sistema visualizza automaticamente le finestre di proprietà associate. In entrambi i casi, il sistema invia il messaggio WM_SHOWWINDOW alle finestre di proprietà prima di nasconderle o visualizzarle. In alcuni casi, un'applicazione potrebbe dover nascondere le finestre di proprietà senza dover ridurre o nascondere il proprietario. In questo caso, l'applicazione usa la funzione ShowOwnedPopups . Questa funzione imposta o rimuove lo stile di WS_VISIBLE per tutte le finestre di proprietà e invia il messaggio WM_SHOWWINDOW alle finestre di proprietà prima di nasconderle o visualizzarle. Nascondere una finestra del proprietario non ha alcun effetto sullo stato di visibilità delle finestre di proprietà.

Quando una finestra padre è visibile, sono visibili anche le finestre figlio associate. Analogamente, quando la finestra padre è nascosta, anche le finestre figlio sono nascoste. La minimizzazione della finestra padre non ha alcun effetto sullo stato di visibilità delle finestre figlio; ovvero, le finestre figlio vengono minimizzate insieme alla finestra 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, anche la finestra figlio si sposta perché è posizionata rispetto all'angolo superiore sinistro della finestra 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, massimizzate e ripristinate

Una finestra ingrandita è una finestra con lo stile WS_MAXIMIZE . Per impostazione predefinita, il sistema ingrandisce una finestra massimizzata per occupare l'intero schermo o, nel caso di una finestra figlio, 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 dello schermo 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 è una finestra con lo stile WS_MINIMIZE. Per impostazione predefinita, il sistema riduce una finestra ridotta a icona alle dimensioni del pulsante della barra delle applicazioni e sposta la finestra ridotta a icona sulla barra delle applicazioni. Una finestra ripristinata è una finestra che è stata restituita alle dimensioni e alla posizione precedenti, ovvero le dimensioni 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 a icona. 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 in una finestra padre nella stessa finestra padre. La funzione OpenIcon ripristina una finestra minimizzata alle sue dimensioni e posizione precedenti.

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

Le funzioni IsZoomed e IsIconic determinano se una determinata finestra è ingrandita o ridotta a icona, rispettivamente. La funzione GetWindowPlacement recupera le posizioni in cui la finestra è ridotta a icona, ingrandita o ripristinata e determina anche lo stato di visualizzazione della finestra.

Quando il sistema riceve un comando per massimizzare o ripristinare una finestra ridotta a icona, invia alla finestra un messaggio 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 ingrandire la finestra. WM_GETMINMAXINFO include un puntatore a una struttura MINMAXINFO contenente valori utilizzati dal sistema per definire le dimensioni e la posizione massimizzate. La sostituzione di questi valori sostituisce le impostazioni predefinite.

Dimensioni e posizione della finestra

Le dimensioni e la posizione di una finestra sono espresse come rettangolo delimitato, in coordinate relative allo schermo 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 di una 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 gli argomenti seguenti:

Dimensioni e posizione predefinite

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 dall'applicazione più di recente. 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 di primo livello creata più di recente dell'applicazione. Se si specifica CW_USEDEFAULT durante la creazione di una finestra figlio o popup, il sistema imposta le dimensioni della finestra sulla dimensione minima predefinita della finestra.

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 di monitoraggio è la dimensione più piccola della finestra che è possibile ottenere trascinando il bordo di ridimensionamento della finestra. Analogamente, la dimensione massima del tracciamento è la dimensione massima della finestra che è possibile produrre trascinando il bordo di ridimensionamento.

Le dimensioni minime e massime di rilevamento di una finestra vengono impostate sui valori predefiniti definiti dal sistema quando il sistema crea la finestra. Un'applicazione può individuare le impostazioni predefinite ed eseguirne l'override elaborando il messaggio di WM_GETMINMAXINFO . Per altre informazioni, vedere Dimensioni e messaggi di 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 Descrzione
SC_CLOSE Chiude la finestra. Questo comando invia un messaggio di WM_CLOSE alla finestra. La finestra esegue tutti i passaggi necessari per pulire e distruggere se stessa.
SC_MAXIMIZE Ingrandisce la finestra.
SC_MINIMIZE Riduce al minimo la finestra.
SC_MOVE Sposta la finestra.
SC_RESTORE Ripristina le dimensioni e la posizione precedenti di una finestra minimizzata o massimizzata.
SC_SIZE Avvia un comando di dimensione. 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 di una finestra quando è ridotta a icona, la posizione ingrandita, le dimensioni e la posizione quando è ripristinata, e lo stato di visualizzazione. Le funzioni MoveWindow e SetWindowPos sono simili; entrambe impostano 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, incluse le dimensioni, la posizione, la posizione nell'ordine z e lo stato di visualizzazione.

Un'applicazione può recuperare le coordinate del rettangolo di delimitazione di una finestra usando la funzione GetWindowRect . GetWindowRect riempie una struttura RECT con le coordinate degli angoli superiore sinistro e inferiore destro della finestra. Le coordinate sono relative all'angolo superiore sinistro dello schermo, anche per una sottofinestra. La funzione ScreenToClient o MapWindowPoints esegue il mapping delle coordinate dello schermo del rettangolo di delimitazione di una finestra figlio alle 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 degli angoli 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 di un'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 organizza le finestre a cascata sul desktop o dispone a cascata le finestre figlio della finestra padre specificata. La funzione TileWindows riquadri le finestre sul desktop o riquadri le finestre figlio della finestra padre specificata.

Dimensioni e posizionamento dei messaggi

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 ingrandita predefinite per la finestra, nonché le dimensioni di rilevamento minime e massime predefinite. Un'applicazione può eseguire l'override delle impostazioni predefinite elaborando WM_GETMINMAXINFO e impostando i membri appropriati di MINMAXINFO. Per ricevere WM_GETMINMAXINFO, una finestra deve avere lo stile WS_THICKFRAME o WS_CAPTION. 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 lo stato di visualizzazione 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 di visualizzazione. Impostando i membri di WINDOWPOS, un'applicazione può influire sulle nuove dimensioni, la posizione e l'aspetto della finestra.

Dopo aver modificato le dimensioni, la posizione, la posizione nell'ordine z o lo stato di visualizzazione, il sistema invia il messaggio WM_WINDOWPOSCHANGED alla finestra. Questo messaggio include un puntatore a WINDOWPOS che indica alla finestra le nuove dimensioni, la posizione, la posizione nell'ordine z e lo stato di visualizzazione. 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 WM_SIZE e WM_MOVE messaggi alla finestra.

Il sistema invia il messaggio WM_NCCALCSIZE a una finestra quando la finestra viene creata o ridimensionata. 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 in genere passa questo messaggio alla routine della 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 è ridimensionata. Per altre informazioni, vedere Pittura 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 arrotola, scorre o sfuma la finestra, a seconda dei flag specificati quando si chiama AnimateWindow.

Per impostazione predefinita, il sistema usa l'animazione a rotazione. Con questo effetto, la finestra appare che si arrotola per aprirsi (mostrando la finestra) o che si arrotola per chiudersi (nascondendo la finestra). È possibile utilizzare il parametro dwFlags per specificare se la finestra si rotola orizzontalmente, verticalmente o diagonalmente.

Quando si specifica il flag AW_SLIDE, il sistema usa l'animazione di scorrimento. Con questo effetto, la finestra appare scorrendo in vista (mostrando la finestra) o scorre fuori vista (nascondendo la finestra). È possibile utilizzare il parametro dwFlags per specificare se la finestra scorre orizzontalmente, verticalmente o diagonalmente.

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

È anche possibile utilizzare il flag AW_CENTER per far comparire una finestra che si comprime verso l'interno o si espande verso l'esterno.

Layout e mirroring delle finestre

Il layout della finestra definisce come il testo e gli oggetti Windows Graphics Device Interface (GDI) sono disposti in una finestra o in un contesto di dispositivo (DC). Alcune lingue, ad esempio inglese, francese e tedesco, richiedono un layout da sinistra a destra (LTR). Altre lingue, ad esempio l'arabo e l'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 cascata 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 metadati e controller di dominio della stampante, deve essere gestito separatamente. Le specifiche per queste sono indicate più avanti in questo argomento.

Le funzioni della finestra consentono di specificare o modificare il layout della finestra nelle versioni arabe ed ebrei di Windows. Si noti che la modifica di un layout da destra a sinistra (RTL, noto anche come mirroring) non è supportata per le finestre con lo stile CS_OWNDC o per un DC 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, chiama CreateWindowEx con lo stile WS_EX_LAYOUTRTL. Inoltre, per impostazione predefinita, 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 dalle 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 è oltre 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 il mirroring della 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, 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 rispecchiati. Ad esempio, quelli con testo, un logo aziendale o un orologio analogico non devono essere specchiati. Per disabilitare il mirroring delle bitmap, chiamare SetLayout con il bit LAYOUT_BITMAPORIENTATIONPRESERVED impostato in dwLayout. Per disabilitare il mirroring in un contesto dispositivo, 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, chiama GetLayout. Dopo un ritorno corretto, GetLayout restituisce un DWORD che indica le impostazioni di layout determinati dai bit di impostazione LAYOUT_RTL e LAYOUT_BITMAPORIENTATIONPRESERVED.

Dopo aver creato una finestra, modificare il layout usando la funzione SetWindowLong . Ad esempio, questo è 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 deriva 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, dovresti pensare in termini di "vicino" e "lontano" invece di "sinistra" e "destra". In caso contrario, può causare 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 specchiata 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 (LTR) 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 il 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 e finestre di messaggio in modalità mirroring

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 creare il layout di una finestra di dialogo da destra a sinistra, usare lo stile esteso WS_EX_LAYOUTRTL nella struttura del modello di finestra di dialogo DLGTEMPLATEEX. La finestra delle proprietà è un caso speciale di finestra di dialogo. Ogni scheda viene considerata come una finestra di dialogo separata, quindi è necessario includere lo stile WS_EX_LAYOUTRTL in ogni scheda di cui si desidera eseguire il mirroring.

Contesti di dispositivo di mirroring non associati a una finestra

I controller di dominio non associati a una finestra, ad esempio i controller di dominio metafile o stampante, non ereditano il layout, quindi è 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 contesto dispositivo associato solo durante l'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 di 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 venga modificata in MM_ANISOTROPIC.

Distruzione delle finestre

In generale, un'applicazione deve distruggere 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 tutti 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 averle create. 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 elimina definitivamente la finestra principale dell'applicazione (prima di terminare).

Prima di eliminare definitivamente 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 definitiva di una finestra non influisce sulla classe della finestra da cui viene creata la finestra. È comunque possibile creare nuove finestre usando tale classe e le finestre esistenti di tale classe continuano a funzionare. Distruggendo una finestra vengono distrutte anche le sue finestre discendenti. La funzione DestroyWindow invia prima un messaggio WM_DESTROY alla finestra, quindi alle finestre figlio e alle finestre discendenti. In questo modo, tutte le finestre discendenti della finestra che viene distrutta vengono anch'esse distrutte.

Una finestra con un menu finestra riceve un messaggio 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 che viene distrutta è la finestra attiva, sia lo stato attivo sia lo stato di messa a fuoco vengono trasferiti ad 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 il focus della tastiera.

 

 

  • Last updated on