windows-xp/Source/XPSP1/NT/shell/osshell/progman/pmgseg.c

/****************************************************************************/
/*                                                                          */
/*  PMGSEG.C -                                                              */
/*                                                                          */
/*      Program Manager Group Handling Routines                             */
/*                                                                          */
/****************************************************************************/

#include "progman.h"
#include "dde.h"
#include "convgrp.h"

#define WORD_MIN -32767
#define WORD_MAX  32767

#ifndef ORGCODE
#include "fcntl.h"
#include "io.h"
#include "stdio.h"
#include <tchar.h>
#define S_IREAD     0000400         /* read permission, owner */
#define S_IWRITE    0000200         /* write permission, owner */
#endif

BOOL fFirstLoad = FALSE;
extern BOOL bHandleProgramGroupsEvent;

#if 0
// DOS apps are no longer set to fullscreen by default in progman
//  5-3-93 johannec (bug 8343)
#ifdef i386
BOOL IsDOSApplication(LPTSTR lpPath);
BOOL SetDOSApplicationToFullScreen(LPTSTR lpTitle);
#endif
#endif

void NEAR PASCAL RemoveItemFromList(PGROUP pGroup, PITEM pItem)
    // Removes a PITEM from the list.
{
    PITEM *ppItem;

    /* Cause it to be repainted later. */
    InvalidateIcon(pGroup, pItem);

    if (pItem == pGroup->pItems) {
        /*
         * first one in list, must invalidate next one so it paints an active
         * title bar.
         */
        InvalidateIcon(pGroup,pItem->pNext);
    }

    /* Remove it from the list. */
    for (ppItem = &pGroup->pItems;*ppItem != pItem;
        ppItem = &((*ppItem)->pNext));

    *ppItem = pItem->pNext;

    /* Lastly free up the memory. */
    LocalFree((HANDLE)pItem);
}

#ifdef DEBUG
void NEAR PASCAL CheckBeforeReAlloc(HANDLE h)
{
        TCHAR buf[100];

        if ((BYTE)GlobalFlags(h)) {
                wsprintf(buf, TEXT("LockCount before realloc %d\r\n"), (BYTE)GlobalFlags(h));
                OutputDebugString(buf);
                DbgBreakPoint();
        }
}
#else
#define CheckBeforeReAlloc(h)
#endif

#ifdef PARANOID
/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CheckRange() -                                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void PASCAL CheckRange(
    LPGROUPDEF lpgd,
    LPTSTR lp1,
    WORD *lpw1,
    WORD cb1,
    LPTSTR lp2,
    WORD w2,
    WORD cb2,
    LPTSTR lpThing)
{
    WORD w1 = *lpw1;
    WORD e1, e2;

    if (!w1 || (w1 == w2)) {
        return;
    }

    if (!cb1) {
        cb1 = (WORD)lstrlen((LPTSTR) PTR(lpgd, *lpw1));
    }

    e1 = w1 + cb1;
    e2 = w2 + cb2;

    if ((w1 < e2) && (w2 < e1)) {
        KdPrint(("ERROR: %s overlaps %s in %s!!!!\r\n",lp2,lp1,lpThing));
    }
}


/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  CheckPointer() -                                                            */
/*                                                                            */
/*--------------------------------------------------------------------------*/

void PASCAL CheckPointer(
    LPGROUPDEF lpgd,
    LPTSTR lp,
    WORD *lpw,
    WORD cb,
    WORD limit)
{
    LPITEMDEF lpid;
    int i;

    if (lpw == NULL || !*lpw) {
        KdPrint(("Warning: %s is NULL\r\n", lp));
        DebugBreak();
    }

    if (!cb) {
        cb = lstrlen((LPTSTR) PTR(lpgd, *lpw));
    }

    if (*lpw + cb > limit) {
        KdPrint(("ERROR: %s runs off end of group\r\n", lp));
        return;
    }

}


/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  VerifyGroup() -                                                            */
/*                                                                            */
/*--------------------------------------------------------------------------*/

void PASCAL VerifyGroup(
    LPGROUPDEF lpgd)
{
    int       i;
    LPITEMDEF lpid;
    DWORD     limit = lpgd->cbGroup;

    KdPrint(("\r\nChecking Group %s\r\n",(LPTSTR) PTR(lpgd, lpgd->pName)));
    CheckPointer(lpgd, TEXT("Group Name"), &lpgd->pName, 0, limit);

    for (i = 0; i < (int)lpgd->cItems; i++) {
        if (!lpgd->rgiItems[i]) {
            continue;
        }

        lpid = ITEM(lpgd, i);
        KdPrint(("Checking item %d at %4.4X (%s):\r\n", i, lpgd->rgiItems[i],
                (LPTSTR) PTR(lpgd, lpid->pName)));
        CheckPointer(lpgd, TEXT("Itemdef"), lpgd->rgiItems + i, sizeof(ITEMDEF), limit);
        CheckPointer(lpgd, TEXT("Item name"), &lpid->pName, 0, limit);
        CheckPointer(lpgd, TEXT("item command"), &lpid->pCommand, 0, limit);
        CheckPointer(lpgd, TEXT("item icon path"), &lpid->pIconPath, 0, limit);
    }
}
#endif


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsGroupReadOnly() -                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL FAR PASCAL IsGroupReadOnly(LPTSTR szGroupKey, BOOL bCommonGroup)
{
    HKEY hkey;
    HKEY hkeyGroups;

    if (bCommonGroup)
       hkeyGroups = hkeyCommonGroups;
    else if (bUseANSIGroups)
        hkeyGroups = hkeyAnsiProgramGroups;
    else
        hkeyGroups = hkeyProgramGroups;

    if (!hkeyGroups)
        return(FALSE);

    if (!RegOpenKeyEx(hkeyGroups, szGroupKey, 0, DELETE | KEY_READ | KEY_WRITE, &hkey)){
        RegCloseKey(hkey);
        return(FALSE);
    }
    return(TRUE);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GroupCheck() -                                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL FAR PASCAL GroupCheck(PGROUP pGroup)
{
    if (!fExiting && IsGroupReadOnly(pGroup->lpKey, pGroup->fCommon)) {
        pGroup->fRO = TRUE;
        return FALSE;
    }
    pGroup->fRO = FALSE;
    return TRUE;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  MyDwordAlign() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

INT MyDwordAlign(INT wStrLen)
{
    return ((wStrLen + 3) & ~3);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SizeofGroup() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/
DWORD PASCAL SizeofGroup(LPGROUPDEF lpgd)
{
    LPPMTAG lptag;
    DWORD cbSeg;
    DWORD cb;

    cbSeg = (DWORD)GlobalSize(lpgd);

    lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);

    if ((DWORD)((PCHAR)lptag - (PCHAR)lpgd +MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))+4) <= cbSeg
        && lptag->wID == ID_MAGIC
        && lptag->wItem == (int)0xFFFF
        && lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4)
        && *(PLONG)lptag->rgb == PMTAG_MAGIC)
      {
        while ((cb = (DWORD)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg)
          {
            if (lptag->wID == ID_LASTTAG)
                return cb;
            (LPSTR)lptag += lptag->cb;
          }
      }
    return lpgd->cbGroup;
}

/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  LockGroup() -                                                            */
/*                                                                            */
/*--------------------------------------------------------------------------*/

/* Given the handle to the group's window, lock the group segment and return
 * a pointer thereto.  Reloads the group segment if it is not in memory.
 */

LPGROUPDEF FAR PASCAL LockGroup(HWND hwndGroup)

{
  PGROUP     pGroup;
  LPGROUPDEF lpgd;
  WORD       status;
  LPTSTR      lpszKey;
  HKEY       hKey = NULL;
  LONG       err;
  DWORD      cbMaxValueLen = 0;
  FILETIME   ft;
  TCHAR       szClass[64];
  DWORD      dummy = 64;
  DWORD      cbSecDesc;
  HKEY       hkeyGroups;
  BOOL       bCommonGroup;

  wLockError = 0;   // No errors.

  /* Find the handle and try to lock it. */
  pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
  lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

  /* If we got a non-NULL selector, return the pointer. */
  if (pGroup->fLoaded)
      return(lpgd);

  if (lpgd) {
      GlobalUnlock(pGroup->hGroup);
  }

  NukeIconBitmap(pGroup);        // invalidate the bitmap

  /* The group has been discarded, must reread the file... */
  lpszKey = pGroup->lpKey;

  pGroup->fRO = FALSE;

  bCommonGroup = pGroup->fCommon;
  if (bCommonGroup)
      hkeyGroups = hkeyCommonGroups;
  else if (bUseANSIGroups)
      hkeyGroups = hkeyAnsiProgramGroups;
  else
      hkeyGroups = hkeyProgramGroups;

  if (!hkeyGroups)
      goto RegError;

  /* Try to open the group key. */
  if (err = RegOpenKeyEx(hkeyGroups, lpszKey, 0,
                         DELETE | KEY_READ | KEY_WRITE,
                         &hKey)) {
      /* Try read-only access */
      if (err = RegOpenKeyEx(hkeyGroups, lpszKey, 0,
                         KEY_READ, &hKey) || !hKey) {
          status = IDS_NOGRPFILE;
          goto LGError1;
      }
      if (!bUseANSIGroups) {
          pGroup->fRO = TRUE;
      }
  }

  if (!(err = RegQueryInfoKey(hKey,
                              szClass,
                              &dummy,   // cbClass
                              NULL,     // Title index
                              &dummy,   // cbSubKeys
                              &dummy,   // cb Max subkey length
                              &dummy,   // max class len
                              &dummy,   // values count
                              &dummy,   // max value name length
                              &cbMaxValueLen,
                              &cbSecDesc,   // cb Security Descriptor
                              &ft))) {
      if (!pGroup->ftLastWriteTime.dwLowDateTime &&
                   !pGroup->ftLastWriteTime.dwHighDateTime)
          pGroup->ftLastWriteTime = ft;
      else if (pGroup->ftLastWriteTime.dwLowDateTime != ft.dwLowDateTime ||
               pGroup->ftLastWriteTime.dwHighDateTime != ft.dwHighDateTime ) {
          wLockError = LOCK_FILECHANGED;
          status = IDS_GRPHASCHANGED;
          if (!fExiting)     // Don't reload changed groups on exit.
              PostMessage(hwndProgman,WM_RELOADGROUP,(WPARAM)pGroup,0L);
          goto LGError2;
      }
  }

  /* Find the size of the file by seeking to the end. */
  if (cbMaxValueLen < sizeof(GROUPDEF)) {
      status = IDS_BADFILE;
      goto LGError2;
  }

  /* Allocate some memory for the thing. */
  CheckBeforeReAlloc(pGroup->hGroup);
  if (!GlobalReAlloc(pGroup->hGroup, (DWORD)cbMaxValueLen, GMEM_MOVEABLE)) {
      wLockError = LOCK_LOWMEM;
      status = IDS_LOWMEM;
      lpszKey = NULL;
      goto LGError2;
  }

  pGroup->fLoaded = TRUE;
  lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

  /* Read the whole group data into memory. */
  status = IDS_BADFILE;
  if (err = RegQueryValueEx(hKey, NULL, 0, 0, (LPBYTE)lpgd, &cbMaxValueLen)) {
      goto LGError3;
  }
  //
  // If we start out from the ANSI groups, we need the security description
  // to copy the entire information to the UNICODE groups
  //
  if (bUseANSIGroups) {
      pGroup->pSecDesc = (PSECURITY_DESCRIPTOR)LocalAlloc(LPTR, cbSecDesc);
      RegGetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pGroup->pSecDesc, &cbSecDesc);
  }
  else {
      pGroup->pSecDesc = NULL;
  }

  //
  // If we loaded an old format ANSI group, then convert it to the
  // UNICODE format and save it back in the registry.
  //
  if (lpgd->dwMagic == GROUP_MAGIC) {
      HANDLE hUNIGroup;

      if (cbMaxValueLen = ConvertToUnicodeGroup((LPGROUPDEF_A)lpgd, &hUNIGroup)) {
          UnlockGroup(hwndGroup);
          /* Free the ANSI group. */
          GlobalFree(pGroup->hGroup);
          pGroup->hGroup = hUNIGroup;
          lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
      }
      else {
          goto LGError3;
      }
  }

  if (lpgd->dwMagic != GROUP_UNICODE)
      goto LGError3;

  if (lpgd->cbGroup > cbMaxValueLen)
      goto LGError3;

  /* Now return the pointer. */
  RegCloseKey(hKey);

  return(lpgd);

