windows-xp/Source/XPSP1/NT/shell/cpls/system/hwprof.c

/*++

Copyright (c) 1995-2001  Microsoft Corporation

Module Name:

    hwprof.c

Abstract:

    This module contains the dialog box procedure for the Hardware Profiles
    Dialog Box in the System Applet.

Author:

    Paula Tomlinson (paulat) 8-22-1995

Environment:

    User mode only.

Revision History:

    22-Aug-1995     paulat

        Creation and initial implementation.

    21-Jan-1999     jamesca

        Added handling for hardware profile aliases and hardware-detected
        profile attributes.

--*/


//
// include files
//

#include "sysdm.h"
#include <stdlib.h>
#include <usp10.h>
#include <dbt.h>

//
// private types and definitions
//

#define MAX_PROFILES             9999
#define MAX_ALIASES              9999
#define MAX_FRIENDLYNAME_LEN     80
#define MAX_PROFILEID_LEN        5
#define MAX_DOCKID_LEN           128
#define MAX_SERIALNUM_LEN        128

#define MAX_USER_WAIT            500
#define MIN_USER_WAIT            0
#define DEFAULT_USER_WAIT        30

#define MAX_GUID_STRING_LEN      39   // 38 chars + terminating null

typedef struct HWPROFILE_s {
   HWND     hParent;
   ULONG    ulFromProfileID;
   TCHAR    szFromFriendlyName[MAX_FRIENDLYNAME_LEN];
   ULONG    ulToProfileID;
   TCHAR    szToFriendlyName[MAX_FRIENDLYNAME_LEN];
} HWPROFILE, *PHWPROFILE;


typedef struct HWPROF_VALUES_s {
   ULONG    ulAction;
   ULONG    ulProfile;
   ULONG    ulPreferenceOrder;
   ULONG    ulDockState;
   BOOL     bAliasable;
   BOOL     bCloned;
   BOOL     bPortable;
   ULONG    ulCreatedFrom;
   WCHAR    szDockID[MAX_DOCKID_LEN];
   WCHAR    szSerialNumber[MAX_SERIALNUM_LEN];
   WCHAR    szFriendlyName[MAX_FRIENDLYNAME_LEN];
} HWPROF_VALUES, *PHWPROF_VALUES;


typedef struct HWPROF_INFO_s {
   ULONG             ulNumProfiles;
   ULONG             ulActiveProfiles;
   PHWPROF_VALUES    pHwProfValues;
   ULONG             ulSelectedProfile;
   ULONG             ulSelectedProfileIndex;
   BOOL              bPortable;
   BOOL              bHwDetectedPortable;
   ULONG             ulUndockedProfileNameCount;
   ULONG             ulDockedProfileNameCount;
   ULONG             ulUnknownProfileNameCount;
} HWPROF_INFO, *PHWPROF_INFO;


#define HWP_NO_ACTION   0x00000000
#define HWP_DELETE      0x00000001
#define HWP_CREATE      0x00000002
#define HWP_RENAME      0x00000004
#define HWP_REORDER     0x00000008
#define HWP_PROPERTIES  0x00000010
#define HWP_NEWPROFILE  0x00001000

//
// private prototypes
//

BOOL
GetCurrentProfile(
      PULONG  pulProfile
      );

BOOL
GetRegProfileCount(
      PULONG   pulProfiles
      );

BOOL
FillProfileList(
      HWND  hDlg
      );

BOOL
IsProfileNameInUse(
      HWND     hDlg,
      LPTSTR   pszFriendlyName
      );

BOOL
CopyHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex,
      ULONG  ulProfile,
      LPTSTR szNewFriendlyName
      );

BOOL
RenameHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex,
      ULONG  ulProfile,
      LPTSTR szNewFriendlyName
      );

BOOL
DeleteHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex
      );

BOOL
GetUserWaitInterval(
      PULONG   pulWait
      );

BOOL
SetUserWaitInterval(
      ULONG   ulWait
      );

BOOL
GetFreeProfileID(
      PHWPROF_INFO   pInfo,
      PULONG         pulProfile
      );

ULONG
GetOriginalProfile(
      PHWPROF_INFO  pInfo,
      ULONG         ulProfile,
      ULONG         ulBufferIndex
      );

BOOL
InsertRank(
      PHWPROF_INFO   pInfo,
      ULONG          ulRank
      );

BOOL
DeleteRank(
      PHWPROF_INFO   pInfo,
      ULONG          ulRank
      );

BOOL
FlushProfileChanges(
      HWND hDlg,
      HWND hList
      );

BOOL
WriteProfileInfo(
      PHWPROF_VALUES pProfValues
      );

BOOL
RemoveNewProfiles(
      PHWPROF_INFO   pInfo
      );

BOOL
SwapPreferenceOrder(
      HWND  hDlg,
      HWND  hList,
      ULONG_PTR ulIndex1,
      ULONG_PTR ulIndex2
      );

BOOL
DeleteProfileDependentTree(
      ULONG ulProfile
      );

BOOL
CopyAliasEntries(
      ULONG ulSrcProfile,
      ULONG ulDestProfile
      );

BOOL
DeleteAliasEntries(
      ULONG ulProfile
      );

BOOL
CopyAliasEntryType(
      ULONG  ulSrcProfile,
      ULONG  ulDestProfile,
      LPWSTR szSubKeyName
      );

BOOL
DeleteAliasEntryType(
      ULONG  ulProfile,
      LPWSTR szSubKeyName
      );

BOOL
CopyRegistryNode(
      HKEY     hSrcKey,
      HKEY     hDestKey
      );

BOOL
DeleteRegistryNode(
      HKEY     hNodeKey,
      LPTSTR   szSubKey
      );
VOID
AdjustProfileTypeCounter(
      PHWPROF_INFO   pInfo,
      ULONG          ulDockState,
      BOOL           bIncrement
      );

BOOL
StripCurrentTag(
      LPTSTR   szOriginalName,
      ULONG    ulProfile,
      ULONG    ulCurrentProfile
      );

BOOL
AppendCurrentTag(
      LPTSTR   szTaggedName,
      LPCTSTR  szOriginalName,
      ULONG    ulProfile,
      ULONG    ulCurrentProfile
      );

VOID
CreateHwProfileFriendlyName(
      IN  HWND    hDlg,
      IN  ULONG   ulDockState,
      OUT LPTSTR  szFriendlyName
   );

VOID
DisplayPrivateMessage(
      HWND  hDlg,
      UINT  uiPrivateError
      );

VOID
DisplaySystemMessage(
      HWND  hWnd,
      UINT  uiSystemError
      );

BOOL
UpdateOrderButtonState(
      HWND  hDlg
      );

BOOL
DisplayProperties(
      IN HWND           hOwnerDlg,
      IN PHWPROF_INFO   pProfValues
      );

typedef BOOL (CALLBACK FAR * LPFNADDPROPSHEETPAGE)(HPROPSHEETPAGE, LPARAM);


//
// global strings
//
WCHAR pszErrorCaption[MAX_PATH];
WCHAR pszRegDefaultFriendlyName[MAX_FRIENDLYNAME_LEN];
WCHAR pszCurrentTag[64];
WCHAR pszUnavailable[64];
WCHAR pszDocked[64];
WCHAR pszUndocked[64];
WCHAR pszUnknown[64];

WCHAR pszRegIDConfigDB[] = TEXT("System\\CurrentControlSet\\Control\\IDConfigDB");
WCHAR pszRegHwProfiles[] = TEXT("System\\CurrentControlSet\\Hardware Profiles");
WCHAR pszRegKnownDockingStates[] =  TEXT("Hardware Profiles");
WCHAR pszRegCurrentDockInfo[] =     TEXT("CurrentDockInfo");
WCHAR pszRegDockingState[] =        TEXT("DockingState");
WCHAR pszRegAlias[] =               TEXT("Alias");
WCHAR pszRegAcpiAlias[] =           TEXT("AcpiAlias");
WCHAR pszRegProfileNumber[] =       TEXT("ProfileNumber");
WCHAR pszRegCurrentConfig[] =       TEXT("CurrentConfig");
WCHAR pszRegUserWaitInterval[] =    TEXT("UserWaitInterval");
WCHAR pszRegFriendlyName[] =        TEXT("FriendlyName");
WCHAR pszRegPristine[] =            TEXT("Pristine");
WCHAR pszRegHwProfileGuid[] =       TEXT("HwProfileGuid");
WCHAR pszRegPreferenceOrder[] =     TEXT("PreferenceOrder");
WCHAR pszRegDockState[] =           TEXT("DockState");
WCHAR pszRegAliasable[] =           TEXT("Aliasable");
WCHAR pszRegCloned[] =              TEXT("Cloned");
WCHAR pszRegIsPortable[] =          TEXT("IsPortable");
WCHAR pszRegDockID[] =              TEXT("DockID");
WCHAR pszRegSerialNumber[] =        TEXT("SerialNumber");
WCHAR pszRegAcpiSerialNumber[] =    TEXT("AcpiSerialNumber");
WCHAR pszRegPropertyProviders[] =   TEXT("PropertyProviders");
WCHAR pszRegDocked[] =              TEXT("Docked");
WCHAR pszRegUndocked[] =            TEXT("Undocked");
WCHAR pszRegUnknown[] =             TEXT("Unknown");

//
// global mutex for synchronization
//
WCHAR  pszNamedMutex[] =            TEXT("System-HardwareProfiles-PLT");
HANDLE g_hMutex = NULL;

//
// global info for property sheet extensions
//
#define MAX_EXTENSION_PROVIDERS  32
HMODULE        hLibs[MAX_EXTENSION_PROVIDERS];
HPROPSHEETPAGE hPages[MAX_EXTENSION_PROVIDERS];
ULONG          ulNumPages = 0;
BOOL           bAdmin = FALSE;


static int HwProfileHelpIds[] = {
   IDD_HWP_PROFILES,        (IDH_HWPROFILE + IDD_HWP_PROFILES),
   IDD_HWP_PROPERTIES,      (IDH_HWPROFILE + IDD_HWP_PROPERTIES),
   IDD_HWP_COPY,            (IDH_HWPROFILE + IDD_HWP_COPY),
   IDD_HWP_RENAME,          (IDH_HWPROFILE + IDD_HWP_RENAME),
   IDD_HWP_DELETE,          (IDH_HWPROFILE + IDD_HWP_DELETE),
   IDD_HWP_ST_MULTIPLE,     (IDH_HWPROFILE + IDD_HWP_ST_MULTIPLE),
   IDD_HWP_WAITFOREVER,     (IDH_HWPROFILE + IDD_HWP_WAITFOREVER),
   IDD_HWP_WAITUSER,        (IDH_HWPROFILE + IDD_HWP_WAITUSER),
   IDD_HWP_SECONDS,         (IDH_HWPROFILE + IDD_HWP_SECONDS),
   IDD_HWP_SECSCROLL,       (IDH_HWPROFILE + IDD_HWP_SECSCROLL),
   IDD_HWP_COPYTO,          (IDH_HWPROFILE + IDD_HWP_COPYTO),
   IDD_HWP_COPYTO_CAPTION,  (IDH_HWPROFILE + IDD_HWP_COPYTO),
   IDD_HWP_COPYFROM,        (IDH_HWPROFILE + IDD_HWP_COPYFROM),
   IDD_HWP_ST_DOCKID,       (IDH_HWPROFILE + IDD_HWP_ST_DOCKID),
   IDD_HWP_ST_SERIALNUM,    (IDH_HWPROFILE + IDD_HWP_ST_SERIALNUM),
   IDD_HWP_DOCKID,          (IDH_HWPROFILE + IDD_HWP_DOCKID),
   IDD_HWP_SERIALNUM,       (IDH_HWPROFILE + IDD_HWP_SERIALNUM),
   IDD_HWP_PORTABLE,        (IDH_HWPROFILE + IDD_HWP_PORTABLE),
   IDD_HWP_ALIASABLE,       IDH_HWP_PROPERTIES_SELECTION_CHECKBOX,
   IDD_HWP_UNKNOWN,         (IDH_HWPROFILE + IDD_HWP_UNKNOWN),
   IDD_HWP_DOCKED,          (IDH_HWPROFILE + IDD_HWP_DOCKED),
   IDD_HWP_UNDOCKED,        (IDH_HWPROFILE + IDD_HWP_UNDOCKED),
   IDD_HWP_ST_PROFILE,      (IDH_HWPROFILE + IDD_HWP_ST_PROFILE),
   IDD_HWP_ORDERUP,         (IDH_HWPROFILE + IDD_HWP_ORDERUP),
   IDD_HWP_ORDERDOWN,       (IDH_HWPROFILE + IDD_HWP_ORDERDOWN),
   IDD_HWP_RENAMEFROM,      (IDH_HWPROFILE + IDD_HWP_RENAMEFROM),
   IDD_HWP_RENAMETO,        (IDH_HWPROFILE + IDD_HWP_RENAMETO),
   IDD_HWP_RENAMETO_CAPTION,(IDH_HWPROFILE + IDD_HWP_RENAMETO),
   IDD_HWP_WAITUSER_TEXT_1, (IDH_HWPROFILE + IDD_HWP_SECSCROLL),
   IDD_HWP_UNUSED_1,        -1,
   IDD_HWP_UNUSED_2,        -1,
   IDD_HWP_UNUSED_3,        -1,
   IDD_HWP_UNUSED_4,        -1,
   IDD_HWP_UNUSED_5,        -1,
   IDD_HWP_UNUSED_6,        -1,
   0, 0
};


/**-------------------------------------------------------------------------**/
INT_PTR
APIENTRY
HardwareProfilesDlg(
      HWND    hDlg,
      UINT    uMessage,
      WPARAM  wParam,
      LPARAM  lParam
      )

