Partager via

Gérer une résolution élevée et redimensionner la résolution dans votre solution Office

De nombreuses configurations d’écran et d’ordinateur prennent désormais en charge une résolution élevée PPP (points par pouce) et peuvent mettre en contact plusieurs moniteurs de différentes tailles et densités exprimées en pixels. Ceci nécessite que les applications s’ajustent quand l’utilisateur déplace l’application sur un moniteur avec une résolution différente ou modifie le niveau de zoom. Les applications qui ne prennent pas en charge la mise à l’échelle PPP peuvent avoir un bon rendu sur moniteurs à faible PPP mais auront l’air étirées et floues sur un écran haute résolution.

Les applications Office 2016, telles que Word et Excel, ont été mises à jour pour répondre aux modifications d’échelle. Toutefois, votre solution Office doit également répondre aux modifications pour dessiner correctement lorsque le PPP change. Cet article décrit comment Office prend en charge les PPP dynamiques et quelles opérations vous pouvez effectuer pour assurer la meilleure expérience d’affichage pour votre solution extensibilité Office pour gérer le redimensionnement PPP.

Symptômes de redimensionnement PPP dans votre solution

Windows applique le redimensionnement PPP lorsqu’une application est déplacée d’un type d’affichage à un autre avec une résolution différente. Cela se produit lorsque vous faites glisser une application vers un autre écran ou utilisez l’ancrage de votre ordinateur portable. Si votre solution Office est affectée négativement par le redimensionnement PPP, vous pouvez constater un ou plusieurs des symptômes suivants :

  • Les fenêtres apparaissent au mauvais emplacement ou ont une taille incorrecte.
  • Les éléments tels que les boutons et étiquettes apparaissent dans un emplacement incorrect dans la fenêtre de votre solution.
  • Les polices et images sont trop petites, trop volumineuses ou à un emplacement incorrect.

Les types suivants de solutions Office peuvent être affectés par la mise à l’échelle PPP :

  • Compléments VSTO
  • Volets des tâches personnalisés
  • Compléments COM
  • Contrôles ActiveX
  • Extensions de ruban
  • Serveurs OLE
  • Compléments Office web

Modes de présence PPP Windows

Dans cet article, nous allons faire référence aux modes de sensibilisation PPP que Windows prend en charge. Chaque mode de présence PPP prend en charge différentes fonctionnalités, comme décrit dans le tableau suivant. Il s’agit d’une description simplifiée des modes afin d’expliquer comment les solutions Office les prennent en charge. Pour plus d’informations sur les modes de présence PPP, voir Développement d’applications bureau haute résolution sur Windows.

Mode Description Lorsque la résolution change
Système PPP ignoré L’application s’affiche toujours comme si elle est sur une résolution de valeur 96. L’application est étirée bitmap à la taille attendue sur l’affichage principal et secondaire.
Système PPP pris en compte L’application détecte la résolution du moniteur principal connecté à Windows, mais ne peut pas répondre aux modifications PPP. Pour plus d’informations, consultez la section Configurer Windows pour corriger les applications floues dans cet article. L’application est étirée bitmap lorsqu’elle est déplacée vers un nouvel affichage avec une résolution différente.
Par moniteur PPP pris en compte L’application est capable de s’afficher correctement d’elle-même lorsque le PPP change. Windows envoie des notifications PPP aux fenêtres de niveau supérieur dans l’application, de sorte qu’elle peut ajuster son affichage en cas de modification de la résolution.
Par moniteur v2 L’application est capable de s’afficher correctement d’elle-même lorsque le PPP change. Windows envoie des notifications PPP aux fenêtres de niveau supérieur et aux fenêtres enfants dans l’application, de sorte qu’elle peut ajuster son affichage en cas de modification de la résolution.

Comment Office prend en charge la mise à l’échelle PPP

Le facteur le plus significatif dans la détermination de comment votre solution Office peut gérer la mise à l’échelle PPP est si votre solution est une fenêtre de niveau supérieur ou une fenêtre enfant. L’image suivante montre quelques exemples de solutions Office opérationnelles en tant que fenêtres de niveau supérieur ou enfants, et quel mode de présence PPP elles utilisent sur la mise à jour Windows avril 2018 (1803) et versions ultérieures.