LGError3:
  GlobalUnlock(pGroup->hGroup);
  GlobalDiscard(pGroup->hGroup);
  pGroup->fLoaded = FALSE;

LGError2:
  RegCloseKey(hKey);

LGError1:
  if (status != IDS_LOWMEM && status != IDS_GRPHASCHANGED && status != IDS_NOGRPFILE) {
      MyMessageBox(hwndProgman, IDS_GROUPFILEERR, status, pGroup->lpKey,
                   MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
      if (status == IDS_BADFILE) {
          //
          // stop handling of Program Groups key changes.
          //
          bHandleProgramGroupsEvent = FALSE;

          RegDeleteKey(hkeyGroups, lpszKey);

          //
          // reset handling of Program Groups key changes.
          //
          ResetProgramGroupsEvent(bCommonGroup);
          bHandleProgramGroupsEvent = TRUE;
      }
      return(NULL);
  }

  /*
   * Special case the group not being found so we can delete it's entry...
   */
  if (status == IDS_NOGRPFILE) {
      /*
       * If no restrictions then we can fixup progman.ini...
       */
      if (!fNoSave && dwEditLevel < 1) {
          TCHAR szGroup[10];

          if (MyMessageBox(hwndProgman,IDS_GROUPFILEERR,IDS_NOGRPFILE2,lpszKey, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON1 | MB_SYSTEMMODAL) == IDNO) {
              wsprintf(szGroup,TEXT("Group%d"),pGroup->wIndex);
              //
              // stop handling of Program Groups key changes.
              //
              bHandleProgramGroupsEvent = FALSE;
              RegDeleteKey(hkeyProgramGroups, lpszKey);

              //
              // reset handling of Program Groups key changes.
              //
              ResetProgramGroupsEvent(bCommonGroup);
              bHandleProgramGroupsEvent = TRUE;
              RegDeleteValue(hkeyPMGroups, szGroup);

              if (!fFirstLoad)
                  PostMessage(hwndProgman,WM_UNLOADGROUP,(WPARAM)hwndGroup,0L);
          }
      }
      else {
RegError:
          /*
           * Restrictions mean that the user can only OK this error...
           */
          MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_NOGRPFILE, lpszKey,
                           MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
      }
  }

  ShowWindow(hwndGroup, SW_SHOWMINNOACTIVE);

  return(NULL);
}


/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  UnlockGroup() -                                                            */
/*                                                                            */
/*--------------------------------------------------------------------------*/

void FAR PASCAL UnlockGroup(register HWND hwndGroup)

{
  GlobalUnlock(((PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP))->hGroup);
}

/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  LockItem() -                                                            */
/*                                                                            */
/*--------------------------------------------------------------------------*/

LPITEMDEF FAR PASCAL LockItem(PGROUP pGroup, PITEM pItem)
{
  LPGROUPDEF        lpgd;

  lpgd = LockGroup(pGroup->hwnd);

  if (!lpgd)
      return((LPITEMDEF)NULL);

  return ITEM(lpgd,pItem->iItem);
}


/*--------------------------------------------------------------------------*/
/*                                                                            */
/*  KeepGroupAround() -                                                     */
/*                                                                            */
/*--------------------------------------------------------------------------*/

/*
 * Sets or unsets the discardable flag for the given group file.  If setting
 * to non-discard, forces the group to be in memory.
 */

HANDLE PASCAL KeepGroupAround(HWND hwndGroup, BOOL fKeep)
{
    PGROUP pGroup;

    UNREFERENCED_PARAMETER(fKeep);
    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
    return pGroup->hGroup;

#ifdef ORGCODE
    PGROUP pGroup;
    WORD flag;

    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);

    if (fKeep) {
        if (LockGroup(hwndGroup)) {
            UnlockGroup(hwndGroup);  // it is still in memory
        } else {
            return NULL; // failure
        }

        flag = GMEM_MODIFY | GMEM_MOVEABLE;  // make non discardable
    } else {
        flag = GMEM_MODIFY | GMEM_MOVEABLE | GMEM_DISCARDABLE;  // discardable
    }

    return GlobalReAlloc(pGroup->hGroup, 0, flag);
#endif
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SaveGroup() -                                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/*
 * Writes out a group file.  It must already be in memory or the operation
 * is meaningless.
 */
BOOL APIENTRY SaveGroup(
    HWND hwndGroup, BOOL bDiscard
    )
{
    LPGROUPDEF lpgd;
    HKEY       hKey;
    PGROUP     pGroup;
    WORD       status = 0;
    DWORD      cb;
    LONG       err;
    HKEY       hkeyGroups;
    BOOL       bCommonGroup;
    DWORD      dwDisposition;

    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);

    bCommonGroup = pGroup->fCommon;

    if (!bUseANSIGroups && IsGroupReadOnly(pGroup->lpKey, bCommonGroup)) {
        // Don't produce an error message for RO groups.
        return FALSE;
    }

    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    if (!lpgd) {
        return FALSE;
    }

    if (bCommonGroup)
        hkeyGroups = hkeyCommonGroups;
    else
        hkeyGroups = hkeyProgramGroups;

    if (!hkeyGroups) {
        goto Exit1;
    }

    // it may already exist

    if (err = RegCreateKeyEx(hkeyGroups, pGroup->lpKey, 0, 0, 0,
                     DELETE | KEY_READ | KEY_WRITE | WRITE_DAC,
                     pSecurityAttributes, &hKey, &dwDisposition)) {
    //if (err = RegOpenKeyEx(hkeyGroups, pGroup->lpKey, 0,
    //                              KEY_SET_VALUE, &hKey)) {
        /*
         * We can't open output group key.
         */
        if (err = RegOpenKeyEx(hkeyGroups, pGroup->lpKey, 0,
                                  KEY_READ, &hKey)) {
            status = IDS_NOGRPFILE;
        } else {
            // status = IDS_GRPISRO;
            RegCloseKey(hKey);
        }
        goto Exit1;
    }
    else {
        if (dwDisposition == REG_CREATED_NEW_KEY && bUseANSIGroups) {
            RegSetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pGroup->pSecDesc);
            LocalFree(pGroup->pSecDesc);
            pGroup->pSecDesc = NULL;
        }

    }

    //
    // stop handling Program Groups key changes for a SAveGroup.
    //
    bHandleProgramGroupsEvent = FALSE;

    cb = SizeofGroup(lpgd);
    if (err = RegSetValueEx(hKey, NULL, 0, REG_BINARY, (LPBYTE)lpgd, cb)) {
        status = IDS_CANTWRITEGRP;
    }

    RegFlushKey(hKey);
    RegCloseKey(hKey);

    pGroup->ftLastWriteTime.dwLowDateTime = 0;   // update file time stamp if we need to reload
    pGroup->ftLastWriteTime.dwHighDateTime = 0;

Exit1:
    GlobalUnlock(pGroup->hGroup);

    if (status && !fExiting) {
        MyMessageBox(hwndProgman, IDS_GROUPFILEERR, status, pGroup->lpKey,
                MB_OK | MB_ICONEXCLAMATION);

        /*
         * Force the group to be reset.
         */
        if (bDiscard) {
            GlobalDiscard(pGroup->hGroup);
            pGroup->fLoaded = FALSE;
            InvalidateRect(pGroup->hwnd, NULL, TRUE);
        }
    }

    //
    // reset handling of Program Groups key changes.
    //
    ResetProgramGroupsEvent(bCommonGroup);
    bHandleProgramGroupsEvent = TRUE;
    return (status == 0);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AdjustPointers() -                                                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/*
 * Adjusts pointers in the segment after a section is moved up or down.
 */
void PASCAL AdjustPointers(LPGROUPDEF lpgd, DWORD iFirst, DWORD di)
{
    WORD i;
    LPITEMDEF lpid;

    if (lpgd->pName >= iFirst) {
        lpgd->pName += di;
    }

    for (i = 0; i < lpgd->cItems; i++) {
        if (!lpgd->rgiItems[i]) {
            continue;
        }

        if (lpgd->rgiItems[i] >= iFirst) {
            lpgd->rgiItems[i] += di;
        }

        lpid = ITEM(lpgd, i);

        if (lpid->pIconRes >= iFirst)
            lpid->pIconRes += di;
        if (lpid->pName >= iFirst)
            lpid->pName += di;
        if (lpid->pCommand >= iFirst)
            lpid->pCommand += di;
        if (lpid->pIconPath >= iFirst)
            lpid->pIconPath += di;
    }
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FindFreeItemIndex() -                                                   */
/*                                                                          */
/* Returns the index of a free slot in the item offset array.  If necessary,*/
/* moves stuff around.                                                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/

WORD PASCAL FindFreeItemIndex(HWND hwndGroup)
{
    LPGROUPDEF lpgd;
    PGROUP     pGroup;
    WORD       i;
    LPTSTR      lp1;
    LPTSTR      lp2;
    DWORD      cb;

    lpgd = LockGroup(hwndGroup);
    if (!lpgd) {
        return(0xFFFF);
    }

    for (i = 0; i < lpgd->cItems; i++) {
        if (!lpgd->rgiItems[i]) {
            UnlockGroup(hwndGroup);
            return(i);
        }
    }

    /*
     * Didn't find an empty slot... make some new ones.
     */
    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);

    // Current groups+tags size.
    cb = SizeofGroup(lpgd);

    // Increase space reserved item info.
    lpgd->cbGroup += NSLOTS*sizeof(DWORD);

    // Increase size of whole group.
    cb += NSLOTS*sizeof(DWORD);

    UnlockGroup(hwndGroup);

    CheckBeforeReAlloc(pGroup->hGroup);
    if (!GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE)) {
        return 0xFFFF;
    }

    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

    /*
     * Copy tags junk (which starts at the end of the rgiItems array)
     * up a bit to make room for the bigger array..
     */
    lp1 = (LPTSTR)&(lpgd->rgiItems[lpgd->cItems]);
    lp2 = (LPTSTR)&(lpgd->rgiItems[lpgd->cItems + NSLOTS]);

    /*
     * Copy everything down in the segment.
     */
    RtlMoveMemory(lp2, lp1, (WORD)(cb - (DWORD)((LPSTR)lp2 - (LPSTR)lpgd)));

    /*
     * Zero out the new offsets.
     */
    for (i = (WORD)lpgd->cItems; i < (WORD)(lpgd->cItems + NSLOTS); i++) {
        lpgd->rgiItems[i] = 0;
    }

    i = lpgd->cItems;

    /* Record that we now have more slots */
    lpgd->cItems += NSLOTS;

    /*
     * Fix up all the offsets in the segment.  Since the rgiItems array is
     * part of the group header, all the pointers will change.
     */
    AdjustPointers(lpgd, (WORD)1, NSLOTS * sizeof(DWORD));

    GlobalUnlock(pGroup->hGroup);

    return i;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DeleteThing() -                                                         */
