David Kline : P/Invoke

Determining the type of a device at runtime II: A single binary solution

DavidKlineMS — Fri, 31 Mar 2006 02:12:00 GMT

Recently, I wrote about a mechanism to identify the type of device on which your application is running. My original solution utilized a custom unmanaged function to provide a simplified, type safe way to call the SystemParametersInfo function.

Some of the folks here commented that, while my method worked and was valid, it was sub-optimal since your application would need to ship an unmanaged DLL. Since this DLL would have to be built for every processor type, it was not that much easier than having a separate application for each device type.

I whole heartedly agreed with their feedback, so I am revisiting my example today.

In my new example, I am taking advatage of the DllImportAttribute's EntryPoint field to allow me to rename the function in my P/Invoke signature. Since, as mentioned last time, SystemParametersInfo is not a type safe function, I have created a string specific version, as shown below.

[DllImport("coredll.dll", EntryPoint="SystemParametersInfo", SetLastError = true)] 
private extern static Boolean GetSystemParameterString(SystemParameters sysParam, 
                                                       UInt32 bufferSize, 
                                                       StringBuilder stringBuffer, 
                                                       Boolean updateWinIni);

I then write a simple, managed method to identify the device type. This method, in turn, calls SystemParametersInfo via my GetSystemParameterString P/Invoke.

// call our wrapper function
public static DeviceType GetDeviceType()
{
    DeviceType devType;

    StringBuilder sb = new StringBuilder(128);

    // ask the operating system for the device type
    Boolean success = GetSystemParameterString(SystemParameters.GetPlatformType,
                                               // SystemParametersInfo expects the buffer size in bytes
                                               (UInt32)(sb.Capacity * sizeof(char)),
                                               sb, false);

    // compare strings as lowercase
    String str = sb.ToString().ToLower();
    switch(str)
    {
        case "smartphone":
            devType = DeviceType.Smartphone;
            break;

        case "pocketpc":
            devType = DeviceType.PocketPC;
            break;

        default:
            devType = DeviceType.WindowsCE;
            break;
    }

    return devType;
}

The GetDeviceType method described above uses the following enums to specify the system parameter and to report the type of device. I have limited the enum values to clarify the example.

enum SystemParameters : uint
{
    GetPlatformType = 257

    // TODO: Add additional SPI_* values (from winuser.h) here
}

enum DeviceType : int
{
    WindowsCE = 0,
    PocketPC = 1,
    Smartphone = 2
}

My application's Main method can make a very simple call to determine the type of device. I have made this method static to simplify this example.

static Main(String[] args)
{
    DeviceType devType = GetDeviceType();
    MessageBox.Show(devType.ToString());
}

Enjoy!
-- DK

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Determining the type of a device at runtime

DavidKlineMS — Tue, 28 Feb 2006 22:18:00 GMT

There are times when it is useful for an application to know on what type of device it is running. An application may wish to modify it's user interface depending on device type (suppress button controls on SmartPhone devices, for example), or may be part of a test harness and have a need to log the type of device on which testing was performed.

On Win32 platforms, including Windows CE, the function SystemParametersInfo provides a mechanism to get and set system-wide parameters on a device. The data returned by SystemParametersInfo (via the pvParam argument) can vary in type. Depending on the system parameter you request, the function can return a string, an integer, a structure, etc. This makes it a difficult function to call from managed code. We can make it using SystemParametersInfo easier by writing type safe wrappers for the specific system parameters of interest. Today's discussion will do just that for SPI_GETPLATFORMTYPE.

The snippet below shows a simple wrapper function which calls SystemParametersInfo to request the device (platform) type.

//--------------------------------------------------------------------- 
//THIS CODE AND INFORMATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY 
//KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
//IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
//PARTICULAR PURPOSE. 
//---------------------------------------------------------------------

/// <summary>
/// Get the device (platform) type of the device
/// </summary>
/// <param name="szDeviceType">
/// The string to hold the device type
/// </param>
/// <param name="length">
/// The length of the string (szDeviceType)
/// </param>
/// <returns>
/// True if the device type was successfully retrieved, false otherwise)
/// </returns>
BOOL GetDeviceType(WCHAR* szDeviceType, DWORD length)
{
    // TODO: Add parameter validation code here.
 
    return SystemParametersInfo(SPI_GETPLATFORMTYPE, 
                                length * sizeof(WCHAR),  // buffer size (length * character size)
                                szDeviceType,            // output buffer 
                                0); 
}