Excel hébergeant un contrôle ActiveX et un volet Office personnalisé en tant que fenêtres enfants. Un complément VSTO/COM distinct s’exécute comme une fenêtre de niveau supérieur. Office est une fenêtre de niveau supérieur.

Dans cette image :

  • La fenêtre de niveau supérieur COM/VSTO est Par moniteur PPP pris en compte.
  • La fenêtre enfant de contrôle ActiveX est Système PPP pris en compte.
  • La fenêtre de niveau supérieur Office est Par moniteur PPP pris en compte.
  • La fenêtre enfant de volet de tâches personnalisé est Système PPP pris en compte.

La gestion de contexte de thread PPP

Lorsque l’application Office hôte démarre, son thread principal est exécuté en contexte Par moniteur PPP pris en compte. Lorsque votre code de solution crée des threads ou reçoit des appels à partir d’Office, vous devez gérer le contexte PPP du thread.

Création de nouveaux threads avec le contexte PPP correct

Si votre solution crée des threads supplémentaires, Office obligent les threads à utiliser un contexte Par moniteur PPP pris en compte. Si votre code attend un contexte différent, vous devez utiliser la fonction SetThreadDpiAwarenessContext pour définir la présence de thread PPP prévue.

Créer un bloc de contexte pour les appels thread entrants

Diagramme montrant le bloc de contexte dans l’application Office passant le thread à un contexte Système pris en compte sur les appels à votre fenêtre de niveau supérieur.

Votre solution interagit avec son application Office hôte, donc vous aurez des appels entrants pour votre solution à partir d’Office, tels que des rappels d’événement. Lorsque Office appelle votre solution, celui-ci comporte un bloc de contexte qui force le contexte de thread en contexte Système PPP pris en compte. Vous devez modifier le contexte du thread pour qu’il soit conforme à la présence de résolution de la fenêtre. Vous pouvez implémenter un bloc de contexte similaire pour basculer le contexte du thread sur les appels entrants. Utilisez la fonction SetThreadDpiAwarenessContext pour modifier le contexte pour correspondre au contexte de votre fenêtre.

Remarque

Votre bloc de contexte doit restaurer le contexte du thread PPP d’origine avant d’appeler d’autres composants en dehors de votre code de solution.

Gérer le bloc de contexte code

L’exemple de code suivant montre comment créer votre propre bloc de contexte.

public struct DPI_AWARENESS_CONTEXT
        {
            private IntPtr value;

            private DPI_AWARENESS_CONTEXT(IntPtr value)
            {
                this.value = value;
            }

            public static implicit operator DPI_AWARENESS_CONTEXT(IntPtr value)
            {
                return new DPI_AWARENESS_CONTEXT(value);
            }

            public static implicit operator IntPtr(DPI_AWARENESS_CONTEXT context)
            {
                return context.value;
            }

            public static bool operator ==(IntPtr context1, DPI_AWARENESS_CONTEXT context2)
            {
                return AreDpiAwarenessContextsEqual(context1, context2);
            }

            public static bool operator !=(IntPtr context1, DPI_AWARENESS_CONTEXT context2)
            {
                return !AreDpiAwarenessContextsEqual(context1, context2);
            }

            public override bool Equals(object obj)
            {
                return base.Equals(obj);
            }

            public override int GetHashCode()
            {
                return base.GetHashCode();
            }
        }

        private static DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_HANDLE = IntPtr.Zero;

        public static readonly DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_INVALID = IntPtr.Zero;
        public static readonly DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_UNAWARE = new IntPtr(-1);
        public static readonly DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = new IntPtr(-2);
        public static readonly DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = new IntPtr(-3);
        public static readonly DPI_AWARENESS_CONTEXT DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);

        public static DPI_AWARENESS_CONTEXT[] DpiAwarenessContexts =
        {
            DPI_AWARENESS_CONTEXT_UNAWARE,
            DPI_AWARENESS_CONTEXT_SYSTEM_AWARE,
            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE,
            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
        };