{
   BOOL           Status;
   ULONG          ulCurrentProfile, ulSelectedProfile,
                  ulWait, ulBufferIndex = 0;
   ULONG_PTR      ulIndex;
   LONG           lValue;
   TCHAR          szProfileName[MAX_PATH], szName[MAX_PATH];
   HWND           hList;
   int            nValue;
   HWPROFILE      HwSelectedProfile;
   LPNM_UPDOWN    pUDData;
   PHWPROF_INFO   pInfo;
   HICON          hIcon;


   switch (uMessage)
   {
      case WM_INITDIALOG:
         bAdmin = IsUserAdmin();

         //
         // attempt to claim the named mutex and lock other instances of
         // this dialog box out
         //
         g_hMutex = CreateMutex(NULL, TRUE, pszNamedMutex);

         if (g_hMutex == NULL) {

            if (GetLastError() == ERROR_ALREADY_EXISTS) {
               DisplayPrivateMessage(hDlg, HWP_ERROR_IN_USE);
            } else {
               DisplaySystemMessage(hDlg, GetLastError());
            }

            EndDialog(hDlg, FALSE);
            return FALSE;
         }

         //
         // load some global strings
         //
         LoadString(hInstance, HWP_CURRENT_TAG, pszCurrentTag, 64);
         LoadString(hInstance, HWP_UNAVAILABLE, pszUnavailable, 64);
         LoadString(hInstance, HWP_UNKNOWN_PROFILE,  pszUnknown, 64);
         LoadString(hInstance, HWP_DOCKED_PROFILE,   pszDocked, 64);
         LoadString(hInstance, HWP_UNDOCKED_PROFILE, pszUndocked, 64);
         LoadString(hInstance, HWP_ERROR_CAPTION, pszErrorCaption, MAX_PATH);
         LoadString(hInstance, HWP_DEF_FRIENDLYNAME, pszRegDefaultFriendlyName,
                  MAX_FRIENDLYNAME_LEN);

         //
         // fill the profiles listbox with all installed profiles,
         // this will also select the current profile
         //
         if (!FillProfileList(hDlg)) {
            EndDialog(hDlg, FALSE);
            return FALSE;
         }

         pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

         //
         // place the icons on the up and down selection buttons
         //
         SendDlgItemMessage(
               hDlg, IDD_HWP_ORDERUP, BM_SETIMAGE, (WPARAM)IMAGE_ICON,
               (LPARAM)LoadIcon(hInstance, MAKEINTRESOURCE(UP_ICON)));

         SendDlgItemMessage(
               hDlg, IDD_HWP_ORDERDOWN, BM_SETIMAGE, (WPARAM)IMAGE_ICON,
               (LPARAM)LoadIcon(hInstance, MAKEINTRESOURCE(DOWN_ICON)));

         //
         // update button enable/disable states
         //
         UpdateOrderButtonState(hDlg);

         //
         // disable Delete for the current profile
         //
         EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE), FALSE);

         //
         // disable copy if we're already at the max number of profiles
         // (including the pristine profile)
         //
         if ((pInfo->ulNumProfiles+1) > MAX_PROFILES) {
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_COPY), FALSE);
         }

         //
         // initialize the user wait setting
         //
         SendDlgItemMessage(hDlg, IDD_HWP_SECSCROLL, UDM_SETBASE, 10, 0);
         SendDlgItemMessage(hDlg, IDD_HWP_SECSCROLL, UDM_SETRANGE, 0,
                  MAKELONG((SHORT)MAX_USER_WAIT, (SHORT)MIN_USER_WAIT));
         SendDlgItemMessage(hDlg, IDD_HWP_SECONDS, EM_LIMITTEXT, 3, 0L);

         GetUserWaitInterval(&ulWait);

         if (ulWait == 0xFFFFFFFF) {
             CheckRadioButton(hDlg, IDD_HWP_WAITFOREVER, IDD_HWP_WAITUSER,
                              IDD_HWP_WAITFOREVER);
            SendDlgItemMessage(hDlg, IDD_HWP_SECSCROLL, UDM_SETPOS, 0,
                               DEFAULT_USER_WAIT);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECONDS), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECSCROLL), FALSE);
         }
         else {
            CheckRadioButton(hDlg, IDD_HWP_WAITFOREVER, IDD_HWP_WAITUSER,
                             IDD_HWP_WAITUSER);
            SendDlgItemMessage(hDlg, IDD_HWP_SECSCROLL, UDM_SETPOS, 0, ulWait);
         }

         //
         // Disable all actions if user not part of administrators local group
         //
         if (!bAdmin) {
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERUP),    FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_PROPERTIES), FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_COPY),       FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_RENAME),     FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE),     FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERDOWN),  FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_WAITFOREVER),FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_WAITUSER),   FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_WAITUSER_TEXT_1), FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECONDS),    FALSE);
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECSCROLL),  FALSE);
         }
         return 0;


      case WM_HELP:
         WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE,
               HELP_WM_HELP, (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;

      case WM_CONTEXTMENU:
         WinHelp((HWND)wParam, HELP_FILE, HELP_CONTEXTMENU,
               (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;

      case WM_DESTROY:
          //
          // only free the buffer if we've already initialized
          //
          pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

          if (pInfo) {
              LocalFree((HLOCAL)pInfo->pHwProfValues);
              LocalFree((HLOCAL)pInfo);

              hIcon = (HICON)SendDlgItemMessage(
                    hDlg, IDD_HWP_ORDERUP, BM_GETIMAGE, 0, 0);
              if (hIcon) {
                 DeleteObject(hIcon);
              }

              hIcon = (HICON)SendDlgItemMessage(
                    hDlg, IDD_HWP_ORDERDOWN, BM_GETIMAGE, 0, 0);
              if (hIcon) {
                 DeleteObject(hIcon);
              }
          }
          break;

      case WM_DEVICECHANGE:
          //
          // If a hardware profile change event takes place while the dialog is
          // up, just dismiss the dialog because things have changed.
          //
          if (wParam == DBT_CONFIGCHANGED) {
              EndDialog(hDlg, FALSE);
              return FALSE;
          }
          break;

      case WM_COMMAND:
      {
         switch (LOWORD(wParam))
         {
            case IDOK:
                if (bAdmin) {
                    //
                    // save the user wait interval in the registry
                    //
                    if (IsDlgButtonChecked(hDlg, IDD_HWP_WAITFOREVER)) {
                        ulWait = 0xFFFFFFFF;
                    }
                    else {
                        ulWait = GetDlgItemInt(hDlg, IDD_HWP_SECONDS,
                            &Status, FALSE);
                        if (!Status  ||  ulWait > MAX_USER_WAIT) {
                            TCHAR szCaption[MAX_PATH];
                            TCHAR szMsg[MAX_PATH];

                            LoadString(hInstance, HWP_ERROR_CAPTION, szCaption, MAX_PATH);
                            LoadString(hInstance, HWP_INVALID_WAIT, szMsg, MAX_PATH);
        
                            MessageBox(hDlg, szMsg, szCaption,
                                       MB_OK | MB_ICONEXCLAMATION);
        
                            SetFocus(GetDlgItem(hDlg, IDD_HWP_SECONDS));
        
                            return(TRUE);
                        }
                    }
                    SetUserWaitInterval(ulWait);
    
                    //
                    // flush the pending changes in profile buffer
                    //
                    hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);
                    FlushProfileChanges(hDlg, hList);
                }
                EndDialog(hDlg, 0);
                break;

            case IDCANCEL:
                pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

                if (pInfo) {
                    //
                    // If profile modifications have already been commited from
                    // within the Property Sheet, that's okay. But if accessing
                    // Properties caused any profiles to be created then they
                    // should be removed now since the user is effectively
                    // cancelling that creation now by cancelling from the main
                    // Hardware Profiles dialog.
                    //
                    if (bAdmin) {
                        RemoveNewProfiles(pInfo);
                    }
                }
                SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
                EndDialog(hDlg, 0);
                break;

            case IDD_HWP_ORDERUP:
               //
               // move selected profile "up" in preference order
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

               //
               // if we're not already at the top, swap preferences
               //
               if (ulIndex > 0) {
                  SwapPreferenceOrder(hDlg, hList, ulIndex, ulIndex-1);
                  UpdateOrderButtonState(hDlg);
                  PropSheet_Changed(GetParent(hDlg), hDlg);
               }
               break;


            case IDD_HWP_ORDERDOWN:
               //
               // move selected profile "down" in preference order
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

               //
               // if we're not already at the bottom, swap preferences
               //
               if (ulIndex < pInfo->ulNumProfiles-1) {
                  SwapPreferenceOrder(hDlg, hList, ulIndex, ulIndex+1);
                  UpdateOrderButtonState(hDlg);
                  PropSheet_Changed(GetParent(hDlg), hDlg);
               }
               break;


            case IDD_HWP_PROFILES:
               //
               // selection changed, enable/disable Delete button based
               // on whether it's the current config that is selected
               //

               if (bAdmin) {

                   if (HIWORD(wParam) == LBN_DBLCLK) {
                      SendMessage(hDlg, WM_COMMAND, MAKELONG(IDD_HWP_PROPERTIES,0), 0);
                   }
                   else if (HIWORD(wParam) == LBN_SELCHANGE) {

                      if (!GetCurrentProfile(&ulCurrentProfile)) {
                         break;
                      }

                      if ((ulIndex = SendMessage((HWND)lParam,
                            LB_GETCURSEL, 0, 0)) == LB_ERR) {
                         break;
                      }

                      if ((lValue = (LONG)SendMessage((HWND)lParam, LB_GETITEMDATA,
                            ulIndex, 0)) == LB_ERR) {
                         break;
                      }

                      if ((ULONG)lValue == ulCurrentProfile) {
                         EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE), FALSE);
                      }
                      else {
                         EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE), TRUE);
                      }


                      //
                      // update button enable/disable states
                      //
                      UpdateOrderButtonState(hDlg);
                   }
               }
               break;


            case IDD_HWP_WAITFOREVER:
               //
               // if user chooses wait forever, disable the seconds control
               //
               if (HIWORD(wParam) == BN_CLICKED) {
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECONDS), FALSE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECSCROLL), FALSE);
                  PropSheet_Changed(GetParent(hDlg), hDlg);
               }
               break;


            case IDD_HWP_WAITUSER:
               //
               // if user chooses a wait interval, reenable seconds control
               //
               if (HIWORD(wParam) == BN_CLICKED) {
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECONDS), TRUE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_SECSCROLL), TRUE);
                  PropSheet_Changed(GetParent(hDlg), hDlg);
               }
               break;


            case IDD_HWP_PROPERTIES:
               //
               // retrieve the profile buffer
               //
               pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

               //
               // get the selected profile
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               //
               // find the profile entry in the buffer that matches the selection
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);
               ulSelectedProfile = (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex, 0);

               while (ulBufferIndex < pInfo->ulNumProfiles) {
                  if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulSelectedProfile) {
                     break;
                  }
                  ulBufferIndex++;
               }

               //
               // commit the changes for this profile before calling Properties
               //
               WriteProfileInfo(&pInfo->pHwProfValues[ulBufferIndex]);

               //
               // pass the HWPROF_VALUES struct for the selected profile
               // to the property sheet page when it's created. The
               // property sheet may update some of these fields and
               // may also commit changes for this profile to the registry.
               //
               pInfo->ulSelectedProfileIndex = ulBufferIndex;
               pInfo->ulSelectedProfile = (ULONG)SendMessage(hList, LB_GETITEMDATA,
                                                      ulIndex, 0);

               DisplayProperties(hDlg, pInfo);
               //DisplayProperties(hDlg, &pInfo->pHwProfValues[ulBufferIndex]);
               break;


            case IDD_HWP_COPY:               
               //
               // retrieve the profile buffer
               //
               pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

               //
               // get the selected profile, this is the "From" selection
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               SendMessage(hList, LB_GETTEXT, ulIndex,
                     (LPARAM)(LPCTSTR)HwSelectedProfile.szFromFriendlyName);
               HwSelectedProfile.ulFromProfileID =
                     (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex, 0);

               //
               // find the profile entry in the buffer that matches the selection
               //
               ulBufferIndex = 0;
               while (ulBufferIndex < pInfo->ulNumProfiles) {
                   if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == HwSelectedProfile.ulFromProfileID) {
                       break;
                   }
                   ulBufferIndex++;
               }


               //
               // determine the next suggested name for the given profile
               //
               CreateHwProfileFriendlyName(hDlg,
                                           pInfo->pHwProfValues[ulBufferIndex].ulDockState,
                                           HwSelectedProfile.szToFriendlyName);

               //
               // pass selected profile info to copy profile dialog box
               //

               HwSelectedProfile.hParent = hDlg;

               if (!DialogBoxParam(hInstance,
                        MAKEINTRESOURCE(DLG_HWP_COPY), hDlg,
                        CopyProfileDlg,
                        (LPARAM)&HwSelectedProfile)) {
                  //
                  // if returns FALSE, either user canceled or no work
                  // required
                  //
                  break;
               }

               //
               // clone the profile in the in-memory profile buffer
               // and update the display
               //
               CopyHardwareProfile(
                        hDlg,
                        ulIndex,
                        HwSelectedProfile.ulFromProfileID,
                        HwSelectedProfile.szToFriendlyName);

               UpdateOrderButtonState(hDlg);
               PropSheet_Changed(GetParent(hDlg), hDlg);
               break;


            case IDD_HWP_RENAME:
               //
               // get the selected profile
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               SendMessage(hList, LB_GETTEXT, ulIndex,
                     (LPARAM)(LPCTSTR)HwSelectedProfile.szFromFriendlyName);
               HwSelectedProfile.ulFromProfileID =
                     (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex, 0);

               //
               // strip off the current tag if it exists "(Current)"
               //
               GetCurrentProfile(&ulCurrentProfile);

               StripCurrentTag(
                     HwSelectedProfile.szFromFriendlyName,
                     HwSelectedProfile.ulFromProfileID,
                     ulCurrentProfile);

               // pass selected profile info to rename profile dialog box
               //

               HwSelectedProfile.hParent = hDlg;

               if (!DialogBoxParam(hInstance,
                        MAKEINTRESOURCE(DLG_HWP_RENAME), hDlg,
                        RenameProfileDlg,
                        (LPARAM)&HwSelectedProfile)) {
                  //
                  // if returns FASLE, either user canceled or no work
                  // required (i.e., user chose same name or zero-length
                  // name)
                  //
                  break;
               }

               //
               // rename the profile in the in-memory profile buffer
               // and update the display
               //
               RenameHardwareProfile(
                        hDlg,
                        ulIndex,
                        HwSelectedProfile.ulFromProfileID,
                        HwSelectedProfile.szToFriendlyName);

               PropSheet_Changed(GetParent(hDlg), hDlg);
               break;


            case IDD_HWP_DELETE: {

               TCHAR szCaption[MAX_PATH];
               TCHAR szMsg[MAX_PATH];
               TCHAR szMsg1[MAX_PATH];

               //
               // get the selected profile
               //
               hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

               ulIndex = SendMessage(hList, LB_GETCURSEL, 0, 0);
               if (ulIndex == LB_ERR) {
                  break;
               }

               //
               // confirm that user really wants to delete the profile
               // (the confirm message has a substitute symbol for
               // profile name)
               //
               SendMessage(hList, LB_GETTEXT, ulIndex,
                     (LPARAM)(LPCTSTR)szProfileName);

               LoadString(hInstance, HWP_CONFIRM_DELETE_CAP, szCaption, MAX_PATH);
               LoadString(hInstance, HWP_CONFIRM_DELETE, szMsg1, MAX_PATH);

               wsprintf(szMsg, szMsg1, szProfileName);

               if (MessageBox(hDlg, szMsg, szCaption,
                              MB_YESNO | MB_ICONQUESTION) == IDNO) {
                   break;
               }

               //
               // mark the profile as deleted in the in-memory buffer
               // and update the display
               //
               DeleteHardwareProfile(
                        hDlg,
                        ulIndex);

               UpdateOrderButtonState(hDlg);
               PropSheet_Changed(GetParent(hDlg), hDlg);
               break;
             }

             case IDD_HWP_SECONDS:

                if (HIWORD(wParam) == EN_UPDATE) {
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                }
                break;

            default:
               return FALSE;
          }
          break;

       } // case WM_COMMAND...

       default:
          return FALSE;
          break;
    }

    return TRUE;

} // HardwareProfilesDlg



/**-------------------------------------------------------------------------**/
INT_PTR
APIENTRY
CopyProfileDlg(
      HWND    hDlg,
      UINT    uMessage,
      WPARAM  wParam,
      LPARAM  lParam
      )