As you can see, the wrapper is very simple. The code forwards the arguments from the wrapper function to SystemParametersInfo and sends the results directly back to the caller. This wrapper is type safe and much easier to call from managed code.

My managed application can now easily determine the type of the device. Please note that for this example, the name of the DLL containing the above function is devicetype.dll and that the above "as is" banner also applies.

using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

class DeviceType
{
    // P/Invoke definition
    [DllImport("devicetype.dll", SetLastError=true)]
    private extern static Boolean GetDeviceType(StringBuilder deviceTypeName, 
                                                Int32 length);

    /// <summary>
    /// Application entry point
    /// </summary>
    public static void Main()
    {
        String message = "Unknown";

        try
        {
            // create a string builder and specify its capacity
            StringBuilder deviceType = new StringBuilder(256);

            // call our wrapper function
            Boolean success = GetDeviceType(deviceType, 
                                            deviceType.Capacity);
            if(success)
            {
                message = deviceType.ToString();
            }
        }
        catch(Exception ex)
        {
            message = String.Format("GetDeviceType failed with exception: {0}", 
                                    ex.GetType().ToString());
        }

        // display our findings
        MessageBox.Show(message, "Device Type Check");
    }
}

Running this example on a SmartPhone device displays a message box containing "SmartPhone" and a Pocket PC device displays "Pocket PC". If desired, your application can use this information to customize its behavior.

Please note: Since we need to allow native code do modify the string, we must use a StringBuilder in our P/Invoke signature.

Enjoy!
-- DK

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Checking for Screen Rotation Support using version 2 of the .NET Compact Framework - Visual Basic .Net version

DavidKlineMS — Wed, 22 Feb 2006 02:50:00 GMT

Last year, I posted a snippet on how to determine whether or not your device supported screen rotation using the .NET Compact Framework. I have recently been asked for a Visual Basic .NET version of the snippet. Other than some minor reordering / reformatting, the code below is a direct port of the example from the C# post.

''--------------------------------------------------------------------- 
''THIS CODE AND INFORMATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY 
''KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
''IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
''PARTICULAR PURPOSE. 
''---------------------------------------------------------------------
Imports System.Runtime.InteropServices
Imports System.Windows.Forms 

Module ScreenRotationCheckVBNet 

    ' DeviceMode field value(s)
    Private Const DisplayQueryOrientation As Int32 = &H1000000 

    ' ChangeDisplaySettingsEx flags value(s)
    Private Const ChangeDisplaySettingsTest As Int32 = 2 

    ' P/Invoke signature(s)
    Declare Function ChangeDisplaySettingsEx Lib "coredll.dll" _
            (ByVal deviceName As String, ByRef deviceMode As DeviceMode, _
            ByVal hwnd As IntPtr, ByVal flags As Int32, ByVal param As IntPtr) As Int32 

    ''' <summary>
    ''' Application entry point
    ''' </summary>
    Sub Main() 

        Dim message As String = String.Empty
        Dim rotationSupported As Boolean = False 

        ' prepare the DeviceMode structure
        Dim devMode As New DeviceMode
        devMode.Size = Marshal.SizeOf(devMode)
        devMode.Fields = DisplayQueryOrientation 

        ' ask the operating system if it supports screen rotation
        Dim result As Int32
        result = ChangeDisplaySettingsEx(Nothing, _
                                        devMode, _
                                        IntPtr.Zero, _
                                        ChangeDisplaySettingsTest, _
                                        IntPtr.Zero)

        If (result = 0) Then 

            ' ChangeDisplaySettingsEx call succeeded,
            ' we can check the results of our query 

            ' non-zero value in DisplayOrientation means
            ' rotation is supported
            If (devMode.DisplayOrientation <> 0) Then 

                rotationSupported = True 

            End If 

        ' format the message to display
        message = "Screen rotation supported: " + rotationSupported.ToString() 

        Else 

            ' ChangeDisplaySettingsEx call failed 

            ' format the message to display
            message = "ChangeDisplaySettingsEx failed with error code: " + result.ToString() 

        End If 

        ' display our findings
        MessageBox.Show(message, "Screen rotation check") 

    End Sub 

End Module 

''' <summary>
''' Managed version of the DEVMODE structure
''' </summary>
Structure DeviceMode 

    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=32)> _
    Public DeviceName As String

    Public SpecVersion As Int16
    Public DriverVersion As Int16
    Public Size As Int16
    Public DriverExtra As Int16
    Public Fields As Int32
    Public Orientation As Int16
    Public PaperSize As Int16
    Public PaperLength As Int16
    Public Scale As Int16
    Public Copies As Int16
    Public DefaultSource As Int16
    Public PrintQuality As Int16
    Public Color As Int16
    Public Duplex As Int16
    Public YResolution As Int16
    Public TTOption As Int16
    Public Collate As Int16 

    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=32)> _
    Public FormName As String 

    Public LogPixels As Int16
    Public BitsPerPixel As Int32
    Public PelsWidth As Int32
    Public PelsHeight As Int32
    Public DisplayFlags As Int32
    Public DisplayFrequency As Int32
    Public DisplayOrientation As Int32 

