Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Een toenemend aantal apparaten wordt geleverd met 'hoge resolutie'-schermen. Deze schermen hebben doorgaans meer dan 200 pixels per inch (ppi). Als u met een toepassing op deze computers werkt, moet inhoud omhoog worden geschaald om te voldoen aan de behoeften van het weergeven van de inhoud op een normale kijkafstand voor het apparaat. Vanaf 2014 zijn hogedichtheidsschermen primair gericht op mobiele computingapparaten (tablets, clamshell-laptops en telefoons).
Windows 8.1 en hoger bevat verschillende functies waarmee deze machines kunnen werken met beeldschermen en omgevingen waarin de machine tegelijkertijd is gekoppeld aan zowel high-density- als standaarddichtheidsweergaven.
Met Windows kunt u inhoud naar het apparaat schalen met behulp van de instelling Tekst en andere items groter of kleiner maken (beschikbaar sinds Windows XP).
Windows 8.1 en hoger schalen automatisch inhoud voor de meeste toepassingen om consistent te zijn wanneer ze worden verplaatst tussen weergaven van verschillende pixeldichtheid. Wanneer de primaire weergave een hoge dichtheid heeft (200% schalen) en de secundaire weergave standaarddichtheid is (100%), wordt de inhoud van het toepassingsvenster automatisch omlaag geschaald op de secundaire weergave (1 pixel weergegeven voor elke 4 pixels die door de toepassing wordt weergegeven).
Windows past standaard de juiste schaalinstellingen toe voor de pixeldichtheid en weergaveafstand van het scherm (Windows 7 en hoger, OEM-configureerbaar).
Windows kan inhoud automatisch schalen tot 250% op nieuwe apparaten die hoger zijn dan 280 ppi (vanaf Windows 8.1 S14).
Windows heeft een manier om te werken met het omhoog schalen van de gebruikersinterface om te profiteren van verhoogde pixelaantallen. Een toepassing meldt zich aan voor dit systeem door zichzelf 'systeem-DPI-bewust' te verklaren. Toepassingen die dit niet doen, worden opgeschaald door het systeem. Dit kan resulteren in een 'fuzzy' gebruikerservaring waarbij de hele toepassing uniform pixel-stretched is. Voorbeeld:
Visual Studio kiest ervoor om DPI-schaalbewust te zijn en is daarom niet 'gevirtualiseerd'.
Windows (en Visual Studio) maken gebruik van verschillende UI-technologieën, die verschillende manieren hebben om te gaan met schaalfactoren die door het systeem zijn ingesteld. Voorbeeld:
WPF meet besturingselementen op een apparaatonafhankelijke manier (eenheden, niet pixels). WPF UI wordt automatisch omhoog geschaald voor de huidige DPI.
Alle tekstgrootten, ongeacht het UI-framework, worden uitgedrukt in punten en worden daarom door het systeem als DPI-onafhankelijk behandeld. Tekst in Win32, WinForms en WPF wordt al correct geschaald wanneer deze op het beeldschermapparaat wordt getekend.
Win32/WinForms-dialoogvensters en -vensters hebben middelen voor het inschakelen van de indeling die het formaat van tekst wijzigt (bijvoorbeeld via raster-, stroom- en tabelindelingspanelen). Hierdoor kunnen hardgecodeerde pixellocaties worden vermeden die niet geschaald worden als de lettergroottes worden vergroot.
Pictogrammen die worden geleverd door het systeem of de resources op basis van metrische systeemgegevens (bijvoorbeeld SM_CXICON en SM_CXSMICON) zijn al omhoog geschaald.
Oudere gebruikersinterface van Win32 (GDI, GDI+) en WinForms
Hoewel WPF al hoge DPI-bewust is, is veel van onze Win32/GDI-code oorspronkelijk niet geschreven met DPI-bewustzijn in gedachten. Windows biedt API's voor DPI-schaalaanpassing. Oplossingen voor Win32-problemen moeten deze consistent in het product gebruiken. Visual Studio heeft een helperklasse-bibliotheek geleverd om te voorkomen dat functionaliteit wordt gedupliceerd. Dit garandeert de consistentie in het product.
Afbeeldingen met hoge resolutie
Deze sectie is voornamelijk bedoeld voor ontwikkelaars die Visual Studio 2013 uitbreiden. Gebruik voor Visual Studio 2015 de beeldservice die is geïntegreerd in Visual Studio. Het is ook mogelijk dat u veel versies van Visual Studio moet ondersteunen/targeten en dat het gebruik van de installatiekopieënservice in 2015 geen optie is omdat deze niet bestaat in eerdere versies. Deze sectie is ook geschikt voor u.
Afbeeldingen omhoog schalen die te klein zijn
Afbeeldingen die te klein zijn, kunnen worden opgeschaald en weergegeven op GDI en WPF met behulp van een aantal veelgebruikte methoden. Beheerde DPI-helperklassen zijn beschikbaar voor interne en externe Visual Studio-integrators om schaalbare pictogrammen, bitmaps, afbeeldingsreeksen en afbeeldingslijsten aan te passen. Systeemeigen C/C++-helpers op basis van Win32 zijn beschikbaar voor het schalen van HICON, HBITMAP, HIMAGELIST en VsUI::GdiplusImage. Voor het schalen van een bitmap is doorgaans slechts één regelwijziging vereist nadat een verwijzing naar de helperbibliotheek is opgegeven. Voorbeeld:
Het schalen van een afbeeldingslijst hangt af van of de afbeeldingslijst compleet is bij het laden, of tijdens de uitvoering wordt toegevoegd. Als dit tijdens de laadtijd is voltooid, roept LogicalToDeviceUnits() u de afbeeldingslijst aan zoals u een bitmap zou doen. Wanneer de code een afzonderlijke bitmap moet laden voordat u de afbeeldingslijst opstelt, moet u de grootte van de afbeeldingslijst schalen:
imagelist.ImageSize = DpiHelper.LogicalToDeviceUnits(imagelist.ImageSize);
In systeemeigen code kunnen de dimensies als volgt worden geschaald bij het maken van de afbeeldingslijst:
ImageList_Create(VsUI::DpiHelper::LogicalToDeviceUnitsX(16),VsUI::DpiHelper::LogicalToDeviceUnitsY(16), ILC_COLOR32|ILC_MASK, nCount, 1);
Functies in de bibliotheek maken het mogelijk om het aanpassen van het algoritme te specificeren. Bij het schalen van afbeeldingen die in de lijst met afbeeldingen moeten worden geplaatst, moet u de achtergrondkleur opgeven die wordt gebruikt voor transparantie of het schalen van NearestNeighbor gebruiken (wat vervormingen veroorzaakt bij 125% en 150%).
Raadpleeg de DpiHelper documentatie op MSDN.
In de volgende tabel ziet u voorbeelden van hoe afbeeldingen moeten worden geschaald op overeenkomstige DPI-schaalfactoren. De afbeeldingen die in oranje worden beschreven, geven onze best practice aan vanaf Visual Studio 2013 (100%-200% DPI-schaal):
Problemen met de indeling
Veelvoorkomende indelingsproblemen kunnen voornamelijk worden vermeden door punten in de gebruikersinterface geschaald en relatief ten opzichte van elkaar te houden in plaats van absolute locaties te gebruiken (met name in pixeleenheden). Voorbeeld:
Indelings-/tekstposities moeten worden aangepast om rekening te houden met opgeschaalde afbeeldingen.
Kolommen in het raster moeten worden aangepast voor de opgeschaalde tekst.
In code vastgelegde grootten of ruimte tussen elementen moeten ook omhoog worden geschaald. Grootten die alleen zijn gebaseerd op tekstdimensies, zijn doorgaans prima, omdat lettertypen automatisch omhoog worden geschaald.
Helperfuncties zijn beschikbaar in de DpiHelper klasse om schalen op de X- en Y-as toe te staan:
De functies LogicalToDeviceUnitsX/LogicalToDeviceUnitsY (deze functies staan schaling langs de X/Y-as toe)
int space = DpiHelper.LogicalToDeviceUnitsX (10);
int height = VsUI::DpiHelper::LogicalToDeviceUnitsY(5);
Er zijn LogicalToDeviceUnits-overloads die het schalen van objecten zoals Rect, Point en Size mogelijk maken.
De DPIHelper-bibliotheek/-klasse gebruiken om afbeeldingen en indeling te schalen
De Visual Studio DPI-helperbibliotheek is beschikbaar in systeemeigen en beheerde formulieren en kan worden gebruikt buiten de Visual Studio-shell door andere toepassingen.
Als u de bibliotheek wilt gebruiken, gaat u naar de visual Studio VSSDK-uitbreidbaarheidsvoorbeelden en kloont u het High-DPI_Images_Icons voorbeeld.
Neem in bronbestanden VsUIDpiHelper.h op en roep de statische functies van VsUI::DpiHelper klasse aan:
#include "VsUIDpiHelper.h"
int cxScaled = VsUI::DpiHelper::LogicalToDeviceUnitsX(cx);
VsUI::DpiHelper::LogicalToDeviceUnits(&hBitmap);
Opmerking
Gebruik de helperfuncties niet in statische variabelen op module- of klasseniveau. De bibliotheek maakt ook gebruik van static variabelen voor de synchronisatie van threads en je kunt problemen ondervinden met de initialisatievolgorde. Converteer deze statische elementen naar niet-statische lidvariabelen of verpakt deze in een functie (zodat ze worden samengesteld op de eerste toegang).
Voor toegang tot de DPI-helperfuncties vanuit beheerde code die in de Visual Studio-omgeving wordt uitgevoerd:
Het verbruikende project moet verwijzen naar de nieuwste versie van Shell MPF. Voorbeeld:
<Reference Include="Microsoft.VisualStudio.Shell.14.0.dll" />Zorg ervoor dat het project verwijzingen heeft naar System.Windows.Forms, PresentationCore en PresentationUI.
Gebruik in code de naamruimte Microsoft.VisualStudio.PlatformUI en roep statische functies van de dpiHelper-klasse aan. Voor ondersteunde typen (punten, grootten, rechthoeken, enzovoort) zijn er extensiefuncties die nieuwe geschaalde objecten retourneren. Voorbeeld:
using Microsoft.VisualStudio.PlatformUI; double x = DpiHelper.LogicalToDeviceUnitsX(posX); Point ptScaled = ptOriginal.LogicalToDeviceUnits(); DpiHelper.LogicalToDeviceUnits(ref bitmap);
Omgaan met WPF-afbeeldingswazigheid in een zoombare gebruikersinterface
In WPF worden bitmaps automatisch aangepast door WPF voor het huidige DPI-zoomniveau met behulp van een bicubisch algoritme van hoge kwaliteit (standaard), dat goed werkt voor afbeeldingen of grote schermafbeeldingen, maar is ongepast voor menu-itempictogrammen, omdat het waargenomen knipperen introduceert.
Aanbevelingen:
Voor logoafbeeldingen en banners kan de standaardgroottemodus BitmapScalingMode worden gebruikt.
Voor menuonderdelen en icoonafbeeldingen moet het BitmapScalingMode worden gebruikt wanneer er geen andere vervormingsartefacten ontstaan, om wazigheid te elimineren (bij 200% en 300%).
Voor grote zoomniveaus die geen veelvouden van 100% zijn (bijvoorbeeld 250% of 350%), het schalen van icoonafbeeldingen met bicubisch resulteren in een wazige, verwassen gebruikersinterface. Een beter resultaat wordt verkregen door eerst de afbeelding te schalen met NearestNeighbor naar het grootste veelvoud van 100% (bijvoorbeeld 200% of 300%) en te schalen met bicubic van daaruit. Zie Bijzonder geval: WPF-afbeeldingen prescalen voor grote DPI-niveaus voor meer informatie.
De DpiHelper-klasse in de naamruimte Microsoft.VisualStudio.PlatformUI biedt een lid BitmapScalingMode dat kan worden gebruikt voor binding. Hiermee kan de Visual Studio-shell de bitmapschaalmodus op het product uniform beheren, afhankelijk van de DPI-schaalfactor.
Als u deze wilt gebruiken in XAML, voegt u het volgende toe:
xmlns:vsui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.14.0"
<Setter Property="RenderOptions.BitmapScalingMode" Value="{x:Static vs:DpiHelper.BitmapScalingMode}" />
In de Visual Studio-shell wordt deze eigenschap al ingesteld op vensters en dialoogvensters op het hoogste niveau. De gebruikersinterface op basis van WPF die wordt uitgevoerd in Visual Studio, neemt deze al over. Als de instelling niet wordt doorgegeven aan uw specifieke onderdelen van de gebruikersinterface, kan deze worden ingesteld op het hoofdelement van de XAML/WPF-gebruikersinterface. Dit gebeurt op plaatsen zoals pop-ups, bij elementen met Win32-oudercomponenten, en ontwerpvensters die als een apart proces draaien, zoals Blend.
Sommige gebruikersinterface kan onafhankelijk van het dpi-zoomniveau van de systeemset worden geschaald, zoals de Visual Studio-teksteditor en WPF-ontwerpers (WPF Desktop en Windows Store). In deze gevallen mag DpiHelper.BitmapScalingMode niet worden gebruikt. Om dit probleem in de editor op te lossen, heeft het IDE-team een aangepaste eigenschap gemaakt met de titel RenderOptions.BitmapScalingMode. Stel deze eigenschapswaarde in op HighQuality of NearestNeighbor, afhankelijk van het gecombineerde zoomniveau van het systeem en uw gebruikersinterface.
Speciaal geval: WPF-afbeeldingen vooraf schalen voor grote DPI-niveaus
Voor zeer hoge zoomniveaus die geen veelvouden zijn van 100% (bijvoorbeeld 250%, 350%, enzovoort) resulteert het schalen van icoonafbeeldingen met bicubische interpolatie in een vage, uitgewassen UI. De indruk van deze afbeeldingen naast heldere tekst lijkt bijna op die van een optische illusie. De afbeeldingen lijken dichter bij het oog te liggen en zijn niet meer gericht op de tekst. Het schaalresultaat van deze vergrootglasgrootte kan worden verbeterd door eerst de afbeelding met NearestNeighbor te schalen naar het grootste veelvoud van 100% (bijvoorbeeld 200% of 300%) en te schalen met bicubisch naar het restgetal (een extra 50%).
Hier volgt een voorbeeld van de verschillen in resultaten, waarbij de eerste afbeelding wordt geschaald met het verbeterde algoritme voor dubbele schaalaanpassing 100%->200%->250%, en de tweede met bicubische 100%->250%.
Als u wilt dat de gebruikersinterface deze dubbele schaalaanpassing gebruikt, moeten XAML-markeringen voor het weergeven van elk afbeeldingselement worden gewijzigd. In de volgende voorbeelden ziet u hoe u dubbel schalen gebruikt in WPF in Visual Studio met behulp van de DpiHelper-bibliotheek en Shell.12/14.
Stap 1: de afbeelding vooraf schalen naar 200%, 300%, enzovoort met behulp van NearestNeighbor.
Schaal de afbeelding vooraf met behulp van een conversieprogramma dat is toegepast op een binding of met een XAML-markeringsextensie. Voorbeeld:
<vsui:DpiPrescaleImageSourceConverter x:Key="DpiPrescaleImageSourceConverter" />
<Image Source="{Binding Path=SelectedImage, Converter={StaticResource DpiPrescaleImageSourceConverter}}" Width="16" Height="16" />
<Image Source="{vsui:DpiPrescaledImage Images/Help.png}" Width="16" Height="16" />
Als de afbeelding ook themagebaseerd moet zijn (de meeste, zo niet alle, moeten), kan de mark-up een andere converter gebruiken die eerst de afbeelding thematiseert en vervolgens vooraf schaalt. De opmaak kan ofwel DpiPrescaleThemedImageConverter ofwel DpiPrescaleThemedImageSourceConverter gebruiken, afhankelijk van de gewenste conversie-uitvoer.
<vsui:DpiPrescaleThemedImageSourceConverter x:Key="DpiPrescaleThemedImageSourceConverter" />
<Image Width="16" Height="16">
<Image.Source>
<MultiBinding Converter="{StaticResource DpiPrescaleThemedImageSourceConverter}">
<Binding Path="Icon" />
<Binding Path="(vsui:ImageThemingUtilities.ImageBackgroundColor)"
RelativeSource="{RelativeSource Self}" />
<Binding Source="{x:Static vsui:Boxes.BooleanTrue}" />
</MultiBinding>
</Image.Source>
</Image>
Stap 2: Zorg ervoor dat de uiteindelijke grootte juist is voor de huidige DPI.
Omdat WPF de gebruikersinterface voor de huidige DPI schaalt met behulp van de eigenschap BitmapScalingMode die is ingesteld op de UIElement, ziet een Afbeeldingsbesturingselement met een vooraf geschaalde afbeelding er twee of drie keer groter uit dan zou moeten. Hier volgen enkele manieren om dit effect tegen te gaan:
Als u de dimensie van de oorspronkelijke afbeelding op 100%kent, kunt u de exacte grootte van het besturingselement Afbeelding opgeven. Deze grootten weerspiegelen de grootte van de gebruikersinterface voordat schalen wordt toegepast.
<Image Source="{Binding Path=SelectedImage, Converter={StaticResource DpiPrescaleImageSourceConverter}}" Width="16" Height="16" />Als de grootte van de oorspronkelijke afbeelding niet bekend is, kan een LayoutTransform worden gebruikt om het uiteindelijke afbeeldingsobject omlaag te schalen. Voorbeeld:
<Image Source="{Binding Path=SelectedImage, Converter={StaticResource DpiPrescaleImageSourceConverter}}" > <Image.LayoutTransform> <ScaleTransform ScaleX="{x:Static vsui:DpiHelper.PreScaledImageLayoutTransformScale}" ScaleY="{x:Static vsui:DpiHelper.PreScaledImageLayoutTransformScale}" /> </Image.LayoutTransform> </Image>
HDPI-ondersteuning inschakelen voor het WebOC
WebOC-besturingselementen (zoals het besturingselement Webbrowser in WPF of de IWebBrowser2-interface) schakelen standaard HDPI-detectie en -ondersteuning niet in. Het resultaat is een ingesloten besturingselement met weergave-inhoud die te klein is op een beeldscherm met hoge resolutie. Hieronder wordt beschreven hoe u ondersteuning voor hoge DPI inschakelt in een specifiek web-WEBOC-exemplaar.
Implementeer de IDocHostUIHandler-interface (zie het MSDN-artikel op de IDocHostUIHandler:
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
Guid("BD3F23C0-D43E-11CF-893B-00AA00BDCE1A")]
public interface IDocHostUIHandler
{
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ShowContextMenu(
[In, MarshalAs(UnmanagedType.U4)] int dwID,
[In] POINT pt,
[In, MarshalAs(UnmanagedType.Interface)] object pcmdtReserved,
[In, MarshalAs(UnmanagedType.IDispatch)] object pdispReserved);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetHostInfo([In, Out] DOCHOSTUIINFO info);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ShowUI(
[In, MarshalAs(UnmanagedType.I4)] int dwID,
[In, MarshalAs(UnmanagedType.Interface)] object activeObject,
[In, MarshalAs(UnmanagedType.Interface)] object commandTarget,
[In, MarshalAs(UnmanagedType.Interface)] object frame,
[In, MarshalAs(UnmanagedType.Interface)] object doc);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int HideUI();
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int UpdateUI();
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int EnableModeless([In, MarshalAs(UnmanagedType.Bool)] bool fEnable);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int OnDocWindowActivate([In, MarshalAs(UnmanagedType.Bool)] bool fActivate);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int OnFrameWindowActivate([In, MarshalAs(UnmanagedType.Bool)] bool fActivate);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ResizeBorder(
[In] COMRECT rect,
[In, MarshalAs(UnmanagedType.Interface)] object doc,
bool fFrameWindow);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int TranslateAccelerator(
[In] ref MSG msg,
[In] ref Guid group,
[In, MarshalAs(UnmanagedType.I4)] int nCmdID);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetOptionKeyPath(
[Out, MarshalAs(UnmanagedType.LPArray)] string[] pbstrKey,
[In, MarshalAs(UnmanagedType.U4)] int dw);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetDropTarget(
[In, MarshalAs(UnmanagedType.Interface)] IOleDropTarget pDropTarget,
[MarshalAs(UnmanagedType.Interface)] out IOleDropTarget ppDropTarget);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetExternal([MarshalAs(UnmanagedType.IDispatch)] out object ppDispatch);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int TranslateUrl(
[In, MarshalAs(UnmanagedType.U4)] int dwTranslate,
[In, MarshalAs(UnmanagedType.LPWStr)] string strURLIn,
[MarshalAs(UnmanagedType.LPWStr)] out string pstrURLOut);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int FilterDataObject(
IDataObject pDO,
out IDataObject ppDORet);
}
Implementeer desgewenst de ICustomDoc-interface (zie het MSDN-artikel op de ICustomDoc:
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
Guid("3050F3F0-98B5-11CF-BB82-00AA00BDCE0B")]
public interface ICustomDoc
{
void SetUIHandler(IDocHostUIHandler pUIHandler);
}
Koppel de klasse die IDocHostUIHandler implementeert aan het webOC-document. Als u de ICustomDoc-interface hierboven hebt geïmplementeerd, dient u, zodra de documenteigenschap van de WebOC geldig is, deze naar een ICustomDoc te casten en de SetUIHandler-methode aan te roepen, waarbij u de klasse opgeeft die IDocHostUIHandler implementeert.
// "this" references that class that owns the WebOC control and in this case also implements the IDocHostUIHandler interface
ICustomDoc customDoc = (ICustomDoc)webBrowser.Document;
customDoc.SetUIHandler(this);
Als u de ICustomDoc-interface niet hebt geïmplementeerd, moet u, zodra de documenteigenschap van de WebOC geldig is, deze casten naar een IOleObject en de SetClientSite-methode aanroepen, waarbij u de klasse doorgeeft die IDocHostUIHandler implementeert. Stel de vlag DOCHOSTUIFLAG_DPI_AWARE in op DOCHOSTUIINFO die is doorgegeven aan de GetHostInfo methode-aanroep:
public int GetHostInfo(DOCHOSTUIINFO info)
{
// This is what the default site provides.
info.dwFlags = (DOCHOSTUIFLAG)0x5a74012;
// Add the DPI flag to the defaults
info.dwFlags |=.DOCHOSTUIFLAG.DOCHOSTUIFLAG_DPI_AWARE;
return S_OK;
}
Dit moet alles zijn wat u nodig hebt om uw WebOC-beheer te krijgen om HPDI te ondersteunen.
Tips
Als de documenteigenschap op het webOC-besturingselement wordt gewijzigd, moet u het document mogelijk opnieuw koppelen aan de klasse IDocHostUIHandler.
Als het bovenstaande niet werkt, is er een bekend probleem met het WebOC dat de wijziging in de DPI-vlag niet ophaalt. De meest betrouwbare manier om dit op te lossen is om de optische zoom van de WebOC in te schakelen, wat betekent dat twee aanroepen met twee verschillende waarden voor het zoompercentage. Als deze tijdelijke oplossing vereist is, kan het nodig zijn om deze uit te voeren bij elke navigate-aanroep.
// browser2 is a SHDocVw.IWebBrowser2 in this case // EX: Call the Exec twice with DPI%-1 and then DPI% as the zoomPercent values IOleCommandTarget cmdTarget = browser2.Document as IOleCommandTarget; if (cmdTarget != null) { object commandInput = zoomPercent; cmdTarget.Exec(IntPtr.Zero, OLECMDID_OPTICAL_ZOOM, OLECMDEXECOPT_DONTPROMPTUSER, ref commandInput, ref commandOutput); }