{
   PHWPROFILE  pHwProfile;
   static HIMC himcOrg;


   switch (uMessage)
   {
      case WM_INITDIALOG:
         //
         // the profile info struct is passed in lparam, save in
         // Window word for thread-safe use in later messages
         //
         SetWindowLongPtr(hDlg, DWLP_USER, lParam);
         pHwProfile = (PHWPROFILE)lParam;

         //
         // initialize "To" and "From" fields
         //
         SendDlgItemMessage(hDlg, IDD_HWP_COPYTO, EM_LIMITTEXT,
               MAX_FRIENDLYNAME_LEN-1, 0L);
         SetDlgItemText(hDlg, IDD_HWP_COPYFROM, pHwProfile->szFromFriendlyName);
         SetDlgItemText(hDlg, IDD_HWP_COPYTO, pHwProfile->szToFriendlyName);
         SendDlgItemMessage(hDlg, IDD_HWP_COPYTO, EM_SETSEL, 0, -1);
         SetFocus(GetDlgItem(hDlg, IDD_HWP_COPYTO));
         //
         // Remove any association the window may have with an input context,
         // because we don't allow to use DBCS in H/W profile name.
         //
         himcOrg = ImmAssociateContext(GetDlgItem(hDlg, IDD_HWP_COPYTO), (HIMC)NULL);
         return FALSE;

      case WM_DEVICECHANGE:
         //
         // If a hardware profile change event takes place while the dialog is
         // up, just dismiss the dialog because things have changed.
         //
         if (wParam == DBT_CONFIGCHANGED) {
            EndDialog(hDlg, FALSE);
            return FALSE;
         }
         break;

      case WM_DESTROY:
         if (himcOrg)
           ImmAssociateContext(GetDlgItem(hDlg, IDD_HWP_COPYTO), himcOrg);
         return FALSE;

      case WM_HELP:
         WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE,
               HELP_WM_HELP, (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;

      case WM_CONTEXTMENU:
         WinHelp((HWND)wParam, HELP_FILE, HELP_CONTEXTMENU,
                  (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;


      case WM_COMMAND:
      {
         switch (LOWORD(wParam))
         {
            case IDOK:
               pHwProfile = (PHWPROFILE)GetWindowLongPtr(hDlg, DWLP_USER);

               GetDlgItemText(hDlg, IDD_HWP_COPYTO,
                     pHwProfile->szToFriendlyName, MAX_FRIENDLYNAME_LEN);


               if (pHwProfile->szToFriendlyName == NULL ||
                        *pHwProfile->szToFriendlyName == '\0') {
                  //
                  // accept request to copy to zero-length string but
                  // do nothing (return FALSE from DialogBox call)
                  //
                  EndDialog(hDlg, FALSE);
                  return TRUE;
               }

               //
               // Check for duplicates
               //

               if (IsProfileNameInUse(pHwProfile->hParent,
                                      pHwProfile->szToFriendlyName)) {
                  //
                  // if name already used by a different profile (including
                  // the name of this profile), deny the request, but don't
                  // end the dialog box
                  //
                  DisplayPrivateMessage(hDlg, HWP_ERROR_PROFILE_IN_USE);
                  break;
               }

               //
               // Check for complex script names
               //
               if (S_OK == ScriptIsComplex(pHwProfile->szToFriendlyName, lstrlen(pHwProfile->szToFriendlyName), SIC_COMPLEX))
               {
                   DisplayPrivateMessage(hDlg, HWP_ERROR_COMPLEX_SCRIPT);
                   break;
               }                  

               //
               // otherwise, we'll accept the name
               //
               EndDialog(hDlg,TRUE);
               break;

            case IDCANCEL:
               EndDialog(hDlg,FALSE);
               break;

            default:
               return FALSE;
          }
          break;

       } // case WM_COMMAND...

       default:
          return FALSE;
          break;
    }

    return TRUE;

} // CopyProfileDlg



/**-------------------------------------------------------------------------**/
INT_PTR
APIENTRY
RenameProfileDlg(
      HWND    hDlg,
      UINT    uMessage,
      WPARAM  wParam,
      LPARAM  lParam
      )

{
   PHWPROFILE  pHwProfile;
   ULONG       ulReturn;
   static HIMC himcOrg;


   switch (uMessage)
   {
      case WM_INITDIALOG:
         //
         // the profile info struct is passed in lparam, save in
         // Window word for thread-safe use in later messages
         //
         SetWindowLongPtr(hDlg, DWLP_USER, lParam);
         pHwProfile = (PHWPROFILE)lParam;

         //
         // initialize "To" and "From" fields
         //
         SendDlgItemMessage(hDlg, IDD_HWP_RENAMETO, EM_LIMITTEXT,
               MAX_FRIENDLYNAME_LEN-1, 0L);
         SetDlgItemText(hDlg, IDD_HWP_RENAMEFROM, pHwProfile->szFromFriendlyName);
         SetDlgItemText(hDlg, IDD_HWP_RENAMETO, pHwProfile->szFromFriendlyName);
         SendDlgItemMessage(hDlg, IDD_HWP_RENAMETO, EM_SETSEL, 0, -1);
         SetFocus(GetDlgItem(hDlg, IDD_HWP_RENAMETO));
         //
         // Remove any association the window may have with an input context,
         // because we don't allow to use DBCS in H/W profile name.
         //
         himcOrg = ImmAssociateContext(GetDlgItem(hDlg, IDD_HWP_RENAMETO), (HIMC)NULL);
         return FALSE;


      case WM_DESTROY:
         if (himcOrg)
           ImmAssociateContext(GetDlgItem(hDlg, IDD_HWP_RENAMETO), himcOrg);
         return FALSE;

      case WM_DEVICECHANGE:
         //
         // If a hardware profile change event takes place while the dialog is
         // up, just dismiss the dialog because things have changed.
         //
         if (wParam == DBT_CONFIGCHANGED) {
            EndDialog(hDlg, FALSE);
            return FALSE;
         }
         break;


      case WM_HELP:
         WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE,
               HELP_WM_HELP, (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;

      case WM_CONTEXTMENU:
         WinHelp((HWND)wParam, HELP_FILE, HELP_CONTEXTMENU,
                  (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;


      case WM_COMMAND:
      {
         switch (LOWORD(wParam))
         {
            case IDOK:
               pHwProfile = (PHWPROFILE)GetWindowLongPtr(hDlg, DWLP_USER);

               ulReturn = GetDlgItemText(hDlg, IDD_HWP_RENAMETO,
                     pHwProfile->szToFriendlyName, MAX_FRIENDLYNAME_LEN);


               if (pHwProfile->szToFriendlyName == NULL ||
                        *pHwProfile->szToFriendlyName == '\0') {
                  //
                  // accept request to copy to zero-length string but
                  // do nothing (return FALSE from DialogBox call)
                  //
                  EndDialog(hDlg, FALSE);
                  return TRUE;
               }

               if (lstrcmpi(pHwProfile->szToFriendlyName,
                        pHwProfile->szFromFriendlyName) == 0) {
                  //
                  // accept request to rename to same name but do
                  // nothing (return FALSE from DialogBox call)
                  //
                  EndDialog(hDlg, FALSE);
                  return TRUE;
               }

               //
               // Check for duplicates
               //

               if (IsProfileNameInUse(pHwProfile->hParent,
                                      pHwProfile->szToFriendlyName)) {
                  //
                  // if name already used by a different profile, deny
                  // the request, but don't end the dialog box
                  //
                  DisplayPrivateMessage(hDlg, HWP_ERROR_PROFILE_IN_USE);
                  break;
               }

               //
               // Check for complex script names
               //
               if (S_OK == ScriptIsComplex(pHwProfile->szToFriendlyName, lstrlen(pHwProfile->szToFriendlyName), SIC_COMPLEX))
               {
                   DisplayPrivateMessage(hDlg, HWP_ERROR_COMPLEX_SCRIPT);
                   break;
               }                  

               //
               // otherwise, we'll accept the name
               //
               EndDialog(hDlg,TRUE);
               break;

            case IDCANCEL:
               EndDialog(hDlg,FALSE);
               break;

            default:
               return FALSE;
          }
          break;

       } // case WM_COMMAND...

       default:
          return FALSE;
          break;
    }

    return TRUE;

} // RenameProfileDlg




/**-------------------------------------------------------------------------**/
BOOL
GetCurrentProfile(
      PULONG  pulProfile
      )
{
   WCHAR    RegStr[MAX_PATH];
   ULONG    ulSize;
   HKEY     hKey;


   //
   // open the IDConfigDB key
   //
   if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
            KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS) {

      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   //
   // retrieve the CurrentConfig value
   //
   ulSize = sizeof(ULONG);
   if (RegQueryValueEx(
            hKey, pszRegCurrentConfig, NULL, NULL,
            (LPBYTE)pulProfile, &ulSize) != ERROR_SUCCESS) {

      RegCloseKey(hKey);
      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   RegCloseKey(hKey);
   return TRUE;

} // GetCurrentProfile


/**-------------------------------------------------------------------------**/
BOOL
GetRegProfileCount(
      PULONG   pulProfiles
      )
{
   WCHAR    RegStr[MAX_PATH];
   HKEY     hKey;


   //
   // open the Known Docking States key
   //
   wsprintf(RegStr, TEXT("%s\\%s"),
            pszRegIDConfigDB,
            pszRegKnownDockingStates);

   if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0, KEY_READ,
            &hKey) != ERROR_SUCCESS) {

      *pulProfiles = 0;
      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   //
   // find out the total number of profiles
   //
   if (RegQueryInfoKey(
            hKey, NULL, NULL, NULL, pulProfiles, NULL, NULL, NULL,
            NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {

      *pulProfiles = 0;
      RegCloseKey(hKey);
      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   ASSERT(*pulProfiles > 0);  // The key for the pristine profile should be there, at least.
   *pulProfiles-= 1;          // Don't count the pristine in the number or working profiles.

   RegCloseKey(hKey);
   return TRUE;

} // GetRegProfileCount


/**-------------------------------------------------------------------------**/
BOOL
GetSelectedProfile(
      HWND     hCtl,
      PULONG   pulSelectedProfile
      )
{
    LONG lSelect;

    // THIS ISN"T BEING CALLED RIGHT NOW, IF IT STARTS GETTING CALLED,
    // THERE SHOULD BE LOGIC FOR REENABLING OR DISABLING THE DELETE
    // BUTTON BASED ON WHETHER THE FIRST INDEX IS THE CURRENT PROFILE
    // (ONLY APPLIES TO THE ERROR CASE WHERE THERE ARE NO CURRENT
    // SELECTIONS)

    lSelect = (LONG)SendMessage(hCtl, LB_GETCURSEL, 0, 0);

    if (lSelect != LB_ERR) {

      *pulSelectedProfile =
         (ULONG)SendMessage(hCtl, LB_GETITEMDATA, lSelect, 0);
    }
    else {
       //
       // no selections, assume first one
       //
       SendMessage(hCtl, LB_SETCURSEL, 0, 0);

       *pulSelectedProfile = (ULONG)SendMessage(hCtl, LB_GETITEMDATA, 0, 0);
    }

    return TRUE;

} // GetSelectedProfile



/**-------------------------------------------------------------------------**/
BOOL
FillProfileList(
      HWND  hDlg
      )

{
   HWND           hList;
   ULONG          ulCurrentProfile, ulCurrentIndex;
   ULONG          ulIndex=0, ulSize=0;
   ULONG          enumIndex = 0, ulProfileID=0;
   ULONG          ulCurrentDockingState = 0;
   ULONG          ulDockID = 0, ulSerialNumber=0;
   HKEY           hKey = NULL, hCfgKey = NULL;
   HKEY           hCurrent = NULL;
   WCHAR          RegStr[MAX_PATH], szName[MAX_PATH];
   ULONG          RegStatus = ERROR_SUCCESS;
   WCHAR          szFriendlyName[MAX_FRIENDLYNAME_LEN];
   WCHAR          szProfile[MAX_PROFILEID_LEN];
   PHWPROF_INFO   pInfo;
   LRESULT        lReturn;
   REGSAM         sam;


   //
   // retrieve a handle to the listbox window
   //
   hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

   //
   // retrieve the id of the current profile
   //
   if (!GetCurrentProfile(&ulCurrentProfile)) {
      DisplaySystemMessage(hDlg, ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
   }

   //
   // allocate a buffer for the main profile info struct
   //
   pInfo = (PHWPROF_INFO) LocalAlloc(LPTR, sizeof(HWPROF_INFO));

   if (pInfo == NULL) {
      DisplaySystemMessage(hDlg, ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
   }

   //
   // save the number of profiles currently in the registry
   //
   if (!GetRegProfileCount(&(pInfo->ulNumProfiles))) {
      LocalFree((HLOCAL)pInfo);
      return FALSE;
   }

   pInfo->ulActiveProfiles = pInfo->ulNumProfiles;

   //
   // Initialize the hardware detected portable flag
   //
   pInfo->bHwDetectedPortable = FALSE;

   //
   // allocate a buffer to hold all the profile values
   //
   pInfo->pHwProfValues = (PHWPROF_VALUES) LocalAlloc(LPTR, sizeof(HWPROF_VALUES) * pInfo->ulNumProfiles);

   if (pInfo->pHwProfValues == NULL) {
      LocalFree((HLOCAL)pInfo);
      return FALSE;
   }

   SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)pInfo);

   //
   // clear the listbox and turn redraw off
   //
   SendMessage(hList, LB_RESETCONTENT, 0, 0);
   SendMessage(hList, WM_SETREDRAW, (WPARAM)FALSE, 0);

   //
   // open the Hardware Profiles key
   //
   wsprintf(RegStr, TEXT("%s\\%s"),
            pszRegIDConfigDB,
            pszRegKnownDockingStates);

   if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0,
            KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
            &hKey) != ERROR_SUCCESS) {

      DisplaySystemMessage(hDlg, ERROR_REGISTRY_CORRUPT);
      LocalFree((HLOCAL)pInfo->pHwProfValues);
      LocalFree((HLOCAL)pInfo);
      return FALSE;
   }

   //
   // read the values for the name generating counters
   //
   ulSize = sizeof(DWORD);

   wsprintf(szName, pszRegUndocked);
   if (RegQueryValueEx(hKey, szName, NULL, NULL,
                       (LPBYTE)&pInfo->ulUndockedProfileNameCount, &ulSize)) {
       pInfo->ulUnknownProfileNameCount = 0;
   }

   wsprintf(szName, pszRegDocked);
   if (RegQueryValueEx(hKey, szName, NULL, NULL,
                       (LPBYTE)&pInfo->ulDockedProfileNameCount, &ulSize)) {
       pInfo->ulUnknownProfileNameCount = 0;
   }

   wsprintf(szName, pszRegUnknown);
   if (RegQueryValueEx(hKey, szName, NULL, NULL,
                       (LPBYTE)&pInfo->ulUnknownProfileNameCount, &ulSize)) {
       pInfo->ulUnknownProfileNameCount = 0;
   }

   //
   // pad the list box with a blank entry for each profile
   // (this facilitates adding the profiles in rank order
   //
   for (ulIndex = 0; ulIndex < pInfo->ulNumProfiles; ulIndex++) {
      SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)(LPCTSTR)TEXT(" "));
   }

   //
   // enumerate each of the existing hardware profiles
   //
   ulIndex = 0;
   enumIndex = 0;
   while (RegStatus != ERROR_NO_MORE_ITEMS) {

      //
      // enumerate the profile key
      //
      ulSize = MAX_PROFILEID_LEN;
      RegStatus = RegEnumKeyEx(
               hKey, enumIndex, szProfile, &ulSize, NULL, NULL, NULL, NULL);

      if (RegStatus == ERROR_SUCCESS) {
         //
         // open the enumerated profile key
         //
         if (bAdmin) {
             sam = KEY_QUERY_VALUE | KEY_SET_VALUE;
         } else {
             sam = KEY_QUERY_VALUE;
         }

         if (RegOpenKeyEx(
                  hKey, szProfile, 0, sam, &hCfgKey) != ERROR_SUCCESS) {

            RegCloseKey(hKey);
            LocalFree((HLOCAL)pInfo->pHwProfValues);
            LocalFree((HLOCAL)pInfo);
            if (bAdmin) {
                DisplaySystemMessage(hDlg, ERROR_REGISTRY_CORRUPT);
                return FALSE;
            }
            else {
                return TRUE;
            }
         }

         //
         // if this is the Pristine profile, ignore it, and move on to the next.
         //

         ulProfileID = _wtoi(szProfile);

         if (!ulProfileID) {
             enumIndex++;
             RegCloseKey(hCfgKey);
             continue;
         }

         //----------------------------------------------------------
         // retrieve the profile registry info, save in buffer
         //----------------------------------------------------------

         //
         // aliasable
         //
         ulSize = sizeof(DWORD);
         if (RegQueryValueEx(
             hCfgKey, pszRegAliasable, NULL, NULL,
             (LPBYTE)&pInfo->pHwProfValues[ulIndex].bAliasable,
             &ulSize) != ERROR_SUCCESS) {
             pInfo->pHwProfValues[ulIndex].bAliasable = TRUE;
         }

         //
         // cloned
         //
         ulSize = sizeof(DWORD);
         if (RegQueryValueEx(
             hCfgKey, pszRegCloned, NULL, NULL,
             (LPBYTE)&pInfo->pHwProfValues[ulIndex].bCloned,
             &ulSize) != ERROR_SUCCESS) {
             pInfo->pHwProfValues[ulIndex].bCloned = FALSE;
         }

         //
         // friendly name
         //
         ulSize = MAX_FRIENDLYNAME_LEN * sizeof(TCHAR);
         if (RegQueryValueEx(
                  hCfgKey, pszRegFriendlyName, NULL, NULL,
                  (LPBYTE)&pInfo->pHwProfValues[ulIndex].szFriendlyName,
                  &ulSize) != ERROR_SUCCESS) {

            //
            // if no FriendlyName then write out and use a default
            // value name (for compatibility with Win95)
            //
            if (bAdmin) {

                lstrcpy(pInfo->pHwProfValues[ulIndex].szFriendlyName,
                         pszRegDefaultFriendlyName);

                RegSetValueEx(
                         hCfgKey, pszRegFriendlyName, 0, REG_SZ,
                         (LPBYTE)pszRegDefaultFriendlyName,
                         (lstrlen(pszRegDefaultFriendlyName)+1) * sizeof(TCHAR));
            }
         }

         //
         // preference order ranking
         //
         ulSize = sizeof(ULONG);
         if (RegQueryValueEx(
                  hCfgKey, pszRegPreferenceOrder, NULL, NULL,
                  (LPBYTE)&pInfo->pHwProfValues[ulIndex].ulPreferenceOrder,
                  &ulSize) != ERROR_SUCCESS) {

            // FEATURE - rerank all profiles if this happens
         }

         //
         // dock state
         //
         ulSize = sizeof(ULONG);
         if (RegQueryValueEx(
                  hCfgKey, pszRegDockState, NULL, NULL,
                  (LPBYTE)&pInfo->pHwProfValues[ulIndex].ulDockState,
                  &ulSize) != ERROR_SUCCESS) {

            pInfo->pHwProfValues[ulIndex].ulDockState =
                     DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED | DOCKINFO_UNDOCKED;
         }

         //
         // portable computer flag  - this is obsolete info, just save the current
         // setting if it exists and then delete it (might need the original
         // setting later)
         //
         ulSize = sizeof(ULONG);
         if (RegQueryValueEx(
                  hCfgKey, pszRegIsPortable, NULL, NULL,
                  (LPBYTE)&pInfo->pHwProfValues[ulIndex].bPortable,
                  &ulSize) != ERROR_SUCCESS) {

            pInfo->pHwProfValues[ulIndex].bPortable = FALSE;
         }

         RegDeleteValue(hCfgKey, pszRegIsPortable);

         pInfo->pHwProfValues[ulIndex].ulProfile = _wtoi(szProfile);
         pInfo->pHwProfValues[ulIndex].ulAction = HWP_NO_ACTION;
         RegCloseKey(hCfgKey);

         //
         // If this is the current profile, open the CurrentDockInfo key
         //
         if (pInfo->pHwProfValues[ulIndex].ulProfile == ulCurrentProfile) {

             wsprintf(RegStr, TEXT("%s\\%s"),
                      pszRegIDConfigDB,
                      pszRegCurrentDockInfo);
             
             if (RegOpenKeyEx(
                 HKEY_LOCAL_MACHINE, RegStr, 0,
                 KEY_QUERY_VALUE, &hCurrent) != ERROR_SUCCESS) {
                 
                 //
                 // Could not open the CurrentDockInfo key;
                 // Dock ID and Serial Number are unavailable
                 //
                 
                 pInfo->pHwProfValues[ulIndex].szDockID[0] = TEXT('\0');
                 pInfo->pHwProfValues[ulIndex].szSerialNumber[0] = TEXT('\0');

             } else {
                 
                 //
                 // Retrieve the hardware-detected dock state for the current profile
                 //
                 ulSize = sizeof(DWORD);
                 if ((RegQueryValueEx(
                     hCurrent, pszRegDockingState, NULL, NULL,
                     (LPBYTE)&ulCurrentDockingState,
                     &ulSize) == ERROR_SUCCESS) && 
                     ulCurrentDockingState &&
                     !((ulCurrentDockingState & DOCKINFO_DOCKED) &&
                       (ulCurrentDockingState & DOCKINFO_UNDOCKED))) {
                     //
                     // if the hardware-detected dockstate is present and known,
                     // override the user-supplied dockstate
                     //
                     pInfo->bHwDetectedPortable = TRUE;
                     pInfo->pHwProfValues[ulIndex].ulDockState = ulCurrentDockingState;
                 } else {
                     //
                     // keep the user-supplied dockstate
                     //
                     pInfo->bHwDetectedPortable = FALSE;
                     ulCurrentDockingState = pInfo->pHwProfValues[ulIndex].ulDockState;
                 }

                 if ((ulCurrentDockingState & DOCKINFO_UNDOCKED) &&
                     !(ulCurrentDockingState & DOCKINFO_DOCKED) &&
                     !(ulCurrentDockingState & DOCKINFO_USER_SUPPLIED)) {
                     //
                     // The hardware has detected an undocked state; set the global IsPortable flag
                     //
                     pInfo->bPortable = TRUE;

                 } else if ((ulCurrentDockingState & DOCKINFO_DOCKED) &&
                     !(ulCurrentDockingState & DOCKINFO_UNDOCKED) &&
                     !(ulCurrentDockingState & DOCKINFO_USER_SUPPLIED)) {                     
                     //
                     // The hardware has detected a docked state; set the global IsPortable flag
                     //
                     pInfo->bPortable = TRUE;
                     
                     //
                     // Serial Number and DockID are only valid for docked Profiles
                     //

                     //
                     // Retrieve the Serial Number for the current Profile.
                     //
                     // ("AcpiSerialNumber" is preferred because it is updated
                     // on Acpi dock events; "SerialNumber" is set only at boot
                     // time, from the BIOS, and may be inaccurate across Acpi
                     // dock transitions)
                     //
                     ulSize = MAX_SERIALNUM_LEN * sizeof(TCHAR);
                     if (RegQueryValueEx(
                         hCurrent, pszRegAcpiSerialNumber, NULL, NULL,
                         (LPBYTE)&pInfo->pHwProfValues[ulIndex].szSerialNumber,
                         &ulSize) != ERROR_SUCCESS) {
                         //
                         // No Acpi Serial Number, but we know the machine is
                         // docked (based on the DockState from the PnP BIOS
                         // info) so check for a PnP BIOS SerialNumber
                         //
                         ulSize = sizeof(DWORD);
                         if (RegQueryValueEx(
                             hCurrent, pszRegSerialNumber, NULL, NULL,
                             (LPBYTE)&ulSerialNumber,
                             &ulSize) != ERROR_SUCCESS) {                             
                             pInfo->pHwProfValues[ulIndex].szSerialNumber[0] = TEXT('\0');
                         } else {
                             wsprintf(pInfo->pHwProfValues[ulIndex].szSerialNumber,
                                      L"%X", 
                                      (ULONG)ulSerialNumber);
                         }
                     }
                     
                     //
                     // Retrieve the DockID for the current Profile, if available.
                     //
                     ulSize = sizeof(DWORD);
                     if (RegQueryValueEx(
                         hCurrent, pszRegDockID, NULL, NULL,
                         (LPBYTE)&ulDockID,
                         &ulSize) != ERROR_SUCCESS) {                 
                         pInfo->pHwProfValues[ulIndex].szDockID[0] = TEXT('\0');
                     } else {
                         wsprintf(pInfo->pHwProfValues[ulIndex].szDockID, 
                                  L"%X", 
                                  (ULONG)ulDockID);
                     }
                     
                 }
                 
             }
             
         } else {
             //
             // Serial Number and DockID are only valid for the current Profile
             //         
             pInfo->pHwProfValues[ulIndex].szSerialNumber[0] = TEXT('\0');
             pInfo->pHwProfValues[ulIndex].szDockID[0] = TEXT('\0');
         }
         
         //
         // delete the blank string in this spot, add the friendly name
         // (append current tag if necessary)
         //
         SendMessage(hList, LB_DELETESTRING,
                  pInfo->pHwProfValues[ulIndex].ulPreferenceOrder, 0);

         AppendCurrentTag(
                  szName,        // new fixed up name
                  pInfo->pHwProfValues[ulIndex].szFriendlyName,
                  pInfo->pHwProfValues[ulIndex].ulProfile,
                  ulCurrentProfile);

         lReturn = SendMessage(hList, LB_INSERTSTRING,
                  pInfo->pHwProfValues[ulIndex].ulPreferenceOrder,
                  (LPARAM)(LPCTSTR)szName);


         //
         // store the profile id along with the entry so we
         // can associate the string and the profile id later
         //
         SendMessage(hList, LB_SETITEMDATA,
            (WPARAM)lReturn, pInfo->pHwProfValues[ulIndex].ulProfile);

         //
         // if this is the current profile, save the index
         //
         if (pInfo->pHwProfValues[ulIndex].ulProfile == ulCurrentProfile) {
            ulCurrentIndex = pInfo->pHwProfValues[ulIndex].ulPreferenceOrder;
         }
      }

      ulIndex++;
      enumIndex++;

   } // while

   RegCloseKey(hKey);

   //---------------------------------------------------------------------
   // migrate portable information
   //---------------------------------------------------------------------
   
   if (bAdmin) {
       sam = KEY_READ | KEY_WRITE;
   } else {
       sam = KEY_READ;
   }

   if (RegOpenKeyEx(
       HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
       sam, &hKey) == ERROR_SUCCESS) {

       if (pInfo->bHwDetectedPortable) {
           if (bAdmin) {
               //
               // Set the global IsPortable setting as identified by the Hardware
               //
               RegSetValueEx(hKey, pszRegIsPortable, 0, REG_DWORD,
                             (LPBYTE)&pInfo->bPortable, sizeof(DWORD));
           }
           
       } else {
           //
           // Is there a global IsPortable setting?
           //
           ulSize = sizeof(DWORD);
           if (RegQueryValueEx(hKey, pszRegIsPortable, NULL, NULL,
                               (LPBYTE)&pInfo->bPortable, &ulSize) != ERROR_SUCCESS) {
               //
               // the global IsPortable flag isn't there, and the hardware did
               // not detect this as being a portable machine, so by default, it
               // is not.
               //
               pInfo->bPortable = FALSE;
           }
       }
       
       RegCloseKey(hKey);
   }

   SendMessage(hList, WM_SETREDRAW, (WPARAM)TRUE, 0);
   SendMessage(hList, LB_SETCURSEL, ulCurrentIndex, 0);

   return TRUE;

} // FillProfileList



/**-------------------------------------------------------------------------**/
BOOL
IsProfileNameInUse(
      HWND     hDlg,
      LPTSTR   pszFriendlyName
      )
{
   ULONG          ulBufferIndex=0;
   PHWPROF_INFO   pInfo=NULL;


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // check each friendly name (that hasn't been deleted) for a
   // match (case-insensitive)
   //
   while (ulBufferIndex < pInfo->ulNumProfiles) {

      if (!(pInfo->pHwProfValues[ulBufferIndex].ulAction & HWP_DELETE)) {

         if (lstrcmpi(pInfo->pHwProfValues[ulBufferIndex].szFriendlyName,
                  pszFriendlyName) == 0) {
            return TRUE;      // match, name is in use
         }
      }
      ulBufferIndex++;
   }

   return FALSE;  // no match found, name not in use

} // IsProfileNameInUse



/**-------------------------------------------------------------------------**/
VOID
UnicodeToUL(LPWSTR pString, PULONG pulValue)
{
    ULONG i;

    *pulValue = 0;
    for (i = 0; i < 4; i++) {
        *pulValue *= 10;
        *pulValue += (pString[i] <= '9') ?
                     (pString[i] - '0') :
                     (pString[i]-'A'+10);
    }
} // UnicodeToUL



/**-------------------------------------------------------------------------**/
BOOL
CopyHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex,
      ULONG  ulProfile,
      LPTSTR szNewFriendlyName
      )
{
   HWND           hList;
   ULONG          ulBufferIndex=0, ulNewBufferIndex=0;
   ULONG          ulNewProfile=0;
   ULONG_PTR      ulNewIndex=0;
   PHWPROF_INFO   pInfo=NULL;
   HLOCAL         hMem=NULL;
   WCHAR          szTemp[MAX_PATH];
   HKEY           hKey;
   LONG           RegStatus;


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // retrieve a handle to the listbox window
   //
   hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

   //
   // find which entry in the buffer list matches this profile
   //
   while (ulBufferIndex < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulProfile) {
         break;
      }
      ulBufferIndex++;
   }

   //
   // reallocate the profile buffer to hold another entry
   //
   pInfo->ulActiveProfiles++;
   pInfo->ulNumProfiles++;

   LocalUnlock(LocalHandle(pInfo->pHwProfValues));

   hMem = (PHWPROF_VALUES)LocalReAlloc(
               LocalHandle(pInfo->pHwProfValues),
               pInfo->ulNumProfiles * sizeof(HWPROF_VALUES),
               LMEM_MOVEABLE | LMEM_ZEROINIT);

   if (hMem == NULL) {
      DisplaySystemMessage(hDlg, ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
   }

   pInfo->pHwProfValues = (PHWPROF_VALUES)LocalLock(hMem);
   ulNewBufferIndex = pInfo->ulNumProfiles-1;

   //
   // find a free profile id to use
   //
   if (!GetFreeProfileID(pInfo, &ulNewProfile)) {
      return FALSE;
   }

   pInfo->pHwProfValues[ulNewBufferIndex].ulProfile = ulNewProfile;

   //
   // save the friendly name retrieved from the copy dialog box
   //
   lstrcpy(pInfo->pHwProfValues[ulNewBufferIndex].szFriendlyName,
            szNewFriendlyName);

   //
   // assume it's the last in the preference order (zero-based)
   //
   pInfo->pHwProfValues[ulNewBufferIndex].ulPreferenceOrder =
               pInfo->ulActiveProfiles - 1;

   //
   // copy the profile info from the selected profile to the new profile
   //
   pInfo->pHwProfValues[ulNewBufferIndex].ulDockState =
               pInfo->pHwProfValues[ulBufferIndex].ulDockState;

   //
   // new hardware profiles are (by default) not aliasable, unless no alias can
   // be copied for this profile.
   //
   pInfo->pHwProfValues[ulNewBufferIndex].bAliasable = FALSE;

   //
   // copied profiles are not clones of the pristine profile.
   //
   pInfo->pHwProfValues[ulNewBufferIndex].bCloned = FALSE;

   //pInfo->pHwProfValues[ulNewBufferIndex].bPortable =
   //            pInfo->pHwProfValues[ulBufferIndex].bPortable;

   lstrcpy(pInfo->pHwProfValues[ulNewBufferIndex].szDockID,
           pInfo->pHwProfValues[ulBufferIndex].szDockID);

   lstrcpy(pInfo->pHwProfValues[ulNewBufferIndex].szSerialNumber,
           pInfo->pHwProfValues[ulBufferIndex].szSerialNumber);

   //
   // save the original profile id this was copied from
   //
   pInfo->pHwProfValues[ulNewBufferIndex].ulCreatedFrom =
               GetOriginalProfile(pInfo, ulProfile, ulBufferIndex);

   //
   // increment the appropriate name-generating counter
   // (note that the counter is NOT symmetrically decreased whenever a profile
   // is deleted -- it increases over the lifetime of the system as new profiles
   // are created; this prevents us from assigning names that incrementally less
   // than names we have already assigned.)
   //
   AdjustProfileTypeCounter(pInfo,
                            pInfo->pHwProfValues[ulNewBufferIndex].ulDockState, 
                            TRUE);

   //
   // set the new profile in the listbox (at the end)
   //
   ulNewIndex = SendMessage(hList, LB_ADDSTRING, 0,
               (LPARAM)(LPTSTR)szNewFriendlyName);

   SendMessage(hList, LB_SETITEMDATA,
               (WPARAM)ulNewIndex,
               pInfo->pHwProfValues[ulNewBufferIndex].ulProfile);

   //
   // select the new profile
   //
   SendMessage(hList, LB_SETCURSEL, ulNewIndex, 0);

   //
   // mark the change
   //
   pInfo->pHwProfValues[ulNewBufferIndex].ulAction |= HWP_CREATE;

   //
   // disable copy if we're now at the max number of profiles
   //
   if ((pInfo->ulNumProfiles+1) >= MAX_PROFILES) {
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_COPY), FALSE);
   }
   
   //
   // reenable delete since by definition the selection is not on the
   // current profile (whether it was before or not)
   //
   EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE), TRUE);

   return TRUE;

} // CopyHardwareProfile