End Structure

Enjoy!
-- DK

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Wrapping Unmanaged Resources

DavidKlineMS — Tue, 10 Jan 2006 22:48:00 GMT

I recently wrote about three common causes of memory leaks in managed applications. In that post, I mentioned that failing to release unmanaged resources was one cause. Today, I'd like to talk a bit about one approach to working with unmanaged resources that has worked well in my code.

Wrapping Unmanaged Resources
While at MEDC 2005, I showed a simple example of wrapping a DeviceContext (a.k.a. DC) as part of my Debugging .NET Compact Framework Applications session. Here, I would like to expand upon that example. In the snippet below, I show finalization and disposal. I will leave it to the reader to add P/Invoke signatures.

//--------------------------------------------------------------------- //THIS CODE AND INFORMATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY //KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE //IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A //PARTICULAR PURPOSE. //--------------------------------------------------------------------- using System; using System.Diagnostics; using System.Runtime.InteropServices; namespace Snippet { /// <summary> /// Wrapper for the Win32 Device Context (DC) /// </summary> public class DeviceContext : IDisposable { // the Win32 Device Context (DC) object private IntPtr hDC; // window handle associated with the DC private IntPtr hWnd; /// <summary> /// Constructor. /// </summary> /// <param name="hwnd"> /// The window handle for which to retrieve the device context /// </param> public DeviceContext(IntPtr hwnd) { // call the p/invoke to get the device context for the specified window handle IntPtr hdc = GetDC(hwnd); // verify that the GetDC call succeeded if(hdc == IntPtr.Zero) { throw new Exception("Failed to get the DeviceContext for the specified window handle"); } // store the window handle and device context for future reference this.hWnd = hwnd; this.hDC = hdc; } /// <summary> /// Finalizer /// </summary> ~DeviceContext() { // dispose the object (unmanaged resources) this.Dispose(false); } /// <summary> /// Cleanup the object (implementation if IDisposable::Dispose) /// </summary> public void Dispose() { // clean up our resources (managed and unmanaged resources) this.Dispose(true); // suppress finalization // the finalizer also calls our cleanup code // cleanup need only occur once GC.SuppressFinalize(this); } /// <summary> /// Cleanup resources used by the object /// </summary> /// <param name="disposing"> /// Are we fully disposing the object? /// True will release all managed resources, unmanaged resources are always released /// </param> protected virtual void Dispose(Boolean disposing) { if(disposing) { //*** release any managed resources } // release unmanaged resources if(this.hDC == IntPtr.Zero) { // we're already been disposed, nothing left to do return; } Int32 ret = ReleaseDC(this.hWnd, this.hDC); this.hDC = IntPtr.Zero; this.hWnd = IntPtr.Zero; // assert if the DC was not released. Debug.Assert(ret != 0, "Failed to release DeviceContext."); } //*** add desired p/invoke definitions } }

With the resource wrapped, your application can easily interoperate with the native resource.

// get the device context for the primary display DeviceContext dc = new DeviceContext(IntPtr.Zero); //*** perform desired operations on the device context // cleanup dc.Dispose();
The above snippet uses a Debug.Assert to provide notification of a failure when releasing the unmanaged resource:

// assert if the DC was not released. Debug.Assert(ret != 0, "Failed to release DeviceContext.");
By running the debug build during development, you can identify scenarios where cleanup fails and take steps to address the issue before the product ships to your customers.

For additional information regarding finalization and disposal, I recommend reading Implementing Finalize and Dispose to Clean Up Unmanaged Resources, on MSDN.

Enjoy!
-- DK

[Edit: Fixed assert]

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Checking for Screen Rotation Support in NetCF version 2

DavidKlineMS — Fri, 17 Jun 2005 07:26:00 GMT

A couple of months ago, I showed an example of how to P/Invoke to check if your device supports device rotation using version 1 of the .NET Compact Framework. In that post, I promised to revisit the example for NetCF v2 once Beta 2 was released.

You may recall that in the previous version of this example, we were required, in our DeviceMode structure, to expand each of the DEVMODE structure's char arrays into 32 individual fields. This is no longer required on NetCF v2 thanks to its expanded marshaling support.

Instead of the individual char fields, the revised DeviceMode structure contains two String objects (DeviceName and FormName). These Strings are decorated with the MarshalAs attribute which specifies that they are to become char arrays of 32 elements. This makes accessing these fields much more pleasant as we no longer need to assemble to and disassemble from individual characters.

Note: The following code example was built and tested using the Beta 2 releases of Visual Studio 2005 and .NET Compact Framework version 2.


using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
class ScreenRotationCheckNetCFv2
{
    public static void Main()
    {
        String msg;
        Boolean rotationSupported = false;
        // prepare the DeviceMode structure
        DeviceMode devMode = new DeviceMode();
        devMode.Size = (Int16)Marshal.SizeOf(devMode);
        devMode.Fields = DisplayQueryOrientation;
       
        // ask the operating system if it supports screen rotation
        Int32 result = ChangeDisplaySettingsEx(null,        // primary display
                                             ref devMode,
                                             IntPtr.Zero,   // reserved must be 0
                                             ChangeDisplaySettingsTest,
                                             IntPtr.Zero);
        if(0 == result)
        {
            // ChangeDisplaySettingsEx call succeeded,
            //  we can check the results of our query
            
            // non-zero value in DisplayOrientation means
            //  rotation is supported
            if(0 != devMode.DisplayOrientation)
            {
                rotationSupported = true;
            }
            
            // format the message to display
            msg = String.Format("Screen rotation supported: {0}", 
                                rotationSupported);
        }
        else
        {
            msg = String.Format("ChangeDisplaySettingsEx failed with error code: {0}",
                                result);
        }
        // display our findings
        MessageBox.Show(msg, "Screen rotation check");
    }    
    // DeviceMode field value(s)
    private static Int32 DisplayQueryOrientation = 0x01000000;
    // ChangeDisplaySettingsEx flags value(s)
    private static Int32 ChangeDisplaySettingsTest = 2;
    // pinvoke(s)
    [DllImport("coredll.dll", SetLastError=true)]
    private extern static Int32 ChangeDisplaySettingsEx(String deviceName, 
                                                    ref DeviceMode deviceMode,
                                                    IntPtr hwnd,
                                                    Int32 flags,
                                                    IntPtr param);
}
// managed version of the DEVMODE structure
struct DeviceMode
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)]
    public String DeviceName;
    public Int16 SpecVersion; 
    public Int16 DriverVersion; 
    public Int16 Size; 
    public Int16 DriverExtra; 
    public Int32 Fields; 
    public Int16 Orientation; 
    public Int16 PaperSize; 
    public Int16 PaperLength; 
    public Int16 PaperWidth; 
    public Int16 Scale; 
    public Int16 Copies; 
    public Int16 DefaultSource; 
    public Int16 PrintQuality; 
    public Int16 Color; 
    public Int16 Duplex; 
    public Int16 YResolution; 
    public Int16 TTOption; 
    public Int16 Collate; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)]
    public String FormName; 
    public Int16 LogPixels; 
    public Int32 BitsPerPel; 
    public Int32 PelsWidth; 
    public Int32 PelsHeight; 
    public Int32 DisplayFlags; 
    public Int32 DisplayFrequency; 
    public Int32 DisplayOrientation;
}

