Mengatasi masalah DPI

Artikel
06/19/2023

Peningkatan jumlah perangkat dikirim dengan layar "resolusi tinggi". Layar ini biasanya memiliki lebih dari 200 piksel per inci (ppi). Bekerja dengan aplikasi di komputer ini akan mengharuskan konten ditingkatkan skalanya untuk memenuhi kebutuhan melihat konten pada jarak pandang normal untuk perangkat. Pada 2014, target utama untuk tampilan dengan kepadatan tinggi adalah perangkat komputasi seluler (tablet, laptop clamshell, dan ponsel).

Windows 8.1 dan yang lebih tinggi berisi beberapa fitur untuk memungkinkan mesin ini bekerja dengan tampilan dan lingkungan di mana komputer dilampirkan ke tampilan kepadatan tinggi dan kepadatan standar secara bersamaan.

Windows dapat memungkinkan Anda untuk menskalakan konten ke perangkat menggunakan pengaturan "Buat teks dan item lain lebih besar atau lebih kecil" (tersedia sejak Windows XP).
Windows 8.1 dan yang lebih tinggi akan secara otomatis menskalakan konten agar sebagian besar aplikasi konsisten ketika dipindahkan di antara tampilan kepadatan piksel yang berbeda. Ketika tampilan utama adalah kepadatan tinggi (penskalaan 200%) dan tampilan sekunder adalah kepadatan standar (100%), Windows akan secara otomatis menurunkan skala konten jendela aplikasi pada tampilan sekunder (1 piksel ditampilkan untuk setiap 4 piksel yang dirender oleh aplikasi).
Windows akan default ke penskalaan yang tepat untuk kepadatan piksel dan jarak tampilan untuk tampilan (Windows 7 dan yang lebih tinggi, dapat dikonfigurasi OEM).
Windows dapat secara otomatis menskalakan konten hingga 250% pada perangkat baru yang melebihi 280 ppi (per Windows 8.1 S14).

Windows memiliki cara untuk menangani peningkatan UI untuk memanfaatkan peningkatan jumlah piksel. Aplikasi ikut serta dalam sistem ini dengan mendeklarasikan dirinya "sistem DPI sadar." Aplikasi yang tidak melakukan ini ditingkatkan skalanya oleh sistem. Ini dapat mengakibatkan pengalaman pengguna "fuzzy" di mana seluruh aplikasi direntangkan secara seragam piksel. Misalnya:

Visual Studio memilih untuk mengetahui penskalaan DPI, dan karenanya tidak "divirtualisasi."

Windows (dan Visual Studio) memanfaatkan beberapa teknologi UI, yang memiliki cara berbeda untuk menangani faktor penskalaan yang ditetapkan oleh sistem. Misalnya:
WPF mengukur kontrol dengan cara yang independen perangkat (unit, bukan piksel). WPF UI secara otomatis meningkatkan skala untuk DPI saat ini.
Semua ukuran teks terlepas dari kerangka kerja UI dinyatakan dalam poin, dan demikian juga diperlakukan oleh sistem sebagai independen DPI. Teks di Win32, WinForms, dan WPF sudah ditingkatkan dengan benar saat digambar ke perangkat tampilan.
Dialog dan jendela Win32/WinForms memiliki sarana untuk mengaktifkan tata letak yang mengubah ukuran dengan teks (misalnya, melalui panel kisi, alur, dan tata letak tabel). Ini memungkinkan menghindari lokasi piksel yang dikodekan secara permanen yang tidak diskalakan ketika ukuran font ditingkatkan.
Ikon yang disediakan oleh sistem atau sumber daya berdasarkan metrik sistem (misalnya, SM_CXICON dan SM_CXSMICON) sudah ditingkatkan skalanya.

UI berbasis Win32 (GDI, GDI+) dan WinForms yang lebih lama