/**-------------------------------------------------------------------------**/
BOOL
RenameHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex,
      ULONG  ulProfile,
      LPTSTR szNewFriendlyName
      )
{
   HWND           hList;
   ULONG          ulBufferIndex=0, ulCurrentProfile=0;
   PHWPROF_INFO   pInfo=NULL;
   WCHAR          szName[MAX_PATH];


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // retrieve a handle to the listbox window
   //
   hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

   //
   // find the profile entry in the buffer that matches the selection
   //
   while (ulBufferIndex < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulProfile) {
         break;
      }
      ulBufferIndex++;
   }

   //
   // set the new friendly name in the listbox
   //
   GetCurrentProfile(&ulCurrentProfile);
   AppendCurrentTag(szName, szNewFriendlyName, ulProfile, ulCurrentProfile);

   SendMessage(hList, LB_DELETESTRING, ulIndex, 0);
   SendMessage(hList, LB_INSERTSTRING, ulIndex, (LPARAM)(LPTSTR)szName);
   SendMessage(hList, LB_SETITEMDATA, ulIndex,
               pInfo->pHwProfValues[ulIndex].ulProfile);

   //
   // re-select the index (is this necessary?)
   //
   SendMessage(hList, LB_SETCURSEL, ulIndex, 0);

   //
   // mark the change
   //
   pInfo->pHwProfValues[ulBufferIndex].ulAction |= HWP_RENAME;
   lstrcpy(pInfo->pHwProfValues[ulBufferIndex].szFriendlyName,
            szNewFriendlyName);

   return TRUE;

} // RenameHardwareProfile