/*                                                                          */
/*                                                                          */
/* Removes a part of the group segment.  Updates everything in the segment  */
/* but does not realloc.                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void NEAR PASCAL DeleteThing(LPGROUPDEF lpgd, LPDWORD lpiThing, WORD cbThing)
{
  DWORD       dwThingOffset;
  LPTSTR      lp1;
  LPTSTR      lp2;
  INT        cb;
  WORD       cbThingSize;

  if (cbThing == 0xFFFF) {
      return;
  }

  dwThingOffset = *lpiThing;

  if (!dwThingOffset)
      return;

  *lpiThing = 0;

  lp1 = (LPTSTR) PTR(lpgd, dwThingOffset);

  /* If its a string we're removing, the caller can pass 0 as the length
   * and have it calculated!!!
   */
  if (!cbThing) {
      cbThing = (WORD)sizeof(TCHAR)*(1 + lstrlen(lp1));
  }

  cbThingSize = (WORD)MyDwordAlign((int)cbThing);

  lp2 = (LPTSTR)((LPBYTE)lp1 + cbThingSize);

  cb = (int)SizeofGroup(lpgd);

  RtlMoveMemory(lp1, lp2, (cb - (DWORD)((LPSTR)lp2 - (LPSTR)lpgd)));

  lpgd->cbGroup -= cbThingSize;

  AdjustPointers(lpgd, dwThingOffset, -cbThingSize);

}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AddThing() -                                                            */
/*                                                                          */
/* in:                                                                      */
/*	hGroup	group handle, must not be discardable                           */
/*	lpStuff	pointer to data or NULL to init data to zero                    */
/*	cbStuff	count of item (may be 0) if lpStuff is a string                 */
/*                                                                          */
/* Adds an object to the group segment and returns its offset.	Will        */
/* reallocate the segment if necessary.                                     */
/*                                                                          */
/* Handle passed in must not be discardable                                 */
/*                                                                          */
/* returns:                                                                 */
/*	0	failure                                                             */
/*	> 0	offset to thing in the segment                                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/

DWORD PASCAL AddThing(HANDLE hGroup, LPTSTR lpStuff, DWORD cbStuff)
{
    DWORD        cb;
    LPGROUPDEF  lpgd;
    DWORD        offset;
    LPTSTR       lpT;
    DWORD        cbStuffSize;
    DWORD        cbGroupSize;
    DWORD        myOffset;

    if (cbStuff == 0xFFFFFFFF) {
        return 0xFFFFFFFF;
    }

    if (!cbStuff) {
        cbStuff = sizeof(TCHAR)*(DWORD)(1 + lstrlen(lpStuff));
    }

    cbStuffSize = MyDwordAlign((int)cbStuff);

    lpgd = (LPGROUPDEF)GlobalLock(hGroup);
    cb = SizeofGroup(lpgd);
    cbGroupSize = MyDwordAlign((int)cb);

    offset = lpgd->cbGroup;
    myOffset = (DWORD)MyDwordAlign((int)offset);

    GlobalUnlock(hGroup);

    CheckBeforeReAlloc(hGroup);
    if (!GlobalReAlloc(hGroup,(DWORD)(cbGroupSize + cbStuffSize), GMEM_MOVEABLE))
        return 0;

    lpgd = (LPGROUPDEF)GlobalLock(hGroup);

    /*
     * Slide the tags up
     */
    RtlMoveMemory((LPSTR)lpgd + myOffset + cbStuffSize, (LPSTR)lpgd + myOffset,
                            (cbGroupSize - myOffset));
    lpgd->cbGroup += cbStuffSize;

    lpT = (LPTSTR)((LPSTR)lpgd + myOffset);
    if (lpStuff) {
        RtlMoveMemory(lpT, lpStuff, cbStuff);

    } else {
        /*
         * Zero it
         */
        while (cbStuffSize--) {
            *((LPSTR)lpT)++ = 0;
        }
    }


    GlobalUnlock(hGroup);

    return myOffset;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FindTag() -                                                             */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LPPMTAG NEAR PASCAL FindTag(LPGROUPDEF lpgd, int item, WORD id)
{
    LPPMTAG lptag;
    int cbSeg;
    int cb;

    cbSeg = (DWORD)GlobalSize(lpgd);

    lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);

    if ((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4 <= cbSeg
        && lptag->wID == ID_MAGIC
        && lptag->wItem == (int)0xFFFF
        && lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) +4)
        && *(LONG FAR *)lptag->rgb == PMTAG_MAGIC) {

        while ((cb = (int)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg)
        {
            if ((item == lptag->wItem)
                && (id == 0 || id == lptag->wID)) {
                return lptag;
            }

            if (lptag->wID == ID_LASTTAG)
                return NULL;

            (LPSTR)lptag += lptag->cb;
        }
    }
    return NULL;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CopyTag() -                                                             */
/*                                                                          */
/*--------------------------------------------------------------------------*/

INT FAR PASCAL CopyTag(LPGROUPDEF lpgd, int item, WORD id, LPTSTR lpbuf, int cb)
{
    LPTSTR lpt;
    LPPMTAG lptag;
    WORD cbT;

    lptag = FindTag(lpgd,item,id);

    if (lptag == NULL)
        return 0;

    if (cb > (int)lptag->cb)
        cb = lptag->cb;

    cbT = (WORD)cb;

    lpt = (LPTSTR) lptag->rgb;

    while (*lpt && cbT) {
       *lpbuf++=*lpt++;
       cbT--;
    }

    if (!(*lpt) && cbT) {
        *lpbuf = TEXT('\0');
    }

    return cb;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DeleteTag() -                                                           */
/*                                                                          */
/* in:                                                                      */
/*	hGroup	group handle, can be discardable (alwayws shrink object)        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FAR PASCAL DeleteTag(HANDLE hGroup, int item, WORD id)
{
    LPPMTAG lptag;
    LPTSTR lp1, lp2;
    LPTSTR lpend;
    LPGROUPDEF lpgd;

    lpgd = (LPGROUPDEF) GlobalLock(hGroup);

    lptag = FindTag(lpgd,item,id);

    if (lptag == NULL) {
        GlobalUnlock(hGroup);
        return;
    }

    lp1 = (LPTSTR)lptag;

    lp2 = (LPTSTR)((LPSTR)lptag + lptag->cb);

    lpend = (LPTSTR)((LPSTR)lpgd + SizeofGroup(lpgd));

    while (lp2 < lpend) {
        *lp1++ = *lp2++;
    }

    /* always reallocing smaller
     */
    GlobalUnlock(hGroup);
    CheckBeforeReAlloc(hGroup);
    GlobalReAlloc(hGroup, (DWORD)((LPSTR)lp1 - (LPSTR)lpgd), 0);

    return;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AddTag() -                                                              */
/*                                                                          */
/* in:                                                                      */
/*	h	group handle, must not be discardable!                              */
/*                                                                          */
/* returns:                                                                 */
/*  0	failure                                                             */
/*	1	success                                                             */
/*--------------------------------------------------------------------------*/
INT PASCAL AddTag(HANDLE h, int item, WORD id, LPTSTR lpbuf, int cb)
{
    LPPMTAG lptag;
    WORD fAddFirst;
    LPGROUPDEF lpgd;
    int cbNew;
    int cbMyLen;
    LPGROUPDEF lpgdOld;


    if (!cb && lpbuf) {
        cb = sizeof(TCHAR)*(lstrlen(lpbuf) + 1);
    }
    cbMyLen = MyDwordAlign(cb);

    if (!lpbuf) {
        cb = 0;
        cbMyLen = 0;
    }

    /*
     * Remove the old version of the tag, if any.
     */
    DeleteTag(h, item, id);

    lpgd = (LPGROUPDEF)GlobalLock(h);

    lptag = FindTag(lpgd, (int)0xFFFF, (WORD)ID_LASTTAG);

    if (!lptag) {
        /*
         * In this case, there are no tags at all, and we have to add
         * the first tag, the interesting tag, and the last tag
         */
        cbNew = 3 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + 4 + cbMyLen;
        fAddFirst = TRUE;
        lptag = (LPPMTAG)((LPSTR)lpgd + lpgd->cbGroup);

    } else {
        /*
         * In this case, only the interesting tag needs to be added
         * but we count in the last because the delta is from lptag
         */
        cbNew = 2 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + cbMyLen;
        fAddFirst = FALSE;
    }

    /*
     * check for 64K limit
     */
    if ((DWORD_PTR)lptag + cbNew < (DWORD_PTR)lptag) {
        return 0;
    }

    cbNew += (int)((PCHAR)lptag -(PCHAR)lpgd);
    lpgdOld = lpgd;
    GlobalUnlock(h);
    CheckBeforeReAlloc(h);
    if (!GlobalReAlloc(h, (DWORD)cbNew, GMEM_MOVEABLE)) {
        return 0;
    }

    lpgd = (LPGROUPDEF)GlobalLock(h);
    lptag = (LPPMTAG)((LPSTR)lpgd + ((LPSTR)lptag - (LPSTR)lpgdOld));
    if (fAddFirst) {
        /*
         * Add the first tag
         */
        lptag->wID = ID_MAGIC;
        lptag->wItem = (int)0xFFFF;
        *(LONG FAR *)lptag->rgb = PMTAG_MAGIC;
        lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + 4);
        (LPSTR)lptag += lptag->cb;
    }

    /*
     * Add the tag
     */
    lptag->wID = id;
    lptag->wItem = item;
    lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + cbMyLen);
    if (lpbuf) {
        RtlMoveMemory(lptag->rgb, lpbuf, (WORD)cb);
    }
    (LPSTR)lptag += lptag->cb;

    /*
     * Add the end tag
     */
    lptag->wID = ID_LASTTAG;
    lptag->wItem = (int)0xFFFF;
    lptag->cb = 0;

    GlobalUnlock(h);

    return 1;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  NukeIconBitmap -- Deletes the icon bitmap if one exists for the group   */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void PASCAL NukeIconBitmap(PGROUP pGroup)
{
    if (pGroup->hbm) {
        DeleteObject(pGroup->hbm);
        pGroup->hbm = NULL;
    }
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GroupFlag() -                                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/

WORD PASCAL GroupFlag(PGROUP pGroup, PITEM pItem, WORD wFlag)
{
    LPGROUPDEF lpgd;
    LPPMTAG lptag;
    WORD wT = 0;
    int wItem;

    if (pItem) {
        wItem = pItem->iItem;
    } else {
        wItem = (int)0xFFFF;
    }

    lpgd = LockGroup(pGroup->hwnd);
    if (!lpgd)
        return 0;

    lptag = FindTag(lpgd, wItem, wFlag);

    if (!lptag)
        wT = 0;
    else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))))
        wT = 1;
    else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 1))
        wT = lptag->rgb[0];
    else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4))
        wT = *(LPWORD)lptag->rgb;
    UnlockGroup(pGroup->hwnd);

    return wT;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetGroupTag() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