As you can see from the above, the code is much easier to read than the previous version and there is much less of a chance of making structure conversion errors (too many or too few elements).

Enjoy!
-- DK

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.
Some of the information contained within this post may be in relation to beta software. Any and all details are subject to change.

Is my device running on battery or AC power?

DavidKlineMS — Thu, 10 Feb 2005 19:55:00 GMT

At times, it's helpful to know if the device running your application is plugged in or on battery power (long duration process, software update, etc). Since the .NET Compact Framework does not provide a managed implementation for this check, you will need to P/Invoke to the native power status API. The power status P/Invoke is straight forward and will provide a good deal of information about the battery - charge level, voltage, even battery chemistry.

Today's snippet uses the power status P/Invoke to check to see whether or not the device is connected to an AC power source (ACLineStatus). For that field, I defined the three (3) power states listed in the Windows CE .NET SDK documentation into an enum. This enum is interesting in that it's base type is specified as a byte, allowing it to fit neatly into the structure.

Since my little example does not use the remainder of the structure, please refer to the Windows CE .NET SDK documentation for details regarding their usage. If your application is interested in the BatteryFlag, BackupBatteryFlag and/or BatteryChemistry elements, you may wish to implement enum(s) similar to what I did for ACLineStatus.

As with my other mini-snippets, I have written this one to use a MessageBox to display the results.

 using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 class AcPowerCheck
{
    public static void Main()
    {
        String msg = "Power status check failed.";
        PowerStatus info = new PowerStatus();       
         // query the device's power status 
        Int32 result = GetSystemPowerStatus(ref info,
                                            Marshal.SizeOf(info),
                                            true);
        if(!result.Equals(0))
        {
            // common message portion
            msg = "Power source:";
             // a non-zero return from the native GetSystemPowerStatusEx
            //  API indicates success
            if(info.ACLineStatus.Equals(ACLineStatus.Online))
            { 
                // plugged in
                msg = String.Format("{0} AC Power", msg);
            }
            else if(info.ACLineStatus.Equals(ACLineStatus.Offline))
            {
                // not plugged in
                msg = String.Format("{0} Battery", msg);
            }
            else
            {
                // could not be determined
                msg = String.Format("{0} Unknown", msg);
            }
        }
        
        
        // display the message
        MessageBox.Show(msg);
    }
     // p/invoke signature
    [DllImport("coredll.dll", EntryPoint="GetSystemPowerStatusEx2", SetLastError=true)]
    private extern static Int32 GetSystemPowerStatus(ref PowerStatus powerStatus,
                                                    Int32 length,
                                                    Boolean update);
}
 // managed version of the SYSTEM_POWER_STATUS_EX2 structure
public struct PowerStatus
{
  public ACLineStatus ACLineStatus;
  public Byte BatteryFlag;
  public Byte BatteryLifePercent;
  public Byte Reserved1;
  public Int32 BatteryLifeTime;
  public Int32 BatteryFullLifeTime;
  public Byte Reserved2;
  public Byte BackupBatteryFlag;
  public Byte BackupBatteryLifePercent;
  public Byte Reserved3;
  public Int32 BackupBatteryLifeTime;
  public Int32 BackupBatteryFullLifeTime;
  public Int32 BatteryVoltage;
  public Int32 BatteryCurrent;
  public Int32 BatteryAverageCurrent;
  public Int32 BatteryAverageInterval;
  public Int32 BatterymAHourConsumed;
  public Int32 BatteryTemperature;
  public Int32 BackupBatteryVoltage;
  public Byte BatteryChemistry;
}
 
// enumeration containing the values for
//  SYSTEM_POWER_STATUS_EX2.ACLineStatus
public enum ACLineStatus : byte
{
    Offline = 0,
    Online  = 1,
    Unknown = 255,
}

To keep the P/Invoke easy for me to read, I have overridden the name. For those who may not be familiar with P/Invokes, you can change the name used in managed code by specifying the actual native API name in the EntryPoint property in the DllImport attribute (as shown below).

 [DllImport("coredll.dll", EntryPoint="GetSystemPowerStatusEx2", SetLastError=true)]
private extern static Int32 GetSystemPowerStatus(ref PowerStatus powerStatus,
                                                Int32 length,
                                                Boolean update);