/**-------------------------------------------------------------------------**/
BOOL
DeleteHardwareProfile(
      HWND   hDlg,
      ULONG_PTR ulIndex
      )
{
   HWND           hList;
   ULONG          ulBufferIndex=0, ulProfile=0, ulCurrentProfile=0;
   PHWPROF_INFO   pInfo=NULL;


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // retrieve a handle to the listbox window
   //
   hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

   //
   // find the profile entry in the buffer that matches the selection
   //
   ulProfile = (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex, 0);

   while (ulBufferIndex < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulProfile) {
         break;
      }
      ulBufferIndex++;
   }

   //
   // readjust all the rankings to be consecutive
   //
   DeleteRank(pInfo, pInfo->pHwProfValues[ulBufferIndex].ulPreferenceOrder);

   //
   // decrement the count of active profiles
   //
   pInfo->ulActiveProfiles--;

   //
   // delete the friendly name in the listbox
   //
   SendMessage(hList, LB_DELETESTRING, ulIndex, 0);

   //
   // re-select the following index (same position)
   //
   if (ulIndex >= pInfo->ulActiveProfiles) {
      ulIndex = pInfo->ulActiveProfiles-1;
   }

   SendMessage(hList, LB_SETCURSEL, ulIndex, 0);

   //
   // mark the change
   //
   pInfo->pHwProfValues[ulBufferIndex].ulAction |= HWP_DELETE;

   //
   // enable copy if less than max number of profiles
   //
   if (pInfo->ulNumProfiles < MAX_PROFILES) {
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_COPY), TRUE);
   }

   //
   // find the profile entry in the buffer that matches the new selection
   //
   ulProfile = (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex, 0);
   ulBufferIndex = 0;

   while (ulBufferIndex < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulProfile) {
         break;
      }
      ulBufferIndex++;
   }

   GetCurrentProfile(&ulCurrentProfile);

   //
   // if the newly selected entry is the current profile, disable delete
   //
   if (pInfo->pHwProfValues[ulBufferIndex].ulProfile == ulCurrentProfile) {
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_DELETE), FALSE);
   }


   return TRUE;

} // DeleteHardwareProfiles



/**-------------------------------------------------------------------------**/
BOOL
GetUserWaitInterval(
      PULONG   pulWait
      )
{
   ULONG    ulSize;
   HKEY     hKey;


   //
   // open the IDConfigDB key
   //
   if(RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
            KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS) {

      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   //
   // retrieve the UserWaitInterval value
   //
   ulSize = sizeof(ULONG);
   if (RegQueryValueEx(
            hKey, pszRegUserWaitInterval, NULL, NULL,
            (LPBYTE)pulWait, &ulSize) != ERROR_SUCCESS) {
      *pulWait = DEFAULT_USER_WAIT;
   }

   RegCloseKey(hKey);
   return TRUE;

} // GetUserWaitInterval



/**-------------------------------------------------------------------------**/
BOOL
SetUserWaitInterval(
      ULONG   ulWait
      )
{
   HKEY     hKey;


   if (bAdmin) {
       //
       // open the IDConfigDB key
       //
       if(RegOpenKeyEx(
                HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
                KEY_SET_VALUE, &hKey) != ERROR_SUCCESS) {

          DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
          return FALSE;
       }

       //
       // set the UserWaitInterval value
       //
       if (RegSetValueEx(
                hKey, pszRegUserWaitInterval, 0, REG_DWORD,
                (LPBYTE)&ulWait, sizeof(ULONG)) != ERROR_SUCCESS) {
          RegCloseKey(hKey);
          return FALSE;
       }

       RegCloseKey(hKey);
   }

   return TRUE;

} // SetUserWaitInterval


/**-------------------------------------------------------------------------**/
BOOL
GetFreeProfileID(
      PHWPROF_INFO   pInfo,
      PULONG         pulProfile
      )

{
   ULONG    ulProfileID = 0, ulBufferIndex = 0;
   BOOL     bHit;


   //
   // find a profile id that isn't used
   //
   while (ulProfileID < MAX_PROFILES) {

      ulBufferIndex = 0;
      bHit = FALSE;

      while (ulBufferIndex < pInfo->ulNumProfiles) {

         if (ulProfileID == pInfo->pHwProfValues[ulBufferIndex].ulProfile) {
            bHit = TRUE;
            break;
         }

         ulBufferIndex++;
      }

      //
      // if I got all the way through the list without a hit, then this
      // profile id is free
      //
      if (!bHit) {
         *pulProfile = ulProfileID;
         return TRUE;
      }

      ulProfileID++;
   }

   *pulProfile = 0xFFFFFFFF;
   return FALSE;

} // GetFreeProfileID


/**-------------------------------------------------------------------------**/
ULONG
GetOriginalProfile(
      PHWPROF_INFO  pInfo,
      ULONG         ulProfile,
      ULONG         ulBufferIndex
      )
{
    ULONG   ulIndex, ulIndexCreatedFrom;

    //
    // if the specified profile is a newly created profile, then it is
    // by definition the first in the copy chain
    //
    if (!(pInfo->pHwProfValues[ulBufferIndex].ulAction & HWP_CREATE)) {
        return ulProfile;
    }

    ulIndex = ulBufferIndex;

    while (pInfo->pHwProfValues[ulIndex].ulAction & HWP_CREATE) {
        //
        // find which entry in the buffer list matches the "CopiedFrom" profile
        //
        ulIndexCreatedFrom = 0;

        while (ulIndexCreatedFrom < pInfo->ulNumProfiles) {
           if (pInfo->pHwProfValues[ulIndexCreatedFrom].ulProfile ==
               pInfo->pHwProfValues[ulIndex].ulCreatedFrom) {
              break;
           }
           ulIndexCreatedFrom++;
        }
        ulIndex = ulIndexCreatedFrom;
    }

    return pInfo->pHwProfValues[ulIndex].ulProfile;

} // GetOriginalProfile


/**-------------------------------------------------------------------------**/
BOOL
InsertRank(
      PHWPROF_INFO   pInfo,
      ULONG          ulRank
      )

{
   ULONG ulIndex;

   //
   // for inserting a rank and readjusting the other ranks, just
   // scan through the list and for any rank that is greater than
   // or equal to the inserted rank, increment the rank value
   //
   for (ulIndex = 0; ulIndex < pInfo->ulNumProfiles; ulIndex++) {
      //
      // if it's marked for delete, don't bother with it
      //
      if (!(pInfo->pHwProfValues[ulIndex].ulAction & HWP_DELETE)) {

         if (pInfo->pHwProfValues[ulIndex].ulPreferenceOrder >= ulRank) {
            pInfo->pHwProfValues[ulIndex].ulPreferenceOrder++;
            pInfo->pHwProfValues[ulIndex].ulAction |= HWP_REORDER;
         }
      }

   }

   return TRUE;

} // InsertRank



/**-------------------------------------------------------------------------**/
BOOL
DeleteRank(
      PHWPROF_INFO   pInfo,
      ULONG          ulRank
      )

{
   ULONG ulIndex;

   //
   // for deleting a rank and readjusting the other ranks, just
   // scan through the list and for any rank that is greater than
   // the deleted rank, subtract one from the rank value
   //
   for (ulIndex = 0; ulIndex < pInfo->ulNumProfiles; ulIndex++) {
      //
      // if it's marked for delete, don't bother with it
      //
      if (!(pInfo->pHwProfValues[ulIndex].ulAction & HWP_DELETE)) {

         if (pInfo->pHwProfValues[ulIndex].ulPreferenceOrder > ulRank) {
            pInfo->pHwProfValues[ulIndex].ulPreferenceOrder--;
            pInfo->pHwProfValues[ulIndex].ulAction |= HWP_REORDER;
         }
      }

   }

   return TRUE;

} // DeleteRank



/**-------------------------------------------------------------------------**/
BOOL
FlushProfileChanges(
      HWND hDlg,
      HWND hList
      )
{
   ULONG    ulIndex=0;
   HKEY     hKey = NULL, hDestKey = NULL, hSrcKey = NULL, hHwProf = NULL;
   WCHAR    RegStr[MAX_PATH];
   PHWPROF_INFO   pInfo=NULL;


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);


   //
   // First pass, process the changes for each profile (except delete)
   //
   while (ulIndex < pInfo->ulNumProfiles) {

      //
      // were any changes made to this profile?
      //
      if (pInfo->pHwProfValues[ulIndex].ulAction == HWP_NO_ACTION) {
         goto NextProfile;
      }

      //
      // save deleting for the second pass
      //
      if (pInfo->pHwProfValues[ulIndex].ulAction & HWP_DELETE) {
         goto NextProfile;
      }

      //
      // commit the changes for this profile
      //
      WriteProfileInfo(&pInfo->pHwProfValues[ulIndex]);

      NextProfile:
         ulIndex++;
   }



   //
   // Second pass, process the delete requests
   //
   ulIndex = 0;
   while (ulIndex < pInfo->ulNumProfiles) {

      if (pInfo->pHwProfValues[ulIndex].ulAction & HWP_DELETE) {
         //
         // we only need to delete the key if it exists (if this
         // isn't a delete of a profile that was also just created)
         //
         if (!(pInfo->pHwProfValues[ulIndex].ulAction & HWP_CREATE)) {

            wsprintf(RegStr, TEXT("%s\\%s"),
                     pszRegIDConfigDB,
                     pszRegKnownDockingStates);

            if (RegOpenKeyEx(
                     HKEY_LOCAL_MACHINE, RegStr, 0, KEY_ALL_ACCESS,
                     &hKey) != ERROR_SUCCESS) {

               DisplaySystemMessage(hDlg, ERROR_REGISTRY_CORRUPT);
               return FALSE;
            }

            wsprintf(RegStr, TEXT("%04u"),
                     pInfo->pHwProfValues[ulIndex].ulProfile);

            RegDeleteKey(hKey, RegStr);
            RegCloseKey(hKey);

            //
            // also delete the profile specific enum tree
            //
            DeleteProfileDependentTree(pInfo->pHwProfValues[ulIndex].ulProfile);

            //
            // also delete the aliases to this profile
            //
            DeleteAliasEntries(pInfo->pHwProfValues[ulIndex].ulProfile);
            
         } else {
             //
             // decrement the name-generating counter for profiles we are
             // deleting that we created this session (only if registry keys
             // were never created for this new profile)
             //
             AdjustProfileTypeCounter(pInfo,
                                      pInfo->pHwProfValues[ulIndex].ulDockState, 
                                      FALSE);
         }
         
      }
      ulIndex++;
   }

   //
   // commit global settings
   //
   if(RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
            KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {

       RegSetValueEx(hKey, pszRegIsPortable, 0, REG_DWORD,
                (LPBYTE)&pInfo->bPortable, sizeof(DWORD));

       if (RegOpenKeyEx(
                 hKey, pszRegKnownDockingStates, 0,
                 KEY_SET_VALUE, &hHwProf) == ERROR_SUCCESS) {

           if (pInfo->ulUndockedProfileNameCount > 0) {
               RegSetValueEx(hHwProf, pszRegUndocked, 0, REG_DWORD,
                             (LPBYTE)&pInfo->ulUndockedProfileNameCount, sizeof(ULONG));
           } else {
               RegDeleteValue(hHwProf, pszRegUndocked);
           }
           
           if (pInfo->ulDockedProfileNameCount > 0) {
               RegSetValueEx(hHwProf, pszRegDocked, 0, REG_DWORD,
                             (LPBYTE)&pInfo->ulDockedProfileNameCount, sizeof(ULONG));
           } else {
               RegDeleteValue(hHwProf, pszRegDocked);
           }
           
           if (pInfo->ulUnknownProfileNameCount > 0) {
               RegSetValueEx(hHwProf, pszRegUnknown, 0, REG_DWORD,
                             (LPBYTE)&pInfo->ulUnknownProfileNameCount, sizeof(ULONG));
           } else {
               RegDeleteValue(hHwProf, pszRegUnknown);
           }
           
           RegCloseKey(hHwProf);
       }
       RegCloseKey(hKey);
   }

   return TRUE;

} // FlushProfileChanges



/**-------------------------------------------------------------------------**/
BOOL
WriteProfileInfo(
   PHWPROF_VALUES pProfValues
   )
{
   HKEY     hKey = NULL, hDestKey = NULL, hSrcKey = NULL;
   WCHAR    RegStr[MAX_PATH];
   UUID     NewGuid;
   LPTSTR   UuidString;
   TCHAR    szGuid[MAX_GUID_STRING_LEN];

   if (pProfValues->ulAction & HWP_DELETE) {
      return TRUE;      // skip it
   }

   //
   // form the registry key string
   //
   wsprintf(RegStr, TEXT("%s\\%s\\%04u"),
            pszRegIDConfigDB,
            pszRegKnownDockingStates,
            pProfValues->ulProfile);

   //
   // create the profile key if it's a new profile. Don't
   // worry about security because the profile subkey always
   // inherits the security of the parent Hardware Profiles key.
   //
   if (pProfValues->ulAction & HWP_CREATE) {

      if (RegCreateKeyEx(
               HKEY_LOCAL_MACHINE, RegStr, 0, NULL,
               REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
               NULL, &hKey, NULL) != ERROR_SUCCESS) {
         return FALSE;
      }

      //
      // create a HwProfileGuid if its a new profile
      //
      if ((UuidCreate(&NewGuid) == RPC_S_OK) &&    
          (UuidToString(&NewGuid, &UuidString) == RPC_S_OK)) {                    

          //
          // put curly braces around the guid
          //
          lstrcpy(szGuid, TEXT("{"));
          lstrcat(szGuid, UuidString);
          lstrcat(szGuid, TEXT("}"));
          RpcStringFree(&UuidString);
          
          //
          // save the new HwProfileGuid in the registry
          //
          RegSetValueEx(
              hKey, pszRegHwProfileGuid, 0, REG_SZ,
              (LPBYTE)szGuid,
              (lstrlen(szGuid)+1) * sizeof(TCHAR) );         
      }
      
   } else {
      //
      // if not a create, just open the existing key
      //
      if (RegOpenKeyEx(
               HKEY_LOCAL_MACHINE, RegStr, 0, KEY_SET_VALUE,
               &hKey) != ERROR_SUCCESS) {
         return FALSE;
      }
   }

   //
   // update preference order if modified
   //
   if ((pProfValues->ulAction & HWP_REORDER) ||
            (pProfValues->ulAction & HWP_CREATE)) {

      RegSetValueEx(
            hKey, pszRegPreferenceOrder, 0, REG_DWORD,
            (LPBYTE)&pProfValues->ulPreferenceOrder, sizeof(ULONG));

      pProfValues->ulAction &= ~HWP_REORDER;    // clear action
   }

   //
   // update friendly name if modified
   //
   if ((pProfValues->ulAction & HWP_RENAME) ||
            (pProfValues->ulAction & HWP_CREATE)) {

      RegSetValueEx(
            hKey, pszRegFriendlyName, 0, REG_SZ,
            (LPBYTE)pProfValues->szFriendlyName,
            (lstrlen(pProfValues->szFriendlyName)+1) * sizeof(TCHAR));

      pProfValues->ulAction &= ~HWP_RENAME;     // clear action
   }

   //
   // update property values if modified
   //
   if ((pProfValues->ulAction & HWP_PROPERTIES) ||
            (pProfValues->ulAction & HWP_CREATE)) {

      RegSetValueEx(
            hKey, pszRegDockState, 0, REG_DWORD,
            (LPBYTE)&pProfValues->ulDockState, sizeof(ULONG));

      RegSetValueEx(
            hKey, pszRegAliasable, 0, REG_DWORD,
            (LPBYTE)&pProfValues->bAliasable, sizeof(DWORD));

      pProfValues->ulAction &= ~HWP_PROPERTIES;    // clear action
   }


   if (pProfValues->ulAction & HWP_CREATE) {
      //
      // copy the profile enum info. Don't worry about security on
      // this createkey because the profile key always inherits the
      // security of the parent Hardware Profiles key.
      //
      wsprintf(RegStr, TEXT("%s\\%04u"),
            pszRegHwProfiles,
            pProfValues->ulProfile);

      RegCreateKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0, NULL, REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS, NULL, &hDestKey, NULL);

      wsprintf(RegStr, TEXT("%s\\%04u"),
            pszRegHwProfiles,
            pProfValues->ulCreatedFrom);

      RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0, KEY_ALL_ACCESS, &hSrcKey);

      CopyRegistryNode(hSrcKey, hDestKey);

      //
      // copy all aliases for the source profile to the destination as well.
      //
      if (CopyAliasEntries(pProfValues->ulCreatedFrom, 
                           pProfValues->ulProfile) == FALSE) {

          //
          // We didn't actually copy any aliases, so make sure this profile gets
          // marked as "Aliasable" so that it shows up as a profile option at
          // boot time.
          //
          pProfValues->bAliasable = TRUE;
          RegSetValueEx(
              hKey, pszRegAliasable, 0, REG_DWORD,
              (LPBYTE)&pProfValues->bAliasable, sizeof(DWORD));
      }

      if (hDestKey != NULL) RegCloseKey(hDestKey);
      if (hSrcKey != NULL) RegCloseKey(hSrcKey);

      pProfValues->ulAction &= ~HWP_CREATE;     // clear action
      pProfValues->ulAction |= HWP_NEWPROFILE;  // created during this session
   }

   RegCloseKey(hKey);

   return TRUE;

} // WriteProfileInfo