class DPIContextBlock : IDisposable
    {
        private DPI_AWARENESS_CONTEXT resetContext;
        private bool disposed = false;

        public DPIContextBlock(DPI_AWARENESS_CONTEXT contextSwitchTo)
        {
            resetContext = SetThreadDpiAwarenessContext(contextSwitchTo);
         }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    SetThreadDpiAwarenessContext(resetContext);
                }
            }
            disposed = true;
        }
    }

Bloc de contexte code natif

#include <winuser.h>
/* DpiAwarenessContextBlock can be used to simplify setting and resetting the DPI_AWARENESS_CONTEXT of
the current thread.  When the object is constructed, the DPI_AWARENESS_CONTEXT is set, and when the object is
destructed, the DPI awareness context is reverted to the previous awareness context at construct time.

This object allows us to write code such as:

// Thread state is currently DPI_AWARENESS_SYSTEM_AWARE
if (condition)
{
DpiAwarenessContextBlock perMonitorAware(DPI_AWARENESS_PER_MONITOR_AWARE);
... // Create a top-level hwnd with the current thread state, DPI_AWARENESS_PER_MONITOR_AWARE
}
// Thread state automatically returns to DPI_AWARENESS_SYSTEM_AWARE

*/
class DpiAwarenessContextBlock
{
public:
      DpiAwarenessContextBlock(DPI_AWARENESS_CONTEXT dpiContext) noexcept;
      ~DpiAwarenessContextBlock();

      // Copy and move are not to be used with these context objects
      DpiAwarenessContextBlock(const DpiAwarenessContextBlock&) = delete;
      DpiAwarenessContextBlock(DpiAwarenessContextBlock&&) = delete;

private:
      DPI_AWARENESS_CONTEXT m_contextReversalType;
      bool m_doContextSwitch;
};

inline DpiAwarenessContextBlock::DpiAwarenessContextBlock(DPI_AWARENESS_CONTEXT dpiContext) noexcept
{
      m_contextReversalType = SetThreadDpiAwarenessContext(dpiContext);
}

inline DpiAwarenessContextBlock::~DpiAwarenessContextBlock()
{
      SetThreadDpiAwarenessContext(m_contextReversalType);
}

Gestion de fenêtre de niveau supérieur

Lors du démarrage des applications Office, un appel est effectué à SetThreadDpiAwarenessContext comme DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE. Dans ce contexte, les modifications PPP sont envoyées à HWND de n’importe quelle fenêtre de niveau supérieur dans le processus en cours d’exécution avec moniteur PPP pris en compte. Les fenêtres de niveau supérieur sont les fenêtres d’application Office, et toute autre fenêtre de niveau supérieur créée par votre solution. Lorsqu’une application Office est déplacée vers un nouvel affichage, elle reçoit une notification afin qu’elle puisse se mettre à l’échelle dynamiquement et s’afficher correctement dans la résolution du nouvel affichage. Votre solution Office pouvez créer des fenêtres de niveau supérieur qui se trouvent dans n’importe quel mode de présence PPP. Vos fenêtres de niveau supérieur peuvent également répondre aux modifications PPP en écoutant les messages Windows pour les modifications.

Si vous créez des fenêtres enfants apparentées à votre fenêtre de niveau supérieur, vous pouvez également les définir sur n’importe quel mode de présence PPP. Toutefois, si vous utilisez le mode Par moniteur PPP pris en compte, vos fenêtres enfant ne recevront pas les notifications de modification PPP. Pour plus d’informations sur les modes de présence PPP Windows, voir Développement d’applications bureau haute résolution sur Windows.

Gestion de fenêtre enfant

Lorsque vous travaillez avec des contrôles ActiveX et volets de tâches personnalisés, Office crée la fenêtre enfant pour votre solution. Vous pouvez créer des fenêtres enfants supplémentaires, mais vous devez tenir compte de la présence PPP de la fenêtre parent. Office est exécuté en mode de présence Per moniteur PPP, ce qui signifie qu’aucune fenêtre enfant dans votre solution ne recevra pas de notifications de modification PPP. Uniquement le mode Par moniteur v2 prend en charge l’envoi de modifications PPP aux fenêtres enfant (Office ne prend pas en charge Par moniteur v2). Toutefois, pour les contrôles ActiveX, il existe une solution de contournement. Pour plus d’informations, voir la section Contrôles ActiveX plus loin dans cette rubrique.