Meskipun WPF sudah sadar akan DPI tinggi, sebagian besar kode berbasis Win32/GDI kami awalnya tidak ditulis dengan mengingat kesadaran DPI. Windows telah menyediakan API penskalakan DPI. Perbaikan untuk masalah Win32 harus menggunakan ini secara konsisten di seluruh produk. Visual Studio telah menyediakan pustaka kelas pembantu untuk menghindari fungsionalitas duplikat dan memastikan konsistensi di seluruh produk.

Gambar resolusi tinggi

Bagian ini terutama untuk pengembang yang memperluas Visual Studio 2013. Untuk Visual Studio 2015, gunakan layanan gambar yang dibangun ke dalam Visual Studio. Anda mungkin juga menemukan bahwa Anda perlu mendukung/menargetkan banyak versi Visual Studio dan oleh karena itu menggunakan layanan gambar pada tahun 2015 bukanlah opsi karena tidak ada di versi sebelumnya. Bagian ini juga untuk Anda.

Meningkatkan skala gambar yang terlalu kecil

Gambar yang terlalu kecil dapat ditingkatkan dan dirender pada GDI dan WPF menggunakan beberapa metode umum. Kelas pembantu DPI terkelola tersedia untuk integrator Visual Studio internal dan eksternal untuk mengatasi ikon penskalaan, bitmap, imagestrips, dan daftar gambar. C/C++helpers asli berbasis Win32 tersedia untuk menskalakan HICON, HBITMAP, HIMAGELIST, dan VsUI::GdiplusImage. Penskalaan bitmap biasanya hanya memerlukan perubahan satu baris setelah menyertakan referensi ke pustaka pembantu. Misalnya:

(WinForms) DpiHelper.LogicalToDeviceUnits(ref image);

(Unmanaged) VsUI::DpiHelper::LogicalToDeviceUnits(&hBitmap);

Menskalakan daftar gambar tergantung pada apakah daftar gambar selesai pada waktu pemuatan, atau ditambahkan pada waktu proses. Jika selesai pada waktu pemuatan, panggil LogicalToDeviceUnits() dengan daftar gambar seperti yang Anda lakukan pada bitmap. Ketika kode perlu memuat bitmap individual sebelum menyusun daftar gambar, pastikan untuk menskalakan ukuran gambar daftar gambar:

imagelist.ImageSize = DpiHelper.LogicalToDeviceUnits(imagelist.ImageSize);

Dalam kode asli, dimensi dapat diskalakan saat membuat daftar gambar sebagai berikut:

ImageList_Create(VsUI::DpiHelper::LogicalToDeviceUnitsX(16),VsUI::DpiHelper::LogicalToDeviceUnitsY(16), ILC_COLOR32|ILC_MASK, nCount, 1);

Fungsi di pustaka memungkinkan menentukan algoritma mengubah ukuran. Saat menskalakan gambar yang akan ditempatkan dalam daftar gambar, pastikan untuk menentukan warna latar belakang yang digunakan untuk transparansi, atau gunakan penskalaan NearestNeighbor (yang akan menyebabkan distorsi pada 125% dan 150%).

DpiHelper Lihat dokumentasi tentang MSDN.

Tabel berikut menunjukkan contoh bagaimana gambar harus diskalakan pada faktor penskalaan DPI yang sesuai. Gambar yang diuraikan dalam warna oranye menunjukkan praktik terbaik kami pada Visual Studio 2013 (penskalaan DPI 100%-200%):

DPI Issues Scaling

Masalah tata letak

Masalah tata letak umum dapat dihindari terutama dengan menjaga titik dalam UI diskalakan dan relatif satu sama lain daripada dengan menggunakan lokasi absolut (khususnya, dalam unit piksel). Misalnya:

Posisi tata letak/teks perlu disesuaikan untuk memperhitungkan gambar yang ditingkatkan skalanya.
Kolom dalam kisi harus memiliki lebar yang disesuaikan untuk teks yang ditingkatkan skalanya.
Ukuran atau spasi yang dikodekan secara permanen antar elemen juga perlu ditingkatkan skalanya. Ukuran yang hanya didasarkan pada dimensi teks biasanya baik-baik saja, karena font secara otomatis ditingkatkan skalanya.

Fungsi pembantu tersedia di DpiHelper kelas untuk memungkinkan penskalakan pada sumbu X dan Y:
LogicalToDeviceUnitsX/LogicalToDeviceUnitsY (fungsi memungkinkan penskalakan pada sumbu X/Y)
int space = DpiHelper.LogicalToDeviceUnitsX (10);
tinggi int = VsUI::D piHelper::LogicalToDeviceUnitsY(5);

Ada kelebihan beban LogicalToDeviceUnits untuk memungkinkan penskalakan objek seperti Rect, Point, dan Size.

Menggunakan pustaka/kelas DPIHelper untuk menskalakan gambar dan tata letak

Pustaka pembantu Visual Studio DPI tersedia dalam bentuk asli dan terkelola dan dapat digunakan di luar shell Visual Studio oleh aplikasi lain.

Untuk menggunakan pustaka, buka sampel ekstensibilitas Visual Studio VSSDK dan kloning sampel high-DPI_Images_Icons.

Dalam file sumber, sertakan VsUIDpiHelper.h dan panggil fungsi VsUI::DpiHelper statis kelas:

#include "VsUIDpiHelper.h"

int cxScaled = VsUI::DpiHelper::LogicalToDeviceUnitsX(cx);
VsUI::DpiHelper::LogicalToDeviceUnits(&hBitmap);

Catatan

Jangan gunakan fungsi pembantu dalam variabel statis tingkat modul atau tingkat kelas. Pustaka juga menggunakan statis untuk sinkronisasi utas dan Anda mungkin mengalami masalah inisialisasi pesanan. Konversikan statis tersebut menjadi variabel anggota nonstatis, atau bungkus menjadi fungsi (sehingga mereka dibangun pada akses pertama).

Untuk mengakses fungsi pembantu DPI dari kode terkelola yang akan berjalan di dalam lingkungan Visual Studio:

Proyek yang menggunakan harus mereferensikan versi terbaru Shell MPF. Misalnya:
```
<Reference Include="Microsoft.VisualStudio.Shell.14.0.dll" />
```
Pastikan proyek memiliki referensi ke System.Windows.Forms, PresentationCore, dan PresentationUI.
Dalam kode, gunakan namespace Microsoft.VisualStudio.PlatformUI dan panggil fungsi statis kelas DpiHelper. Untuk jenis yang didukung (titik, ukuran, persegi panjang, dan sebagainya), ada fungsi ekstensi yang disediakan yang mengembalikan objek berskala baru. Misalnya:
```
using Microsoft.VisualStudio.PlatformUI;
double x = DpiHelper.LogicalToDeviceUnitsX(posX);
Point ptScaled = ptOriginal.LogicalToDeviceUnits();
DpiHelper.LogicalToDeviceUnits(ref bitmap);
```

Menangani kesiapan gambar WPF di UI yang dapat diperbesar

Di WPF, bitmap diubah ukurannya secara otomatis oleh WPF untuk tingkat perbesar tampilan DPI saat ini menggunakan algoritma bikubik berkualitas tinggi (default), yang berfungsi dengan baik untuk gambar atau cuplikan layar besar, tetapi tidak sesuai untuk ikon item menu karena memperkenalkan keseringan yang dirasakan.

Rekomendasi:

Untuk gambar logo dan karya seni banner, mode pengubahan ukuran default BitmapScalingMode dapat digunakan.
Untuk item menu dan gambar ikonografi, BitmapScalingMode harus digunakan ketika tidak menyebabkan artefak distorsi lain menghilangkan fuzziness (pada 200% dan 300%).
Untuk tingkat zoom besar tidak kelipatan 100% (misalnya, 250% atau 350%), menskalakan gambar ikonografi dengan hasil bikubik dalam UI fuzzy, washed-out. Hasil yang lebih baik diperoleh dengan terlebih dahulu menskalakan gambar dengan NearestNeighbor ke kelipatan terbesar 100% (misalnya, 200% atau 300%) dan penskalaan dengan bikubik dari sana. Lihat Kasus khusus: prescaling gambar WPF untuk tingkat DPI besar untuk informasi selengkapnya.

Kelas DpiHelper di namespace Microsoft.VisualStudio.PlatformUI menyediakan anggota BitmapScalingMode yang dapat digunakan untuk pengikatan. Ini akan memungkinkan shell Visual Studio untuk mengontrol mode penskalakan bitmap di seluruh produk secara seragam, tergantung pada faktor penskalakan DPI.

Untuk menggunakannya di XAML, tambahkan:

xmlns:vsui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.14.0"

<Setter Property="RenderOptions.BitmapScalingMode" Value="{x:Static vs:DpiHelper.BitmapScalingMode}" />

Shell Visual Studio sudah mengatur properti ini pada jendela dan dialog tingkat atas. UI berbasis WPF yang berjalan di Visual Studio sudah akan mewarisinya. Jika pengaturan tidak menyebar ke bagian UI tertentu Anda, pengaturan dapat diatur pada elemen akar UI XAML/WPF. Tempat-tempat di mana ini terjadi termasuk pop-up, pada elemen dengan induk Win32, dan jendela desainer yang kehabisan proses, seperti Blend.

Beberapa UI dapat menskalakan secara independen dari tingkat zoom DPI yang ditetapkan sistem, seperti editor teks Visual Studio dan desainer berbasis WPF (WPF Desktop dan Windows Store). Dalam kasus ini, DpiHelper.BitmapScalingMode tidak boleh digunakan. Untuk memperbaiki masalah ini di editor, tim IDE membuat properti kustom berjudul RenderOptions.BitmapScalingMode. Atur nilai properti tersebut ke HighQuality atau NearestNeighbor tergantung pada tingkat zoom gabungan sistem dan UI Anda.

Kasus khusus: prescaling gambar WPF untuk tingkat DPI besar

Untuk tingkat zoom yang sangat besar yang bukan kelipatan 100% (misalnya, 250%, 350%, dan sebagainya), menskalakan gambar ikonografi dengan hasil bikubik dalam UI kabur dan dicuci. Kesan gambar-gambar ini bersama teks renyah hampir seperti ilusi optik. Gambar tampak lebih dekat ke mata dan di luar fokus dalam kaitannya dengan teks. Hasil penskalaan pada ukuran yang diperbesar ini dapat ditingkatkan dengan terlebih dahulu menskalakan gambar dengan NearestNeighbor ke kelipatan terbesar 100% (misalnya, 200% atau 300%) dan penskalaan dengan bikubik ke sisanya (tambahan 50%).

Berikut ini adalah contoh perbedaan dalam hasil, di mana gambar pertama diskalakan dengan algoritma penskalaan ganda yang ditingkatkan 100%->200%->250%, dan yang kedua hanya dengan bikubik 100%->250%.

DPI Issues Double Scaling Example

Untuk memungkinkan UI menggunakan penskalaan ganda ini, markup XAML untuk menampilkan setiap elemen Gambar perlu dimodifikasi. Contoh berikut menunjukkan cara menggunakan penskalaan ganda di WPF di Visual Studio menggunakan pustaka DpiHelper dan Shell.12/14.

Langkah 1: Prescale gambar menjadi 200%, 300%, dan sebagainya menggunakan NearestNeighbor.

Prescale gambar menggunakan pengonversi yang diterapkan pada pengikatan, atau dengan ekstensi markup XAML. Misalnya:

<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" />