/**-------------------------------------------------------------------------**/
BOOL
RemoveNewProfiles(
      PHWPROF_INFO   pInfo
      )
{
   ULONG    ulIndex=0;
   HKEY     hKey = NULL;
   WCHAR    RegStr[MAX_PATH];


   //
   // check each profile for any HWP_NEWPROFILE flags
   //
   while (ulIndex < pInfo->ulNumProfiles) {

      if (pInfo->pHwProfValues[ulIndex].ulAction & HWP_NEWPROFILE) {

         wsprintf(RegStr, TEXT("%s\\%s"),
                  pszRegIDConfigDB,
                  pszRegKnownDockingStates);

         if (RegOpenKeyEx(
                  HKEY_LOCAL_MACHINE, RegStr, 0, KEY_ALL_ACCESS,
                  &hKey) == ERROR_SUCCESS) {

            wsprintf(RegStr, TEXT("%04u"),
                     pInfo->pHwProfValues[ulIndex].ulProfile);

            RegDeleteKey(hKey, RegStr);
            RegCloseKey(hKey);
         }

         //
         // also delete the profile specific enum tree
         //
         DeleteProfileDependentTree(pInfo->pHwProfValues[ulIndex].ulProfile);

         //
         // also delete aliases to this profile
         //
         DeleteAliasEntries(pInfo->pHwProfValues[ulIndex].ulProfile);

         //
         // decrement the appropriate name-generating counter
         // (note that the counter is only deleted for new profiles that are
         // never fully commited; we don't make an attempt to decerement the
         // counter when any profile is deleted, else we may get into a case
         // where we assign a name to a new profile that in incrementally less
         // than a name we had previously assigned.)
         //
         AdjustProfileTypeCounter(pInfo,
                                  pInfo->pHwProfValues[ulIndex].ulDockState, 
                                  FALSE);
      }
      ulIndex++;
   }

   return TRUE;

} // RemoveNewProfiles



/**-------------------------------------------------------------------------**/
BOOL
SwapPreferenceOrder(
      HWND  hDlg,
      HWND  hList,
      ULONG_PTR ulIndex1,
      ULONG_PTR ulIndex2
      )

{
   ULONG    ulProfile1=0, ulProfile2=0;
   ULONG    ulBufferIndex1=0, ulBufferIndex2=0;
   WCHAR    szFriendlyName1[MAX_FRIENDLYNAME_LEN];
   WCHAR    szFriendlyName2[MAX_FRIENDLYNAME_LEN];
   ULONG    ulTemp=0;
   PHWPROF_INFO   pInfo=NULL;


   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // retrieve the profile id for the two selected profile entries
   //
   ulProfile1 = (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex1, 0);
   ulProfile2 = (ULONG)SendMessage(hList, LB_GETITEMDATA, ulIndex2, 0);

   //
   // find the profile entry in the buffer that matches these selections
   //
   while (ulBufferIndex1 < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex1].ulProfile == ulProfile1) {
         break;
      }
      ulBufferIndex1++;
   }

   while (ulBufferIndex2 < pInfo->ulNumProfiles) {
      if (pInfo->pHwProfValues[ulBufferIndex2].ulProfile == ulProfile2) {
         break;
      }
      ulBufferIndex2++;
   }

   //
   // swap the order values of the profiles in the in-memory buffer
   //
   ulTemp = pInfo->pHwProfValues[ulBufferIndex1].ulPreferenceOrder;
   pInfo->pHwProfValues[ulBufferIndex1].ulPreferenceOrder =
            pInfo->pHwProfValues[ulBufferIndex2].ulPreferenceOrder;
   pInfo->pHwProfValues[ulBufferIndex2].ulPreferenceOrder = ulTemp;

   //
   // mark both profiles as having been reordered
   //
   pInfo->pHwProfValues[ulBufferIndex1].ulAction |= HWP_REORDER;
   pInfo->pHwProfValues[ulBufferIndex2].ulAction |= HWP_REORDER;

   //
   // swap the positions in the list box
   //
   SendMessage(hList, LB_GETTEXT, ulIndex1, (LPARAM)(LPTSTR)szFriendlyName1);
   SendMessage(hList, LB_GETTEXT, ulIndex2, (LPARAM)(LPTSTR)szFriendlyName2);

   SendMessage(hList, LB_DELETESTRING, ulIndex1, 0);
   SendMessage(hList, LB_INSERTSTRING, ulIndex1,
         (LPARAM)(LPTSTR)szFriendlyName2);

   SendMessage(hList, LB_DELETESTRING, ulIndex2, 0);
   SendMessage(hList, LB_INSERTSTRING, ulIndex2,
         (LPARAM)(LPTSTR)szFriendlyName1);

   SendMessage(hList, LB_SETITEMDATA, ulIndex1, ulProfile2);
   SendMessage(hList, LB_SETITEMDATA, ulIndex2, ulProfile1);

   //
   // finally, select the second index (the second index is the rank
   // position we're moving to)
   //
   SendMessage(hList, LB_SETCURSEL, ulIndex2, 0);

   return TRUE;

} // SwapPreferenceOrder


/**-------------------------------------------------------------------------**/
BOOL
DeleteProfileDependentTree(
      ULONG ulProfile
      )
{
   TCHAR szProfile[5], szKey[MAX_PATH];
   LONG  RegStatus = ERROR_SUCCESS;
   HKEY  hHwProfKey, hCfgKey;
   ULONG ulIndex = 0, ulSize = 0;


   //
   // form the registry key string
   //
   if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, pszRegHwProfiles, 0, KEY_ALL_ACCESS,
            &hHwProfKey) != ERROR_SUCCESS) {

      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }

   wsprintf(szProfile, TEXT("%04u"),
            ulProfile);

   DeleteRegistryNode(hHwProfKey, szProfile);
   RegCloseKey(hHwProfKey);

   return TRUE;

} // DeleteProfileDependentTree

/**-------------------------------------------------------------------------**/

BOOL
CopyAliasEntries(
    ULONG ulSrcProfile,
    ULONG ulDestProfile
    )
{
   BOOL bNewAliasCreated = FALSE;

   bNewAliasCreated |= CopyAliasEntryType(ulSrcProfile, ulDestProfile, pszRegAlias);
   bNewAliasCreated |= CopyAliasEntryType(ulSrcProfile, ulDestProfile, pszRegAcpiAlias);    

   return bNewAliasCreated;

} // CopyAliasEntries

/**-------------------------------------------------------------------------**/

BOOL
DeleteAliasEntries(
    ULONG ulProfile    
    )
{
   BOOL bResult = TRUE;

   bResult |= DeleteAliasEntryType(ulProfile, pszRegAlias);
   bResult |= DeleteAliasEntryType(ulProfile, pszRegAcpiAlias);    

   return bResult;

} // CopyAliasEntries

/**-------------------------------------------------------------------------**/