WORD PASCAL GetGroupTag(
    PGROUP pGroup,
    PITEM pItem,
    WORD id,
    LPTSTR lpT,
    WORD cb)
{
    WORD wT;
    LPGROUPDEF lpgd;
    int wItem;

    if (pItem)
        wItem = pItem->iItem;
    else
        wItem = (int)0xFFFF;

    lpgd = LockGroup(pGroup->hwnd);
    if (!lpgd)
        return 0;

    wT = (WORD)CopyTag(lpgd, wItem, id, lpT, cb);

    UnlockGroup(pGroup->hwnd);
    return wT;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  ChangeTagID() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void PASCAL ChangeTagID(
    LPGROUPDEF lpgd,
    int iOld,
    int iNew)
{
    LPPMTAG lptag;

    while (lptag = FindTag(lpgd,iOld,0)) {
        lptag->wItem = iNew;
    }
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  LoadItem() -                                                            */
/*                                                                          */
/* Creates an item window (iconic) within a group window.  Assumes that the */
/* group segment is up to date.                                             */
/*                                                                          */
/*--------------------------------------------------------------------------*/

PITEM PASCAL LoadItem(HWND hwndGroup, WORD iItem, BOOL bActivate)
{
    LPGROUPDEF lpgd;
    LPITEMDEF  lpid;
    PGROUP     pGroup;
    PITEM      pItem;
    PITEM      *ppItem;

    lpgd = LockGroup(hwndGroup);
    if (!lpgd)
        return NULL;

    pItem = (PITEM)LocalAlloc(LPTR, sizeof(ITEM));
    if (!pItem) {
        UnlockGroup(hwndGroup);
        return NULL;
    }

    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);

    NukeIconBitmap(pGroup);

    if (bActivate) {
        InvalidateIcon(pGroup, pGroup->pItems);
        pItem->pNext = pGroup->pItems;
        pGroup->pItems = pItem;
    } else {
        ppItem = &pGroup->pItems;
        while (*ppItem) {
            ppItem = &((*ppItem)->pNext);
        }
        pItem->pNext = NULL;
        *ppItem = pItem;
    }

    lpid = ITEM(lpgd, iItem);

    pItem->iItem = iItem;
    pItem->dwDDEId = 0;
    SetRectEmpty(&pItem->rcTitle);
    SetRectEmpty(&pItem->rcIcon);

    ComputeIconPosition(pGroup, lpid->pt, &pItem->rcIcon, &pItem->rcTitle,
            (LPTSTR) PTR(lpgd, lpid->pName));

    UnlockGroup(hwndGroup);

    InvalidateIcon(pGroup, pItem);

    return pItem;
}


PITEM FindItemName(LPGROUPDEF lpgd, register PITEM pItem, LPTSTR lpTitle)
{
  LPITEMDEF  lpid;

  while (pItem) {
      lpid = ITEM(lpgd, pItem->iItem);

      if (!lstrcmp(lpTitle, (LPTSTR) PTR(lpgd, lpid->pName)))
        return pItem;

      pItem = pItem->pNext;
  }

  return NULL;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CreateNewItem() -                                                       */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/*
 * Creates a new item in the file, and adds a window for it.
 */
PITEM PASCAL CreateNewItem(
    HWND    hwndGroup,
    LPTSTR   lpTitle,
    LPTSTR   lpCommand,
    LPTSTR   lpIconPath,
    LPTSTR   lpDefDir,
    WORD    wHotKey,
    BOOL    fMinimize,
    WORD    wIconId,
    WORD    wIconIndex,
    HICON   hIcon,
    LPPOINT lppt,
    DWORD   dwFlags)
{
    LPGROUPDEF lpgd;
    LPITEMDEF  lpid;
    WORD       id;
    DWORD      offset;
    PGROUP     pGroup;
    LPTSTR     lpIconRes;
    WORD       cbIconRes;
    //DWORD    dwVer;
    WORD       wVer;
    WORD       idError = IDS_LOWMEM;
    PITEM      pItem;
    DWORD      cb;
    TCHAR      szCommand[3*MAX_PATH];
    TCHAR      szExeDir[MAXITEMPATHLEN + 1];
    TCHAR      szIconExe[MAX_PATH];
    TCHAR      szTemp[MAXITEMPATHLEN+1];
    LPTSTR     lp1, lp2, lp3;
    HANDLE     hIconRes;
    HANDLE     hModule;
    BOOL       fWin32App = FALSE;
    BOOL       fUseDefaultIcon = FALSE;
    BOOL       bNoIconPath = TRUE;
    TCHAR      cSeparator;

    /*
     * Before we do anything, whack the command line and exedir
     */
    lp1 = lpCommand;
    if (*lpCommand == TEXT('"') && wcschr(lpCommand + 1, TEXT('"'))) {
        cSeparator = TEXT('"');
        //lp1++;
    }
    else {
        cSeparator = TEXT(' ');
    }
    for (lp2=lp3=szExeDir; *lp1 && *lp1 != cSeparator; lp1 = CharNext(lp1))
    {
        *lp2++ = *lp1;

        /*
         * We know we're looking at the first byte
         */
        if ((*lp1 == TEXT(':')) || (*lp1 == TEXT('\\'))) {
            lp3 = lp2;
        }
    }

    *lp2 = 0;

    /*
     * If the default dir pointer is NULL then we use the directory
     * component of the command line.  Otherwise we do the normal
     * path whacking stuff to get everything into 3.0 format.
     */
    if (lpDefDir) {
        LPTSTR lpT;

        lpT = lpDefDir;
        // We have a valid pointer.
    	lstrcpy(szCommand,lpDefDir);
#if 0
/* spaces are allowed in LFN.
 */
        RemoveLeadingSpaces(szCommand);
#endif

        // If a default dir was supplied then go ahead and whack it
        // into 3.0 format otherwise leave it blank.
        if (*lpDefDir)
        {
            LPTSTR lpNextChar;

            // locate the character before the NULL
            while ( *(lpNextChar = CharNext(lpDefDir)) )
                lpDefDir = lpNextChar;

            // If there is no '\' seperator, add one.
            if (lpDefDir[0] != TEXT('\\')) {
                lstrcat(szCommand,TEXT("\\"));
            }
        }

        /*
         * Now add the filename itself.  this puts the command in the
         * 3.0 format: defdir\exename
         */
        lstrcat(szCommand, lp3);

        /*
         * Append the arguments
         */
        lstrcat(szCommand, lp1);
        lpDefDir = lpT;

    } else {
        /*
         * Use the same command line (note def dir is assigned exe dir
         */
        lstrcpy(szCommand, lpCommand);
    }

    /*
     * Now truncate exedir so that it does not include the command filename
     */
    *lp3 = 0;

    pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

    if (!GroupCheck(pGroup)) {
    	MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_GROUPRO,
                     (LPTSTR) PTR(lpgd, lpgd->pName),
                     MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
	GlobalUnlock(pGroup->hGroup);
        return NULL;
    }
    GlobalUnlock(pGroup->hGroup);

    if (*lpIconPath) {
	    bNoIconPath = FALSE;
    }

    lstrcpy(szIconExe, lpIconPath);
    if (bNoIconPath && !(dwFlags & CI_NO_ASSOCIATION)) {
        lstrcpy(szIconExe, lpCommand);
    }
    DoEnvironmentSubst(szIconExe, (WORD)CharSizeOf(szIconExe));
    StripArgs(szIconExe);
    if (!bNoIconPath) {
        TagExtension(szIconExe, sizeof(szIconExe));
    }

    if (*szIconExe == TEXT('"') && *(szIconExe + lstrlen(szIconExe)-1) == TEXT('"')) {
        SheRemoveQuotes(szIconExe);
    }

    if (bNoIconPath) {
        //
        // if it's a relative path, extractassociatedicon and LoadLibrary don't
        // handle that so find the executable first
        //
        SetCurrentDirectory(szOriginalDirectory);
        FindExecutable(szIconExe, lpDefDir, szTemp);
        if (*szTemp) {
            lstrcpy(szIconExe, szTemp);
            TagExtension(szIconExe, sizeof(szIconExe));
            if (*szIconExe == TEXT('"') && *(szIconExe + lstrlen(szIconExe)-1) == TEXT('"')) {
		        SheRemoveQuotes(szIconExe);
	        }
        }
        else {
            *szIconExe = 0;    // Use a dummy value so no icons will be found
                               // and progman's item icon will be used instead
                               // This is to make moricons.dll item icon be the
                               // right one.  -johannec 6/4/93
        }
        //
        // reset the current directory to progman's working directory i.e. Windows directory
        //
        SetCurrentDirectory(szWindowsDirectory);

        wIconId = 0;
        wIconIndex = 0;
    }


NoIcon:

    if (!wIconId) {
        TCHAR szOldIconExe[MAX_PATH];

        lstrcpy(szOldIconExe, szIconExe);
        hIcon = ExtractAssociatedIconEx(hAppInstance, szIconExe, &wIconIndex, &wIconId);
        if (lstrcmp(szOldIconExe, szIconExe)) {
            /* using default icon from Progman.exe */
            fUseDefaultIcon = TRUE;
        }
        if (hIcon)
            DestroyIcon(hIcon);
    }

    lpIconRes = NULL;
    hIconRes = NULL;
    if (hModule = LoadLibrary(szIconExe)) {
        fWin32App = TRUE;
        hIconRes = FindResource(hModule, (LPTSTR) MAKEINTRESOURCE(wIconId), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
        if (hIconRes) {
            //dwVer = 0x00030000;  // resource version is windows 3.x
            wVer = 3;  // resource version is windows 3.x
            cbIconRes = (WORD)SizeofResource(hModule, hIconRes);
            hIconRes = LoadResource(hModule, hIconRes);
            lpIconRes = LockResource(hIconRes);
        }
        if (fUseDefaultIcon) {
            wIconId = 0;
        }
    }
    else { // Win 3.1 app

        if (wVer = ExtractIconResInfo(hAppInstance, szIconExe, wIconIndex, &cbIconRes, &hIconRes)){
            lpIconRes = GlobalLock(hIconRes);
        }
    }

    if (!lpIconRes) {
       wIconId = 0;
       wIconIndex = 0;

       // ToddB: I see no harm in always setting the current directory to the WinDir
       //   before jumping back to NoIcon.  Seems to be required to fix a Japanese bug.
       //   The WinDir is the default directory of Progman anyhow, I really don't see
       //   where it's possible for us to not already be in this directory.
       SetCurrentDirectory(szWindowsDirectory);

       goto NoIcon;
    }

    if (!KeepGroupAround(hwndGroup, TRUE)) {
        goto FreeIcon;
    }

    id = FindFreeItemIndex(hwndGroup);
    if (id == 0xFFFF) {
        goto FreeIcon;
    }

    if (id >= CITEMSMAX) {                      // check group size limit
        idError = IDS_TOOMANYITEMS;
        goto FreeIcon;
    }

    offset = AddThing(pGroup->hGroup, (TCHAR)0, (WORD)sizeof(ITEMDEF));
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

    if (!offset) {
        goto QuitThis;
    }

    lpgd->rgiItems[id] = offset;
    lpid = ITEM(lpgd, id);

    GlobalUnlock(pGroup->hGroup);
    offset = AddThing(pGroup->hGroup, lpTitle, (WORD)0);
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    lpid = ITEM(lpgd, id);
    if (!offset) {
        goto PuntCreation;
    }

    lpid->pName = offset;

    GlobalUnlock(pGroup->hGroup);
    offset = AddThing(pGroup->hGroup, szCommand,(WORD) 0);
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    lpid = ITEM(lpgd, id);
    if (!offset) {
        goto PuntCreation;
    }
    lpid->pCommand = offset;

    GlobalUnlock(pGroup->hGroup);
    CheckEscapes(szIconExe, CharSizeOf(szIconExe));
    offset = AddThing(pGroup->hGroup, szIconExe,(WORD) 0);
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    lpid = ITEM(lpgd, id);
    if (!offset)
        goto PuntCreation;
    lpid->pIconPath = offset;

    GlobalUnlock(pGroup->hGroup);
    offset = AddThing(pGroup->hGroup, lpIconRes, cbIconRes);
    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    lpid = ITEM(lpgd, id);
    if (!offset)
        goto PuntCreation;
    lpid->pIconRes = offset;

    if (lppt) {
        lpid->pt = *lppt;
    } else {
        lpid->pt.x = lpid->pt.y = -1;
    }

    lpid->iIcon = wIconId;
    lpid->wIconIndex = wIconIndex;
    //lpid->dwIconVer = dwVer;
    lpid->wIconVer = wVer;
    lpid->cbIconRes = cbIconRes;

    if (cbIconRes != 0xFFFF)
    if (fWin32App) {
        UnlockResource(hIconRes);
        FreeResource(hIconRes);
        FreeLibrary(hModule);
    }
    else {
        GlobalUnlock(hIconRes);
        GlobalFree(hIconRes);
    }
    GlobalUnlock(pGroup->hGroup);

    if (wHotKey) {
        AddTag(pGroup->hGroup, (int)id, (WORD)ID_HOTKEY, (LPTSTR)&wHotKey, sizeof(wHotKey));
    }
    if (fMinimize) {
        AddTag(pGroup->hGroup, (int)id, (WORD)ID_MINIMIZE, NULL, 0);
    }
    if (dwFlags & CI_SEPARATE_VDM) {
        AddTag(pGroup->hGroup, (int)id, (WORD)ID_NEWVDM, NULL, 0);
    }
    if (*szExeDir) {
        AddTag(pGroup->hGroup, (int)id, (WORD)ID_APPLICATIONDIR, szExeDir, 0);
    }

    pItem = LoadItem(hwndGroup, id, dwFlags & CI_ACTIVATE);

    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
    lpid = ITEM(lpgd, id);

    if (!pItem) {
        goto PuntCreation;
    }

    lpid->pt.x = pItem->rcIcon.left;
    lpid->pt.y = pItem->rcIcon.top;

    GlobalUnlock(pGroup->hGroup);

#if 0
// DOS apps are no longer set to fullscreen by default in progman
//  5-3-93 johannec (bug 8343)
#ifdef i386
    //
    // If this is a new DOS application, set the default to full screen.
    // This is only done for x86, since mips doesn't have full screen.
    //
    lstrcpy(szCommand, lpCommand);
    DoEnvironmentSubst(szCommand, (WORD)lstrlen(szCommand));
    StripArgs(szCommand);
    TagExtension(szCommand, sizeof(szCommand));
    *szTemp = 0;
    FindExecutable(szCommand, lpDefDir, szTemp);

    if ((dwFlags & CI_SET_DOS_FULLSCRN) && *szTemp && IsDOSApplication(szTemp)) {
        SetDOSApplicationToFullScreen(lpTitle);
    }
#endif
#endif

    KeepGroupAround(hwndGroup, FALSE);

    // We need to save the current group to disk now
    // in case a setup program is doing DDE with us,
    // and they reboot the system when finished.

    if (!SaveGroup (hwndGroup, FALSE)) {
        idError = 0;
        DeleteItem(pGroup, pItem);
        goto FreeIcon;
    }

    return pItem;

PuntCreation:
    /*
     * Note, must set lpid after each because it may move
     */
    DeleteThing(lpgd, (LPDWORD)&lpid->pName, 0);
    DeleteThing(lpgd, (LPDWORD)&lpid->pCommand, 0);
    DeleteThing(lpgd, (LPDWORD)&lpid->pIconPath, 0);
    DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
    DeleteThing(lpgd, (LPDWORD)&lpgd->rgiItems[id], sizeof(ITEMDEF));

QuitThis:
    cb = SizeofGroup(lpgd);
    UnlockGroup(pGroup->hwnd);

    CheckBeforeReAlloc(pGroup->hGroup);
    GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE);

    KeepGroupAround(hwndGroup, FALSE);

FreeIcon:
    if (cbIconRes != 0xFFFF)
    if (fWin32App) {
        UnlockResource(hIconRes);
        FreeResource(hIconRes);
        FreeLibrary(hModule);
    }
    else {
        GlobalUnlock(hIconRes);
        GlobalFree(hIconRes);
    }

    if (idError != 0)
        MyMessageBox(hwndProgman, IDS_GROUPFILEERR, idError, NULL,
                        MB_OK | MB_ICONEXCLAMATION);
    // Force re-read of group.
    //GlobalDiscard(pGroup->hGroup);
    //pGroup->fLoaded = FALSE ;
    //LockGroup(pGroup->hwnd);
    //UnlockGroup(pGroup->hwnd);

    return NULL;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DeleteItem() -                                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FAR PASCAL DeleteItem(PGROUP pGroup, PITEM pItem)
{
  LPGROUPDEF lpgd;
  LPITEMDEF  lpid;
  DWORD      cb;
  LPPMTAG    lptag;

  lpgd = LockGroup(pGroup->hwnd);
  if (!lpgd)
      return;

  if (!GroupCheck(pGroup)) {
      MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_GROUPRO,
                   (LPTSTR) PTR(lpgd, lpgd->pName),
                   MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
      InvalidateIcon(pGroup, pItem);
      return;
  }

  NukeIconBitmap(pGroup);

  lpid = ITEM(lpgd,pItem->iItem);

  if ( (lpgd->cbGroup != (DWORD)MyDwordAlign((int)lpgd->cbGroup)) ||
       (lpid->pName != (DWORD)MyDwordAlign((int)lpid->pName)) ||
       (lpid->pCommand != (DWORD)MyDwordAlign((int)lpid->pCommand)) ||
       (lpid->pIconPath != (DWORD)MyDwordAlign((int)lpid->pIconPath)) ||
       (lpgd->rgiItems[pItem->iItem] != (DWORD)MyDwordAlign((int)lpgd->rgiItems[pItem->iItem])) ) {

      MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
                   (LPTSTR) PTR(lpgd, lpgd->pName),
                   MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
      return;
  }


  /* note, must set lpid after each because it may move
   */
  DeleteThing(lpgd, (LPDWORD)&lpid->pName, 0);
  DeleteThing(lpgd, (LPDWORD)&lpid->pCommand, 0);
  DeleteThing(lpgd, (LPDWORD)&lpid->pIconPath, 0);
  DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
  DeleteThing(lpgd, (LPDWORD)&lpgd->rgiItems[pItem->iItem], sizeof(ITEMDEF));

  while (lptag = FindTag(lpgd,pItem->iItem,0)) {
      /* delete all tags associated with this item
       */
      UnlockGroup(pGroup->hwnd);
      DeleteTag(pGroup->hGroup, lptag->wItem, lptag->wID);
      lpgd = LockGroup(pGroup->hwnd);
  }

  /* Don't need Item anymore so delete it. */
  RemoveItemFromList(pGroup, pItem);

  cb = SizeofGroup(lpgd);

  UnlockGroup(pGroup->hwnd);

  CheckBeforeReAlloc(pGroup->hGroup);
  GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE);

  if (bAutoArrange && !bAutoArranging)
      ArrangeItems(pGroup->hwnd);
  else if (!bAutoArranging)
      CalcGroupScrolls(pGroup->hwnd);

}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CreateItemIcons() -                                                     */
/*                                                                          */
/* Creates all the item windows...                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID PASCAL CreateItemIcons(HWND hwndGroup)
{
    LPGROUPDEF lpgd;
    int        i;

    lpgd = LockGroup(hwndGroup);

    if (!lpgd) {
        return;
    }

    /*
     * Create the items in reverse Z-Order.
     */
    for (i = lpgd->cItems - 1; i >= 0; i--) {
        if (lpgd->rgiItems[i]) {
            LoadItem(hwndGroup, (WORD)i, TRUE);
        }
    }

    UnlockGroup(hwndGroup);

  // REVIEW This may be not be needed because LoadGroupWindow does a
  // SetInternalWindowPos which MIGHT already be generating the messages
  // to do this.
  if (bAutoArrange && !bAutoArranging)
      ArrangeItems(hwndGroup);
  else if (!bAutoArranging)
      CalcGroupScrolls(hwndGroup);
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CheckIconResolution() -                                                 */
/*                                                                          */
/* Makes sure we have the right icons loaded... reextracts and saves        */
/* the file if not.                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID NEAR PASCAL CheckIconResolution(HWND hwndGroup)

{
  LPGROUPDEF        lpgd;
  LPITEMDEF         lpid;
  register PGROUP   pGroup;
  HANDLE            hGroup;
  BOOL              fGottaDoIt;
  register HDC      hdc;
  int               i;
  HICON             hIcon;
  WORD              cbIconRes;
  DWORD             pIconRes;
  LPTSTR            lpIconRes;
  WORD              wFormat;
  TCHAR             szTemp[MAXITEMPATHLEN];
  HANDLE            hModule;
  BOOL              fWin32App;
  //DWORD             dwVer;
  WORD              wVer;

  lpgd = LockGroup(hwndGroup);
  if (!lpgd)
      return;

  hdc = GetDC(hwndGroup);

  wFormat = (WORD)GetDeviceCaps(hdc, BITSPIXEL) |
        (WORD)GetDeviceCaps(hdc, PLANES) * (WORD)256;

  ReleaseDC(hwndGroup,hdc);

  fGottaDoIt = lpgd->wIconFormat != wFormat ||
               lpgd->cxIcon != (WORD)GetSystemMetrics(SM_CXICON) ||
               lpgd->cyIcon != (WORD)GetSystemMetrics(SM_CYICON);

  if (!fGottaDoIt) {
      goto CleanUpAndLeave;
  }

  pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);

  NukeIconBitmap(pGroup);

  /* Save the new resolution parameters in the group file. */
  lpgd->wIconFormat = wFormat;
  lpgd->cxIcon = (WORD)GetSystemMetrics(SM_CXICON);
  lpgd->cyIcon = (WORD)GetSystemMetrics(SM_CYICON);

  hGroup = pGroup->hGroup;

  for (i = 0; i < (int)lpgd->cItems; ++i) {
      if (!lpgd->rgiItems[i])
          continue;

      lpid = ITEM(lpgd, i);
      DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
      lpid = ITEM(lpgd, i);

      lstrcpy(szTemp, (LPTSTR) PTR(lpgd, lpid->pIconPath));
      if (!*szTemp) {
          /* Get default icon path */
          lstrcpy(szTemp, (LPTSTR) PTR(lpgd, lpid->pCommand));
          DoEnvironmentSubst(szTemp, (WORD)(MAXITEMPATHLEN+1));
          StripArgs(szTemp);
      }
      SheRemoveQuotes(szTemp);
    cbIconRes = 0xFFFF;
    lpIconRes = NULL;
    hIcon = NULL;

    if (hModule = LoadLibrary(szTemp)) {
        // if WIN32 app
        fWin32App = TRUE;
        hIcon = (HICON)FindResource(hModule, (LPTSTR) MAKEINTRESOURCE(lpid->iIcon), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
        if (hIcon) {
            //dwVer = 0x00030000;
            wVer = 3;
            cbIconRes = (WORD)SizeofResource(hModule, (HRSRC)hIcon);
            hIcon = (HICON)LoadResource(hModule, (HRSRC)hIcon);
            lpIconRes = LockResource(hIcon);
        }
    }
    else { // Win 3.1 app
        fWin32App = FALSE;
        if (wVer = ExtractIconResInfo(hAppInstance, szTemp, lpid->iIcon, &cbIconRes, (LPHANDLE)&hIcon)){
            lpIconRes = GlobalLock(hIcon);
        }
    }


      UnlockGroup(hwndGroup);

      pIconRes = AddThing(pGroup->hGroup, lpIconRes, cbIconRes);
      lpgd = LockGroup(hwndGroup);
      if (!lpgd)
          continue;

      /* In case the segment got moved... */
      lpid = ITEM(lpgd, i);

      if (hIcon)
      if (fWin32App) {
          UnlockResource(hIcon);
          FreeResource(hIcon);
          FreeLibrary(hModule);
      }
      else {
          GlobalUnlock(hIcon);
          GlobalFree(hIcon);
      }

      lpid->pIconRes = pIconRes;
      //lpid->dwIconVer = dwVer;
      lpid->wIconVer = wVer;
      lpid->cbIconRes = cbIconRes;
    }

#ifdef ORGCODE
      // Check everythings OK.
      if (!pHdr || !pAND || !pXOR)
        {
          // FU - delete icon stuff for this item..
          // REVIEW UNDONE - warn user about memory problem  ?

#ifdef DEBUG
          KdPrint(("PM.CIR: Corrupted icon %s \n\r", (LPTSTR) PTR(lpid->pName)));
#endif
          lpid = ITEM(lpgd, i);
          DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);

          // Mark item as being effed - the header is checked by
          // GetItemIcon.
          lpid = ITEM(lpgd, i);
          lpid->pIconRes = NULL;
          lpid->wIconVer = 0;           // This is the important one.
          lpid->cbIconRes = 0;

          // Warn user when we're through, not right in the middle.
          fErrorOnExtract = TRUE;
        }
    }
#endif

  if (!GroupCheck(pGroup))
      MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_EEGROUPRO,
                   (LPTSTR) PTR(lpgd, lpgd->pName),
                   MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);


