From 2134c6612403a2fdad98a5c0efcfb43f53d0c153 Mon Sep 17 00:00:00 2001
From: andreja6 <andrejaandjic@hotmail.com>
Date: Sun, 21 Oct 2018 18:25:42 -0700
Subject: [PATCH] Tried to add property grid

---
 G3DTest.vcproj |    8 +
 propertyGrid.c | 4403 ++++++++++++++++++++++++++++++++++++++++++++++++
 propertyGrid.h |  392 +++++
 3 files changed, 4803 insertions(+)
 create mode 100644 propertyGrid.c
 create mode 100644 propertyGrid.h

diff --git a/G3DTest.vcproj b/G3DTest.vcproj
index ce75f8b..64430cf 100644
--- a/G3DTest.vcproj
+++ b/G3DTest.vcproj
@@ -289,6 +289,10 @@
 					/>
 				</FileConfiguration>
 			</File>
+			<File
+				RelativePath=".\propertyGrid.c"
+				>
+			</File>
 			<File
 				RelativePath=".\WindowFunctions.cpp"
 				>
@@ -362,6 +366,10 @@
 				RelativePath=".\IEDispatcher.h"
 				>
 			</File>
+			<File
+				RelativePath=".\propertyGrid.h"
+				>
+			</File>
 			<File
 				RelativePath=".\resource.h"
 				>
