/******************************************************************
* WDML_ClientQueueExecute
*
*
*/
static WDML_XACT* WDML_ClientQueueExecute(WDML_CONV* pConv, LPCVOID pData, DWORD cbData)
{
WDML_XACT* pXAct;
TRACE("XTYP_EXECUTE transaction\n");
pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
if (!pXAct)
return NULL;
if (cbData == (DWORD)-1)
{
HDDEDATA hDdeData = (HDDEDATA)pData;
pData = DdeAccessData(hDdeData, &cbData);
if (pData)
{
pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
DdeUnaccessData(hDdeData);
}
}
else
{
pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
}
pXAct->lParam = (LPARAM)pXAct->hMem;
return pXAct;
}
BOOL CDDEServer::Execute(LPCTSTR pszTopic, HDDEDATA hData, HDDEDATA* phResult)
{
DWORD nLength = 0;
LPVOID pData = DdeAccessData( hData, &nLength );
BOOL bResult = Execute( pszTopic, pData, nLength );
DdeUnaccessData( hData );
*phResult = (HDDEDATA)( bResult ? DDE_FACK : DDE_FNOTPROCESSED );
return bResult;
}
static DWORD __inline Dde_OnExecute(HCONV hconv, HSZ hszTopic, HDDEDATA hdata)
{
BYTE * pszCommand;
pszCommand = DdeAccessData(hdata, NULL);
if (!pszCommand)
return DDE_FNOTPROCESSED;
FIXME("stub: %s\n", pszCommand);
DdeUnaccessData(hdata);
return DDE_FNOTPROCESSED;
}
static inline DWORD Dde_OnExecute(HCONV hconv, HSZ hszTopic, HDDEDATA hdata)
{
WCHAR * pszCommand;
pszCommand = (WCHAR *)DdeAccessData(hdata, NULL);
if (!pszCommand)
return DDE_FNOTPROCESSED;
FIXME("stub: %s %s\n", debugstr_hsz(hszTopic), debugstr_w(pszCommand));
DdeUnaccessData(hdata);
return DDE_FNOTPROCESSED;
}
word
pl_dde_request(term_t handle, term_t item,
term_t value, term_t timeout)
{ int hdl;
int rval;
int ddeErr;
HSZ Hitem;
DWORD result, valuelen;
HDDEDATA Hvalue;
long tmo;
if ( !get_conv_handle(handle, &hdl) ||
!get_hsz(item, &Hitem) )
fail;
if ( !PL_get_long(timeout, &tmo) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_integer, timeout);
if ( tmo <= 0 )
tmo = TIMEOUT_VERY_LONG;
Hvalue = DdeClientTransaction(NULL, 0, conv_handle[hdl], Hitem, CF_TEXT,
XTYP_REQUEST, (DWORD)tmo, &result);
ddeErr = DdeGetLastError(ddeInst);
DdeFreeStringHandle(ddeInst, Hitem);
if ( Hvalue)
{ char * valuebuf;
char * valuedata;
valuedata = DdeAccessData(Hvalue, &valuelen);
valuebuf = (char *)malloc((size_t)valuelen+1);
strncpy(valuebuf, valuedata, valuelen+1);
DdeUnaccessData(Hvalue);
valuebuf[valuelen] = EOS;
rval = PL_unify_string_chars(value, valuebuf);
free(valuebuf);
return rval;
} else
{ const char * errmsg = dde_error_message(ddeErr);
return PL_unify_term(value,
PL_FUNCTOR, FUNCTOR_error1, /* error(Message) */
PL_CHARS, errmsg);
}
}
//Complete a DDE query
char* queryDDE(char* ItemName, DWORD* DataLength)
{
char* DataStr = NULL;
HSZ ItemHSZ = DdeCreateStringHandle(Inst, ItemName, CP_WINANSI);
//Get data in DDE format from the server
HDDEDATA DataHandle = DdeClientTransaction(NULL, 0, Conversation, ItemHSZ, CF_TEXT, XTYP_REQUEST, Timeout, NULL); //need to check about NULL vs. nil here
DdeFreeStringHandle(Inst, ItemHSZ);
//If we get a handle to it we contrinue
if (DataHandle == NULL)
{
printf("DDE Query \"%s\" Failed\n", ItemName);
DDEError(DdeGetLastError(Inst));
}
else
{
#ifdef _ddedebug
printf("Completed DDE Transaction\n");
#endif
//Find out how much data we've got
DdeAccessData(DataHandle, DataLength);
DataStr = malloc(*DataLength);
//Convert the data to char
DdeGetData(DataHandle, DataStr, *DataLength, 0);
#ifdef _ddedebug
printf("Converted DDE Data %d byte(s)\n", *DataLength);
printf("%s\n",DataStr);
#endif
DdeUnaccessData(DataHandle);
}
return DataStr;
}
/******************************************************************
* WDML_ClientQueueExecute
*
*
*/
static WDML_XACT* WDML_ClientQueueExecute(WDML_CONV* pConv, LPVOID pData, DWORD cbData)
{
WDML_XACT* pXAct;
TRACE("XTYP_EXECUTE transaction\n");
if (pData == NULL)
{
if (cbData == (DWORD)-1)
pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
else
pConv->instance->lastError = DMLERR_MEMORY_ERROR;
return NULL;
}
pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
if (!pXAct)
return NULL;
if (cbData == (DWORD)-1)
{
HDDEDATA hDdeData = pData;
pData = DdeAccessData(hDdeData, &cbData);
if (pData)
{
pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
DdeUnaccessData(hDdeData);
}
}
else
{
pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
}
pXAct->lParam = (LPARAM)pXAct->hMem;
return pXAct;
}
int
gsview_progman(char *groupname, char *gsviewpath, int gsver, char *gspath, char *gsargs)
{
DWORD idInst = 0L;
FARPROC lpDdeProc;
HSZ hszServName;
HSZ hszSysTopic;
HSZ hszGroupsItem;
HCONV hConv;
HDDEDATA hdata = NULL;
char setup[MAXSTR+MAXSTR];
DWORD dwResult;
char groupfile[MAXSTR];
int i;
char *s, *d;
FILE *ddefile;
char gspathbuf[MAXSTR];
char gsviewpathbuf[MAXSTR];
char gsdocbuf[MAXSTR];
strncpy(gspathbuf, gspath, sizeof(gspathbuf)/sizeof(TCHAR));
strncpy(gsdocbuf, gsargs, sizeof(gsdocbuf)/sizeof(TCHAR));
d = strchr(gsdocbuf, ';');
if (d)
*d = '\0';
if (gsver >= 593) {
d = strrchr(gsdocbuf, '\\');
if (d) {
d++;
strcpy(d, "doc\\");
}
}
else {
strcat(gsdocbuf, "\\");
}
strncpy(gsviewpathbuf, gsviewpath, sizeof(gsviewpathbuf));
if (!is_win32s) {
/* The DDE interface isn't reliable with long names */
/* Convert everything to short names */
GetShortPathNameA(gspath, gspathbuf, sizeof(gspathbuf));
GetShortPathNameA(gsviewpath, gsviewpathbuf, sizeof(gsviewpathbuf));
}
/* Open ProgMan DDE undo file if it doesn't exist */
strcpy(setup, gsviewpathbuf);
strcat(setup, GSVIEW_ZIP);
d = strrchr(setup, '.');
strcpy(d, "dde.log");
ddefile = fopen(setup, "r");
if (ddefile != (FILE *)NULL) {
/* We found a previous ProgMan DDE undo file. */
/* Don't touch it since we want to keep the original record */
/* of the ProgMan state before GSview was installed */
fclose(ddefile);
ddefile = (FILE *)NULL;
}
else {
ddefile = fopen(setup, "w");
/* If we fail to open the file for writing, the destination is probably
* read only. Don't worry, just don't write to the log file.
*/
}
/* derive group filename from group name */
for (i=0, s=groupname, d=groupfile; i<8 && *s; s++) {
if (isalpha((int)(*s)) || isdigit((int)(*s))) {
*d++ = *s;
i++;
}
}
*d = '\0';
if (strlen(groupfile)==0)
strcpy(groupfile, "gstools");
lpDdeProc = MakeProcInstance((FARPROC)DdeCallback, phInstance);
if (DdeInitialize(&idInst, (PFNCALLBACK)lpDdeProc, CBF_FAIL_POKES, 0L)) {
return 1;
}
hszServName = DdeCreateStringHandleA(idInst, "PROGMAN", CP_WINANSI);
hszSysTopic = DdeCreateStringHandleA(idInst, "PROGMAN", CP_WINANSI);
hConv = DdeConnect(idInst, hszServName, hszSysTopic, (PCONVCONTEXT)NULL);
if (hConv == NULL) {
DdeFreeStringHandle(idInst, hszServName);
DdeFreeStringHandle(idInst, hszSysTopic);
return 1;
}
if (ddefile) {
/* Find out if group existed */
hszGroupsItem = DdeCreateStringHandleA(idInst, groupname, CP_WINANSI);
hdata = DdeClientTransaction((LPBYTE)NULL, 0, hConv,\
hszGroupsItem, CF_TEXT, XTYP_REQUEST, 5000, &dwResult);
DdeFreeStringHandle(idInst, hszGroupsItem);
}
#define DDEEXECUTE(str)\
DdeClientTransaction((LPBYTE)str, strlen(str)+1, hConv,\
NULL, CF_TEXT, XTYP_EXECUTE, 5000, &dwResult)
sprintf(setup, "[CreateGroup(\042%s\042,%s.grp)][ShowGroup(\042%s\042,1)]",
groupname, groupfile, groupname); /* display, active */
DDEEXECUTE(setup);
if (ddefile) /* display, no active */
fprintf(ddefile, "[ShowGroup(\042%s\042,8)]\n",groupname);
sprintf(setup, "[ReplaceItem(\042%s\042)]", GSVIEW_NAME);
DDEEXECUTE(setup);
#ifdef _WIN64
#define GSVIEW_ICON "gsview64.ico"
#else
#define GSVIEW_ICON "gsview32.ico"
#endif
if (!is_win4)
sprintf(setup, "[AddItem(\042%s%s\042,\042%s\042, \042%s%s\042)]",
gsviewpathbuf, GSVIEW_EXENAME, GSVIEW_NAME, gsviewpathbuf,
GSVIEW_ICON);
else
sprintf(setup, "[AddItem(\042%s%s\042,\042%s\042)]",
gsviewpathbuf, GSVIEW_EXENAME, GSVIEW_NAME);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", GSVIEW_NAME);
/* Win3.1 documentation says you must put quotes around names */
/* with embedded spaces. */
/* In Win95, it appears you must put quotes around the EXE name */
/* and options separately */
sprintf(setup, "[ReplaceItem(\042GSview README\042)]");
DDEEXECUTE(setup);
#ifdef NOTUSED_IN_GSVIEW28
if (!is_win4)
sprintf(setup, "[AddItem(\042notepad.exe %sREADME.TXT\042,\042GSview README\042)]",
gsviewpathbuf);
else
sprintf(setup, "[AddItem(\042notepad.exe\042 \042%sREADME.TXT\042,\042GSview README\042,\042notepad.exe\042,1)]",
gsviewpathbuf);
#endif
sprintf(setup, "[AddItem(\042%sReadme.htm\042,\042GSview README\042)]",
gsviewpathbuf);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "GSview README");
sprintf(setup, "[ReplaceItem(\042Ghostscript\042)]");
DDEEXECUTE(setup);
if (!is_win4)
sprintf(setup, "[AddItem(\042%s%s -I%s\042,\042Ghostscript\042, \042%sgstext.ico\042)]",
gspathbuf, GS_EXENAME, gsargs, gspathbuf);
else
sprintf(setup, "[AddItem(\042%s%s\042 \042-I%s\042,\042Ghostscript\042)]",
gspathbuf, GS_EXENAME, gsargs);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "Ghostscript");
sprintf(setup, "[ReplaceItem(\042Ghostscript README\042)]");
DDEEXECUTE(setup);
if (gsver >= 540) {
sprintf(setup,
"[AddItem(\042%sReadme.htm\042,\042Ghostscript README\042)]",
gsdocbuf);
}
else {
if (!is_win4)
sprintf(setup, "[AddItem(\042notepad.exe %sREADME.\042,\042Ghostscript README\042)]",
gsdocbuf);
else
sprintf(setup, "[AddItem(\042notepad.exe\042 \042%sREADME.\042,\042Ghostscript README\042, \042notepad.exe\042,1)]",
gsdocbuf);
}
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "Ghostscript README");
#undef DDEXECUTE
/* Now remember the way things were */
if (ddefile) {
if (hdata) {
DWORD dlen;
BYTE FAR *lpData = DdeAccessData(hdata, &dlen);
LPSTR p, q;
/* skip first line */
q = (LPSTR)lpData;
while (*q && (*q != '\r') && (*q != '\n'))
q++;
while (*q && ((*q == '\r') || (*q == '\n')))
q++;
p = q;
/* for each group item */
while (*p) {
/* skip to end of line */
while (*q && (*q != '\r') && (*q != '\n'))
q++;
strncpy(setup, p, (int)(q-p)+1);
add_group_item(ddefile, setup);
/* skip to start of next group name */
while (*q && ((*q == '\r') || (*q == '\n')))
q++;
p = q;
}
if (ddefile) /* display, no active */
fprintf(ddefile, "[ShowGroup(\042%s\042,8)]\n",groupname);
DdeUnaccessData(hdata);
DdeFreeDataHandle(hdata);
}
else {
/* group didn't exist before, so delete it */
fprintf(ddefile, "[DeleteGroup(\042%s\042)]\n", groupname);
}
fclose(ddefile);
}
DdeDisconnect(hConv);
DdeFreeStringHandle(idInst, hszServName);
DdeFreeStringHandle(idInst, hszSysTopic);
DdeUninitialize(idInst);
return 0;
}
/*****************************************************************
* DdeUnaccessData (DDEML.18)
*/
BOOL16 WINAPI DdeUnaccessData16(HDDEDATA hData)
{
return DdeUnaccessData(hData);
}
HDDEDATA FAR PASCAL _export PowDdeServerProc (UINT type,UINT fmt,HCONV hconv,HSZ hsz1,HSZ hsz2,HDDEDATA hdata,DWORD dwData1,DWORD dwData2)
{
LPSTR exec;
HWND hWnd;
DWORD size;
HDDEDATA hDat;
switch (type) {
case XTYP_CONNECT:
return (HDDEDATA)IsTopic(hsz1);
case XTYP_EXECUTE:
{
char buf[1000];
if (IsTopic(hsz1)) {
DdeGetData(hdata,buf,sizeof(buf),0);
exec=GetExecData(buf);
if (IsCommand(buf,"openfile")) {
if (*exec && (hWnd=AlreadyOpen(exec)))
BringWindowToTop(hWnd);
else {
#ifndef _WIN32
DownStr(exec);
#endif
AddFile(exec);
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"newfile")) {
hWnd=AddFile(0);
if (hWnd && *exec) {
HWND old;
if (old=AlreadyOpen(exec))
SendMessage (hwndMDIClient,WM_MDIDESTROY,(WPARAM)old,0L);
#ifndef _WIN32
DownStr(exec);
#endif
SetWindowText(hWnd,exec);
SetWindowWord(hWnd,GWW_UNTITLED,0);
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"savefile")) {
if (GetActiveEditWindow(hwndMDIClient)) {
if (*exec) {
#ifndef _WIN32
AnsiLower(exec);
#endif
SetWindowText(GetActiveEditWindow(hwndMDIClient),exec);
SetWindowWord(GetActiveEditWindow(hwndMDIClient),GWW_UNTITLED,0);
}
SendMessage(hwndFrame,WM_COMMAND,IDM_FILESAVE,0);
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"activate")) {
if (*exec && (hWnd=AlreadyOpen(exec)))
BringWindowToTop(hWnd);
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"appendtext") || IsCommand(buf,"addtext")) {
if (*exec && GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
EditAddText(GetActiveEditWindow(hwndMDIClient),exec);
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"inserttext")) {
if (*exec && GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
EditInsertText(GetActiveEditWindow(hwndMDIClient),exec);
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"appendfile") || IsCommand(buf,"addtext")) {
if (*exec && GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient))) {
EditGotoPos(GetActiveEditWindow(hwndMDIClient),-1,-1);
InsertFile(exec);
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"insertfile")) {
if (*exec && GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
InsertFile(exec);
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"showposition")) {
/* go to line/col of a given file (open if necessary) */
if (*exec) {
char *file,*sline,*scol;
int line=-1,col=-1;
file=strtok(exec," ");
if (file) {
/* read position */
sline=strtok(NULL," ");
if (sline) {
line=atoi(sline);
scol=strtok(NULL," ");
if (scol)
col=atoi(scol);
}
/* display the file */
if (hWnd=AlreadyOpen(file))
BringWindowToTop(hWnd);
else {
#ifndef _WIN32
DownStr(file);
#endif
AddFile(file);
}
/* set caret to given position */
EditGotoPos(GetActiveEditWindow(hwndMDIClient),line,col);
}
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"addtool")) {
/* create a new tool */
if (*exec) {
LPSTR lp;
char *name,*cmd,*dir,*options;
BOOL menu,askArg,toTop;
int buttonId;
name=cmd=dir=options=NULL;
menu=askArg=toTop=FALSE;
buttonId=0;
/* read tool name */
name=strtok(exec,",");
if (name) {
cmd=strtok(NULL,",");
if (cmd) {
dir=strtok(NULL,",");
if (dir) {
options=strtok(NULL,",");
if (options) {
lp=strtok(NULL,",");
if (lp) {
menu=(BOOL)atoi(lp);
lp=strtok(NULL,",");
if (lp) {
buttonId=atoi(lp);
lp=strtok(NULL,",");
if (lp) {
toTop=(BOOL)atoi(lp);
lp=strtok(NULL,",");
if (lp) {
askArg=(BOOL)atoi(lp);
}
}
}
}
}
}
}
}
if (strcmp(dir," ")==0) dir="";
if (strcmp(options," ")==0) options="";
if (name && cmd && *name && *cmd && (menu || buttonId))
ToolAdd(name,cmd,dir,options,menu,buttonId,toTop,askArg);
}
return (HDDEDATA)DDE_FACK;
}
else if (IsCommand(buf,"deletetool")) {
/* remove an external tool */
if (*exec)
ToolDelete(exec);
return (HDDEDATA)DDE_FACK;
}
}
return (HDDEDATA)DDE_FNOTPROCESSED;
}
case XTYP_POKE:
{
if (IsTopic(hsz1))
{
if (IsEqualString(hsz2,"editbuffer"))
{
if (GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
{
LPSTR lBuf;
if (lBuf=DdeAccessData(hdata,(LPDWORD)&size))
{
EditResetContent(GetActiveEditWindow(hwndMDIClient));
EditAddText(GetActiveEditWindow(hwndMDIClient),lBuf);
DdeUnaccessData(hdata);
}
}
return (HDDEDATA)DDE_FACK;
}
}
return (HDDEDATA)DDE_FNOTPROCESSED;
}
case XTYP_REQUEST:
{
if (IsTopic(hsz1))
{
if (IsEqualString(hsz2,"activefile"))
{
if (GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
{
long len;
char name[100];
HSZ hitem;
hitem=DdeCreateStringHandle(ddeInstId,(LPSTR)"activefile",CP_WINANSI);
len=GetWindowText(GetActiveEditWindow(hwndMDIClient),(LPSTR)name,sizeof(name));
return DdeCreateDataHandle(ddeInstId,(LPSTR)name,len+1,0,hitem,CF_TEXT,0);
}
}
else if (IsEqualString(hsz2,"editbuffer"))
{
if (GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)))
{
LPSTR lp;
HGLOBAL h;
if (h=EditGetText(GetActiveEditWindow(hwndMDIClient)))
{
HSZ hitem;
hitem=DdeCreateStringHandle(ddeInstId,(LPSTR)"editbuffer",CP_WINANSI);
lp=GlobalLock(h);
hDat=DdeCreateDataHandle(ddeInstId,lp,GlobalSize(h),0,hitem,CF_TEXT,0);
GlobalUnlock(h);
GlobalFree(h);
}
else
hDat=0;
return hDat;
}
}
else if (IsEqualString(hsz2,"compiler"))
{
/* return name of active compiler interface dll */
char name[100];
HSZ hitem;
hitem=DdeCreateStringHandle(ddeInstId,(LPSTR)"compiler",CP_WINANSI);
strcpy(name,actConfig.compiler);
return DdeCreateDataHandle(ddeInstId,(LPSTR)name,strlen(name)+1,0,hitem,CF_TEXT,0);
}
else if (IsEqualString(hsz2,"executable"))
{
/* return name of target executale */
BOOL isExecutable;
//FARPROC lpfn;
char name[500];
HSZ hitem;
if (IsCompilerInterfaceLoaded())
{
if (!*actPrj)
{
RemoveMessageWindow();
if (GetActiveEditWindow(hwndMDIClient) && IsEditWindow(GetActiveEditWindow(hwndMDIClient)) && !GetWindowWord(GetActiveEditWindow(hwndMDIClient),GWW_UNTITLED))
{
SetDefaultProjectName();
isExecutable=(*compGetTarget)(hCompData,(LPSTR)name);
if (*name && *RunArgs)
{
/* append run arguments (as string included in "") */
strcat(name," \"");
strcat(name,RunArgs);
strcat(name,"\"");
}
}
else *name=0;
}
else
isExecutable=(*compGetTarget)(hCompData,(LPSTR)name);
}
else *name=0;
hitem=DdeCreateStringHandle(ddeInstId,(LPSTR)"executable",CP_WINANSI);
return DdeCreateDataHandle(ddeInstId,(LPSTR)name,strlen(name)+1,0,hitem,CF_TEXT,0);
}
}
return (HDDEDATA) NULL;
}
}
if (type&XCLASS_FLAGS)
return (HDDEDATA)DDE_FNOTPROCESSED;
else
return (HDDEDATA)NULL;
}
HDDEDATA CALLBACK DDEService::DdeCallback(
UINT wType,
UINT wFmt,
HCONV /* hConv */,
HSZ hszTopic,
HSZ hszItem,
HDDEDATA hData,
DWORD /* lData1 */,
DWORD /* lData2 */)
{
HDDEDATA hReturn = (HDDEDATA)FALSE;
switch (wType)
{
case XTYP_CONNECT:
{
hReturn = (HDDEDATA)TRUE;
}
break;
case XTYP_WILDCONNECT:
{
HSZPAIR FAR *phszp;
DWORD cb;
if ((!hszTopic || hszTopic == m_hszProgman) &&
(!hszItem || hszItem == m_hszProgman))
{
HDDEDATA hData = DdeCreateDataHandle(m_dwDDEInst, NULL,
2 * sizeof(HSZPAIR), 0L, 0, 0, 0);
if (hData)
{
phszp = (HSZPAIR FAR *)DdeAccessData(hData, &cb);
phszp[0].hszSvc = m_hszProgman;
phszp[0].hszTopic = m_hszProgman;
phszp[1].hszSvc = phszp[1].hszTopic = 0;
DdeUnaccessData(hData);
hReturn = hData;
}
}
}
break;
case XTYP_EXECUTE:
{
if ((hszTopic == m_hszGroups) || (hszTopic == m_hszAppProperties))
{
TCHAR tzBuf[MAX_PATH];
DdeGetData(hData, (LPBYTE)tzBuf, MAX_PATH, 0);
tzBuf[MAX_PATH - 1] = '\0';
if (m_DDEWorker.ParseRequest(tzBuf))
{
hReturn = (HDDEDATA)DDE_FACK;
}
}
}
break;
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
{
if (wFmt == CF_TEXT)
{
hReturn = (HDDEDATA)TRUE;
}
}
break;
case XTYP_REQUEST:
case XTYP_ADVREQ:
{
if ((wFmt == CF_TEXT) && ((hszTopic == m_hszProgman) &&
(hszItem == m_hszGroups)))
{
LPVOID pList = NULL;
UINT ulLen = 0;
if (m_DDEWorker.ListGroups(pList, ulLen))
{
hReturn = DdeCreateDataHandle(m_dwDDEInst, (LPBYTE)pList,
ulLen, 0L, m_hszGroups, CF_TEXT, 0);
HeapFree(GetProcessHeap(), 0, pList);
}
}
}
break;
default:
{
// do nothing
}
break;
}
return hReturn;
}
/******************************************************************
* WDML_ServerNameProc
*
*
*/
static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
HWND hwndClient;
HSZ hszApp, hszTop;
HDDEDATA hDdeData = 0;
WDML_INSTANCE* pInstance;
UINT uiLo, uiHi;
switch (iMsg)
{
case WM_DDE_INITIATE:
/* wParam -- sending window handle
LOWORD(lParam) -- application atom
HIWORD(lParam) -- topic atom */
TRACE("WM_DDE_INITIATE message received!\n");
hwndClient = (HWND)wParam;
pInstance = WDML_GetInstanceFromWnd(hwndServer);
TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
if (!pInstance) return 0;
/* don't free DDEParams, since this is a broadcast */
UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
{
BOOL self = FALSE;
CONVCONTEXT cc;
CONVCONTEXT* pcc = NULL;
WDML_CONV* pConv;
char buf[256];
if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
{
self = TRUE;
}
/* FIXME: so far, we don't grab distant convcontext, so only check if remote is
* handled under DDEML, and if so build a default context
*/
if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
strcmp(buf, WDML_szClientConvClassA) == 0) ||
(GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
lstrcmpW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
{
pcc = &cc;
memset(pcc, 0, sizeof(*pcc));
pcc->cb = sizeof(*pcc);
pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
}
if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
{
TRACE("Don't do self connection as requested\n");
}
else if (hszApp && hszTop)
{
WDML_SERVER* pServer = (WDML_SERVER*)GetWindowLongA(hwndServer, GWL_WDML_SERVER);
/* check filters for name service */
if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
{
/* pass on to the callback */
hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
if ((UINT)hDdeData)
{
pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
hszApp, hszTop);
if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
}
}
}
else if (pInstance->servers)
{
/* pass on to the callback */
hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
if (hDdeData == (HDDEDATA)CBR_BLOCK)
{
/* MS doc is not consistent here */
FIXME("CBR_BLOCK returned for WILDCONNECT\n");
}
else if ((UINT)hDdeData != 0)
{
HSZPAIR* hszp;
hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
if (hszp)
{
int i;
for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
{
pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
hszp[i].hszSvc, hszp[i].hszTopic);
if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
}
DdeUnaccessData(hDdeData);
}
if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
}
}
}
return 0;
case WM_DDE_REQUEST:
FIXME("WM_DDE_REQUEST message received!\n");
return 0;
case WM_DDE_ADVISE:
FIXME("WM_DDE_ADVISE message received!\n");
return 0;
case WM_DDE_UNADVISE:
FIXME("WM_DDE_UNADVISE message received!\n");
return 0;
case WM_DDE_EXECUTE:
FIXME("WM_DDE_EXECUTE message received!\n");
return 0;
case WM_DDE_POKE:
FIXME("WM_DDE_POKE message received!\n");
return 0;
case WM_DDE_TERMINATE:
FIXME("WM_DDE_TERMINATE message received!\n");
return 0;
}
return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
}
static DWORD Dde_OnExecute(HCONV hconv, HSZ hszTopic, HDDEDATA hdata)
{
WCHAR szTopic[MAX_PATH];
WCHAR szCommand[MAX_PATH];
WCHAR *pszCommand;
DdeQueryStringW(dwDDEInst, hszTopic, szTopic, _countof(szTopic), CP_WINUNICODE);
pszCommand = (WCHAR*) DdeAccessData(hdata, NULL);
if (!pszCommand)
return DDE_FNOTPROCESSED;
StringCchCopyW(szCommand, _countof(szCommand), pszCommand);
DdeUnaccessData(hdata);
TRACE("Dde_OnExecute: hconv=%p, topic=%S, command=%S\n", hconv, szTopic, pszCommand);
/*
[ViewFolder("%l", %I, %S)] -- Open a folder in standard mode
[ExploreFolder("%l", %I, %S)] -- Open a folder in "explore" mode (file tree is shown to the left by default)
[FindFolder("%l", %I)] -- Open a folder in "find" mode (search panel is shown to the left by default)
[ShellFile("%1","%1",%S)] -- Execute the contents of the specified .SCF file
Approximate grammar (Upper names define rules, <lower> names define terminals, single-quotes are literals):
Rules
Command = ('[' Function ']') | Function
Function = <identifier> '(' Parameters ')'
Parameters = (<quoted-string> (',' <idlist> (',' <number>)?)?)?
Terminals
<identifier> = [a-zA-Z]+
<quoted-string> = \"([^\"]|\\.)\"
<idlist> = \:[0-9]+\:[0-9]+
<number> = [0-9]+
*/
WCHAR Command[MAX_PATH] = L"";
WCHAR Path[MAX_PATH] = L"";
LPITEMIDLIST IdList = NULL;
INT UnknownParameter = 0;
// Simplified parsing (assumes the command will not be TOO broken):
PWSTR cmd = szCommand;
// 1. if starts with [, skip first char
if (*cmd == L'[')
cmd++;
if (*cmd == L']')
{
ERR("Empty command. Nothing to run.\n");
return DDE_FNOTPROCESSED;
}
// Read until first (, and take text before ( as command name
{
PWSTR cmdEnd = StrChrW(cmd, L'(');
if (!cmdEnd)
{
ERR("Could not find '('. Invalid command.\n");
return DDE_FNOTPROCESSED;
}
*cmdEnd = 0;
StringCchCopy(Command, _countof(Command), cmd);
cmd = cmdEnd + 1;
}
// Read first param after (, expecting quoted string
if (*cmd != L')')
{
// Copy unescaped string
PWSTR dst = Path;
BOOL isQuote = FALSE;
PWSTR arg = cmd;
while (*arg && (isQuote || *arg != L','))
{
if (*arg == L'"')
{
isQuote = !isQuote;
if (isQuote && arg != cmd) // do not copy the " at the beginning of the string
{
*(dst++) = L'"';
}
}
else
{
*(dst++) = *arg;
}
arg++;
}
cmd = arg + 1;
while (*cmd == L' ')
cmd++;
}
// Read second param, expecting an idlist in shared memory
if (*cmd != L')')
{
if (*cmd != ':')
{
ERR("Expected ':'. Invalid command.\n");
return DDE_FNOTPROCESSED;
}
PWSTR idlistEnd = StrChrW(cmd, L',');
if (!idlistEnd)
idlistEnd = StrChrW(cmd, L')');
if (!idlistEnd)
{
ERR("Expected ',' or ')'. Invalid command.\n");
return DDE_FNOTPROCESSED;
}
IdList = _ILReadFromSharedMemory(cmd);
cmd = idlistEnd + 1;
}
// Read third param, expecting an integer
if (*cmd != L')')
{
UnknownParameter = StrToIntW(cmd);
}
TRACE("Parse end: cmd=%S, S=%d, pidl=%p, path=%S\n", Command, UnknownParameter, IdList, Path);
// Find handler in list
for (int i = 0; i < HandlerListLength; i++)
{
DDECommandHandler & handler = HandlerList[i];
if (StrCmpW(handler.Command, Command) == 0)
{
return handler.Handler(Command, Path, IdList, UnknownParameter);
}
}
// No handler found
ERR("Unknown command %S\n", Command);
return DDE_FNOTPROCESSED;
}
BOOL MessageDDE ( WPARAM wParam )
{
switch ( wParam )
{
case IDM_BUFFER_BATCH:
case IDM_BUFFER_LOAD:
case IDM_BUFFER_LBUF:
{
extern HSZ hSZService, hSZItem;
extern HCONV hConv;
extern DWORD idInst;
extern HWND hEditWnd;
HANDLE hTemp;
HSZ hSZTopic;
DWORD dwResult;
HDDEDATA hData;
DWORD sel;
int len;
WORD start;
char *Data;
int text_length; // GDR
/*--------------------------+
| Create conversation Topic |
+--------------------------*/
if ( wParam == IDM_BUFFER_BATCH )
hSZTopic = DdeCreateStringHandle( idInst, "BATCH", CP_WINANSI);
else
hSZTopic = DdeCreateStringHandle( idInst, "LOAD", CP_WINANSI);
/*---------------------+
| Selected entire File |
+---------------------*/
if ( wParam == IDM_BUFFER_LBUF )
SendMessage ( hEditWnd, EM_SETSEL, 0, -1);
/*----------------------------------------+
| Find the area of text that was selected |
+----------------------------------------*/
sel = SendMessage(hEditWnd,EM_GETSEL,0,0L);
len = HIWORD(sel)- LOWORD(sel);
start = LOWORD (sel);
/*-------------------------------+
| Start conversation with server |
+-------------------------------*/
if ( hConv != NULL ) DdeDisconnect ( hConv );
hConv = DdeConnect ( idInst, hSZService, hSZTopic, (PCONVCONTEXT)NULL);
if ( hConv == NULL )
{
DdeFreeStringHandle ( idInst, hSZTopic );
return ( FALSE );
}
/*----------------------------+
| Find Data that was Selected |
+----------------------------*/
// Begin GDR
// hEditHandle = (HLOCAL) SendMessage ( hEditWnd, EM_GETHANDLE, 0, 0);
// Data = (char *) LocalLock ( hEditHandle );
text_length = SendMessage(hEditWnd,WM_GETTEXTLENGTH,0,0);
Data = (char *) malloc(text_length+1);
if (Data == NULL )
{
MessageBeep ( 0 );
MessageBox (NULL,"Can not complete operation",
"Memory Low", MB_ICONSTOP | MB_TASKMODAL );
DdeDisconnect( hConv );
DdeFreeStringHandle ( idInst, hSZTopic );
return(FALSE);
}
SendMessage(hEditWnd,WM_GETTEXT,text_length+1,
(LPARAM) Data);
// End GDR
/*------------------------------------------+
| Create Packet Data and Copy Selected Data |
+------------------------------------------*/
hTemp = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT, len + 1 );
if ( hTemp == NULL )
{
MessageBeep ( 0 );
MessageBox (NULL,"Can not complete operation",
"Memory Low", MB_ICONSTOP | MB_TASKMODAL );
free(Data); // GDR
DdeDisconnect( hConv );
DdeFreeStringHandle ( idInst, hSZTopic );
return(FALSE);
}
{
BYTE *Temp;
int x;
Temp = (BYTE *) GlobalLock ( hTemp );
strncpy ( (char *) Temp, Data+start, len );
for (x=0; x< len; x++ )
if ( Temp[x] == '\r' )
Temp[x] = ' ';
Temp[len] = '\0';
hData = DdeCreateDataHandle ( idInst, Temp, len+1 ,
0L, hSZItem, CF_TEXT, 0 );
if ( hData == NULL )
{
free(Data); // GDR
DdeDisconnect( hConv );
DdeFreeStringHandle ( idInst, hSZTopic );
GlobalUnlock ( hTemp );
GlobalFree ( hTemp );
return ( FALSE );
}
/*-------------------------------------------------+
| Pass DDE Data Via XTYP_POKE DdeClientTransaction |
+-------------------------------------------------*/
DdeClientTransaction ((LPBYTE)hData, -1, hConv, hSZItem, CF_TEXT,
XTYP_POKE, 1000, &dwResult );
if ( DdeGetLastError ( idInst ) == DMLERR_BUSY )
{
MessageBeep ( 0 );
MessageBox (NULL,"Can not complete operation",
"CLIPS Running.", MB_ICONSTOP | MB_TASKMODAL );
free(Data); // GDR
DdeDisconnect( hConv );
DdeFreeStringHandle ( idInst, hSZTopic );
GlobalUnlock ( hTemp );
GlobalFree ( hTemp );
return(FALSE);
}
GlobalUnlock ( hTemp );
GlobalFree ( hTemp );
}
// LocalUnlock ( hEditHandle);
free(Data); // GDR
DdeDisconnect( hConv );
DdeFreeStringHandle ( idInst, hSZTopic );
break;
}
case IDM_HELP_COMPLETE:
case IDM_EDIT_COMPLETE:
{
extern DWORD idInst;
extern HCONV hConv;
extern HSZ hSZService, hSZItem;
extern HWND hEditWnd;
HSZ hSZTopic;
DWORD dwResult;
HDDEDATA hData;
/*-------------------------------+
| Start conversation with server |
+-------------------------------*/
hSZTopic = DdeCreateStringHandle ( idInst, "COMPLETE", CP_WINANSI );
if ( hConv != NULL ) DdeDisconnect ( hConv );
hConv = DdeConnect ( idInst, hSZService, hSZTopic, (PCONVCONTEXT)NULL);
if ( hConv == NULL )
{
DdeFreeStringHandle ( idInst, hSZTopic );
return ( FALSE );
}
/*--------------------+
| Find and Send Token |
+--------------------*/
{
// HANDLE hEditHandle;
int text_length; // GDR
DWORD sel = SendMessage(hEditWnd,EM_GETSEL,0,0L);
WORD start = LOWORD (sel);
WORD end;
int len;
BYTE *buffer;
char *EditData;
/*-------------------------+
| Find Token to be matched |
+-------------------------*/
text_length = SendMessage(hEditWnd,WM_GETTEXTLENGTH,0,0);
EditData = (char *) malloc(text_length+1);
if ( EditData == NULL )
{
DdeDisconnect(hConv);
DdeFreeStringHandle ( idInst, hSZTopic );
return ( FALSE );
}
SendMessage(hEditWnd,WM_GETTEXT,text_length+1,(LPARAM) EditData);
// hEditHandle = (HLOCAL) SendMessage ( hEditWnd, EM_GETHANDLE, 0, 0);
// EditData = (char *) LocalLock ( hEditHandle );
while (start > 0 && !(isspace(EditData[start-1])))
{start --;}
end = start;
while (!(isspace(EditData[end])))
{ end ++; }
len = (end - start)+1;
buffer = (BYTE *) malloc ( len + 1);
if (buffer == NULL )
{
MessageBeep ( 0 );
MessageBox (NULL,"Can not complete operation",
"Memory Low", MB_ICONSTOP | MB_TASKMODAL );
free(EditData);
DdeDisconnect(hConv);
DdeFreeStringHandle ( idInst, hSZTopic );
return(FALSE);
}
strncpy ( (char *) buffer, EditData+start, len );
/*--------------------------+
| Create Data Packet & Send |
+--------------------------*/
hData = DdeCreateDataHandle ( idInst, buffer,
(DWORD) (len)+1, 0, hSZItem, CF_TEXT, 0 );
if ( hData == NULL )
{
DdeDisconnect(hConv);
DdeFreeStringHandle ( idInst, hSZTopic );
free(buffer);
free(EditData);
return ( FALSE );
}
DdeClientTransaction ((LPBYTE)hData, -1, hConv, hSZItem, CF_TEXT, XTYP_POKE, 1000, &dwResult);
free ( buffer );
// LocalUnlock ( hEditHandle );
free(EditData);
// Begin GDR
SendMessage ( hEditWnd, EM_SETSEL, start, end);
// End GDR
}
/*---------------------------+
| Retrieve and replace token |
+---------------------------*/
{
char *buffer;
/*----------------+
| Wait for Result |
+----------------*/
hData = NULL;
while ( hData == FALSE )
{
hData = DdeClientTransaction ( NULL, 90, hConv,
hSZItem, CF_TEXT, XTYP_REQUEST, 100, &dwResult );
}
/*------------+
| Copy Result |
+------------*/
SetFocus ( hEditWnd );
buffer = (char*)DdeAccessData (hData, NULL);
if ( strcmp ( buffer, "\0" ) != 0 )
SendMessage ( hEditWnd, EM_REPLACESEL, 0,
(LPARAM)((LPSTR) buffer));
DdeUnaccessData (hData);
}
/*----------------------+
| ShutDown Conversation |
+----------------------*/
DdeDisconnect(hConv);
DdeFreeStringHandle ( idInst, hSZTopic );
break;
}
}
return ( TRUE );
}
HDDEDATA CALLBACK DDECallBack(
UINT uType,
UINT uFmt,
HCONV hconv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD dwData1,
DWORD dwData2)
{
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(hconv)
#pragma unused(dwData1)
#pragma unused(dwData2)
#endif
extern HSZ hszService;
extern char CompleteString[255];
DWORD size;
HWND hWnd;
char *TheData;
char *Data;
char *theString;
void *theEnv = GetCurrentEnvironment();
/*
char theBuffer[100];
DWORD cb;
PSTR pszTopicName;
*/
switch (uType)
{
case XTYP_ADVDATA:
case XTYP_POKE:
return ((HDDEDATA) DDE_FNOTPROCESSED);
case XTYP_ADVREQ:
case XTYP_WILDCONNECT:
return ((HDDEDATA) NULL);
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
case XTYP_CONNECT_CONFIRM:
case XTYP_DISCONNECT:
case XTYP_ERROR:
case XTYP_REGISTER:
case XTYP_UNREGISTER:
case XTYP_XACT_COMPLETE:
return ((HDDEDATA) FALSE);
case XTYP_MONITOR:
return ((HDDEDATA) TRUE);
case XTYP_CONNECT:
/*
cb = DdeQueryString(idInst,hsz1,(LPSTR) NULL, 0,CP_WINANSI) + 1;
pszTopicName = (PSTR) LocalAlloc(LPTR, (UINT) cb);
DdeQueryString(idInst,hsz1, pszTopicName,cb,CP_WINANSI);
cb = DdeQueryString(idInst,hsz2,(LPSTR) NULL, 0,CP_WINANSI) + 1;
pszTopicName = (PSTR) LocalAlloc(LPTR, (UINT) cb);
DdeQueryString(idInst,hsz2, pszTopicName,cb,CP_WINANSI);
*/
DDE_RV.type = RVOID;
if (hsz2 != hszService)
{ return ((HDDEDATA) FALSE); }
return((HDDEDATA) TRUE);
/*--------------------------------------------------+
| Get completed command and return result to client |
+--------------------------------------------------*/
case XTYP_REQUEST:
if (uFmt != CF_TEXT)
{ return(NULL); }
/* sprintf(theBuffer,"XTYP_REQUEST uFmt = %d\n",(int) uFmt);
PrintRouter(WDISPLAY,theBuffer); */
hData = NULL;
if (hsz1 == hszCommand)
{
theString = DataObjectToString(GetCurrentEnvironment(),&DDE_RV);
hData = DdeCreateDataHandle (idInst,
(unsigned char *) theString,
strlen(theString)+1,
0L, hsz2,CF_TEXT,0);
}
return (hData);
case XTYP_EXECUTE:
SetFocus(DialogWindow);
if (CommandLineData(GetCurrentEnvironment())->EvaluatingTopLevelCommand ||
BatchActive(GetCurrentEnvironment()) )
{ return ((HDDEDATA) DDE_FBUSY ); }
Data = (char *) DdeAccessData ( hData, NULL);
size = strlen((char *) Data) + 1;
TheData = (char *) genalloc ( GetCurrentEnvironment(),(unsigned) size );
DdeGetData ( hData, (LPBYTE)TheData, size, 0L );
EnvPrintRouter(theEnv,WPROMPT,TheData);
EnvPrintRouter(theEnv,WPROMPT,"\n");
EnvEval(theEnv,TheData,&DDE_RV);
if (DDE_RV.type != RVOID)
{
PrintDataObject(GetCurrentEnvironment(),"stdout",&DDE_RV);
EnvPrintRouter(theEnv,"stdout","\n");
}
PrintPrompt(theEnv);
DdeUnaccessData(hData);
hWnd = FindWindow("ClipsEditWClass", NULL);
SetFocus (hWnd);
return ((HDDEDATA) DDE_FACK);
}
return ( (HDDEDATA) TRUE );
}
HDDEDATA W_CALLBACK KapDDECallBack(WORD wTran, WORD wFmt, HCONV hConv,
HSZ hsz1, HSZ hsz2, HDDEDATA hData,
DWORD dwData1, DWORD dwData2)
{
switch (wTran) {
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
{
BOOL bRes = FALSE;
if (wFmt == CF_TEXT)
{
char *cl;
if (!DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
return (HDDEDATA) FALSE;
cl = strchr(return_buffer, ':');
if (cl)
{
DDEINFO ddeInfo;
ATOMID idName;
WORD wType;
cl[0] = '\0';
idName = KppAddAtom(return_buffer);
ddeInfo.idSlot = KppAddAtom(cl + 1);
ddeInfo.idObj = KppGetObjectId(idName, &wType);
ddeInfo.idApp = ddeInfo.idItem = NULLID;
ddeInfo.idTopic = HszToAtom(hsz1);
ddeInfo.hConv = hConv;
if (ddeInfo.idObj)
{
UnwindProtect(cleanup1);
requests++;
switch (wTran) {
case XTYP_ADVSTART:
if (CreateLink(&ddeInfo))
bRes = TRUE;
break;
case XTYP_ADVSTOP:
if (CloseServerLink(&ddeInfo, idName))
bRes = TRUE;
break;
}
cleanup1:
requests--;
EndProtect();
}
}
}
return (HDDEDATA) bRes;
}
case XTYP_EXECUTE:
{
DWORD dwLen;
LPBYTE lpByte = DdeAccessData(hData, &dwLen);
if (lpByte)
{
BOOL bFree = FALSE;
LPBYTE lpCopy;
if (dwLen < RET_BUFFER_LEN)
{
strcpy(return_buffer, lpByte);
lpCopy = return_buffer;
}
else
{
lpCopy = strdup(lpByte);
bFree = TRUE;
}
DdeUnaccessData(hData);
if (lpCopy)
{
UnwindProtect(cleanup2);
requests++;
if (!KppEvalExpString(lpCopy))
KppPostKappaErrorMessageCB();
cleanup2:
requests--;
if (bFree)
free(lpCopy);
EndProtect();
return (HDDEDATA) DDE_FACK;
}
}
return (HDDEDATA) DDE_FNOTPROCESSED;
}
case XTYP_CONNECT:
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
char *dot = strrchr(return_buffer, '.');
if (dot)
dot[0] = '\0';
if (!stricmp(DDETopicName, return_buffer) ||
#ifdef MULTI
!stricmp(DDEKappaName, return_buffer) ||
S_ILOC == 0 &&
#endif
!stricmp("KAPPA", return_buffer))
return TRUE;
}
return (HDDEDATA) FALSE;
case XTYP_DISCONNECT:
UnwindProtect(cleanup3);
requests++;
DeleteDDETasks(hConv);
cleanup3:
requests--;
EndProtect();
return (HDDEDATA) NULL;
case XTYP_WILDCONNECT:
{
HSZPAIR hszPair[3];
hszPair[0].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[0].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDETopicName, CP_WINANSI);
hszPair[1].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[1].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDEKappaName, CP_WINANSI);
hszPair[2].hszSvc = hszPair[2].hszTopic = NULL;
return DdeCreateDataHandle(dwDDEInst, (LPVOID) hszPair,
sizeof(HSZPAIR) * 3, 0,
hszPair[0].hszSvc, CF_TEXT, 0);
}
case XTYP_POKE:
{
UINT flag = DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup4);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj && StoreData(lpIDs->idNull, hData, idObj, idSlot))
flag = DDE_FACK;
cleanup4:
requests--;
EndProtect();
}
return (HDDEDATA) flag;
}
case XTYP_REQUEST:
case XTYP_ADVREQ:
hData = (HDDEDATA) DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup5);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj)
{
BOOL bMulti = FALSE;
ITEMID idValue =
Kpp_Get_SlotAnyValue(OBJECT_TYPE(idObj),
idObj, idSlot, (LPWORD) &bMulti);
GLOBALHANDLE hMem = NULL;
LPBYTE lpBytes = NULL;
DWORD dwLen = ValueToString(idValue, bMulti,
&hMem, &lpBytes);
if (dwLen)
{
hData = DdeCreateDataHandle(dwDDEInst, lpBytes, dwLen,
0, hsz2, CF_TEXT, 0);
if (hMem)
{
GLOBALUNLOCK(hMem);
GLOBALFREE(hMem);
}
if (!hData)
hData = (HDDEDATA) DDE_FNOTPROCESSED;
}
}
cleanup5:
requests--;
EndProtect();
}
return hData;
case XTYP_REGISTER:
{
ATOMID idApp = HszToAtom(hsz2);
UnwindProtect(cleanup6);
requests++;
if (idApp)
{
WORD wType;
OBJECTID idService = KppGetObjectId(idApp, &wType);
if (!idService)
{
idService = KppMakeCO(OBJECT, idApp, idDDEService);
wType = OBJECT;
}
if (idService)
{
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
Kpp_Set_SlotValue(wType, idService, Slot(idService),
KppAddAtom(return_buffer), EXPATOM);
else
Kpp_Set_SlotValue(wType, idService, Slot(idService),
lpIDs->idNull, EXPATOM);
}
}
cleanup6:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
case XTYP_ADVDATA:
UnwindProtect(cleanup7);
requests++;
if (wFmt == CF_TEXT)
{
CONVINFO ci;
ATOMID idApp, idItem, idName;
OBJECTID idLink;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, QID_SYNC, &ci);
idApp = HszToAtom(ci.hszSvcPartner);
idItem = HszToAtom(hsz2);
idName = LinkName(idApp, idItem);
idLink = FindLink(idName);
if (idLink)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest, &wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
}
}
cleanup7:
requests--;
EndProtect();
return (HDDEDATA) DDE_FACK;
case XTYP_XACT_COMPLETE:
{
char name[20];
OBJECTID idTask;
ATOMID idName;
WORD wType;
UnwindProtect(cleanup8);
requests++;
task_name(name, hConv, dwData1);
idName = KppAddAtom(name);
idTask = KppGetObjectId(idName, &wType);
if (idTask)
{
CONVINFO ci;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, dwData1, &ci);
switch (ci.wType) {
case XTYP_REQUEST:
if (wFmt == CF_TEXT)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest,
&wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
DdeDisconnect(hConv);
}
break;
case XTYP_POKE:
case XTYP_EXECUTE:
DdeDisconnect(hConv);
break;
case (XTYP_ADVSTART | XTYPF_ACKREQ):
{
ATOMID idDest =
Kpp_Get_SlotValue(wType, idTask, Slot(idDDEObject));
WORD wDestType;
DDEINFO ddeInfo;
ddeInfo.hConv = hConv;
ddeInfo.idApp = Kpp_Get_SlotValue(wType, idTask,
Slot(idService));
ddeInfo.idTopic = Kpp_Get_SlotValue(wType, idTask,
Slot(idTopic));
ddeInfo.idItem = Kpp_Get_SlotValue(wType, idTask,
Slot(idItem));
ddeInfo.idObj = KppGetObjectId(idDest, &wDestType);
ddeInfo.idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
CreateLink(&ddeInfo);
break;
}
}
DeleteDDETask(lpIDs->idNull, wType, idTask, (LPVOID) &hConv);
}
cleanup8:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
default:
return (HDDEDATA) NULL;
}
}