CleanUpAndLeave:
  UnlockGroup(hwndGroup);

//REVIEW See above.
  KeepGroupAround(hwndGroup, FALSE);
  return;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CreateGroupHandle() -                                                   */
/*                                                                          */
/* Creates a discarded handle for use as a group handle... on the first     */
/* LockGroup() the file will be loaded.                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/

HANDLE NEAR PASCAL CreateGroupHandle(void)
{
  register HANDLE   hGroup;

  if (hGroup = GlobalAlloc(GMEM_MOVEABLE | GMEM_DISCARDABLE, 1L))
      GlobalDiscard(hGroup);

  return(hGroup);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  StartupGroup() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FAR PASCAL StartupGroup(HWND hwnd)
{
  PITEM pItemCur, pItemExec;
  LPGROUPDEF lpgd;
  INT xLast, yLast;    // Coord of icon to exec.
  INT xBest, yBest;    // Coord of next topmost-leftmost icon.
  MSG msg;             // Peek a message.
  PGROUP pGroup;       // The group.

  pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);

  /*
   * Handle Startup group in icon position order - not Z-order.
   */
  lpgd = LockGroup(hwnd);
  if (!lpgd)
      return;

  /*
   * Starts with the top left and works from left to right then
   * top to bottom.
   * This is really naff in terms of speed, but groups are usually
   * small and the time cost is still small compared to that of execing.
   */
  yLast = WORD_MIN;
  xLast = WORD_MIN;
  for (;;) {
      /*
       * Init
       */
      xBest = WORD_MAX;
      yBest = WORD_MAX;
      pItemExec = NULL;
      /*
       * Find next icon to the right of this one.
       */
      for (pItemCur = pGroup->pItems; pItemCur; pItemCur = pItemCur->pNext) {
          /*
           * Look for Icon to the right of this one.
           * REVIEW This will ignore icons stacked on top of each other.
           */
          if (pItemCur->rcIcon.top >= yLast
            && pItemCur->rcIcon.top <= yLast + (cyArrange/2)
            && pItemCur->rcIcon.left < xBest
            && pItemCur->rcIcon.left > xLast) {
              pItemExec = pItemCur;
              xBest = pItemCur->rcIcon.left;
          }
          /*
           * Check if it'll be suitable for the next row.
           */
          else if (pItemCur->rcIcon.top > yLast + (cyArrange/2)
            && pItemCur->rcIcon.top < yBest) {
              yBest = pItemCur->rcIcon.top;
          }

      }

      if (pItemExec) {
          /*
           * Found one on the current row.
           */

          xLast = xBest;
          /*
           * Move this item to the top of the z-order so that any searches
           * done during DDE will find the last execed item first.
           * REVIEW This messes with the z-odrder of the startup group.
           */
          BringItemToTop(pGroup, pItemExec, TRUE);
          /* Start it up. */
          ExecItem(pGroup,pItemExec,FALSE, TRUE);
          /*
           * Handle any DDE before doing anything else to stop
           * the message queue from over-flowing.
           */
          while(PeekMessage(&msg, hwndProgman, 0, 0, PM_REMOVE|PM_NOYIELD)) {
              TranslateMessage(&msg);
              DispatchMessage(&msg);
          }


      }
      else if (yBest != WORD_MAX) {
          /*
           * Nothing left on the current row but there is another row.
           */
          yLast = yBest;
          xLast = WORD_MIN;

      }
      else {
          /*
           * Nothing left.
           */
          goto Quit;
      }
  }