diff --git a/propertyGrid.c b/propertyGrid.c
new file mode 100644
index 0000000..af40ebd
--- /dev/null
+++ b/propertyGrid.c
@@ -0,0 +1,4403 @@
+//////////////////////////////////////////////////////////////////////////////
+///
+/// @file propertyGrid.c
+///
+/// @brief A property grid control in Win32 SDK C.
+///
+/// @author David MacDermot
+///
+/// @par Comments:
+///         This source is distributed in the hope that it will be useful,
+///         but WITHOUT ANY WARRANTY; without even the implied warranty of
+///         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+/// 
+/// @date 2-27-16
+/// 
+/// @todo 
+///
+/// @bug 
+///
+//////////////////////////////////////////////////////////////////////////////
+
+//DWM 1.1: Version 1.1 changes labelled thus.
+//DWM 1.2: Version 1.2 changes labelled thus.
+//DWM 1.3: Version 1.3 changes labelled thus.
+//DWM 1.4: Version 1.4 changes labelled thus.
+//DWM 1.5: Version 1.5 changes labelled thus.
+//DWM 1.6: Version 1.6 changes labelled thus.
+//DWM 1.7: Version 1.7 changes labelled thus.
+//DWM 1.8: Version 1.8 changes labelled thus.
+//DWM 1.9: Version 1.9 changes labelled thus.
+
+//DWM 1.9: Suppress POCC Warning "Argument x to 'sscanf' does not match the format string; 
+//          expected 'unsigned char *' but found 'unsigned long'"
+#ifdef __POCC__
+#pragma warn(disable:2234)
+#endif
+
+#ifndef _WIN32_WINNT // Necessary for WM_MOUSEWHEEL support
+#define _WIN32_WINNT 0x0500
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+
+#include <windows.h>
+#include <windowsx.h>
+#include <commctrl.h>
+#include <commdlg.h>
+#include <shlobj.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <tchar.h>
+#include <uxtheme.h>
+#include "propertyGrid.h"
+
+#define ID_LISTBOX 2000   ///<An Id for the Listbox
+#define ID_LISTMAP 2001   ///<An Id for the Listmap
+#define ID_PROPDESC 2002  ///<An Id for the Property description
+#define ID_EDIT 2003      ///<An Id for an editor
+#define ID_BUTTON 2004    ///<An Id for the button
+#define ID_IPEDIT 2005    ///<An Id for an editor
+#define ID_DATE 2006      ///<An Id for an editor
+#define ID_TIME 2007      ///<An Id for an editor
+#define ID_COMBO 2008     ///<An Id for an editor
+#define ID_EDITCOMBO 2009 ///<An Id for an editor
+
+#define WIDTH_PART0 16         ///< Constant
+#define WIDTH_PART2 20         ///< Constant
+#define HEIGHT_DESC 80         ///< Constant
+#define MINIMUM_ITEM_HEIGHT 20 ///< Constant
+
+//DWM 1.2: Converted the following 4 items to constants
+#define SELECT _T("T")         ///< PIT_CHECK select
+#define UNSELECT _T("F")       ///< PIT_CHECK unselect
+#define CHECKED SELECT         ///< PIT_CHECK checked 
+#define UNCHECKED UNSELECT     ///< PIT_CHECK unchecked
+
+//DWM 1.3: Added
+#define WPRC _T("Wprc")
+
+//DWM 1.8: Added
+#define FLATCHECKS 0x01        ///< Draw flat checks flag
+
+/// @name Macroes
+/// @{
+
+/// @def NELEMS(a)
+///
+/// @brief Computes number of elements of an array.
+///
+/// @param a An array.
+#define NELEMS(a) (sizeof(a) / sizeof((a)[0]))
+
+/// @def HEIGHT(rect)
+///
+/// @brief Given a RECT, Computes height.
+///
+/// @param rect A RECT struct.
+#define HEIGHT(rect) ((LONG)(rect.bottom - rect.top))
+
+/// @def WIDTH(rect)
+///
+/// @brief Given a RECT, Computes width.
+///
+/// @param rect A RECT struct.
+#define WIDTH(rect) ((LONG)(rect.right - rect.left))
+
+/// @def MAKE_PRECT(left, top, right, bottom)
+///
+/// @brief Declare an inline rect.
+///
+/// @param left The left coordinate.
+/// @param top The top coordinate.
+/// @param right The right coordinate.
+/// @param bottom The bottom coordinate.
+#define MAKE_PRECT(left, top, right, bottom) \
+    (&(RECT) { (left), (top), (right), (bottom) })
+
+/// @def ListBox_ItemFromPoint(hwndCtl, xPos, yPos)
+///
+/// @brief Gets the zero-based index of the item nearest the specified point
+///         in a list box.
+///
+/// @param hwndCtl The handle of a listbox.
+/// @param xPos The x coordinate of a point. 
+/// @param yPos The y coordinate of a point.
+///
+/// @returns The return value contains the index of the nearest item
+///           in the low-order word.  The high-order word is zero if
+///           the specified point is in the client area of the list box,
+///           or one if it is outside the client area.
+#define ListBox_ItemFromPoint(hwndCtl, xPos, yPos) \
+    (DWORD)SendMessage((hwndCtl),LB_ITEMFROMPOINT, \
+        (WPARAM)0,MAKELPARAM((UINT)(xPos),(UINT)(yPos)))
+
+/// @def Refresh(hwnd)
+///
+/// @brief Refresh a window.
+///
+/// @param hwnd The handle to the window.
+#define Refresh(hwnd) RedrawWindow((hwnd), NULL, NULL, \
+    RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW)
+
+/// @def AllocatedString_Replace(lpszTarget, lpszReplace)
+///
+/// @brief Replace an allocated string.
+///
+/// @param lpszTarget The existing allocated string.
+/// @param lpszReplace The new string.
+#define AllocatedString_Replace(lpszTarget, lpszReplace) \
+    (free((lpszTarget)), (lpszTarget) = NewString(lpszReplace))
+
+/// @}
+
+LPCTSTR g_szClassName = _T("PropGridCtl"); ///< The classname.
+
+/// @brief A nice assortment of custom colors.
+static COLORREF g_CustomColors[] = {
+    0xDCDCDC, 0xCDCDDB, 0xBDBED2, 0xE3C4C3,
+    0xFFE0C0, 0xE0C8AB, 0xD7AFB0, 0xF0BFEB,
+    0xE2A7DA, 0x9697FF, 0xBFBFFF, 0xBBDBFF,
+    0xCBFFFF, 0xBFEFCB, 0xA6DEB3, 0x82D28B
+};
+
+/****************************************************************************/
+//Functions
+static LRESULT CALLBACK Grid_Proc(HWND, UINT, WPARAM, LPARAM);
+static LRESULT CALLBACK ListBox_Proc(HWND, UINT, WPARAM, LPARAM);
+static VOID Grid_NotifyParent(VOID);
+
+/// @brief Default window procedure for the grid and child windows.
+///
+/// @param hwnd Handle of grid or child.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @returns LRESULT depends on message.
+static LRESULT DefProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    //DWM 1.3: Added
+    return CallWindowProc((WNDPROC)GetProp(hwnd, WPRC), hwnd, msg, wParam, lParam);
+}
+
+/// @brief Determine if this is running on XP or lower.
+///
+/// @returns TRUE if OS is XP or earlier.
+static BOOL IsWindowsXPorLower(VOID) {
+    //DWM 1.4: Added
+    OSVERSIONINFO osvi;
+    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    GetVersionEx(&osvi);
+    return osvi.dwMajorVersion < 6;
+}
+
+#pragma region Instance Data
+
+/// @var LISTBOXITEM
+/// @brief An item object
+
+/// @var LPLISTBOXITEM
+/// @brief Pointer to an item
+
+/// @struct tagLISTBOXITEM
+/// @brief This is the data associated with a grid item
+typedef struct tagLISTBOXITEM {
+    LPTSTR lpszCatalog; ///< Catalog (group) name
+    LPTSTR lpszPropName;///< Property (item) name
+    LPTSTR lpszMisc;    ///< Item specific data string
+    LPTSTR lpszPropDesc;///< Property (item) description
+    LPTSTR lpszCurValue;///< Property (item) value
+    INT iItemType;      ///< Property (item) type identifier
+    BOOL fCollapsed;    ///< Catalog (group) collapsed flag
+} LISTBOXITEM , *LPLISTBOXITEM;
+
+/// @var INSTANCEDATA
+/// @brief Data for this instance of the control
+
+/// @var LPINSTANCEDATA
+/// @brief Pointer instance data
+
+/// @struct tagINSTANCEDATA
+/// @brief This is the data associated with an instance of the grid
+typedef struct tagINSTANCEDATA {
+    HINSTANCE hInstance;    ///< Handle to this instance
+    LPLISTBOXITEM lpCurrent;///< Currently selected grid item
+    HWND hwndParent;        ///< Handle of grid's parent
+    HWND hwndToolTip;       ///< ToolTip handle
+    HWND hwndPropDesc;      ///< Description pane handle
+    HWND hwndListBox;       ///< Handle of the visible list box
+    HWND hwndListMap;       ///< Handle of the hidden list box
+    HWND hwndCtl1;          ///< Handle of the primary edit control
+    HWND hwndCtl2;          ///< Handle of the secondary edit control
+    INT iHDivider;          ///< Position of horizontal divider
+    INT iVDivider;          ///< Position of verticle divider
+    INT iDescHeight;        ///< Height of description pane
+    INT iPrevSel;           ///< Index of previously selected item
+    BOOL fXpOrLower;        ///< TRUE is running on Xp or earlier version of OS
+    BOOL fGotFocus;         ///< TRUE while focus resides within property grid
+    BOOL fScrolling;        ///< TRUE while scrolling
+    BOOL fTracking;         ///< TRUE while moving dividers
+    LONG nOldDivX;          ///< Previous divider x position
+    LONG nOldDivY;          ///< Previous divider y position
+    LONG nDivTop;           ///< Horizontal Divider positon limit
+    LONG nDivBtm;           ///< Horizontal Divider positon limit
+    LONG nDivLft;           ///< Vertical Divider positon limit
+    LONG nDivRht;           ///< Vertical Divider positon limit
+} INSTANCEDATA , *LPINSTANCEDATA;
+
+static LPINSTANCEDATA g_lpInst; ///< instance data (this) pointer
+
+/// @brief Get the Instance data associated with this instance.
+///
+/// @param hControl Handle to Current instance.
+/// @param ppInstanceData - Pointer to the address of an INSTANCEDATA struct. 
+///
+/// @returns TRUE if successful
+static BOOL Control_GetInstanceData(HWND hControl, LPINSTANCEDATA * ppInstanceData)
+{
+    *ppInstanceData = (LPINSTANCEDATA)GetProp(hControl, (LPCTSTR)_T("lpInsData"));
+    if (NULL != *ppInstanceData)
+        return TRUE;
+    return FALSE;
+}
+
+/// @brief Allocate the Instance data associated with this instance.
+///
+/// @param hControl Handle to current instance.
+/// @param pInstanceData Pointer to an INSTANCEDATA struct
+///
+/// @returns TRUE if successful
+static BOOL Control_CreateInstanceData(HWND hControl, LPINSTANCEDATA pInstanceData)
+{
+    LPINSTANCEDATA pInst = (LPINSTANCEDATA)malloc(sizeof(INSTANCEDATA));
+    memmove(pInst, pInstanceData, sizeof(INSTANCEDATA));
+    return SetProp(hControl, (LPCTSTR)_T("lpInsData"), pInst);
+}
+
+/// @brief Free the instance data allocation of an instance of the Grid Control.
+///
+/// @param hControl Handle to current instance.
+///
+/// @returns TRUE if successful
+static BOOL Control_FreeInstanceData(HWND hControl)
+{
+    LPINSTANCEDATA pInst;
+    if (Control_GetInstanceData(hControl, &pInst))
+    {
+        free((LPINSTANCEDATA)pInst);
+        RemoveProp(hControl, (LPCTSTR)_T("lpInsData"));
+        return TRUE;
+    }
+    return FALSE;
+}
+
+/// @brief Get Item data associated with a property grid item.
+///
+/// @param hwnd Handle of a listbox.
+/// @param idx The item index.
+///
+/// @returns a listbox item pointer if successful, otherwise NULL
+static LPLISTBOXITEM ListBox_GetItemDataSafe(HWND hwnd, INT idx)
+{
+    LRESULT lres = ListBox_GetItemData(hwnd, idx);
+    // Don't return LB_ERR cast to an item!
+    if (LB_ERR == lres)
+        return NULL;
+    return (LPLISTBOXITEM)lres;
+}
+
+#pragma endregion Instance Data
+
+#pragma region memory management
+
+/// @brief Allocate and store a string.
+///
+/// @param str The string to store.
+///
+/// @returns a Pointer to the allocated string.
+static LPTSTR NewString(LPTSTR str)
+{
+    if(NULL == str || _T('\0') == *str) str = _T("");
+    LPTSTR tmp = (LPTSTR)calloc(_tcslen(str) + 1, sizeof(TCHAR));
+
+    if(NULL == tmp)
+    {
+        return (LPTSTR)calloc(1, sizeof(TCHAR)); 
+    }
+    return _tmemmove(tmp, str, _tcslen(str));
+}
+
+/// @brief Allocate and store a string array (double-null-terminated string).
+///
+/// @param szzStr The double-null-terminated string to store.
+///
+/// @returns a Pointer to the allocated string array.
+static LPTSTR NewStringArray(LPTSTR szzStr)
+{
+    if(NULL == szzStr || _T('\0') == *szzStr) szzStr = _T("");
+
+    //Determine total buffer length
+    INT iLen = 0;
+    //Walk the buffer to find the terminating empty string.
+    for (LPTSTR p = szzStr; *p; (p += _tcslen(p) + 1, iLen = p - szzStr)) ;
+
+    //Allocate for array
+    LPTSTR tmp = (LPTSTR)calloc(iLen + 1, sizeof(TCHAR));
+
+    if(NULL == tmp)
+    {
+        return (LPTSTR)calloc(1, sizeof(TCHAR)); 
+    }
+    return _tmemmove(tmp, szzStr, iLen);
+}
+
+/// @brief Allocate and populate a list box item data structure.
+///
+/// @param szCatalog The catalog this item belongs to.
+/// @param szPropName The item's name.
+/// @param szCurValue The item's current value.
+/// @param szMisc This data varies with item type.
+/// @param szPropDesc The item's description string.
+/// @param iItemType The item type designation.
+///
+/// @returns a Pointer to the allocated list box item.
+static LPLISTBOXITEM NewItem(LPTSTR szCatalog, LPTSTR szPropName, LPTSTR szCurValue, LPTSTR szMisc, LPTSTR szPropDesc, INT iItemType)
+{
+    LPLISTBOXITEM lpItem = (LPLISTBOXITEM)calloc(1, sizeof(LISTBOXITEM));
+
+    lpItem->iItemType = iItemType;
+    lpItem->lpszCatalog = NewString(szCatalog);
+    lpItem->lpszPropName = NewString(szPropName);
+    lpItem->lpszCurValue = NewString(szCurValue);
+
+    if (PIT_COMBO == iItemType || PIT_EDITCOMBO == iItemType)
+        lpItem->lpszMisc = NewStringArray(szMisc);
+    else
+        lpItem->lpszMisc = NewString(szMisc);
+
+    lpItem->lpszPropDesc = NewString(szPropDesc);
+
+    return lpItem;
+}
+
+/// @brief Free a list box item's data structure.
+///
+/// @param lpItem A pointer to a LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID DeleteItem(LPLISTBOXITEM lpItem)
+{
+    free(lpItem->lpszCatalog);
+    free(lpItem->lpszPropName);
+    if(PIT_CHECK != lpItem->iItemType)  //DWM 1.2: Don't attempt to free a constant
+    {
+        free(lpItem->lpszCurValue);
+        free(lpItem->lpszMisc);
+    }
+    free(lpItem->lpszPropDesc);
+    free(lpItem);
+}
+
+/// @brief Handle the WM_DELETEIETM message.
+///
+/// @param hwnd The handle of a list box (in this case the list map).
+/// @param lpDeleteItem A pointer to the delete item struct.
+///
+/// @returns VOID.
+static VOID Grid_OnDeleteItem(HWND hwnd, const DELETEITEMSTRUCT * lpDeleteItem)
+{
+    if (g_lpInst->hwndListMap == lpDeleteItem->hwndItem)
+        DeleteItem((LPLISTBOXITEM)lpDeleteItem->itemData);
+
+    // Catalogs only reside in visible list box
+    if (g_lpInst->hwndListBox == lpDeleteItem->hwndItem)
+    {
+        if(PIT_CATALOG == ((LPLISTBOXITEM)lpDeleteItem->itemData)->iItemType)
+            DeleteItem((LPLISTBOXITEM)lpDeleteItem->itemData);
+    }
+}
+
+#pragma endregion memory management
+
+#pragma region Drawing
+
+/// @brief Pass keyboard focus to parent and refresh grid.
+///
+/// @returns VOID.
+static VOID SetFocusToParent(VOID)
+{
+    SetFocus(g_lpInst->hwndParent);
+}
+
+/// @brief Handle WM_KILLFOCUS in editors.
+///
+/// @param hwnd Handle of the editor.
+/// @param hwndNewFocus Handle of the window that recieved focus.
+///
+/// @returns VOID.
+static VOID Editor_OnKillFocus(HWND hwnd, HWND hwndNewFocus)
+{
+    //DWM 1.3: Added so that grid selection is drawn inactive
+    // when grid doesn't have focus.
+    g_lpInst->fGotFocus =
+        (NULL != hwndNewFocus &&
+        (g_lpInst->hwndListBox  == hwndNewFocus ||
+         g_lpInst->hwndCtl1     == hwndNewFocus || 
+         g_lpInst->hwndCtl2     == hwndNewFocus ||
+         g_lpInst->hwndPropDesc == hwndNewFocus ||
+         g_lpInst->hwndToolTip  == hwndNewFocus));
+
+    if(!g_lpInst->fGotFocus)
+        Refresh(g_lpInst->hwndListBox);
+}
+
+/// @brief Handle WM_KILLFOCUS in listbox.
+///
+/// @param hwnd Handle of the editor.
+/// @param hwndNewFocus Handle of the window that recieved focus.
+///
+/// @returns VOID.
+static VOID ListBox_OnKillFocus(HWND hwnd, HWND hwndNewFocus)
+{
+    if (NULL != g_lpInst->lpCurrent)
+    {
+        if(PIT_CHECK == g_lpInst->lpCurrent->iItemType)//DWM 1.3: Added
+            g_lpInst->lpCurrent->lpszMisc = UNSELECT;
+    }
+    Editor_OnKillFocus(hwnd, hwndNewFocus);
+}
+
+/// @brief Set a control's font to bold or back to normal.
+///
+/// @param hwndCtl The handle of a control.
+/// @param fBold TRUE if bold desired.
+///
+/// @returns HFONT A new font with the desired font weight.
+static HFONT Font_SetBold(HWND hwndCtl, BOOL fBold)
+{
+    HFONT hFont;
+    LOGFONT lf;
+
+    // Get a handle to the control's font object
+    hFont = (HFONT)SendMessage(hwndCtl, WM_GETFONT, 0, 0);
+
+    // Pull the handle into a Logical Font UDT type
+    GetObject(hFont, sizeof(LOGFONT), &lf);
+
+    // Determine if that font should be bold or not
+    if (fBold)
+        lf.lfWeight = FW_BOLD;
+    else
+        lf.lfWeight = FW_NORMAL;
+
+    // Create a new font based off the logical font UDT
+    return CreateFontIndirect(&lf);
+}
+
+/// @brief Draw a filled rectangle of a desired color.
+///
+/// @param hdc A handle to a device context.
+/// @param lprc The address of a RECT structure with drawing coordinates.
+/// @param clr The desired fill color value.
+///
+/// @returns VOID.
+static VOID FillSolidRect(HDC hdc, LPRECT lprc, COLORREF clr)
+{
+    HBRUSH hbrush = CreateSolidBrush(clr);
+    FillRect(hdc, lprc, hbrush);
+    DeleteObject(hbrush);
+}
+
+/// @brief Draw a line.
+///
+/// @param hdc A handle to a device context.
+/// @param x1 From point x-coordinate.
+/// @param y1 From point y-coordinate.
+/// @param x2 To point x-coordinate.
+/// @param y2 To point y-coordinate.
+///
+/// @returns VOID.
+static VOID DrawLine(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2)
+{
+    MoveToEx(hdc, x1, y1, NULL);
+    LineTo(hdc, x2, y2);
+}
+
+/// @brief Draw an inverted line.
+///
+/// @param hdc A handle to a device context.
+/// @param x1 From point x-coordinate.
+/// @param y1 From point y-coordinate.
+/// @param x2 To point x-coordinate.
+/// @param y2 To point y-coordinate.
+///
+/// @returns VOID.
+static VOID InvertLine(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2)
+{
+    INT nOldMode = SetROP2(hdc, R2_NOT);
+    DrawLine(hdc, x1, y1, x2, y2);
+    SetROP2(hdc, nOldMode);
+}
+
+/// @brief Draw specified borders of a rectangle.
+///
+/// @param hdc A handle to a device context.
+/// @param lprc The address of a RECT structure with drawing coordinates.
+/// @param dwBorder specifies which borders to draw.
+/// @param clr The desired line color value.
+///
+/// @returns VOID.
+static VOID DrawBorder(HDC hdc, LPRECT lprc, DWORD dwBorder, COLORREF clr)
+{
+    LOGPEN oLogPen;
+
+    HPEN hOld;
+    GetObject(hOld = SelectObject(hdc, GetStockObject(BLACK_PEN)), sizeof(oLogPen), &oLogPen);
+    oLogPen.lopnColor = clr;
+
+    SelectObject(hdc, CreatePenIndirect(&oLogPen));
+
+    if (dwBorder & BF_LEFT)
+        DrawLine(hdc, lprc->left, lprc->top, lprc->left, lprc->bottom);
+    if (dwBorder & BF_TOP)
+        DrawLine(hdc, lprc->left, lprc->top, lprc->right, lprc->top);
+    if (dwBorder & BF_RIGHT)
+        DrawLine(hdc, lprc->right, lprc->top, lprc->right, lprc->bottom);
+    if (dwBorder & BF_BOTTOM)
+        DrawLine(hdc, lprc->left, lprc->bottom, lprc->right, lprc->bottom);
+
+    DeleteObject(SelectObject(hdc, hOld));
+}
+
+/// @brief Convert string value, Ex: "255 255 255" to RGB COLORREF.
+///
+/// @param src The string to convert.
+///
+/// @returns COLORREF The converted color.
+static COLORREF GetColor(LPTSTR src)
+{
+    INT RVal, GVal, BVal;
+    RVal = GVal = BVal = 0;
+    if (_tcslen(src) > 0)
+        _stscanf(src, _T("%d,%d,%d"), &RVal, &GVal, &BVal);
+
+    return RGB(RVal, GVal, BVal);
+}
+
+/// @brief Handle the WM_PAINT message for most of the edit controls.
+///         Obliterate the control's border to get that integrated flat look.
+///
+/// @param hwnd The control's handle.
+/// @param msg The window message (in this case WM_PAINT).
+/// @param wParam The message WPARAM.
+/// @param lParam The message LPARAM.
+///
+/// @returns BOOL Always TRUE.
+static BOOL Editor_OnPaint(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    HDC hdc = GetWindowDC(hwnd);
+    RECT rect;
+
+    // First let the system do its thing
+    DefProc(hwnd, msg, wParam, lParam);
+
+    // Next obliterate the border
+    GetWindowRect(hwnd, &rect);
+    MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT) & rect.left, 2);
+
+    rect.top += 2;
+    rect.left += 2;
+    DrawBorder(hdc, &rect, BF_RECT, GetSysColor(COLOR_WINDOW));
+
+    rect.top += 1;
+    rect.left += 1;
+    rect.bottom += 1;
+    rect.right += 1;
+    
+    DrawBorder(hdc, &rect, BF_RECT, GetSysColor(COLOR_WINDOW));
+
+    ReleaseDC(hwnd, hdc);
+    return TRUE;
+}
+
+/// @brief Set the colors used to paint controls in WM_CTLCOLORLISTBOX handler.
+///
+/// @param hdc Handle of a device context.
+/// @param TxtColr Desired text color.
+/// @param BkColr Desired back color.
+///
+/// @returns HBRUSH A reusable brush object.
+static HBRUSH SetColor(HDC hdc, COLORREF TxtColr, COLORREF BkColr)
+{
+    static HBRUSH ReUsableBrush;
+    DeleteObject(ReUsableBrush);
+    ReUsableBrush = CreateSolidBrush(BkColr);
+    SetTextColor(hdc, TxtColr);
+    SetBkColor(hdc, BkColr);
+    return ReUsableBrush;
+}
+
+#pragma endregion Drawing
+
+#pragma region ToolTip
+
+/// @brief Create the tool tip object that will display tips for grid items.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the tooltip's parent.
+///
+/// @returns HWND A handle to a tooltip object.
+static HWND CreateToolTip(HINSTANCE hInstance, HWND hwndParent)
+{
+    RECT rect;
+    TOOLINFO ti;
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP;
+    dwExStyle = WS_EX_TOPMOST;
+
+    hwnd = CreateWindowEx(dwExStyle, // ex style
+        TOOLTIPS_CLASS, // class name - defined in commctrl.h
+        NULL,           // dummy text
+        dwStyle,        // style
+        CW_USEDEFAULT,  // x position
+        CW_USEDEFAULT,  // y position
+        CW_USEDEFAULT,  // width
+        CW_USEDEFAULT,  // height
+        hwndParent,     // parent
+        NULL,           // ID
+        hInstance,      // instance
+        NULL);          // no extra data
+
+    if (!hwnd)
+        return NULL;
+
+    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
+
+    GetClientRect(hwndParent, &rect);
+
+    // Initialize members of toolinfo structure
+    ti.cbSize = sizeof(TOOLINFO);
+    ti.uFlags = TTF_SUBCLASS;
+    ti.hwnd = hwndParent;
+    ti.hinst = hInstance;
+    ti.uId = 0;
+    ti.lpszText = _T("");
+    // ToolTip control will cover the entire window
+    ti.rect.left = rect.left;
+    ti.rect.top = rect.top;
+    ti.rect.right = rect.right;
+    ti.rect.bottom = rect.bottom;
+    ToolTip_AddTool(hwnd, &ti);
+
+    return hwnd;
+}
+
+#pragma endregion ToolTip
+
+#pragma region Static
+
+/// @brief Create the static control for the property description pane.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the Property Grid window).
+/// @param id An id tag for this control
+///
+/// @returns HWND A handle to a static control.
+static HWND CreateStatic(HINSTANCE hInstance, HWND hwndParent, INT id)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | SS_LEFT;
+
+    dwExStyle = WS_EX_LEFT | WS_EX_CLIENTEDGE;
+
+    hwnd = CreateWindowEx(dwExStyle,
+        WC_STATIC,
+        NULL,
+        dwStyle,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        hwndParent,
+        (HMENU)id,
+        hInstance,
+        NULL);
+    if (!hwnd)
+        return NULL;
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
+
+    return hwnd;
+}
+
+#pragma endregion Static
+
+#pragma region ListBox and ListMap
+
+/// @brief Create the owner draw listbox for item display.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the Property Grid window).
+/// @param id An id tag for this control
+///
+/// @par Comments:
+///       There is some kind of bug where a listbox created as an
+///       LBS_OWNERDRAWVARIABLE will scroll erratically when the mouse
+///       wheel is used.
+///
+/// @returns HWND A handle to the owner draw listbox control.
+static HWND CreateListBox(HINSTANCE hInstance, HWND hwndParent, INT id)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL |
+                LBS_NOTIFY | LBS_OWNERDRAWFIXED |
+                LBS_NOINTEGRALHEIGHT | LBS_WANTKEYBOARDINPUT;
+
+    dwExStyle = WS_EX_LEFT | WS_EX_RTLREADING | WS_EX_RIGHTSCROLLBAR |
+                WS_EX_CLIENTEDGE;
+    hwnd = CreateWindowEx(dwExStyle,
+        WC_LISTBOX,
+        NULL,
+        dwStyle,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        hwndParent,
+        (HMENU)id,
+        hInstance,
+        NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
+
+    // Subclass listbox and save the old proc
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, ListBox_Proc);
+
+    return hwnd;
+}
+
+/// @brief Create a minimal hidden listbox (the listmap) to store pointers
+///          to all items, including those not displayed.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the Property Grid window).
+/// @param id An id tag for this control
+///
+/// @returns HWND A handle to the hidden listmap control.
+static HWND CreateListMap(HINSTANCE hInstance, HWND hwndParent, INT id)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | LBS_OWNERDRAWFIXED;    // Want WM_DELETEITEM messages
+
+    dwExStyle = 0;
+    hwnd = CreateWindowEx(dwExStyle,
+        WC_LISTBOX,
+        NULL,
+        dwStyle,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        hwndParent,
+        (HMENU)id,
+        hInstance,
+        NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    return hwnd;
+}
+
+#pragma endregion ListBox and ListMap
+
+#pragma region Edit Control
+
+/// @brief Window procedure for the edit control.
+///
+/// @param hEdit Handle of editor.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK Edit_Proc(HWND hEdit, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    HWND hGParent = GetParent(GetParent(hEdit));
+
+    // Note: Instance data is attached to Edit's grandparent
+    Control_GetInstanceData(hGParent, &g_lpInst);
+
+    if (WM_DESTROY == msg)  // Unsubclass the Edit Control
+    {
+        SetWindowLongPtr(hEdit, GWLP_WNDPROC, (DWORD_PTR)GetProp(hEdit, WPRC)); //DWM 1.5: fixed cast
+        RemoveProp(hEdit, WPRC);
+        return 0;
+    }
+    else if (WM_KILLFOCUS == msg)
+    {
+        FORWARD_WM_CHAR(hEdit, VK_RETURN, 0, SNDMSG);//DWM 1.6: force update of grid data
+        Editor_OnKillFocus(hEdit, (HWND)wParam);
+    }
+    else if (WM_PAINT == msg)   // Obliterate border
+    {
+        return Editor_OnPaint(hEdit, msg, wParam, lParam);
+    }
+    else if (WM_MOUSEWHEEL == msg)
+    {
+        FORWARD_WM_CHAR(hEdit, VK_RETURN, 0, SNDMSG);
+    }
+    else if (WM_CHAR == msg && VK_RETURN == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            TCHAR buf[MAX_PATH];
+            Edit_GetText(hEdit, buf, sizeof buf);
+            AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+        }
+        ShowWindow(hEdit, SW_HIDE);
+        SetFocus(g_lpInst->hwndListBox);
+        Grid_NotifyParent();
+        return TRUE;    // handle Enter (NO BELL)
+    }
+    else if (WM_KEYDOWN == msg)
+    {
+        switch (wParam)
+        {
+            case VK_TAB:
+                if (GetKeyState(VK_SHIFT) & 0x8000)
+                {
+                    FORWARD_WM_CHAR(hEdit, VK_RETURN, 0, SNDMSG);
+                }
+                else //DWM 1.3: Added Focus to grid parent
+                {
+                    SetFocusToParent();
+                }
+                return TRUE;
+            case VK_ESCAPE:
+                ShowWindow(hEdit, SW_HIDE);
+                SetFocus(g_lpInst->hwndListBox);
+                return FALSE;
+        }
+    }
+    return DefProc(hEdit, msg, wParam, lParam);
+}
+
+/// @brief Create an Edit control to edit PIT_EDIT fields.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the visible listbox).
+/// @param id An id tag for this control.
+///
+/// @returns HWND A handle to the edit control.
+static HWND CreateEdit(HINSTANCE hInstance, HWND hwndParent, INT id)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | ES_LEFT | ES_AUTOHSCROLL | ES_MULTILINE | ES_WANTRETURN;
+
+    dwExStyle = WS_EX_LEFT | WS_EX_CLIENTEDGE;
+
+    hwnd = CreateWindowEx(dwExStyle, WC_EDIT, TEXT(""), dwStyle, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwndParent, (HMENU)id, hInstance, NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    //DWM 1.4: Added Disable visual styles for this control.
+    SetWindowTheme(hwnd, L" ", L" ");
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0L);
+
+    // Subclass Editor and save the OldProc
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, Edit_Proc);
+
+    return hwnd;
+}
+
+#pragma endregion Edit Control
+
+#pragma region IP Control
+
+/// @brief Window procedure for the ipedit control.
+///
+/// @param hwnd Handle of the ipedit or a child edit control.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @par Comments
+///       The ipedit control wraps four edit control children.
+///       Each child needs to be subclassed in order to handle
+///       keyboard events.  Each edit control posts some notification
+///       to the parent ipedit control and I use this behavior to capture
+///       and subclass these children.  These children are subclassed to
+///       this very procedure and so 'hwnd' could be parent ipedit or one
+///       of the child Edits.  Care then, must be taken to differentiate between
+///       child and parent.  I do this by getting the class name and restricting
+///       the handling of certain messages to one or the other control type.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK IpEdit_Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    static TCHAR buf[MAX_PATH];
+    HWND hGParent = GetParent(GetParent(hwnd));
+
+    // Note: Instance data is attached to ipedit's grandparent
+    //  or the edit field's greatgrandparent
+    GetClassName(hwnd, buf, NELEMS(buf));
+    BOOL fEdit = (0 == _tcsicmp(buf, WC_EDIT));
+
+    if (fEdit)
+        Control_GetInstanceData(GetParent(hGParent), &g_lpInst);
+    else
+        Control_GetInstanceData(hGParent, &g_lpInst);
+
+    HWND hIpEdit = fEdit ? GetParent(hwnd) : hwnd;
+
+    if (WM_DESTROY == msg)  //Unsubclass the ipedit or child edit control
+    {
+        SetWindowLongPtr(hwnd, GWLP_WNDPROC, (DWORD_PTR)GetProp(hwnd, WPRC)); //DWM 1.5: fixed cast
+        RemoveProp(hwnd, WPRC);
+        return 0;
+    }
+    else if (WM_KILLFOCUS == msg)//DWM 1.3: Added
+    {
+        if(fEdit)
+        {
+            // Determine if hwndNewfocus is a child of the IpEdit
+            if(hIpEdit != GetParent((HWND) wParam)) //No, result of mouse click
+            {
+                FORWARD_WM_CHAR(hIpEdit, VK_RETURN, 0, SNDMSG);//DWM 1.6: force update of grid data
+                Editor_OnKillFocus(hIpEdit, (HWND)wParam);
+            }
+        }
+    }
+    else if (WM_CHAR == msg && VK_RETURN == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+			//DWM 1.9: Updated this code to use DWORD and IPADDRESS macroes instead of 4 byte array and cast.
+            DWORD ip;
+            TCHAR buf[MAX_PATH];
+            if (4 == SNDMSG(hIpEdit, IPM_GETADDRESS, 0, (LPARAM) &ip))
+            {
+                _stprintf(buf, MAX_PATH, _T("%d.%d.%d.%d"), FIRST_IPADDRESS(ip), SECOND_IPADDRESS(ip), THIRD_IPADDRESS(ip), FOURTH_IPADDRESS(ip));
+                AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+            }
+        }
+        ShowWindow(hIpEdit, SW_HIDE);
+        SetFocus(g_lpInst->hwndListBox);
+        Grid_NotifyParent();
+        return TRUE;
+    }
+    if (fEdit)  //Handle keyboard events in the child edit controls
+    {
+        if (WM_GETDLGCODE == msg)
+        {
+            return DLGC_WANTALLKEYS;
+        }
+        else if (WM_MOUSEWHEEL == msg)
+        {
+            FORWARD_WM_CHAR(hwnd, VK_RETURN, 0, SNDMSG);
+        }
+        else if (WM_CHAR == msg && VK_TAB == wParam)
+        {
+            HWND hNext;
+            if (GetKeyState(VK_SHIFT) & 0x8000) //Shift tab
+            {
+                hNext = GetWindow(hwnd, GW_HWNDNEXT);
+                if (NULL == hNext) //DWM 1.3: Added Focus to Listbox
+                {
+                    SetFocus(g_lpInst->hwndListBox);
+                    return TRUE;
+                }
+            }
+            else
+            {
+                hNext = GetWindow(hwnd, GW_HWNDPREV);
+                if (NULL == hNext) //DWM 1.3: Added Focus to grid parent
+                {
+                    SetFocusToParent();
+                    Editor_OnKillFocus(hIpEdit, NULL);
+                    return TRUE;
+                }
+            }
+            Edit_SetSel(hNext, 0, -1);
+            SetFocus(hNext);
+            return TRUE;
+        }
+        else if (WM_CHAR == msg && VK_ESCAPE == wParam)
+        {
+            ShowWindow(hIpEdit, SW_HIDE);
+            SetFocus(g_lpInst->hwndListBox);
+            return TRUE;
+        }
+        else if (WM_PASTE == msg)
+            return TRUE;    //Do not allow paste
+    }
+    else    //Handle messages (events) in the parent ipedit control
+    {
+        if (WM_PAINT == msg)    // Obliterate border
+        {
+            return Editor_OnPaint(hwnd, msg, wParam, lParam);
+        }
+        else if (WM_COMMAND == msg)
+        {
+            // Each of the control's edit fields posts notifications on showing,
+            //  the first time they do so we'll grab and subclass them.
+            HWND hwndCtl = GET_WM_COMMAND_HWND(wParam, lParam);
+            {
+                WNDPROC lpfn = (WNDPROC)GetProp(hwndCtl, WPRC);
+                if (NULL == lpfn)
+                {
+                    //Subclass child and save the OldProc
+                    SetProp(hwndCtl, WPRC, (HANDLE)GetWindowLongPtr(hwndCtl, GWLP_WNDPROC));
+                    SubclassWindow(hwndCtl, IpEdit_Proc);
+                }
+            }
+        }
+    }
+    return DefProc(hwnd, msg, wParam, lParam);
+}
+
+/// @brief Create an ipedit control to edit PIT_IP fields.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the visible listbox).
+/// @param id An id tag for this control.
+/// @param lprc A pointer to RECT struct that contains initial size data.
+///
+/// @par Comments
+///      It is not possible to create this control with CW_USEDEFAULT for width
+///      and height.  The control cannot be properly resized once created and
+///      so it is necessary to specify width and height at the time of creation.
+///
+/// @returns HWND A handle to the ipedit control.
+static HWND CreateIpEdit(HINSTANCE hInstance, HWND hwndParent, INT id, LPRECT lprc)
+{
+    INITCOMMONCONTROLSEX cc;
+    cc.dwSize = sizeof(INITCOMMONCONTROLSEX);
+    cc.dwICC = ICC_INTERNET_CLASSES;
+    if (!InitCommonControlsEx(&cc))
+        return NULL;
+
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD;
+
+    dwExStyle = WS_EX_LEFT;
+
+    hwnd = CreateWindowEx(dwExStyle,
+        WC_IPADDRESS,
+        NULL,
+        dwStyle,
+        CW_USEDEFAULT, // x position can be changed after creation
+        CW_USEDEFAULT, // y position can be changed after creation 
+        lprc->right - lprc->left, // width can only be set here
+        lprc->bottom - lprc->top, // height can only be set here
+        hwndParent, (HMENU)id, hInstance, NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0L);
+
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, IpEdit_Proc);
+
+    return hwnd;
+}
+
+#pragma endregion IP Control
+
+#pragma region Button Control
+
+/// @brief Window procedure for the button control.
+///
+/// @param hButton Handle of button control.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK Button_Proc(HWND hButton, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    HWND hGParent = GetParent(GetParent(hButton));
+
+    // Note: Instance data is attached to buttons's grandparent
+    Control_GetInstanceData(hGParent, &g_lpInst);
+
+    if (WM_DESTROY == msg)  // Unsubclass the button control
+    {
+        SetWindowLongPtr(hButton, GWLP_WNDPROC, (DWORD_PTR)GetProp(hButton, WPRC)); //DWM 1.5: fixed cast
+        RemoveProp(hButton, WPRC);
+        return 0;
+    }
+    else if (WM_KILLFOCUS == msg)
+    {
+        ShowWindow(hButton, SW_HIDE);
+        Editor_OnKillFocus(hButton, (HWND) wParam);
+    }
+    else if (WM_MOUSEWHEEL == msg)
+    {
+        FORWARD_WM_KEYDOWN(hButton, VK_ESCAPE, 0, 0, SNDMSG);
+    }
+    else if (WM_GETDLGCODE == msg)
+    {
+        return DLGC_WANTALLKEYS;
+    }
+    else if (WM_KEYUP == msg && VK_RETURN == wParam)
+    {
+        FORWARD_WM_KEYUP(hButton, VK_SPACE, 0, 0, SNDMSG);
+        return TRUE;
+    }
+    else if (WM_KEYDOWN == msg)
+    {
+        switch (wParam)
+        {
+            case VK_RETURN:
+                FORWARD_WM_KEYDOWN(hButton, VK_SPACE, 0, 0, SNDMSG);
+                return TRUE;
+            case VK_TAB:
+                if (GetKeyState(VK_SHIFT) & 0x8000)
+                {
+                    FORWARD_WM_KEYDOWN(hButton, VK_ESCAPE, 0, 0, SNDMSG);
+                }
+                else //DWM 1.3: Added Focus to grid parent
+                {
+                    ShowWindow(hButton, SW_HIDE);
+                    SetFocusToParent();
+                }
+                return FALSE;
+            case VK_ESCAPE:
+            {
+                ShowWindow(hButton, SW_HIDE);
+                SetFocus(g_lpInst->hwndListBox);
+                return FALSE;
+            }
+        }
+    }
+    return DefProc(hButton, msg, wParam, lParam);
+}
+
+/// @brief Create button control to launch dialogs.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the visible listbox).
+/// @param id An id tag for this control.
+///
+/// @returns HWND A handle to the button control.
+static HWND CreateButton(HINSTANCE hInstance, HWND hwndParent, INT id)
+{
+    DWORD dwStyle;
+    HWND hwnd;
+
+    dwStyle = WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON;
+
+    hwnd = CreateWindowEx(0,
+        WC_BUTTON,
+        TEXT("..."),
+        dwStyle,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        hwndParent,
+        (HMENU)id,
+        hInstance,
+        NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    //DWM 1.4: Added Disable visual styles for this control.
+    SetWindowTheme(hwnd, L" ", L" ");
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0L);
+
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, Button_Proc);
+
+    return hwnd;
+}
+
+#pragma endregion Button Control
+
+#pragma region Date Picker
+
+/// @brief Window Procedure for the datepicker control.
+///
+/// @param hDate Handle of the datepicker.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @par Comments
+///       This procedure handles datepicker controls configured either as
+///       date pickers or time pickers for three grid field types PIT_DATE,
+///       PIT_TIME, and PIT_DATETIME.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK DatePicker_Proc(HWND hDate, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    HWND hGParent = GetParent(GetParent(hDate));
+
+    // Note: Instance data is attached to datepicker's grandparent
+    Control_GetInstanceData(hGParent, &g_lpInst);
+
+    if (WM_DESTROY == msg)  // Unsubclass the control
+    {
+        SetWindowLongPtr(hDate, GWLP_WNDPROC, (DWORD_PTR)GetProp(hDate, WPRC)); //DWM 1.5: fixed cast
+        RemoveProp(hDate, WPRC);
+        return 0;
+    }
+    else if (WM_KILLFOCUS == msg) //DWM 1.3: Added this
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            if(PIT_DATETIME == g_lpInst->lpCurrent->iItemType)
+            {
+                HWND hFocus = (HWND)wParam;
+                if(g_lpInst->hwndCtl1 == hFocus ||
+                   g_lpInst->hwndCtl2 == hFocus) // ignore thise two windows
+                    return 0;
+
+                ShowWindow(g_lpInst->hwndCtl2, SW_HIDE);
+            }
+        }
+        FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);//DWM 1.6: force update of grid data
+        Editor_OnKillFocus(hDate, (HWND)wParam);
+    }
+    else if (WM_PAINT == msg) // Obliterate border
+    {
+        //DWM 1.4: Changed this handler
+        if(g_lpInst->fXpOrLower)
+        {
+            return Editor_OnPaint(hDate, msg, wParam, lParam);
+        }
+        else
+        {
+            // First let the system do its thing
+            DefProc(hDate, msg, wParam, lParam);
+
+            // Next obliterate the border
+            HDC hdc = GetWindowDC(hDate);
+            RECT rect;
+
+            GetClientRect(hDate, &rect);
+
+            DrawBorder(hdc, &rect, BF_TOPLEFT, GetSysColor(COLOR_WINDOW));
+            rect.top += 1;
+            rect.left += 1;
+
+			//DWM 1.9: Added
+#ifdef __POCC__
+            rect.bottom -= 2;
+#else
+			rect.bottom += 2;
+#endif
+            DrawBorder(hdc, &rect, BF_RECT, GetSysColor(COLOR_WINDOW));
+
+            ReleaseDC(hDate, hdc);
+
+            return TRUE;
+        }
+    }
+    else if (WM_MOUSEWHEEL == msg)
+    {
+        FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);
+    }
+    else if (WM_GETDLGCODE == msg)
+    {
+        return DLGC_WANTALLKEYS;
+    }
+    else if (WM_CHAR == msg && VK_RETURN == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            switch (g_lpInst->lpCurrent->iItemType)
+            {
+                case PIT_DATE:
+                {
+                    SYSTEMTIME st = {0};
+                    TCHAR buf[MAX_PATH] = {0};
+                    DateTime_GetSystemtime(g_lpInst->hwndCtl1, &st);
+                    GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buf, MAX_PATH);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                }
+                    break;
+                case PIT_TIME:
+                {
+                    SYSTEMTIME st = {0};
+                    TCHAR buf[MAX_PATH] = {0};
+                    DateTime_GetSystemtime(g_lpInst->hwndCtl1, &st);
+                    GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, _T("hh':'mm':'ss tt"), buf, MAX_PATH);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                }
+                    break;
+                case PIT_DATETIME:
+                {
+                    SYSTEMTIME st = {0};
+                    TCHAR buf[MAX_PATH] = {0};
+                    DateTime_GetSystemtime(g_lpInst->hwndCtl1, &st);
+                    GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buf, MAX_PATH);
+                    _tcscat(buf, _T(" "));
+                    DateTime_GetSystemtime(g_lpInst->hwndCtl2, &st);
+                    GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, _T("hh':'mm':'ss tt"), (LPTSTR) (buf + _tcslen(buf)), MAX_PATH - _tcslen(buf));
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                    ShowWindow(g_lpInst->hwndCtl2, SW_HIDE);
+                }
+                    break;
+            }
+        }
+        SetFocus(g_lpInst->hwndListBox);
+        Grid_NotifyParent();
+        return TRUE;    // handle Enter (NO BELL)
+    }
+    else if (WM_CHAR == msg && VK_TAB == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            if (PIT_DATETIME == g_lpInst->lpCurrent->iItemType)
+            {
+                //DWM 1.3: Fixed focus selection
+                HWND hFocus = GetFocus();
+                if(g_lpInst->hwndCtl1 == hFocus)
+                {
+                    if (GetKeyState(VK_SHIFT) & 0x8000)
+                    {
+                        FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);
+                    }
+                    else
+                    {
+                        SetFocus(g_lpInst->hwndCtl2);
+                    }
+                }
+                else if (g_lpInst->hwndCtl2 == hFocus)
+                {
+                    if (GetKeyState(VK_SHIFT) & 0x8000)
+                    {
+                        SetFocus(g_lpInst->hwndCtl1);
+                    }
+                    else
+                    {
+                        FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);
+                        SetFocusToParent();
+                    }
+                }
+            }
+            else
+            {
+                if (GetKeyState(VK_SHIFT) & 0x8000)
+                {
+                    FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);
+                }
+                else
+                {
+                    FORWARD_WM_CHAR(hDate, VK_RETURN, 0, SNDMSG);
+                    SetFocusToParent();
+                }
+            }
+            return TRUE;
+        }
+    }
+    else if (WM_KEYDOWN == msg && VK_ESCAPE == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            switch (g_lpInst->lpCurrent->iItemType)
+            {
+                case PIT_DATE:
+                case PIT_TIME:
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                    break;
+                case PIT_DATETIME:
+                {
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                    ShowWindow(g_lpInst->hwndCtl2, SW_HIDE);
+                }
+                    break;
+            }
+        }
+    }
+    return DefProc(hDate, msg, wParam, lParam);
+}
+
+/// @brief Create datepicker control configured either as a date or time picker.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the visible listbox).
+/// @param id An id tag for this control.
+/// @param fDate TRUE to create a date picker, FALSE for time picker.
+///
+/// @returns HWND A handle to the control.
+static HWND CreateDatePicker(HINSTANCE hInstance, HWND hwndParent, INT id, BOOL fDate)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | (fDate ? DTS_SHORTDATEFORMAT : DTS_TIMEFORMAT);
+
+    dwExStyle = WS_EX_LEFT;
+
+    hwnd = CreateWindowEx(dwExStyle, DATETIMEPICK_CLASS, TEXT(""), dwStyle, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwndParent, (HMENU)id, hInstance, NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    //DWM 1.4: Added Disable visual styles for this control.
+    SetWindowTheme(hwnd, L" ", L" ");
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0L);
+
+    // Subclass date or timepicker and save the old proc
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, DatePicker_Proc);
+
+    return hwnd;
+}
+
+#pragma endregion Date Picker
+
+#pragma region Combo Box
+
+/// @brief Window procedure for the combobox control.
+///
+/// @param hwnd Handle of the combobox or a child edit control.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @par Comments
+///       The combobox control wraps a listbox (drop down) and an edit control
+///       child (if it is an editable list box).  The edit control child needs
+///       to be subclassed in order to handle keyboard events.  Each child control
+///       posts some notification to the parent combobox control and I use this
+///       behavior to capture and subclass the child edit control.  This edit control is
+///       subclassed to this very procedure and so 'hwnd' could be parent combobox or
+///       child edit control.  Care then, must be taken to differentiate between
+///       child and parent.  I do this by getting the class name and restricting
+///       the handling of certain messages to one or the other control type.
+/// @par Warning
+///       The drop down list control of a combobox is not a child of the combobox
+///       it is the child of the desktop so that the list is not clipped by the
+///       combobox's client area.  Do not sub class it to this procedure since
+///       doing so will cause the instance data pointer to be reset to NULL!  The
+///       instance data pointer is attached to the PropertyGrid's window.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK ComboBox_Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    static TCHAR classname[MAX_PATH];
+    HWND hGParent = GetParent(GetParent(hwnd));
+
+    // Note: Instance data is attached to combo's grandparent
+    //  or the edit field's greatgrandparent
+    GetClassName(hwnd, classname, NELEMS(classname));
+    BOOL fEdit = (0 == _tcsicmp(classname, WC_EDIT));
+
+    if (fEdit)
+        Control_GetInstanceData(GetParent(hGParent), &g_lpInst);
+    else
+        Control_GetInstanceData(hGParent, &g_lpInst);
+
+    if (WM_DESTROY == msg)  //Unsubclass the combobox or child edit control
+    {
+        SetWindowLongPtr(hwnd, GWLP_WNDPROC, (DWORD_PTR)GetProp(hwnd, WPRC)); //DWM 1.5: fixed cast
+        RemoveProp(hwnd, WPRC);
+        return 0;
+    }
+    else if (WM_KILLFOCUS == msg)//DWM 1.3: Added
+    {
+        HWND hFocus = (HWND) wParam;
+        if(hwnd != GetParent(hFocus))// not a combobox editor or a combobox
+        {
+            FORWARD_WM_CHAR(hwnd, VK_RETURN, 0, SNDMSG);//DWM 1.6: force update of grid data
+            Editor_OnKillFocus(hwnd, (HWND) wParam);
+        }
+    }
+    else if (WM_PAINT == msg && !fEdit) // Obliterate border (differs from standard method)
+    {
+        // First let the system do its thing
+        DefProc(hwnd, msg, wParam, lParam);
+
+        // Next obliterate the border
+        HDC hdc = GetWindowDC(hwnd);
+        RECT rect;
+
+        GetClientRect(hwnd, &rect);
+
+        DrawBorder(hdc, &rect, BF_TOPLEFT, GetSysColor(COLOR_WINDOW));
+
+        rect.top += 1;
+        rect.left += 1;
+        DrawBorder(hdc, &rect, BF_TOPLEFT, GetSysColor(COLOR_WINDOW));
+
+        ReleaseDC(hwnd, hdc);
+        return TRUE;
+    }
+    else if (WM_GETDLGCODE == msg)
+    {
+        return DLGC_WANTALLKEYS;
+    }
+    else if (WM_COMMAND == msg)
+    {
+        // The editable combo's edit box posts a notification on loading
+        //  the first time it does so we'll grab and subclass it.
+        HWND hwndCtl = GET_WM_COMMAND_HWND(wParam, lParam);
+        {
+            WNDPROC lpfn = (WNDPROC)GetProp(hwndCtl, WPRC);
+            if (NULL == lpfn)
+            {
+                // Do not subclass the drop down list
+                GetClassName(hwndCtl, classname, NELEMS(classname));
+                if (0 == _tcsicmp(classname, WC_EDIT))
+                {
+                    //Subclass edit and save the old proc
+                    SetProp(hwndCtl, WPRC, (HANDLE)GetWindowLongPtr(hwndCtl, GWLP_WNDPROC));
+                    SubclassWindow(hwndCtl, ComboBox_Proc);
+                }
+            }
+        }
+    }
+    else if (WM_CHAR == msg && VK_RETURN == wParam)
+    {
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            GetWindowText(hwnd, classname, sizeof classname);   //Combo or child edit text is the same
+            AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, classname);
+        }
+        if (fEdit)
+            ShowWindow(GetParent(hwnd), SW_HIDE);
+        else
+            ShowWindow(hwnd, SW_HIDE);
+
+        SetFocus(g_lpInst->hwndListBox);
+        Grid_NotifyParent();
+        return TRUE;    // handle Enter (NO BELL)
+    }
+    else if (WM_CHAR == msg && VK_TAB == wParam)
+    {
+        if (GetKeyState(VK_SHIFT) & 0x8000)
+        {
+            FORWARD_WM_CHAR(hwnd, VK_RETURN, 0, SNDMSG);
+        }
+        else //DWM 1.3: Added Focus to grid parent
+        {
+            ShowWindow(fEdit ? GetParent(hwnd) : hwnd, SW_HIDE);
+            SetFocusToParent();
+            Editor_OnKillFocus(hwnd, NULL);
+        }
+        return TRUE;
+    }
+    else if (WM_KEYDOWN == msg && VK_ESCAPE == wParam)
+    {
+        if (fEdit)
+            ShowWindow(GetParent(hwnd), SW_HIDE);
+        else
+            ShowWindow(hwnd, SW_HIDE);
+
+        SetFocus(g_lpInst->hwndListBox);
+        return FALSE;
+    }
+    return DefProc(hwnd, msg, wParam, lParam);
+}
+
+/// @brief Create combobox control configured either as editable or static.
+///
+/// @param hInstance The handle of an instance.
+/// @param hwndParent The handle of the parent (the visible listbox).
+/// @param id An id tag for this control.
+/// @param fEditable TRUE to create an editable combo, FALSE for static.
+///
+/// @returns HWND A handle to the control.
+static HWND CreateCombo(HINSTANCE hInstance, HWND hwndParent, INT id, BOOL fEditable)
+{
+    DWORD dwStyle, dwExStyle;
+    HWND hwnd;
+
+    dwStyle = WS_CHILD | CBS_NOINTEGRALHEIGHT | (fEditable ? CBS_DROPDOWN : CBS_DROPDOWNLIST);
+
+    dwExStyle = WS_EX_LEFT;
+
+    hwnd = CreateWindowEx(dwExStyle,
+        WC_COMBOBOX,
+        NULL,
+        dwStyle,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        hwndParent,
+        (HMENU)id,
+        hInstance,
+        NULL);
+
+    if (!hwnd)
+        return NULL;
+
+    //DWM 1.4: Disable visual styles for the time being since the combo looks bad
+    // in this grid when drawn using the Vista and later styles.
+    SetWindowTheme(hwnd, L" ", L" ");
+
+    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0L);
+
+    SetProp(hwnd, WPRC, (HANDLE)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+    SubclassWindow(hwnd, ComboBox_Proc);
+
+    return hwnd;
+}
+
+#pragma endregion Combo Box
+
+#pragma region choose font
+
+/// @brief Create a string from a property grid font dialog item.
+///
+/// @param lpLogFontItem The address of a PROPGRIDFONTITEM struct.
+/// @param lpszFont The string representation of PROPGRIDFONTITEM elements.
+///
+/// @returns VOID.
+static VOID LogFontItem_FromString(LPPROPGRIDFONTITEM lpLogFontItem, LPTSTR lpszFont)
+{
+    LPLOGFONT lpLf = (LPLOGFONT)lpLogFontItem;
+    _stscanf(lpszFont,
+#ifdef _UNICODE
+        _T( "Height: %d " \
+            "Width: %d " \
+            "Escapement: %d " \
+            "Orientation:  %d " \
+            "Weight: %d " \
+            "Italic: %hhd " \
+            "Underline: %hhd " \
+            "StrikeOut: %hhd " \
+            "CharSet: %hhd " \
+            "OutPrecision: %hhd " \
+            "ClipPrecision: %hhd " \
+            "Quality: %hhd " \
+            "PitchAndFamily: %hhd " \
+            "FaceName: %32l[^\r\n] " \
+            "Color: %d"),
+#else
+        _T( "Height: %d " \
+            "Width: %d " \
+            "Escapement: %d " \
+            "Orientation:  %d " \
+            "Weight: %d " \
+            "Italic: %hhd " \
+            "Underline: %hhd " \
+            "StrikeOut: %hhd " \
+            "CharSet: %hhd " \
+            "OutPrecision: %hhd " \
+            "ClipPrecision: %hhd " \
+            "Quality: %hhd " \
+            "PitchAndFamily: %hhd " \
+            "FaceName: %32[^\r\n] " \
+            "Color: %d"),
+#endif
+        &lpLf->lfHeight,
+        &lpLf->lfWidth,
+        &lpLf->lfEscapement,
+        &lpLf->lfOrientation,
+        &lpLf->lfWeight,
+        &lpLf->lfItalic,
+        &lpLf->lfUnderline,
+        &lpLf->lfStrikeOut,
+        &lpLf->lfCharSet,
+        &lpLf->lfOutPrecision,
+        &lpLf->lfClipPrecision,
+        &lpLf->lfQuality,
+        &lpLf->lfPitchAndFamily,
+        (LPTSTR)&lpLf->lfFaceName,
+        &lpLogFontItem->crFont);
+}
+
+/// @brief Create a string from a property grid font dialog item.
+///
+/// @param lpLogFontItem A pointer to a PROPGRIDFONTITEM.
+///
+/// @returns LPTSTR The string representation of PROPGRIDFONTITEM elements.
+static LPTSTR LogFontItem_ToString(LPPROPGRIDFONTITEM lpLogFontItem)
+{
+    static TCHAR buf[MAX_PATH];
+    _tmemset(buf, (TCHAR)0, MAX_PATH);
+
+    LPLOGFONT lpLf = (LPLOGFONT)lpLogFontItem;
+    _stprintf(buf, MAX_PATH,
+#ifdef _UNICODE
+        _T( "Height: %d\r\n" \
+            "Width: %d\r\n" \
+            "Escapement: %d\r\n" \
+            "Orientation:  %d\r\n" \
+            "Weight: %d\r\n" \
+            "Italic: %d\r\n" \
+            "Underline: %d\r\n" \
+            "StrikeOut: %d\r\n" \
+            "CharSet: %d\r\n" \
+            "OutPrecision: %d\r\n" \
+            "ClipPrecision: %d\r\n" \
+            "Quality: %d\r\n" \
+            "PitchAndFamily: %d\r\n" \
+            "FaceName: %ls\r\n" \
+            "Color: %d"),
+#else
+        _T( "Height: %d\r\n" \
+            "Width: %d\r\n" \
+            "Escapement: %d\r\n" \
+            "Orientation:  %d\r\n" \
+            "Weight: %d\r\n" \
+            "Italic: %d\r\n" \
+            "Underline: %d\r\n" \
+            "StrikeOut: %d\r\n" \
+            "CharSet: %d\r\n" \
+            "OutPrecision: %d\r\n" \
+            "ClipPrecision: %d\r\n" \
+            "Quality: %d\r\n" \
+            "PitchAndFamily: %d\r\n" \
+            "FaceName: %s\r\n" \
+            "Color: %d"),
+#endif
+        lpLf->lfHeight,
+        lpLf->lfWidth,
+        lpLf->lfEscapement,
+        lpLf->lfOrientation,
+        lpLf->lfWeight,
+        lpLf->lfItalic,
+        lpLf->lfUnderline,
+        lpLf->lfStrikeOut,
+        lpLf->lfCharSet,
+        lpLf->lfOutPrecision,
+        lpLf->lfClipPrecision,
+        lpLf->lfQuality,
+        lpLf->lfPitchAndFamily,
+        lpLf->lfFaceName,
+        lpLogFontItem->crFont);
+    return buf;
+}
+
+#pragma endregion choose font
+
+#pragma region browse folder
+
+/// @brief Create a string from a property grid file dialog item.
+///
+/// @param lpPgFdItem The address of a PROPGRIDFDITEM struct.
+/// @param lpszFdItem The string representation of PROPGRIDFDITEM elements.
+///
+/// @returns VOID.
+static VOID FileDialogItem_FromString(LPPROPGRIDFDITEM lpPgFdItem, LPTSTR lpszFdItem)
+{
+    //DWM 1.2: Added method
+    static TCHAR PgFdItem[4][MAX_PATH];
+    memset(PgFdItem, (TCHAR)0, sizeof(PgFdItem));
+
+    _stscanf(lpszFdItem,
+#ifdef _UNICODE
+        _T( "Title: %256l[^\r\n] " \
+            "Path: %256l[^\r\n] " \
+            "Filter: %256l[^\r\n] " \
+            "Default Extension: %3ls"),
+#else
+        _T( "Title: %256[^\r\n] " \
+            "Path: %256[^\r\n] " \
+            "Filter: %256[^\r\n] " \
+            "Default Extension: %3s"),
+#endif
+        (LPTSTR)&PgFdItem[0], (LPTSTR)&PgFdItem[1], (LPTSTR)&PgFdItem[2], (LPTSTR)&PgFdItem[3]);
+
+    for(int i = 0; i < NELEMS(PgFdItem); i++)
+    {
+        if (0 == _tcscmp(_T("?"), PgFdItem[i]))
+        {
+            //Convert back to empty string
+            PgFdItem[i][0] = (TCHAR)0;
+        }
+        else if(2 == i)
+        {
+            //Convert back to double null-terminated string
+            for (LPTSTR ptr = PgFdItem[2]; *ptr; ptr++)
+                if (_T('\t') == *ptr) *ptr = _T('\0');
+        }
+    }
+    lpPgFdItem->lpszDlgTitle = PgFdItem[0];
+    lpPgFdItem->lpszFilePath = PgFdItem[1];
+    lpPgFdItem->lpszFilter = PgFdItem[2];
+    lpPgFdItem->lpszDefExt = PgFdItem[3];
+}
+
+/// @brief Create a string from a property grid file dialog item.
+///
+/// @param lpPgFdItem A pointer to a PROPGRIDFDITEM.
+///
+/// @returns LPTSTR The string representation of PROPGRIDFDITEM elements.
+static LPTSTR FileDialogItem_ToString(LPPROPGRIDFDITEM lpPgFdItem)
+{
+    static TCHAR szBuf[3 * MAX_PATH];
+    _tmemset(szBuf, (TCHAR)0, NELEMS(szBuf));
+
+    TCHAR filter[MAX_PATH] = { 0 };
+
+    //Copy filter string replacing \0 with \t"
+    INT iLen = 0;
+    for (LPTSTR psz = (LPTSTR)lpPgFdItem->lpszFilter,
+          ps = filter, pe = filter + NELEMS(filter) - 1;
+           *psz && ps < pe; psz += iLen + 1)
+    {
+        _tmemmove(ps, psz, (iLen = _tcslen(psz)));
+        ps += iLen;
+        *ps++ = _T('\t');
+    }
+
+    _stprintf(szBuf, NELEMS(szBuf),
+#ifdef _UNICODE
+        _T( "Title: %ls\r\n" \
+            "Path: %ls\r\n" \
+            "Filter: %ls\r\n" \
+            "Default Extension: %3ls"),
+#else
+        _T( "Title: %s\r\n" \
+            "Path: %s\r\n" \
+            "Filter: %s\r\n" \
+            "Default Extension: %3s"),
+#endif
+        0 < _tcslen(lpPgFdItem->lpszDlgTitle) ? lpPgFdItem->lpszDlgTitle : _T("?"), //DWM 1.2: Added default "?"
+        0 < _tcslen(lpPgFdItem->lpszFilePath) ? lpPgFdItem->lpszFilePath : _T("?"), //DWM 1.2: Added default "?"
+        0 < _tcslen(filter) ? filter : _T("?"), //DWM 1.2: Added default "?"
+        0 < _tcslen(lpPgFdItem->lpszDefExt) ? lpPgFdItem->lpszDefExt : _T("?")); //DWM 1.2: Added default "?"
+    return szBuf;
+}
+
+/// @brief Convert a CHAR string to a WCHAR string.
+///
+/// @param dest  Pointer to a buffer that will contain the converted string.
+/// @param ccDest  destination buffer size (number of characters)
+/// @param source  Constant pointer to a source string to be converted to WCHAR.
+///
+/// @returns VOID.
+static VOID CharToWide(LPWSTR dest, INT ccDest, const LPSTR source)
+{
+	//DWM 1.7: Added
+    int i = 0;
+
+    while(source[i] != '\0' && i <= ccDest)
+    {
+        dest[i] = (WCHAR)source[i];
+        ++i;
+    }
+}
+
+/// @brief Convert a path to an item id list object.
+///
+/// @param pszPath The file path string.
+///
+/// @returns LPITEMIDLIST A pointer to an item id list object.
+static LPITEMIDLIST ConvertPathToLpItemIdList(LPTSTR pszPath)
+{
+    LPITEMIDLIST pidl;
+    LPSHELLFOLDER pDesktopFolder;
+    ULONG chEaten;
+    ULONG dwAttributes;
+
+	//DWM 1.7: Added
+#ifdef _UNICODE
+	LPWSTR pwzPath = pszPath;
+#else
+	int iLen = strlen(pszPath);
+	WCHAR pwzPath[iLen + 1];
+	wmemset(pwzPath, (WCHAR)0, NELEMS(pwzPath));
+	CharToWide(pwzPath, NELEMS(pwzPath), pszPath);
+#endif
+
+    if (SUCCEEDED(SHGetDesktopFolder(&pDesktopFolder)))
+    {
+        pDesktopFolder->lpVtbl->ParseDisplayName(pDesktopFolder,
+         NULL, NULL, pwzPath, &chEaten, &pidl, &dwAttributes);
+        pDesktopFolder->lpVtbl->Release(pDesktopFolder);
+    }
+    return pidl;
+}
+
+/// @brief An application-defined callback function used with the
+///         SHBrowseForFolder function.
+///
+/// @param hwnd Handle of the dialog.
+/// @param uMsg Which message?
+/// @param lParam Message parameter.
+/// @param lpData Pointer to message data.
+///
+/// @returns BOOL FALSE.
+static BOOL CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
+{
+    //Buffer for the folder dialog
+    static TCHAR SelectedDir[MAX_PATH];
+
+    switch (uMsg)
+    {
+        case BFFM_INITIALIZED:
+        {
+            // change the selected folder.
+            SNDMSG(hwnd, BFFM_SETSELECTION, TRUE, lpData);
+            break;
+        }
+        case BFFM_SELCHANGED:
+        {
+            // Set the status window to the currently selected path.
+            if (SHGetPathFromIDList((LPITEMIDLIST)lParam, SelectedDir))
+                SNDMSG(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)SelectedDir);
+            break;
+        }
+        default:
+            break;
+    }
+    return FALSE;
+}
+
+/// @brief Show the folder browser dialog to get a directory pathname.
+///
+/// @param hwnd Handle of the dialog's owner.
+/// @param curPath The path of the currently selected folder.
+/// @param title Browser dialog title.
+/// @param rootPath Path location to begin browsing.
+///
+/// @returns BOOL Depends on message.
+static LPTSTR BrowseFolder(HWND hwnd, LPTSTR curPath, LPTSTR title, LPTSTR rootPath)
+{
+    BROWSEINFO bi;
+    static TCHAR szDir[MAX_PATH];
+    LPITEMIDLIST pidl;
+    LPMALLOC pMalloc;
+
+    if (SUCCEEDED(SHGetMalloc(&pMalloc)))
+    {
+        memset(&bi, 0, sizeof(bi));
+        bi.hwndOwner = hwnd;
+        bi.pszDisplayName = 0;
+        bi.lpszTitle = title;
+        bi.pidlRoot = ConvertPathToLpItemIdList(rootPath);
+        bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
+        bi.lpfn = BrowseCallbackProc;
+        bi.lParam = (long)curPath;
+
+        pidl = SHBrowseForFolder(&bi);
+        if (pidl)
+            SHGetPathFromIDList(pidl, szDir);
+        else
+            _tmemset(szDir, (TCHAR)0, MAX_PATH);
+
+        // free memory used
+        pMalloc->lpVtbl->Free(pMalloc, pidl);
+        pMalloc->lpVtbl->Release(pMalloc);
+    }
+    return szDir;
+}
+
+#pragma endregion browse folder
+
+#pragma region list box message handlers
+
+/// @brief Find the catalog item that matches the given catalog name.
+///
+/// @param hwnd Handle of the listbox.
+/// @param indexStart Index to begin search.
+/// @param szCatalog The catalog name.
+///
+/// @returns INT The index of the catalog otherwise LB_ERR.
+static INT ListBox_FindCatalog(HWND hwnd, INT indexStart, LPCTSTR szCatalog)
+{
+    INT ln = _tcslen(szCatalog) + 1;
+    if (ln == 1 || indexStart >= ListBox_GetCount(hwnd))
+        return LB_ERR;
+
+    for (INT i = indexStart < 0 ? 0 : indexStart; i < ListBox_GetCount(hwnd); i++)
+    {
+        LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(hwnd, i);
+        if (NULL != pItem && 0 == _tcsicmp(pItem->lpszCatalog, szCatalog))
+            return i;
+    }
+    return LB_ERR;
+}
+
+/// @brief Given the address of a LISTBOXITEM object of type PIT_CATALOG,
+///         collapse it if it is expanded, or expand it if it is collapsed.
+///
+/// @param pItem Pointer to an LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID ToggleCatalog(LPLISTBOXITEM pItem)
+{
+    if (NULL != pItem && PIT_CATALOG != pItem->iItemType)
+        return;
+
+    pItem->fCollapsed = !pItem->fCollapsed;
+
+    if (pItem->fCollapsed)
+    {
+        for (INT i = ListBox_GetCount(g_lpInst->hwndListBox) - 1; i >= 0; i--)
+        {
+            LPLISTBOXITEM p = (LPLISTBOXITEM)ListBox_GetItemDataSafe(g_lpInst->hwndListBox, i);
+            if (NULL != p && _tcsicmp(p->lpszCatalog, pItem->lpszCatalog) == 0)
+            {
+                if (PIT_CATALOG != p->iItemType)
+                {
+                    ListBox_DeleteString(g_lpInst->hwndListBox, i);
+                }
+            }
+        }
+    }
+    else
+    {
+        INT idx = ListBox_FindCatalog(g_lpInst->hwndListBox, 0, pItem->lpszCatalog);
+        if (LB_ERR != idx)
+        {
+            LPLISTBOXITEM pp;
+            for (INT i = ListBox_GetCount(g_lpInst->hwndListMap) - 1; 0 <= i; i--)
+            {
+                pp = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, i);
+                if (NULL != pp->lpszCatalog)
+                {
+                    if (0 == _tcsicmp(pp->lpszCatalog, pItem->lpszCatalog))
+                    {
+                        if (PIT_CATALOG != pp->iItemType)
+                        {
+                            ListBox_InsertItemData(g_lpInst->hwndListBox, idx + 1, pp);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// @brief Handle the begin scroll event of a listbox.
+///
+/// @param hwnd Handle of a listbox.
+///
+/// @par Comments:
+///       This event is not raised by the listbox but is detected
+///        by indirect means.
+///
+/// @see ListBox_Proc() WM_NCLBUTTONDOWN for details.
+///
+/// @returns VOID.
+static VOID ListBox_OnBeginScroll(HWND hwnd)
+{
+    g_lpInst->fGotFocus = TRUE;//DWM 1:3: Added
+
+    if (NULL == g_lpInst->lpCurrent)
+        return;
+
+    switch (g_lpInst->lpCurrent->iItemType)
+    {
+        case PIT_CHECK:
+            g_lpInst->lpCurrent->lpszMisc = UNSELECT;
+            break;
+        case PIT_STATIC:
+            break;
+        case PIT_DATETIME:
+            ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+            ShowWindow(g_lpInst->hwndCtl2, SW_HIDE);
+            break;
+        default:
+            ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+    }
+}
+
+/// @brief Handle the end scroll event of a listbox.
+///
+/// @param hwnd Handle of a listbox.
+///
+/// @par Comments:
+///       This event is not raised by the listbox but is detected
+///        by indirect means.
+///
+/// @see ListBox_Proc() WM_SETCURSOR for details.
+///
+/// @returns VOID.
+static VOID ListBox_OnEndScroll(HWND hwnd)
+{
+    if (NULL == g_lpInst->lpCurrent)
+        return;
+
+    RECT rect;
+    memset(&rect, 0, sizeof rect);
+
+    //Caculate the grid width
+    ListBox_GetItemRect(hwnd, ListBox_GetCurSel(hwnd), &rect);
+
+    rect.top += 1;
+    rect.left = g_lpInst->iHDivider + 1;
+
+    switch (g_lpInst->lpCurrent->iItemType)
+    {
+        case PIT_CATALOG:
+        case PIT_STATIC:
+            break; //Don't display anything
+        case PIT_CHECK:
+            g_lpInst->lpCurrent->lpszMisc = SELECT;
+            RedrawWindow(hwnd, &rect, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+            break;
+        case PIT_EDIT:
+            if (NULL == g_lpInst->hwndCtl1)
+            {
+                SetFocus(g_lpInst->hwndListBox);
+            }
+            else //Display edit box
+            {
+                MoveWindow(g_lpInst->hwndCtl1, rect.left, rect.top, WIDTH(rect), HEIGHT(rect), TRUE);
+                ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+                SetFocus(g_lpInst->hwndCtl1);
+            }
+            break;
+        case PIT_COMBO:
+        case PIT_EDITCOMBO:
+        case PIT_IP:
+        case PIT_DATE:
+        case PIT_TIME:
+            if (NULL == g_lpInst->hwndCtl1)
+                SetFocus(g_lpInst->hwndListBox);
+            else //Display editable combobox
+            {
+                MoveWindow(g_lpInst->hwndCtl1, rect.left, rect.top, WIDTH(rect), HEIGHT(rect), TRUE);
+                ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+                SetFocus(g_lpInst->hwndCtl1);
+            }
+            break;
+        case PIT_DATETIME:
+            if (NULL == g_lpInst->hwndCtl1 || NULL == g_lpInst->hwndCtl2)
+                SetFocus(g_lpInst->hwndListBox);
+            else //Display date and time
+            {
+                RECT rect0, rect1;
+                rect0 = rect1 = rect;
+                rect0.right = rect0.left + (rect0.right - rect0.left) / 2;
+                rect1.left = rect1.left + (rect1.right - rect1.left) / 2;
+                MoveWindow(g_lpInst->hwndCtl1, rect0.left, rect0.top, WIDTH(rect0), HEIGHT(rect0), TRUE);
+                MoveWindow(g_lpInst->hwndCtl2, rect1.left, rect1.top, WIDTH(rect1), HEIGHT(rect1), TRUE);
+                ShowWindow(g_lpInst->hwndCtl2, SW_SHOW);
+                ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+                SetFocus(g_lpInst->hwndCtl1);
+            }
+            break;
+        default: //Button control
+            if (NULL == g_lpInst->hwndCtl1)
+            {
+                SetFocus(g_lpInst->hwndListBox);
+            }
+            else //Display Button
+            {
+                if (WIDTH(rect) > 19)
+                {
+                    rect.left = rect.right - 19;
+                    rect.right -= 2;
+                }
+
+                rect.top += 2;
+                rect.bottom -= 2;
+
+                MoveWindow(g_lpInst->hwndCtl1, rect.left, rect.top, WIDTH(rect), HEIGHT(rect), TRUE);
+
+                ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+                SetFocus(g_lpInst->hwndCtl1);
+            }
+            break;
+    }
+}
+
+/// @brief Handles WM_LBUTTONDOWN message in the listbox.
+///
+/// @param hwnd  Handle of listbox.
+/// @param fDoubleClick TRUE if this is a double click event.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of click.
+///
+/// @returns VOID.
+static VOID ListBox_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, INT x, INT y, UINT keyFlags)
+{
+    if ((x >= g_lpInst->iHDivider - 5) && (x <= g_lpInst->iHDivider + 5))
+    {
+        //If mouse clicked on divider line, then start resizing
+        SetCursor(LoadCursor(NULL, IDC_SIZEWE));
+
+        RECT rcWindow;
+        GetWindowRect(hwnd, &rcWindow);
+        rcWindow.left += WIDTH_PART0;
+        rcWindow.right -= 10;
+        //Do not let mouse leave the list box boundary
+        ClipCursor(&rcWindow);
+
+        RECT rcClient;
+        GetClientRect(hwnd, &rcClient);
+
+        g_lpInst->fTracking = TRUE;
+        g_lpInst->nDivTop = rcClient.top;
+        g_lpInst->nDivBtm = rcClient.bottom;
+        g_lpInst->nOldDivX = x;
+
+        HDC hdc = GetDC(hwnd);
+        InvertLine(hdc, x, rcClient.top, x, rcClient.bottom);
+        ReleaseDC(hwnd, hdc);
+
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            TCHAR buf[MAX_PATH] = {0};
+
+            switch (g_lpInst->lpCurrent->iItemType)
+            {
+                case PIT_CATALOG:
+                case PIT_STATIC:
+                    break; //Ignore
+                case PIT_CHECK:
+                    g_lpInst->lpCurrent->lpszMisc = UNSELECT; //Prevent toggle
+                    break;
+                case PIT_DATETIME:
+                    //DWM 1.6: force update of grid data
+                    GetWindowText(g_lpInst->hwndCtl2,buf, sizeof buf);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                    ShowWindow(g_lpInst->hwndCtl2, SW_HIDE);
+                // Fall through
+                default:
+                    //DWM 1.6: force update of grid data
+                    GetWindowText(g_lpInst->hwndCtl1,buf, sizeof buf);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                    ShowWindow(g_lpInst->hwndCtl1, SW_HIDE);
+                    break;
+            }
+        }
+
+        //Capture the mouse
+        SetCapture(hwnd);
+    }
+    else
+    {
+        if (fDoubleClick)
+        {
+            INT i = LOWORD(ListBox_ItemFromPoint(hwnd, x, y));
+            LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(hwnd, i);
+            if (NULL != pItem)
+            {
+                if (PIT_CATALOG == pItem->iItemType)
+                    ToggleCatalog(pItem);
+            }
+        }
+        g_lpInst->fTracking = FALSE;
+    }
+}
+
+/// @brief Handles WM_LBUTTONUP message in the listbox.
+///
+/// @param hwnd  Handle of listbox.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of click.
+///
+/// @returns VOID.
+static VOID ListBox_OnLButtonUp(HWND hwnd, INT x, INT y, UINT keyFlags)
+{
+    if (g_lpInst->fTracking)
+    {
+        //If columns were being resized then this indicates
+        // that mouse is up so resizing is done.  Need to redraw
+        // columns to reflect their new widths.
+
+        g_lpInst->fTracking = FALSE;
+        //If mouse was captured then release it
+        if (hwnd == GetCapture())
+            ReleaseCapture();
+
+        ClipCursor(NULL);
+
+        HDC hdc = GetDC(hwnd);
+        InvertLine(hdc, x, g_lpInst->nDivTop, x, g_lpInst->nDivBtm);
+        ReleaseDC(hwnd, hdc);
+
+        //Set the divider position to the new value
+        g_lpInst->iHDivider = x;
+        Refresh(hwnd);
+
+        if (NULL != g_lpInst->lpCurrent)
+        {
+            switch (g_lpInst->lpCurrent->iItemType)
+            {
+                case PIT_CATALOG:
+                case PIT_STATIC:
+                case PIT_CHECK:
+                    break; //Ignore
+                case PIT_DATETIME:
+                    ShowWindow(g_lpInst->hwndCtl2, SW_SHOW);
+                //Fall through
+                default:
+                    ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+                    break;
+            }
+        }
+    }
+    else
+    {
+        INT i = LOWORD(ListBox_ItemFromPoint(hwnd, x, y));
+
+        if (ListBox_GetCurSel(hwnd) != i)
+        {
+            ListBox_SetCurSel(hwnd, i);
+        }
+    }
+    //Update the fields
+    FORWARD_WM_CHAR(g_lpInst->hwndCtl1, VK_RETURN, 0, SNDMSG);
+    FORWARD_WM_CHAR(g_lpInst->hwndCtl2, VK_RETURN, 0, SNDMSG);
+
+    FORWARD_WM_COMMAND(GetParent(hwnd), GetDlgCtrlID(hwnd), hwnd, LBN_SELCHANGE, SNDMSG);
+
+    if (NULL != g_lpInst->lpCurrent)
+    {
+        switch(g_lpInst->lpCurrent->iItemType)//DWM 1.3: Added switch
+        {
+            case PIT_CATALOG:
+            case PIT_STATIC:
+                return;
+            case PIT_CHECK:
+                if(0 == _tcsicmp(g_lpInst->lpCurrent->lpszMisc, SELECT))
+                {
+                    FORWARD_WM_KEYDOWN(hwnd, VK_SPACE, 0, 0, SNDMSG);
+                    break;
+                } // else fallthrough
+            default:
+                    FORWARD_WM_KEYDOWN(hwnd, VK_TAB, 0, 0, SNDMSG); //Focus to editor
+        }
+    }
+}
+
+/// @brief Handles WM_MOUSEMOVE message in the listbox.
+///
+/// @param hwnd  Handle of listbox.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of move.
+///
+/// @returns VOID.
+static VOID ListBox_OnMouseMove(HWND hwnd, INT x, INT y, UINT keyFlags)
+{
+    if (g_lpInst->fTracking)
+    {
+        //Move divider line to the mouse pos. if columns are
+        // currently being resized
+        HDC hdc = GetDC(hwnd);
+        //Remove old divider line
+        InvertLine(hdc, g_lpInst->nOldDivX, g_lpInst->nDivTop, g_lpInst->nOldDivX, g_lpInst->nDivBtm);
+        //Draw new divider line
+        InvertLine(hdc, x, g_lpInst->nDivTop, x, g_lpInst->nDivBtm);
+        ReleaseDC(hwnd, hdc);
+
+        g_lpInst->nOldDivX = x;
+    }
+    else if ((x >= g_lpInst->iHDivider - 5) && (x <= g_lpInst->iHDivider + 5))
+    {
+        //Set the cursor to a sizing cursor if the cursor is over the row divider
+        SetCursor(LoadCursor(NULL, IDC_SIZEWE));
+    }
+    //
+    //Set the tool tip text
+    //
+    if (NULL != g_lpInst->hwndToolTip)
+    {
+        TOOLINFO tiToolInfo;
+        //Allocate a buf for lpszText
+        TCHAR buf[80];
+        TCHAR newText[80] = {0};
+        tiToolInfo.lpszText = buf;
+        tiToolInfo.cbSize = sizeof(TOOLINFO);
+
+        //Populate TOOLINFO with the info for the tool (including old text)
+        ToolTip_EnumTools(g_lpInst->hwndToolTip, 0, &tiToolInfo);
+
+        if ((x >= g_lpInst->iHDivider + 5) && !g_lpInst->fTracking)
+        {
+            INT i = LOWORD(ListBox_ItemFromPoint(hwnd, x, y));
+            LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(hwnd, i);
+            if (NULL != pItem)
+            {
+                switch (pItem->iItemType)
+                {
+                    case PIT_FONT:
+                    {
+                        LPTSTR szFmt;
+                        PROPGRIDFONTITEM pgfi;
+                        LONG PointSize = 0;
+                        LogFontItem_FromString(&pgfi, pItem->lpszCurValue);
+                        HDC hDC = GetDC(hwnd);
+                        PointSize = -MulDiv(pgfi.logFont.lfHeight, 72, GetDeviceCaps(hDC, LOGPIXELSY));
+                        ReleaseDC(hwnd, hDC);
+#ifdef _UNICODE
+                        szFmt = _T("%ls %d");
+#else
+                        szFmt = _T("%s %d");
+#endif
+                        //Replace the text in the buf and update the tool
+                        _stprintf(newText, NELEMS(buf), szFmt, pgfi.logFont.lfFaceName, PointSize);
+                    }
+                        break;
+                    case PIT_CHECK: //Skip this item
+                        break;
+                    default:
+                        //Replace the text in the buf and update the tool
+                        _tcsncpy(newText, pItem->lpszCurValue, NELEMS(newText) - 1);
+                        break;
+                }
+            }
+        }
+        if(0 != _tcsncmp(buf, newText, _tcslen(newText))) //DWM 1.4: Do not update unless text changed to reduce flicker
+        {
+            //Clear out old text
+            _tmemset(buf, (TCHAR)0, NELEMS(buf)-1);
+            //Replace the text in the buf and update the tool
+            _tcsncpy(buf, newText, NELEMS(buf) - 1);
+            ToolTip_UpdateTipText(g_lpInst->hwndToolTip, &tiToolInfo);
+        }
+    }
+}
+
+/// @brief Handle the selection of a listbox item of type PIT_EDIT.
+///
+/// @param hwnd The handle of the listbox.
+/// @param rc RECT containing desired coordinates for the edit control.
+/// @param pItem Pointer to a LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID ListBox_OnSelectEdit(HWND hwnd, RECT rc, LPLISTBOXITEM pItem)
+{
+    rc.top += 1;
+
+    //display edit box
+    if (NULL == g_lpInst->hwndCtl1)
+        g_lpInst->hwndCtl1 = CreateEdit(g_lpInst->hInstance, hwnd, ID_EDIT);
+
+    MoveWindow(g_lpInst->hwndCtl1, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+    //Set the text in the edit box to the property's current value
+    Edit_SetText(g_lpInst->hwndCtl1, pItem->lpszCurValue);
+    ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+    SetFocus(g_lpInst->hwndCtl1);
+    Edit_SetSel(g_lpInst->hwndCtl1, 0, -1);
+}
+
+/// @brief Handle the selection of a listbox item of type PIT_IP.
+///
+/// @param hwnd The handle of the listbox.
+/// @param rc RECT containing desired coordinates for the ipedit control.
+/// @param pItem Pointer to a LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID ListBox_OnSelectIP(HWND hwnd, RECT rc, LPLISTBOXITEM pItem)
+{
+    rc.top += 1;
+
+    if (NULL == g_lpInst->hwndCtl1)
+        g_lpInst->hwndCtl1 = CreateIpEdit(g_lpInst->hInstance, hwnd, ID_IPEDIT, &rc);
+
+    MoveWindow(g_lpInst->hwndCtl1, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+	//DWM 1.9: Updated this code to use DWORD array and MAKEIPADDRESS macroe instead of 4 byte array and cast.
+	//DWM 1.9: This was necessary to support MSVC _stscanf (sscanf - swscanf) beahavior which expects DWORD arguments.
+    DWORD ip[4] = { 0, 0, 0, 0 };
+    _stscanf(pItem->lpszCurValue, _T("%hhu.%hhu.%hhu.%hhu"), &ip[0], &ip[1], &ip[2], &ip[3]);
+
+    SNDMSG(g_lpInst->hwndCtl1, IPM_SETADDRESS, 0, MAKEIPADDRESS(ip[0],ip[1],ip[2],ip[3]));
+
+    ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+
+    SetFocus(g_lpInst->hwndCtl1);
+}
+
+/// @brief Handle the selection of a listbox item of the following types:
+///         PIT_COLOR, PIT_FONT, PIT_FILE, and PIT_FOLDER.
+///
+/// @param hwnd The handle of the listbox.
+/// @param rc RECT containing desired coordinates for the button control.
+///
+/// @returns VOID.
+static VOID ListBox_OnDisplayButton(HWND hwnd, RECT rc)
+{
+    if (WIDTH(rc) > 19)
+    {
+        rc.left = rc.right - 19;
+        rc.right -= 2;
+    }
+
+    rc.top += 2;
+    rc.bottom -= 2;
+
+    if (NULL == g_lpInst->hwndCtl1)
+        g_lpInst->hwndCtl1 = CreateButton(g_lpInst->hInstance, hwnd, ID_BUTTON);
+
+    MoveWindow(g_lpInst->hwndCtl1, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+    ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+    SetFocus(g_lpInst->hwndCtl1);
+}
+
+/// @brief Handle the selection of a listbox item of the following types:
+///         PIT_DATE, PIT_TIME, and PIT_DATETIME.
+///
+/// @param hwnd The handle of the listbox.
+/// @param rc RECT containing desired coordinates for the date or timepicker control(s).
+/// @param pItem Pointer to a LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID ListBox_OnSelectDateTime(HWND hwnd, RECT rc, LPLISTBOXITEM pItem)
+{
+    rc.top += 1;
+
+    LPTSTR szFormat;
+    TCHAR buf[3];
+    _tmemset(buf, (TCHAR)0, 3);
+
+    SYSTEMTIME st;
+    memset(&st, 0, sizeof(SYSTEMTIME));
+
+    if (PIT_DATE == pItem->iItemType)
+    {
+        if (NULL == g_lpInst->hwndCtl1)
+            g_lpInst->hwndCtl1 = CreateDatePicker(g_lpInst->hInstance, hwnd, ID_DATE, TRUE);
+
+        MoveWindow(g_lpInst->hwndCtl1, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+        if (NULL != pItem)
+            _stscanf(pItem->lpszCurValue, _T("%hd/%hd/%hd"), &st.wMonth, &st.wDay, &st.wYear);
+
+        DateTime_SetSystemtime(g_lpInst->hwndCtl1, GDT_VALID, &st);
+
+        ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+        SetFocus(g_lpInst->hwndCtl1);
+    }
+    else if (PIT_TIME == pItem->iItemType)
+    {
+        if (NULL == g_lpInst->hwndCtl1)
+            g_lpInst->hwndCtl1 = CreateDatePicker(g_lpInst->hInstance, hwnd, ID_TIME, FALSE);
+
+        MoveWindow(g_lpInst->hwndCtl1, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+#ifdef _UNICODE
+        szFormat = _T("%hd:%hd:%hd %2ls");
+#else
+        szFormat = _T("%hd:%hd:%hd %2s");
+#endif
+
+        if (NULL != pItem)
+        {
+            //DWM 1.6: Initialize unused date portion so DTP doesn't default to current date time
+            GetLocalTime(&st);
+            _stscanf(pItem->lpszCurValue, szFormat, &st.wHour, &st.wMinute, &st.wSecond, &buf);
+        }
+        if ((0 == _tcsicmp(_T("PM"), buf)) && st.wHour != 12)//DWM 1.6:Added st.wHour != 12
+            st.wHour += 12;
+
+        DateTime_SetSystemtime(g_lpInst->hwndCtl1, GDT_VALID, &st);
+
+        ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+        SetFocus(g_lpInst->hwndCtl1);
+    }
+    else if (PIT_DATETIME == pItem->iItemType)
+    {
+        RECT rect0, rect1;
+        rect0 = rect1 = rc;
+        rect0.right = rect0.left + (rect0.right - rect0.left) / 2;
+        rect1.left = rect1.left + (rect1.right - rect1.left) / 2;
+
+        if (NULL == g_lpInst->hwndCtl1)
+            g_lpInst->hwndCtl1 = CreateDatePicker(g_lpInst->hInstance, hwnd, ID_DATE, TRUE);
+
+        MoveWindow(g_lpInst->hwndCtl1, rect0.left, rect0.top, WIDTH(rect0), HEIGHT(rect0), TRUE);
+
+        if (NULL == g_lpInst->hwndCtl2)
+            g_lpInst->hwndCtl2 = CreateDatePicker(g_lpInst->hInstance, hwnd, ID_TIME, FALSE);
+
+        MoveWindow(g_lpInst->hwndCtl2, rect1.left, rect1.top, WIDTH(rect1), HEIGHT(rect1), TRUE);
+
+#ifdef _UNICODE
+        szFormat = _T("%hd/%hd/%hd %hd:%hd:%hd %2ls");
+#else
+        szFormat = _T("%hd/%hd/%hd %hd:%hd:%hd %2s");
+#endif
+
+        if (NULL != pItem)
+            _stscanf(pItem->lpszCurValue, szFormat, &st.wMonth, &st.wDay, &st.wYear, &st.wHour, &st.wMinute, &st.wSecond, &buf);
+
+        if ((0 == _tcsicmp(_T("PM"), buf)) && st.wHour != 12)//DWM 1.6:Added st.wHour != 12
+            st.wHour += 12;
+
+        DateTime_SetSystemtime(g_lpInst->hwndCtl1, GDT_VALID, &st);
+        DateTime_SetSystemtime(g_lpInst->hwndCtl2, GDT_VALID, &st);
+
+        ShowWindow(g_lpInst->hwndCtl1, SW_SHOW);
+        ShowWindow(g_lpInst->hwndCtl2, SW_SHOW);
+        SetFocus(g_lpInst->hwndCtl1);
+    }
+}
+
+/// @brief Handle the selection of a listbox item of the following types:
+///         PIT_COMBO, and PIT_EDITCOMBO.
+///
+/// @param hwnd The handle of the listbox.
+/// @param rc RECT containing desired coordinates for the combobox control.
+/// @param pItem Pointer to a LISTBOXITEM object.
+///
+/// @returns VOID.
+static VOID ListBox_OnSelectComboBox(HWND hwnd, RECT rc, LPLISTBOXITEM pItem)
+{
+    HWND hCombo;
+
+    rc.top += 1;
+    rc.bottom += 100;
+
+    if (PIT_COMBO == pItem->iItemType)
+    {
+        if (NULL == g_lpInst->hwndCtl1)
+            g_lpInst->hwndCtl1 = CreateCombo(g_lpInst->hInstance, hwnd, ID_COMBO, FALSE);
+
+        hCombo = g_lpInst->hwndCtl1;
+    }
+    else //PIT_EDITCOMBO
+    {
+        if (NULL == g_lpInst->hwndCtl1)
+            g_lpInst->hwndCtl1 = CreateCombo(g_lpInst->hInstance, hwnd, ID_EDITCOMBO, TRUE);
+
+        hCombo = g_lpInst->hwndCtl1;
+    }
+    ComboBox_ResetContent(hCombo);
+    MoveWindow(hCombo, rc.left, rc.top, WIDTH(rc), HEIGHT(rc), TRUE);
+
+    //Walk the item list and add each string until the empty string
+    for (LPTSTR p = pItem->lpszMisc; *p; p += _tcslen(p) + 1)
+    {
+        if (CB_ERR == ComboBox_FindStringExact(hCombo, 0, p))
+            ComboBox_AddString(hCombo, p);
+    }
+
+    ShowWindow(hCombo, SW_SHOW);
+    SetFocus(hCombo);
+
+    //Jump to the property's current value in the combo box
+    INT itm = ComboBox_FindStringExact(hCombo, 0, pItem->lpszCurValue);
+    if (itm != CB_ERR)
+        ComboBox_SetCurSel(hCombo, itm);
+    else
+    {
+        ComboBox_SetCurSel(hCombo, 0);
+        ComboBox_SetText(hCombo, pItem->lpszCurValue);
+        ComboBox_SetEditSel(hCombo, 0, -1);
+    }
+}
+
+/// @brief Handles WM_KEYDOWN messages sent to the listbox.
+///
+/// @param hwnd  Handle of the listbox.
+/// @param vk The virtual key code.
+/// @param fDown TRUE for keydown (always TRUE).
+/// @param cRepeat The number of times the keystroke is repeated
+///         as a result of the user holding down the key.
+/// @param flags Indicate OEM scan codes etc.
+///
+/// @returns VOID.
+static VOID ListBox_OnKeyDown(HWND hwnd, UINT vk, BOOL fDown, INT cRepeat, UINT flags)
+{
+    BOOL fHandled = FALSE;
+
+    if (NULL != g_lpInst->lpCurrent)
+    {
+        RECT rc;
+        memset(&rc, 0, sizeof rc);
+        ListBox_GetItemRect(hwnd, ListBox_GetCurSel(hwnd), &rc);
+
+        if (PIT_CATALOG == g_lpInst->lpCurrent->iItemType)
+        {
+            if (VK_RIGHT == vk && g_lpInst->lpCurrent->fCollapsed || VK_LEFT == vk && !g_lpInst->lpCurrent->fCollapsed)
+            {
+                ToggleCatalog(g_lpInst->lpCurrent);
+                fHandled = TRUE;
+            }
+        }
+        if (PIT_CHECK == g_lpInst->lpCurrent->iItemType && (VK_SPACE == vk || VK_RETURN == vk))
+        {
+            if (0 == _tcsicmp(g_lpInst->lpCurrent->lpszMisc, SELECT))
+            {
+                g_lpInst->lpCurrent->lpszCurValue = (0 == _tcsicmp(g_lpInst->lpCurrent->lpszCurValue, CHECKED) ? UNCHECKED : CHECKED);
+                RedrawWindow(hwnd, &rc, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+                Grid_NotifyParent(); //DWM 1.2: Notify of check change
+            }
+        }
+        else if (PIT_CHECK == g_lpInst->lpCurrent->iItemType && VK_ESCAPE == vk)
+        {
+            g_lpInst->lpCurrent->lpszMisc = UNSELECT;
+            RedrawWindow(hwnd, &rc, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+        }
+        else if (PIT_CHECK == g_lpInst->lpCurrent->iItemType &&
+                VK_LEFT <= vk && vk <= VK_DOWN &&
+                0 == _tcsicmp(g_lpInst->lpCurrent->lpszMisc, SELECT))
+        {
+            fHandled = TRUE;
+        }
+        else
+        {
+            if (VK_TAB == vk)
+            {
+                if (PIT_COLOR == g_lpInst->lpCurrent->iItemType)
+                {
+                    rc.left = g_lpInst->iHDivider + 1 + WIDTH_PART2;
+                }
+                else
+                {
+                    rc.left = g_lpInst->iHDivider + 1;
+                }
+                switch (g_lpInst->lpCurrent->iItemType)
+                {
+                    case PIT_CATALOG: //Ignore this
+                    case PIT_STATIC:
+                        SetFocusToParent(); //DWM 1.3: Added
+                        break;
+                    case PIT_EDIT:
+                        ListBox_OnSelectEdit(hwnd, rc, g_lpInst->lpCurrent);
+                        break;
+                    case PIT_COMBO:
+                    case PIT_EDITCOMBO:
+                        ListBox_OnSelectComboBox(hwnd, rc, g_lpInst->lpCurrent);
+                        break;
+                    case PIT_IP:
+                        ListBox_OnSelectIP(hwnd, rc, g_lpInst->lpCurrent);
+                        break;
+                    case PIT_CHECK:
+                        if(GetKeyState(VK_SHIFT) & 0x8000)
+                        {
+                            FORWARD_WM_KEYDOWN(hwnd, VK_ESCAPE, cRepeat, flags, SNDMSG);
+                        }
+                        else if(0 == _tcsicmp(g_lpInst->lpCurrent->lpszMisc, SELECT))
+                        {
+                            g_lpInst->lpCurrent->lpszMisc = UNSELECT;
+                            SetFocusToParent();
+                        }
+                        else
+                        {
+                            g_lpInst->lpCurrent->lpszMisc = SELECT;
+                        }
+                        RedrawWindow(hwnd, &rc, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+                        break;
+                    case PIT_DATE:
+                    case PIT_TIME:
+                    case PIT_DATETIME:
+                        ListBox_OnSelectDateTime(hwnd, rc, g_lpInst->lpCurrent);
+                        break;
+                    default:
+                        ListBox_OnDisplayButton(hwnd, rc);
+                        break;
+                }
+            }
+            else if (VK_PRIOR == vk) //Mimic behavior of VS propGrid
+            {
+                FORWARD_WM_KEYDOWN(hwnd, VK_HOME, cRepeat, flags, SNDMSG);
+                fHandled = TRUE;
+            }
+            else if (VK_NEXT == vk) //Mimic behavior of VS propGrid
+            {
+                FORWARD_WM_KEYDOWN(hwnd, VK_END, cRepeat, flags, SNDMSG);
+                fHandled = TRUE;
+            }
+        }
+    }
+    if (!fHandled) //Not fully handled so follow up with default handler
+        FORWARD_WM_KEYDOWN(hwnd, vk, cRepeat, flags, DefProc);
+}
+
+/// @brief Handles WM_COMMAND messages sent to the listbox.
+///
+/// @param hwnd  Handle of listbox.
+/// @param id The id of the sender.
+/// @param hwndCtl The hwnd of the sender.
+/// @param codeNotify The notification code sent.
+///
+/// @par Comments:
+///       We are only concerned with handling button click notifications here.
+///       These notifications originate when the button is clicked for items of
+///        type PIT_COLOR, PIT_FONT, PIT_FILE, and PIT_FOLDER.
+///
+/// @returns VOID.
+static VOID ListBox_OnCommand(HWND hwnd, INT id, HWND hwndCtl, UINT codeNotify)
+{
+    if (ID_BUTTON == id)
+    {
+        if (NULL == g_lpInst->lpCurrent)
+            return;
+
+        //Display the appropriate common dialog depending on what type
+        // of chooser is associated with the property
+        switch (g_lpInst->lpCurrent->iItemType)
+        {
+            case PIT_COLOR:
+            {
+                CHOOSECOLOR cc;
+                memset(&cc, 0, sizeof(cc));
+                cc.lStructSize = sizeof(cc);
+                cc.hwndOwner = hwnd;
+                cc.hInstance = (HWND)g_lpInst->hInstance;
+                cc.rgbResult = GetColor(g_lpInst->lpCurrent->lpszCurValue);
+                cc.lpCustColors = (LPDWORD)g_CustomColors;
+                cc.Flags = CC_FULLOPEN | CC_RGBINIT;
+                if (ChooseColor(&cc))
+                {
+                    TCHAR buf[MAX_PATH];
+                    _stprintf(buf, MAX_PATH, _T("%d,%d,%d"), GetRValue(cc.rgbResult), GetGValue(cc.rgbResult), GetBValue(cc.rgbResult));
+
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, buf);
+                }
+            }
+                break;
+
+            case PIT_FILE:
+            {
+                TCHAR title[MAX_PATH] = { 0 };
+                TCHAR filename[MAX_PATH] = { 0 };
+                TCHAR path[MAX_PATH] = { 0 };
+                TCHAR filter[MAX_PATH] = { 0 };
+                TCHAR ext[4] = { 0 };
+
+                OPENFILENAME ofn;
+                memset(&ofn, 0, sizeof(OPENFILENAME));
+
+                ofn.lStructSize = sizeof(OPENFILENAME);
+                ofn.hwndOwner = hwnd;
+                ofn.hInstance = g_lpInst->hInstance;
+
+                _stscanf(g_lpInst->lpCurrent->lpszMisc,
+#ifdef _UNICODE
+                    _T( "Title: %32l[^\r\n] " \
+                        "Path: %256l[^\r\n] " \
+                        "Filter: %256l[^\r\n] " \
+                        "Default Extension: %3l[^\r\n] "),
+#else
+                    _T( "Title: %32[^\r\n] " \
+                        "Path: %256[^\r\n] " \
+                        "Filter: %256[^\r\n] " \
+                        "Default Extension: %3[^\r\n]"),
+#endif
+                    (LPTSTR)&title, (LPTSTR)&path, (LPTSTR)&filter, (LPTSTR)&ext);
+
+                if (0 != _tcscmp(_T("?"), title)) //DWM 1.2: Added test
+                    ofn.lpstrTitle = title;
+                else
+                    ofn.lpstrTitle = _T("Select file");
+
+                if (0 != _tcscmp(_T("?"), path)) //DWM 1.2: Added test
+                {
+                    //Exclude the filename
+                    for (LPTSTR ptr = path + _tcslen(path) - 1; *ptr; ptr--)
+                        if (*ptr == _T('\\'))
+                        {
+                            *ptr = _T('\0');
+                            break;
+                        }
+                    ofn.lpstrInitialDir = path;
+                }
+
+                if (0 != _tcscmp(_T("?"), filter)) //DWM 1.2: Added test
+                {
+                    //Convert back to double null-terminated string
+                    for (LPTSTR ptr = filter; *ptr; ptr++)
+                        if (_T('\t') == *ptr)
+                            *ptr = _T('\0');
+
+                    ofn.lpstrFilter = filter;
+                }
+                else
+                    ofn.lpstrFilter = _T("All Files (*.*)\0*.*\0");
+
+                if (0 != _tcscmp(_T("?"), ext)) //DWM 1.2: Added test
+                {
+                    ofn.lpstrDefExt = ext;
+                }
+                else
+                {
+                    ofn.lpstrDefExt = _T("txt");
+                }
+                ofn.lpstrFile = filename;
+                ofn.nMaxFile = MAX_PATH;
+                ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
+
+                if (GetOpenFileName(&ofn))
+                {
+                    PROPGRIDFDITEM pgi;
+                    pgi.lpszDlgTitle = (LPTSTR)ofn.lpstrTitle;
+                    pgi.lpszFilePath = (LPTSTR)ofn.lpstrFile;
+                    pgi.lpszFilter = (LPTSTR)ofn.lpstrFilter;
+                    pgi.lpszDefExt = (LPTSTR)ofn.lpstrDefExt;
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, pgi.lpszFilePath);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszMisc, FileDialogItem_ToString(&pgi));
+                }
+                else //DWM 1.2: Reset to unselected file
+                {
+                    PROPGRIDFDITEM pgi;
+                    pgi.lpszDlgTitle = (LPTSTR)ofn.lpstrTitle;
+                    pgi.lpszFilePath = _T("");
+                    pgi.lpszFilter = (LPTSTR)ofn.lpstrFilter;
+                    pgi.lpszDefExt = (LPTSTR)ofn.lpstrDefExt;
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, pgi.lpszFilePath);
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszMisc, FileDialogItem_ToString(&pgi));
+                }
+
+            }
+                break;
+
+            case PIT_FONT:
+            {
+                CHOOSEFONT ocf;
+                memset(&ocf, 0, sizeof(ocf));
+
+                PROPGRIDFONTITEM pgfi;
+                LogFontItem_FromString(&pgfi, g_lpInst->lpCurrent->lpszCurValue);
+
+                ocf.lStructSize = sizeof(ocf);
+                ocf.hwndOwner = hwnd;
+                ocf.hInstance = g_lpInst->hInstance;
+                ocf.Flags = CF_INITTOLOGFONTSTRUCT | CF_EFFECTS | CF_SCREENFONTS;
+                ocf.lpLogFont = &pgfi.logFont;
+                ocf.rgbColors = pgfi.crFont;
+
+                if (ChooseFont(&ocf))
+                {
+                    pgfi.crFont = ocf.rgbColors;
+                    AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, LogFontItem_ToString(&pgfi));
+                }
+            }
+                break;
+
+            case PIT_FOLDER:
+            {
+                LPTSTR temp = BrowseFolder(hwnd, g_lpInst->lpCurrent->lpszCurValue, _T(""), _T(""));
+                //DWM 1.2: Reset to unselected folder //if (0 < _tcslen(temp))
+                AllocatedString_Replace(g_lpInst->lpCurrent->lpszCurValue, temp);
+            }
+                break;
+        }
+        ShowWindow(hwndCtl, SW_HIDE);
+        SetFocus(hwnd);
+        Refresh(hwnd); //Trigger WM_DRAWITEM
+        Grid_NotifyParent();
+    }
+}
+
+#pragma endregion list box message handlers
+
+#pragma region grid message handlers
+
+/// @brief Handles WM_SIZE message.
+///
+/// @param hwnd  Handle of grid.
+/// @param state Specifies the type of resizing requested.
+/// @param cx The width of client area.
+/// @param cy The height of client area.
+///
+/// @returns VOID.
+static VOID Grid_OnSize(HWND hwnd, UINT state, INT cx, INT cy)
+{
+    g_lpInst->iVDivider = cy - g_lpInst->iDescHeight;
+
+    if (NULL != g_lpInst->hwndPropDesc)
+    {
+        //Size listbox component
+        SetWindowPos(g_lpInst->hwndListBox, NULL, 0, 0, cx,
+            g_lpInst->iVDivider - 2, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+
+        SetWindowPos(g_lpInst->hwndPropDesc, NULL, 0, g_lpInst->iVDivider,
+            cx, g_lpInst->iDescHeight, SWP_NOZORDER | SWP_NOACTIVATE);
+    }
+    else
+    {
+        //Size listbox component to fill parent
+        SetWindowPos(g_lpInst->hwndListBox, NULL, 0, 0, cx, cy,
+            SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+    }
+    if(NULL != g_lpInst->hwndToolTip)//Resize ToolTips
+    {
+        TOOLINFO ti = { sizeof(ti) };
+        ti.hwnd = g_lpInst->hwndListBox;
+        ti.uId = 0;
+        GetClientRect(hwnd, &ti.rect);
+        ToolTip_NewToolRect(g_lpInst->hwndToolTip, &ti);
+    }
+    if (NULL != g_lpInst->lpCurrent)
+    {
+        if(PIT_CHECK == g_lpInst->lpCurrent->iItemType)
+            g_lpInst->lpCurrent->lpszMisc = UNSELECT; //Prevent toggle
+    }
+
+    FORWARD_WM_COMMAND(hwnd, GetDlgCtrlID(g_lpInst->hwndListBox),
+        g_lpInst->hwndListBox, LBN_SELCHANGE, SNDMSG);
+}
+
+/// @brief Handles WM_SETCURSOR message.
+///
+/// @param hwnd  Handle of grid.
+/// @param hwndCursor The handle of the cursor.
+/// @param codeHitTest The hit test code.
+/// @param msg The windows mouse message related to hit test.
+///
+/// @par Comments:
+///       We are only concerned with detecting the completion of a sizing operation
+///        consequently return false and let the default behavior stand.
+///
+/// @returns BOOL TRUE if handled.
+static BOOL Grid_OnSetCursor(HWND hwnd, HWND hwndCursor, UINT codeHitTest, UINT msg)
+{
+    if (NULL != g_lpInst->lpCurrent)
+    {
+        if(g_lpInst->fTracking) //Sizing operation concluded
+        {
+            if(PIT_CHECK == g_lpInst->lpCurrent->iItemType)
+                g_lpInst->lpCurrent->lpszMisc = SELECT;
+
+            g_lpInst->fTracking = FALSE;
+            FORWARD_WM_KEYDOWN(g_lpInst->hwndListBox, VK_TAB, 0, 0, SNDMSG); //Focus to editor
+        }
+    }
+    return FALSE;
+}
+
+/// @brief Handles WM_LBUTTONDOWN message.
+///
+/// @param hwnd  Handle of grid.
+/// @param fDoubleClick TRUE if this is a double click event.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of click.
+///
+/// @returns VOID.
+static VOID Grid_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, INT x, INT y, UINT keyFlags)
+{
+    if ((y >= g_lpInst->iVDivider - 5) && (y <= g_lpInst->iVDivider + 5))
+    {
+        //If mouse clicked on divider line, then start resizing
+        SetCursor(LoadCursor(NULL, IDC_SIZENS));
+
+        RECT rc;
+        GetWindowRect(hwnd, &rc);
+        rc.top += 10;
+        rc.bottom -= 10;
+        //Do not let mouse leave the list box boundary
+        ClipCursor(&rc);
+
+        g_lpInst->fTracking = TRUE;
+        g_lpInst->nDivLft = 0;
+        g_lpInst->nDivRht = WIDTH(rc); //DWM 1.7: Changed from = rc.right
+        g_lpInst->nOldDivY = y;
+
+        HDC hdc = GetDC(hwnd);
+        HPEN hOld = SelectObject(hdc, CreatePen(PS_SOLID, 3, 0));
+
+        InvertLine(hdc, g_lpInst->nDivLft, g_lpInst->nOldDivY,
+            g_lpInst->nDivRht, g_lpInst->nOldDivY);
+
+        DeleteObject(SelectObject(hdc, hOld));
+        ReleaseDC(hwnd, hdc);
+
+        //Capture the mouse
+        SetCapture(hwnd);
+    }
+}
+
+/// @brief Handles WM_LBUTTONUP message.
+///
+/// @param hwnd  Handle of grid.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of click.
+///
+/// @returns VOID.
+static VOID Grid_OnLButtonUp(HWND hwnd, INT x, INT y, UINT keyFlags)
+{
+    if (g_lpInst->fTracking)
+    {
+        g_lpInst->fTracking = FALSE;
+        //If mouse was captured then release it
+        if (hwnd == GetCapture())
+            ReleaseCapture();
+
+        ClipCursor(NULL);
+
+        //Set the divider position to the new value
+        g_lpInst->nOldDivY = y;
+
+        HDC hdc = GetDC(hwnd);
+        HPEN hOld = SelectObject(hdc, CreatePen(PS_SOLID, 3, 0));
+
+        InvertLine(hdc, g_lpInst->nDivLft, g_lpInst->nOldDivY,
+            g_lpInst->nDivRht, g_lpInst->nOldDivY);
+
+        DeleteObject(SelectObject(hdc, hOld));
+        ReleaseDC(hwnd,hdc);
+
+        //Trigger a resize
+        RECT rc;
+        GetClientRect(hwnd, &rc);
+        g_lpInst->iDescHeight = HEIGHT(rc) - y;
+        Grid_OnSize(hwnd, 0, WIDTH(rc), HEIGHT(rc));
+    }
+}
+
+/// @brief Handles WM_MOUSEMOVE message.
+///
+/// @param hwnd  Handle of grid.
+/// @param x The xpos of the mouse.
+/// @param y The ypos of the mouse.
+/// @param keyFlags Set if certain keys down at time of move.
+///
+/// @returns VOID.
+static VOID Grid_OnMouseMove(HWND hwnd, INT x, INT y, UINT keyFlags)
+{
+    if ((y >= g_lpInst->iVDivider - 5) && (y <= g_lpInst->iVDivider + 5))
+    {
+        SetCursor(LoadCursor(NULL, IDC_SIZENS));
+    }
+    else if (g_lpInst->fTracking)
+    {
+        //Move divider line to the mouse pos. if columns are
+        // currently being resized
+        HDC hdc = GetDC(hwnd);
+        HPEN hOld = SelectObject(hdc, CreatePen(PS_SOLID, 3, 0));
+
+        //Remove old divider line
+        InvertLine(hdc, g_lpInst->nDivLft, g_lpInst->nOldDivY,
+            g_lpInst->nDivRht, g_lpInst->nOldDivY);
+        //Draw new divider line
+        g_lpInst->nOldDivY = y;
+
+        InvertLine(hdc, g_lpInst->nDivLft, g_lpInst->nOldDivY,
+            g_lpInst->nDivRht, g_lpInst->nOldDivY);
+
+        DeleteObject(SelectObject(hdc, hOld));
+        ReleaseDC(hwnd, hdc);
+    }
+    else
+    {
+        SetCursor(LoadCursor(NULL, IDC_ARROW));
+    }
+}
+
+/// @brief Handles WM_CTLCOLORLISTBOX message sent to the grid.
+///
+/// @param hwnd  Handle of grid.
+/// @param hdc The handle of the device context.
+/// @param hwndChild The handle of the listbox.
+/// @param type CTLCOLOR_LISTBOX.
+///
+/// @returns HBRUSH The handle of the brush used to paint the
+///                  listbox's background.
+static HBRUSH Grid_OnCtlColorListbox(HWND hwnd, HDC hdc, HWND hwndChild, INT type)
+{
+    return SetColor(hdc, GetSysColor(COLOR_MENUTEXT), GetSysColor(COLOR_3DFACE));
+}
+
+/// @brief Handles WM_CTLCOLORSTATIC message sent to the grid.
+///
+/// @param hwnd  Handle of grid.
+/// @param hdc The handle of the device context.
+/// @param hwndChild The handle of the static.
+/// @param type CTLCOLOR_STATIC.
+///
+/// @returns HBRUSH The handle of the brush used to paint the
+///                  static's background.
+static HBRUSH Grid_OnCtlColorStatic(HWND hwnd, HDC hdc, HWND hwndChild, INT type)
+{
+    //DWM 1.3: Keep the area between the description and the list refreshed
+    if (NULL != g_lpInst->hwndPropDesc)
+    {
+        RECT rc;
+        GetClientRect(hwnd, &rc);
+
+        HDC hdc = GetDC(hwnd);
+        FillSolidRect(hdc,MAKE_PRECT(0, g_lpInst->iVDivider - 2,
+            WIDTH(rc), g_lpInst->iVDivider),GetSysColor(COLOR_BTNFACE));
+        ReleaseDC(hwnd,hdc);
+    } 
+    return FORWARD_WM_CTLCOLORSTATIC(hwnd, hdc, hwndChild, DefWindowProc);
+}
+
+/// @brief Handles WM_MEASUREITEM message sent to the grid when the owner-drawn
+///         listbox is created.
+///
+/// @param hwnd  Handle of grid.
+/// @param lpMeasureItem The structure that contains the dimensions of the
+///                       owner-drawn listbox.
+///
+/// @returns VOID.
+static VOID Grid_OnMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpMeasureItem)
+{
+    lpMeasureItem->itemHeight = MINIMUM_ITEM_HEIGHT; //pixels
+}
+
+/// @brief Ensure that a catalog item matching the given catalog name is expanded.
+///
+/// @param szCatalog The catalog name.
+///
+/// @returns VOID.
+static VOID Grid_ExpandCatalog(LPCTSTR szCatalog)
+{
+    if (NULL != szCatalog)
+    {
+        INT ln = _tcslen(szCatalog) + 1; //Check for empty string
+        if (ln == 1)
+            return;
+    }
+
+    for (INT i = 0; i < ListBox_GetCount(g_lpInst->hwndListBox); i++)
+    {
+        LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListBox, i);
+        if (NULL != pItem && PIT_CATALOG == pItem->iItemType &&
+            (NULL == szCatalog || 0 == _tcsicmp(pItem->lpszCatalog, szCatalog)))
+        {
+            if (pItem->fCollapsed)
+                ToggleCatalog(pItem);
+        }
+    }
+}
+
+/// @brief Ensure that a catalog item matching the given catalog name is collapsed.
+///
+/// @param szCatalog The catalog name.
+///
+/// @returns VOID.
+static VOID Grid_CollapseCatalog(LPCTSTR szCatalog)
+{
+    if (NULL != szCatalog)
+    {
+        INT ln = _tcslen(szCatalog) + 1; //Check for empty string
+        if (ln == 1)
+            return;
+    }
+    for (INT i = 0; i < ListBox_GetCount(g_lpInst->hwndListBox); i++)
+    {
+        LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListBox, i);
+        if (NULL != pItem && PIT_CATALOG == pItem->iItemType &&
+            (NULL == szCatalog || 0 == _tcsicmp(pItem->lpszCatalog, szCatalog)))
+        {
+            if (!pItem->fCollapsed)
+                ToggleCatalog(pItem);
+        }
+    }
+}
+
+/// @brief Handles WM_COMMAND message.
+///
+/// @param hwnd  Handle of grid.
+/// @param id The id of the sender.
+/// @param hwndCtl The hwnd of the sender.
+/// @param codeNotify The notification code sent.
+///
+/// @returns VOID.
+static VOID Grid_OnCommand(HWND hwnd, INT id, HWND hwndCtl, UINT codeNotify)
+{
+    if (g_lpInst->hwndListBox == hwndCtl)
+    {
+        switch (codeNotify)
+        {
+            case LBN_SELCHANGE:
+            {
+                SetFocus(hwndCtl);
+                INT iCurSel = ListBox_GetCurSel(hwndCtl);
+
+                //If this is a checkbox, notify of the previous item's change
+                LPLISTBOXITEM pItem = (LPLISTBOXITEM)ListBox_GetItemDataSafe(hwndCtl,
+                    g_lpInst->iPrevSel);
+                if (NULL != pItem)
+                {
+                    if (PIT_CHECK == pItem->iItemType)
+                    {
+                        if (iCurSel != g_lpInst->iPrevSel &&
+                            0 == _tcsicmp(pItem->lpszMisc, SELECT))
+                            pItem->lpszMisc = UNSELECT;
+                    }
+                }
+                g_lpInst->lpCurrent = (LPLISTBOXITEM)ListBox_GetItemDataSafe(hwndCtl,
+                    iCurSel);
+                if (NULL == g_lpInst->lpCurrent)
+                    return;
+
+                //Display the property description if desired
+                if (NULL != g_lpInst->hwndPropDesc)
+                    Static_SetText(g_lpInst->hwndPropDesc,
+                        g_lpInst->lpCurrent->lpszPropDesc);
+
+                //Destroy previous editor
+                if (NULL != g_lpInst->hwndCtl1)
+                {
+                    DestroyWindow(g_lpInst->hwndCtl1);
+                    g_lpInst->hwndCtl1 = NULL;
+                }
+                if (NULL != g_lpInst->hwndCtl2)
+                {
+                    DestroyWindow(g_lpInst->hwndCtl2);
+                    g_lpInst->hwndCtl2 = NULL;
+                }
+
+                //Redraw the selection
+                if(iCurSel != g_lpInst->iPrevSel)
+                {
+                    RECT rc;
+                    memset(&rc, 0, sizeof rc);
+
+                    ListBox_GetItemRect(hwndCtl, g_lpInst->iPrevSel, &rc);
+                    RedrawWindow(hwndCtl, &rc,
+                     NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+
+                    ListBox_GetItemRect(hwndCtl, iCurSel, &rc);
+                    RedrawWindow(hwndCtl, &rc,
+                        NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
+
+                    g_lpInst->iPrevSel = iCurSel;
+                }
+            }
+        }
+    }
+}
+
+/// @brief Handles WM_DRAWITEM message sent to the grid when a visual aspect of
+///         the owner-drawn listbox has changed.
+///
+/// @param hwnd  Handle of grid.
+/// @param lpDIS The structure that contains information about the item
+///               to be drawn and the type of drawing required.
+///
+/// @returns VOID.
+static VOID Grid_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT *lpDIS)
+{
+    UINT nIndex = lpDIS->itemID;
+
+    if (lpDIS->hwndItem != g_lpInst->hwndListBox)
+        return;
+
+    if (nIndex == (UINT) - 1 || !(lpDIS->itemAction & ODA_DRAWENTIRE))
+        return;
+
+    //Get the item for the current row
+    LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(lpDIS->hwndItem, nIndex);
+    if (NULL == pItem)
+        return;
+
+    RECT rectFullItem, rectPart0, rectCatPart1, rectPart1, rectPart2, rectPart3;
+
+    rectFullItem = lpDIS->rcItem;
+
+    if (g_lpInst->iHDivider == 0)
+        g_lpInst->iHDivider = WIDTH(rectFullItem) / 2;
+
+    rectPart0 = rectFullItem;
+    rectPart0.right = rectPart0.left + WIDTH_PART0;
+
+    rectCatPart1 = rectFullItem;
+    rectCatPart1.left = rectPart0.right;
+
+    rectPart1 = rectCatPart1;
+    rectPart1.right = g_lpInst->iHDivider;
+
+    rectPart2 = rectFullItem;
+    rectPart2.left = g_lpInst->iHDivider + (PIT_CATALOG == pItem->iItemType ? 0 : 1);
+    if (PIT_COLOR == pItem->iItemType || PIT_CHECK == pItem->iItemType)
+    {
+        rectPart2.right = rectPart2.left + WIDTH_PART2;
+    }
+    else
+        rectPart2.right = rectPart2.left;
+
+    rectPart3 = rectFullItem;
+    rectPart3.left = rectPart2.right;
+
+    //
+    //First part of item
+    //
+    FillRect(lpDIS->hDC, &rectPart0, GetStockObject(HOLLOW_BRUSH));
+
+    if (PIT_CATALOG == pItem->iItemType) //Draw expand / collapse box
+    {
+        RECT rect2;
+        rect2.left = rectPart0.left + 4;
+        rect2.top = rectPart0.top + 4;
+        rect2.right = rect2.left + 9;
+        rect2.bottom = rect2.top + 9;
+
+        FillRect(lpDIS->hDC, &rect2, GetSysColorBrush(COLOR_WINDOW));
+        FrameRect(lpDIS->hDC, &rect2, GetStockObject(BLACK_BRUSH));
+
+        POINT ptCtr;
+        ptCtr.x = (LONG) (rect2.left + (WIDTH(rect2) * 0.5));
+        ptCtr.y = (LONG) (rect2.top + (HEIGHT(rect2) * 0.5));
+        InflateRect(&rect2, -2, -2);
+
+        DrawLine(lpDIS->hDC, rect2.left, ptCtr.y, rect2.right, ptCtr.y); //Make a -
+        if (pItem->fCollapsed) //Convert to +
+            DrawLine(lpDIS->hDC, ptCtr.x, rect2.top, ptCtr.x, rect2.bottom);
+    }
+
+    //
+    //Second part of item
+    //
+
+    //If it is the selected item, set its background-color
+    HFONT oldFont;
+    if (PIT_CATALOG == pItem->iItemType)
+    {
+        FillRect(lpDIS->hDC, &rectCatPart1, GetStockObject(HOLLOW_BRUSH));
+
+        if (nIndex == (UINT)ListBox_GetCurSel(lpDIS->hwndItem) && g_lpInst->fGotFocus)
+        {
+            InflateRect(&rectCatPart1, -2, -2);
+            FrameRect(lpDIS->hDC, &rectCatPart1, GetSysColorBrush(COLOR_BTNSHADOW));
+            InflateRect(&rectCatPart1, 2, 2);
+        }
+
+        //Write the property name (bold font, Visual Studio style)
+        oldFont = SelectObject(lpDIS->hDC, Font_SetBold(lpDIS->hwndItem, TRUE));
+        SetTextColor(lpDIS->hDC, GetSysColor(COLOR_BTNTEXT));
+        DrawText(lpDIS->hDC, pItem->lpszCatalog, _tcslen(pItem->lpszCatalog),
+            MAKE_PRECT(rectCatPart1.left + 6, rectCatPart1.top + 3,
+            rectCatPart1.right - 6, rectCatPart1.bottom + 3),
+            DT_NOCLIP | DT_LEFT | DT_SINGLELINE);
+    }
+    else
+    {
+        SetBkMode(lpDIS->hDC, TRANSPARENT);
+
+        FillRect(lpDIS->hDC, &rectPart1,
+            GetSysColorBrush(nIndex == (UINT)ListBox_GetCurSel(lpDIS->hwndItem) ?
+            (g_lpInst->fGotFocus ? COLOR_HIGHLIGHT : COLOR_BTNFACE) : COLOR_WINDOW));
+
+        //Write the property name
+        oldFont = SelectObject(lpDIS->hDC, Font_SetBold(lpDIS->hwndItem, FALSE));
+        SetTextColor(lpDIS->hDC,
+            GetSysColor(nIndex == (UINT)ListBox_GetCurSel(lpDIS->hwndItem) ?
+            (g_lpInst->fGotFocus ? COLOR_HIGHLIGHTTEXT : COLOR_BTNTEXT) : COLOR_WINDOWTEXT));
+        DrawText(lpDIS->hDC, pItem->lpszPropName, _tcslen(pItem->lpszPropName),
+            MAKE_PRECT(rectPart1.left + 3, rectPart1.top + 3, rectPart1.right - 3,
+            rectPart1.bottom + 3), DT_NOCLIP | DT_LEFT | DT_SINGLELINE);
+
+        DrawBorder(lpDIS->hDC, &rectPart1, BF_TOPRIGHT,
+            GetSysColor(COLOR_BTNFACE));
+    }
+    DeleteObject(oldFont);
+
+    //
+    //Third part - Draw color box or check box
+    //
+    if (PIT_CATALOG != pItem->iItemType)
+    {
+        FillRect(lpDIS->hDC, &rectPart2, GetSysColorBrush(COLOR_WINDOW));
+
+        RECT rect3 = rectPart2;
+        rect3.left += 2;
+        rect3.top += 3;
+        rect3.bottom = rect3.top + 15;
+        rect3.right = rect3.left + 15;
+
+        if (PIT_COLOR == pItem->iItemType)
+        {
+            FillSolidRect(lpDIS->hDC, &rect3, GetColor(pItem->lpszCurValue));
+            FrameRect(lpDIS->hDC, &rect3, GetStockObject(BLACK_BRUSH));
+        }
+        else if (PIT_CHECK == pItem->iItemType)
+        {
+            if (0 == _tcsicmp(pItem->lpszMisc, SELECT))
+            {
+                FillRect(lpDIS->hDC, &rectPart2,
+                    GetSysColorBrush(COLOR_HIGHLIGHT));
+            }
+            DrawFrameControl(lpDIS->hDC, &rect3, DFC_BUTTON, DFCS_BUTTONCHECK |
+                (_tcsicmp(pItem->lpszCurValue, CHECKED) == 0 ? DFCS_CHECKED : 0));
+
+			//DWM 1.8: Added
+		    if (FLATCHECKS & (DWORD)GetWindowLongPtr(lpDIS->hwndItem, GWLP_USERDATA))
+		    {
+		        //Make border thin
+	            FrameRect(lpDIS->hDC, &rect3, GetSysColorBrush(COLOR_BTNFACE));
+	            InflateRect(&rect3, -1, -1);
+	            FrameRect(lpDIS->hDC, &rect3, GetSysColorBrush(COLOR_WINDOW));
+		    }
+        }
+    }
+    DrawBorder(lpDIS->hDC, &rectPart2, BF_TOP, GetSysColor(COLOR_BTNFACE));
+
+    //
+    //Fourth part - Write the initial property value in the second rectangle
+    //
+    if (PIT_CATALOG != pItem->iItemType)
+    {
+        FillRect(lpDIS->hDC, &rectPart3, GetSysColorBrush(COLOR_WINDOW));
+    }
+    if (PIT_CHECK != pItem->iItemType)
+    {
+        SetBkMode(lpDIS->hDC, TRANSPARENT);
+
+        if (PIT_FONT == pItem->iItemType)
+        {
+            TCHAR buf[MAX_PATH] = { 0 };
+            LPTSTR szFmt;
+            PROPGRIDFONTITEM pgfi;
+            TEXTMETRIC tm;
+            HFONT hf, hfOld;
+            LONG PointSize = 0;
+
+            LogFontItem_FromString(&pgfi, pItem->lpszCurValue);
+            PointSize = -MulDiv(pgfi.logFont.lfHeight, 72,
+                GetDeviceCaps(lpDIS->hDC, LOGPIXELSY));
+
+            if (0 < PointSize)
+            {
+                if (GetTextMetrics(lpDIS->hDC, &tm))
+                    pgfi.logFont.lfHeight = tm.tmHeight + 2; //So displayed text is not oversized
+
+                hf = CreateFontIndirect(&pgfi.logFont);
+                hfOld = SelectObject(lpDIS->hDC, hf);
+
+                SetTextColor(lpDIS->hDC, pgfi.crFont);
+#ifdef _UNICODE
+                szFmt = _T("%ls %d");
+#else
+                szFmt = _T("%s %d");
+#endif
+                _stprintf(buf, MAX_PATH, szFmt, pgfi.logFont.lfFaceName, PointSize);
+                DrawText(lpDIS->hDC, buf, _tcslen(buf),
+                    MAKE_PRECT(rectPart3.left + 3, rectPart3.top + 3,
+                    rectPart3.right + 3, rectPart3.bottom + 3),
+                    DT_NOCLIP | DT_LEFT | DT_SINGLELINE);
+
+                DeleteObject(SelectObject(lpDIS->hDC, hfOld));
+            }
+        }
+        else
+        {
+            SetTextColor(lpDIS->hDC, GetSysColor(COLOR_WINDOWTEXT));
+            DrawText(lpDIS->hDC, pItem->lpszCurValue, _tcslen(pItem->lpszCurValue),
+                MAKE_PRECT(rectPart3.left + 3, rectPart3.top + 3,
+                rectPart3.right + 3, rectPart3.bottom + 3),
+                DT_NOCLIP | DT_LEFT | DT_SINGLELINE);
+        }
+    }
+    DrawBorder(lpDIS->hDC, &rectPart3, BF_TOP, GetSysColor(COLOR_BTNFACE));
+}
+
+/// @brief Handles WM_SHOWWINDOW message.
+///
+/// @param hwnd Handle of grid.
+/// @param fShow Show/hide flag TRUE for show FALSE for hide.
+/// @param status Status flag.
+///
+/// @returns VOID.
+static VOID Grid_OnShowWindow(HWND hwnd, BOOL fShow, UINT status)
+{
+    //DWM 1.3: Added this handler
+    if(!fShow) //Hiding so make sure we update the fields
+    {
+        FORWARD_WM_CHAR(g_lpInst->hwndCtl1, VK_RETURN, 0, SNDMSG);
+        FORWARD_WM_CHAR(g_lpInst->hwndCtl2, VK_RETURN, 0, SNDMSG);
+    }
+    FORWARD_WM_SHOWWINDOW(hwnd, fShow, status, DefWindowProc);
+}
+
+#pragma endregion grid message handlers
+
+#pragma region public interface handlers
+
+/// @brief Handles LB_ADDSTRING message sent to the grid.
+///
+/// @param pgi A pointer to a PROPGRIDITEM object.
+///
+/// @returns INT The index of the item added to the grid.
+static INT Grid_OnAddString(LPPROPGRIDITEM pgi)
+{
+    LPLISTBOXITEM lpi;
+    TCHAR buf[MAX_PATH];
+    _tmemset(buf, (TCHAR)0, MAX_PATH);
+
+    LPTSTR lpszCurValue = _T("");
+
+    //Make sure the catalog for this item has been inserted
+    INT idx = ListBox_FindCatalog(g_lpInst->hwndListBox, 0, pgi->lpszCatalog);
+
+    if (LB_ERR == idx)  // Must add catalog to the listBox
+    {
+        lpi = NewItem(pgi->lpszCatalog,_T(""), _T(""),
+            _T(""), _T(""), PIT_CATALOG);
+        lpi->fCollapsed = TRUE;
+        ListBox_AddItemData(g_lpInst->hwndListBox, lpi);
+    }
+    switch (pgi->iItemType)
+    {
+        case PIT_CATALOG: //We explicitly added a catalog item to the listbox
+            return -2;    // catalogs are not added to the list map so skip the rest
+        case PIT_EDIT:
+        case PIT_STATIC:
+        case PIT_COMBO:
+        case PIT_EDITCOMBO:
+        case PIT_FOLDER:
+            lpszCurValue = (LPTSTR)pgi->lpCurValue;
+            break;
+        case PIT_COLOR:
+            _stprintf(buf, MAX_PATH, _T("%d,%d,%d"),
+                GetRValue((COLORREF)pgi->lpCurValue),
+                GetGValue((COLORREF)pgi->lpCurValue),
+                GetBValue((COLORREF)pgi->lpCurValue));
+            lpszCurValue = buf;
+            break;
+        case PIT_FONT:
+            lpszCurValue = LogFontItem_ToString((LPPROPGRIDFONTITEM)pgi->lpCurValue);
+            break;
+        case PIT_CHECK:
+            lpszCurValue = (BOOL)pgi->lpCurValue ? CHECKED : UNCHECKED;
+            break;
+        case PIT_FILE:
+            pgi->lpszzCmbItems = FileDialogItem_ToString((LPPROPGRIDFDITEM)pgi->lpCurValue);
+            lpszCurValue = ((LPPROPGRIDFDITEM)pgi->lpCurValue)->lpszFilePath;
+            break;
+        case PIT_IP:
+            _stprintf(buf, MAX_PATH,
+                _T("%d.%d.%d.%d"),
+                FIRST_IPADDRESS((DWORD)pgi->lpCurValue),
+                SECOND_IPADDRESS((DWORD)pgi->lpCurValue),
+                THIRD_IPADDRESS((DWORD)pgi->lpCurValue),
+                FOURTH_IPADDRESS((DWORD)pgi->lpCurValue));
+            lpszCurValue = buf;
+            break;
+        case PIT_DATE:
+            GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE,
+                (LPSYSTEMTIME)pgi->lpCurValue, NULL, buf, MAX_PATH);
+            lpszCurValue = buf;
+            break;
+        case PIT_TIME:
+            GetTimeFormat(LOCALE_USER_DEFAULT, 0, (LPSYSTEMTIME)pgi->lpCurValue,
+                _T("hh':'mm':'ss tt"), buf, MAX_PATH);
+            lpszCurValue = buf;
+            break;
+        case PIT_DATETIME:
+            GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE,
+                (LPSYSTEMTIME)pgi->lpCurValue, NULL, buf, MAX_PATH);
+            _tcscat(buf, _T(" "));
+            GetTimeFormat(LOCALE_USER_DEFAULT, 0, (LPSYSTEMTIME)pgi->lpCurValue,
+                _T("hh':'mm':'ss tt"), (LPTSTR) (buf + _tcslen(buf)),
+                MAX_PATH - _tcslen(buf));
+            lpszCurValue = buf;
+            break;
+    }
+    lpi = NewItem(pgi->lpszCatalog, pgi->lpszPropName,
+            lpszCurValue, pgi->lpszzCmbItems, pgi->lpszPropDesc, pgi->iItemType);
+
+    return ListBox_AddItemData(g_lpInst->hwndListMap, lpi);
+}
+
+/// @brief Handles LB_DELETESTRING message sent to the grid.
+///
+/// @param nIndex The index of the item to delete.
+///
+/// @returns INT A count of the items remaining in the grid. The return value is
+///               LB_ERR if the index parameter specifies an index greater than
+///               the number of items in the grid.
+static INT Grid_OnDeleteString(INT nIndex)
+{
+    LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, nIndex);
+    if (NULL == pItem)
+        return LB_ERR;
+
+    INT iItem = ListBox_FindItemData(g_lpInst->hwndListBox, 0, pItem);
+    if (LB_ERR != iItem)
+        ListBox_DeleteString(g_lpInst->hwndListBox, iItem);
+
+    return ListBox_DeleteString(g_lpInst->hwndListMap, nIndex);
+}
+
+/// @brief Handles LB_GETCURSEL message sent to the grid.
+///
+/// @returns INT The zero-based index of the selected item. If there is no
+///               selection, the return value is LB_ERR.
+static INT Grid_OnGetCurSel(VOID)
+{
+    INT iItem = ListBox_GetCurSel(g_lpInst->hwndListBox);
+    if (LB_ERR != iItem)
+    {
+        LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListBox, iItem);
+        if (NULL != pItem)
+        {
+            if (PIT_CATALOG != pItem->iItemType)
+                return ListBox_FindItemData(g_lpInst->hwndListMap, 0, pItem);
+        }
+    }
+    //If we get here we didn't succeed
+    return LB_ERR;
+}
+
+/// @brief Handles LB_GETITEMDATA message sent to the grid.
+///
+/// @param iItem The zero-based index of the item.
+///
+/// @returns LRESULT In this case a pointer to a PROPGRIDITEM object.
+static LRESULT Grid_OnGetItemData(INT iItem)
+{
+    static PROPGRIDITEM pgi;
+    static PROPGRIDFONTITEM pgfi;
+    static PROPGRIDFDITEM pgfdi;
+    static SYSTEMTIME st = {0};
+    static TCHAR outbuf[MAX_PATH];
+
+    LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, iItem);
+    if (NULL != pItem)
+    {
+        if (PIT_CATALOG != pItem->iItemType)
+        {
+            pgi.lpszCatalog = pItem->lpszCatalog;
+            pgi.lpszPropName = pItem->lpszPropName;
+            pgi.lpszzCmbItems = pItem->lpszMisc;
+            pgi.lpszPropDesc = pItem->lpszPropDesc;
+            pgi.iItemType = pItem->iItemType;
+
+            switch (pgi.iItemType)
+            {
+                case PIT_EDIT:
+                case PIT_COMBO:
+                case PIT_EDITCOMBO:
+                case PIT_STATIC:
+                case PIT_FOLDER:
+                    pgi.lpCurValue = (LPARAM)pItem->lpszCurValue;
+                    break;
+                case PIT_COLOR:
+                    pgi.lpCurValue = (LPARAM)GetColor(pItem->lpszCurValue);
+                    break;
+                case PIT_FONT:
+                    LogFontItem_FromString(&pgfi, pItem->lpszCurValue);
+                    pgi.lpCurValue = (LPARAM) & pgfi;
+                    break;
+                case PIT_CHECK:
+                    pgi.lpCurValue = (LPARAM) (0 == _tcsicmp(CHECKED,
+                        pItem->lpszCurValue));
+                    break;
+                case PIT_FILE:
+                    FileDialogItem_FromString(&pgfdi, pgi.lpszzCmbItems);
+                    pgi.lpCurValue = (LPARAM) & pgfdi;
+                    break;
+                case PIT_IP:
+                {
+					//DWM 1.9: Updated this code to use DWORD array and MAKEIPADDRESS macroe instead of 4 byte array and cast.
+					//DWM 1.9: This was necessary to support MSVC _stscanf (sscanf - swscanf) beahavior which expects DWORD arguments.
+                    DWORD ip[4] = { 0, 0, 0, 0 };
+                    _stscanf(pItem->lpszCurValue, _T("%hhd.%hhd.%hhd.%hhd"),
+                        &ip[0], &ip[1], &ip[2], &ip[3]);
+                    pgi.lpCurValue = (LPARAM)  MAKEIPADDRESS(ip[0],ip[1],ip[2],ip[3]);
+                }
+                    break;
+                case PIT_DATE:
+                    memset(&st, 0, sizeof(SYSTEMTIME));
+                    _stscanf(pItem->lpszCurValue, _T("%hd/%hd/%hd"),
+                        &st.wMonth, &st.wDay, &st.wYear);
+                    pgi.lpCurValue = (LPARAM) & st;
+                    break;
+                case PIT_TIME:
+                    memset(&st, 0, sizeof(SYSTEMTIME));
+                    _tmemset(outbuf, (TCHAR)0, MAX_PATH);
+                    _stscanf(pItem->lpszCurValue,
+#ifdef _UNICODE
+                        _T("%hd:%hd:%hd %2ls"),
+#else
+                        _T("%hd:%hd:%hd %2s"),
+#endif
+                        &st.wHour, &st.wMinute, &st.wSecond, (LPTSTR)&outbuf);
+                    if ((0 == _tcsicmp(_T("PM"), outbuf)) && st.wHour != 12)//DWM 1.6:Added st.wHour != 12
+                        st.wHour += 12;
+
+                    pgi.lpCurValue = (LPARAM)&st;
+                    break;
+                case PIT_DATETIME:
+                    memset(&st, 0, sizeof(SYSTEMTIME));
+                    _tmemset(outbuf, (TCHAR)0, MAX_PATH);
+                    _stscanf(pItem->lpszCurValue,
+#ifdef _UNICODE
+                        _T("%hd/%hd/%hd %hd:%hd:%hd %2ls"),
+#else
+                        _T("%hd/%hd/%hd %hd:%hd:%hd %2s"),
+#endif
+                        &st.wMonth, &st.wDay, &st.wYear,
+                        &st.wHour, &st.wMinute, &st.wSecond, (LPTSTR)&outbuf);
+                    if ((0 == _tcsicmp(_T("PM"), outbuf)) && st.wHour != 12)//DWM 1.6:Added st.wHour != 12
+                        st.wHour += 12;
+
+                    pgi.lpCurValue = (LPARAM) & st;
+                    break;
+            }
+        }
+        return (LRESULT) & pgi;
+    }
+    else
+        return LB_ERR;
+}
+
+/// @brief Handles LB_GETSEL message sent to the grid.
+///
+/// @param iItem The zero-based index of the item.
+///
+/// @returns BOOL TRUE if the item is selected, FALSE if not, or LB_ERR
+///           if an error occurs.
+static BOOL Grid_OnGetSel(INT iItem)
+{
+    LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, iItem);
+    if (NULL != pItem)
+    {
+        if (PIT_CATALOG != pItem->iItemType)
+        {
+            INT i = ListBox_FindItemData(g_lpInst->hwndListBox, 0, pItem);
+            if (LB_ERR != i)
+                return ListBox_GetSel(g_lpInst->hwndListBox, i);
+            else
+                return FALSE;   //Collapsed Not selected
+        }
+    }
+    return LB_ERR;
+}
+
+/// @brief Handles LB_RESETCONTENT message sent to the grid.
+///
+/// @returns VOID.
+static VOID Grid_OnResetContent(VOID)
+{
+    ListBox_ResetContent(g_lpInst->hwndListMap);
+
+    if (NULL != g_lpInst->hwndCtl1)
+    {
+        DestroyWindow(g_lpInst->hwndCtl1);
+        g_lpInst->hwndCtl1 = NULL;
+    }
+    if (NULL != g_lpInst->hwndCtl2)
+    {
+        DestroyWindow(g_lpInst->hwndCtl2);
+        g_lpInst->hwndCtl2 = NULL;
+    }
+    ListBox_ResetContent(g_lpInst->hwndListBox);
+    Static_SetText(g_lpInst->hwndPropDesc,_T("")); //DWM 1.2: Clear the property pane
+}
+
+/// @brief Handles LB_SETCURSEL message sent to the grid.
+///
+/// @param iItem The zero-based index of the item to select, or –1 to clear the selection.
+///
+/// @returns LRESULT If an error occurs, the return value is LB_ERR.
+///                   If the index parameter is –1, the return value is LB_ERR
+///                   even though no error occurred.
+static LRESULT Grid_OnSetCurSel(INT iItem)
+{
+    LPLISTBOXITEM pItem = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, iItem);
+    if (NULL != pItem)
+    {
+        if (PIT_CATALOG != pItem->iItemType)
+        {
+            INT i = ListBox_FindItemData(g_lpInst->hwndListBox, 0, pItem);
+            if (LB_ERR != i)
+            {
+                INT ret = ListBox_SetCurSel(g_lpInst->hwndListBox, i);
+                FORWARD_WM_COMMAND(GetParent(g_lpInst->hwndListBox),
+                    GetDlgCtrlID(g_lpInst->hwndListBox), g_lpInst->hwndListBox,
+                    LBN_SELCHANGE, SNDMSG);
+
+                if(PIT_CHECK == pItem->iItemType)
+                    pItem->lpszMisc = SELECT; //DWM 1.2: Ensure Checkbox selected
+
+                Refresh(g_lpInst->hwndListBox);
+                return ret;
+            }
+        }
+    }
+    return LB_ERR;
+}
+
+/// @brief Handles LB_ADDSTRING message sent to the grid.
+///
+/// @param iItem The zero-based index of the item.
+/// @param pgi A pointer to a PROPGRIDITEM object.
+///
+/// @returns LRESULT The return value is the zero-based index of the item in
+///                   the list. If an error occurs, the return value is LB_ERR.
+///                   If there is insufficient space to store the data,
+///                   the return value is LB_ERRSPACE.
+static LRESULT Grid_OnSetItemData(INT iItem, LPPROPGRIDITEM pgi)
+{
+    if (PIT_CATALOG == pgi->iItemType)
+        return LB_ERR;  //Can't change an item to a catalog
+
+    LRESULT lrtn = LB_ERR;
+    LPLISTBOXITEM lpiCurrent, lpiNew;
+    TCHAR buf[MAX_PATH];
+    _tmemset(buf, (TCHAR)0, MAX_PATH);
+
+    LPTSTR lpszCurValue = _T("");
+
+    //Get the current item
+    lpiCurrent = ListBox_GetItemDataSafe(g_lpInst->hwndListMap, iItem);
+    if (NULL != lpiCurrent)
+    {
+        switch (pgi->iItemType)
+        {
+            case PIT_EDIT:
+            case PIT_STATIC:
+            case PIT_COMBO:
+            case PIT_EDITCOMBO:
+            case PIT_FOLDER:
+                lpszCurValue = (LPTSTR)pgi->lpCurValue;
+                break;
+            case PIT_COLOR:
+                _stprintf(buf, MAX_PATH, _T("%d,%d,%d"),
+                    GetRValue((COLORREF)pgi->lpCurValue),
+                    GetGValue((COLORREF)pgi->lpCurValue),
+                    GetBValue((COLORREF)pgi->lpCurValue));
+                lpszCurValue = buf;
+                break;
+            case PIT_FONT:
+                lpszCurValue = LogFontItem_ToString((LPPROPGRIDFONTITEM)pgi->lpCurValue);
+                break;
+            case PIT_CHECK:
+                lpszCurValue = (BOOL)pgi->lpCurValue ? CHECKED : UNCHECKED;
+                break;
+            case PIT_FILE:
+                pgi->lpszzCmbItems = FileDialogItem_ToString((LPPROPGRIDFDITEM)pgi->lpCurValue);
+                lpszCurValue = ((LPPROPGRIDFDITEM)pgi->lpCurValue)->lpszFilePath;
+                break;
+            case PIT_IP:
+                _stprintf(buf, MAX_PATH, _T("%d.%d.%d.%d"),
+                    FIRST_IPADDRESS((DWORD)pgi->lpCurValue),
+                    SECOND_IPADDRESS((DWORD)pgi->lpCurValue),
+                    THIRD_IPADDRESS((DWORD)pgi->lpCurValue),
+                    FOURTH_IPADDRESS((DWORD)pgi->lpCurValue));
+                lpszCurValue = buf;
+                break;
+            case PIT_DATE:
+                GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE,
+                    (LPSYSTEMTIME)pgi->lpCurValue, NULL, buf, MAX_PATH);
+                lpszCurValue = buf;
+                break;
+            case PIT_TIME:
+                GetTimeFormat(LOCALE_USER_DEFAULT, 0,
+                    (LPSYSTEMTIME)pgi->lpCurValue, _T("hh':'mm':'ss tt"),
+                    buf, MAX_PATH);
+                lpszCurValue = buf;
+                break;
+            case PIT_DATETIME:
+                GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE,
+                    (LPSYSTEMTIME)pgi->lpCurValue, NULL, buf, MAX_PATH);
+                _tcscat(buf, _T(" "));
+                GetTimeFormat(LOCALE_USER_DEFAULT, 0, (LPSYSTEMTIME)pgi->lpCurValue,
+                    _T("hh':'mm':'ss tt"), (LPTSTR) (buf + _tcslen(buf)),
+                    MAX_PATH - _tcslen(buf));
+                lpszCurValue = buf;
+                break;
+        }
+        //Do not allow the catalog to change; to do so would necessitate moving
+        // the item to a different index throwing off the indexing for items.
+        lpiNew = NewItem(lpiCurrent->lpszCatalog, pgi->lpszPropName,
+            lpszCurValue, pgi->lpszzCmbItems, pgi->lpszPropDesc, pgi->iItemType);
+
+        //Set new data
+        lrtn = ListBox_SetItemData(g_lpInst->hwndListMap, iItem, lpiNew);
+        if(LB_ERR != lrtn)
+        {
+            lrtn = ListBox_FindItemData(g_lpInst->hwndListBox,0,lpiCurrent);
+            if(LB_ERR != lrtn)
+            {
+                lrtn = ListBox_SetItemData(g_lpInst->hwndListBox, lrtn, lpiNew);
+
+                //DWM 1.3: Refresh Display of item
+                Refresh(g_lpInst->hwndListBox);
+            }
+        }
+        if(LB_ERR == lrtn)
+            return LB_ERR;
+
+        //Reset lpCurrent if necessary
+        if(lpiCurrent == g_lpInst->lpCurrent)
+            g_lpInst->lpCurrent = lpiNew;
+
+        //Delete old data
+        DeleteItem(lpiCurrent);
+    }
+    return lrtn;
+}
+
+#pragma endregion public interface handlers
+
+#pragma region create destroy
+
+/// @brief Handles WM_CREATE message.
+///
+/// @param hwnd Handle of grid.
+/// @param lpCreateStruct Pointer to a structure with creation data.
+///
+/// @returns BOOL If an application processes this message,
+///                it should return TRUE to continue creation of the window.
+static BOOL Grid_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
+{
+    INSTANCEDATA inst;
+    memset(&inst, 0, sizeof(INSTANCEDATA));
+
+    inst.hInstance = lpCreateStruct->hInstance;
+    inst.hwndParent = lpCreateStruct->hwndParent;
+    inst.fXpOrLower = IsWindowsXPorLower(); // DWM 1.4: Added
+    inst.fGotFocus = FALSE;
+    inst.fScrolling = FALSE;
+    inst.fTracking = FALSE;
+    inst.iDescHeight = HEIGHT_DESC;
+    inst.iPrevSel = LB_ERR; //Nothing selected
+
+    //Create the listbox control
+    inst.hwndListBox = CreateListBox(lpCreateStruct->hInstance, hwnd, ID_LISTBOX);
+    if (NULL == inst.hwndListBox)
+        return FALSE;
+
+    //And the hidden list map
+    inst.hwndListMap = CreateListMap(lpCreateStruct->hInstance, hwnd, ID_LISTMAP);
+    if (NULL == inst.hwndListMap)
+        return FALSE;
+
+    return Control_CreateInstanceData(hwnd, &inst);
+}
+
+/// @brief Handles WM_DESTROY message.
+///
+/// @param hwnd Handle of Grid.
+///
+/// @returns VOID.
+static VOID Grid_OnDestroy(HWND hwnd)
+{
+    if (NULL != g_lpInst)
+    {
+        ListBox_ResetContent(g_lpInst->hwndListMap); //Delete all Items
+        DestroyWindow(g_lpInst->hwndListMap);
+        DestroyWindow(g_lpInst->hwndListBox);
+
+        if (NULL != g_lpInst->hwndToolTip)
+            DestroyWindow(g_lpInst->hwndToolTip);
+        if (NULL != g_lpInst->hwndPropDesc)
+            DestroyWindow(g_lpInst->hwndPropDesc);
+        if (NULL != g_lpInst->hwndCtl1)
+            DestroyWindow(g_lpInst->hwndCtl1);
+        if (NULL != g_lpInst->hwndCtl2)
+            DestroyWindow(g_lpInst->hwndCtl2);
+
+        Control_FreeInstanceData(hwnd);
+
+        //DWM 1.3: Removed PostQuitMessage() call.
+    }
+}
+
+/// @brief Initialize and register the property grid class.
+///
+/// @param hInstance Handle of application instance.
+///
+/// @returns ATOM If the function succeeds, the atom that uniquely identifies
+///                the class being registered, otherwise 0.
+ATOM InitPropertyGrid(HINSTANCE hInstance)
+{
+    WNDCLASSEX wcex;
+
+    // Get standard listbox information
+    wcex.cbSize = sizeof(wcex);
+    if (!GetClassInfoEx(NULL, WC_LISTBOX, &wcex))
+        return 0;
+
+    // Add our own stuff
+    wcex.lpfnWndProc = (WNDPROC)Grid_Proc;;
+    wcex.hInstance = hInstance;
+    wcex.lpszClassName = g_szClassName;
+
+    // Register our new class
+    return RegisterClassEx(&wcex);
+}
+
+/// @brief Create an new instance of the property grid.
+///
+/// @param hParent Handle of the grid's parent.
+/// @param dwID The ID for this control.
+///
+/// @returns HWND If the function succeeds, the grid handle, otherwise NULL.
+HWND New_PropertyGrid(HWND hParent, DWORD dwID)
+{
+    static ATOM aPropertyGrid = 0;
+    static HWND hPropertyGrid;
+
+    HINSTANCE hinst = (HINSTANCE)GetWindowLongPtr(hParent, GWLP_HINSTANCE);
+
+    //Only need to register the property grid once
+    if (!aPropertyGrid)
+        aPropertyGrid = InitPropertyGrid(hinst);
+
+    hPropertyGrid = CreateWindowEx(0, g_szClassName, _T(""),
+         WS_CHILD | WS_TABSTOP, 0, 0, 0, 0, hParent, (HMENU)dwID, hinst, NULL);
+
+    return hPropertyGrid;
+}
+
+#pragma endregion create destroy
+
+/// @brief Send a PGN_PROPERTYCHANGE notification to grid's parent.
+///
+/// @returns VOID.
+static VOID Grid_NotifyParent(VOID)
+{
+    static NMPROPGRID nmPropGrid;
+
+    // Notify of the change
+    if (NULL != g_lpInst->lpCurrent &&
+        PIT_CATALOG != g_lpInst->lpCurrent->iItemType &&
+        PIT_STATIC != g_lpInst->lpCurrent->iItemType)
+    {
+        nmPropGrid.hdr.hwndFrom = GetParent(g_lpInst->hwndListBox);
+        nmPropGrid.hdr.idFrom = GetDlgCtrlID(nmPropGrid.hdr.hwndFrom);
+        nmPropGrid.hdr.code = PGN_PROPERTYCHANGE;
+
+        LRESULT lres = ListBox_FindItemData(g_lpInst->hwndListMap, 0, g_lpInst->lpCurrent);
+        nmPropGrid.iIndex = LB_ERR == lres ? -1 : lres;
+
+        FORWARD_WM_NOTIFY(g_lpInst->hwndParent, nmPropGrid.hdr.idFrom, &nmPropGrid, SNDMSG);
+    }
+}
+
+/// @brief Window procedure for the visible owner-drawn listbox control.
+///
+/// @param hList Handle of listbox.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK ListBox_Proc(HWND hList, UINT msg,
+        WPARAM wParam, LPARAM lParam)
+{
+    HWND hParent = GetParent(hList);
+
+    // Note: Instance data is attached to listbox's parent
+    Control_GetInstanceData(hParent, &g_lpInst);
+
+    switch (msg)
+    {
+        HANDLE_MSG(hList, WM_COMMAND, ListBox_OnCommand);
+        HANDLE_MSG(hList, WM_LBUTTONDOWN, ListBox_OnLButtonDown);
+        HANDLE_MSG(hList, WM_LBUTTONDBLCLK, ListBox_OnLButtonDown);
+        HANDLE_MSG(hList, WM_LBUTTONUP, ListBox_OnLButtonUp);
+        HANDLE_MSG(hList, WM_MOUSEMOVE, ListBox_OnMouseMove);
+        HANDLE_MSG(hList, WM_KEYDOWN, ListBox_OnKeyDown);
+        HANDLE_MSG(hList, WM_KILLFOCUS, ListBox_OnKillFocus);
+
+        case WM_SETFOCUS: //DWM 1.3: Focus to ListBox
+            g_lpInst->fGotFocus = TRUE;
+            Refresh(g_lpInst->hwndListBox);
+            return 0;
+
+        case WM_MBUTTONDOWN:
+        case WM_NCLBUTTONDOWN:
+            //The listbox doesn't have a scrollbar component, it draws a scroll
+            // bar in the non-client area of the control.  A mouse click in the
+            // non-client area then, equals clicking on a scroll bar.  A click
+            // on the middle mouse button equals pan, we'll handle that as if
+            // it were a scroll event.
+            ListBox_OnBeginScroll(hList);
+            g_lpInst->fScrolling = TRUE;
+            break;
+
+        case WM_SETCURSOR:
+            //Whenever the mouse leaves the non-client area of a listbox, it
+            // fires a WM_SETCURSOR message.  The same happens when the middle
+            // mouse button is released.  We can use this behavior to detect the
+            // completion of a scrolling operation.
+            if (g_lpInst->fScrolling)
+            {
+                ListBox_OnEndScroll(hList);
+                g_lpInst->fScrolling = FALSE;
+            }
+            break;
+
+        case WM_GETDLGCODE:
+            return DLGC_WANTALLKEYS;
+
+        case WM_DESTROY: //Unsubclass the listbox Control
+        {
+            SetWindowLongPtr(hList, GWLP_WNDPROC, (DWORD_PTR)GetProp(hList, WPRC)); //DWM 1.5: fixed cast
+            RemoveProp(hList, WPRC);
+            return 0;
+        }
+    }
+    return DefProc(hList, msg, wParam, lParam);
+}
+
+/// @brief Window procedure and public interface for the property grid.
+///
+/// @param hwnd Handle of grid.
+/// @param msg Which message?
+/// @param wParam Message parameter.
+/// @param lParam Message parameter.
+///
+/// @returns LRESULT depends on message.
+static LRESULT CALLBACK Grid_Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    Control_GetInstanceData(hwnd, &g_lpInst);//Update the instance pointer
+
+    switch (msg)
+    {
+        HANDLE_MSG(hwnd, WM_COMMAND, Grid_OnCommand);
+        HANDLE_MSG(hwnd, WM_CREATE, Grid_OnCreate);
+        HANDLE_MSG(hwnd, WM_DESTROY, Grid_OnDestroy);
+        HANDLE_MSG(hwnd, WM_SIZE, Grid_OnSize);
+        HANDLE_MSG(hwnd, WM_CTLCOLORLISTBOX, Grid_OnCtlColorListbox);
+        HANDLE_MSG(hwnd, WM_CTLCOLORSTATIC, Grid_OnCtlColorStatic);
+        HANDLE_MSG(hwnd, WM_DRAWITEM, Grid_OnDrawItem);
+        HANDLE_MSG(hwnd, WM_MEASUREITEM, Grid_OnMeasureItem);
+        HANDLE_MSG(hwnd, WM_DELETEITEM, Grid_OnDeleteItem);
+        HANDLE_MSG(hwnd, WM_LBUTTONDOWN, Grid_OnLButtonDown);
+        HANDLE_MSG(hwnd, WM_LBUTTONUP, Grid_OnLButtonUp);
+        HANDLE_MSG(hwnd, WM_MOUSEMOVE, Grid_OnMouseMove);
+        HANDLE_MSG(hwnd, WM_SETCURSOR, Grid_OnSetCursor);
+        HANDLE_MSG(hwnd, WM_SHOWWINDOW, Grid_OnShowWindow);
+
+        case WM_SETFOCUS: //DWM 1.3: Focus to ListBox
+            SetFocus(g_lpInst->hwndListBox);
+            return 0;
+        case LB_ADDSTRING: //PropGrid_AddItem
+            return Grid_OnAddString((LPPROPGRIDITEM)lParam);
+        case LB_DELETESTRING: //PropGrid_DeleteItem
+            return Grid_OnDeleteString((INT)wParam);
+        case LB_GETCOUNT: //PropGrid_GetCount
+            return ListBox_GetCount(g_lpInst->hwndListMap);
+        case LB_GETCURSEL: //PropGrid_GetCurSel
+            return Grid_OnGetCurSel();
+        case LB_GETHORIZONTALEXTENT: //PropGrid_GetHorizontalExtent
+            return ListBox_GetHorizontalExtent(g_lpInst->hwndListBox);
+        case LB_GETITEMDATA: //PropGrid_GetItemData
+            return Grid_OnGetItemData((INT)wParam);
+        case LB_GETITEMHEIGHT: //PropGrid_GetItemHeight
+            return ListBox_GetItemHeight(g_lpInst->hwndListBox, wParam);
+        case LB_GETITEMRECT: //PropGrid_GetItemRect
+            return ListBox_GetItemRect(g_lpInst->hwndListBox, wParam, lParam);
+        case LB_GETSEL: //PropGrid_GetSel
+            return Grid_OnGetSel((INT)wParam);
+        case LB_RESETCONTENT: //PropGrid_ResetContent
+            Grid_OnResetContent();
+            break;
+        case LB_SETCURSEL: //PropGrid_SetCurSel
+            return Grid_OnSetCurSel((INT)wParam);
+        case LB_SETHORIZONTALEXTENT: //PropGrid_SetHorizontalExtent
+            ListBox_SetHorizontalExtent(g_lpInst->hwndListBox, wParam);
+            break;
+        case LB_SETITEMDATA: //PropGrid_SetItemData
+            return Grid_OnSetItemData((INT)wParam, (LPPROPGRIDITEM)lParam);
+        case LB_SETITEMHEIGHT: //PropGrid_SetItemHeight
+        {
+            if (MINIMUM_ITEM_HEIGHT > LOWORD(lParam))
+                return LB_ERR;
+            LRESULT lres = SNDMSG(g_lpInst->hwndListBox, msg, wParam, lParam);
+            Refresh(g_lpInst->hwndListBox);
+            return lres;
+        }
+        case PG_FLATCHECKS: //DWM 1.8: Added
+        {
+            DWORD dwUserData = (DWORD)GetWindowLongPtr(g_lpInst->hwndListBox, GWLP_USERDATA);
+            if (FALSE != (BOOL)wParam)
+                dwUserData |= FLATCHECKS;
+            else
+                dwUserData &= ~FLATCHECKS;
+
+            return SetWindowLongPtr(g_lpInst->hwndListBox, GWLP_USERDATA,
+                        (LONG_PTR)dwUserData);
+        }
+        case PG_EXPANDCATALOGS:
+        {
+            if (NULL == (LPTSTR)lParam) //Expand all
+            {
+                Grid_ExpandCatalog(NULL);
+            }
+            else
+            {
+                //Walk the catalog list and handle each string until the empty string
+                for (LPTSTR p = (LPTSTR)lParam; *p; p += _tcslen(p) + 1)
+                    Grid_ExpandCatalog((LPCTSTR)p);
+            }
+        }
+            break;
+        case PG_COLLAPSECATALOGS:
+        {
+            if (NULL == (LPTSTR)lParam) //Collapse all
+            {
+                Grid_CollapseCatalog(NULL);
+            }
+            else
+            {
+                for (LPTSTR p = (LPTSTR)lParam; *p; p += _tcslen(p) + 1)
+                    Grid_CollapseCatalog((LPCTSTR)p);
+            }
+        }
+            break;
+        case PG_SHOWTOOLTIPS:
+        {
+            if ((BOOL)wParam)
+            {
+                if (NULL == g_lpInst->hwndToolTip)
+                {
+                    g_lpInst->hwndToolTip = CreateToolTip(g_lpInst->hInstance, g_lpInst->hwndListBox);
+
+                    if (NULL != g_lpInst->hwndToolTip)
+                    {
+                        TOOLINFO ti = { sizeof(ti) };
+                        ti.hwnd = g_lpInst->hwndListBox;
+                        ti.uId = 0;
+                        GetClientRect(hwnd, &ti.rect);
+                        ToolTip_NewToolRect(g_lpInst->hwndToolTip, &ti);
+
+                        ShowWindow(g_lpInst->hwndToolTip, SW_SHOW);
+                    }
+                }
+            }
+            else
+            {
+                DestroyWindow(g_lpInst->hwndToolTip);
+                g_lpInst->hwndToolTip = NULL;
+            }
+        }
+            break;
+        case PG_SHOWPROPERTYDESC:
+        {
+            if ((BOOL)wParam)
+            {
+                if (NULL == g_lpInst->hwndPropDesc)
+                    g_lpInst->hwndPropDesc = CreateStatic(g_lpInst->hInstance, hwnd, ID_PROPDESC);
+
+                ShowWindow(g_lpInst->hwndPropDesc, SW_SHOW);
+            }
+            else
+            {
+                DestroyWindow(g_lpInst->hwndPropDesc);
+                g_lpInst->hwndPropDesc = NULL;
+            }
+            //Call Grid_OnSize() to position and display the control
+            RECT rc;
+            GetClientRect(hwnd, &rc);
+            Grid_OnSize(hwnd, 0, WIDTH(rc), HEIGHT(rc));
+        }
+            break;
+    }
+    return DefWindowProc(hwnd, msg, wParam, lParam);
+}
diff --git a/propertyGrid.h b/propertyGrid.h
new file mode 100644
index 0000000..8985993
--- /dev/null
+++ b/propertyGrid.h
@@ -0,0 +1,392 @@
+//////////////////////////////////////////////////////////////////////////////
+///
+/// @file propertyGrid.h
+///
+/// @brief A property grid control in Win32 SDK C.
+///
+/// @author David MacDermot
+///
+/// @par Comments:
+///         This source is distributed in the hope that it will be useful,
+///         but WITHOUT ANY WARRANTY; without even the implied warranty of
+///         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+/// 
+/// @date 2-27-16
+/// 
+/// @todo 
+///
+/// @bug 
+///
+//////////////////////////////////////////////////////////////////////////////
+
+//DWM 1.8: Added Message PG_FLATCHECKS and associated macroes
+
+#ifndef PROPERTYGRID_H 
+#define PROPERTYGRID_H
+
+/****************************************************************************/
+// Public Messages
+
+// List box message subset handled by the property grid.
+ 
+// LB_ADDSTRING - PropGrid_AddItem()
+// LB_DELETESTRING - PropGrid_DeleteItem()
+// LB_GETCOUNT - PropGrid_GetCount()
+// LB_GETCURSEL - PropGrid_GetCurSel()
+// LB_GETHORIZONTALEXTENT - PropGrid_GetHorizontalExtent()
+// LB_GETITEMDATA - PropGrid_GetItemData()
+// LB_GETITEMHEIGHT - PropGrid_GetItemHeight()
+// LB_GETITEMRECT - PropGrid_GetItemRect()
+// LB_GETSEL - PropGrid_GetSel()
+// LB_RESETCONTENT - PropGrid_ResetContent()
+// LB_SETCURSEL - PropGrid_SetCurSel()
+// LB_SETHORIZONTALEXTENT - PropGrid_SetHorizontalExtent()
+// LB_SETITEMDATA - PropGrid_SetItemData()
+// LB_SETITEMHEIGHT - PropGrid_SetItemHeight()
+
+/// @name Property grid specific messages.
+/// @{
+#define PG_EXPANDCATALOGS WM_USER + 0x01   ///<PropGrid_ExpandCatalogs()
+#define PG_COLLAPSECATALOGS WM_USER + 0x02 ///<PropGrid_CollapseCatalogs()
+#define PG_SHOWTOOLTIPS WM_USER + 0x03     ///<PropGrid_ShowToolTips()
+#define PG_SHOWPROPERTYDESC WM_USER + 0x04 ///<PropGrid_ShowPropertyDescriptions()
+#define PG_FLATCHECKS  WM_USER + 0x05      ///<PropGrid_SetFlatStyleChecks()
+/// @}
+
+/****************************************************************************/
+// Property item types
+
+#define PIT_EDIT        0   ///< Property item type: Edit
+#define PIT_COMBO       1   ///< Property item type: Dropdownlist
+#define PIT_EDITCOMBO   2   ///< Property item type: Dropdown(editable)
+#define PIT_STATIC      3   ///< Property item type: Not editable text
+#define PIT_COLOR       4   ///< Property item type: Color
+#define PIT_FONT        5   ///< Property item type: Font
+#define PIT_FILE        6   ///< Property item type: File select dialog
+#define PIT_FOLDER      7   ///< Property item type: Folder select dialog
+#define PIT_CHECK       8   ///< Property item type: BOOL
+#define PIT_IP          9   ///< Property item type: IP Address
+#define PIT_DATE        10  ///< Property item type: Date
+#define PIT_TIME        11  ///< Property item type: Time
+#define PIT_DATETIME    12  ///< Property item type: Date & Time
+#define PIT_CATALOG     99  ///< Property item type: Catalog
+
+/****************************************************************************/
+// Public structures and notifications
+
+/// @var PROPGRIDFDITEM
+/// @brief A property grid file dialog item object
+
+/// @var LPPROPGRIDFDITEM
+/// @brief Pointer to a property grid file dialog item
+
+/// @struct tagPROPGRIDFDITEM
+/// @brief This is additional data associated with a property grid file dialog item
+typedef struct tagPROPGRIDFDITEM {
+    LPTSTR lpszDlgTitle; ///< Dialog title
+    LPTSTR lpszFilePath; ///< Initial path
+    LPTSTR lpszFilter;   ///< Double null terminated filter string
+    LPTSTR lpszDefExt;   ///< Default extension
+} PROPGRIDFDITEM, *LPPROPGRIDFDITEM;
+
+/// @var PROPGRIDFONTITEM
+/// @brief A property grid font item object
+
+/// @var LPPROPGRIDFONTITEM
+/// @brief Pointer to a property grid font item
+
+/// @struct tagPROPGRIDFONTITEM
+/// @brief This is additional data associated with a property grid font item
+typedef struct tagPROPGRIDFONTITEM {
+    LOGFONT logFont; ///< Logical font struct
+    COLORREF crFont; ///< Text color
+} PROPGRIDFONTITEM, *LPPROPGRIDFONTITEM;
+
+/// @var PROPGRIDITEM
+/// @brief A property grid item object
+
+/// @var LPPROPGRIDITEM
+/// @brief Pointer to a property grid item
+
+/// @struct tagPROPGRIDITEM
+/// @brief This is the data associated with a property grid item
+typedef struct tagPROPGRIDITEM {
+    LPTSTR lpszCatalog;   ///< Catalog (group) name
+    LPTSTR lpszPropName;  ///< Property (item) name
+    LPTSTR lpszzCmbItems; ///< Double null terminated list of strings
+    LPTSTR lpszPropDesc;  ///< Property (item) description
+    LPARAM lpCurValue;    ///< Property (item) value
+    INT    iItemType;     ///< Property (item) type identifier
+} PROPGRIDITEM, *LPPROPGRIDITEM;
+
+/// @var NMPROPGRID
+/// @brief A property grid notification message data object
+
+/// @var LPNMPROPGRID
+/// @brief Pointer to property grid notification message data
+
+/// @struct tagNMPROPGRID
+/// @brief This is the data associated with a property grid notification
+typedef struct tagNMPROPGRID {
+    NMHDR hdr;  ///< Notification message header
+    INT iIndex; ///< Index of a property grid item
+} NMPROPGRID, *LPNMPROPGRID;
+
+#define PGN_PROPERTYCHANGE WM_USER + 0x2A  ///<property grid Property changed notification message
+
+/****************************************************************************/
+/// @name Macroes
+/// @{
+
+/// @def PropGrid_AddItem(hwndCtl,lpItem)
+///
+/// @brief Add an item to a property grid.  Items are appended to their respective
+///         catalogs.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param lpItem Pointer to a property grid item.
+///
+/// @returns The zero-based index of the item in the list box. If an error occurs,
+///           the return value is LB_ERR. If there is insufficient space to store
+///           the new string, the return value is LB_ERRSPACE. 
+#define PropGrid_AddItem(hwndCtl,lpItem) ((int)(DWORD)SendMessage((hwndCtl),LB_ADDSTRING,0,(LPARAM)(lpItem)))
+
+/// @def PropGrid_DeleteItem(hwndCtl,index)
+///
+/// @brief Deletes the item at the specified location in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item to delete.
+///
+/// @returns A count of the items remaining in the grid. The return value is
+///           LB_ERR if the index parameter specifies an index greater than the
+///           number of items in the list. 
+#define PropGrid_DeleteItem(hwndCtl,index) ((int)(DWORD)SendMessage((hwndCtl),LB_DELETESTRING,(WPARAM)(int)(index),0))
+
+/// @def PropGrid_Enable(hwndCtl,fEnable)
+///
+/// @brief Enables or disables a property grid control.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param fEnable TRUE to enable the control, or FALSE to disable it.
+///
+/// @returns No return value.
+#define PropGrid_Enable(hwndCtl,fEnable) EnableWindow((hwndCtl),(fEnable))
+
+/// @def PropGrid_GetCount(hwndCtl)
+///
+/// @brief Gets the number of items in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns The number of items.
+#define PropGrid_GetCount(hwndCtl) ((int)(DWORD)SendMessage((hwndCtl),LB_GETCOUNT,0,0))
+
+/// @def PropGrid_GetCurSel(hwndCtl)
+///
+/// @brief Gets the index of the currently selected item in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns The zero-based index of the selected item. If there is no selection,
+///           the return value is LB_ERR.
+#define PropGrid_GetCurSel(hwndCtl) ((int)(DWORD)SendMessage((hwndCtl),LB_GETCURSEL,0,0))
+
+/// @def PropGrid_GetHorizontalExtent(hwndCtl)
+///
+/// @brief Gets the width that a property grid can be scrolled horizontally
+///         (the scrollable width).
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns The scrollable width, in pixels, of the property grid.
+#define PropGrid_GetHorizontalExtent(hwndCtl) ((int)(DWORD)SendMessage((hwndCtl),LB_GETHORIZONTALEXTENT,0,0))
+
+/// @def PropGrid_GetItemData(hwndCtl,index)
+///
+/// @brief Gets the PROPGRIDITEM associated with the specified property grid item.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item.
+///
+/// @returns A pointer to a PROPGRIDITEM object.
+#define PropGrid_GetItemData(hwndCtl,index) ((LPPROPGRIDITEM)(DWORD_PTR)SendMessage((hwndCtl),LB_GETITEMDATA,(WPARAM)(int)(index),0))
+
+/// @def PropGrid_GetItemHeight(hwndCtl)
+///
+/// @brief Retrieves the height of all items in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns The height, in pixels, of the items, or LB_ERR if an error occurs.
+#define PropGrid_GetItemHeight(hwndCtl) ((int)(DWORD)SendMessage((hwndCtl),LB_GETITEMHEIGHT,(WPARAM)0,0))
+
+/// @def PropGrid_GetItemRect(hwndCtl,index,lprc)
+///
+/// @brief Gets the dimensions of the rectangle that bounds a property grid item
+///         as it is currently displayed in the property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item in the property grid.
+/// @param lprc A pointer to a RECT structure that receives the client
+///              coordinates for the item in the property grid.
+///
+/// @returns If an error occurs, the return value is LB_ERR.
+#define PropGrid_GetItemRect(hwndCtl,index,lprc) ((int)(DWORD)SendMessage((hwndCtl),LB_GETITEMRECT,(WPARAM)(int)(index),(LPARAM)(RECT*)(lprc)))
+
+/// @def PropGrid_GetSel(hwndCtl,index)
+///
+/// @brief Gets the selection state of an item.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item.
+///
+/// @returns If the item is selected, the return value is greater than zero;
+///           otherwise, it is zero. If an error occurs, the return value is LB_ERR.
+#define PropGrid_GetSel(hwndCtl,index) ((int)(DWORD)SendMessage((hwndCtl),LB_GETSEL,(WPARAM)(int)(index),0))
+
+/// @def PropGrid_ResetContent(hwndCtl)
+///
+/// @brief Removes all items from a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns The return value is not meaningful.
+#define PropGrid_ResetContent(hwndCtl) ((BOOL)(DWORD)SendMessage((hwndCtl),LB_RESETCONTENT,0,0))
+
+/// @def PropGrid_SetCurSel(hwndCtl,index)
+///
+/// @brief Sets the currently selected item in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item to select, or –1 to clear the selection.
+///
+/// @returns If an error occurs, the return value is LB_ERR. If the index
+///           parameter is –1, the return value is LB_ERR even though no error occurred. 
+#define PropGrid_SetCurSel(hwndCtl,index) ((int)(DWORD)SendMessage((hwndCtl),LB_SETCURSEL,(WPARAM)(int)(index),0))
+
+/// @def PropGrid_SetHorizontalExtent(hwndCtl,cxExtent)
+///
+/// @brief Set the width by which a property grid can be scrolled horizontally
+///         (the scrollable width). If the width of the property grid is smaller
+///         than this value, the horizontal scroll bar horizontally scrolls items
+///         in the property grid. If the width of the property grid is equal to or
+///         greater than this value, the horizontal scroll bar is hidden.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param cxExtent The number of pixels by which the list box can be scrolled.
+///
+/// @returns No return value.
+#define PropGrid_SetHorizontalExtent(hwndCtl,cxExtent) ((void)SendMessage((hwndCtl),LB_SETHORIZONTALEXTENT,(WPARAM)(int)(cxExtent),0))
+
+/// @def PropGrid_SetItemData(hwndCtl,index,data)
+///
+/// @brief Sets the PROPGRIDITEM associated with the specified property grid item.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param index The zero-based index of the item.
+/// @param data The item data to set.
+///
+/// @returns If an error occurs, the return value is LB_ERR.
+#define PropGrid_SetItemData(hwndCtl,index,data) ((int)(DWORD)SendMessage((hwndCtl),LB_SETITEMDATA,(WPARAM)(int)(index),(LPARAM)(data)))
+
+/// @def PropGrid_SetItemHeight(hwndCtl,cy)
+///
+/// @brief Sets the height of all items in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param cy The height of the items, in pixels.
+///
+/// @returns If the height is invalid, the return value is LB_ERR.
+#define PropGrid_SetItemHeight(hwndCtl,cy) ((int)(DWORD)SendMessage((hwndCtl),LB_SETITEMHEIGHT,(WPARAM)0,MAKELPARAM((cy),0)))
+
+/// @def PropGrid_ExpandCatalogs(hwndCtl, lpszzCatalogs)
+///
+/// @brief Expand certain specified catalogs in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param lpszzCatalogs The list of catalog names each terminated by a null (\\0).
+///
+/// @returns No return value.
+#define PropGrid_ExpandCatalogs(hwndCtl, lpszzCatalogs) ((void)SendMessage((hwndCtl),PG_EXPANDCATALOGS,(WPARAM)0,(LPARAM)(lpszzCatalogs)))
+
+/// @def PropGrid_ExpandAllCatalogs(hwndCtl)
+///
+/// @brief Expand all catalogs in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns No return value.
+#define PropGrid_ExpandAllCatalogs(hwndCtl) ((void)SendMessage((hwndCtl),PG_EXPANDCATALOGS,(WPARAM)0,(LPARAM)NULL))
+
+/// @def PropGrid_CollapseCatalogs(hwndCtl, lpszzCatalogs)
+///
+/// @brief Collapse certain specified catalogs in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param lpszzCatalogs The catalog names each terminated by a null (\\0).
+///
+/// @returns No return value.
+#define PropGrid_CollapseCatalogs(hwndCtl, lpszzCatalogs) ((void)SendMessage((hwndCtl),PG_COLLAPSECATALOGS,(WPARAM)0,(LPARAM)(lpszzCatalogs)))
+
+/// @def PropGrid_CollapseAllCatalogs(hwndCtl)
+///
+/// @brief Collapse all catalogs in a property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+///
+/// @returns No return value.
+#define PropGrid_CollapseAllCatalogs(hwndCtl) ((void)SendMessage((hwndCtl),PG_COLLAPSECATALOGS,(WPARAM)0,(LPARAM)NULL))
+
+/// @def PropGrid_ShowToolTips(hwndCtl,fShow)
+///
+/// @brief Show or hide tooltips in the property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param fShow TRUE for tooltips; FALSE do not show tooltips.
+///
+/// @returns No return value.
+#define PropGrid_ShowToolTips(hwndCtl,fShow) ((void)SendMessage((hwndCtl),PG_SHOWTOOLTIPS,(WPARAM)(fShow),(LPARAM)0L))
+
+/// @def PropGrid_ShowPropertyDescriptions(hwndCtl,fShow)
+///
+/// @brief Show or hide the property discription pane in the property grid.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param fShow TRUE for descriptions; FALSE do not show discription pane.
+///
+/// @returns No return value.
+#define PropGrid_ShowPropertyDescriptions(hwndCtl,fShow) ((void)SendMessage((hwndCtl),PG_SHOWPROPERTYDESC,(WPARAM)(fShow),(LPARAM)0L))
+
+/// @def PropGrid_SetFlatStyleChecks(hwndCtl, fFlat)
+///
+/// @brief Sets the appearance of the checkboxes.
+///
+/// @param hwndCtl The handle of a property grid.
+/// @param fFlat TRUE for flat checkboxes, or FALSE for standard checkboxes.
+///
+/// @returns No return value.
+#define PropGrid_SetFlatStyleChecks(hwndCtl, fFlat) \
+     ((void)SendMessage((hwndCtl),PG_FLATCHECKS,(WPARAM)(BOOL) (fFlat),(LPARAM)0L))
+
+/// @def PropGrid_ItemInit(pgi)
+///
+/// @brief Initialize an item struct.
+///
+/// @param pgi The PROPGRIDITEM struct.
+///
+/// @returns No return value.
+#define PropGrid_ItemInit(pgi) \
+    (pgi.lpszCatalog = NULL,  pgi.lpszPropName = NULL, \
+    pgi.lpszzCmbItems = NULL,  pgi.lpszPropDesc = NULL, \
+    pgi.lpCurValue = 0,  pgi.iItemType = 0)
+
+/// @}
+
+/****************************************************************************/
+// Exported function prototypes
+
+ATOM InitPropertyGrid(HINSTANCE hInstance);
+HWND New_PropertyGrid(HWND hParent, DWORD dwID);
+
+#endif //PROPERTYGRID_H