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

/****************************************************************************/
/*                                                                          */
/*  PMDDE.C -                                                               */
/*                                                                          */
/*        Windows Program Starter DDE Routines                              */
/*                                                                          */
/****************************************************************************/
#include "progman.h"
#include "dde.h"
#include "uniconv.h"

#define PMPrint(s)  KdPrint(("PROGMAN: ")); \
                         KdPrint(s);            \
                         KdPrint(("\n"));


//
// Define this if you want to know everything about Progman DDE
//

//#define VERBOSE_PROGMANDDE

#ifdef VERBOSE_PROGMANDDE
#define VerbosePrint(s) PMPrint(s)
#else
#define VerbosePrint(s)
#endif



/* DDE window classes */
TCHAR szProgmanDDE[] = TEXT("ProgmanDDE");
TCHAR szAppIconDDE[] = TEXT("AppIconDDE");
TCHAR szAppDescDDE[] = TEXT("AppDescDDE");
TCHAR szAppWDirDDE[] = TEXT("AppWDirDDE");
//
// For compatibility reasons, allow the old WIn3.1 Shell - AppProperties
// DDE connection.
//
TCHAR szAppProperties[] = TEXT("AppProperties");

BOOL bProgmanDDE = TRUE;
BOOL bAppIconDDE = TRUE;
BOOL bAppDescDDE = TRUE;
BOOL bAppWDirDDE = TRUE;

/* application names*/
TCHAR szShell[] = TEXT("Shell");

/* topics*/
TCHAR szAppIcon[] = TEXT("AppIcon");
TCHAR szAppDesc[] = TEXT("AppDescription");
TCHAR szAppWDir[] = TEXT("AppWorkingDir");
TCHAR szSystem[]  = TEXT("System");

/* items*/
TCHAR szGroupList[] = TEXT("Groups");

#define DDE_PROGMAN     0
#define APP_ICON        1
#define APP_DESC        2
#define APP_WDIR        3

#define WCHAR_QUOTE     L'"'

BOOL fForcePoint = FALSE;                /* used for replacement*/
POINT ptForce;

typedef struct _datadde
  {
    unsigned short unused:12,
             fResponse:1,
             fRelease:1,
             reserved:1,
             fAckReq:1;
    WORD  cfFormat;
  } DATADDE;

typedef struct _newicondata
  {
    DATADDE dd;
    DWORD dwResSize;
    DWORD dwVer;
    BYTE iResource;
  } NEWICONDATA;


int NEAR PASCAL myatoi(LPTSTR lp);
LPTSTR NEAR PASCAL SkipWhite(LPTSTR lpsz);
LPTSTR APIENTRY GetOneParameter(LPTSTR lpCmd, WPARAM *lpW, BOOL bSaveQuotes);
LPTSTR NEAR PASCAL GetCommandName(LPTSTR lpCmd, LPTSTR lpFormat, WPARAM *lpW);
HANDLE NEAR PASCAL GetDDECommands(LPTSTR lpCmd, LPTSTR lpFormat);

typedef struct _ddeconversation {
    HWND hwndClient;
    HWND hwndServer;
    DWORD dwType;
    struct _ddeconversation *Next;
} DDECONVERSATION, *PDDECONVERSATION;