I hope you find this mini-snippet useful.

Take care!
-- DK

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

How To Get The Display's Color Depth using NetCF Version 1

DavidKlineMS — Thu, 03 Feb 2005 04:28:00 GMT

I've seen this asked about recently on the NetCF (microsoft.public.dotnet.framework.compactframework) newsgroup, and it fits nicely with yesterday's display related p/invoke, too... :)

You may have noticed that, in version 1 of the .NET Compact Framework, the Screen object (System.Windows.Forms.Screen) does not specify the color depth of the display device (Bounds, PrimaryScreen, WorkingArea are provided). The color depth may be useful, if you are writing an application to working with graphics, you may wish to limit a user's color palette based on what the display is capable of showing, for example.

Fortunately, getting this information is not difficult. You only need two p/invoke calls: GetDC() and GetDeviceCaps().

 
using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 class DisplayInfo
{
    public static void Main()
    {
        // get the dimensions of the display
        Rectangle screen = Screen.PrimaryScreen.Bounds;
         // get the color depth (bits per pixel)
        //  first, we get the handle to the primary display (using GetDC)
        IntPtr deviceHandle = GetDC(IntPtr.Zero);
        if(IntPtr.Zero == deviceHandle)
        {
            // our call to GetDC failed
            MessageBox.Show("Failed to get device handle");
            return;
        }
        
        // if we get here, we can query the device capabilities
        Int32 colorDepth = GetDeviceCaps(deviceHandle, BitsPerPixel);        
         // release the device context
        //  0 == not released
        //  1 == released
        if(0 == ReleaseDC(IntPtr.Zero, deviceHandle))
        {
            MessageBox.Show("Failed to release the device handle");
        }
        
        // build a string containing the information we will show
        String msg = String.Format("{0} x {1} {2} bpp", 
                                screen.Width, 
                                screen.Height,
                                colorDepth);
        
        // display the screen info
        MessageBox.Show(msg, "Screen information");
    }
     // GetDeviceCaps index value(s)
    private const Int32 BitsPerPixel = 12;
     // pinvoke methods
    [DllImport("coredll.dll", SetLastError=true)]
    private extern static IntPtr GetDC(IntPtr hwnd);
    
    [DllImport("coredll.dll", SetLastError=true)]
    private extern static Int32 ReleaseDC(IntPtr hwnd,
                                        IntPtr hdc);
     [DllImport("coredll.dll", SetLastError=true)]
    private extern static Int32 GetDeviceCaps(IntPtr hdc, 
                                            Int32 index);
}

Enjoy!
-- DK

[Edit: Add call to ReleaseDC]

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Checking for Screen Rotation Support Using NetCF

DavidKlineMS — Tue, 01 Feb 2005 19:49:00 GMT

Yesterday, the Windows Mobile team posted a handy tip titled "How to check if screen can be rotated". This got me interested in checking for screen rotation support from managed code.