Remarque

Si votre fenêtre enfant crée une fenêtre de niveau supérieur, vous pouvez utiliser n’importe quel mode de présence PPP pour la nouvelle fenêtre de niveau supérieur. Pour plus d’informations sur la gestion des fenêtres de niveau supérieur, voir la section Gestion de la fenêtre de niveau supérieur de cet article.

Vous verrez deux différents modes PPP appliqués à la fenêtre enfant, selon la version d’Office Windows 10 en cours d’exécution.

Comportement Office PPP sur Windows Fall Creators Update (1709)

Étant donné que les applications Office utilisent le mode de présence par moniteur, les fenêtres enfants de votre solution seront également créées en mode de présence Per moniteur PPP. Cela signifie que Windows attend de votre solution qu’elle se mette à jour lorsqu’elle s’affiche dans un nouveau PPP. Étant donné que la fenêtre ne peut pas recevoir de notifications de modification PPP, l’interface utilisateur de votre solution peut être incorrecte.

Diagramme montrant les fenêtres enfants en cours d’exécution dans un contexte Par moniteur PPP pris en compte sur Windows Fall Creators Update (1709).

Comportement Office PPP sur Mise à jour Windows avril 2018 (1803)

Avec la mise à jour Windows avril 2018 (1803) et versions ultérieures, le comportement d’hébergement Office PPP utilise la mise à l’échelle PPP en mode mixte pour certains scénarios. Cela permet aux fenêtres de système PPP pris en compte d’être liées aux fenêtres Office configurées sur Par moniteur PPP pris en compte. Cela permet de garantir une meilleure compatibilité lorsque la résolution change lorsque les fenêtres sont étirées bitmap. Les fenêtres peuvent toujours être floues en raison de l’étirement bitmap.

Diagramme montrant les fenêtres enfants en cours d’exécution dans un contexte Par système PPP pris en compte sur Windows mise à jour avril 2018 (1803).

Lorsque vous créez nouveau fenêtre enfant, assurez-vous qu’elles correspondent à la résolution de présence de leur fenêtre parent. Vous pouvez utiliser la fonction GetWindowDpiAwarenessContext pour obtenir la reconnaissance ppp de la fenêtre parente. Pour plus d’informations sur la cohérence de présence PPP, voir la section « Réinitialisation forcée de présence à l’échelle de processus PPP » dans Développement d’applications bureau pour haute résolution sur Windows.

Remarque

Vous ne pouvez pas dépendre de la présence de processus PPP car cela peut renvoyer PROCESS_SYSTEM_DPI_AWARE même lorsque le contexte de présence du thread principal PPP de l’application est DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE. Utilisez la fonction GetThreadDpiAwarenessContext pour obtenir le contexte de présence du thread PPP.

Paramètres de compatibilité Office et Windows PPP

Lorsque les utilisateurs rencontrent des compléments ou des solutions qui ne sont pas affichés correctement, certains paramètres de compatibilité peuvent vous aider à corriger le problème.

Configurer Office pour optimiser la compatibilité

Office a défini un paramètre pour optimiser la compatibilité lors de la transition vers différentes échelles PPP sur différents écrans. Le mode de compatibilité désactive la mise à l’échelle PPP afin que tout le contenu dans Office soit étiré bitmap lors du déplacement vers un affichage utilisant une échelle PPP différente.

Le mode de compatibilité force Office à s’exécuter en mode système PPP pris en compte. Cela amène les fenêtres d’application à un étirement bitmap et peut avoir un aspect flou comme effet secondaire. Votre solution Office ne peut pas contrôler ce paramètre, car l’utilisateur choisit celui-ci. Utiliser le mode de compatibilité d’affichage permet de résoudre la plupart des problèmes d’apparence. Pour plus d’informations, voir Support Office pour l’affichage haute définition.

Configurez Windows pour résoudre les application floues