Jika gambar juga perlu bertema (sebagian besar, jika tidak semua, harus), markup dapat menggunakan pengonversi berbeda yang terlebih dahulu melakukan tema gambar dan kemudian pra-penskalaan. Markup dapat menggunakan atau DpiPrescaleThemedImageConverter DpiPrescaleThemedImageSourceConverter, tergantung pada output konversi yang diinginkan.

<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>

Langkah 2: Pastikan ukuran akhir sudah benar untuk DPI saat ini.

Karena WPF akan menskalakan UI untuk DPI saat ini menggunakan properti BitmapScalingMode yang diatur pada UIElement, kontrol Gambar menggunakan gambar preskal karena sumbernya akan terlihat dua atau tiga kali lebih besar dari yang seharusnya. Berikut ini adalah beberapa cara untuk melawan efek ini:

Jika Anda mengetahui dimensi gambar asli pada 100%, Anda dapat menentukan ukuran kontrol Gambar yang tepat. Ukuran ini akan mencerminkan ukuran UI sebelum penskalaan diterapkan.
```
<Image Source="{Binding Path=SelectedImage, Converter={StaticResource DpiPrescaleImageSourceConverter}}" Width="16" Height="16" />
```

Jika ukuran gambar asli tidak diketahui, LayoutTransform dapat digunakan untuk menurunkan skala objek Gambar akhir. Misalnya:

<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>

Mengaktifkan dukungan HDPI ke WebOC

Secara default, kontrol WebOC (seperti kontrol WebBrowser di WPF, atau antarmuka IWebBrowser2) tidak mengaktifkan deteksi dan dukungan HDPI. Hasilnya akan menjadi kontrol tersemat dengan konten tampilan yang terlalu kecil pada tampilan resolusi tinggi. Berikut ini menjelaskan cara mengaktifkan dukungan DPI tinggi dalam instans WebOC web tertentu.

Terapkan antarmuka IDocHostUIHandler (lihat artikel MSDN di 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);
    }

Secara opsional, terapkan antarmuka ICustomDoc (lihat artikel MSDN di ICustomDoc:

[InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
 Guid("3050F3F0-98B5-11CF-BB82-00AA00BDCE0B")]
public interface ICustomDoc
{
    void SetUIHandler(IDocHostUIHandler pUIHandler);
}

Kaitkan kelas yang mengimplementasikan IDocHostUIHandler dengan dokumen WebOC. Jika Anda menerapkan antarmuka ICustomDoc di atas, maka segera setelah properti dokumen WebOC valid, transmisikan ke ICustomDoc dan panggil metode SetUIHandler, melewati kelas yang mengimplementasikan IDocHostUIHandler.

// "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);

Jika Anda TIDAK mengimplementasikan antarmuka ICustomDoc, maka segera setelah properti dokumen WebOC valid, Anda harus mentransmisikannya ke IOleObject, dan memanggil SetClientSite metode , melewati kelas yang mengimplementasikan IDocHostUIHandler. Atur bendera DOCHOSTUIFLAG_DPI_AWARE pada DOCHOSTUIINFO yang diteruskan ke GetHostInfo panggilan metode:

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;
}

Ini harus semua yang Anda butuhkan untuk mendapatkan kontrol WebOC Anda untuk mendukung HPDI.

Tips

Jika properti dokumen pada kontrol WebOC berubah, Anda mungkin perlu mengaitkan kembali dokumen dengan kelas IDocHostUIHandler.

Jika hal di atas tidak berfungsi, ada masalah yang diketahui dengan WebOC yang tidak mengambil perubahan pada bendera DPI. Cara yang paling dapat diandalkan untuk memperbaiki ini adalah dengan mengalihkan zoom optik WebOC, yang berarti dua panggilan dengan dua nilai berbeda untuk persentase zoom. Selain itu, jika solusi ini diperlukan, mungkin perlu untuk melakukannya pada setiap panggilan navigasi.

// 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);
}

Bagikan melalui