/* 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(); }