Windows 10 (Version 1803) et versions suivantes ont défini un paramètre pour corriger les applications afin qu’elles ne soient pas floues. Il s’agit d’un autre paramètre à essayer si votre solution n’est pas affichée correctement. Votre solution Office ne peut pas contrôler ce paramètre, car l’utilisateur choisit celui-ci. Pour plus d’informations, voir Corriger les applications qui s’affichent floues dans Windows 10.

Comment prendre en charge le redimensionnement PPP dans votre solution

Certaines solutions peuvent recevoir et répondre aux modifications PPP. Certaines ont une solution de contournement si elles ne peuvent pas recevoir des notifications. Le tableau suivant répertorie les détails pour chaque type de solution.

Type de solution Type de fenêtre Peut répondre au redimensionnement PPP Plus de détails
Complément VSTO Niveau supérieur et descendants Oui Voir Conseils complément VSTO.
Enfant apparenté à la fenêtre Office Non Voir Configurer Office pour optimiser la compatibilité.
Volet Office personnalisé Niveau supérieur et descendants Oui Voir Conseils fenêtre de niveau supérieur.
Enfant apparenté à la fenêtre Office Non Voir Configurer Office pour optimiser la compatibilité.
Complément COM Niveau supérieur et descendants Oui Voir Conseils complément COM.
Enfant apparenté à la fenêtre Office Non Voir Configurer Office pour optimiser la compatibilité.
Contrôle ActiveX Niveau supérieur et descendants Oui Voir Conseils contrôle ActiveX.
Enfant apparenté à la fenêtre Office Oui
Complément Web N/A Oui Voir Conseils complément Office web.
Extension du ruban N/A N/A Voir Conseils extension ruban.
Client ou serveur OLE N/A N/A Voir Conseils client/serveur OLE.

Complément VSTO

Si votre complément VSTO crée des fenêtres enfant apparentées à n’importe quelle fenêtre Office, assurez-vous qu’elles correspondent à la résolution de présence de leur fenêtre parent. Vous pouvez utiliser la fonctionGetWindowdpiAwarenessContext pour obtenir la résolution de présence de la fenêtre parent. Vos fenêtres enfants ne recevront pas les notifications de modification PPP. Si votre solution n’est pas affichée correctement, les utilisateurs doivent configurer Office en mode de compatibilité.

Pour n’importe quelle fenêtre de niveau supérieur que votre complément VSTO crée, vous pouvez les définir sur n’importe quel mode de présence PPP. L’exemple de code suivant explique comment configurer la présence de PPP souhaitée et comment répondre aux modifications PPP. Vous devrez également ajuster votre app.config, comme décrit dans l’article Prise en charge de la haute résolution dans Windows Forms.