Quit:
  UnlockGroup(pGroup->hwnd);
}


/*---------------------------------------------------------------------------
 * Check for null item pointers and item pointers that go out of the group.
 * REVIEW UNDONE this doesn't check that the pointers point to things
 * after the end of the items array.
 */
BOOL NEAR PASCAL ValidItems(LPGROUPDEF lpgd)
{
    INT i;
    LPITEMDEF lpid;
    DWORD cbGroup;

    if (!lpgd)
        return FALSE;


    cbGroup = lpgd->cbGroup;

    for (i = 0; (WORD)i < lpgd->cItems; i++) {
        if (!lpgd->rgiItems[i])
	        continue;

        lpid = ITEM(lpgd,i);
        if (!lpid)
            return FALSE;

        if (lpid->pName > cbGroup)
            return FALSE;
        if (lpid->pCommand > cbGroup)
            return FALSE;
        if (lpid->pIconPath > cbGroup)
            return FALSE;
        if ((lpid->cbIconRes != (WORD)-1) && (lpid->pIconRes > cbGroup))
            return FALSE;

    }

    return(TRUE);
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsGroupAlreadyLoaded() -                                                */
/*                                                                          */
/* Determines if the user is trying to load a currently loaded group.       */
/*                                                                          */
/*--------------------------------------------------------------------------*/

HWND NEAR PASCAL IsGroupAlreadyLoaded(LPTSTR lpGroupKey, BOOL bCommonGroup)
{
  HWND     hwndT;
  PGROUP   pGroup;

  for (hwndT=GetWindow(hwndMDIClient, GW_CHILD); hwndT; hwndT=GetWindow(hwndT, GW_HWNDNEXT)) {
      if (GetWindow(hwndT, GW_OWNER))
          continue;

      pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
      if (!lstrcmpi(lpGroupKey, pGroup->lpKey)) {

          if (bCommonGroup) {

              if (pGroup->fCommon)
                  return(hwndT);

          } else {

              if (!pGroup->fCommon)
                  return(hwndT);

          }
      }
  }
  return(NULL);
}


BOOL NEAR PASCAL IndexUsed(WORD wIndex, BOOL bCommonGroup)
{
    PGROUP pGroup;

    for (pGroup = pFirstGroup; pGroup; pGroup = pGroup->pNext)
        if ((pGroup->wIndex == wIndex) && (pGroup->fCommon == bCommonGroup))
            return TRUE;

    return FALSE;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  LoadGroupWindow() -                                                     */
/*                                                                          */
/* Creates a group window by sending an MDI create message to the MDI client. */
/* The MDICREATESTRUCT contains a parameter pointer to the name of the group  */
/* key.                                                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/
// GroupFile must be ANSI.

HWND PASCAL LoadGroupWindow(LPTSTR lpKey, WORD wIndex, BOOL bCommonGroup)
{
    MDICREATESTRUCT mdics;
    PGROUP          pGroup;
    TCHAR           szGroupClass[64];
    LPGROUPDEF      lpgd;
    HWND            hwnd;
    TCHAR           szCommonGroupSuffix[MAXKEYLEN];
    TCHAR           szCommonGroupTitle[2*MAXKEYLEN];
    WINDOWPLACEMENT wp;

    //
    // Check if the group is already loaded. This will prevent duplicate groups.
    //
    if (hwnd = IsGroupAlreadyLoaded(lpKey, bCommonGroup)) {
        return(hwnd);
    }

    if (!wIndex) {
        while (IndexUsed(++wIndex, bCommonGroup))
                ;
    }

    if (!LoadString(hAppInstance, IDS_GROUPCLASS, szGroupClass,
            CharSizeOf(szGroupClass))) {
        return NULL;
    }

    pGroup = (PGROUP)LocalAlloc(LPTR,sizeof(GROUP));
    if (!pGroup) {
        return NULL;
    }

    pGroup->hGroup = CreateGroupHandle();
    pGroup->pItems = NULL;
    pGroup->hbm    = NULL;
    pGroup->wIndex = wIndex;
    pGroup->fCommon = bCommonGroup;
    pGroup->ftLastWriteTime.dwLowDateTime = 0;
    pGroup->ftLastWriteTime.dwHighDateTime = 0;

    pGroup->lpKey = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(lstrlen(lpKey) + 1));
    pGroup->fLoaded = FALSE;

    if (!pGroup->lpKey) {
GoAway:
        GlobalFree(pGroup->hGroup);
        LocalFree((HANDLE)pGroup);
        if (!fLowMemErrYet) {
            MyMessageBox(hwndProgman, IDS_APPTITLE, IDS_LOWMEMONINIT,
                    lpKey, MB_OK|MB_ICONEXCLAMATION);
            fLowMemErrYet = TRUE;
        }
        return NULL;
    }

    lstrcpy(pGroup->lpKey, lpKey);

    mdics.szTitle = TEXT("");
    mdics.hOwner = hAppInstance;
    mdics.szClass = szGroupClass;
    mdics.style = WS_VSCROLL|WS_HSCROLL;
    mdics.x = mdics.y = mdics.cx = mdics.cy = CW_USEDEFAULT;
    mdics.lParam = (LPARAM)pGroup;

    /*
     * REVIEW HACK - Set the auto arranging flag to stop the group being
     * loaded by ArrangingIcons doing a LockGroup  and then producing
     * an error if something goes wrong. We're going to do a lock
     * later on anyway and we don't want two error messages.
     */
    bAutoArranging = TRUE;
    pGroup->hwnd = (HWND)SendMessage(hwndMDIClient, WM_MDICREATE, 0, (LPARAM)(LPTSTR)&mdics);
    bAutoArranging = FALSE;

    if (!pGroup->hwnd) {
        LocalFree((HANDLE)pGroup->lpKey);
        goto GoAway;
    }

    /*
     * Note that we're about to load a group for the first time.
     * NB Stting this tells LockGroup that the caller can handle the errors.
     */
    fFirstLoad = TRUE;
    lpgd = LockGroup(pGroup->hwnd);
    /*
     * The group has been loaded or at least we tried.
     */
    fFirstLoad = FALSE;
    if (!lpgd) {
LoadFail:
        /* Loading the group failed somehow... */
        SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)pGroup->hwnd, 0L);
        //
        // stop handling of Program Groups key changes.
        //
        bHandleProgramGroupsEvent = FALSE;
        RegDeleteKey(hkeyProgramGroups, pGroup->lpKey);

        //
        // reset handling of Program Groups key changes.
        //
        ResetProgramGroupsEvent(bCommonGroup);
        bHandleProgramGroupsEvent = TRUE;

        LocalFree((HANDLE)pGroup->lpKey);
        GlobalFree(pGroup->hGroup);
        LocalFree((HANDLE)pGroup);
        return NULL;
    }

    /*
     * test if it is a Windows 3.1 group file format. If so it is not
     * valid in WIN32. In Windows 3.1 RECT and POINT are WORD instead of LONG.
     */

    if ( (lpgd->rcNormal.left != (INT)(SHORT)lpgd->rcNormal.left) ||
         (lpgd->rcNormal.right != (INT)(SHORT)lpgd->rcNormal.right) ||
         (lpgd->rcNormal.top != (INT)(SHORT)lpgd->rcNormal.top) ||
         (lpgd->rcNormal.bottom != (INT)(SHORT)lpgd->rcNormal.bottom) ){
        /* The group is invalid. */
        MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
                                (LPTSTR) PTR(lpgd, lpgd->pName),
                                MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
        UnlockGroup(pGroup->hwnd);
        goto LoadFail;
    }

    if (!ValidItems(lpgd)) {
        MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
                                (LPTSTR) PTR(lpgd, lpgd->pName),
                                MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
        UnlockGroup(pGroup->hwnd);
        goto LoadFail;
    }


    if (lpgd->nCmdShow) {
        SetInternalWindowPos(pGroup->hwnd, (UINT)lpgd->nCmdShow, &lpgd->rcNormal,
                &lpgd->ptMin);
    }

    if (pGroup->fCommon) {

        //
        // Add the common group suffix to the name of the group e.g. (Common)
        // Only do this if the group window is not minimized.
        //

        wp.length = sizeof(WINDOWPLACEMENT);
        GetWindowPlacement(pGroup->hwnd, &wp);
        if ((wp.showCmd == SW_MINIMIZE) ||
            (wp.showCmd == SW_SHOWMINIMIZED) ||
            (wp.showCmd == SW_SHOWMINNOACTIVE) ) {
            SetWindowText(pGroup->hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
        }
        else {
            lstrcpy(szCommonGroupTitle, (LPTSTR) PTR(lpgd, lpgd->pName));
            if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
                           CharSizeOf(szCommonGroupSuffix))) {
                lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
            }
            SetWindowText(pGroup->hwnd, szCommonGroupTitle);
            if (!UserIsAdmin) {
                pGroup->fRO = TRUE;
            }
        }
    }
    else {
        SetWindowText(pGroup->hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
    }


    UnlockGroup(pGroup->hwnd);

    //CheckIconResolution(pGroup->hwnd);

    CreateItemIcons(pGroup->hwnd);

    /*
     * Link the group.
     */
    pGroup->pNext = NULL;
    *pLastGroup = pGroup;
    pLastGroup = &pGroup->pNext;
    pCurrentGroup = pGroup;

#ifdef NOTINUSER
    CalcChildScroll(pGroup->hwnd, SB_BOTH);
#endif

    GroupCheck(pGroup);

    return(pGroup->hwnd);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  UnloadGroupWindow() -                                                   */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void FAR PASCAL UnloadGroupWindow(HWND hwnd)
{
    PGROUP pGroup, *ppGroup;
    PITEM pItem, pItemNext;

    pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);

    /* Destroy the window. */
    SendMessage(hwndMDIClient,WM_MDIDESTROY,(WPARAM)hwnd,0L);

    /* Free the group segment. */
    GlobalFree(pGroup->hGroup);

    /* Free the local stuff. */
    LocalFree((HANDLE)pGroup->lpKey);

    /* The cached bitmap if there is one. */
    if (pGroup->hbm) {
        DeleteObject(pGroup->hbm);
        pGroup->hbm = NULL;
    }

    /* The item data. */
    for (pItem = pGroup->pItems; pItem; pItem = pItemNext) {
        pItemNext = pItem->pNext;
        LocalFree((HANDLE) pItem);
    }

    /* Remove the group from the linked list. */
    for (ppGroup = &pFirstGroup; *ppGroup; ppGroup = &((*ppGroup)->pNext)) {
        if (*ppGroup == pGroup) {
            *ppGroup = pGroup->pNext;
            break;
        }
    }
    if (pLastGroup == &pGroup->pNext)
	pLastGroup = ppGroup;

    /* Lastly, free the group structure itself. */
    LocalFree((HANDLE)pGroup);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  RemoveBackslashFromKeyName() -                                          */
/*                                                                          */
/*  replace the invalid characters for a key name by some valid charater.   */
/*  the same characters that are invalid for a file name are invalid for a  */
/*  key name.                                                               */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void RemoveBackslashFromKeyName(LPTSTR lpKeyName)
{
    LPTSTR lpt;

    for (lpt = lpKeyName; *lpt; lpt++) {
        if ((*lpt == TEXT('\\')) || (*lpt == TEXT(':')) || (*lpt == TEXT('>')) || (*lpt == TEXT('<')) ||
             (*lpt == TEXT('*')) || (*lpt == TEXT('?')) ){
            *lpt = TEXT('.');
        }
    }
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  CreateNewGroup() -                                                      */
/*                                                                          */
/*  This function creates a new, empty group.                               */
/*                                                                          */
/*--------------------------------------------------------------------------*/

HWND PASCAL CreateNewGroup(LPTSTR pGroupName, BOOL bCommonGroup)
{
    HANDLE      hT;
    LPGROUPDEF  lpgd;
    PGROUP      pGroup;
    HDC         hdc;
    int         i;
    int         cb;
    TCHAR       szKeyName[MAXKEYLEN+1];
    HWND        hwnd;
    DWORD       status = 0;
    WORD        cGroups;
    INT         wGroupNameLen;   //length of pGroupName DWORD aligned.
    HKEY        hkeyGroups;
    HKEY        hKey;
    HWND        hwndT;
    PSECURITY_ATTRIBUTES pSecAttr;

    /*
     * Check we're not trying to create too many groups.
     * Count the current number of groups.
     */
    cGroups = 0;

    for (hwnd = GetWindow(hwndMDIClient, GW_CHILD); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT)) {
        if (GetWindow(hwnd, GW_OWNER))
            continue;
        //
        // count the common groups seperately from the personal group.
        // Both have a maximum of CGROUPSMAX groups.
        //
        pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
        if (bCommonGroup && pGroup->fCommon ||
                             !bCommonGroup && !pGroup->fCommon) {
            cGroups++;
        }
    }

    // Compare with limit.
    if (cGroups >= CGROUPSMAX) {
        status = bCommonGroup ? IDS_TOOMANYCOMMONGROUPS : IDS_TOOMANYGROUPS;
        goto Exit;
    }

    if (bCommonGroup) {

        hkeyGroups = hkeyCommonGroups;
        pSecAttr = pAdminSecAttr;
        if (!hkeyGroups) {
            if (MyMessageBox(hwndProgman,
                             IDS_COMMONGROUPERR,
                             IDS_NOCOMMONGRPS,
                             pGroupName,
                             MB_OKCANCEL | MB_ICONEXCLAMATION | MB_TASKMODAL)
                       == IDOK) {

                hkeyGroups = hkeyProgramGroups;
                pSecAttr = pSecurityAttributes;
                bCommonGroup = FALSE;

            } else {
                return(NULL);
            }
        }

    } else {

        hkeyGroups = hkeyProgramGroups;
        pSecAttr = pSecurityAttributes;

    }

    if (!hkeyGroups) {
        status = IDS_NOGRPFILE;
        goto Exit;
    }

    //
    // Replace backslash in the group name because the registry does not
    // allow key names with backslash, bckslash is used to separate keys.
    //
    lstrcpy(szKeyName, pGroupName);
    RemoveBackslashFromKeyName(szKeyName);

    //
    // Test for existing key.
    //
    while (!RegOpenKeyEx(hkeyGroups, szKeyName, 0, KEY_READ, &hKey)) {
        /* a group with this name already exists */
        if (hwndT = IsGroupAlreadyLoaded(szKeyName, bCommonGroup)) {
            if (lstrlen(szKeyName) < MAXKEYLEN) {
                lstrcat(szKeyName, TEXT("."));
                GlobalUnlock(pGroup->hGroup);
                RegCloseKey(hKey);
                continue;
            }
        }
        RegCloseKey(hKey);
        goto LoadGroupFile;
    }

    wGroupNameLen = MyDwordAlign(sizeof(TCHAR)*(lstrlen(pGroupName) + 1));
    cb = sizeof(GROUPDEF) + (NSLOTS * sizeof(DWORD)) +  wGroupNameLen;

    /*
     * In CreateNewGroup before GlobalAlloc.
     */
    hT = GlobalAlloc(GHND, (DWORD)cb);
    if (!hT) {
        status = IDS_LOWMEM;
        goto Exit;
    }

    lpgd = (LPGROUPDEF)GlobalLock(hT);

    lpgd->dwMagic = GROUP_UNICODE;
    lpgd->cbGroup = (DWORD)cb;
    lpgd->nCmdShow = 0;            /* use MDI defaults  */
    lpgd->pName = sizeof(GROUPDEF) + NSLOTS * sizeof(DWORD);
    hdc = GetDC(NULL);
    lpgd->wIconFormat = (WORD)GetDeviceCaps(hdc, BITSPIXEL) + (WORD)256 *
            (WORD)GetDeviceCaps(hdc, PLANES);
    ReleaseDC(NULL, hdc);
    lpgd->cxIcon = (WORD)GetSystemMetrics(SM_CXICON);
    lpgd->cyIcon = (WORD)GetSystemMetrics(SM_CYICON);
    lpgd->Reserved1 = (WORD)-1;
    lpgd->Reserved2 = (DWORD)-1;

    lpgd->cItems = NSLOTS;

    for (i = 0; i < NSLOTS; i++) {
        lpgd->rgiItems[i] = 0;
    }

    lstrcpy((LPTSTR)((LPSTR)lpgd + sizeof(GROUPDEF) + NSLOTS * sizeof(DWORD)),
            pGroupName);

    /*
     * In CreateNewGroup before SizeofGroup.
     */
    cb = (int)SizeofGroup(lpgd);


    //
    // stop handling of Program Groups key changes when creating groups.
    //
    bHandleProgramGroupsEvent = FALSE;

    //
    // REARCHITECT: pSecurityAttributes might change for Common groups.
    //

    if (!RegCreateKeyEx(hkeyGroups, szKeyName, 0, 0, 0,
                     DELETE | KEY_READ | KEY_WRITE,
                     pSecAttr, &hKey, NULL)) {
        if (RegSetValueEx(hKey, NULL, 0, REG_BINARY, (LPBYTE)lpgd, cb))
            status = IDS_CANTWRITEGRP;
        RegCloseKey(hKey);
    }
    else
        status = IDS_NOGRPFILE;

    GlobalUnlock(hT);
    GlobalFree(hT);

Exit:
    if (status) {
        MyMessageBox(hwndProgman, IDS_GROUPFILEERR, (WORD)status, pGroupName,
                MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
        ResetProgramGroupsEvent(bCommonGroup);
	bHandleProgramGroupsEvent = TRUE;
        return NULL;
    }

LoadGroupFile:
    /*
     * The group file now exists on the disk... load it in!
     */
    fLowMemErrYet = FALSE;
    fErrorOnExtract = FALSE;
    hwnd = LoadGroupWindow(szKeyName, 0, bCommonGroup);

    if (fErrorOnExtract) {
        // On observed problem with icon extraction has been to do
        // with a low memory.
        MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXTRACT,
            NULL, MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
    }

    // Save the group section even if SaveSettings is off to stop
    // users from themselves.
    if (!bCommonGroup) {
        WriteGroupsSection();
    }
    ResetProgramGroupsEvent(bCommonGroup);
    bHandleProgramGroupsEvent = TRUE;
    return hwnd;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DeleteGroup() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FAR PASCAL DeleteGroup(HWND hwndGroup)
{
  PGROUP pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
  PGROUP *ppGroup;
  PITEM  pItem;
  TCHAR   szT[10];
  BOOL   bCommonGroup;
  HKEY   hkeyGroups;

  //
  // stop handling of Program Groups key changes when deleting groups.
  //
  bHandleProgramGroupsEvent = FALSE;

  bCommonGroup = pGroup->fCommon;
  if (bCommonGroup)
      hkeyGroups = hkeyCommonGroups;
  else
      hkeyGroups = hkeyProgramGroups;

  if (pGroup->fRO || RegDeleteKey(hkeyGroups, pGroup->lpKey) != ERROR_SUCCESS) {
      MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_ERRORDELETEGROUP,
                                                      pGroup->lpKey, MB_OK);
      //
      // reset handling of Program Groups key changes.
      //
      ResetProgramGroupsEvent(bCommonGroup);
      bHandleProgramGroupsEvent = TRUE;
      return;   // cannot delete the group
  }

  //
  // reset handling of Program Groups key changes.
  //
  ResetProgramGroupsEvent(bCommonGroup);
  bHandleProgramGroupsEvent = TRUE;

  /* Destroy the window, the global memory block, and the file. */
  SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndGroup, 0L);
  NukeIconBitmap(pGroup);
  GlobalFree(pGroup->hGroup);

  if (!bCommonGroup) {

      //
      // Remove the program manager's settings for that personal group.
      //

      wsprintf(szT,TEXT("Group%d"),pGroup->wIndex);
      RegDeleteValue(hkeyPMGroups, szT);
  }

  /* Unlink the group structure. */
  for (ppGroup=&pFirstGroup; *ppGroup && *ppGroup != pGroup; ppGroup = &(*ppGroup)->pNext)
      ;

  if (*ppGroup)
      *ppGroup = pGroup->pNext;

  if (pLastGroup == &pGroup->pNext)
      pLastGroup = ppGroup;

  /* Destroying the window should activate another one, but if it is the
   * last one, nothing will get activated, so to make sure punt the
   * current group pointer...
   */
  if (pCurrentGroup == pGroup)
      pCurrentGroup = NULL;

  /* Lastly, toss out the group and item structures. */
  while (pGroup->pItems) {
      pItem = pGroup->pItems;
      pGroup->pItems = pItem->pNext;
      LocalFree((HANDLE)pItem);
  }
  LocalFree((HANDLE)pGroup->lpKey);
  LocalFree((HANDLE)pGroup);

  if (!bCommonGroup) {

      //
      // Change the program manager's settings for that personal group.
      //

      WriteGroupsSection();
  }
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  ChangeGroupTitle() -                                                    */
/*                                                                          */
/*  Modifies the name of a program group, on the screen and in the file.    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FAR PASCAL ChangeGroupTitle(HWND hwndGroup, LPTSTR lpName, BOOL bCommonGroup)
{
  LPGROUPDEF lpgd;
  PGROUP pGroup;
  DWORD pName;
  TCHAR szCommonGroupSuffix[MAXKEYLEN];
  TCHAR szCommonGroupTitle[2*MAXKEYLEN];
  WINDOWPLACEMENT wp;

  if (!hwndGroup)
      return;

  //
  // Change the title of the window.
  //

  if (bCommonGroup) {

      //
      // Add the common group suffix to the name of the group e.g. (Common),
      // do not append the common suffix if the group window is minimized.
      //
      wp.length = sizeof(WINDOWPLACEMENT);
      GetWindowPlacement(hwndGroup, &wp);
      if (wp.showCmd == SW_MINIMIZE || wp.showCmd == SW_SHOWMINIMIZED ||
          wp.showCmd == SW_SHOWMINNOACTIVE) {
          SetWindowText(hwndGroup, lpName);
      }
      else {

          lstrcpy(szCommonGroupTitle, lpName);
          if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
                         CharSizeOf(szCommonGroupSuffix))) {
              lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
          }
          SetWindowText(hwndGroup, szCommonGroupTitle);
      }
  }
  else {
      SetWindowText(hwndGroup, lpName);
  }

  //
  // Remove the old name.
  //

  lpgd = LockGroup(hwndGroup);
  if (!lpgd)
      return;

  DeleteThing(lpgd, (LPDWORD)&lpgd->pName, 0);
  UnlockGroup(hwndGroup);

  //
  // Insert the new one.
  //

  pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);
  pName = AddThing(pGroup->hGroup, lpName ,(WORD)0);

  //
  // Set the new offset...
  //

  if (lpgd = LockGroup(hwndGroup)) {
      lpgd->pName = pName;
      UnlockGroup(hwndGroup);
  }

}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SetGroupDimensions() -                                                  */
/*                                                                          */
/*  Saves the size and position of the group file in the group segment, as  */
/*  as well as the positions of all the item icons                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID NEAR PASCAL SetGroupDimensions(HWND hwndGroup)
{
  LPGROUPDEF        lpgd;
  LPITEMDEF        lpid;
  PGROUP pGroup;
  PITEM pItem;
  WORD i;

  lpgd = LockGroup(hwndGroup);
  if (!lpgd)
      return;

  lpgd->nCmdShow = (WORD)GetInternalWindowPos(hwndGroup, &lpgd->rcNormal,
            &lpgd->ptMin);

  pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);
  NukeIconBitmap(pGroup);	// invalidate the bitmap

  for (pItem=pGroup->pItems; pItem; pItem=pItem->pNext) {
      lpid = ITEM(lpgd,pItem->iItem);
      lpid->pt.x = pItem->rcIcon.left;
      lpid->pt.y = pItem->rcIcon.top;

      /* save offset of ITEMDEF for each item
       */
      ChangeTagID(lpgd,pItem->iItem,(int)lpgd->rgiItems[pItem->iItem]);
      pItem->iItem = (int)lpgd->rgiItems[pItem->iItem];
  }

  for (i=0, pItem=pGroup->pItems; pItem; pItem=pItem->pNext, i++) {
      /* write offsets back out in Z order and update the index
       */
      ChangeTagID(lpgd,pItem->iItem,(int)i);
      lpgd->rgiItems[i] = (DWORD)pItem->iItem;
      pItem->iItem = (int)i;
  }

  /* Clear out remaining pointers to prevent duped item wierdness. */
  while (i < lpgd->cItems)
      lpgd->rgiItems[i++] = 0;

  UnlockGroup(hwndGroup);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  WriteGroupsSection() -                                                  */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void PASCAL WriteGroupsSection(VOID)
{
    PGROUP      pGroup;
    HCURSOR     hCursor;
    HWND        hwndGroup;
    LPGROUPDEF  lpgd;
    TCHAR        szT[66];
    TCHAR        szOrd[CGROUPSMAX*8+7];
    TCHAR szFmt[] = TEXT("Group%d");
    TCHAR szFmtCommonGrp[] = TEXT("GroupC%d");
    INT cGroups;
    TCHAR szGroupKey[MAXKEYLEN];
    INT i;
    RECT rc;
    POINT ptMin;
    TCHAR szCGrpInfo[MAXKEYLEN];
    INT cbValueName;

    hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
    ShowCursor(TRUE);

    if (!(hwndGroup = GetWindow(hwndMDIClient, GW_CHILD))) {
        goto WPIExit;
    }

    hwndGroup = GetWindow(hwndGroup, GW_HWNDLAST);

    szOrd[0] = 0;
    cGroups = 0;

    //
    // Clear user's previous positioning of common groups.
    //
    if (hkeyPMCommonGroups) {
        cbValueName = CharSizeOf(szGroupKey);
        while (!RegEnumValue(hkeyPMCommonGroups, 0, szGroupKey, &cbValueName, 0, 0,
                             0, 0)) {
            RegDeleteValue(hkeyPMCommonGroups, szGroupKey);
            cbValueName = CharSizeOf(szGroupKey);
        }
    }

    for (; hwndGroup; hwndGroup = GetWindow(hwndGroup, GW_HWNDPREV)) {
        /*
         * Check to make sure we're not out of room for the order string.
         */
        if (cGroups > CGROUPSMAX) {
            MessageBeep(0);
            break;
        }

        if (GetWindow(hwndGroup, GW_OWNER)) {
            continue;
        }

        pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);

        if (!pGroup->lpKey || !*pGroup->lpKey) {
            if (pGroup->lpKey) {
                LocalFree((HANDLE)pGroup->lpKey);
            }

            lpgd = LockGroup(hwndGroup);
            if (!lpgd) {
                continue;
            }

            lstrcpy(szGroupKey, (LPTSTR) PTR(lpgd, lpgd->pName));
            pGroup->lpKey = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(lstrlen(szGroupKey) + 1));
            lstrcpy(pGroup->lpKey, szGroupKey);
            UnlockGroup(hwndGroup);
        }

        if (pGroup->fCommon) {
            wsprintf(szT, szFmtCommonGrp, pGroup->wIndex);
            lstrcat(szOrd, TEXT(" C"));
            lstrcat(szOrd, szT + CCHCOMMONGROUP);
            if (hkeyPMCommonGroups) {
                i = GetInternalWindowPos(hwndGroup, &rc, &ptMin);

                if (i==SW_SHOWMINNOACTIVE)
                    i = SW_SHOWNORMAL;

                wsprintf(szCGrpInfo, TEXT("%d %d %d %d %d %d %d "),
                          rc.left, rc.top, rc.right, rc.bottom,
                          ptMin.x, ptMin.y, i);
                lstrcat(szCGrpInfo, pGroup->lpKey);
                RegSetValueEx(hkeyPMCommonGroups, szT, 0, REG_SZ, (LPBYTE)szCGrpInfo, sizeof(TCHAR)*(lstrlen(szCGrpInfo)+1));
            }
        }
        else {
            wsprintf(szT, szFmt, pGroup->wIndex);
            lstrcat(szOrd, TEXT(" "));
            lstrcat(szOrd, szT + CCHGROUP);
            if (hkeyPMGroups) {
                RegSetValueEx(hkeyPMGroups, szT, 0, REG_SZ, (LPBYTE)pGroup->lpKey, sizeof(TCHAR)*(lstrlen(pGroup->lpKey)+1));
            }
        }

        cGroups++;
    }

    if (hkeyPMSettings) {
        RegSetValueEx(hkeyPMSettings, szOrder, 0, REG_SZ, (LPBYTE)szOrd, sizeof(TCHAR)*(lstrlen(szOrd) + 1));
    }

