able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/osshell/progman/pmdde.c

2652 lines
85 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************/
/* */
/* 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();
}
Reference in a new issue Copy permalink