using System;
using System.Diagnostics;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SharedModule
{
    // DpiAwareWindowsForm
    // For any top level winform you create, derive from the DpiWindowsForm class
    // if you are creating Windows Forms with the Dpi Awareness Context set to 
    // DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE or DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
    //
    // For example, if you Window form class is defined as:
    //    public partial class TopLevelWinForm : Form
    //
    // update to:
    //    public partial class TopLevelWinForm : DpiAwareWindowsForm
    //
    // When showing the form, call SetThreadDpiAwarenessContext() or use a context block to
    // to set the desired Dpi Awareness Context.
    //
    // For example, here is code to show a Windows Form using a context block as Per Monitor Aware v2.
    //
    //    DPIContextBlock context = new DPIContextBlock(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
    //    TopLevelWinForm frm = new TopLevelWinForm();
    //    frm.Show();
    //
    public partial class DpiAwareWindowsForm : Form
    {
        private SizeF m_newDpi = SizeF.Empty;
        private SizeF m_oldDpi = SizeF.Empty;

        public DpiAwareWindowsForm()
        {
            this.HandleCreated += new EventHandler((sender, args) =>
            {
                m_oldDpi = m_newDpi = DPIHelper.GetDpiForWindowSizeF(this.Handle);
            });
        }

        public void OnDpiChangedEvent(RECT newRect)
        {
            this.SuspendLayout();

            // Resize form
            this.Width = newRect.Width;
            this.Height = newRect.Height;

            // Resize controls and set font sizes
            ScaleAllChildControls(this.Controls, m_oldDpi.Width, m_newDpi.Width);
            this.ResumeLayout(true);
        }

        // Additional changes may be needed for controls that set Anchor or Dock properties 
        private void ScaleAllChildControls(Control.ControlCollection controls, float oldDpi, float newDpi)
        {
            float scaleFactorChange = newDpi / oldDpi;

            foreach (Control control in controls)
            {
                control.Top = (int)(control.Top * scaleFactorChange);
                control.Left = (int)(control.Left * scaleFactorChange);
                control.Width = (int)(control.Width * scaleFactorChange);
                control.Height = (int)(control.Height * scaleFactorChange);
                control.Font = ScaleFont(control.Font, oldDpi, newDpi);
            }
        }

        private Font ScaleFont(Font font, float oldDpi, float newDpi)
        {
            float fontSizePx = 0.0f;
            float fontSizePt = 0.0f;

            fontSizePx = font.SizeInPoints / 72 * oldDpi;
            fontSizePt = fontSizePx * (newDpi / oldDpi) * 72 / oldDpi;

            return new Font(font.Name, fontSizePt, font.Style, GraphicsUnit.Point);
        }

        protected override void WndProc(ref Message m)
        {
            switch ((DPIHelper.WinMessages)m.Msg)
            {
                case DPIHelper.WinMessages.WM_DPICHANGED:
                    // Marshal the value in the lParam into a Rect.
                    RECT newDisplayRect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));

                    // Remember current DPI and calculate current from WParam.
                    // Both X and Y are the same on Windows for Dpi.
                    m_oldDpi = m_newDpi;

                    m_newDpi.Width = (float)(m.WParam.ToInt32() >> 16);
                    m_newDpi.Height = (float)(m.WParam.ToInt32() & 0x0000FFFF);

                    // DPI should be the same for both width and height on Windows devices.
                    Debug.Assert(m_newDpi.Height == m_newDpi.Width);

                    if (m_oldDpi.Width != m_newDpi.Width)
                    {
                        OnDpiChangedEvent(newDisplayRect);
                    }
                    base.DefWndProc(ref m);
                    break;
                default:
                    base.WndProc(ref m);
                    break;
            }
        }
    }
}

Volets des tâches personnalisés

Un volet de tâches personnalisé est créé comme fenêtre enfant par Office. Lors de l’exécution sur Windows Fall Creators Update (1709), votre volet Office personnalisé s’exécute en utilisant le même mode de présence PPP qu’Office. Lors de l’exécution sur la mise à jour avril 2018 Windows (1803) et versions ultérieures, votre volet de tâches personnalisé s’exécutera sur le mode de présence système PPP.

Comme les volets de tâches personnalisés sont des fenêtres enfants, ils ne peuvent pas recevoir de notifications PPP. S’ils sont affichés incorrectement, l’utilisateur devra utiliser lemode de compatibilité Office PPP. Si votre volet de tâches personnalisé crée des fenêtres de niveau supérieur, ces fenêtres peuvent s’exécuter dans n’importe quel mode de présence PPP et recevoir des notifications de modification PPP. Pour plus d’informations, voir la section Gestion de la fenêtre de niveau supérieur de cet article.

Compléments COM

Les compléments COM qui créent des fenêtres de niveau supérieur peuvent recevoir des notifications PPP. Vous devez créer un bloc de contexte pour définir le thread à la présence PPP souhaitée pour la fenêtre, puis créer la fenêtre. Il y a beaucoup à gagner à gérer les notifications PPP correctement, veillez donc à lire Développement d’applications bureau à haute résolution sur Windows pour plus d’informations.

Le message WM_DPICHANGED est envoyé lorsque le PPP pour une fenêtre a changé. Dans le code non géré, ce message est géré par la Procédure de fenêtre pour le HWND. Un exemple de code de modification du gestionnaire PPP est accessible dans l’article WM_DPICHANGED.

Les compléments COM qui montrent les fenêtres enfants apparentées à une fenêtre dans Office ne peuvent pas recevoir de notifications PPP. S’ils sont affichés incorrectement, l’utilisateur devra utiliser lemode de compatibilité Office PPP.

Contrôles ActiveX