In V1, the structure to be marshalled is not pretty. Since the fixed size character arrays are not at the end of the structure (and since we will not be needing their values in this example), the easiest way to get them marshalled is to flatten the arrays. This will get much nicer in V2 (I'll revisit this example when the next public V2 beta is available).

Though the structure (DeviceMode) included here is rather large, we will be using only three fields:
DeviceMode.Size - the size of the structure DeviceMode.Fields - the fields being used DeviceMode.DisplayOrientation - where we will receive the results

Example
using System; using System.Runtime.InteropServices; using System.Windows.Forms;

 class ScreenRotationCheck
{
    public static void Main()
    {
        String msg;
        Boolean rotationSupported = false;
         // prepare the DeviceMode structure
        DeviceMode devMode = new DeviceMode();
        devMode.Size = (Int16)Marshal.SizeOf(devMode);
        devMode.Fields = DisplayQueryOrientation;
       
        // ask the operating system if it supports screen rotation
        Int32 result = ChangeDisplaySettingsEx(null,        // primary display
                                             ref devMode,
                                             IntPtr.Zero,   // reserved must be 0
                                             ChangeDisplaySettingsTest,
                                             IntPtr.Zero);
        if(0 == result)
        {
            // ChangeDisplaySettingsEx call succeeded,
            //  we can check the results of our query
            
            // non-zero value in DisplayOrientation means
            //  rotation is supported
            if(0 != devMode.DisplayOrientation)
            {
                rotationSupported = true;
            }
            
            // format the message to display
            msg = String.Format("Screen rotation supported: {0}", 
                                rotationSupported);
        }
        else
        {
            msg = String.Format("ChangeDisplaySettingsEx failed with error code: {0}",
                                result);
        }
         // display our findings
        MessageBox.Show(msg, "Screen rotation check");
    }    
     // DeviceMode field value(s)
    private static Int32 DisplayQueryOrientation = 0x01000000;
     // ChangeDisplaySettingsEx flags value(s)
    private static Int32 ChangeDisplaySettingsTest = 2;
     // pinvoke(s)
    [DllImport("coredll.dll", SetLastError=true)]
    private extern static Int32 ChangeDisplaySettingsEx(String deviceName, 
                                                    ref DeviceMode deviceMode,
                                                    IntPtr hwnd,
                                                    Int32 flags,
                                                    IntPtr param);
}
 // managed version of the DEVMODE structure
struct DeviceMode
{
    // these 32 elements are DEVMODE.dmDeviceName
    public char DeviceName0; 
    public char DeviceName1; 
    public char DeviceName2; 
    public char DeviceName3; 
    public char DeviceName4; 
    public char DeviceName5; 
    public char DeviceName6; 
    public char DeviceName7; 
    public char DeviceName8; 
    public char DeviceName9; 
    public char DeviceName10; 
    public char DeviceName11; 
    public char DeviceName12; 
    public char DeviceName13; 
    public char DeviceName14; 
    public char DeviceName15; 
    public char DeviceName16;
    public char DeviceName17; 
    public char DeviceName18; 
    public char DeviceName19; 
    public char DeviceName20; 
    public char DeviceName21; 
    public char DeviceName22; 
    public char DeviceName23; 
    public char DeviceName24; 
    public char DeviceName25; 
    public char DeviceName26; 
    public char DeviceName27; 
    public char DeviceName28; 
    public char DeviceName29; 
    public char DeviceName30; 
    public char DeviceName31; 
     public Int16 SpecVersion; 
    public Int16 DriverVersion; 
    public Int16 Size; 
    public Int16 DriverExtra; 
    public Int32 Fields; 
    public Int16 Orientation; 
    public Int16 PaperSize; 
    public Int16 PaperLength; 
    public Int16 PaperWidth; 
    public Int16 Scale; 
    public Int16 Copies; 
    public Int16 DefaultSource; 
    public Int16 PrintQuality; 
    public Int16 Color; 
    public Int16 Duplex; 
    public Int16 YResolution; 
    public Int16 TTOption; 
    public Int16 Collate; 
     // these 32 elements are DEVMODE.dmFormName
    public char FormName0; 
    public char FormName1; 
    public char FormName2; 
    public char FormName3; 
    public char FormName4; 
    public char FormName5; 
    public char FormName6; 
    public char FormName7; 
    public char FormName8; 
    public char FormName9; 
    public char FormName10; 
    public char FormName11; 
    public char FormName12; 
    public char FormName13; 
    public char FormName14; 
    public char FormName15; 
    public char FormName16; 
    public char FormName17; 
    public char FormName18; 
    public char FormName19; 
    public char FormName20; 
    public char FormName21; 
    public char FormName22; 
    public char FormName23; 
    public char FormName24; 
    public char FormName25; 
    public char FormName26; 
    public char FormName27; 
    public char FormName28; 
    public char FormName29; 
    public char FormName30; 
    public char FormName31;

public Int16 LogPixels; public Int32 BitsPerPel; public Int32 PelsWidth; public Int32 PelsHeight; public Int32 DisplayFlags; public Int32 DisplayFrequency; public Int32 DisplayOrientation; }

From the documentation on ChangeDisplaySettingsEx, when querying display orientation support:

"The supported screen orientations are returned in lpDevMode.dmDisplayOrientation. A value of just DMO_0 indicates that screen rotation is not supported."

Based on the above, receiving the default orientation value (DMOD_0 == 0) in DeviceMode.DisplayOrientation indicates that the device does not support rotation. Any value other than 0 means rotation is supported.

Enjoy!
-- DK