BOOL
CopyAliasEntryType(
    ULONG  ulSrcProfile,
    ULONG  ulDestProfile,
    LPWSTR szSubKeyName
    )
{

   LONG   RegStatus = ERROR_SUCCESS;
   HKEY   hAliasRoot, hSrcKey, hDestKey;
   WCHAR  RegStr[MAX_PATH];
   WCHAR  szString[MAX_PATH];
   ULONG  ulAliasProfileNumber, ulNewAlias, ulSize, i;
   BOOL   bNewAliasCreated=FALSE;

   //
   // check all aliases under the "Alias" key
   //
   wsprintf(RegStr, TEXT("%s\\%s"),
            pszRegIDConfigDB,
            szSubKeyName);

   RegStatus = RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0, KEY_ALL_ACCESS,
            &hAliasRoot);
   if (RegStatus == ERROR_FILE_NOT_FOUND) {
      //
      // No Alias subkey, this could be ok if we have the other type.
      //
      RegStatus = ERROR_SUCCESS;
      return bNewAliasCreated;
   } else if (RegStatus != ERROR_SUCCESS) {
      //
      // Some other registry error occurred.
      //
      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   } else {
       //
       // enumerate all Alias subkeys
       //
       for (i=0; RegStatus == ERROR_SUCCESS; i++) {

           ulSize = MAX_PATH;
           
           RegStatus = RegEnumKey(hAliasRoot, i, szString, ulSize);

           if (RegStatus == ERROR_SUCCESS) {

               if (RegOpenKey(hAliasRoot, szString, &hSrcKey) == ERROR_SUCCESS) {
             
                   ulSize = sizeof(ULONG);
                   
                   if (RegQueryValueEx(
                       hSrcKey, pszRegProfileNumber, NULL, NULL,
                       (LPBYTE)&ulAliasProfileNumber, 
                       &ulSize) == ERROR_SUCCESS) {
                 
                       //
                       // Check if we need to copy this one
                       //
                       if (ulSrcProfile == ulAliasProfileNumber) {

                           //
                           // Find an unused Alias subkey name
                           //          
                           ulNewAlias = 0;
                           while (ulNewAlias < MAX_ALIASES) {
                               ulNewAlias++;
                               wsprintf(RegStr, TEXT("%s\\%s\\%04u"),
                                        pszRegIDConfigDB,
                                        szSubKeyName,
                                        ulNewAlias);              
                               RegStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
                                                        RegStr, 0, KEY_ALL_ACCESS, 
                                                        &hDestKey);
                               
                               if (RegStatus == ERROR_SUCCESS) {
                                   RegCloseKey(hDestKey);
                                   continue;
                               } else if (RegStatus == ERROR_FILE_NOT_FOUND) {
                                   RegStatus = ERROR_SUCCESS;
                                   break;
                               } else {
                                   break;
                               }
                           }
                     
                           if ((RegStatus != ERROR_SUCCESS) || (ulNewAlias >= MAX_ALIASES)) {
                               RegCloseKey(hSrcKey);
                               break;
                           }

                           wsprintf(RegStr, TEXT("%s\\%s\\%04u"),
                                    pszRegIDConfigDB,
                                    szSubKeyName,
                                    ulNewAlias);
                           
                           RegCreateKeyEx(
                               HKEY_LOCAL_MACHINE, RegStr, 0, NULL, REG_OPTION_NON_VOLATILE,
                               KEY_ALL_ACCESS, NULL, &hDestKey, NULL);
                        
                           //
                           // copy this alias entry 
                           //   
                           CopyRegistryNode(hSrcKey, hDestKey);
                           
                           RegSetValueEx(
                               hDestKey, pszRegProfileNumber, 0, REG_DWORD,
                               (LPBYTE)&ulDestProfile, sizeof(ULONG));
                           
                           bNewAliasCreated = TRUE;
                           if (ulNewAlias < (ULONG)_wtoi(szString)) {
                               // kick the enumeration index up one, else we'll
                               // find the key we just copied again.
                               i++;
                           }
                           
                           if (hDestKey != NULL) {
                               RegCloseKey(hDestKey);
                               hDestKey = NULL;
                           }                           
                       }
                   }
                   if (hSrcKey != NULL) {
                       RegCloseKey(hSrcKey);
                       hSrcKey = NULL;
                   }
               }
           }
       }
       RegCloseKey(hAliasRoot);
       hAliasRoot = NULL;
   }

   return bNewAliasCreated;

} // CopyAliasEntryType

/**-------------------------------------------------------------------------**/

BOOL
DeleteAliasEntryType(
      ULONG  ulProfile,
      LPWSTR szSubKeyName
      )

{

   LONG   RegStatus = ERROR_SUCCESS;
   HKEY   hAliasRoot;
   HKEY   hAliasSubKey;
   WCHAR  RegStr[MAX_PATH];
   WCHAR  szString[MAX_PATH];
   ULONG  ulAliasProfileNumber, ulSize, i;
   BOOL   bDeleted = FALSE;

   //
   // check all aliases under the "Alias" key
   //
   wsprintf(RegStr, TEXT("%s\\%s"),
            pszRegIDConfigDB,
            szSubKeyName);

   RegStatus = RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, RegStr, 0, KEY_ALL_ACCESS,
            &hAliasRoot);
   if (RegStatus == ERROR_FILE_NOT_FOUND) {
       return TRUE;
   } else if (RegStatus != ERROR_SUCCESS) {
      DisplaySystemMessage(NULL, ERROR_REGISTRY_CORRUPT);
      return FALSE;
   }
   
   //
   // enumerate all subkeys
   //
   RegStatus = ERROR_SUCCESS;

   for (i=0; RegStatus == ERROR_SUCCESS; ) {

      ulSize = MAX_PATH;

      RegStatus = RegEnumKey(hAliasRoot, i, szString, ulSize);
      bDeleted = FALSE;

      if (RegStatus == ERROR_SUCCESS) {
         if (RegOpenKey(hAliasRoot, szString, &hAliasSubKey) == ERROR_SUCCESS) {
             
             ulSize = sizeof(ULONG);
             if (RegQueryValueEx(
                 hAliasSubKey, pszRegProfileNumber, NULL, NULL,
                 (LPBYTE)&ulAliasProfileNumber, 
                 &ulSize) == ERROR_SUCCESS) {
                 
                 if (ulProfile == ulAliasProfileNumber) {
                     //
                     // delete this alias entry 
                     //
                     RegCloseKey(hAliasSubKey);
                     hAliasSubKey = NULL;
                     RegDeleteKey(hAliasRoot, szString);
                     bDeleted = TRUE;
                 }
             }
             if (hAliasSubKey) RegCloseKey(hAliasSubKey);
         }
      }
      if (!bDeleted) i++;
   }   
   RegCloseKey(hAliasRoot);
      
   return TRUE;

} // DeleteAliasEntryType

/**-------------------------------------------------------------------------**/

BOOL
CopyRegistryNode(
   HKEY     hSrcKey,
   HKEY     hDestKey
   )
{

   LONG  RegStatus = ERROR_SUCCESS;
   HKEY  hSrcSubKey, hDestSubKey;
   WCHAR szString[MAX_PATH];
   ULONG ulDataSize, ulLength, ulType, i;
   BYTE  Data[MAX_PATH * 2];          // biggest value data??
   PSECURITY_DESCRIPTOR pSecDesc;

   // copy all values for this key
   for (i=0; RegStatus == ERROR_SUCCESS; i++)
   {
      ulLength = MAX_PATH;
      ulDataSize = sizeof(Data);

      RegStatus = RegEnumValue(hSrcKey, i, szString, &ulLength, NULL,
            &ulType, Data, &ulDataSize);

        if (RegStatus == ERROR_SUCCESS)
        {
           RegSetValueEx(hDestKey, szString, 0, ulType, Data, ulDataSize);
        }
    }

    // recursively call CopyRegistryNode to copy all subkeys
    RegStatus = ERROR_SUCCESS;
    for (i=0; RegStatus == ERROR_SUCCESS; i++)
    {

      ulLength = MAX_PATH;

      RegStatus = RegEnumKey(hSrcKey, i, szString, ulLength);

      if (RegStatus == ERROR_SUCCESS)
      {
         if (RegOpenKey(hSrcKey, szString, &hSrcSubKey) == ERROR_SUCCESS)
         {
            if (RegCreateKey(hDestKey, szString, &hDestSubKey) == ERROR_SUCCESS)
            {
               RegGetKeySecurity(hSrcSubKey, DACL_SECURITY_INFORMATION, NULL, &ulDataSize);
               pSecDesc = LocalAlloc(LPTR, ulDataSize);
               RegGetKeySecurity(hSrcSubKey, DACL_SECURITY_INFORMATION, pSecDesc, &ulDataSize);

               CopyRegistryNode(hSrcSubKey, hDestSubKey);

               RegSetKeySecurity(hDestSubKey, DACL_SECURITY_INFORMATION, pSecDesc);
               LocalFree(pSecDesc);
               RegCloseKey(hDestSubKey);
            }
            RegCloseKey(hSrcSubKey);
         }
      }
   }

   return TRUE;

} // CopyRegistryNode


/**-------------------------------------------------------------------------**/
BOOL
DeleteRegistryNode(
   HKEY     hParentKey,
   LPTSTR   szKey
   )
{
   ULONG ulSize = 0;
   LONG  RegStatus = ERROR_SUCCESS;
   HKEY  hKey = NULL;
   WCHAR szSubKey[MAX_PATH];


   //
   // attempt to delete the key
   //
   if (RegDeleteKey(hParentKey, szKey) != ERROR_SUCCESS) {

      if (RegOpenKeyEx(
               hParentKey, szKey, 0, KEY_ENUMERATE_SUB_KEYS | KEY_WRITE,
               &hKey) != ERROR_SUCCESS) {
         return FALSE;
      }

      //
      // enumerate subkeys and delete those nodes
      //
      while (RegStatus == ERROR_SUCCESS) {
         //
         // enumerate the first level children under the profile key
         //
         ulSize = MAX_PATH;
         RegStatus = RegEnumKeyEx(
                  hKey, 0, szSubKey, &ulSize,
                  NULL, NULL, NULL, NULL);

         if (RegStatus == ERROR_SUCCESS) {

            if (!DeleteRegistryNode(hKey, szSubKey)) {
               RegCloseKey(hKey);
               return FALSE;
            }
         }
      }

      //
      // subkeys have been deleted, try deleting this key again
      //
      RegCloseKey(hKey);
      RegDeleteKey(hParentKey, szKey);
   }

   return TRUE;

}  // DeleteRegistryNode


/**-------------------------------------------------------------------------**/
VOID
AdjustProfileTypeCounter(
    PHWPROF_INFO   pInfo,
    ULONG          ulDockState,
    BOOL           bIncrement
    )
{
    PULONG pCounter;

    //
    // use the counter corresponding to the given DockState.
    //
    if ((ulDockState & DOCKINFO_DOCKED) &&
        (ulDockState & DOCKINFO_UNDOCKED)) {       
        pCounter = &pInfo->ulUnknownProfileNameCount;
    } else if (ulDockState & DOCKINFO_DOCKED) {
        pCounter = &pInfo->ulDockedProfileNameCount;
    } else if (ulDockState & DOCKINFO_UNDOCKED) {
        pCounter = &pInfo->ulUndockedProfileNameCount;
    } else {
        pCounter = &pInfo->ulUnknownProfileNameCount;
    }

    //
    // increment or decrement the counter, as requested.
    //
    if (bIncrement) {
        *pCounter += 1;
    } else if (!bIncrement && (*pCounter > 0)) {
        *pCounter -= 1;        
    } else {
        *pCounter = 0;
    }
}

/**-------------------------------------------------------------------------**/
BOOL
StripCurrentTag(
   LPTSTR   szFriendlyName,
   ULONG    ulProfile,
   ULONG    ulCurrentProfile
   )
{
   ULONG ulTagLen, ulNameLen;


   if (ulProfile == ulCurrentProfile) {

      ulTagLen = lstrlen(pszCurrentTag);
      ulNameLen = lstrlen(szFriendlyName);

      if (ulNameLen < ulTagLen) {
         return TRUE;   // nothing to do
      }

      if (lstrcmpi(&szFriendlyName[ulNameLen - ulTagLen], pszCurrentTag) == 0) {
         //
         // truncate the string before the current tag
         //
         szFriendlyName[ulNameLen - ulTagLen - 1] = '\0';
      }
   }

   return TRUE;

} // StripCurrentTag


/**-------------------------------------------------------------------------**/
BOOL
AppendCurrentTag(
   LPTSTR   szTaggedName,
   LPCTSTR  szOriginalName,
   ULONG    ulProfile,
   ULONG    ulCurrentProfile
   )
{

   lstrcpy(szTaggedName, szOriginalName);

   //
   // if the profile is the current profile, then append the tag
   // (let's user easily identify it as current)
   //
   if (ulProfile == ulCurrentProfile) {
      lstrcat(szTaggedName, TEXT(" "));
      lstrcat(szTaggedName, pszCurrentTag);
   }

   return TRUE;

} // AppendCurrentTag


/**-------------------------------------------------------------------------**/
VOID
CreateHwProfileFriendlyName(
   IN  HWND       hDlg,
   IN  ULONG      ulDockState,
   OUT LPTSTR     szFriendlyName
   )
{

   PHWPROF_INFO   pInfo;
   LPTSTR         szPrefix;
   PULONG         pulIndex;
   BOOL           bUnknown=FALSE, bUniqueFriendlyName=FALSE;

   //
   // retrieve the profile buffer
   //
   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   //
   // based on the DockState, determine the appropriate label to use and get a
   // pointer to its counter index
   //
   if ((ulDockState & DOCKINFO_DOCKED) &&
       (ulDockState & DOCKINFO_UNDOCKED)) {
       szPrefix = pszUnknown;
       pulIndex = &pInfo->ulUnknownProfileNameCount;
       bUnknown = TRUE;
   }
   else if (ulDockState & DOCKINFO_DOCKED) {
       szPrefix = pszDocked;
       pulIndex = &pInfo->ulDockedProfileNameCount;
   }
   else if (ulDockState & DOCKINFO_UNDOCKED) {
       szPrefix = pszUndocked;
       pulIndex = &pInfo->ulUndockedProfileNameCount;
   }
   else {
       szPrefix = pszUnknown;
       pulIndex = &pInfo->ulUnknownProfileNameCount;
       bUnknown = TRUE;
   }

   while ((!bUniqueFriendlyName) && (*pulIndex < MAX_PROFILES)) {
       //
       // as long as we don't have a unique name, build a FriendlyName based on
       // the DockState and counter index
       //
       if (bUnknown || (*pulIndex > 0)) {
           wsprintf(szFriendlyName, TEXT("%s %u"),
                    szPrefix,
                    *pulIndex + 1);
       } else {
           lstrcpy(szFriendlyName, szPrefix);
       }

       if (IsProfileNameInUse(hDlg,szFriendlyName)) {
           //
           // if this friendly name is in use, increment the counter to reflect this
           //
           *pulIndex += 1;
       } else {
           //
           // a unique friendly name has been generated
           //
           bUniqueFriendlyName = TRUE;
       }
   }

   if (!bUniqueFriendlyName) {
       //
       // if unable to generate a unique friendly name, just use some default.
       // the user may have to deal with any errors arising from duplicate names
       // is this name is already taken
       //
       lstrcpy(szFriendlyName, pszRegDefaultFriendlyName);
   }

   return;

} // CreateHwProfileFriendlyName


/**-------------------------------------------------------------------------**/
VOID
DisplayPrivateMessage(
      HWND  hWnd,
      UINT  uiPrivateError
      )
{
   WCHAR szMessage[MAX_PATH];


   LoadString(hInstance, uiPrivateError, szMessage, MAX_PATH);
   MessageBox(hWnd, szMessage, pszErrorCaption, MB_OK | MB_ICONSTOP);

   return;
}


/**-------------------------------------------------------------------------**/
VOID
DisplaySystemMessage(
      HWND  hWnd,
      UINT  uiSystemError
      )
{
   WCHAR szMessage[MAX_PATH];

   //
   // retrieve the string matching the Win32 system error
   //
   FormatMessage(
            FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
            NULL,
            uiSystemError,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
            szMessage,
            MAX_PATH,
            NULL);

   //
   // display a message box with this error
   //
   MessageBox(
            hWnd,
            szMessage,
            pszErrorCaption,
            MB_OK | MB_ICONSTOP);

   return;

} // DisplaySystemMessage