Comment prendre en charge la mise à l’échelle PPP dans les contrôles ActiveX dépend de si le contrôle dans une fenêtre ou sans fenêtre.

Contrôles ActiveX dans une fenêtre

Les contrôles ActiveX dans une fenêtre reçoivent un message WM_SIZE chaque fois que le contrôle est redimensionné. Lorsque cet événement est déclenché, le code gestionnaire d’événements peut d’appeler la fonction GetDpiForWindow utilisant HWND du contrôle pour obtenir le PPP, calculer les différences de facteur échelle et ajuster en conséquence.

L’exemple suivant permet au contrôle ActiveX basé sur MFC de répondre à l’événement OnSize.

void ChangeWindowFontDPI(HWND hWnd, UINT dpi) 
{ 
LOGFONT fontInfo1 = { 0 }; 
// Calculate the font height based on the DPI. 
fontInfo1.lfHeight = -MulDiv(DESIRED_HEIGHT, dpi, 72); 
fontInfo1.lfQuality = CLEARTYPE_QUALITY; 
wcscpy_s(fontInfo1.lfFaceName, DESIRED_FONT_NAME); 
 
::SendMessage(hWnd, WM_SETFONT, (WPARAM)::CreateFontIndirectW(&fontInfo1), TRUE); 
} 
 
BOOL CALLBACK CMainDialog::EnumChildProc(HWND hWnd, LPARAM lParam) 
{ 
CMainDialog* _this = (CMainDialog*) lParam; 
if (_this != nullptr) 
{ 
// Calculate the scale factor difference between the old and new DPI changes. 
double scale = (((double) _this->m_newDPI) /  
   (((double) _this->m_currentDPI) / 100.0)) / 100; 
 
RECT rect = {}; 
::GetWindowRect(hWnd, &rect); 
 
POINT pt = { rect.left, rect.top }; 
::ScreenToClient(::GetParent(hWnd), &pt); 
 
// Adjust the window based on the scale changes. 
::MoveWindow(hWnd, 
pt.x * scale, 
pt.y * scale, 
(rect.right - rect.left) * scale, 
(rect.bottom - rect.top) * scale, 
TRUE); 
 
ChangeWindowFontDPI(hWnd, _this->m_newDPI); 
return TRUE; 
} 
return FALSE; 
} 
 
void CMainDialog::OnSize(UINT nType, int cx, int cy) 
{ 
CDialog::OnSize(nType, cx, cy); 
 
// Get the new DPI and enumerate the child windows that will use that value. 
m_currentDPI = ::GetDpiForWindow(this->GetSafeHwnd()); 
::EnumChildWindows(this->GetSafeHwnd(), EnumChildProc, (LPARAM)this); 
}

Contrôles ActiveX sans fenêtre

Les contrôles ActiveX ne sont pas garantis d’avoir un HWND. Quand un contrôle ActiveX est inséré sur une zone de document, il placé en mode Création. Dans les applications Office, le conteneur d’hébergement retourne 0 pour l’appel à hDC-GetWindow>() dans l’événement ::OnDraw lorsque le contrôle est en mode Création. Un PPP fiable ne peut pas être récupéré dans ce cas.

Toutefois, lorsque le contrôle est en mode d’exécution, Office renverra HWND où le contrôle doit être affiché. Dans ce cas, le développeur de contrôle peut appeler GetDpiForWindow afin de recevoir les polices, l’échelle, contrôles PPP actuels et ainsi de suite.

Extensibilité du ruban

Les rappels Office pour les contrôles de ruban personnalisés sont également une présence thread PPP de système PPP pris en compte. Si votre solution attend une présence de thread PPP différente, vous devez implémenter un bloc de contexte pour configurer la présence de thread attendue. Pour plus d’informations, voir Créer un bloc de contexte.

Serveurs et clients OLE

Lorsqu’un serveur OLE est hébergé dans un conteneur de client OLE, vous ne pouvez pas fournir d’informations PPP actuelles ni prises en charge. Cela peut provoquer des problèmes, car certaines combinaisons de modes mixtes de fenêtre parent à fenêtre enfant ne sont pas pris en charge par l’architecture actuelle de Windows.