WPIExit:
    ShowCursor(FALSE);
    SetCursor(hCursor);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SaveGroupsContent() -
/*
/*  Save the contents of the all the groups, doesn't save changes in
/*  size or position if bSaveGroupSettings is FALSE, only the group items.
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL SaveGroupsContent(BOOL bSaveGroupSettings)
{
    HWND hwndGroup;

    hwndGroup = GetWindow(hwndMDIClient, GW_CHILD);
    if (!hwndGroup)
        return FALSE;

    for (hwndGroup=GetWindow(hwndGroup, GW_HWNDLAST); hwndGroup; hwndGroup=GetWindow(hwndGroup, GW_HWNDPREV)) {
        if (GetWindow(hwndGroup, GW_OWNER))
            continue;

        /* Save the latest sizes and positions. */
        if (bSaveGroupSettings) {
            SetGroupDimensions(hwndGroup);
            if (wLockError == LOCK_LOWMEM && !fLowMemErrYet) {
                // No more error messages.
                fLowMemErrYet = TRUE;
                wLockError = 0;
                // Warn user that some settings couldn't be saved.
                MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXIT, NULL,
                     MB_OK | MB_ICONHAND | MB_SYSTEMMODAL);
            }
        }

        SaveGroup(hwndGroup, TRUE);
    }

    RegFlushKey(HKEY_CURRENT_USER);

    return(TRUE);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  WriteINIFile() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void FAR PASCAL WriteINIFile()
{
    register int  i;
    RECT          rc;
    TCHAR          szT[40];
    HANDLE        hCursor;

    //
    // Don't save if restricted. But force save if we've just converted the
    // ansi groups to unicode so we can work from unicode the next time around.
    //
    if (fNoSave && !bUseANSIGroups)
        return;

    fLowMemErrYet = FALSE;

    hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
    ShowCursor(TRUE);

    i = GetInternalWindowPos(hwndProgman, &rc, NULL);

    if (i==SW_SHOWMINNOACTIVE)
        i = SW_SHOWNORMAL;

    wsprintf(szT, TEXT("%d %d %d %d %d"), rc.left, rc.top, rc.right, rc.bottom, i);
    if (hkeyPMSettings) {
        RegSetValueEx(hkeyPMSettings, szWindow, 0, REG_SZ, (LPBYTE)szT, sizeof(TCHAR)*(lstrlen(szT)+ 1));
    }

    if (!bLoadEvil)
        WriteGroupsSection();
    //
    // Save all groups content, TRUE means we want the size and position saved
    // as well.
    //
    SaveGroupsContent(TRUE);

    ShowCursor(FALSE);
    SetCursor(hCursor);
}




