Ryan O'Neill's www.rhinomobile.net

Professional Development Plan 2010

noreply@blogger.com (Ryan O'Neill) — Wed, 10 Mar 2010 21:16:00 PST

Being someone who constantly reads has been great for my career in developing new skills and learning new technologies. I believe that "Continuous Learning" is very important for any software developer especially considering the rapid change in the advances of technology as well as the maturation and evolution of the software development profession.

In January, I read James Marcus Bach's Secrets of a Buccaneer Scholar, and really identified with it. Bach is someone who is a huge proponent of self-study. I consider myself largely self-taught, yet someone who has learned at the feet of the most respected men in the software development profession by reading their works.

The two books which really had a dramatic and immediate impact on how I not only developed software but thought about developing software were Martin Fowler's Refactoring: Improving the Design of Existing Code and Steve McConnell's Code Complete: A Practical Handbook of Software Construction (the first version). These books opened doors for me and my voraciousness for reading technical books spiraled out of control from there. How I have chosen which books to read in the past could be described as random at best.

In Bach's book, he had mapped out areas of study which he focuses on. As I thought more about that, I realized that there are a few areas of study that I want to focus on and further develop my own skills in this year. So I decided to pick 6 areas to focus on:

Planning and Estimation
Analysis and Design
Testing
Leadership Strategy
Presentation
Business

Within each of these 6 areas, I decided to pick two books which I would like to read. Some of these books I have owned for years but not read, some I had bought recently but not read, and some are available on O'Reilly's Safari Books Online, to which I have a full subscription. I then set a goal for myself to read all twelve books by the end of this year. Some of them I have not started, some of them I am partially through, and some of them I have completed:

Planning and Estimation
Agile Estimating and Planning by Mike Cohn (2005) (0% Completed)
Software Estimation: Demystifying the Black Art by Steve McConnell (2006) (24% Completed)

Analysis and Design
Emergent Design: The Evolutionary Nature of Professional Software Development by Scott Bain (2008) (32% Completed)
Analysis Patterns: Reusable Object Models by Martin Fowler (1996) (6% Completed)

Testing
Testing Computer Software, 2nd Edition by Cem Kaner et. al. (1999) (6% Completed)
Agile Testing: A Practical Guide for Testers and Agile Teams by Lisa Crispin et. al. (2009) (0% Completed)

Leadership Strategy
Leading Lean Software Development: Results are not the Point by Mary Poppendieck et. al. (2009) (0% Completed)
One Strategy: Organizing, Planning, and Decision Making by Steven Sinofsky et. al. (2009) (60% Completed)

Presentation
Confessions of a Public Speaker by Scott Berkun (2009) (100% Completed)
Speak to Win: How to Present with Power in Any Situation by Brian Tracy (2008) (18% Completed)

Business
The Effective Executive: The Definitive Guide to Getting the Right Things Done by Peter Drucker (1967) (100% Completed)
The Ten-Day MBA 3rd Ed.: A Step-By-Step Guide To Mastering The Skills Taught In America's Top Business Schools by Steven Silbiger (2005) (17% Completed)

Quick Hitter: The King of Kong: A Fistful of Quarters

noreply@blogger.com (Ryan O'Neill) — Sun, 19 Aug 2007 21:06:00 PDT

Champion versus challenger. The perennial winner versus the lovable loser. The guy people love to hate versus the guy people love to cheer. The same qualities that make a heated sports rivalry so spectacular are in full effect in Seth Gordon's amazing documentary The King of Kong: A Fistful of Quarters. Gordon's story details the battle between challenger Steve Wiebe and champion Billy Mitchell as they vie for the Donkey Kong world record. Wiebe, with a wife, two kids, no job, and a penchant for crying, fights for integrity and respectability. Mitchell, the 1980's arcade master with the 1970's haircut, fights for video game supremacy. Colorful characters are plentiful throughout which only adds to the narrative. A highly gripping and entertaining picture.

What is a movie review doing on a blog about mobile and embedded technology?

Well, the main CPU for the Donkey Kong arcade game machine was a Zilog Z80.

Quick Hitter: Installing Windows Embedded CE 6

noreply@blogger.com (Ryan O'Neill) — Thu, 16 Aug 2007 21:16:00 PDT

During the installation of Windows Embedded CE 6, sometimes the installer displays a dialog box stating that it "Could not access network location [url]." An example of this is displayed in Image 1. Hitting the Retry button on the dialog may not have any effect at first. What appears to work when this occurs is to open Internet Explorer, type the url in the location bar and hit Enter. Hit the Cancel button on the File Download dialog. Then, go back to the installer dialog and hit the Retry button again. This time it should work fine.

Image 1 - Error Dialog

Webcast Review: Testing the Most Critical Part of Your Application

noreply@blogger.com (Ryan O'Neill) — Wed, 15 Aug 2007 21:00:00 PDT

In this webcast, Microsoft MVP and frequent MSDN Webcast presenter Jim Wilson provides an overview and a demonstration of the Local Server Framework. The Local Server Framework, also known as FakeServer, is a new tool included with the Windows Mobile 6 SDK. The Local Server Framework provides both a native dll and a managed wrapper for setting up a testing server which runs directly on a Windows Mobile device.

Running a test server on a Windows Mobile device provides greater control over an application's test environment by removing network setup and maintenance from the equation. When building mobile applications, often times the server component is being developed in parallel with the client. Using the Local Server Framework for testing, therefore, is a great way to cut down on the impact of client and server modifications. Jim mentions how blame for miscommunication when versions are out of sync is usually placed on the client because it is the application that exposes the error. For this and other reasons, he believes that a mobile client should not trust server data unconditionally and that the application should validate transmitted data just like user-entered data. By using the Local Server Framework, developers can modify the FakeServer to see how their mobile applications respond to these and other spurious inputs.

From an information perspective, this is a great resource on the Local Server Framework, a tool which has not seen nearly any publicity since the release of Windows Mobile 6. This webcast shares the necessary information needed to get started using the Local Server Framework making it very effective.

Windows Mobile Native Unit Testing

noreply@blogger.com (Ryan O'Neill) — Tue, 14 Aug 2007 21:40:00 PDT

When applied with discipline and care, unit testing can be a powerful weapon in a software developer's arsenal. It allows a developer to garner feedback on functional correctness as well as refactor an existing codebase with security and confidence. Additional benefits of unit testing can be greater modularity, looser coupling, and an easier ability to measure whether software is meeting functional requirements.

There is a wealth of information on the Internet regarding unit testing and unit testing frameworks, but very few items are Windows Mobile specific. With the .NET Compact Framework, unit testing can currently be done with the Mobile Client Software Factory, released in mid-2006. And with the upcoming release of Visual Studio 2008 and the .NET Compact Framework version 3.5, unit tests are integrated into Visual Studio for managed mobile development.

The managed side is covered pretty well at this point (or will be when Visual Studio 2008 comes out), but what about the native side? What is available for C++ developers on Windows Mobile to use? One answer is CppUnitLite.

CppUnitLite was written by Michael C. Feathers, author of Working Effectively with Legacy Code. Feathers was also the original author of CppUnit and developed CppUnitLite when he realized that CppUnit could have been "smaller, easier to use, and far more portable if it used some C idioms and only a bare subset of the C++ language." [Feathers p48]

Here are steps to setup CppUnitLite for use with Windows Mobile.

1. Download CppUnitLite from the Object Mentor website.

2. Extract the following files from the om/CppUnitLite section of the zip file:

Failure.h
SimpleString.h
Test.h
TestHarness.h
TestRegistry.h
TestResult.h
Failure.cpp
SimpleString.cpp
Test.cpp
TestRegistry.cpp
TestResult.cpp

(In this demo, these files have been extracted to C:\CppUnitLite)

3. Open the Solution which requires unit tests.(In this demo, the solution is named StackExample. This solution contains one project, Stack, which contains two files, Stack.h and Stack.cpp. Image 1 contains a screenshot of the solution loaded in the Solution Explorer. Stack.h is displayed in Code Listing 1. Stack.cpp is displayed in Code Listing 2.)

Image 1 - StackExample solution in Solution Explorer

Code Listing 1 - Stack.h

#ifndef Stack_h
#define Stack_h

#if (_MSC_VER > 1000)
#pragma once
#endif

/*!
 * \brief
 * This class is a stack which holds integer
 * values.
 *
 * The size of the stack is determined at time
 * of construction. A stack uses the last-in
 * first-out approach.
 */
class Stack
{
public:
    Stack(int maxSize);
    virtual ~Stack();

    bool IsEmpty() const;
    void Push(int item);
    int Pop();
private:
    int* m_items;
    int  m_currentSize;
    int  m_maxSize;
};

#endif

Code Listing 2 - Stack.cpp

#include "Stack.h"
#include <stdexcept>

using namespace std;

/*!
 * \brief
 * This method is the constructor for the Stack class.
 *
 * \param maxSize
 * This parameter is the maximum number of integers
 * the stack can hold.
 */
Stack::Stack(int maxSize)
{
    m_maxSize = maxSize;
    m_items = new int[maxSize];
    m_currentSize = 0;
}

/*!
 * \brief
 * This method is the destructor for the Stack class.
 */
Stack::~Stack()
{
    delete[] m_items;
}

/*!
 * \brief
 * This function calculates whether or not the
 * stack is currently empty.
 *
 * \returns
 * This function returns true if the stack is
 * empty, or false otherwise.
 */
bool Stack::IsEmpty() const
{
    return (m_currentSize == 0);
}

/*!
 * \brief
 * This function adds an integer value to the stack.
 *
 * \param item
 * This parameter is the integer value to add to the stack.
 *
 * \throws exception
 * This function throws an exception if a value is pushed
 * when the stack is already full.
 */
void Stack::Push(int item)
{
    if (m_currentSize >= m_maxSize)
    {
        throw exception("Stack is full.");
    }
    else
    {
        m_items[m_currentSize++] = item;
    }
}

/*!
 * \brief
 * This function removes an integer value from the stack.
 *
 * \returns
 * This function returns the last integer value added to
 * the stack and removes it.
 *
 * \throws exception
 * This function throws an exception if this function is
 * called when the stack is empty.
 */
int Stack::Pop()
{
    if (IsEmpty())
    {
        throw exception("Stack is empty.");
    }
    else
    {
        return m_items[--m_currentSize];
    }
}

4. Add a new Win32 Smart Device Project to the solution named CppUnitLite and place it in the directory where the CppUnitLite source code was extracted in Step 2.

Image 2 - Add New Project Wizard

5. Add all Windows Mobile platform SDKs to the new project.

Image 3 - Win32 Smart Device Project Wizard (Platform)

6. Set the Application type to Static Library and turn off Precompiled header in the Additional options section.

Image 4 - Win32 Smart Device Project Wizard (Application Settings)

7. Move the project file and the readme.txt file into the main directory where the CppUnitLite files are stored. The project needs to be removed and readded to the solution within Visual Studio.

Image 5 - Directory listing of CppUnitLite files.

8. Using the Add->Existing Item... mechanism, add the header files (*.h) to the Header files section and add the source files (*.cpp) to the Source files section.

Image 6 - CppUnitLite project with all header and source files added

This walkthrough assumes that the code to be tested is in a static library (*.lib). In the example, Stack.h and Stack.cpp are in a static library project named Stack.

9. Add a new project to the solution and name it LibraryName.Tests. In the example, the project is named Stack.Tests.

10. Right-click on the project and choose properties. In the Common Properties->References section add the other two projects as references by using the Add New Reference button.

Image 7 - References added to the project properties.

11. In the Configuration Properties->C/C++->General section is an option named Additional Include Directories. Add the directories which contain the header files of the classes to be tested as well as the directory which contains the CppUnitLite header files. In the example, these two directories are ..\Stack and C:\CppUnitLite.

Image 8 - Additional Include Directories added to the project properties.

12. Add a .cpp file with a command line main method for Windows Mobile in it. This file should include TestHarness.h from CppUnitLite. In the main method, create a TestResult variable and pass it into TestRegistry::runAllTests as done in the StackMain.cpp example in Code Listing 3.

Code Listing 3 - StackMain.cpp

#include "TestHarness.h"
#include <windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
    TestResult tr;
    TestRegistry::runAllTests(tr);

    return 0;
}

13. Add a file named corresponding to the class to be tested. In the example, the Stack class is being tested, so the file is named StackTest.cpp. The code for this file is listed in Code Listing 4.

Code Listing 4 - StackTest.cpp

#include "TestHarness.h"
#include "Stack.h"
#include <string>

TEST( MultiPushPop, Stack )
{
    Stack s(10);
    s.Push(14); 
    LONGS_EQUAL(14, s.Pop());
    s.Push(12);
    s.Push(18);
    s.Push(27); 
    LONGS_EQUAL(27, s.Pop());
    s.Push(38);
    s.Push(2);
    s.Push(12);
    LONGS_EQUAL(12, s.Pop());
    LONGS_EQUAL( 2, s.Pop());
    LONGS_EQUAL(38, s.Pop());
    LONGS_EQUAL(18, s.Pop());
    LONGS_EQUAL(12, s.Pop());
    CHECK(s.IsEmpty());
}

TEST( PushExceedsMax, Stack )
{
    Stack s(5);
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    s.Push(5);
    try
    {
        s.Push(6);
        FAIL("Push should have exceeded max stack size");
    }
    catch (std::exception ex)
    {
        // Expected behavior
    }
}

TEST( PushPop, Stack )
{
    Stack s(10);
    s.Push(27000);
    CHECK(!s.IsEmpty());
    int value = s.Pop();
    LONGS_EQUAL(27000, value);
    CHECK(s.IsEmpty());
}

TEST( PopEmpty, Stack )
{
    Stack s(10);
    try
    {
        // This test should throw an exception
        int value = s.Pop();
        FAIL("Popping an empty stack should throw an exception");
    }
    catch (std::exception ex)
    {
        // Expected behavior
    }
}

TEST( IsEmpty, Stack )
{
    Stack s(10);
    CHECK(s.IsEmpty());
}

TEST( Creation, Stack )
{
    Stack s(10);
}

13. Set the .Tests project (Stack.Tests) as the startup project by right-clicking on the project and choosing Set as Startup Project.

14. Build all the projects.

15. Make sure to choose the same emulator or device for all three projects otherwise multiple emulator windows may pop up.

16. Run the project. Hopefully, a message stating "There were no test failures" is then displayed in the Output window as shown in Image 9.

Image 9 - Successful Test Run

Aside from the examples that come with CppUnitLite, there are additional examples within Working Effectively with Legacy Code.

Webcast Review: Building High-Performance Applications Using the .NET Compact Framework

noreply@blogger.com (Ryan O'Neill) — Thu, 09 Aug 2007 20:07:00 PDT

On August 8th, 2007, the Microsoft .NET Compact Framework team's lead software developer, Steven Pratschner, conducted an extremely informative MSDN webcast entitled "Building High-Performance Applications Using the .NET Compact Framework". For people unfamiliar with Steven's blog, performance is a topic which he has covered quite extensively there. This webcast included discussion of a wide array of topics ranging from performance comparisons with native code to the implementation of the .NET CF garbage collector.
There are many notable highlights in this 71 minute webcast including the following subjects:

A comparison of method calls on performance:

Managed Method calls are 2.3x the cost of a native call
Virtual Method calls are 1.5x the cost of a method instance call
P/Invoke Method calls are 5x the cost of a managed instance call
(Unfortunately though it did not discuss the performance of static methods versus instance methods nor the use of interfaces)

The effect of boxing on performance demonstrated through the use of a simple demo game containing a grid of blocks being rotated.
How to use the .NET CF Remote Performance Monitor to look at metrics including the total number of garbage collections, memory usage, and objects allocated.
How to use the new CLR Profiler, which will be included in version 3.5 of the .NET Compact Framework. This provided detailed information to the level of showing which methods within the demo application were causing a high percentage of object allocations.
Why it is better to use an indexer or custom iterator over a foreach statement

Early in the session, Steven mentions how code is just-in-time compiled or jitted, on a per method basis. How code is jitted is important when testing the performance of methods. Steven reveals an extremely useful approach. He says to run the method once so that it gets jitted. Then, call the method again this time measuring for performance. Following these steps gives the true runtime of the method as opposed to the jit time and runtime combined.

Other fascinating topics are discussed including collections, reducing application startup times and reflection. This is definitely a webcast that developers working on enterprise level line of business applications using the .NET CF should watch.

iPhone Business Usage

noreply@blogger.com (Ryan O'Neill) — Wed, 25 Jul 2007 07:00:00 PDT

CRN (Channel Reseller News) and CRN Tech have recently had two commentaries regarding the business practicality of Apple's iPhone. First was Frank J. Ohlhorst's The iPhone Has No Business In Business where Ohlhorst compares the Apple iPhone hype to that of Windows 95 and deems the iPhone as inferior to BlackBerry, Treo, Windows Mobile and Symbian devices for business use. Ed Moltzen then posted a follow up blog entry entitled A Pro-Business Argument For The iPhone where he says the following:

The iPhone has pretty darn good push email functionality (if you can sync your Yahoo, AOL, Gmail, or .Mac email to the device.) You can also set up POP mail or Exchange (if IMAP support is set up on the Exchange Server.) For those who can access Lotus Notes via webmail, you can do that on the iPhone's Safari browser although sending email or performing other Notes functions can be mind-bendingly difficult. (But if you can auto-forward Notes email to another account, like Yahoo, that works fine.) The bottom line for email on the iPhone: for most people it will work well.

Two things are bothersome with the above statements.

One, saying that the iPhone works with Exchange and then throwing in a caveat in parentheses is misleading. Unfortunately, respected technology journalist Walt Mossberg falls into the same trap in his iPhone review, "It can also handle corporate email using Microsoft’s Exchange system, if your IT department cooperates by enabling a setting on the server." Saying the iPhone works with Exchange as long as a system administrator flips a setting is like saying that John is a millionaire (as long as he buys the winning lottery ticket). Unless someone with a 'C' as the first letter in her title (CEO, CFO, CIO, CTO) is carrying the iPhone, don't expect that setting to get flipped. Additionally, the Microsoft Exchange Team has posted their own rebuttal to Walt Mossberg's statement.

Two, even suggesting that iPhone users auto-forward their email to another service is absolutely ludicrous. Not only does it go against almost all business security policies, but in some cases forwarding email in that manner can open a company up to liability as well. Also, how would clients react to finding out that their email sent to john.smith@xyzcompany.com is passing through (or residing on) Yahoo's, Google's, or AOL's email servers? Definitely not positively. Of course it still happens where people do this, but to suggest it as standard operating procedure is irresponsible.

Regardless of whether the iPhone becomes a staple of business use or not, the attention that this topic receives is good for the industry as a whole. As Ohlhorst points out, "[b]ut the hype does have benefits for the channel—namely, the resurgence of interest in mobile applications and business communications devices." Reminds one of the old saying -- "There is no such thing as bad publicity".

(Special thanks to Nino Benvenuti for editing this entry.)

AUTDv1 Text Messaging Impact

noreply@blogger.com (Ryan O'Neill) — Tue, 24 Jul 2007 06:30:00 PDT

With Exchange 2003 and Windows Mobile 2003, Microsoft attempted to mitigate the wide-spread usage of RIM BlackBerry's push email service with a technology named Always Up-To-Date, or AUTD. This first version of AUTD worked by sending an SMS control message to the Windows Mobile 2003 phone whenever an event occurred within Exchange which modified a folder marked for synchronization. The Windows Mobile 2003 phone would then download the updates from Exchange.

For more background information, see Microsoft Technet: How to Configure Always Up-To-Date Notifications

Image1 shows a chart detailing my text message usage from August 2005 through July 2007. It is fairly obvious the period where my usage of AUTDv1 starts and ends.

Image1 - Text Message Usage Per Month

.NET CF Custom Control: RoundedGroupBox

noreply@blogger.com (Ryan O'Neill) — Wed, 02 May 2007 11:00:00 PDT

The .NET Compact Framework provides an excellent abstracted interface to the Graphics Device Interface (GDI) subsystem in the same manner as the full .NET Framework. However, there are still quite a few drawing methods which are not part of the CF which if included would make the design of custom controls easier (and sometimes more fun). One of the methods missing from the Compact Framework is the RoundRect GDI function. According to MSDN, "This function draws a rectangle with rounded corners. The current pen outlines the rectangle and the current brush fills it."

In this entry, the RoundRect function is used to create a new custom control called a RoundedGroupBox. The standard GroupBox control exists on the full framework and provides a panel with a rounded outline and a title. It logically groups controls into a designated area of the screen. An image of the GroupBox from the full framework is displayed in Image 1. The Compact Framework does not contain a GroupBox control, so this custom control, RoundedGroupBox, serves as a stand-in with a little more flare.

Image 1 - GroupBox from the full .NET framework

To create the RoundedGroupBox using C# and the .NET Compact Framework, aside from the RoundRect GDI function, there are three other GDI functions which need to be P/Invoked:

CreateSolidBrush - This function is used to create colored brushes used to fill in the round rectangles.

SelectObject - This function is used to select a brush to use when drawing.

DeleteObject - This function deletes a drawing object and frees its associated memory.

A fourth function, GetStockObject is also contained within the source code but not used within this example. GDI contains some predefined pens, brushes and fonts. This function can retrieve any of those.

One very important point when P/Invoking these functions is that they need to be accessed at both design time and runtime. On Windows Mobile, these functions are all found in the coredll native assembly. Trying to use that assembly during design time is not going to work however, because Visual Studio will try to access a coredll.dll file on the local desktop. To work in the designer on the desktop, these functions need to be accessed in the gdi32 assembly found in the \Windows\System32 folder. A simple wrapper function has been written that checks the current environment and decides which version of the function to use -- gdi32 on the desktop and coredll on Windows Mobile. The source code for accessing these functions is listed in Code Listing 1. Image 2 shows the RoundedGroupBox control displayed in the Visual Studio designer.

Code Listing 1 - NativeMethods.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

#endregion

namespace Rhinomobile.ControlLibrary
{
    /// <summary>
    /// Platform Invocation Methods
    /// </summary>
    class NativeMethods
    {
        #region Windows CE Methods

        [DllImport("coredll", EntryPoint = "RoundRect")]
        private static extern bool RoundRectCE(IntPtr hdc, int nLeftRect, int nTopRect, 
            int nRightRect, int nBottomRect, int nWidth, int nHeight);

        [DllImport("coredll", EntryPoint = "CreateSolidBrush")]
        private static extern IntPtr CreateSolidBrushCE(int crColor);

        [DllImport("coredll", EntryPoint = "SelectObject")]
        private static extern IntPtr SelectObjectCE(IntPtr hdc, IntPtr hgdiobj);

        [DllImport("coredll", EntryPoint = "DeleteObject")]
        private static extern bool DeleteObjectCE(IntPtr hObject);

        [DllImport("coredll", EntryPoint = "GetStockObject")]
        private static extern IntPtr GetStockObjectCE(int fnObject);

        #endregion

        #region Windows Methods

        [DllImport("gdi32", EntryPoint = "RoundRect")]
        private static extern bool RoundRectWin(IntPtr hdc, int nLeftRect, int nTopRect, 
            int nRightRect, int nBottomRect, int nWidth, int nHeight);

        [DllImport("gdi32", EntryPoint = "CreateSolidBrush")]
        private static extern IntPtr CreateSolidBrushWin(int crColor);

        [DllImport("gdi32", EntryPoint = "SelectObject")]
        private static extern IntPtr SelectObjectWin(IntPtr hdc, IntPtr hgdiobj);

        [DllImport("gdi32", EntryPoint = "DeleteObject")]
        private static extern bool DeleteObjectWin(IntPtr hObject);

        [DllImport("gdi32", EntryPoint = "GetStockObject")]
        private static extern IntPtr GetStockObjectWin(int fnObject);

        #endregion

        #region Platform Agnostic Methods

        /// <summary>
        /// This function draws a rectangle with rounded corners. The current pen outlines the 
        /// rectangle and the current brush fills it.
        /// </summary>
        /// <param name="hdc">Handle to the device context.</param>
        /// <param name="nLeftRect">Specifies the x-coordinate of the upper left corner of 
        /// the rectangle.</param>
        /// <param name="nTopRect">Specifies the y-coordinate of the upper left corner of 
        /// the rectangle.</param>
        /// <param name="nRightRect">Specifies the x-coordinate of the lower right corner 
        /// of the rectangle.</param>
        /// <param name="nBottomRect">Specifies the y-coordinate of the lower right corner
        /// of the rectangle.</param>
        /// <param name="nWidth">Specifies the width of the ellipse used to draw the 
        /// rounded corners.</param>
        /// <param name="nHeight">Specifies the height of the ellipese used to draw the 
        /// rounded corners.</param>
        /// <returns>
        /// Nonzero indicates success. Zero indicates failure. To get extended 
        /// error information, call GetLastError.
        /// </returns>
        internal static bool RoundRect(IntPtr hdc, int nLeftRect, int nTopRect,
     int nRightRect, int nBottomRect, int nWidth, int nHeight)
        {
            bool result = false;
            if (Environment.OSVersion.Platform == PlatformID.WinCE)
            {
                result = RoundRectCE(hdc, nLeftRect, nTopRect, nRightRect, 
                    nBottomRect, nWidth, nHeight);
            }
            else
            {
                result = RoundRectWin(hdc, nLeftRect, nTopRect, nRightRect, 
                    nBottomRect, nWidth, nHeight);
            }
            return result;
        }

        /// <summary>
        /// This function creates a logical brush that has the specified solid color.
        /// </summary>
        /// <param name="crColor">Specifies the color of the brush.</param>
        /// <returns>
        /// A handle that identifies a logical brush indicates success. NULL 
        /// indicates failure. To get extended error information, call GetLastError.
        /// </returns>
        internal static IntPtr CreateSolidBrush(int crColor)
        {
            IntPtr result = IntPtr.Zero;
            if (Environment.OSVersion.Platform == PlatformID.WinCE)
            {
                result = CreateSolidBrushCE(crColor);
            }
            else
            {
                result = CreateSolidBrushWin(crColor);
            }
            return result;
        }

        /// <summary>
        /// This function selects an object into a specified device context. The new object 
        /// replaces the previous object of the same type.
        /// </summary>
        /// <param name="hdc">Handle to the device context.</param>
        /// <param name="hgdiobj">Handle to the object to be selected.</param>
        /// <returns>
        /// If the selected object is not a region, the handle of the object being 
        /// replaced indicates success.
        /// </returns>
        internal static IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj)
        {
            IntPtr result = IntPtr.Zero;
            if (Environment.OSVersion.Platform == PlatformID.WinCE)
            {
                result = SelectObjectCE(hdc, hgdiobj);
            }
            else
            {
                result = SelectObjectWin(hdc, hgdiobj);
            }
            return result;
        }

        /// <summary>
        /// This function deletes a logical pen, brush, font, bitmap, region, or palette, 
        /// freeing all system resources associated with the object. After the object is 
        /// deleted, the specified handle is no longer valid.
        /// </summary>
        /// <param name="hObject">Handle to a logical pen, brush, font, bitmap, region, 
        /// or palette.</param>
        /// <returns>Nonzero indicates success.</returns>
        internal static bool DeleteObject(IntPtr hObject)
        {
            bool result = false;
            if (Environment.OSVersion.Platform == PlatformID.WinCE)
            {
                result = DeleteObjectCE(hObject);
            }
            else
            {
                result = DeleteObjectWin(hObject);
            }
            return result;
        }

        /// <summary>
        /// This function retrieves a handle to one of the predefined stock pens, 
        /// brushes or fonts.
        /// </summary>
        /// <param name="fnObject">Specifies the type of stock object.</param>
        /// <returns>If the function succeeds, the return value identifies the 
        /// logical object requested.</returns>
        internal static IntPtr GetStockObject(int fnObject)
        {
            IntPtr result = IntPtr.Zero;
            if (Environment.OSVersion.Platform == PlatformID.WinCE)
            {
                result = GetStockObjectCE(fnObject);
            }
            else
            {
                result = GetStockObjectWin(fnObject);
            }
            return result;
        }

        #endregion
    }
}

Image 2 - RoundedGroupBox control displayed in the designer

By default, when a P/Invoke call is made inside a .NET CF custom control, the Visual Studio designer will not attempt to draw the control properly because it believes it cannot. The attribute which controls whether Visual Studio will attempt to draw the control or not is the DesktopCompatible attribute which is placed in the DesignTimeAttributes.xmta xml file. Code Listing 2 shows the DesignTimeAttributes.xmta file. Image 3 displays two versions of the control - one with the DesktopCompatible attribute set to true in the xmta file and the other without it.

Code Listing 2 - DesignTimeAttributes.xmta


<?xml version="1.0" encoding="utf-16"?>
<Classes xmlns="http://schemas.microsoft.com/VisualStudio/2004/03/SmartDevices/XMTA.xsd">
  <Class Name="Rhinomobile.ControlLibrary.BorderPanel">
    <DesktopCompatible>true</DesktopCompatible>
    <Property Name="BorderColor">
      <Category>Appearance</Category>
      <Description>The color used to draw the border of the panel.</Description>
    </Property>
    <Property Name="BorderWidth">
      <Category>Layout</Category>
      <Description>The width of the panel border.</Description>
    </Property>
  </Class>
  <Class Name="Rhinomobile.ControlLibrary.RoundedGroupBox">
    <DesktopCompatible>true</DesktopCompatible>
    <Property Name="OuterColor">
      <Category>Appearance</Category>
      <Description>The color user to fill the background of the title of the rounded group box.</Description>
    </Property>
    <Property Name="RoundedGroupBoxText">
      <Category>Appearance</Category>
      <Description>The text displayed in the title of the group box panel.</Description>
    </Property>
  </Class>
</Classes>

Image 3 - Two versions of RoundedGroupBox displayed - One with the DesktopCompatible attribute set to true in the DesignTimeAttributes.xmta file, the other without

The RoundedGroupBox control itself is comprised of two round rectangles drawn with different colored brushes. The top is slightly offset on the inner polygon which leaves an area for the title to be written. This control is derived from a standard .NET Compact Framework System.Windows.Forms.Panel, so out of the box it provides the logical grouping functionality inherent in a panel.

RoundedGroupBox provides two additional properties, OuterColor and RoundedGroupBoxText. OuterColor is the color used for the title area and the outline. The standard BackColor property is used for the area where controls are placed. RoundedGroupBoxText is a property which contains the text displayed in the title area.

RoundedGroupBox also overrides two inherited methods, OnPaintBackground and OnPaint. In OnPaintBackground, the background color of the parent control is used to fill the RoundedGroupBox control. Doing this fills in the gaps left by the rounded corners of the control so that seemingly the parent control is showing through. OnPaint is more complicated and a snippet of code is displayed inline below.


        protected override void OnPaint(PaintEventArgs e)
        {
            int outerBrushColor = HelperMethods.ColorToWin32(m_outerColor);
            int innerBrushColor = HelperMethods.ColorToWin32(this.BackColor);

            IntPtr hdc = e.Graphics.GetHdc();
            try
            {
                IntPtr hbrOuter = NativeMethods.CreateSolidBrush(outerBrushColor);
                IntPtr hOldBrush = NativeMethods.SelectObject(hdc, hbrOuter);
                NativeMethods.RoundRect(hdc, 0, 0, this.Width, this.Height, DIAMETER, DIAMETER);
                IntPtr hbrInner = NativeMethods.CreateSolidBrush(innerBrushColor);
                NativeMethods.SelectObject(hdc, hbrInner);
                NativeMethods.RoundRect(hdc, 0, 18, this.Width, this.Height, DIAMETER, DIAMETER);
                NativeMethods.SelectObject(hdc, hOldBrush);
                NativeMethods.DeleteObject(hbrOuter);
                NativeMethods.DeleteObject(hbrInner);
            }
            finally
            {
                e.Graphics.ReleaseHdc(hdc);
            }

            if (!string.IsNullOrEmpty(m_roundedGroupBoxText))
            {
                Font titleFont = new Font("Tahoma", 9.0F, FontStyle.Bold);
                Brush titleBrush = new SolidBrush(this.BackColor);
                try
                {
                    e.Graphics.DrawString(m_roundedGroupBoxText, titleFont, titleBrush, 14.0F, 2.0F);
                }
                finally
                {
                    titleFont.Dispose();
                    titleBrush.Dispose();
                }
            }

            base.OnPaint(e);
        }

The first two function calls are to the ColorToWin32 method. This method converts a System.Drawing.Color value into an integer used with Windows 32 functions. It is contained in the HelperMethods class. This class can be found in Code Listing 3.

Following the color conversions, a handle to the underlying GDI device context is retrieved using the GetHdc method. A solid brush of the outer color is then created using CreateSolidBrush. This brush is then selected using the SelectObject function. This is analagous to selecting a type of brush within a graphics program when drawing shapes. A handle to the previously selected brush is saved so that it can be the selected brush again when the control is finished drawing. The outer round rectangle is drawn with a call to the RoundRect function. The same steps are repeated for the inner round rectangle: creation, selection, and drawing. Both the outer and inner round rectangles are drawn using a constant value for nWidth and nHeight giving the control a circular corner. When both round rectangles have been drawn, the previously selected brush is set as the selected brush again. The two created brushes are then deleted. Finally, the handle to the device context is released. The remaining part of the OnPaint method is responsible for writing the title text in the space between the two round rectangles. The source code for RoundedGroupBox.cs is found in Code Listing 4. Image 4 shows a screenshot of a sample application which uses the RoundedGroupBox control to ask a question where a singular answer can be chosen.

Code Listing 3 - HelperMethods.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

#endregion

namespace Rhinomobile.ControlLibrary
{
    /// <summary>
    /// Useful methods
    /// </summary>
    static class HelperMethods
    {
        /// <summary>
        /// Converts a System.Drawing.Color value into a Windows 32 color value.
        /// </summary>
        /// <param name="color">System.Drawing.Color value</param>
        /// <returns>Windows 32 integer representation of a color</returns>
        public static int ColorToWin32(Color color)
        {
            return ((color.R | (color.G << 8)) | (color.B << 16));
        }
    }
}

Code Listing 4 - RoundedGroupBox.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.Text;

#endregion

namespace Rhinomobile.ControlLibrary
{
    /// <summary>
    /// A group box panel with rounded corners and a title
    /// </summary>
    public class RoundedGroupBox : Panel
    {
        #region Constants

        private const int DIAMETER = 32;        

        #endregion

        #region Fields
        
        private Color m_outerColor = SystemColors.ActiveCaption;
        private string m_roundedGroupBoxText = string.Empty;

        #endregion

        #region Protected Methods

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            if (this.Parent != null)
            {
                SolidBrush backBrush = new SolidBrush(this.Parent.BackColor);
                try
                {
                    e.Graphics.FillRectangle(backBrush, 0, 0, this.Width, this.Height);
                }
                finally
                {
                    backBrush.Dispose();
                }
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            int outerBrushColor = HelperMethods.ColorToWin32(m_outerColor);
            int innerBrushColor = HelperMethods.ColorToWin32(this.BackColor);

            IntPtr hdc = e.Graphics.GetHdc();
            try
            {
                IntPtr hbrOuter = NativeMethods.CreateSolidBrush(outerBrushColor);
                IntPtr hOldBrush = NativeMethods.SelectObject(hdc, hbrOuter);
                NativeMethods.RoundRect(hdc, 0, 0, this.Width, this.Height, DIAMETER, DIAMETER);
                IntPtr hbrInner = NativeMethods.CreateSolidBrush(innerBrushColor);
                NativeMethods.SelectObject(hdc, hbrInner);
                NativeMethods.RoundRect(hdc, 0, 18, this.Width, this.Height, DIAMETER, DIAMETER);
                NativeMethods.SelectObject(hdc, hOldBrush);
                NativeMethods.DeleteObject(hbrOuter);
                NativeMethods.DeleteObject(hbrInner);
            }
            finally
            {
                e.Graphics.ReleaseHdc(hdc);
            }

            if (!string.IsNullOrEmpty(m_roundedGroupBoxText))
            {
                Font titleFont = new Font("Tahoma", 9.0F, FontStyle.Bold);
                Brush titleBrush = new SolidBrush(this.BackColor);
                try
                {
                    e.Graphics.DrawString(m_roundedGroupBoxText, titleFont, titleBrush, 14.0F, 2.0F);
                }
                finally
                {
                    titleFont.Dispose();
                    titleBrush.Dispose();
                }
            }

            base.OnPaint(e);
        }

        #endregion

        #region Properties

        /// <summary>
        /// The color user to fill the background of the title of the rounded group box.
        /// </summary>
        public Color OuterColor
        {
            get
            {
                return m_outerColor;
            }
            set
            {
                m_outerColor = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// The text displayed in the title of the group box panel.
        /// </summary>
        public string RoundedGroupBoxText
        {
            get
            {
                return this.m_roundedGroupBoxText;
            }
            set
            {
                m_roundedGroupBoxText = value;
                this.Invalidate();
            }
        }

        #endregion
    }
}

Image 4 - RoundedGroupBox example application

Quick Hitter: Indoor GPS Navigation

noreply@blogger.com (Ryan O'Neill) — Thu, 26 Apr 2007 09:24:00 PDT

After working for some time on projects requiring a Global Positioning System (GPS) solution, mostly involving Windows Mobile, I have learned that there are associated headaches due to GPS not working indoors. Two of the GPS pioneers from the 70s are trying to change that with a solution using TV signals.

Rosum: Taking GPS Indoors [Business Week]

.NET CF Custom Control: BorderPanel

noreply@blogger.com (Ryan O'Neill) — Fri, 20 Apr 2007 12:59:00 PDT

Creating custom controls using the .NET Compact Framework 2.0 and Visual Studio 2005 can be a tough chore at times, but sometimes it can also be very rewarding and time saving. This entry details how to create a .NET CF BorderPanel custom control. A BorderPanel is a type of Panel which contains a border of a specified color and width. This control is used in the Run Application at Time (and Time Change) post to separate different sections of the demonstration application into logical groupings.

Inside the Rhinomobile.ControlLibrary sample project, which is of type ControlLibrary, there are three files to note: BorderPanel.bmp, BorderPanel.cs, and DesignTimeAttributes.xmta. BorderPanel.bmp is the graphic which represents the BorderPanel when it is placed in the Toolbox. BorderPanel.cs is the source code for the BorderPanel custom control. DesignTimeAttributes.xmta is an xml file which contains information used by Visual Studio when using the control through the designer. The project layout including these three files is displayed in Image 1.

Image 1 - Solution Explorer Showing BorderPanel.bmp, BorderPanel.cs, and DesignTimeAttributes.xmta Files

BorderPanel.bmp is a 16 x 16 bitmap added to the project with the same base name as the custom control. The Build Action for this file should be set to "Embedded Resource". The BorderPanel.bmp file used in this project is displayed in Image 2.

Image 2 - BorderPanel.bmp Graphic

BorderPanel is a .NET Compact Framework 2.0 Custom Control which behaves exactly like a Panel yet has a border of a specified color and width. BorderPanel inherits from the standard System.Windows.Forms.Panel class. By doing so, BorderPanel automatically acts in the same fashion as a Panel. The only difference with a BorderPanel is how it is drawn.

Two fields are added to the BorderPanel class, one containing information about the border color and the other about the border width. Corresponding public properties are also added to the class. These are named appropriately enough BorderColor and BorderWidth. A call to Invalidate() is also added to the mutator (set) of the public properties. The Invalidate method with no parameters causes the entire control to be redrawn on the next painting. Changing the border color or changing the border width would both cause the visual look of the control to change and is why Invalidate is called.

The OnPaint method inherited from the Panel class is overridden to draw the custom control. A new Pen object is instantiated, used to draw the border, and then disposed. It is of extreme importance to dispose of GDI objects as soon as they are finished being used on a mobile device as they are a major source of memory issues. The width of the Pen is set to the BorderWidth property and the color is set to BorderColor.

Calculating where to draw the border though is an interesting issue. The drawing is covered in these two lines:


int halfWidth = m_borderWidth / 2;
e.Graphics.DrawRectangle(borderPen, halfWidth, halfWidth, 
    this.Width - m_borderWidth, this.Height - m_borderWidth);

The halfWidth variable is used due to the alignment of the Pen object. Pen.Alignment is not a property that is supported on the .NET Compact Framework. The alignment of the Pen is therefore set to center, meaning that if the width of the pen is 10 pixels, 5 are going to be drawn on one side of the pen and 5 on the other. For this reason, half the width (halfWidth) of the Pen is calculated and used as the starting x,y coordinate for the drawing of the border. This ensures that the entire border is drawn on the viewable area. The third and fourth parameters to the DrawRectangle method are a width and height of the rectangle which is the reason the entire width and entire height of the border are subtracted from these values respectively.

The final item in OnPaint is a call to base.OnPaint(e) to ensure that other items are properly drawn. The source code for the BorderPanel is shown in Code Listing 1.

Code Listing 1 - BorderPanel.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

#endregion

namespace Rhinomobile.ControlLibrary
{
    /// <summary>
    /// A Panel with a colored sizable border
    /// </summary>
    public class BorderPanel : Panel
    {
        #region Fields

        private Color m_borderColor = SystemColors.Control;
        private int m_borderWidth = 4;

        #endregion

        #region Constructor

        /// <summary>
        /// BorderPanel Constructor
        /// </summary>
        public BorderPanel() : base()
        {
        }

        #endregion

        #region Protected Methods

        protected override void OnPaint(PaintEventArgs e)
        {
            if ((m_borderWidth > 0) && (m_borderWidth < (this.Width / 2)))
            {
                Pen borderPen = new Pen(m_borderColor, (float)m_borderWidth);
                try
                {
                    int halfWidth = m_borderWidth / 2;
                    e.Graphics.DrawRectangle(borderPen, halfWidth, halfWidth, 
                        this.Width - m_borderWidth, this.Height - m_borderWidth);                    
                }
                finally
                {
                    borderPen.Dispose();
                }
            }
            base.OnPaint(e);
        }

        #endregion

        #region Properties

        /// <summary>
        /// Color used for drawing border on panel
        /// </summary>
        public Color BorderColor
        {
            get
            {
                return m_borderColor;
            }
            set
            {
                m_borderColor = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// Width of border on panel
        /// </summary>
        public int BorderWidth
        {
            get
            {
                return m_borderWidth;
            }
            set
            {
                m_borderWidth = value;
                this.Invalidate();
            }
        }

        #endregion
    }
}

DesignTimeAttributes.xmta is an xml file which contains information about classes, properties, methods, and events used by Visual Studio at design time for controls. The xmta file for the BorderPanel custom control, demonstrates how to add descriptions for added properties as well as placing the properties within the proper categories in the Properties Window.

Working with the DesignTimeAttributes.xmta file can be one of the flakiest and time consuming tasks when working with the .NET Compact Framework. The one for this control has been simplified to only show the simplest two elements. The DesignTimeAttributes.xmta file can be found in Code Listing 2.

Code Listing 2 - DesignTimeAttributes.xmta


<?xml version="1.0" encoding="utf-16"?>
<Classes xmlns="http://schemas.microsoft.com/VisualStudio/2004/03/SmartDevices/XMTA.xsd">
  <Class Name="Rhinomobile.ControlLibrary.BorderPanel">
    <Property Name="BorderColor">
      <Category>Appearance</Category>
      <Description>The color used to draw the border of the panel.</Description>
    </Property>
    <Property Name="BorderWidth">
      <Category>Layout</Category>
      <Description>The width of the panel border.</Description>
    </Property>
  </Class>
</Classes>

At this point the project can be compiled and the control library built. The following images indicate how to go about adding the BorderPanel to the Toolbox within Visual Studio.

Image 3 - Toolbox Before Adding BorderPanel

Right click on the Toolbox and select "Choose Items..."

Image 4 - Choose Toolbox Items Dialog Before Adding BorderPanel

Click the "Browse" button on the Choose Toolbox Items Dialog.

Image 5 - Choose Toolbox Items Browse Dialog

Navigate to the location of the control library assembly and select it.

Image 6 - Choose Toolbox Items After Adding BorderPanel

Notice the controls in the assembly have been added to the list of components and checked. Click the "Ok" button on the dialog and the controls should be added to the Toolbox.

Image 7 - Toolbox After Adding BorderPanel

Image 8 - Form1.cs Design After Dragging Over a BorderPanel from the Toolbox

Image 9 - Properties Window Showing the BorderColor and BorderWidth Properties

Run Application at Time (and Time Change)

noreply@blogger.com (Ryan O'Neill) — Fri, 30 Mar 2007 13:47:00 PDT

MSDN describes CeRunAppAtTime as a function which "prompts the system to start running a specified application at a specified time." This function can be extremely useful for performing scheduled tasks such as snapshots of running processes, the retrieval of device memory statistics, routine checks on security settings, or automatic device synchronization. Conversely, it can also be used to rescind the scheduling of these activities.

The CeRunAppAtTime function takes two parameters: TCHAR* pwszAppName, and SYSTEMTIME* lpTime. The first parameter, pwszAppName, is the name of the application to be run (e.g. \windows\cgacutil.exe). The type of the parameter is a pointer to a TCHAR. One might ask, "What's a TCHAR?" Well, according to MSDN, a TCHAR is a "Win32 character string that can be used to describe ANSI, DBCS, or Unicode strings. [...] For Unicode platforms, TCHAR is defined as synonymous with the WCHAR type." With Windows CE being a Unicode platform, this makes a TCHAR a WCHAR (wide character). Further demonstrating this is that the name of the actual first parameter - pwszAppName, translates into Pointer to a Wide String terminated with a Zero (null character) when broken down. Because the parameter is an input parameter, a standard C# string can be passed in as an equivalent in a P/Invoke function call.

The second parameter, lpTime, is the time at which the specified application should be run. A simple C# type though won't suffice for lpTime (Long Pointer to a time variable). This parameter requires a little bit more work. SYSTEMTIME is a structure composed of WORD representations of 8 items: year, month, day, day of week, hours, minutes, seconds, and milliseconds. A WORD is equivalent to a C# short, i.e. 2 bytes, putting the size of the structure at 16 bytes. A C# equivalent has been provided in Code Listing 1.

Additionally, it is the second parameter which also controls whether CeRunAppAtTime rescinds the scheduling of an application. This is done by passing in a null parameter for lpTime. One note on cancelling an application though is that CeRunAppAtTime will return false if the application specified was not already currently specified, so do not interpret this as the function only failing to remove a scheduled instance.

In the example below, because SYSTEMTIME (represented in C# as SystemTime) is a structure, two P/Invoke calls have been defined (see NativeTimeMethods.cs). The one which takes an array of bytes as the lpTime parameter is the one which can have a null value sent into it (see TimeUtilities.cs). The other one should be used for standard scheduling of applications.

An interesting point requiring further discussion is what happens when the time on the device is changed. The device time could be changed by the user or by a time negotiation on synchronization, or via an NTP (Network Time Protocol) server.

Images 1 through 5 show what happens when the current time on a device (March 28th, 2007) is changed to a future time (March 30th, 2007) to the point where applications would be scheduled to run in the past (March 29th, 2007). Windows CE ends up running those scheduled applications immediately. This is demonstrated within the screenshots of the sample application.

Image 1 - First "Set Date" button tapped. Date changed to March 28th, 2007

Image 2 - Right soft key button tapped. Application soft key menu displayed

Image 3 - Run App menu option selected. Application is run now.

Image 4 - "Set App" button tapped. Application set to run on March 29th, 2007

Image 5 - Second "Set Date" button tapped. Date changed to March 30th, 2007

With the time now changed to March 30th, 2007, the application which was scheduled to run on March 29th, 2007 is now run immediately.

Code Listing 1 - SystemTime.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

#endregion

namespace Rhinomobile.ClassLibrary
{
    /// <summary>
    /// This structure represents a date and time using individual members for the month,
    /// day, year, weekday, hour, minute, second, and millisecond.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct SystemTime
    {
        #region Fields

        private short m_year;
        private short m_month;
        private short m_dayOfWeek;
        private short m_day;
        private short m_hour;
        private short m_minute;
        private short m_second;
        private short m_milliseconds;

        #endregion

        #region Constructors

        public SystemTime(DateTime value)
            : this()
        {
            ConvertFromDateTime(value);
        }

        #endregion

        #region Properties

        /// <summary>
        /// Specifies the current year
        /// </summary>
        public short Year
        {
            get { return m_year; }
        }

        /// <summary>
        /// Specifies the current month
        /// January = 1 ... December = 12
        /// </summary>
        public short Month
        {
            get { return m_month; }
        }

        /// <summary>
        /// Specifies the current day of the week
        /// Sunday = 0 ... Saturday = 6
        /// </summary>
        public short DayOfWeek
        {
            get { return m_dayOfWeek; }
        }

        /// <summary>
        /// Specifies the current day of the month
        /// </summary>
        public short Day
        {
            get { return m_day; }
        }

        /// <summary>
        /// Specifies the current hour
        /// </summary>
        public short Hour
        {
            get { return m_hour; }
        }

        /// <summary>
        /// Specifies the current minute
        /// </summary>
        public short Minute
        {
            get { return m_minute; }
        }

        /// <summary>
        /// Specifies the current second
        /// </summary>
        public short Second
        {
            get { return m_minute; }
        }

        /// <summary>
        /// Specifies the current millisecond
        /// </summary>
        public short Milliseconds
        {
            get { return m_milliseconds; }
        }

        public DateTime DateTime
        {
            get { return ConvertToDateTime(); }
            set { ConvertFromDateTime(value); }
        }

        /// <summary>
        /// Gets the day of the year represented by this instance.
        /// </summary>
        public int DayOfYear
        {
            get { return DateTime.DayOfYear; }
        }

        /// <summary>
        /// Gets the number of ticks that represent the date and time of this instance.
        /// </summary>
        public long Ticks
        {
            get { return DateTime.Ticks; }
        }

        /// <summary>
        /// Gets the time of day for this instance.
        /// </summary>
        public TimeSpan TimeOfDay
        {
            get { return DateTime.TimeOfDay; }
        }

        #endregion

        #region Private Methods

        private void ConvertFromDateTime(DateTime value)
        {
            m_year = (short)value.Year;
            m_month = (short)value.Month;
            m_dayOfWeek = (short)value.DayOfWeek;
            m_day = (short)value.Day;
            m_hour = (short)value.Hour;
            m_minute = (short)value.Minute;
            m_second = (short)value.Second;
            m_milliseconds = (short)value.Millisecond;
        }

        private DateTime ConvertToDateTime()
        {
            return new DateTime(m_year, m_month, m_day, m_hour, m_minute, m_second);
        }

        #endregion
    }
}

Code Listing 2 - NativeTimeMethods.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

#endregion

namespace Rhinomobile.ClassLibrary
{
    /// <summary>
    /// P/Invoked time related methods.
    /// </summary>
    static class NativeTimeMethods
    {
        #region Internal Static Methods

        /// <summary>
        /// This function sets the current local time and date.
        /// </summary>
        /// <param name="lpSystemTime">A pointer to a SystemTime structure that contains 
        /// the new local date and time. The DayOfWeek member of the SystemTime structure 
        /// is ignored.</param>
        /// <returns>Nonzero indicates success. Zero indicates failure.</returns>
        [DllImport("coredll")]
        internal static extern bool SetLocalTime(ref SystemTime lpSystemTime);

        /// <summary>
        /// This function prompts the system to start running a specified application at
        /// a specified time.
        /// </summary>
        /// <param name="pwszAppName">Pointer to a null-terminated string that specifies
        /// the name of the application to be run.</param>
        /// <param name="lpTime">Long pointer to a SystemTime structure that specifies
        /// the time when the given application is to be run. If this parameter is NULL,
        /// the existing run request is deleted and no new request is entered. The 
        /// deleted run request must have been initiated by a call to CeRunAppAtTime.</param>
        /// <returns>TRUE indicates success. FALSE indicates failure.</returns>
        [DllImport("coredll")]
        internal static extern bool CeRunAppAtTime(string pwszAppName, ref SystemTime lpTime);

        /// <summary>
        /// This function prompts the system to start running a specified application at
        /// a specified time.
        /// </summary>
        /// <param name="pwszAppName">Pointer to a null-terminated string that specifies
        /// the name of the application to be run.</param>
        /// <param name="lpTime">Long pointer to a SystemTime structure that specifies
        /// the time when the given application is to be run. If this parameter is NULL,
        /// the existing run request is deleted and no new request is entered. The 
        /// deleted run request must have been initiated by a call to CeRunAppAtTime.</param>
        /// <returns>TRUE indicates success. FALSE indicates failure.</returns>
        [DllImport("coredll")]
        internal static extern bool CeRunAppAtTime(string pwszAppName, byte[] lpTime);

        #endregion
    }
}

Code Listing 3 - TimeException.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace Rhinomobile.ClassLibrary
{
    /// <summary>
    /// Represents errors that occur during time methods
    /// </summary>
    public class TimeException : Exception
    {
        #region Constructors

        /// <summary>
        /// Initializes a new instance of the TimeException class.
        /// </summary>
        public TimeException()
            : base()
        {
        }

        /// <summary>
        /// Initializes a new instance of the TimeException class with a specified error message.
        /// </summary>
        /// <param name="message">The message that describes the error.</param>
        public TimeException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of the TimeException class with a specified error 
        /// message and a reference to the inner exception that is the cause of the exception.
        /// </summary>
        /// <param name="message">The message that describes the error.</param>
        /// <param name="innerException">The exception that is 
        /// the cause of the current exception.</param>
        public TimeException(string message, Exception innerException)
            : base(message, innerException)
        {
        }

        #endregion
    }
}

Code Listing 4 - TimeUtilities.cs


#region Using Directives

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

#endregion

namespace Rhinomobile.ClassLibrary
{
    /// <summary>
    /// Methods for performing time based functions
    /// </summary>
    public static class TimeUtilities
    {
        #region Static Public Methods

        /// <summary>
        /// This function sets the current local date and time.
        /// </summary>
        /// <param name="value">The local date and time to set on the device.</param>
        /// <returns>True if date and time are successfully set</returns>
        public static bool SetLocalDeviceTime(DateTime value)
        {
            SystemTime systemTime = new SystemTime(value);
            bool result = NativeTimeMethods.SetLocalTime(ref systemTime);
            if (!result)
            {
                int errorCode = Marshal.GetLastWin32Error();
                throw new TimeException(StandardConstants.ERROR_CODE + errorCode.ToString());
            }
            return result;
        }

        /// <summary>
        /// This function prompts the system to start running a specified application
        /// at a specified time.
        /// </summary>
        /// <param name="application">The name of the application to be run</param>
        /// <param name="value">The date and time when the given application is to be run</param>
        /// <returns>True if the application is properly scheduled</returns>
        public static bool RunApplication(string application, DateTime value)
        {
            SystemTime systemTime = new SystemTime(value);
            bool result = NativeTimeMethods.CeRunAppAtTime(application, ref systemTime);
            if (!result)
            {
                int errorCode = Marshal.GetLastWin32Error();
                throw new TimeException(StandardConstants.ERROR_CODE + errorCode.ToString());
            }
            return result;
        }

        /// <summary>
        /// This method deletes an existing run application request
        /// </summary>
        /// <param name="application">Application which has been requested to run</param>
        /// <returns>True if application is found and request is removed</returns>
        public static bool CancelRunApplication(string application)
        {
            return NativeTimeMethods.CeRunAppAtTime(application, null);
        }

        #endregion
    }
}

What's the Deal: Smart Device Project Ordering in Visual Studio 2005

noreply@blogger.com (Ryan O'Neill) — Sat, 17 Mar 2007 13:32:00 PDT

While creating an application earlier this afternoon for testing a proposed change, I went to create a new Windows Mobile 5.0 Pocket PC application using Visual Studio 2005's New Project dialog. I was curious as to why the entries underneath Visual C#\Smart Device seemed to be in alphabetical order except for Windows Mobile 6 Professional.

The entries were in the following order under Smart Device:

Pocket PC 2003

Windows Mobile 6 Professional

Smartphone 2003

Windows CE 5.0

Windows Mobile 5.0 Pocket PC

Windows Mobile 5.0 Smartphone

Windows Mobile 6 Standard

Image 1 - New Project dialog out of order

After a little bit of digging around in the C:\Program Files\Microsoft Visual Studio 8\ directory, I found a folder structure with the hierarchy of "Common 7\IDE\ProjectTemplates\CSharp\SmartDevice". Inside the SmartDevice folder was a file named TemplateIndex.vstdir and 7 folders:

PocketPC2003

Smartphone2003

Windows Mobile 6 Professional

Windows Mobile 6 Standard

Windows CE

Image 2 - SmartDevice folder structure

I soon noticed that each of the 7 folders had their own TemplateIndex.vstdir files. I did a search on that file and discovered an excellent blog entry entitled "New Project Generation: Under the Hood" by the Visual Studio Documentation Team. It confirmed my suspicions that the SortIndex was what controlled the ordering and also brought to my attention that I needed to start visual Studio using the /installvstemplates command line parameter in order for the changes to take effect.


Entry                          Old Sort Index            New Sort Index
Pocket PC 2003                          1100                      1100
Smartphone 2003                         1110                      1110
Windows CE 5.0                          1120                      1120
Windows Mobile 5.0 Pocket PC            1150                      1130
Windows Mobile 5.0 Smartphone           1160                      1140
Windows Mobile 6 Professional           1100                      1150
Windows Mobile 6 Standard               1100                      1160

After making the changes to the associated TemplateIndex.vstdir files, I ran Visual Studio with the /installvstemplates command line parameter.

Image 3 - Visual Studio started via command line

When Visual Studio finished processing the template files and opened, going to the New Project dialog had things ordered alphabetically underneath SmartDevice:

Pocket PC 2003

Smartphone 2003

Windows CE 5.0

Windows Mobile 5.0 Pocket PC

Windows Mobile 5.0 Smartphone

Windows Mobile 6 Professional

Windows Mobile 6 Standard

Image 4 - New Project dialog in order

Quick Hitter: Navigating Windows Folder via ActiveSync

noreply@blogger.com (Ryan O'Neill) — Fri, 16 Mar 2007 13:10:00 PDT

Annoyed because the \Windows folder can't be viewed when trying to "Explore" a Windows Mobile device using Microsoft ActiveSync? Well, actually it can. Where the setting to change that behavior is though is fairly counterintuitive. In order to be able to see the \Windows folder on a Windows Mobile device, the Windows Explorer folder options of the machine ActiveSync is running on are what need to be changed.

Image 1 - \Windows folder not visible through ActiveSync

On the window displayed in Image 1, from the main menu select Tools-->Folder Options. Switch from the General tab to the View tab located at the top of the Folder Options dialog window. In the "Advanced Settings" area, there will be an option under "Files and Folders" named "Hidden files and folders".

Image 2 - Folder Options dialog with Hidden files and folders highlighted

Change the "Hidden files and folders" value from "Do not show hidden files and folders" to "Show hidden files and folders". Click the "Apply" button and then click the "OK" button to close the dialog window. The explorer window should now display and allow access to the \Windows folder.

Image 3 - \Windows folder visible through ActiveSync

Oops, Activator.CreateInstance with a Singleton

noreply@blogger.com (Ryan O'Neill) — Wed, 07 Mar 2007 08:22:00 PST

The Singleton pattern is one of the most widely used design patterns. The Singleton pattern ensures that exactly one and only one instance of a class is instantiated at any given time. It can also be somewhat confusing because it seems that there are multiple ways of implementing the pattern. In the article "Implementing Singleton in C#", MSDN recommends a slightly different approach for implementation than the Design Patterns classic in order to take advantage of C#'s features.

The Activator class is a useful .NET class for creating types of objects as well as obtaining references to remote objects. On the .NET Compact Framework side, the method which stands out prominently is the CreateInstance method. The .NET Compact Framework supports two overloads of the CreateInstance method. Both methods take a type. One takes a type as a parameter and returns an object. The other takes a type as a generic parameter and returns an object of that specific type.

As part of my current project, there is a navigation component responsible for returning a user to where he or she left off within the application. At the lowest levels, this component is calling Activator.CreateInstance(Type) where Type is a type of form. Everything was working fine until yesterday, when the application would repeatedly blow up anytime it was started. The issue was traced down all the way to the Activator.CreateInstance(Type) method throwing a MissingMethodException.

At first, I could not understand why a MissingMethodException was being thrown. A group of us theorized that maybe it was due to this particular form being in an assembly outside of the executing assembly. I was able to collapse the two assemblies together by adding all the files in the referenced assembly as links to the executing assembly. That did not fix the issue. The MissingMethodException was still occurring.

I decided to step back and verify what I thought was true. I then looked up the particular CreateInstance method on MSDN. It was there that I realized exactly what was happening and why a MissingMethodException was being thrown. Next to MissingMethodException was the explanation of "No matching public constructor was found". At this point it was obvious what was the cause of the issue. The form type being passed to CreateInstance had no public constructor due to the fact that there should only ever be one object of that form instantiated (because it interacts with a native application's window handles). CreateInstance was failing because it had no idea how to create an instance of that type of form.

This is just one of those times where the answer is blatantly obvious once found.

Samsung IP-830W Errors

noreply@blogger.com (Ryan O'Neill) — Tue, 06 Mar 2007 14:05:00 PST

With increasing frequency, I have started to receive some disturbing error messages from my Samsung IP-830w. I thought this would be a good forum to try to keep track of them. This entry will be updated from time to time with new messages I receive. It is not my intent to disparage the name of Sprint nor Samsung, just to point out the interesting messages displayed by this phone.

March 06, 2007 -- CDMAdsatcmdp.c 806 Out of memory DS

April 03, 2007 -- CDMAhdrutil.c 1048 Failed write item to NV HDRMC

May 29, 2007 -- (This is not an error message, but a phone defect.) I changed the phone from ring mode to vibrate mode and left it alone. When I received a new message, the phone started vibrating and would not stop. Switching the phone back to ring mode, playing with settings, sliding the phone open and closed, and even turning the cellular radio on and off would not turn the vibrating off. Pulling down the little switch to turn the screen off did momentarily stop the vibrating. (It resumed immediately when turning the screen back on.) The only way to resolve the issue was to soft reset the phone.

Quick Hitter: Securing the Run Dialog

noreply@blogger.com (Ryan O'Neill) — Sat, 24 Feb 2007 21:04:00 PST

The Windows Mobile taskbar provides users with an ability to run any particular program via the Run dialog. The Run dialog is accessed by pressing the action key (the center button of the directional pad) and tapping and holding (right-clicking) on the clock.

Image 1 - The Run Dialog menu

When writing line of business software which should be the only application the user should run on the device however, it may be necessary to disable the Run dialog as a security precaution. Disabling the Run dialog makes it more difficult for users to bypass the desired functionality. Access to the Run dialog can be disabled by setting a value within the HKEY_LOCAL_MACHINE\Security\Policies\Shell registry key. Inside that key, a value named NoRunDlg needs to be set as a DWORD with a value of 1.

Image 2 - Remote Registry Editor showing NoRunDlg value

Once the NoRunDlg value has been set, the menu showing Run and Clock is still accessible. However, the Run menu option is now disabled (indicated by it being grayed out) preventing users from running applications via that option.

Image 3 - Run Dialog option grayed out

Mobile Spy

noreply@blogger.com (Ryan O'Neill) — Thu, 22 Feb 2007 15:54:00 PST

Many Windows and Windows Mobile developers have at one time used the Microsoft Spy++ or the Microsoft CE Remote Spy tools. The Microsoft Spy++ tool allows a developer to view properties of selected windows, threads, processes, or messages using a graphical tree. Remote Spy displays a list of the windows that are open on a particular device that is connected. In addition to the list of windows, Remote Spy also provides the capability to view properties of a window such as the class, style, extended style, window procedure address, window positioning, and client area window positioning as well as the messages within the message queue for a selected window.

Image 1 - Microsoft CE Remote Spy

Remote Spy is an excellent application which is extremely useful for any mobile developer. What happens though if an individual wants to see the listing of top-level windows currently running on a device and does not have the ability to connect the device to another machine where Remote Spy can be run? Here's a simple application that performs that functionality.

Image 2 - Mobile Spy

This application (which has been named Mobile Spy just to differentiate) shows a listing of all the top level windows running on a device at a particular moment in time. Along side the window handle of the top-level window, Mobile Spy also displays the Window Text, and the Class Name of the class to which a window belongs.

This application uses three P/Invoked methods to retrieve the window handles, the window text, and the window class names:

GetWindow - This function retrieves the handle to a window that has the specified relationship to the specified window.

GetWindowText - This function copies the text of the specified windows title bar—if it has one—into a buffer. If the specified window is a control, the text of the control is copied.

GetClassName - This function retrieves the name of the class to which the specified window belongs.

(Source for all above descriptions comes directly from MSDN)

The application contains a simple button and a simple list view with three columns. The "Refresh" button loads the windows in at a specific point in time. Here is code of the method associated with the click event of the "Refresh" button as well as an associated explanation:


    lvWindows.BeginUpdate();
    lvWindows.Items.Clear();
    IntPtr window = GetWindow(this.Handle, GW_HWNDFIRST);
    StringBuilder className = new StringBuilder(MAX_LENGTH);
    StringBuilder windowText = new StringBuilder(MAX_LENGTH);
    while (window != IntPtr.Zero)
    {                
        int classNameCount = GetClassName(window, className, MAX_LENGTH);
        int windowTextCount = GetWindowText(window, windowText, MAX_LENGTH);
        string windowTextDisplay = NO_NAME;
        if (windowTextCount > 0)
        {
            windowTextDisplay = windowText.ToString();
        }
        string hexWindow = String.Format("{0:X2}", window.ToInt32());
        ListViewItem item = new ListViewItem(new string[] { hexWindow, 
                            windowTextDisplay, className.ToString() });
        lvWindows.Items.Add(item);
        window = GetWindow(window, GW_HWNDNEXT);
    }
    lvWindows.EndUpdate();

The method begins with a call to lvWindows.BeginUpdate() and lvWindows.Items.Clear(). lvWindows is the name of the ListView where the information is displayed. Calling BeginUpdate prevents the control from redrawing until EndUpdate is called. The next call is made to clear the items from the list view. Be cognizant of the difference between calling lvWindows.Clear() and lvWindows.Items.Clear().

The next line is where it starts to get interesting with a call to GetWindow using the window handle of the Mobile Spy application and GW_HWNDFIRST (defined as 0). Using the GW_HWNDFIRST constant retrieves the handle of the window highest in the Z-order. Because GetWindow is passed a top-level window, it retrieves the topmost window in the Z-order.

The application then sets up a while loop and iterates as long as the returned window handle is not zero. If the window handle is not zero, the application retrieves the Class Name and the WindowText using a StringBuilder for each call respectively. The return value of both the GetClassName and GetWindowText functions are the count of characters copied into the StringBuilder passed in. If the window text returned is a length of zero, "<No name>" is used for display purposes (just as in Remote Spy).

A list view item is setup using the window handle, the window text, and the class name. The window handle is slightly modified to be displayed in its hexadecimal notation (just as in Remote Spy). The window text is displayed as explained above and the class name is displayed as returned by the GetClassName function. The list view item is added to the list view.

When the application is done processing for a particular window handle, it attempts to retrieve the next window handle. The next window handle within the Z-order is retrieved via a call to GetWindow using the current window handle and GW_HWNDNEXT (defined as 2). GW_HWNDNEXT retrieves the window below the specified window in the Z-order. If this window handle retrieved is zero, the loop will exit on the next iteration. If this window handle is non-zero, the inner section of the loop will retrieve the window text and the class name and add the information to the list view.
Finally the list view is allowed to resume drawing because of the EndUpdate() method call.

My Mobile Application Travel Experience

noreply@blogger.com (Ryan O'Neill) — Sun, 10 Dec 2006 13:08:00 PST

With a four hour layover last Sunday in Cincinnati (Northern Kentucky to be entirely accurate), I had the opportunity to look at some mobile applications with which I had not previously been acquainted. Here's the rundown:

Handango On Demand: The installation for this application came with my new phone (see earlier post about the Samsung IP-830W). Firstly, and most importantly, the content is actually pretty good. When I landed at my destination in Seattle, I actually used this application to find out what the score was of the Giants vs. Cowboys game.

Unfortunately, the content is the only good thing about the application. The user interface is confusing and non-standard. It is completely understandable if an application follows Windows Mobile User Interface guidelines, executes in full screen mode, or executes in a kiosk like mode. Oddly enough, this application combines all three. It replaces the Windows taskbar, yet still uses soft keys. Button placements are also inconsistent, and it appeared to me that they were trying to trick me into tapping a button to buy something by constantly moving where buttons were placed.

The user interface only scratches the surface though. Before installing this application, I had the .NET Compact Framework 2.0 SP1 installed. Well, Handango On Demand wouldn't install without the original 2.0 version installed. That is just plain embarrassing.

Audible Air: This application works in conjunction with the Audible.com book service. Audible.com provides audio books and program subscriptions for purchase and download in formats that work on portable media players such as ipods. A few years ago (when I had a little bit more free time), I had had a subscription and purchased probably about 20 books. Miraculously, I was able to remember my username and password. After logging in with my information, I was able to see the list of items that I had previously purchased and download them directly to my phone. I chose to download one of them which was very painless (and fast with EV-DO speeds). If the audible team extends the application so that new items can be purchased, I think they might get enough impulse buys from people like me to be worth it. I definitely would have bought a new audio book in that position for my flight to Seattle.

Windows Live Search for Mobile Beta: Wow! I downloaded and installed the cab file for this application while sitting in the airport. Being that I had booked my flight to Seattle less than a week earlier (and thus the reason for my four hour layover), I had somehow neglected to figure out how I was getting from the Seattle-Tacoma airport to my hotel in downtown Seattle. As soon as the plane landed in Seattle and it was taxi-ing to the gate, I whipped out my phone and started Windows Live Search. I was easily able to look up the address and the phone number of my hotel and even see where on the map it was located. I used this information to call them and ask, and once I had decided on taking a taxi I used the map to keep track of the route.

One suggestion I would make for the future is the ability to add looked up information directly to contacts. The other little minor annoyance was that the application is added to the Programs menu with a shortcut name of "Search". On my phone, Sprint had already added one with that name which means that Windows Live Search shows up as "Search (1)". Overall though, this is an amazing application which everyone who can have it installed should have it installed.

Quick Hitter: Blank Form

noreply@blogger.com (Ryan O'Neill) — Sat, 02 Dec 2006 07:30:00 PST

What a difference a function call makes sometimes, right?

Ever start a program, go to a specific form and all the controls that were placed on the form at design time are missing? Well, some way some how, the InitializeComponent method has probably been removed from the form's constructor. The InitializeComponent method is a private void method which is placed inside the "Windows Form Designer generated code" region by Visual Studio. The attached comment even states that it is a "Required method for Designer support - do not modify the contents of this method with the code editor." This method sets all the properties of the form, initializes every control and subsequently adds each one to its parent control. Sometimes people think this is just magic that the controls get added to the form, but it's the InitializeComponent method which is doing all of the heavy lifting. So, if the controls are missing, check to verify that InitializeComponent is being called in the form's constructor.

Performance vs. Readability

noreply@blogger.com (Ryan O'Neill) — Sun, 26 Nov 2006 20:21:00 PST

My pal Rabi recently analyzed Steve McConnell's updated classic Code Complete from a mobile perspective. Personally, I am a huge fan of McConnell's work and credit his books and reading suggestions with tremendously improving my own professional development. However, as Rabi points out, not all suggestions work in all situations.

Among many great points Rabi makes, these two stick out for me:

"So the Compact Framework will pitch code on a per method basis to free memory unlike the full framework."

"Don't have methods just to have more readable code - more code in a method is better"

So how can we as managed (sometimes) mobile developers fight the trade-off of performance vs. readability? Currently, I don't have a good answer. What I do have, however, is a suggestion.

Bring the inline function specifier from C++ to the .NET Compact Framework. MSDN defines inline and __inline as function specifiers that "instruct the compiler to insert a copy of the function body into each place the function is called."

Having the ability to use inline functions would mitigate Rabi's points above. Because code is pitched on a per method basis, the inline code would not be pitched being that the inline code is part of the actual method where it's being used. Additionally, the readability gains from having discrete methods instead of excessively long functions would be there as well.

Another additional benefit would be much easier unit testing. It would be much simpler to unit test these functions by having something like the following:

#if UnitTesting
public int CalculateReturnValue(int param1, int param2, int param3)
#else
private inline int CalculateReturnValue(int param1, int param2, int param3)
#endif
... Continue method definition

Therefore, from a testing and readability standpoint the benefit would be had with these methods looking and acting like methods, and from a performance standpoint the benefit would be had with these methods acting like a part of other methods.

Samsung IP-830W Initial Thoughts

noreply@blogger.com (Ryan O'Neill) — Sun, 26 Nov 2006 18:06:00 PST

Due to the current project I am staffed on for work, I am unable to have a cellphone with a camera within the building. Being a Sprint customer for the last 7 years or so and not having much desire to switch carriers, this left me with very few options for phones. Recently, Sprint finally came out with a Windows Mobile 5 phone without a camera - the Samsung IP-830W. The IP-830W is a dual CDMA/GSM phone (although the GSM portion is only usable with overseas frequencies). I've had the IP-830W for about two weeks now, so here are my initial thoughts.

The Good:

Windows Mobile 5.0 - Being a mobile developer, it's great to finally have a Windows Mobile 5.0 phone.

EV-DO - Major +++ - While stuck late one Monday at work, I was able to nicely stream the Giants on Monday Night Football using Orb.

No Camera - I have always found cellphone cameras to be completely worthless and think it's a bad idea that Microsoft made them be standard on Smartphones.

Slide Down Keyboard - I also can't stand keyboards that slide out to the slide, which is the reason I never bought a PPC 6700. I have found myself using the keyboard more than I thought I would.

Regular and Extended Battery - Included in the box is an extended battery in addition to a standard battery.

Easy Speed Dial Buttons - One of my major gripes with the PPC 6600/6601 was that if the particular number button was not held down perfectly, the speed dial would not activate. The IP-830W is great on this front.

The Bad:

Not Mini-USB - Just great, another cable to carry around in my bag.

On/off Button - I'm not liking the slider on/off button, although this is only a slight negative.

Stick up antenna - It's just annoying to have a phone with an antenna again.

The Ugly:

Unreliable Push Email - I've had problems with the push email constantly updating. I feel like it synchronizes when it feels like. Using AUTD with my PPC 6600 and 6601, this was never an issue.

Previous Windows Mobile Phones:
Hitachi G1000
Audiovox PPC 6600
Audiovox PPC 6601 (Bought when I needed to ditch the phone with the camera)

Here's a comparison photo of my current and previous Windows Mobile phones.
(From left to right: Hitachi G1000, Audiovox PPC 6601, Samsung IP-830W)

System Colors (Part 1)

noreply@blogger.com (Ryan O'Neill) — Sun, 26 Nov 2006 17:10:00 PST

While putting together what hopefully will be a future post, I came across a situation where I needed to know what the red, green, and blue values were for various system colors. On a Windows Mobile device, those values are stored in the Registry. In fact, when a user changes the Today theme via the Today Settings applet, behind the scenes that specific registry value is being changed.

All the information in the following paragraph comes from this entry on MSDN.

System Colors are stored in the SysColor registry value in the HKEY_LOCAL_MACHINE\System\GWE key. GWE is the Graphics, Windows, and Events subsystem. There are 29 different colors which are stored in a blob in the SysColor key. These values control items such as caption background and text colors, button colors, and window and menu colors.

Below is a C# class which allows easy retrieval and access to those System Colors. Part 2 will extend the class to save new values to the System Colors.

These are images of a simple application used to retrieve the system colors and set the foreground color of list view items to the corresponding colors.

Image 1 - Before Retrieving System Colors

Image 2 - After Retrieving System Colors

Image 3 - After Changing to Guava Bubbles Today Theme and Retrieving System Colors


#region Using Directives

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Security;
using System.Text;
using Microsoft.Win32;

#endregion

namespace SystemColors
{
   public static class SystemColors
   {

       #region MSDN Information

       // Taken from "Customizing System Colors" (http://msdn2.microsoft.com/en-us/library/ms906614.aspx)

       //0     COLOR_SCROLLBAR     Color of the gray area of a scroll bar.
       //1     COLOR_BACKGROUND     Background color of the desktop window.
       //2     COLOR_ACTIVECAPTION     Color of the title bar of an active window.
       //3     COLOR_INACTIVECAPTION     Color of the title bar of an inactive window.
       //4     COLOR_MENU     Background color of a menu.
       //5     COLOR_WINDOW     Background color of a window.
       //6     COLOR_WINDOWFRAME     Color of a window frame.
       //7     COLOR_MENUTEXT     Color of the text in a menu.
       //8     COLOR_WINDOWTEXT     Color of the text in a window.
       //9     COLOR_CAPTIONTEXT     Color of the text in a title bar and of the size box and scroll bar arrow box.
       //10     COLOR_ACTIVEBORDER     Color of the border of an active window.
       //11     COLOR_INACTIVEBORDER     Color of the border of an inactive window.
       //12     COLOR_APPWORKSPACE     Background color of multiple document interface (MDI) applications.
       //13     COLOR_HIGHLIGHT     Color of an item selected in a control.
       //14     COLOR_HIGHLIGHTTEXT     Color of the text of an item selected in a control.
       //15     COLOR_BTNFACE     Color of the face of a button.
       //16     COLOR_BTNSHADOW     Shadow color of buttons for edges that face away from the light source.
       //17     COLOR_GRAYTEXT     Color of shaded text. This color is set to 0 if the current display driver does not support a solid gray color.
       //18     COLOR_BTNTEXT     Color of the text for push buttons.
       //19     COLOR_INACTIVECAPTIONTEXT     Color of the text in the title bar of an inactive window.
       //20     COLOR_BTNHIGHLIGHT     Highlight color of buttons for edges that face the light source.
       //21     COLOR_3DDKSHADOW     Color of the dark shadow for three-dimensional display elements.
       //22     COLOR_3DLIGHT     Highlight color of three-dimensional display elements for edges that face the light source.
       //23     COLOR_INFOTEXT     Color of the text for ToolTip controls.
       //24     COLOR_INFOBK     Background color for ToolTip controls.
       //25     COLOR_STATIC     Background color for static controls and dialog boxes. Supported in Windows CE 2.0 and later.
       //26     COLOR_STATICTEXT     Color of the text for static controls. Supported in Windows CE 2.0 and later.
       //27     COLOR_GRADIENTACTIVECAPTION     Color of the title bar of an active window that is filled with a color gradient.
       //28     COLOR_GRADIENTINACTIVECAPTION     Color of the title bar of an inactive window that is filled with a color gradient.

       #endregion

       #region Constants

       private const string SYSTEM_SUBKEY = "SYSTEM";
       private const string GWE_SUBKEY = "GWE";
       private const string SYSTEM_COLORS_KEY = SYSTEM_SUBKEY + SLASH + GWE_SUBKEY;
       private const string SLASH = @"\";
       private const string SYSTEM_COLORS_VALUE = "SysColor";

       private const int SYSTEM_COLORS_BLOB_SIZE = 116;        // 29 (# of values) * 4 (size of DWORD)

       private const int SCROLLBAR_OFFSET = 0;                 //  0 (position) * 4 (size of DWORD)
       private const int BACKGROUND_OFFSET = 4;                //  1 (position) * 4 (size of DWORD)
       private const int ACTIVECAPTION_OFFSET = 8;             //  2 (position) * 4 (size of DWORD)
       private const int INACTIVECAPTION_OFFSET = 12;          //  3 (position) * 4 (size of DWORD)
       private const int MENU_OFFSET = 16;                     //  4 (position) * 4 (size of DWORD)
       private const int WINDOW_OFFSET = 20;                   //  5 (position) * 4 (size of DWORD)
       private const int WINDOWFRAME_OFFSET = 24;              //  6 (position) * 4 (size of DWORD)
       private const int MENUTEXT_OFFSET = 28;                 //  7 (position) * 4 (size of DWORD)
       private const int WINDOWTEXT_OFFSET = 32;               //  8 (position) * 4 (size of DWORD)
       private const int CAPTIONTEXT_OFFSET = 36;              //  9 (position) * 4 (size of DWORD)
       private const int ACTIVEBORDER_OFFSET = 40;             // 10 (position) * 4 (size of DWORD)
       private const int INACTIVEBORDER_OFFSET = 44;           // 11 (position) * 4 (size of DWORD)
       private const int APPWORKSPACE_OFFSET = 48;             // 12 (position) * 4 (size of DWORD)
       private const int HIGHLIGHT_OFFSET = 52;                // 13 (position) * 4 (size of DWORD)
       private const int HIGHLIGHTTEXT_OFFSET = 56;            // 14 (position) * 4 (size of DWORD)
       private const int BTNFACE_OFFSET = 60;                  // 15 (position) * 4 (size of DWORD)
       private const int BTNSHADOW_OFFSET = 64;                // 16 (position) * 4 (size of DWORD)
       private const int GRAYTEXT_OFFSET = 68;                 // 17 (position) * 4 (size of DWORD)
       private const int BTNTEXT_OFFSET = 72;                  // 18 (position) * 4 (size of DWORD)
       private const int INACTIVECAPTIONTEXT_OFFSET = 76;      // 19 (position) * 4 (size of DWORD)
       private const int BTNHIGHLIGHT_OFFSET = 80;             // 20 (position) * 4 (size of DWORD)
       private const int THREEDDKSHADOW_OFFSET = 84;           // 21 (position) * 4 (size of DWORD)
       private const int THREEDLIGHT_OFFSET = 88;              // 22 (position) * 4 (size of DWORD)
       private const int INFOTEXT_OFFSET = 92;                 // 23 (position) * 4 (size of DWORD)
       private const int INFOBK_OFFSET = 96;                   // 24 (position) * 4 (size of DWORD)
       private const int STATIC_OFFSET = 100;                  // 25 (position) * 4 (size of DWORD)
       private const int STATICTEXT_OFFSET = 104;              // 26 (position) * 4 (size of DWORD)
       private const int GRADIENTACTIVECAPTION_OFFSET = 108;   // 27 (position) * 4 (size of DWORD)
       private const int GRADIENTINACTIVECAPTION_OFFSET = 112; // 28 (position) * 4 (size of DWORD)

       #endregion

       #region Static Fields

       private static Color m_scrollbar;
       private static Color m_background;
       private static Color m_activeCaption;
       private static Color m_inactiveCaption;
       private static Color m_menu;
       private static Color m_window;
       private static Color m_windowFrame;
       private static Color m_menuText;
       private static Color m_windowText;
       private static Color m_captionText;
       private static Color m_activeBorder;
       private static Color m_inactiveBorder;
       private static Color m_appWorkspace;
       private static Color m_highlight;
       private static Color m_highlightText;
       private static Color m_buttonFace;
       private static Color m_buttonShadow;
       private static Color m_grayText;
       private static Color m_buttonText;
       private static Color m_inactiveCaptionText;
       private static Color m_buttonHighlight;
       private static Color m_threeDimensionalDarkShadow;
       private static Color m_threeDimensionalLight;
       private static Color m_infoText;
       private static Color m_infoBackground;
       private static Color m_static;
       private static Color m_staticText;
       private static Color m_gradientActiveCaption;
       private static Color m_gradientInactiveCaption;

       #endregion

       #region Private Static Methods

       private static Color ConvertToSystemColor(byte[] values, int offset)
       {
           if (values.Length >= (offset + 4))
           {
               int r = (int)values[offset];
               int g = (int)values[offset + 1];
               int b = (int)values[offset + 2];
               return Color.FromArgb(r, g, b);
           }
           else
           {
               throw new SystemColorsException("Incorrect System Color Values Received");
           }
       }

       private static void ParseSystemColors(byte[] systemColors)
       {
           // Make sure size is proper
           if (systemColors.Length == SYSTEM_COLORS_BLOB_SIZE)
           {
               m_scrollbar = ConvertToSystemColor(systemColors, SCROLLBAR_OFFSET);
               m_background = ConvertToSystemColor(systemColors, BACKGROUND_OFFSET);
               m_activeCaption = ConvertToSystemColor(systemColors, ACTIVECAPTION_OFFSET);
               m_inactiveCaption = ConvertToSystemColor(systemColors, INACTIVECAPTION_OFFSET);
               m_menu = ConvertToSystemColor(systemColors, MENU_OFFSET);
               m_window = ConvertToSystemColor(systemColors, WINDOW_OFFSET);
               m_windowFrame = ConvertToSystemColor(systemColors, WINDOWFRAME_OFFSET);
               m_menuText = ConvertToSystemColor(systemColors, MENUTEXT_OFFSET);
               m_windowText = ConvertToSystemColor(systemColors, WINDOWTEXT_OFFSET);
               m_captionText = ConvertToSystemColor(systemColors, CAPTIONTEXT_OFFSET);
               m_activeBorder = ConvertToSystemColor(systemColors, ACTIVEBORDER_OFFSET);
               m_inactiveBorder = ConvertToSystemColor(systemColors, INACTIVEBORDER_OFFSET);
               m_appWorkspace = ConvertToSystemColor(systemColors, APPWORKSPACE_OFFSET);
               m_highlight = ConvertToSystemColor(systemColors, HIGHLIGHT_OFFSET);
               m_highlightText = ConvertToSystemColor(systemColors, HIGHLIGHTTEXT_OFFSET);
               m_buttonFace = ConvertToSystemColor(systemColors, BTNFACE_OFFSET);
               m_buttonShadow = ConvertToSystemColor(systemColors, BTNSHADOW_OFFSET);
               m_grayText = ConvertToSystemColor(systemColors, GRAYTEXT_OFFSET);
               m_buttonText = ConvertToSystemColor(systemColors, BTNTEXT_OFFSET);
               m_inactiveCaptionText = ConvertToSystemColor(systemColors, INACTIVECAPTIONTEXT_OFFSET);
               m_buttonHighlight = ConvertToSystemColor(systemColors, BTNHIGHLIGHT_OFFSET);
               m_threeDimensionalDarkShadow = ConvertToSystemColor(systemColors, THREEDDKSHADOW_OFFSET);
               m_threeDimensionalLight = ConvertToSystemColor(systemColors, THREEDLIGHT_OFFSET);
               m_infoText = ConvertToSystemColor(systemColors, INFOTEXT_OFFSET);
               m_infoBackground = ConvertToSystemColor(systemColors, INFOBK_OFFSET);
               m_static = ConvertToSystemColor(systemColors, STATIC_OFFSET);
               m_staticText = ConvertToSystemColor(systemColors, STATICTEXT_OFFSET);
               m_gradientActiveCaption = ConvertToSystemColor(systemColors, GRADIENTACTIVECAPTION_OFFSET);
               m_gradientInactiveCaption = ConvertToSystemColor(systemColors, GRADIENTINACTIVECAPTION_OFFSET);
           }
       }

       private static void LoadSystemColors(bool throwExceptions)
       {
           RegistryKey key = null;

           try
           {
               key = Registry.LocalMachine.OpenSubKey(SYSTEM_COLORS_KEY);
               byte[] value = (byte[])key.GetValue(SYSTEM_COLORS_VALUE);
               ParseSystemColors(value);
           }
           catch (UnauthorizedAccessException uae)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(uae.Message, uae);
               }
           }
           catch (IOException ioe)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(ioe.Message, ioe);
               }
           }
           catch (SecurityException se)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(se.Message, se);
               }
           }
           catch (ArgumentNullException ane)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(ane.Message, ane);
               }
           }
           catch (ArgumentException ae)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(ae.Message, ae);
               }
           }
           catch (ObjectDisposedException ode)
           {
               if (throwExceptions)
               {
                   throw new SystemColorsException(ode.Message, ode);
               }
           }
           catch (SystemColorsException sce)
           {
               if (throwExceptions)
               {
                   throw sce;
               }
           }
           finally
           {
               if (key != null)
               {
                   try
                   {
                       key.Close();
                       key = null;
                   }
                   catch (Exception ex)
                   {
                       if (throwExceptions)
                       {
                           throw new SystemColorsException(ex.Message, ex);
                       }
                   }
               }
           }
       }

       #endregion

       #region Public Static Methods

       public static void LoadSystemColors()
       {
           LoadSystemColors(true);
       }

       public static void LoadSystemColorsSilently()
       {
           LoadSystemColors(false);
       }

       public static void SaveSystemColors()
       {
       }

       #endregion

       #region Static Properties

       /// 
       /// Color of the gray area of a scroll bar.
       /// 

       public static Color Scrollbar
       {
           get { return m_scrollbar; }
           set { m_scrollbar = value; }
       }

       /// 
       /// Background color of the desktop window.
       /// 

       public static Color Background
       {
           get { return m_background; }
           set { m_background = value; }
       }

       /// 
       /// Color of the title bar of an active window.
       /// 

       public static Color ActiveCaption
       {
           get { return m_activeCaption; }
           set { m_activeCaption = value; }
       }

       /// 
       /// Color of the title bar of an inactive window.
       /// 

       public static Color InactiveCaption
       {
           get { return m_inactiveCaption; }
           set { m_inactiveCaption = value; }
       }

       /// 
       /// Background color of a menu.
       /// 

       public static Color Menu
       {
           get { return m_menu; }
           set { m_menu = value; }
       }

       /// 
       /// Background color of a window.
       /// 

       public static Color Window
       {
           get { return m_window; }
           set { m_window = value; }
       }

       /// 
       /// Color of a window frame.
       /// 

       public static Color WindowFrame
       {
           get { return m_windowFrame; }
           set { m_windowFrame = value; }
       }

       /// 
       /// Color of the text in a menu.
       /// 

       public static Color MenuText
       {
           get { return m_menuText; }
           set { m_menuText = value; }
       }

       /// 
       /// Color of the text in a window.
       /// 

       public static Color WindowText
       {
           get { return m_windowText; }
           set { m_windowText = value; }
       }

       /// 
       /// Color of the text in a title bar and of the size box and scroll bar arrow box.
       /// 

       public static Color CaptionText
       {
           get { return m_captionText; }
           set { m_captionText = value; }
       }

       /// 
       /// Color of the border of an active window.
       /// 

       public static Color ActiveBorder
       {
           get { return m_activeBorder; }
           set { m_activeBorder = value; }
       }

       /// 
       /// Color of the border of an inactive window.
       /// 

       public static Color InactiveBorder
       {
           get { return m_inactiveBorder; }
           set { m_inactiveBorder = value; }
       }

       /// 
       /// Background color of multiple document interface (MDI) applications.
       /// 

       public static Color AppWorkspace
       {
           get { return m_appWorkspace; }
           set { m_appWorkspace = value; }
       }

       /// 
       /// Color of an item selected in a control.
       /// 

       public static Color Highlight
       {
           get { return m_highlight; }
           set { m_highlight = value; }
       }

       /// 
       /// Color of the text of an item selected in a control.
       /// 

       public static Color HighlightText
       {
           get { return m_highlightText; }
           set { m_highlightText = value; }
       }

       /// 
       /// Color of the face of a button.
       /// 

       public static Color ButtonFace
       {
           get { return m_buttonFace; }
           set { m_buttonFace = value; }
       }

       /// 
       /// Shadow color of buttons for edges that face away from the light source.
       /// 

       public static Color ButtonShadow
       {
           get { return m_buttonShadow; }
           set { m_buttonShadow = value; }
       }

       /// 
       /// Color of shaded text. This color is set to 0 if the current display driver does not support a solid gray color.
       /// 

       public static Color GrayText
       {
           get { return m_grayText; }
           set { m_grayText = value; }
       }

       /// 
       /// Color of the text for push buttons.
       /// 

       public static Color ButtonText
       {
           get { return m_buttonText; }
           set { m_buttonText = value; }
       }

       /// 
       /// Color of the text in the title bar of an inactive window.
       /// 

       public static Color InactiveCaptionText
       {
           get { return m_inactiveCaptionText; }
           set { m_inactiveCaptionText = value; }
       }

       /// 
       /// Highlight color of buttons for edges that face the light source.
       /// 

       public static Color ButtonHighlight
       {
           get { return m_buttonHighlight; }
           set { m_buttonHighlight = value; }
       }

       /// 
       /// Color of the dark shadow for three-dimensional display elements.
       /// 

       public static Color ThreeDimensionalDarkShadow
       {
           get { return m_threeDimensionalDarkShadow; }
           set { m_threeDimensionalDarkShadow = value; }
       }

       /// 
       /// Highlight color of three-dimensional display elements for edges that face the light source.
       /// 

       public static Color ThreeDimensionalLight
       {
           get { return m_threeDimensionalLight; }
           set { m_threeDimensionalLight = value; }
       }

       /// 
       /// Color of the text for ToolTip controls.
       /// 

       public static Color InfoText
       {
           get { return m_infoText; }
           set { m_infoText = value; }
       }

       /// 
       /// Background color for ToolTip controls.
       /// 

       public static Color InfoBackground
       {
           get { return m_infoBackground; }
           set { m_infoBackground = value; }
       }

       /// 
       /// Background color for static controls and dialog boxes. Supported in Windows CE 2.0 and later.
       /// 

       public static Color Static
       {
           get { return m_static; }
           set { m_static = value; }
       }

       /// 
       /// Color of the text for static controls. Supported in Windows CE 2.0 and later.
       /// 

       public static Color StaticText
       {
           get { return m_staticText; }
           set { m_staticText = value; }
       }

       /// 
       /// Color of the title bar of an active window that is filled with a color gradient.
       /// 

       public static Color GradientActiveCaption
       {
           get { return m_gradientActiveCaption; }
           set { m_gradientActiveCaption = value; }
       }

       /// 
       /// Color of the title bar of an inactive window that is filled with a color gradient.
       /// 

       public static Color GradientInactiveCaption
       {
           get { return m_gradientInactiveCaption; }
           set { m_gradientInactiveCaption = value; }
       }                     

       #endregion
   }
}

Programmatically Determine Windows Mobile Processor

noreply@blogger.com (Ryan O'Neill) — Sat, 04 Nov 2006 15:37:00 PST

On a Windows Mobile device, the KernelIoControl function can provide some rather useful information. One such piece of information is related to the processor in the device. Processor information can be retrieved from the device using the IOCTL_PROCESSOR_INFORMATION control code.

Here's how ...

First, some constants:


private const int PROCESSOR_FLOATINGPOINT = 0x00000001;
private const int PROCESSOR_DSP = 0x00000002;
private const int PROCESSOR_16BITINSTRUCTION = 0x00000004;

private const int PROCESSOR_INFORMATION_FUNCTION = 25;
private const int FILE_DEVICE_HAL = 0x00000101;
private const int METHOD_BUFFERED = 0;
private const int FILE_ANY_ACCESS = 0;

private const int PROCESSOR_INFORMATION_SIZE = 576;

At this point, you might be asking yourself where these values came from. All of the values with the exception of the PROCESSOR_INFORMATION_SIZE came from Windows header files. The PROCESSOR_INFORMATION_SIZE value was calculated based on the PROCESSOR_INFO structure which looks like this:

(Source: MSDN)


typedef __PROCESSOR_INFO {
  WORD wVersion; 
  WCHAR szProcessCore[40];
  WORD wCoreRevision;
  WCHAR szProcessorName[40];
  WORD wProcessorRevision;
  WCAHR szCatalogNumber[100]; [sic]
  WCHAR szVendor[100];
  DWORD dwInstructionSet;
  DWORD dwClockSpeed;
} PROCESSOR_INFO, *PPROCESSOR_INFO;

A WORD is analogous to a C# short (Int16 - 2 bytes), and a DWORD is analogous to a C# int (Int32 - 4 bytes). Because the strings are Unicode (denoted by WCHAR or Wide Char), those string byte values double when calculating the true size.
wVersion = 2
szProcessorCore = 80
wCoreRevision = 2
szProcessorName = 80
wProcessorRevision = 2
szCatalogNumber = 200
szVendor = 200
dwInstructionSet = 4
dwClockSpeed = 4

This gives us 2 + 80 + 2 + 80 + 2 + 200 + 200 + 4 + 4 = 574. So why am I using 576 above and not 574? The reason has to do with how structures are word aligned which is beyond the scope of this blog post. Just recognize that 576 is divisible by 4 and 574 isn't.

Next, we define the information necessary to calculate the actual control code from the device type, function, method, and file access:


private int IOCTL_PROCESSOR_INFORMATION = CTL_CODE(FILE_DEVICE_HAL, 
     PROCESSOR_INFORMATION_FUNCTION, METHOD_BUFFERED, FILE_ANY_ACCESS);

private static int CTL_CODE(int DeviceType, int Function, int Method, int Access)
{
     return ((DeviceType) << 16) | ((Access) << 14) | ((Function << 2)) | (Method);
}

Then, we define out P/Invoke functions:


[DllImport("coredll", EntryPoint = "KernelIoControl", SetLastError = true)]
private static extern bool KernelIoControlOutBytes(int dwIoControlCode, IntPtr lpInBuf, int nInBufSize, 
     byte[] lpOutBuf, int nOutBufSize, ref int lpBytesReturned);

[DllImport("coredll")]
private static extern int GetLastError();

Notice I'm using a modified version of KernelIoControl where for the out buffer I am using a byte array. Why? Because it's much easier and cleaner than marshalling structures.

Next, the code to actually retrieve the values:


private void btnGetInfo_Click(object sender, EventArgs e)
{
    int size = PROCESSOR_INFORMATION_SIZE;
    byte[] processorInfo = new byte[size];
    int bytesReturned = 0;
    bool result = KernelIoControlOutBytes(IOCTL_PROCESSOR_INFORMATION, IntPtr.Zero, 0,
        processorInfo, size, ref bytesReturned);
    if (result)
    {
        int version = BitConverter.ToInt16(processorInfo, 0);
        txtProcessorCore.Text = UnicodeEncoding.Unicode.GetString(processorInfo, 2, 80);
        txtCoreRevision.Text = BitConverter.ToInt16(processorInfo, 82).ToString();
        txtProcessorName.Text = UnicodeEncoding.Unicode.GetString(processorInfo, 84, 80);
        txtProcessorRevision.Text = BitConverter.ToInt16(processorInfo, 164).ToString();
        txtCatalogNumber.Text = UnicodeEncoding.Unicode.GetString(processorInfo, 166, 200);
        txtVendor.Text = UnicodeEncoding.Unicode.GetString(processorInfo, 366, 200);
        txtInstructionSet.Text = BitConverter.ToInt32(processorInfo, 568).ToString();
        txtClockSpeed.Text = BitConverter.ToInt32(processorInfo, 572).ToString();
    }
    else
    {
        MessageBox.Show(GetLastError().ToString());
    }
}

Some items to recognize:

BitConverter.ToInt16 is used to get WORD values

BitConverter.ToInt32 is used to get DWORD values

UnicodeEncoding.Unicode.GetString is used to get WCHAR values and that the number of bytes specified is double the number specified in the PROCESSOR_INFO structure

In between the WCHAR value for the vendor and the DWORD for the Instruction Set, there is a two byte gap. This is where our extra 2 bytes which take us from 574 to 576 come into play.

When I ran this on a Pharos GPS 525 device, here are the values I received:
Processor Core: (Empty)
Core Revision: 0
Processor Name: SC32442-300MHz
Processor Revision: 0
Catalog Number: (Empty)
Vendor: Samsung
Instruction Set: 4 (PROCESSOR_16BITINSTRUCTION)
Clock Speed: 305