Avant Office 365 version 2109 pour Excel et PowerPoint, et version 2203 pour Word

Si Excel, PowerPoint ou Word détectent qu’il existe plusieurs moniteurs avec différentes échelles PPP, ils ne prennent pas en charge l’activation sur place. Votre serveur OLE s’activera en externe. Si vous rencontrez des problèmes avec les interactions de serveur OLE, l’utilisateur devra utiliser le mode de compatibilité Office PPP.

Après Office 365 version 2109 pour Excel et PowerPoint, et version 2203 pour Word

À compter de la version 2109 pour Excel et PowerPoint, et de la version 2203 pour Word, les trois applications autorisent l’activation sur place en mode Prise en charge ppp par moniteur lorsque certaines conditions sont remplies. Lorsqu’elles sont activées sur place en tant que serveurs OLE, les applications Office case activée la DPI_AWARENESS_CONTEXT fenêtre parente fournie par le conteneur et autorisent l’activation sur place en fonction des modes d’affichage Ppp Office suivants sélectionnés par l’utilisateur :

  • « Optimiser pour une apparence optimale » autorise l’activation sur place si la fenêtre fournie par le conteneur est prise en charge par moniteur ppp (DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ou DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2).
  • « Optimiser pour la compatibilité » autorise l’activation sur place si la fenêtre fournie par le conteneur est Prise en charge du système ppp (DPI_AWARENESS_CONTEXT_SYSTEM_AWARE) et si l’application conteneur et l’application Office ont le même ppp système.

Cette case activée de compatibilité du contexte de reconnaissance ppp signifie que les conteneurs OLE non compatibles ppp ne pourront pas activer sur place l’une ou l’autre des applications. La solution de contournement consiste à remplacer la prise en charge ppp de l’application conteneur par Prise en charge de la résolution système (et à utiliser le paramètre « Optimiser pour la compatibilité » dans l’application Office). Cette opération peut être effectuée via SetProcessDpiAwareness, incorporé ou manifeste externe. Le manifeste externe est particulièrement utile pour les solutions VB Forms existantes, car il ne nécessite pas la recompilation de la solution.

Lorsqu’ils agissent en tant que conteneur OLE, Excel et PowerPoint se reportent sur le serveur pour case activée compatibilité de la prise en charge ppp, et ils n’empêchent pas l’activation sur place.

Compléments Office web

Les compléments Office créés à l’aide de l’API JavaScript Office s’exécutent à l’intérieur d’un contrôle de navigateur. Vous pouvez gérer la mise à l’échelle PPP à l’aide des mêmes techniques utilisées dans n’importe quelle conception d’applications web. Plusieurs ressources en ligne sont disponibles pour vous aider à créer une page web pour les écrans haute résolution.

Vérifier que votre solution prend en charge la mise à l’échelle PPP

Une fois que vous avez mis à jour votre application pour prendre en charge la mise à l’échelle PPP, vous devez valider vos modifications dans un environnement mixte PPP. Vérifiez que votre code d’interface utilisateur répond correctement aux modifications PPP quand les fenêtres de votre solution sont déplacées d’un affichage à un autre ayant des valeurs PPP différentes. Pour plus d’informations sur les techniques de test de redimensionnement PPP, voir Développement d’applications bureau haute résolution sur Windows.

Vous pouvez également trouver ces techniques supplémentaires utiles :

  • Avec un ordinateur portable, vous pouvez configurer le moniteur principal à un moniteur externe, puis détacher l’ordinateur portable. Cela force le moniteur principal à aligner son affichage à celui de l’ordinateur portable.
  • Utiliser l’open source WinSpy ++ outil afin de déboguer. Vous pouvez l’utiliser pour afficher le paramètre de présence PPP de n’importe quelle fenêtre.
  • Vous pouvez utiliser le bureau à distance pour tester plusieurs moniteurs sur un ordinateur distant en sélectionnant Utiliser tous mes moniteurs pour la session distante sous l’onglet Affichage, comme illustré dans la capture d’écran suivante.

L’application de Connexion Bureau à distance montrant l’onglet Affichage, et sélectionnant Utiliser mes moniteurs pour la session distante.

Voir aussi

Articles

Exemples de code