/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetItemCommand() -                                                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void FAR PASCAL GetItemCommand(
    PGROUP pGroup,
    PITEM pItem,
    LPTSTR lpCommand,
    LPTSTR lpDir)
{
    BYTE b=0;
    LPTSTR lp1, lp2, lp3;
    LPGROUPDEF lpgd;
    LPITEMDEF lpid;
    BOOL bNoFirstQuote = TRUE;

    if (!GetGroupTag(pGroup,pItem,(WORD)ID_APPLICATIONDIR,lpCommand,MAXITEMPATHLEN)) {
        // the application directory is not defined
        *lpCommand = 0;
    }

    lpgd = LockGroup(pGroup->hwnd);
    if (!lpgd) {
        *lpCommand = 0;
        *lpDir = 0;
        return;
    }
    lpid = ITEM(lpgd,pItem->iItem);

    // init working directory
    lp3 = lpDir;
    *lp3 = 0;

    // item command
    lp1 = (LPTSTR) PTR(lpgd, lpid->pCommand);
    if (*lp1 == TEXT('"')) {
        lp2 = lp1;
        while (lp2 && (lp2 = wcschr(lp2+1, TEXT('"'))) && *(lp2+1) != TEXT('\\')) { //go to next quote
             ;
        }
        if (!lp2) {
            //
            // The directory is not in quotes and since the command path starts
            // with a quote, there's no working directory.
            //
            lp2 = lpDir;
	    *lp2 = 0;
        }
        else {
            if (*(lp2+1) == TEXT('\\')) {
                //
                // the working directory is in quotes
                //
                *lp3++ = *lp1++; //write first quote

                for (; *lp1 && lp1 != lp2; lp1 = CharNext(lp1)) {
                    *lp3++ = *lp1;
                }
                if (*lp1 == TEXT('"')) {
                   *lp3++ = *lp1++; //write last quote
                   lp1++;
                   *lp3 = 0;
                }
            }
            lp2 = lp3 + lstrlen(lp3);
	}
    }
    else {
        //
        // if there's a working directory, it is not in quotes
        //

        for (lp2 = lp3 = lpDir; *lp1 && *lp1 != TEXT(' ') && *lp1 != TEXT('"'); // the command line might be in quotes
                                               lp1 = CharNext(lp1)) {

            *lp3++ = *lp1;

            if (*lp1 == TEXT(':') || *lp1 == TEXT('\\'))
                lp2 = lp3;
        }
        *lp3 = 0;
    }

    /* we are assuming the exe dir contains the necessary separator
     * add the filename to the command line
     */
    lstrcat(lpCommand,lp2);
    /* add the arguments to the command line
     */
    lstrcat(lpCommand,lp1);


    /* truncate the command name from the exe path.  note this implies
     * that if there is no path, lpDir will be empty
     */
    *lp2 = 0;
    lp2 = CharPrev(lpDir,lp2);
    if (*lp2 == TEXT('\\') && *CharPrev(lpDir,lp2) != TEXT(':'))
        *lp2 = 0;

    UnlockGroup(pGroup->hwnd);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DuplicateItem() -                                                       */
/*                                                                          */
/*--------------------------------------------------------------------------*/

PITEM PASCAL DuplicateItem(
    PGROUP pGroup,
    PITEM pItem,
    PGROUP pGNew,
    LPPOINT lppt)
{
    WORD       wIconId;
    WORD       wIconIndex;
    LPITEMDEF  lpid;
    LPGROUPDEF lpgd;
    TCHAR       szCommand[MAXITEMPATHLEN + 1];
    TCHAR       szDefDir[2 * (MAXITEMPATHLEN + 1)];
    TCHAR       szIconPath[MAXITEMPATHLEN + 1];
    TCHAR       szName[64];
    TCHAR       szExpPath[MAXITEMPATHLEN+1];
    TCHAR       szExpDir[MAXITEMPATHLEN+1];
    DWORD       dwFlags = CI_ACTIVATE;

    lpid = LockItem(pGroup, pItem);
    if (lpid == 0L) {
        UnlockGroup(pGroup->hwnd);
        return NULL;
    }

    lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

    lstrcpy(szName, (LPTSTR) PTR(lpgd, lpid->pName));
    lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
    wIconId = lpid->iIcon;
    wIconIndex = lpid->wIconIndex;
    GlobalUnlock(pGroup->hGroup);
    UnlockGroup(pGroup->hwnd);

    GetItemCommand(pGroup, pItem, szCommand, szDefDir);

    //
    // I f there's no icon path, check if we have an executable associated
    // with the command path.
    //
    if (!*szIconPath) {
        lstrcpy(szExpPath, szCommand);
        DoEnvironmentSubst(szExpPath, CharSizeOf(szExpPath));
        StripArgs(szExpPath);
        lstrcpy(szExpDir, szDefDir);
        DoEnvironmentSubst(szExpDir, CharSizeOf(szExpDir));
        FindExecutable(szExpPath, szExpDir, szIconPath);
        if (!*szIconPath) {
            dwFlags |= CI_NO_ASSOCIATION;
        }
        else
            *szIconPath = 0;
    }
    if (GroupFlag(pGroup, pItem, (WORD)ID_NEWVDM)) {
        dwFlags |= CI_SEPARATE_VDM;
    }

    return CreateNewItem(pGNew->hwnd,
                         szName,
                         szCommand,
                         szIconPath,
                         szDefDir,
                         GroupFlag(pGroup, pItem, (WORD)ID_HOTKEY),
                         GroupFlag(pGroup, pItem, (WORD)ID_MINIMIZE),
                         wIconId,
                         wIconIndex,
                         NULL,
                         lppt,
                         dwFlags);
}