PDDECONVERSATION pDdeConversation = NULL;
/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  InitDDEConverstionStruct() -                                            */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID InitDdeConversationStruct()
{
    pDdeConversation = (PDDECONVERSATION)LocalAlloc(LPTR, sizeof(DDECONVERSATION));
    pDdeConversation->Next = NULL;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AddDdeConverstion() -                                                   */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID AddDdeConversation(HWND hwndServer, HWND hwndClient, DWORD dwType)
{
    PDDECONVERSATION pT = NULL;

    if (!pDdeConversation) {
        return;
    }
    if (pT = (PDDECONVERSATION)LocalAlloc(LPTR, sizeof(DDECONVERSATION))) {
        pT->hwndServer = hwndServer;
        pT->hwndClient = hwndClient;
        pT->dwType = dwType;
        pT->Next = pDdeConversation->Next;
        pDdeConversation->Next = pT;
    }
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  RemoveDdeConverstion() -                                                */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID RemoveDdeConversation(HWND hwndServer, HWND hwndClient, DWORD dwType)
{
    PDDECONVERSATION pT;
    PDDECONVERSATION pFree;

    if (!pDdeConversation) {
        return;
    }
    for (pT = pDdeConversation; pT->Next; pT = pT->Next) {
        if ((pT->Next->hwndClient == hwndClient) &&
                      (pT->Next->hwndServer == hwndServer) &&
                      (pT->Next->dwType == dwType)) {
            pFree = pT->Next;
            pT->Next = pT->Next->Next;
            LocalFree(pFree);
            return;
        }
    }
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsDDEConverstion() -                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL IsDdeConversation(HWND hwndServer, HWND hwndClient, DWORD dwType)
{
    PDDECONVERSATION pT;

    if (!pDdeConversation) {
        return(FALSE);
    }
    for (pT = pDdeConversation; pT->Next; pT = pT->Next) {
        if ((pT->Next->hwndClient == hwndClient) &&
                      (pT->Next->hwndServer == hwndServer) &&
                      (pT->Next->dwType == dwType)) {
            return(TRUE);
        }
    }
    return(FALSE);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DDEFail() -                                                             */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID APIENTRY DDEFail(HWND hWnd, HWND hwndTo, ATOM aItem)
{
    MPostWM_DDE_ACK(hwndTo, hWnd, ACK_NEG, aItem);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SkipWhite() -                                                           */
/*                                                                          */
/* Returns a pointer to the first non-whitespace character in a string.     */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LPTSTR APIENTRY SkipWhite(LPTSTR lpsz)
{
  /* prevent sign extension */
  while (*lpsz && (TUCHAR)*lpsz <= (TUCHAR)TEXT(' '))
      lpsz++;

  return(lpsz);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetCommandName() -                                                      */
/*                                                                          */
/* Extracts an alphabetic string and looks it up in a list of possible
/* commands, returning a pointer to the character after the command and
/* sticking the command index somewhere.
/*
/* lpFormat string syntax:
/*     cmd\0cmd\0...\0\0
/*
/*--------------------------------------------------------------------------*/

LPTSTR APIENTRY GetCommandName(LPTSTR lpCmd, LPTSTR lpFormat, WPARAM *lpW)
{
  register TCHAR chT;
  register WORD iCmd = 0;
  LPTSTR         lpT;

  /* Eat any white space. */
  lpT = lpCmd = SkipWhite(lpCmd);

  /* Find the end of the token. */
  while (IsCharAlpha(*lpCmd))
      lpCmd++;

  /* Temporarily NULL terminate it. */
  chT = *lpCmd;
  *lpCmd = TEXT('\0');

  /* Look up the token in a list of commands. */
  *lpW = (DWORD_PTR)0xFFFF;
  while (*lpFormat) {
      if (!lstrcmpi(lpFormat, lpT)) {
          *lpW = iCmd;
          break;
      }
      iCmd++;
      while (*lpFormat++)
          ;
  }

  *lpCmd = chT;

  return(lpCmd);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  ValidateFileName() -                                                    */
/*                                                                          */
/*  Checks if the given filename really exists.  The filename passed        */
/*  in will have quotes around it, so this routine removes the quotes       */
/*  first.  Returns TRUE if it is a valid file.                             */
/*                                                                          */
/*--------------------------------------------------------------------------*/
BOOL APIENTRY ValidateFileName (LPTSTR lpFileName)
{
    TCHAR           chT;
    WORD            wLen;
    LPTSTR          lpEnd;
    BOOL            bResult = FALSE;
    HANDLE          hFile;
    WIN32_FIND_DATA fd;

    // Save the last character (better be a quote), and move
    // the terminating NULL one character forward.
    wLen = (WORD)lstrlen (lpFileName);
    lpEnd = lpFileName + wLen - 1;
    chT = *lpEnd;

    // MarkTa fix for spaces at the end of a filename
    // Remove the spaces by moving the quote forward.
    while (*(lpEnd-1) == TEXT(' '))
        lpEnd--;

    *lpEnd = TEXT('\0');

    // Test if this is a file.
    hFile = FindFirstFile(lpFileName+1, &fd);

    if (hFile != INVALID_HANDLE_VALUE)
       {
       FindClose (hFile);
       bResult = TRUE;
       }


    // Put back the character we removed eariler, and NULL terminate
    *lpEnd = chT;
    *(lpEnd+1) = TEXT('\0');

    return (bResult);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetOneParameter() -                                                     */
/*                                                                          */
/*  Reads a parameter out of a string removing leading and trailing whitespace.
/*  Terminated by , or ).  ] [ and ( are not allowed.  Exception: quoted
/*  strings are treated as a whole parameter and may contain []() and ,.
/*  Places the offset of the first character of the parameter into some place
/*  and NULL terminates the parameter.
/*
/*--------------------------------------------------------------------------*/

LPTSTR APIENTRY GetOneParameter(LPTSTR lpCmd, WPARAM *lpW, BOOL bSaveQuotes)
{
    LPTSTR          lpT;
    LPTSTR          lpTemp;
    TCHAR           chT;
    WORD            wLen;
    LPTSTR          lpEnd;

    switch (*lpCmd) {
    case TEXT(','):
        *lpW = (DWORD_PTR)lpCmd;
        *lpCmd++ = 0;                /* comma: becomes a NULL string */
        break;

    case TEXT('"'):                         /* quoted string... trim off " */

        VerbosePrint (("Quoted parameter before parsing: %S", lpCmd));
        VerbosePrint (("bSaveQuotes = %d", bSaveQuotes));

        if (bSaveQuotes)
           {
           // Set the beginning marker at the quote then increment.
           *lpW = (DWORD_PTR)lpCmd;
           ++lpCmd;
           }
        else
           {
           // Increment first to skip the quote
           ++lpCmd;
           *lpW = (DWORD_PTR)lpCmd;
           }

        while (*lpCmd && *lpCmd != TEXT('"'))
            lpCmd++;
        if (!*lpCmd)
            return(NULL);

        lpTemp = lpCmd;  // lpTemp should point at the quote
        lpCmd++;

        if (bSaveQuotes)
           {
           chT = *lpCmd;
           *lpCmd = TEXT('\0');

           VerbosePrint (("Checking %S to confirm that it really is a file.", *lpW));
           if (!ValidateFileName ((LPTSTR) *lpW))
              {
              // file doesn't exist.  Remove the quotes.
              VerbosePrint (("No, this isn't a file.  Removing the quotes."));
              *lpW = *lpW + sizeof (TCHAR);
              lpTemp = (LPTSTR)(*lpW) + lstrlen((LPTSTR) (*lpW)) - 1;
              *lpTemp = TEXT('\0');
              VerbosePrint (("New string after removing the quotes: %S", *lpW));
              }
            else
              {

              //
              // The quoted filename is valid, so now we want to test if
              // the quotes are really necessary.  To do this, remove
              // the quotes, and then call CheckEscapes to look for funny
              // characters.
              //

              VerbosePrint (("Yes, %S is a file.  Checking if we really need these quotes", *lpW));
              SheRemoveQuotes ((LPTSTR) *lpW);
              CheckEscapes ((LPTSTR) *lpW, lstrlen ((LPTSTR) *lpW) + 2);
              VerbosePrint (("After checking quotes we have %S", *lpW));
              }

           *lpCmd = chT;
           }
        else
           *lpTemp = TEXT(' ');


        while (*lpCmd && *lpCmd != TEXT(')') && *lpCmd != TEXT(','))
            lpCmd++;
        if (!*lpCmd)
            return(NULL);

        if (*lpCmd == TEXT(','))
           {
           *lpCmd = TEXT('\0');
           lpCmd++;
           }
        else
           *lpCmd = TEXT('\0');


        // Remove the space at the end of the string if the parser
        // added it.
        wLen = (WORD)lstrlen ((LPTSTR)(*lpW));
        lpEnd = (LPTSTR)(*lpW) + wLen - 1;
        if (*lpEnd == TEXT (' '))
           *lpEnd = TEXT('\0');

        VerbosePrint (("Quoted parameter after parsing: %S", *lpW));
        break;

    case TEXT(')'):
        return(lpCmd);                /* we ought not to hit this */

    case TEXT('('):
    case TEXT('['):
    case TEXT(']'):
        return(NULL);                 /* these are illegal */

    default:
        lpT = lpCmd;
        *lpW = (DWORD_PTR)lpT;

        while (*lpCmd && *lpCmd != TEXT(',') && *lpCmd != TEXT(')')) {
            /* Check for illegal characters. */
            if (*lpCmd == TEXT(']') || *lpCmd == TEXT('[') || *lpCmd == TEXT('(') )
                return(NULL);

            /* Remove trailing whitespace */
            /* prevent sign extension */
            if ((TUCHAR)*lpCmd > (TUCHAR)TEXT(' '))
                lpT = lpCmd;
            lpCmd = CharNext(lpCmd);
        }

        /* Eat any trailing comma. */
        if (*lpCmd == TEXT(','))
            lpCmd++;

        /* NULL terminator after last nonblank character -- may write over
         * terminating ')' but the caller checks for that because this is
         * a hack.
         */
        lpT = CharNext(lpT);
        *lpT = TEXT('\0');

        break;
    }

    /* Return next unused character. */
    return(lpCmd);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetDDECommands() -                                                      */
/*                                                                          */
/*  Called with: far pointer to a string to parse and a far pointer to a
/*  list of sz's containing the allowed function names.
/*  The function returns a global handle to an array of words containing
/*  one or more command definitions.  A command definition consists of
/*  a command index, a parameter count, and that number of offsets.  Each
/*  offset is an offset to a parameter in lpCmd which is now zero terminated.
/*  The list of command is terminated with -1.
/*  If there was a syntax error the return value is NULL.
/*  Caller must free block.
/*
/*--------------------------------------------------------------------------*/

HANDLE NEAR PASCAL GetDDECommands(LPTSTR lpCmd, LPTSTR lpFormat)
{
  register WORD     cParm;
  WORD              cCmd = 0;
  register HANDLE   hDDECmds;
  DWORD_PTR *       lpW = NULL;
  BOOL              bAddItem = FALSE;

  /* Will allow up to 128 words, 64 single command (less with parms). */
  /*
   * Now these are 32bit, since the offset is now replaced by the
   * full pointer which is 32 bit.
   *
   * (And if they are 64bit, they get even bigger.)
   */
  hDDECmds = GlobalAlloc(GHND, 128 * sizeof(DWORD_PTR));
  if (!hDDECmds)
      return(NULL);

  /* Get pointer to array. */
  lpW = (DWORD_PTR *)GlobalLock(hDDECmds);
  while (*lpCmd) {
      /* Skip leading whitespace. */
      lpCmd = SkipWhite(lpCmd);

      /* Are we at a NULL? */
      if (!*lpCmd) {
          /* Did we find any commands yet? */
          if (cCmd)
              goto GDEExit;
          else
              goto GDEErrExit;
      }

      /* Each command should be inside square brackets. */
      if (*lpCmd != TEXT('['))
          goto GDEErrExit;
      lpCmd++;

      /* Get the command name. */
      lpCmd = GetCommandName(lpCmd, lpFormat, lpW);
      if (*lpW == (DWORD_PTR)0xFFFF)
          goto GDEErrExit;

      if (*lpW == 1)
         bAddItem = TRUE;

      lpW++;

      /* Start with zero parms. */
      cParm = 0;
      lpCmd = SkipWhite(lpCmd);

      /* Check for opening '(' */
      if (*lpCmd == TEXT('(')) {
          lpCmd++;

          /* Skip white space and then find some parameters (may be none). */
          lpCmd = SkipWhite(lpCmd);

          while (*lpCmd != TEXT(')')) {
              if (!*lpCmd)
                  goto GDEErrExit;

              /* Get the parameter. */
              if (bAddItem && (cParm == 0 || cParm == 2 || cParm == 6))
                 {
                 // In this case, we are working with filenames of
                 // the command line, icon path, or default directory of
                 // the AddItem command.
                 // We don't want to strip the quotes if they exist.
                 if (!(lpCmd = GetOneParameter(lpCmd, lpW + (++cParm), TRUE)))
                     goto GDEErrExit;
                 }
              else
                 {
                 // This is for every other parameter.  The quotes will be
                 // stripped.
                 if (!(lpCmd = GetOneParameter(lpCmd, lpW + (++cParm), FALSE)))
                     goto GDEErrExit;
                 }

              /* HACK: Did GOP replace a ')' with a NULL? */
              if (!*lpCmd)
                  break;

              /* Find the next one or ')' */
              lpCmd = SkipWhite(lpCmd);
          }

          lpCmd++;

          /* Skip the terminating stuff. */
          lpCmd = SkipWhite(lpCmd);
      }

      /* Set the count of parameters and then skip the parameters. */
      *lpW++ = cParm;
      lpW += cParm;

      /* We found one more command. */
      cCmd++;

      /* Commands must be in square brackets. */
      if (*lpCmd != TEXT(']'))
          goto GDEErrExit;
      lpCmd++;
  }

GDEExit:
  /* Terminate the command list with -1. */
  *lpW = (DWORD_PTR)0xFFFF;

  GlobalUnlock(hDDECmds);
  return(hDDECmds);

GDEErrExit:
  GlobalUnlock(hDDECmds);
  GlobalFree(hDDECmds);
  return(NULL);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsParameterANumber() -                                                  */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL APIENTRY IsParameterANumber(LPTSTR lp)
{
  while (*lp) {
      if (*lp < TEXT('0') || *lp > TEXT('9'))
          return(FALSE);
      lp++;
  }
  return(TRUE);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  myatoi() -                                                              */
/*                                                                          */
/*--------------------------------------------------------------------------*/

int APIENTRY myatoi(LPTSTR lp)
{
  register int        i = 0;

  while (*lp >= TEXT('0') && *lp <= TEXT('9')) {
      i *= 10;
      i += (int)(*lp-TEXT('0'));
      lp++;
  }
  return(i);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  ExecuteHandler() -                                                      */
/*                                                                          */
/* Handles WM_DDE_EXECUTE messages...                                       */
/*                                                                          */
/*  return 0 if it fails                                                    */
/*         1 if it succeeds                                                 */
/*         2 if it succeeds and the command was ExitProgman                 */
/*                                                                          */
/*--------------------------------------------------------------------------*/

DWORD APIENTRY ExecuteHandler(HANDLE hString)
{
  register HWND     hwndT;
  LPTSTR             lpT;
  LPTSTR             lpString;
  register HANDLE   hCmd;
  DWORD_PTR *       lpwCmd;
  DWORD             dwRet = 0;
  PGROUP            pGroup;
  LPGROUPDEF        lpgd;
  WCHAR		    lpFmtinit[] = TEXT("CreateGroup#AddItem#DeleteGroup#ExitProgman#ShowGroup#DeleteItem#ReplaceItem#Reload#ChangeINIFile#");
  LPTSTR	    lpFmt ;

  lpFmt = lpFmtinit;
  /* Lock the command string. */
  lpString = (LPTSTR)GlobalLock(hString);
  if(!lpString)
      return(0);

  VerbosePrint(("Execute Handler received: %S", lpString));

#ifdef DEBUG_PROGMAN_DDE
  {
  TCHAR szDebug[300];

  wsprintf (szDebug, TEXT("%d   PROGMAN:   Execute Handler recived:  %s\r\n"),
            GetTickCount(), lpString);
  OutputDebugString(szDebug);
  }
#endif

  bInDDE = TRUE;

  /* Parse the commands. */

// the following line does not work on build 363! TEXT string is truncated
// after "CreateGroup".
  //hCmd = GetDDECommands(lpString, (LPTSTR)TEXT("CreateGroup\0AddItem\0DeleteGroup\0ExitProgman\0ShowGroup\0DeleteItem\0ReplaceItem\0Reload\0ChangeINIFile\0"));


  // substitute nulls for '#'
  while (*lpFmt) {
      if (*lpFmt == TEXT('#'))
	 *lpFmt = (TCHAR) 0;
      lpFmt++ ;
  }
  lpFmt = lpFmtinit; // reset the pointer back to the begining
  hCmd = GetDDECommands(lpString, lpFmt) ;
  if (!hCmd)
      goto DEHErrExit1;

  /* Lock the list of commands and parameter offsets. */
  lpwCmd = (DWORD_PTR *)GlobalLock(hCmd);

  /* Execute each command. */
  while (*lpwCmd != (DWORD_PTR)0xFFFF) {

      switch (*lpwCmd++) {
      case 0:
      {
          INT   cParm;
          INT   nCommonGrp = -1;
          LPTSTR lpCommonGrp = NULL;
          LPTSTR lpGroupName;


          /* [ CreateGroup ( groupname [, groupfile] [, common_group_flag] ) ] */
          /*
           * The groups are now in the registry thus no more group files
           * and therefore this is now replaced by
           *   [ CreateGroup ( groupname ) ]
           * The groupfile is specified is ignored. This will cause an error
           * for compatability reasons.
           */

          /*
           * A new optional parameter is added to specify whether to create
           * a Common group  or a Personal group.
           *     1 for Common Group
           *     0 for Personal Group
           * Only users with administrative rights can create/delete Common
           * groups. The default if this parameter is not specified is:
           *     Common group if user has admin rights
           *     Personal group if not
           */

          /* Make sure that we have 1, 2 or 3 parameters, ignore the 2nd one
           * if it represents a groupfile name.
           */
          cParm = (INT)*lpwCmd++;
          if ((cParm < 1) || (cParm > 3))
              goto DEHErrExit;

          /* Get a pointer to the group name. */
          lpT = (LPTSTR) *lpwCmd++;

          VerbosePrint (("CreateGroup received: %S", lpT));

          if (cParm == 3) {
              // skip group file parameter
              lpwCmd++;
          }


          if (cParm > 1) {
              //
              // Test if the 2nd parameter is a groupfile name or the
              // common group flag
              //

              if (IsParameterANumber((LPTSTR)*lpwCmd)) {

                  // get the common group flag
                  if ((nCommonGrp = myatoi((LPTSTR) *lpwCmd++)) &&
                                              !AccessToCommonGroups)
                      goto DEHErrExit;

              }
              else {
                  lpwCmd++;
              }
          }

          /* Search for the group... if it already exists, activate it. */
          hwndT = GetWindow(hwndMDIClient, GW_CHILD);
          while (hwndT) {
              /* Skip icon titles. */
              if (!GetWindow(hwndT, GW_OWNER)) {

                  /* Compare the group title with the request. */
                  pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
                  if (lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup)) {

                      lpGroupName = (LPTSTR) PTR(lpgd, lpgd->pName);
                      GlobalUnlock(pGroup->hGroup);
                      if (!lstrcmpi(lpT, lpGroupName)) {
                          BOOL bContinueSearch = TRUE;

                          //
                          // First case is the app didn't request
                          // a specific type of group.
                          //

                          if (nCommonGrp == -1) {

                              //
                              // If the user has access to
                              // common groups (thus also has
                              // access to personal groups), or
                              // the existing group is personal,
                              // then we are finished.
                              //

                              if (AccessToCommonGroups || !pGroup->fCommon) {
                                  bContinueSearch = FALSE;
                              }
                          }

                          //
                          // Second case the app requested
                          // a common group match.
                          //

                          else if (nCommonGrp == 1) {

                              //
                              // If user has access to the common groups
                              // and the group found is common, then we
                              // are finished.
                              //

                              if (AccessToCommonGroups && pGroup->fCommon) {
                                  bContinueSearch = FALSE;
                              }
                          }

                          //
                          // Third case is the app requested
                          // a personal group match.
                          //

                          else if (nCommonGrp == 0) {

                              //
                              // Check to see if the group is also
                              // personal.
                              //

                              if (!pGroup->fCommon) {
                                 bContinueSearch = FALSE;
                              }
                          }

                          if (bContinueSearch) {
                              hwndT = GetWindow(hwndT, GW_HWNDNEXT);
                              continue;
                          } else {

                              VerbosePrint (("CreateGroup: Activing group"));
                              BringWindowToTop(hwndT);
                              break;
                          }
                      }
                  }
              }
              hwndT = GetWindow(hwndT, GW_HWNDNEXT);
          }

          /* If we didn't find it, add it. */
          if (!hwndT) {
              TCHAR szTemp[MAXITEMPATHLEN+1];         // Group name.

              //
              // If the app does care what type of group to create,
              // the default is to create a common group if the
              // user has admin privilages.  Otherwise they get a
              // personal group.
              //

              if (nCommonGrp == -1) {

                  if (AccessToCommonGroups) {
                      nCommonGrp = 1;
                  } else {
                      nCommonGrp = 0;
                  }
              }

              lstrcpy(szTemp, lpT);
              VerbosePrint (("CreateGroup: Creating new group"));
              CreateNewGroup(szTemp, (nCommonGrp == 1));
          }

          break;
      }

      case 1:
      {
          INT      cParm;
          WORD      iIconIndex;
          POINT     pt;
          LPPOINT   lppt;
          DWORD     dwFlags = CI_SET_DOS_FULLSCRN;
          BOOL      fMinimize;
          WORD      wHotKey;
          TCHAR      szExpPath[MAXITEMPATHLEN+1];
          TCHAR      szExpDir[MAXITEMPATHLEN+1];
          HICON     hIcon;
    	  TCHAR     szT[MAX_PATH];
	      WORD      id;

          /* [ AddItem (command,name,icopath,index,pointx,pointy,
                            defdir,hotkey,fminimize) ] */
          //
          // pActiveGroup is non NULL when the user
          // has an item or group properties dialog up in
          // progman i.e. the user is working in progman
          // while some other app is doing DDE.
          // We can't have both play on the same group at
          // the same time.
          // johannec 5-13-93 bug 9513
          //
          if (pCurrentGroup == pActiveGroup) {
              PMPrint (("AddItem:  DDE converstation started with the group you have open! Exiting."));
              goto DEHErrExit;
          }

          /* There must be at least a command string. */
          if ((cParm = (INT)*lpwCmd++) < 1) {
              PMPrint (("AddItem:  No command string!"));
              goto DEHErrExit;
          }

          /* Make sure we have a reasonable number of parameters. */
          if (cParm == 5 || cParm > 10) {
              PMPrint (("AddItem:  Not enough or too many parameters!"));
              goto DEHErrExit;
          }

          /* If all else fails, there must be a command string! */
          lpT = (LPTSTR) *lpwCmd++;
          if (!*lpT) {
              PMPrint (("AddItem:  Null pointer for command string!"));
              goto DEHErrExit;
          }

          VerbosePrint (("AddItem:  szPathField = %S", lpT));
          lstrcpy(szPathField, lpT);
          lstrcpy(szExpPath, szPathField);
          DoEnvironmentSubst(szExpPath, CharSizeOf(szExpPath));

          VerbosePrint (("AddItem:  Expanded path = %S", szExpPath));

          StripArgs(szExpPath);

          VerbosePrint (("AddItem:  Path after StripArgs call = %S", szExpPath));

          if (*szExpPath != WCHAR_QUOTE)
            CheckEscapes(szExpPath, CharSizeOf(szExpPath));

          VerbosePrint (("AddItem:  Path after CheckEscapes call = %S", szExpPath));

          /* Look for the name field. */
          szNameField[0] = TEXT('\0');
          if (cParm > 1) {
              /* Get the next parameter. */
              lpT = (LPTSTR)*lpwCmd++;

              if (lstrlen (lpT) > MAXITEMNAMELEN)
                  lpT[MAXITEMNAMELEN] = TEXT('\0');

              lstrcpy(szNameField, lpT);
          }

          /* If none given, generate one from the command. */
          if (szNameField[0] == TEXT('\0')) {
              // NB Use the unexpanded path.
              BuildDescription(szNameField, szPathField);
          }

          VerbosePrint (("AddItem:  Name field will be: %S", szNameField));

          /* Look for the icon's path. */
          szIconPath[0] = TEXT('\0');
          if (cParm > 2) {
              lpT = (LPTSTR)*lpwCmd++;
              lstrcpy(szIconPath,lpT);

              VerbosePrint(("AddItem:  An icon path was given of: %S", szIconPath));
              StripArgs(szIconPath);
              // I am removing this call to CheckEscapes because
              // the filenames could now have quotes around them.
              // This call will automaticly add another set of quotes
              // thus causing the wrong icon to be displayed.
              // ericflo 2/25/94
              //CheckEscapes(szIconPath, CharSizeOf(szIconPath));
              VerbosePrint (("AddItem:  After stripping args the icon path = %S", szIconPath));
          }
          else
              szIconPath[0] = TEXT('\0');

          /* Get the icon index. */
          if (cParm > 3) {
              lpT = (LPTSTR)*lpwCmd++;
              iIconIndex = (WORD)myatoi(lpT);
          }
          else
              iIconIndex = 0;

          if (iIconIndex >= 666) {
              iIconIndex -= 666;
          }
	  else {
	      dwFlags |= CI_ACTIVATE;
	  }

          //
          // If there is no icon path, check if we have an executable associated
          // with the command path.
          //
	  if (!*szIconPath) {
    	      FindExecutable(szExpPath, szExpDir, szT);
    	      if (!*szT) {
        	  dwFlags |= CI_NO_ASSOCIATION;
    	      }
	  }
	  else {
    	      //
    	      // convert the icon index to the icon id which is what progman
    	      // uses.
    	      //
    	      lstrcpy(szT, szIconPath);
    	      id = iIconIndex;
    	      hIcon = ExtractAssociatedIcon(hAppInstance, szT, &id);
    	      if (lstrcmpi(szT, szIconPath)) {
        	  id = iIconIndex;
    	      }
	  }

          VerbosePrint (("AddItem:  Icon index = %d", id));

          /* Get the point :)  Note x cannot be specified alone. */
          if (cParm > 4) {
              lpT = (LPTSTR)*lpwCmd++;
              if (*lpT) {
                  pt.x = myatoi(lpT);
              }
              else {
                  pt.x = -1;
              }
              lpT = (LPTSTR)*lpwCmd++;
              if (*lpT) {
                  pt.y = myatoi(lpT);
              }
              else {
                  pt.x = -1;
              }
              lppt = (LPPOINT)&pt;
          }
          else
              lppt = (LPPOINT)NULL;

          if (fForcePoint) {
              lppt = &ptForce;
              fForcePoint = FALSE;
          }

          /* look to see if there is a default directory
           */
          if (cParm > 6) {
              lpT = (LPTSTR)*lpwCmd++;
              VerbosePrint (("AddItem:  Given this default direcotry: %S", lpT));
              lstrcpy(szDirField, lpT);
              lstrcpy(szExpDir, lpT);
              DoEnvironmentSubst(szExpDir, CharSizeOf(szExpDir));
              StripArgs(szExpDir);
              VerbosePrint(("AddItem:  After expanding and strip args, we have: %S", szExpDir));
          }
          else {
              szDirField[0] = TEXT('\0');
          }

          // If the directory is null then use the path bit
          // of the command line.  (Unexpanded)
          if (!*szDirField) {
              GetDirectoryFromPath(szPathField, szDirField);
              if (*szDirField) {
                 CheckEscapes (szDirField, MAXITEMPATHLEN+1);
              }
          }

          VerbosePrint (("AddItem:  Default directory is: %S", szDirField));

          /* hotkey
           */
          if (cParm > 7) {
              lpT = (LPTSTR)*lpwCmd++;
              wHotKey = (WORD)myatoi(lpT);
          }
          else
              wHotKey = 0;

          /* fminimize
           */
          if (cParm > 8) {
              lpT = (LPTSTR)*lpwCmd++;
              fMinimize = myatoi(lpT);
          }
          else
              fMinimize = FALSE;

          /* fseparateVDM
           */
          if (cParm > 9) {
              lpT = (LPTSTR)*lpwCmd++;
              if (myatoi(lpT)) {
                  dwFlags |= CI_SEPARATE_VDM;
                  VerbosePrint (("AddItem:  Separate VDM flag specified"));
              }
          }

          VerbosePrint (("AddItem: Results passed to CreateNewItem are:"));
          VerbosePrint (("         Name Field = %S", szNameField));
          VerbosePrint (("         Path Field = %S", szPathField));
          VerbosePrint (("         Icon Path  = %S", szIconPath));
          VerbosePrint (("         Dir Field  = %S", szDirField));
          VerbosePrint (("         Hot Key    = %d", wHotKey));
          VerbosePrint (("         Minimize   = %d", fMinimize));
          VerbosePrint (("         id         = %d", id));
          VerbosePrint (("         Icon Index = %d", iIconIndex));
          VerbosePrint (("         Flags      = %lx", dwFlags));


          /* Now add the new item!!! */
          if (!CreateNewItem(pCurrentGroup->hwnd,
                      szNameField, szPathField,
                      szIconPath, szDirField, wHotKey, fMinimize,
                      id, iIconIndex, NULL, lppt, dwFlags))
              goto DEHErrExit;

          // Update scrollbars.
          if ((bAutoArrange) && (!bAutoArranging))
              ArrangeItems(pCurrentGroup->hwnd);
          else if (!bAutoArranging)
              CalcGroupScrolls(pCurrentGroup->hwnd);

          break;
      }

      case 2:
      {
          int cParm;
          BOOL fCommonGrp = FALSE;
          BOOL fCommonDefaulted = FALSE;
          LPTSTR lpGroupName;
          HWND hwndPersGrp = NULL;

          /* [ DeleteGroup (group_name [, common_group_flag] ) ] */

          /*
           * A new optional parameter is added to specify whether to delete
           * a Common group  or a Personal group.
           *     1 for Common Group
           *     0 for Personal Group
           * Only users with administrative rights can create/delete Common
           * groups. The default if this parameter is not specified is:
           *     Common group if user has admin rights
           *     Personal group if not
           */

          /* Make sure that we have 1 or 2 parameter. */
          cParm = (int)*lpwCmd++;

          if ((cParm < 1) || (cParm > 2))
              goto DEHErrExit;

          /* Get a pointer to the group name. */
          lpT = (LPTSTR) *lpwCmd++;

          if (cParm == 2) {
              //
              // Get the common group flag. The User must have Write and
              // Delete access to the common groups.
              //
              if ((fCommonGrp = myatoi((LPTSTR) *lpwCmd++)) &&
                                              !AccessToCommonGroups)
                   goto DEHErrExit;
          }
          else if (AccessToCommonGroups) {
              //
              // The default for a user with Write access rights to the Common
              // Groups is deleting a common group.
              //
              fCommonGrp = TRUE;
              fCommonDefaulted = TRUE;
          }

          /* Search for the group... */
          hwndT = GetWindow(hwndMDIClient, GW_CHILD);
          while (hwndT) {
              /* Skip icon titles. */
              if (!GetWindow(hwndT, GW_OWNER)) {

                  /* Compare the group title with the request. */
                  pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
                  if (lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup)) {

                      lpGroupName = (LPTSTR) PTR(lpgd, lpgd->pName);
                      GlobalUnlock(pGroup->hGroup);
                      if (!lstrcmpi(lpT, lpGroupName)) {
                          if ((fCommonGrp && !pGroup->fCommon) ||
                              (!fCommonGrp && pGroup->fCommon) ) {

                              //
                              // If the app did not specify common nor personal
                              // group and we defaulted to common group (because
                              // the user is an admin), then don't ignore the
                              // personal group that was found. If no common group
                              // is found, we'll default to the personal group.
                              //  5-7-93 johannec bug ????
                              //
                              if (fCommonGrp && fCommonDefaulted) {
                                  hwndPersGrp = hwndT;
                              }

                              hwndT = GetWindow(hwndT, GW_HWNDNEXT);
                              continue;
                          }
                          //
                          // pActiveGroup is non NULL when the user
                          // has an item or group properties dialog up in
                          // progman i.e. the user is working in progman
                          // while some other app is doing DDE.
                          // We can't have both play on the same group at
                          // the same time.
                          // johannec 5-13-93 bug 9513
                          //
                          if (pGroup == pActiveGroup) {
                              goto DEHErrExit;
                          }
                          DeleteGroup(hwndT);
                          break;
                      }
                  }
              }
              hwndT = GetWindow(hwndT, GW_HWNDNEXT);
          }

          /* If we didn't find it, report the error. */
          if (!hwndT) {
              if (hwndPersGrp) {
                  //
                  // If a personal group was found instead of the common group
                  // delete it.
                  //

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

                  //
                  // pActiveGroup is non NULL when the user
                  // has an item or group properties dialog up in
                  // progman i.e. the user is working in progman
                  // while some other app is doing DDE.
                  // We can't have both play on the same group at
                  // the same time.
                  // johannec 5-13-93 bug 9513
                  //
                  if (pGroup == pActiveGroup) {
                      goto DEHErrExit;
                  }
                  DeleteGroup(hwndPersGrp);

              } else {
                  goto DEHErrExit;
              }
          }
          break;
      }

      case 3:
          /* [ ExitProgman (bSaveGroups) ] */

          if (bExitWindows)
              goto DEHErrExit;

          /* Make sure that we have 1 parameter. */
          if (*lpwCmd++ != 1)
              goto DEHErrExit;

          /* Get a pointer to the parm. */
          lpT = (LPTSTR) *lpwCmd++;

          bSaveSettings = FALSE;
          if (*lpT == TEXT('1'))
              WriteINIFile();

          //
          // The 2 is a magic return value inside of the
          // DDEMsgProc routine.
          //

          dwRet = 2;
          goto DEHErrExit;
          break;

      case 4:
      {
          INT cParm;
          int iShowCmd;
          BOOL fCommonGrp = FALSE;
          BOOL fCommonDefaulted = FALSE;
          HWND hwndPersGrp = NULL;
          TCHAR szT[MAXKEYLEN + 1];
          TCHAR szCommonGroupSuffix[MAXKEYLEN + 1];
          WINDOWPLACEMENT wp;

          /* [ ShowGroup (group_name, wShowParm [, fCommonGroup] ) ] */

          /*
           * A new optional parameter is added to specify whether to show
           * a Common group  or a Personal group.
           *     1 for Common Group
           *     0 for Personal Group
           * Only users with administrative rights can create/delete Common
           * groups. The default if this parameter is not specified is:
           *     Common group if user has admin rights
           *     Personal group if not
           */

          /* Make sure that we have 2 or 3 parameters. */
          cParm = (INT)*lpwCmd++;
          if ((cParm < 2) || (cParm > 3))
              goto DEHErrExit;

          /* Get a pointer to the group name. */
          lpT = (LPTSTR) *lpwCmd++;

          VerbosePrint (("ShowGroup:  Called with %S", lpT));

          iShowCmd = myatoi((LPTSTR) *lpwCmd++);

          if (cParm == 3) {
              //
              // get the common group flag
              //
              fCommonGrp = myatoi((LPTSTR) *lpwCmd++);
          }
          else if (AccessToCommonGroups) {
              //
              // The default for a user with administrative rights is Common
              // Groups.
              //
              fCommonGrp = TRUE;
              fCommonDefaulted = TRUE;
          }

          /* Search for the group... */
          hwndT = GetWindow(hwndMDIClient, GW_CHILD);
          while (hwndT) {
              //
              // Skip icon titles.
              //
              if (GetWindow(hwndT, GW_OWNER)) {
                   hwndT = GetWindow(hwndT, GW_HWNDNEXT);
                   continue;
              }

              /* Compare the group title with the request. */
              pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
              if (lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup)) {

                  lstrcpy(szT, (LPTSTR) PTR(lpgd, lpgd->pName));
                  GlobalUnlock(pGroup->hGroup);
                  if (!lstrcmpi(lpT, szT)) {

                      if ((fCommonGrp && !pGroup->fCommon) ||
                          (!fCommonGrp && pGroup->fCommon) ) {
                          //
                          // If the app did not specify common nor personal
                          // group and we defaulted to common group (because
                          // the user is an admin), then don't ignore the
                          // personal group that was found. If no common group
                          // is found, we'll default to the personal group.
                          //  5-7-93 johannec bug ????
                          //
                          if (fCommonGrp && fCommonDefaulted) {
                              hwndPersGrp = hwndT;
                          }

                          hwndT = GetWindow(hwndT, GW_HWNDNEXT);
                          continue;
                      }
                      ShowWindow(hwndT, iShowCmd);
                      //
                      // if the group is common and not being minimized
                      // then must add the common suffix to the group
                      // window title. If the group is being minimized
                      // then make sure the common suffix is not there.
                      //
                      if (fCommonGrp) {
                          wp.length = sizeof(WINDOWPLACEMENT);
                          GetWindowPlacement(hwndT, &wp);
                          if (wp.showCmd != SW_SHOWMINIMIZED &&
                              wp.showCmd != SW_MINIMIZE &&
                              wp.showCmd != SW_SHOWMINNOACTIVE ) {
                              LoadString(hAppInstance, IDS_COMMONGRPSUFFIX,
                                             szCommonGroupSuffix,
                                             CharSizeOf(szCommonGroupSuffix));
                              lstrcat(szT, szCommonGroupSuffix);
                          }
                          SetWindowText(hwndT, szT);
                      }
                      SendMessage(hwndT, WM_ACTIVATE, 1, 0);
                      break;
                  }
              }
              hwndT = GetWindow(hwndT, GW_HWNDNEXT);
          }

          /* If we didn't find it, report the error. */
          if (!hwndT) {
              if (hwndPersGrp) {
                  //
                  // If a personal group was found instead of the common group
                  // show it.
                  //
                  ShowWindow(hwndPersGrp, iShowCmd);
                  SendMessage(hwndPersGrp, WM_ACTIVATE, 1, 0);
              }
              else {
                  goto DEHErrExit;
              }
          }
          break;
      }
      case 6:

          /* [ ReplaceItem (item_name) ] */
          fForcePoint = TRUE;
          ptForce.x = -1;     // in case we don't really find the item
          ptForce.y = -1;

          /* fall thru */

      case 5:
      {
          PITEM pItem;
          LPITEMDEF lpid;

          /* [ DeleteItem (item_name) ] */

          //
          // pActiveGroup is non NULL when the user
          // has an item or group properties dialog up in
          // progman i.e. the user is working in progman
          // while some other app is doing DDE.
          // We can't have both play on the same group at
          // the same time.
          // johannec 5-13-93 bug 9513
          //
          if (pCurrentGroup == pActiveGroup) {
              goto DEHErrExit;
          }

          /* exactly one parameter
           */
          if (*lpwCmd++ != 1)
              goto DEHErrExit;

          lpT = (LPTSTR) *lpwCmd++;

          lpgd = LockGroup(pCurrentGroup->hwnd);
          if (!lpgd)
              goto DEHErrExit;

          for (pItem = pCurrentGroup->pItems; pItem; pItem = pItem->pNext) {
              lpid = ITEM(lpgd,pItem->iItem);
              if (!lstrcmpi((LPTSTR) PTR(lpgd, lpid->pName),lpT)) {
                  ptForce.x = pItem->rcIcon.left;
                  ptForce.y = pItem->rcIcon.top;
                  UnlockGroup(pCurrentGroup->hwnd);
                  DeleteItem(pCurrentGroup,pItem);
                  break;
              }
          }
          if (!pItem) {
              UnlockGroup(pCurrentGroup->hwnd);
              goto DEHErrExit;
          }

          break;
      }

      case 7:
      {
          int cParm;
          BOOL fAll;
          BOOL fCommonGrp = FALSE;

          /* [ Reload [(groupname [, common_group_flag] )] ] */

          /*
           * A new optional parameter is added to specify whether to reload
           * a Common group  or a Personal group.
           *     1 for Common Group
           *     0 for Personal Group
           * Only users with administrative rights can create/delete Common
           * groups. The default if this parameter is not specified is:
           *     Common group if user has admin rights
           *     Personal group if not
           */

          cParm = (int)*lpwCmd++;

          if (!cParm)
              fAll = TRUE;
          else if ((cParm == 1) || (cParm == 2))
              fAll = FALSE;
          else
              goto DEHErrExit;

          if (fAll) {
              HWND hwndT;

              ShowWindow(hwndMDIClient, SW_HIDE);
              ValidateRect(hwndProgman,NULL);

              /* unload all the groups!
               */
              for (hwndT = GetWindow(hwndMDIClient, GW_CHILD);
                   hwndT;
                   hwndT = GetWindow(hwndMDIClient, GW_CHILD)) {

                  /* Skip icon titles. */
                  while (GetWindow(hwndT, GW_OWNER)) {
                      hwndT = GetWindow(hwndT,GW_HWNDNEXT);
                      if (!hwndT)
                          break;
                  }

                  if (hwndT)
                      UnloadGroupWindow(hwndT);
              }

              LoadAllGroups();
              ShowWindow(hwndMDIClient,SW_SHOW);
          }
          else {
              TCHAR szT[120];
              WORD idGroup;
              HWND hwndT;

              /* get the name to reload
               */
              lpT = (LPTSTR) *lpwCmd++;

              if (cParm == 2) {
                  //
                  // Get the common group flag. The User must have Write
                  // access to the reload common groups.
                  //
                  if ((fCommonGrp = myatoi((LPTSTR) *lpwCmd++)) &&
                                              !AccessToCommonGroups)
                      goto DEHErrExit;
              }
              else if (AccessToCommonGroups) {
                  //
                  // The default for a user with administrative rights is Common
                  // Groups.
                  //
                  fCommonGrp = TRUE;
              }

              /* search for it
               */
              for (hwndT = GetWindow(hwndMDIClient, GW_CHILD);
                   hwndT;
                   hwndT = GetWindow(hwndT, GW_HWNDNEXT)) {

                  /* Skip icon titles. */
                  if (GetWindow(hwndT, GW_OWNER))
                      continue;

                  /* Compare the group title with the request. */
                  pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
                  if (lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup)) {

                      lstrcpy(szT, (LPTSTR) PTR(lpgd, lpgd->pName));
                      GlobalUnlock(pGroup->hGroup);

                      if (lstrcmpi(lpT, szT))
                          continue;

                      if ((fCommonGrp && !pGroup->fCommon) ||
                          (!fCommonGrp && pGroup->fCommon) )
                          continue;

                      /* we found the group.  Unload and reload it.
                       */
                      lstrcpy(szT,pGroup->lpKey);
                      idGroup = pGroup->wIndex;
                      UnloadGroupWindow(hwndT);
                      LoadGroupWindow(szT, idGroup, fCommonGrp);
                      break;
                  }
              }
              if (!hwndT)
                  goto DEHErrExit;
          }
          break;
      }

      default:
          goto DEHErrExit;
      }
  }

  /* 't all woiked! */
  dwRet = 1;

DEHErrExit:
  GlobalUnlock(hCmd);
  GlobalFree(hCmd);

DEHErrExit1:
  GlobalUnlock(hString);

  bInDDE = FALSE;

  return dwRet;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  InitRespond() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL APIENTRY InitRespond( HANDLE hWnd, WPARAM wParam, LPARAM lParam,
                           LPTSTR szApp, LPTSTR szTopic,
                           BOOL fBCReply       // Whether or not to reply to a broadcast message.
                                               // ie a null app string.
                           )
{
    HWND hwndDDE = NULL;
    ATOM atom1, atom2;
    DWORD dwType;

    atom1 = GlobalAddAtom(szApp);
    atom2 = GlobalAddAtom(szTopic);

    if ((!LOWORD(lParam) && fBCReply) || LOWORD(lParam) == atom1) {
        if (!HIWORD(lParam) || HIWORD(lParam) == atom2) {

            if (!lstrcmp(szApp, szProgman)) {  // use Progman's main hwnd
                dwType = DDE_PROGMAN;
                if (IsDdeConversation(hWnd, (HWND)wParam, DDE_PROGMAN)) {
                    MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
                    hwndDDE = CreateWindow(szProgmanDDE, NULL, WS_CHILD, 0, 0, 0, 0,
                                   hwndProgman, NULL, hAppInstance, NULL);
                }
                else {
                    // use Progman's hwnd for the first DDE conversation
                    hwndDDE = hWnd;
                }
            } else if (!lstrcmp(szApp, szShell)) {
                if (!lstrcmp(szTopic, szAppIcon)) {
                    if (IsDdeConversation(hWnd, (HWND)wParam, APP_ICON)) {
                        return(TRUE);
                    }
                    dwType = APP_ICON;
                    hwndDDE = CreateWindow(szAppIconDDE, NULL, WS_CHILD, 0, 0, 0, 0,
                                   hwndProgman, NULL, hAppInstance, NULL);
                }
                else if (!lstrcmp(szTopic, szAppDesc)) {
                    if (IsDdeConversation(hWnd, (HWND)wParam, APP_DESC)) {
                        return(TRUE);
                    }
                    dwType = APP_DESC;
                    hwndDDE = CreateWindow(szAppDescDDE, NULL, WS_CHILD, 0, 0, 0, 0,
                                   hwndProgman, NULL, hAppInstance, NULL);
                }
                else if (!lstrcmp(szTopic, szAppWDir)) {
                    if (IsDdeConversation(hWnd, (HWND)wParam, APP_WDIR)) {
                        return(TRUE);
                    }
                    dwType = APP_WDIR;
                    hwndDDE = CreateWindow(szAppWDirDDE, NULL, WS_CHILD, 0, 0, 0, 0,
                                   hwndProgman, NULL, hAppInstance, NULL);
                }
            }

            //
            // For compatibility reasons, allow Shell - AppProperties DDE
            // connection.
            //
            if (!lstrcmp(szApp, szShell) &&
                          !lstrcmp(szTopic, szAppProperties) ) {  // use Progman's main hwnd
                dwType = DDE_PROGMAN;
                if (IsDdeConversation(hWnd, (HWND)wParam, DDE_PROGMAN)) {
                    MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
                    hwndDDE = CreateWindow(szProgmanDDE, NULL, WS_CHILD, 0, 0, 0, 0,
                                   hwndProgman, NULL, hAppInstance, NULL);
                }
                else {
                    // use Progman's hwnd for the first DDE conversation
                    hwndDDE = hWnd;
                }
            }

            if (hwndDDE) {
                SendMessage((HWND)wParam, WM_DDE_ACK, (WPARAM)hwndDDE,
                                                 MAKELONG(atom1, atom2));
                AddDdeConversation(hwndDDE, (HWND)wParam, dwType);
                return(TRUE);
            }
        }
    }
    /*
     * No message sent or
     * Destination won't accept the ACK and so didn't delete
     * the atoms we provided - so we must do it.
     */
//    GlobalDeleteAtom(atom1);
//    GlobalDeleteAtom(atom2);
    return(FALSE);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GroupRequest() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID APIENTRY GroupRequest(HWND hWnd, HWND hwndClient, ATOM fmt, ATOM aItem)
{
    DWORD     cb;
    LPTSTR     lpT;
    register HANDLE   hT;
    register PGROUP   pGroup;
    HANDLE hReAlloc;
    LPGROUPDEF lpgd;

    if (fmt != CF_TEXT && fmt != CF_UNICODETEXT) {
        DDEFail(hWnd, hwndClient, aItem);
        return;
    }

    /*sizeof (WORD) ok, as hT becomes lpT which is LPSTR*/
    cb = 2 * sizeof(WORD) + 2;
    hT = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cb);
    if (!hT) {
        DDEFail(hWnd,hwndClient,aItem);
        return;
    }

    /* Ask the client to release the data and inform him that this
     * is in response to a request message.  Clipboard format is
     * plain text.
     */
    lpT = (LPTSTR)GlobalLock(hT);
    ((WORD FAR *)lpT)[0] = 3 << 12;
    ((WORD FAR *)lpT)[1] = CF_TEXT;
    ((WORD FAR *)lpT)[2] = 0;
    GlobalUnlock(hT);

    /* Go through the list of groups appending the name of each
     * group as a line in the shared memory item.
     */
    for (pGroup=pFirstGroup; pGroup; pGroup = pGroup->pNext) {
        lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);

        cb += sizeof(TCHAR) * (2 + lstrlen( (LPTSTR)PTR(lpgd, lpgd->pName) ));
        if (!(hReAlloc = GlobalReAlloc(hT, cb, GMEM_MOVEABLE))) {
            GlobalFree(hT);
            DDEFail(hWnd,hwndClient,aItem);
            return;
        }
        hT = hReAlloc;

        /*sizeof (WORD) ok, as hT becomes lpT which is LPSTR*/
        lpT = (LPTSTR)((LPSTR)GlobalLock(hT) + 2 * sizeof(WORD));
        lpT += lstrlen(lpT);
        /* we've already allocated it to be large enough...
         */
        //
        // The title may contain ' (Common)' at the end if the group is a
        // common group. So get the group title from the group itself not
        // from the window title.
        //
        lstrcpy(lpT, (LPTSTR)PTR(lpgd, lpgd->pName));
        lstrcat(lpT, TEXT("\r\n"));
        GlobalUnlock(pGroup->hGroup);
        GlobalUnlock(hT);
    }

    if (fmt == CF_TEXT) {
        LPSTR lpMultiByteStr = NULL;
        int cchMultiByte = 0;
        HANDLE hMultiByte;

        // convert the string to Ansi
        lpT = GlobalLock(hT) ;
        cchMultiByte = WideCharToMultiByte(CP_ACP, 0,
                    (LPTSTR)((LPBYTE)lpT+ 2*sizeof(WORD)), -1,
                    lpMultiByteStr, cchMultiByte, NULL, NULL);

        hMultiByte = GlobalAlloc(GMEM_MOVEABLE,(++cchMultiByte) + 2 * sizeof(WORD));
        lpMultiByteStr = GlobalLock(hMultiByte);

        ((WORD FAR *)lpMultiByteStr)[0] = 3 << 12;
        ((WORD FAR *)lpMultiByteStr)[1] = CF_TEXT;
        WideCharToMultiByte(CP_ACP, 0,
                            (LPTSTR)((LPBYTE)lpT+ 2*sizeof(WORD)), -1,
                             (LPSTR)(lpMultiByteStr + 2 * sizeof(WORD)),
                             cchMultiByte, NULL, NULL);

        GlobalUnlock(hMultiByte);
        GlobalUnlock(hT);
        GlobalFree(hT);
        hT = hMultiByte;

    }
    MPostWM_DDE_DATA(hwndClient, hWnd, hT, aItem);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FindIconProp() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

extern ULONG Color16Palette[];
extern ULONG Color256Palette[];

VOID APIENTRY FindIconProp(HWND hWnd, WPARAM wParam, LPARAM lParam, WORD iProp)
{
    PGROUP pGroup;
    PITEM pItem;
    LPGROUPDEF lpgd;
    LPITEMDEF lpid;
    UINT uiMsg = WM_DDE_ACK;
    HANDLE hData;
    DDEDATA FAR * lpdd;
    WORD cb;
    NEWICONDATA FAR * lpIconData;
    LPBYTE lpS;
    LPBYTE lpD;
    HWND hwndT;
    TCHAR szCommand[MAXITEMPATHLEN+1];
    TCHAR szDefDir[2 * (MAXITEMPATHLEN+1)];
    ATOM aItem;    // the app.'s id for which the info. is requested.
    TCHAR szId[16]; //to extract the id from the atom.
    DWORD dwId;
    PBITMAPINFOHEADER pbih, pbihNew;
    DWORD colors;
    LPVOID palette;

    if (fInExec) {
        /* we are inside the exec call!  it must have come from the
         * current icon!
         */
        pGroup = pCurrentGroup;
        pItem = pGroup->pItems;
        goto GotIt;
    }

    /* use the mdi window list to get the z-order */
    aItem = HIWORD(lParam);
    if (!GlobalGetAtomName(aItem, (LPTSTR)szId, 16))
        goto Fail;
    dwId = MyAtoi((LPTSTR)szId);
    if (!dwId) {
        goto Fail;
    }

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

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

        for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
            if (pItem->dwDDEId == dwId) {
                goto GotIt;
            }
        }
    }

Fail:
    /* didn't find it; fail
     */
    MPostDDEMsg((HWND)wParam, uiMsg, hWnd, (UINT)0, (UINT)aItem);
    return;

GotIt:
    /* from now on, we say use default instead of not me
     */
    uiMsg = WM_DDE_DATA;

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

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

    switch (iProp) {

    case APP_ICON:
        cb = (WORD)(sizeof(NEWICONDATA) + lpid->cbIconRes);
        pbih = (PBITMAPINFOHEADER)PTR(lpgd, lpid->pIconRes);
        if (pbih->biClrUsed == -1) {
            colors = (1 << (pbih ->biPlanes * pbih->biBitCount));
            if (colors == 16 || colors == 256) {
                cb += (WORD)(colors * sizeof(RGBQUAD));
            }
        }
        break;

    case APP_DESC:
        cb = (WORD)(sizeof(DDEDATA) + sizeof(TCHAR)*lstrlen((LPTSTR) PTR(lpgd, lpid->pName)));
        break;

    case APP_WDIR:
        GetItemCommand(pGroup, pItem, szCommand, szDefDir);
        cb = (WORD)(sizeof(DDEDATA) + sizeof(TCHAR)*lstrlen(szDefDir));
        break;

    default:
        goto Fail;
    }

    hData = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT,
            (DWORD)cb);
    if (!hData) {
        UnlockGroup(pGroup->hwnd);
        goto Fail;
    }

    lpdd = (DDEDATA FAR *)GlobalLock(hData);
    if (!lpdd) {
        GlobalFree(hData);
        UnlockGroup(pGroup->hwnd);
        goto Fail;
    }
    lpdd->fResponse = TRUE;
    lpdd->fRelease = TRUE;
    lpdd->cfFormat = CF_TEXT;

    switch (iProp) {
    case APP_ICON:
    	if ((short)lpid->cbIconRes <= 0) {
            // This icon is toast.
            GlobalUnlock(hData);
            UnlockGroup(pGroup->hwnd);
            goto Fail;
        }

        lpIconData = (NEWICONDATA FAR *)lpdd;

        lpIconData->dwResSize = (DWORD)lpid->cbIconRes;
        //lpIconData->dwVer = lpid->dwIconVer;
        lpIconData->dwVer = (lpid->wIconVer == 2) ? 0x00020000 : 0x00030000;

        lpD = (LPBYTE)&(lpIconData->iResource);
        lpS = (LPBYTE)PTR(lpgd, lpid->pIconRes);
        cb = lpid->cbIconRes;
        if ((pbih->biClrUsed == -1) && (colors == 16 || colors == 32)) {
            if (colors == 16) {
                palette = Color16Palette;
            } else if (colors == 256) {
                palette = Color256Palette;
            }

            pbihNew = (PBITMAPINFOHEADER)lpD;
            RtlCopyMemory(pbihNew, pbih, sizeof( *pbih ));
            pbihNew->biClrUsed = 0;
            RtlCopyMemory((pbihNew+1), palette, colors * sizeof(RGBQUAD));
            RtlCopyMemory((PCHAR)(pbihNew+1) + (colors * sizeof(RGBQUAD)),
                          (pbih+1),
                          lpid->cbIconRes - sizeof(*pbih)
                         );
        } else {
            while (cb--) {
                *lpD++ = *lpS++;
            }
        }

        break;

    case APP_DESC:
        lstrcpy((LPTSTR)lpdd->Value,(LPTSTR) PTR(lpgd, lpid->pName));
        break;

    case APP_WDIR:
        lstrcpy((LPTSTR)lpdd->Value,szDefDir);
        break;
    }

    GlobalUnlock(hData);
    UnlockGroup(pGroup->hwnd);

    if (!MPostWM_DDE_DATA((HWND)wParam, hWnd, hData, (ATOM)aItem)){
        GlobalFree(hData);
    }
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FindIconPath() -                                                        */
/*     In NT groups the icon path is not stored when it is not specified by */
/*     the user when the item is created. For DDE requests on groups, the   */
/*     icon path needs to be returned. This function will determine the     */
/*     icon path the way it first find the icon.                            */
/*  9/17/93 JOhannec
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID FindIconPath(
    LPTSTR szPathField,
    LPTSTR szDirField,
    LPTSTR szIconPath
    )
{
    TCHAR szIconExe[MAX_PATH];
    TCHAR szTemp[MAX_PATH];
    HICON hIcon;
    WORD wIconIndex;
    WORD wIconId;

    lstrcpy(szIconExe, szPathField);
    DoEnvironmentSubst(szIconExe, CharSizeOf(szIconExe));
    StripArgs(szIconExe);
    TagExtension(szIconExe, sizeof(szIconExe));
    if (*szIconExe == TEXT('"') && *(szIconExe + lstrlen(szIconExe)-1) == TEXT('"')) {
        SheRemoveQuotes(szIconExe);
    }

        //
        // if it's a relative path, extractassociatedicon and LoadLibrary don't
        // handle that so find the executable first
        //
        SetCurrentDirectory(szOriginalDirectory);
        FindExecutable(szIconExe, szDirField, 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);

        wIconIndex = 0;
        hIcon = ExtractAssociatedIconEx(hAppInstance, szIconExe, &wIconIndex, &wIconId);
        if (hIcon)
            DestroyIcon(hIcon);

        lstrcpy(szIconPath, szIconExe);
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AddStringToSeg() -                                                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/
BOOL APIENTRY AddStringToSeg(LPHANDLE lphT, LPINT lpcb, LPTSTR lpsz, WORD wT, BOOL fCR)
{
    TCHAR szT[10];
    INT cb;
    LPTSTR lp;
    HANDLE hReAlloc;

    if (!lpsz) {
        wsprintf(szT,TEXT("%d"),wT);
        lpsz = szT;
        wT = (WORD)0;
    }

    cb = sizeof(TCHAR) * (lstrlen(lpsz) + (wT ? 2 : 0) + (fCR ? 2 : 1));
    if (!(hReAlloc = GlobalReAlloc(*lphT,*lpcb+cb,GMEM_MOVEABLE|GMEM_ZEROINIT))) {
        GlobalFree(*lphT);
        return FALSE;
    }
    else {
        *lphT = hReAlloc;
    }

    lp = (LPTSTR)((LPSTR)GlobalLock(*lphT) + *lpcb - 2);   // this is to go before the null byte
    if (wT)
        *lp++ = TEXT('"');

    lstrcpy(lp,lpsz);
    lp += lstrlen(lp);
    if (wT)
        *lp++ = TEXT('"');

    if (fCR) {
        *lp++ = TEXT('\r');
        *lp++ = TEXT('\n');
    }
    else
        *lp++ = TEXT(',');
    *lp = 0;
    GlobalUnlock(*lphT);

    *lpcb += cb;

    return TRUE;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DumpGroup() -                                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/
VOID APIENTRY DumpGroup(HWND hwnd, ATOM aName, HWND hwndConv, WORD cfFormat)
{
    HWND hwndGroup;
    PGROUP pGroup;
    PITEM pItem;
    LPGROUPDEF lpgd;
    LPITEMDEF lpid;
    WORD i;
    INT cb;
    HANDLE hT;
    LPTSTR lpT;
    INT state;
    BOOL fActivated;

    if (cfFormat != CF_TEXT && cfFormat != CF_UNICODETEXT)
        goto Fail;

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

        lpgd = LockGroup(hwndGroup);
        if (!lpgd)
            goto Fail;

        if (aName == GlobalFindAtom((LPTSTR) PTR(lpgd, lpgd->pName)))
            goto FoundGroup;
        UnlockGroup(hwndGroup);
    }

Fail:
#ifdef ORGCODE
    DDEFail(hwnd,hwndConv,MAKELONG(cfFormat,aName));
#else
    DDEFail(hwnd, hwndConv, aName);
#endif
    return;

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

        /*sizeof (WORD) ok, as hT becomes lpT which is LPSTR*/
    cb = 2 * sizeof(WORD) + 2;
    hT = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cb);
    if (!hT)
        goto Fail;

    /* Ask the client to release the data and inform him that this
     * is in response to a request message.  Clipboard format is
     * plain text.
     */
    lpT = (LPTSTR)GlobalLock(hT);
    ((WORD FAR *)lpT)[0] = 3 << 12;
    ((WORD FAR *)lpT)[1] = CF_TEXT;
    ((WORD FAR *)lpT)[2] = 0;
    GlobalUnlock(hT);

    /* the first line is group properties
     */
    if (!AddStringToSeg(&hT,&cb,(LPTSTR) PTR(lpgd, lpgd->pName),TRUE,FALSE))
        goto Fail;

#if 1
// don't allow apps to know the group key.

//
// change 2-21-93 johannec
// for compatibilty reasons we must privide the group filename which
// doesn't mean anything in NT so we provide the key name instad.
    if (!AddStringToSeg(&hT,&cb,pGroup->lpKey, FALSE, FALSE))
        goto Fail;
#endif

    /* put the number of items in
     */
    for (i = 0, pItem = pGroup->pItems; pItem; pItem = pItem->pNext)
        i++;

#if 1
    if (!AddStringToSeg(&hT,&cb,NULL,i,FALSE))
    	goto Fail;

    // Return the window state as a SW_ value.
    // REVIEW not all SW_ values are supported.
    // It would be nice if there was some way to query a SW_ value
    // but I guess it would too much to ask for windows to be even remotely
    // orthogonal.  I don't know who "designed" the Windows API but it
    // really is the worst windowing system I have ever used.
    // Luckily orthogonality doesn't affect stock prices :-)
    state = SW_SHOWNORMAL;

    if (pGroup == pCurrentGroup) {
        fActivated = TRUE;
    }
    else {
        fActivated = FALSE;
    }

    if (IsZoomed(hwndGroup)) {
        // Maxed.
        state = SW_SHOWMAXIMIZED;
    }
    else if (IsIconic(hwndGroup)) {
        // Minned.
        if(fActivated)
            state = SW_SHOWMINIMIZED;
        else
            state = SW_SHOWMINNOACTIVE;
    }
    else {
        // It's normal.
        if(fActivated)
            state = SW_SHOWNORMAL;
        else
            state = SW_SHOWNOACTIVATE;
    }

    // Give info on the state.
    if (!AddStringToSeg(&hT,&cb,NULL,(WORD)state, FALSE))
    	goto Fail;
#else
    if (!AddStringToSeg(&hT,&cb,NULL,i,FALSE))
	    goto Fail;
#endif

    if (!AddStringToSeg(&hT,&cb,NULL,(WORD)pGroup->fCommon,TRUE))
        goto Fail;


    /* each additional line is an item
     */
    for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {

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

        /* name
         */
        if (!AddStringToSeg(&hT, &cb, (LPTSTR) PTR(lpgd, lpid->pName), TRUE, FALSE))
            goto Fail;

        /* command line and default directory
         */
        GetItemCommand(pGroup, pItem, szPathField, szDirField);
        if (!AddStringToSeg(&hT, &cb, szPathField, TRUE, FALSE))
            goto Fail;
        if (!AddStringToSeg(&hT, &cb, szDirField, FALSE, FALSE))
            goto Fail;

        /* icon path
         */
        if (!*(LPTSTR)PTR(lpgd, lpid->pIconPath)) {
            FindIconPath(szPathField, szDirField, szIconPath);
        }
        else {
            lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
        }
        if (!AddStringToSeg(&hT, &cb, szIconPath, FALSE, FALSE))
            goto Fail;

        /* x-y coordinates
         */
        if (!AddStringToSeg(&hT, &cb, NULL, (WORD)pItem->rcIcon.left, FALSE))
            goto Fail;

        if (!AddStringToSeg(&hT, &cb, NULL, (WORD)pItem->rcIcon.top, FALSE))
            goto Fail;

        /* icon, hotkey, fminimize
         */
        if ((SHORT)lpid->wIconIndex >= 0) {
            //
            // apps requesting group info are expecting icon index not icon id.
            //
            if (!AddStringToSeg(&hT, &cb, NULL, lpid->wIconIndex,FALSE))
                goto Fail;
        }
        else {
            if (!AddStringToSeg(&hT, &cb, NULL, lpid->iIcon, FALSE))
                goto Fail;
        }

        if (!AddStringToSeg(&hT,&cb,NULL,GroupFlag(pGroup,pItem,(WORD)ID_HOTKEY),FALSE))
            goto Fail;

        if (!AddStringToSeg(&hT,&cb,NULL,GroupFlag(pGroup,pItem,(WORD)ID_MINIMIZE),FALSE))
            goto Fail;

        if (!AddStringToSeg(&hT,&cb,NULL,GroupFlag(pGroup,pItem,(WORD)ID_NEWVDM),TRUE))
            goto Fail;
    }

#ifdef ORGCODE
    PostMessage(hwndConv, WM_DDE_DATA, hwnd, MAKELONG(hT,cfFormat));
#else
    if (cfFormat == CF_TEXT) {
        LPSTR lpMultiByteStr = NULL;
        int cchMultiByte = 0;
        HANDLE hMultiByte;

	    // convert the string to Ansi
        lpT = GlobalLock(hT) ;
        cchMultiByte = WideCharToMultiByte(CP_ACP, 0,
                    (LPTSTR)((LPBYTE)lpT+ 2*sizeof(WORD)), -1,
                    lpMultiByteStr, cchMultiByte, NULL, NULL);

        hMultiByte = GlobalAlloc(GMEM_MOVEABLE,(++cchMultiByte) + 2 * sizeof(WORD));
        lpMultiByteStr = GlobalLock(hMultiByte);

        ((WORD FAR *)lpMultiByteStr)[0] = 3 << 12;
        ((WORD FAR *)lpMultiByteStr)[1] = CF_TEXT;
        WideCharToMultiByte(CP_ACP, 0,
                            (LPTSTR)((LPBYTE)lpT+ 2*sizeof(WORD)), -1,
                             (LPSTR)(lpMultiByteStr + 2 * sizeof(WORD)),
                             cchMultiByte, NULL, NULL);

	    GlobalUnlock(hMultiByte);
        GlobalUnlock(hT);
        GlobalFree(hT);
        hT = hMultiByte;


    }
    MPostWM_DDE_DATA(hwndConv, hwnd, hT, (ATOM)aName);
#endif

}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DDEMsgProc() -                                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LRESULT APIENTRY DDEMsgProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
    switch (wMsg) {
    // should go in ProgmanWndProc
    case WM_DDE_INITIATE:
        //
        // HACK: returning 1 if the WM_DDE_ACK was sent successfully in
        // InitRespond is NOT part of the DDE Protocol BUT for backward
        // compatability with WIndows3.0 and 3.1 this solves
        // some problems with WOW apps' setup.
        //

#ifdef DEBUG_PROGMAN_DDE
        {
        TCHAR szDebug[300];

        wsprintf (szDebug, TEXT("%d   PROGMAN:   Received WM_DDE_INITIATE\r\n"),
                  GetTickCount());
        OutputDebugString(szDebug);
        }
#endif

        if (InitRespond(hWnd,wParam,lParam,szShell,szAppIcon, TRUE))
            return(1L);
        if (InitRespond(hWnd,wParam,lParam,szShell,szAppDesc, TRUE))
            return(1L);
        if (InitRespond(hWnd,wParam,lParam,szShell,szAppWDir, TRUE))
            return(1L);
//      InitRespond(hWnd,wParam,lParam,szShell,szSystem, TRUE);
        if (InitRespond(hWnd,wParam,lParam,szProgman,szProgman, FALSE)) {
#ifdef DEBUG_PROGMAN_DDE
            {
            TCHAR szDebug[300];

            wsprintf (szDebug, TEXT("%d   PROGMAN:   Received WM_DDE_INITIATE.  return 1\r\n"),
                      GetTickCount());
            OutputDebugString(szDebug);
            }
#endif
            return(1L);
        }
        //
        // For compatibility reasons, allow Shell - AppProperties DDE
        // connection
        //
        if (InitRespond(hWnd,wParam,lParam,szShell,szAppProperties, TRUE))
            return(1L);

#ifdef DEBUG_PROGMAN_DDE
        {
        TCHAR szDebug[300];

        wsprintf (szDebug, TEXT("%d   PROGMAN:   Received WM_DDE_INITIATE.  FAILED\r\n"),
                  GetTickCount());
        OutputDebugString(szDebug);
        }
#endif
        break;

    case WM_DDE_REQUEST:
    {
        ATOM fmt;
        ATOM aItem;

        fmt = GET_WM_DDE_REQUEST_FORMAT(wParam, lParam);
        aItem = GET_WM_DDE_REQUEST_ITEM(wParam, lParam);
        if (aItem == GlobalFindAtom(szProgman)
            || aItem == GlobalFindAtom(szGroupList)) {
            GroupRequest(hWnd, (HWND)wParam, fmt, aItem);
        }
        else
            DumpGroup(hWnd, aItem, (HWND)wParam, fmt);
        DDEFREE(WM_DDE_REQUEST, lParam);
        break;
    }

    case WM_DDE_EXECUTE:
    {
        HANDLE hCommands;
        WORD wStatus;
        DWORD ret;
    LPSTR lpCommands ;
    HLOCAL hloc ;
    HLOCAL hlocTemp ;
    int cchMultiByte ;
    LPWSTR lpWideCharStr = NULL ;
    int cchWideChar = 0  ;
    BOOL bIsWindowUnicode ;
        UnpackDDElParam(WM_DDE_EXECUTE, lParam, NULL, (PUINT_PTR)&hCommands);

	// was the sending window a unicode app?
        bIsWindowUnicode=IsWindowUnicode((HWND)wParam) ;
	if (!bIsWindowUnicode) {
	    // convert the string to unicode
            lpCommands = GlobalLock(hCommands) ;
            cchMultiByte=MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,lpCommands,
                    -1,lpWideCharStr,cchWideChar) ;

            hloc = GlobalAlloc(GMEM_MOVEABLE,(++cchMultiByte)*sizeof(TCHAR)) ;
            lpWideCharStr = GlobalLock(hloc) ;

            MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,lpCommands,
                            -1,lpWideCharStr,cchMultiByte) ;

	    GlobalUnlock(hloc) ;
            GlobalUnlock(hCommands) ;
            hlocTemp  = hCommands;
            hCommands = hloc ;
	}

        if (ret = ExecuteHandler(hCommands)) {
            wStatus = 0x8000;
        } else {
            wStatus = 0x0000;
        }
	if (!bIsWindowUnicode) {
            hCommands = hlocTemp;
	    GlobalFree(hloc) ;
        }

        MPostWM_DDE_EXECACK((HWND)wParam, hWnd, wStatus, hCommands);
        if (ret == 2) {         // Exit command was executed
            MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
            PostMessage(hwndProgman, WM_CLOSE, 0, 0L);
        }
//      DDEFREE(WM_DDE_EXECUTE, lParam);    // executes arn't really packed.
        break;
    }

    case WM_DDE_TERMINATE:
#ifdef ORGCODE
        SendMessage(wParam, WM_DDE_TERMINATE, (WPARAM)hWnd, lParam);
#else
        RemoveDdeConversation(hWnd, (HWND)wParam, DDE_PROGMAN);
        MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
//      DDEFREE(WM_DDE_TERMINATE, lParam);  // terminates arn't packed
#endif
        if (hWnd != hwndProgman) {
            DestroyWindow (hWnd);
        }
        break;

    case WM_DDE_ACK:
        DDEFREE(WM_DDE_ACK, lParam);
        break;

    /* All other DDE messages are unsupported. */
    case WM_DDE_DATA:
    case WM_DDE_ADVISE:
    case WM_DDE_UNADVISE:
    case WM_DDE_POKE:
#ifdef ORGCODE
        DDEFail(hWnd,wParam,lParam);
#else
        {
            UINT_PTR uiHi;

            UnpackDDElParam(wMsg, lParam, NULL, &uiHi);
            DDEFail(hWnd, (HWND)wParam, (ATOM)uiHi);
            DDEFREE(wMsg, lParam);
        }
#endif
        break;

    default:
        return DefWindowProc(hWnd,wMsg,wParam,lParam);
    }
    return(0L);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AppIconDDEMsgProc() -                                                   */
/*                                                                          */
/*        Application = "Shell"                                             */
/*        Topic = "AppIcon"                                                 */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LRESULT APIENTRY AppIconDDEMsgProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
    switch (wMsg) {
    case WM_DDE_REQUEST:
        FindIconProp(hWnd, wParam, lParam, APP_ICON);
        DDEFREE(WM_DDE_REQUEST, lParam);
        break;

    case WM_DDE_TERMINATE:
        RemoveDdeConversation(hWnd, (HWND)wParam, APP_ICON);
        MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
        DDEFREE(WM_DDE_TERMINATE, lParam);
        DestroyWindow(hWnd);
        break;

    default:
        return DDEMsgProc(hWnd, wMsg, wParam, lParam);
    }
    return 0L;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AppDescriptionDDEMsgProc() -                                            */
/*                                                                          */
/*        Application = "Shell"                                             */
/*        Topic = "AppDescription"                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LRESULT APIENTRY AppDescriptionDDEMsgProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
    switch (wMsg) {
    case WM_DDE_REQUEST:
        FindIconProp(hWnd, wParam, lParam, APP_DESC);
        DDEFREE(WM_DDE_REQUEST, lParam);
        break;

    case WM_DDE_TERMINATE:
        RemoveDdeConversation(hWnd, (HWND)wParam, APP_DESC);
        PostMessage((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hWnd, 0L);
        DestroyWindow(hWnd);
        break;

    default:
        return DDEMsgProc(hWnd, wMsg, wParam, lParam);
    }
    return 0L;
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  AppWorkingDirDDEMsgProc() -                                             */
/*                                                                          */
/*        Application = "Shell"                                             */
/*        Topic = "AppWorkingDir"                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/

LRESULT APIENTRY AppWorkingDirDDEMsgProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
    switch (wMsg) {
    case WM_DDE_REQUEST:
        FindIconProp(hWnd, wParam, lParam, APP_WDIR);
        DDEFREE(WM_DDE_REQUEST, lParam);
        break;

    case WM_DDE_TERMINATE:
        RemoveDdeConversation(hWnd, (HWND)wParam, APP_WDIR);
        MPostWM_DDE_TERMINATE((HWND)wParam, hWnd);
        DDEFREE(WM_DDE_TERMINATE, lParam);
        DestroyWindow(hWnd);
        break;

    default:
        return DDEMsgProc(hWnd, wMsg, wParam, lParam);
    }
    return 0L;
}


VOID APIENTRY RegisterDDEClasses(HANDLE hInstance)
{
    WNDCLASS wc;

    wc.style = 0;
    wc.lpfnWndProc = AppIconDDEMsgProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = NULL;
    wc.hCursor = NULL;
    wc.hbrBackground = NULL;
    wc.lpszMenuName = NULL;
    wc.lpszClassName = szAppIconDDE;

    if (!RegisterClass(&wc))
        bAppIconDDE = FALSE;

    wc.lpfnWndProc = AppDescriptionDDEMsgProc;
    wc.lpszClassName = szAppDescDDE;

    if (!RegisterClass(&wc))
        bAppDescDDE = FALSE;

    wc.lpfnWndProc = AppWorkingDirDDEMsgProc;
    wc.lpszClassName = szAppWDirDDE;

    if (!RegisterClass(&wc))
        bAppWDirDDE = FALSE;

    wc.lpfnWndProc = DDEMsgProc;
    wc.lpszClassName = szProgmanDDE;

    if (!RegisterClass(&wc))
        bProgmanDDE = FALSE;

    InitDdeConversationStruct();

}