enumerazione PROCESS_DPI_AWARENESS (shellscalingapi.h)
Identifica i valori di consapevolezza dei punti per pollice (dpi). La consapevolezza DPI indica la quantità di operazioni di ridimensionamento eseguite da un'applicazione per DPI rispetto alla quantità di operazioni eseguite dal sistema.
Gli utenti hanno la possibilità di impostare il fattore di scala DPI sui propri schermi indipendentemente l'uno dall'altro. Alcune applicazioni legacy non sono in grado di regolare il ridimensionamento per più impostazioni DPI. Per consentire agli utenti di usare queste applicazioni senza la visualizzazione di contenuti troppo grandi o piccoli su schermi, Windows può applicare la virtualizzazione DPI a un'applicazione, causando la scalabilità automatica da parte del sistema in modo che corrisponda al DPI dello schermo corrente. Il valore PROCESS_DPI_AWARENESS indica il livello di ridimensionamento dell'applicazione gestito autonomamente e la quantità fornita da Windows. Tenere presente che le applicazioni ridimensionate dal sistema potrebbero apparire sfocate e leggeranno i dati virtualizzati sul monitoraggio per mantenere la compatibilità.
Sintassi
typedef enum PROCESS_DPI_AWARENESS {
PROCESS_DPI_UNAWARE = 0,
PROCESS_SYSTEM_DPI_AWARE = 1,
PROCESS_PER_MONITOR_DPI_AWARE = 2
} ;
Costanti
PROCESS_DPI_UNAWAREValore: 0 DPI non a conoscenza. Questa app non ridimensiona le modifiche dpi e si presuppone che abbia sempre un fattore di scala del 100% (96 DPI). Verrà ridimensionata automaticamente dal sistema in qualsiasi altra impostazione DPI. |
PROCESS_SYSTEM_DPI_AWAREValore: 1 Riconoscimento dpi del sistema. Questa app non ridimensiona le modifiche dpi. Eseguirà una query per il valore DPI una sola volta e userà tale valore per la durata dell'app. Se il valore DPI cambia, l'app non verrà modificata in base al nuovo valore DPI. Verrà automaticamente ridimensionato verso l'alto o verso il basso dal sistema quando il valore DPI cambia dal valore di sistema. |
PROCESS_PER_MONITOR_DPI_AWAREValore: 2 Per monitor DPI aware.Per monitor DPI aware. Questa app verifica la presenza del valore DPI quando viene creata e regola il fattore di scala ogni volta che cambia il valore DPI. Queste applicazioni non vengono ridimensionate automaticamente dal sistema. |
Commenti
Le versioni precedenti di Windows richiedevano di impostare il riconoscimento DPI per l'intera applicazione. Ora la consapevolezza dpi è associata a singoli thread, processi o finestre. Ciò significa che la consapevolezza DPI può cambiare mentre l'app è in esecuzione e che più finestre possono avere i propri valori di riconoscimento DPI indipendenti. Per altre informazioni sul funzionamento corrente della consapevolezza dpi, vedere DPI_AWARENESS. Le raccomandazioni seguenti sull'impostazione del riconoscimento DPI nel manifesto dell'applicazione sono ancora supportate, ma la raccomandazione corrente consiste nell'usare il DPI_AWARENESS_CONTEXT.
Se l'app è PROCESS_DPI_UNAWARE, non è necessario impostare alcun valore nel manifesto dell'applicazione. PROCESS_DPI_UNAWARE è il valore predefinito per le app, a meno che non venga specificato un altro valore.
Nelle versioni precedenti di Windows non è stata impostata alcuna impostazione per PROCESS_PER_MONITOR_DPI_AWARE. Le app non sapevano dpi o con riconoscimento DPI. Le applicazioni legacy classificate come dpi sensibili prima di Windows 8.1 vengono considerate come un'impostazione di PROCESS_DPI_AWARENESS di PROCESS_SYSTEM_DPI_AWARE nelle versioni correnti di Windows.
Un'applicazione PROCESS_DPI_UNAWARE userà sempre un fattore di ridimensionamento del 100% (96 DPI). In questo scenario viene creata una finestra PROCESS_DPI_UNAWARE con dimensioni pari a 500 per 500. Nella visualizzazione A, il rendering verrà eseguito in modo nativo senza ridimensionamento. Nei display B e C, verrà ridimensionata automaticamente dal sistema con un fattore pari rispettivamente a 2 e 3. Ciò è dovuto al fatto che un PROCESS_DPI_UNAWARE presuppone sempre un VALORE DPI pari a 96 e gli account di sistema per tale valore. Se l'app esegue query per le dimensioni della finestra, otterrà sempre un valore pari a 500 per 500 indipendentemente dalla visualizzazione in cui si trova. Se questa app richiedesse il DPI di uno dei tre monitor, riceverà 96.
Si consideri ora un'applicazione PROCESS_SYSTEM_DPI_AWARE. Tenere presente che nel campione il valore DPI di sistema è 200% o 192 DPI. Ciò significa che tutte le finestre create da questa app verranno visualizzate in modo nativo nella visualizzazione B. La finestra si sposta per visualizzare A, verrà automaticamente ridotta di un fattore pari a 2. Questo perché un'app PROCESS_SYSTEM_DPI_AWARE in questo scenario presuppone che il valore DPI sia sempre 192. Esegue una query per il valore DPI all'avvio e quindi non lo modifica mai. Il sistema consente di adattarlo automaticamente quando si passa alla visualizzazione A. Analogamente, se la finestra passa alla visualizzazione C, il sistema aumenta automaticamente di un fattore pari a 1,5. Se l'app esegue query per le dimensioni della finestra, otterrà sempre lo stesso valore, simile a PROCESS_DPI_UNAWARE. Se chiede la DPI di uno dei tre monitor, riceverà il 192.
A differenza degli altri valori di consapevolezza, PROCESS_PER_MONITOR_DPI_AWARE deve adattarsi alla visualizzazione su cui si trova. Ciò significa che viene sempre eseguito il rendering in modo nativo e non viene mai ridimensionato dal sistema. La responsabilità dell'app è modificare il fattore di scala quando riceve il messaggio di WM_DPICHANGED . Parte di questo messaggio include una correzione suggerita per la finestra. Questo suggerimento è la finestra corrente ridimensionata dal valore DPI precedente al nuovo valore DPI. Ad esempio, una finestra che è 500 per 500 nella visualizzazione A e spostata per visualizzare B riceverà una correzione della finestra suggerita pari a 1000 di 1000. Se la stessa finestra viene spostata per visualizzare C, la finestra suggerita collegata a WM_DPICHANGED sarà 1500 entro 1500. Inoltre, quando questa app esegue una query per le dimensioni della finestra, otterrà sempre il valore nativo effettivo. Analogamente, se richiede il DPI di uno dei tre monitor, riceverà rispettivamente 96, 192 e 288.
A causa della virtualizzazione DPI, se un'applicazione esegue una query con un livello di consapevolezza diverso per le informazioni dipendenti da DPI, il sistema ridimensiona automaticamente i valori in modo che corrispondano al livello di consapevolezza del chiamante. Un esempio è se chiami GetWindowRect e passi una finestra creata da un'altra applicazione. Usando la situazione descritta in precedenza, si supponga che un'app PROCESS_DPI_UNAWARE abbia creato una finestra di 500 per 500 nella visualizzazione C. Se si esegue una query per la correzione della finestra da un'applicazione diversa, le dimensioni del rect variano in base alla consapevolezza dpi dell'app.
| PROCESS_DPI_UNAWARE | Si otterrà un 500 per 500 rect perché il sistema assumerà un DPI pari a 96 e ridimensiona automaticamente il rect effettivo di un fattore pari a 3. |
| PROCESS_SYSTEM_DPI_AWARE | Si otterrà un 1000 per 1000 rect perché il sistema assumerà un DPI pari a 192 e ridimensiona automaticamente il rect effettivo di un fattore pari a 3/2. |
| PROCESS_PER_MONITOR_DPI_AWARE | Si otterrà un 1500 per 1500 rect perché il sistema userà il dpi effettivo dello schermo e non esegue alcuna scalabilità dietro le quinte. |
Esempio
Questo frammento di codice illustra come impostare un valore di PROCESS_SYSTEM_DPI_AWARE nel manifesto dell'applicazione.
<dpiAware>true</dpiAware>
Questo frammento di codice illustra come impostare un valore di PROCESS_PER_MONITOR_DPI_AWARE nel manifesto dell'applicazione.
<dpiAware>true/PM</dpiAware>
Requisiti
| Requisito | Valore |
|---|---|
| Client minimo supportato | Windows 8.1 [solo app desktop] |
| Server minimo supportato | Windows Server 2012 R2 [solo app desktop] |
| Intestazione | shellscalingapi.h |