/**--------------------------------------------------------------------------**/
BOOL
UpdateOrderButtonState(
   HWND  hDlg
   )
{
   PHWPROF_INFO   pInfo;
   ULONG_PTR      ulIndex = 0;
   HWND           hList;


   pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);

   hList = GetDlgItem(hDlg, IDD_HWP_PROFILES);

   if ((ulIndex = SendMessage(hList,
        LB_GETCURSEL, 0, 0)) == LB_ERR) {
      return FALSE;
   }

   if (ulIndex == 0) {
      //
      // if focus currently on the button we're about to disable,
      // change focus first or focus will be lost.
      //
      if (GetFocus() == GetDlgItem(hDlg, IDD_HWP_ORDERUP)) {
          SendMessage(hDlg, DM_SETDEFID, IDD_HWP_ORDERDOWN, 0L);
          SetFocus(GetDlgItem(hDlg, IDD_HWP_ORDERDOWN));
      }
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERUP), FALSE);
   } else {
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERUP), TRUE);
   }

   if (ulIndex < pInfo->ulActiveProfiles-1) {
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERDOWN), TRUE);
   } else {
      //
      // if focus currently on the button we're about to disable,
      // change focus first or focus will be lost.
      //
      if (GetFocus() == GetDlgItem(hDlg, IDD_HWP_ORDERDOWN)) {
          SendMessage(hDlg, DM_SETDEFID, IDD_HWP_PROPERTIES, 0L);
          SetFocus(GetDlgItem(hDlg, IDD_HWP_PROPERTIES));
      }
      EnableWindow(GetDlgItem(hDlg, IDD_HWP_ORDERDOWN), FALSE);
   }




   return TRUE;
}


/**-------------------------------------------------------------------------**/
BOOL CALLBACK AddPropSheetPageProc(
    HPROPSHEETPAGE  hpage,
    LPARAM  lParam
   )
{
    hPages[ulNumPages] = hpage;

    return TRUE;

} // AddPropSheetPageProc


/**--------------------------------------------------------------------------**/
BOOL
DisplayProperties(
    IN HWND           hOwnerDlg,
    IN PHWPROF_INFO   pInfo
    )
{
    BOOL              bStatus;
    LPTSTR            pszProviderList = NULL, pszProvider = NULL;
    PROPSHEETPAGE     PropPage;
    PROPSHEETHEADER   PropHeader;
    FARPROC           lpProc;
    ULONG             i, ulSize = 0;
    HKEY              hKey = NULL;


    //
    // create the first page (General)
    //
    ulNumPages = 0;

    PropPage.dwSize        = sizeof(PROPSHEETPAGE);
    PropPage.dwFlags       = PSP_DEFAULT;
    PropPage.hInstance     = hInstance;
    PropPage.pszTemplate   = MAKEINTRESOURCE(DLG_HWP_GENERAL);
    PropPage.pszIcon       = NULL;
    PropPage.pszTitle      = NULL;
    PropPage.pfnDlgProc    = GeneralProfileDlg;
    PropPage.lParam        = (LPARAM)pInfo;
    PropPage.pfnCallback   = NULL;

    hPages[0] = CreatePropertySheetPage(&PropPage);
    if (hPages[0] == NULL) {
        return FALSE;
    }

    ulNumPages++;

    //
    // open the IDConfigDB key
    //
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszRegIDConfigDB, 0,
                     KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS) {
        return FALSE;
    }


    //---------------------------------------------------------------
    // Are there any other property pages?
    //---------------------------------------------------------------

    if (RegQueryValueEx(hKey, pszRegPropertyProviders, NULL, NULL,
                        NULL, &ulSize) == ERROR_SUCCESS) {

        pszProviderList = LocalAlloc(LPTR, ulSize);

        if (pszProviderList != NULL) {
            //
            // read list of providers
            //
            if (RegQueryValueEx(hKey, pszRegPropertyProviders, NULL, NULL,
                    (LPBYTE)pszProviderList, &ulSize) == ERROR_SUCCESS) {
                //
                // Ask each provider to create and register it's property page
                //
                for (pszProvider = pszProviderList;
                     *pszProvider;
                     pszProvider += lstrlen(pszProvider) + 1) {

                    if (ulNumPages >= MAX_EXTENSION_PROVIDERS) {
                        break;      // stop at max number of pages
                    }

                    //
                    // load the provider DLL
                    //
                    hLibs[ulNumPages] = LoadLibrary(pszProvider);
                    if (hLibs[ulNumPages] != NULL) {

                        lpProc = GetProcAddress(hLibs[ulNumPages],
                                                "ExtensionPropSheetPageProc");
                        if (lpProc != NULL) {
                            //
                            // pass the profile ID to the provider as the lParam value
                            //
                            if ((lpProc)(NULL,
                                         &AddPropSheetPageProc,
                                         pInfo->ulSelectedProfile)) {
                                ulNumPages++;
                            }
                        }
                    }
                }
            }
            LocalFree(pszProviderList);
        }
    }

    RegCloseKey(hKey);


    //
    // create the property sheet
    //
    PropHeader.dwSize      = sizeof(PROPSHEETHEADER);
    PropHeader.dwFlags     = PSH_PROPTITLE | PSH_NOAPPLYNOW;
    PropHeader.hwndParent  = hOwnerDlg;
    PropHeader.hInstance   = hInstance;
    PropHeader.pszIcon     = NULL;   //MAKEINTRESOURCE(DOCK_ICON);
    PropHeader.pszCaption  =
            pInfo->pHwProfValues[pInfo->ulSelectedProfileIndex].szFriendlyName;
    PropHeader.nPages      = ulNumPages;
    PropHeader.phpage      = hPages;
    PropHeader.nStartPage  = 0;
    PropHeader.pfnCallback = NULL;

    if (PropertySheet(&PropHeader) == 1) {
        bStatus = FALSE;
    } else {
        bStatus = TRUE;
    }

    //
    // cleanup extension page info
    //
    for (i = 1; i < ulNumPages; i++) {
        FreeLibrary(hLibs[i]);
    }

    return bStatus;

} // DisplayProperties



/**-------------------------------------------------------------------------**/
INT_PTR
APIENTRY
GeneralProfileDlg(
      HWND    hDlg,
      UINT    uMessage,
      WPARAM  wParam,
      LPARAM  lParam
      )

{
   PHWPROF_INFO      pInfo = NULL;
   PHWPROF_VALUES    pProfInfo = NULL;
   ULONG             ulReturn, ulIndex;

   switch (uMessage)
   {
      case WM_INITDIALOG:

         if (!lParam) {
            break;
         }

         //
         // on WM_INITDIALOG call, lParam points to the property sheet page.
         // The lParam field in the property sheet page struct is set by,
         // caller. When I created the property sheet, I passed in a pointer
         // to a HWPROF_INFO struct. Save this in the user window long so I
         // can access it on later messages.
         //
         pInfo = (PHWPROF_INFO)((LPPROPSHEETPAGE)lParam)->lParam;
         SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)pInfo);

         pProfInfo = (PHWPROF_VALUES)(&(pInfo->pHwProfValues[pInfo->ulSelectedProfileIndex]));

         SetDlgItemText(hDlg, IDD_HWP_ST_PROFILE, pProfInfo->szFriendlyName);

         //
         // for pre-beta hwprofile code, the dockstate might have originally
         // been set to zero which is invalid, use 0x111 instead
         //
         if (pProfInfo->ulDockState == 0) {
            pProfInfo->ulDockState =
                     DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED | DOCKINFO_UNDOCKED;
         }

         //
         // initialize the dock state radio buttons
         //
         if ((pProfInfo->ulDockState & DOCKINFO_DOCKED) &&
             (pProfInfo->ulDockState & DOCKINFO_UNDOCKED)) {

            CheckRadioButton(hDlg, IDD_HWP_UNKNOWN, IDD_HWP_UNDOCKED, IDD_HWP_UNKNOWN);
         }
         else if (pProfInfo->ulDockState & DOCKINFO_DOCKED) {
            CheckRadioButton(hDlg, IDD_HWP_UNKNOWN, IDD_HWP_UNDOCKED, IDD_HWP_DOCKED);
         }
         else if (pProfInfo->ulDockState & DOCKINFO_UNDOCKED) {
            CheckRadioButton(hDlg, IDD_HWP_UNKNOWN, IDD_HWP_UNDOCKED, IDD_HWP_UNDOCKED);
         }
         else {
            CheckRadioButton(hDlg, IDD_HWP_UNKNOWN, IDD_HWP_UNDOCKED, IDD_HWP_UNKNOWN);
         }

         //
         // if the user-specified bit is not set then the dock state
         // was determined from the hardware so don't allow changing it
         //
         if (pProfInfo->ulDockState & DOCKINFO_USER_SUPPLIED) {
         }
         else {
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_PORTABLE), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_DOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNDOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNKNOWN), FALSE);
         }

         //
         // initialize the dock id and serial # static control
         //
         if (pProfInfo->szSerialNumber[0] &&
             (pProfInfo->szSerialNumber[0] != TEXT('0'))) {
            SetDlgItemText(hDlg, IDD_HWP_SERIALNUM, pProfInfo->szSerialNumber);
         }
         else {
            SetDlgItemText(hDlg, IDD_HWP_SERIALNUM, pszUnavailable);
         }

         if (pProfInfo->szDockID[0] &&
             (pProfInfo->szDockID[0] != TEXT('0'))) {
            SetDlgItemText(hDlg, IDD_HWP_DOCKID, pProfInfo->szDockID);
            //
            // if dock id is available then docking state is known
            // and cannot be over-ridden (this is a redundant check,
            // the dock state should be accurate)
            //
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_PORTABLE), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_DOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNDOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNKNOWN), FALSE);
         }
         else {
            SetDlgItemText(hDlg, IDD_HWP_DOCKID, pszUnavailable);
         }

         //
         // initialize the portable checkbox-groupbox
         //
         if (pInfo->bPortable) {
            CheckDlgButton(hDlg, IDD_HWP_PORTABLE, BST_CHECKED);
         }
         else {
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_DOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNDOCKED), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNKNOWN), FALSE);
         }

         //
         // Don't allow changing the global IsPortable Flag if it was determined
         // from the hardware
         //
         if (pInfo->bHwDetectedPortable) {
             EnableWindow(GetDlgItem(hDlg, IDD_HWP_PORTABLE), FALSE);
         }

         //
         // initialize the aliasable checkbox
         //
         if (pProfInfo->bAliasable) {
            CheckDlgButton(hDlg, IDD_HWP_ALIASABLE, BST_CHECKED);
         }
         else {
             CheckDlgButton(hDlg, IDD_HWP_ALIASABLE, BST_UNCHECKED);
         }

         SetFocus(GetDlgItem(hDlg, IDD_HWP_PORTABLE));
         return FALSE;

      case WM_DEVICECHANGE:
         //
         // If a hardware profile change event takes place while the dialog is
         // up, just dismiss the dialog because things have changed.
         //
         if (wParam == DBT_CONFIGCHANGED) {
            PropSheet_PressButton(GetParent(hDlg), PSBTN_CANCEL);
            return TRUE;
         }
         break;

      case WM_NOTIFY:

         if (!lParam) {
            break;
         }

         switch (((NMHDR *)lParam)->code) {

             case PSN_APPLY:

               pInfo = (PHWPROF_INFO)GetWindowLongPtr(hDlg, DWLP_USER);
               pProfInfo = (PHWPROF_VALUES)(&(pInfo->pHwProfValues[pInfo->ulSelectedProfileIndex]));

               //
               // unchecked --> checked case
               //
               if (!pInfo->bPortable && IsDlgButtonChecked(hDlg, IDD_HWP_PORTABLE)) {
                  pInfo->bPortable = TRUE;
               }
               //
               // checked --> unchecked case
               //
               else if (pInfo->bPortable && !IsDlgButtonChecked(hDlg, IDD_HWP_PORTABLE)) {

                   TCHAR szCaption[MAX_PATH];
                   TCHAR szMsg[MAX_PATH];

                   LoadString(hInstance, HWP_ERROR_CAPTION, szCaption, MAX_PATH);
                   LoadString(hInstance, HWP_CONFIRM_NOT_PORTABLE, szMsg, MAX_PATH);

                   //
                   // confirm with user that other profiles will be set to unknown
                   //
                   if (MessageBox(hDlg, szMsg, szCaption,
                                  MB_OKCANCEL | MB_ICONQUESTION) == IDCANCEL) {

                       SetWindowLongPtr(hDlg, DWLP_MSGRESULT, TRUE);   // don't apply
                       return TRUE;
                   }

                   for (ulIndex = 0; ulIndex < pInfo->ulNumProfiles; ulIndex++) {

                       if (pInfo->pHwProfValues[ulIndex].ulDockState & 
                           DOCKINFO_USER_SUPPLIED) {
                           //
                           // only user-specified dock states will be changed
                           //
                           pInfo->pHwProfValues[ulIndex].ulDockState =
                               DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED | DOCKINFO_UNDOCKED;
                           pInfo->pHwProfValues[ulIndex].ulAction = HWP_PROPERTIES;                           
                       }

                   }
                   pInfo->bPortable = FALSE;
               }

               //
               // if user-specified dock state, then update the profile values
               // with current ui settings
               //
               if (pProfInfo->ulDockState & DOCKINFO_USER_SUPPLIED) {

                  if (IsDlgButtonChecked(hDlg, IDD_HWP_DOCKED)) {
                     pProfInfo->ulDockState |= DOCKINFO_DOCKED;
                     pProfInfo->ulDockState &= ~DOCKINFO_UNDOCKED;
                  }
                  else if (IsDlgButtonChecked(hDlg, IDD_HWP_UNDOCKED)) {
                     pProfInfo->ulDockState |= DOCKINFO_UNDOCKED;
                     pProfInfo->ulDockState &= ~DOCKINFO_DOCKED;
                  }
                  else {
                     pProfInfo->ulDockState |= (DOCKINFO_UNDOCKED | DOCKINFO_DOCKED);
                  }
               }

               //
               // aliasable unchecked --> checked case
               //
               if (!pProfInfo->bAliasable && IsDlgButtonChecked(hDlg, IDD_HWP_ALIASABLE)) {
                  pProfInfo->bAliasable = TRUE;
               } 
               //
               // aliasable checked --> unchecked case
               //
               else if (pProfInfo->bAliasable && !IsDlgButtonChecked(hDlg, IDD_HWP_ALIASABLE)) {
                  pProfInfo->bAliasable = FALSE;
               } 

               //
               // commit the changes for this profile
               //
               pProfInfo->ulAction |= HWP_PROPERTIES;
               WriteProfileInfo(pProfInfo);

               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);   // TRUE if error
               break;

            case PSN_RESET:
               //
               // user canceled the property sheet
               //
               break;
         }
         break;


      case WM_HELP:
         WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE,
               HELP_WM_HELP, (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;

      case WM_CONTEXTMENU:
         WinHelp((HWND)wParam, HELP_FILE, HELP_CONTEXTMENU,
                  (DWORD_PTR)(LPTSTR)HwProfileHelpIds);
         break;


      case WM_COMMAND:
      {
         switch (LOWORD(wParam))
         {
            case IDD_HWP_PORTABLE:
               //
               // if user chooses portable
               //
               if (!IsDlgButtonChecked(hDlg, IDD_HWP_PORTABLE)) {
                  CheckRadioButton(hDlg, IDD_HWP_UNKNOWN, IDD_HWP_UNDOCKED, IDD_HWP_UNKNOWN);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_DOCKED), FALSE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNDOCKED), FALSE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNKNOWN), FALSE);
               }
               else {
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_DOCKED), TRUE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNDOCKED), TRUE);
                  EnableWindow(GetDlgItem(hDlg, IDD_HWP_UNKNOWN), TRUE);
               }
               break;

            default:
               return FALSE;
          }
          break;

       } // case WM_COMMAND...

       default:
          return FALSE;
          break;
    }

    return TRUE;

} // GeneralProfileDlg