bool WdeUpdateDDEEditSession( void )
{
WdeResInfo *rinfo;
WdeResDlgItem *ditem;
HDDEDATA hdata;
bool ok;
hdata = (HDDEDATA)NULL;
ditem = WdeGetDlgItem();
ok = (WdeClientConv != (HCONV)NULL && ditem != NULL);
if( ok ) {
hdata = WdeCreateResData( ditem );
ok = (hdata != (HDDEDATA)NULL);
}
if( ok ) {
ok = DdeClientTransaction( (LPBYTE)hdata, -1, WdeClientConv,
hDataItem, WdeDataClipbdFormat,
XTYP_POKE, TIME_OUT, NULL ) != 0;
}
if( hdata != (HDDEDATA)NULL ) {
DdeFreeDataHandle( hdata );
}
if( ok ) {
hdata = WdeCreateResNameData( ditem->dialog_name, ditem->is32bit );
ok = (hdata != (HDDEDATA)NULL);
}
if( ok ) {
ok = DdeClientTransaction( (LPBYTE)hdata, -1, WdeClientConv,
hNameItem, WdeDataClipbdFormat,
XTYP_POKE, TIME_OUT, NULL ) != 0;
}
if( hdata != (HDDEDATA)NULL ) {
DdeFreeDataHandle( hdata );
}
if( ok ) {
rinfo = WdeGetCurrentRes();
WdeSetResModified( rinfo, FALSE );
}
return( ok );
}
word
pl_dde_execute(term_t handle, term_t command, term_t timeout)
{ int hdl;
char *cmdstr;
HDDEDATA Hvalue, data;
DWORD result;
long tmo;
if ( !get_conv_handle(handle, &hdl) ||
!PL_get_chars_ex(command, &cmdstr, CVT_ALL) ||
!PL_get_long_ex(timeout, &tmo) )
fail;
if ( tmo <= 0 )
tmo = TIMEOUT_VERY_LONG;
if ( !(data = DdeCreateDataHandle(ddeInst, cmdstr, strlen(cmdstr)+1,
0, 0, CF_TEXT, 0)) )
return dde_warning("dde_execute/3");
Hvalue = DdeClientTransaction((LPBYTE) data, (DWORD) -1,
conv_handle[hdl], 0L, 0,
XTYP_EXECUTE, (DWORD) tmo, &result);
if ( Hvalue )
succeed;
return dde_warning("execute");
}
/*
* IEUpdateDDEEditSession
*/
BOOL IEUpdateDDEEditSession( void )
{
img_node *node;
HDDEDATA hdata;
BOOL ok;
hdata = (HDDEDATA)NULL;
node = IEGetCurrentImageNode();
ok = (IEClientConv != (HCONV)NULL && node != NULL && EditFormat != DDENone);
if( ok ) {
hdata = IECreateResData( node );
ok = (hdata != (HDDEDATA)NULL);
}
if( ok ) {
ok = DdeClientTransaction( (LPBYTE)hdata, -1, IEClientConv, hDataItem,
IEClipFormats[EditFormat].format,
XTYP_POKE, TIME_OUT, NULL ) != 0;
}
if( hdata != (HDDEDATA)NULL ) {
DdeFreeDataHandle( hdata );
}
if( ok ) {
SetIsSaved( node->hwnd, TRUE );
}
return( ok );
} /* IEUpdateDDEEditSession */
word
pl_dde_poke(term_t handle, term_t item, term_t data, term_t timeout)
{ int hdl;
char *datastr;
HDDEDATA Hvalue;
HSZ Hitem;
long tmo;
if ( !get_conv_handle(handle, &hdl) ||
!get_hsz(item, &Hitem) )
fail;
if ( !PL_get_chars(data, &datastr, CVT_ALL) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_text, data);
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(datastr, strlen(datastr)+1,
conv_handle[hdl], Hitem, CF_TEXT,
XTYP_POKE, (DWORD)tmo, NULL);
if ( !Hvalue )
return dde_warning("poke");
succeed;
}
bool WREPokeData( HCONV conv, void *data, int size, bool retry )
{
DWORD result;
UINT err;
bool timeout;
bool ret;
UINT tries;
if( conv == (HCONV)NULL || data == NULL || size == 0 ) {
return( FALSE );
}
if( retry ) {
tries = 8;
} else {
tries = 0;
}
for( ;; ) {
ret = ( DdeClientTransaction( (LPBYTE)data, size, conv, hDataItem, CF_TEXT, XTYP_POKE, LONG_TIME_OUT, &result ) != 0 );
if( !ret && tries-- != 0 ) {
err = DdeGetLastError( IdInst );
timeout = ((err & DMLERR_POKEACKTIMEOUT) != 0);
if( !timeout ) {
break;
}
} else {
break;
}
}
return( ret );
}
JNIEXPORT jint JNICALL Java_de_walware_ecommons_io_win_DDEClient_ddeExecute(
JNIEnv* env, jclass obj, jstring server, jstring topic, jstring command)
{
// Pull unicode strings from the java arguments
const jchar *szServer = env->GetStringChars(server, 0);
const jchar *szTopic = env->GetStringChars(topic, 0);
const jchar *szCommand = env->GetStringChars(command, 0);
// Init the DDEM Library
DWORD idInst = 0;
UINT iReturn = DdeInitialize(&idInst, (PFNCALLBACK) DdeCallback,
APPCLASS_STANDARD | APPCMD_CLIENTONLY, 0 );
if (iReturn != DMLERR_NO_ERROR)
{
return 1;
}
// Connect to the DDE server
HSZ hszServer = DdeCreateStringHandle(idInst, (WCHAR*) szServer, 0);
HSZ hszTopic = DdeCreateStringHandle(idInst, (WCHAR*) szTopic, 0);
HCONV hConv = DdeConnect(idInst, hszServer, hszTopic, NULL);
// Free up some resources
DdeFreeStringHandle(idInst, hszServer);
env->ReleaseStringChars(server, szServer);
DdeFreeStringHandle(idInst, hszTopic);
env->ReleaseStringChars(topic, szTopic);
// Make sure we're connected
if (hConv == NULL)
{
DdeUninitialize(idInst);
env->ReleaseStringChars(command, szCommand);
return 2;
}
// Prepare data for transaction
HDDEDATA hData = DdeCreateDataHandle(idInst, (LPBYTE) szCommand,
(lstrlen((WCHAR*) szCommand) + 1) * sizeof(WCHAR), 0L, 0L, CF_UNICODETEXT, 0);
env->ReleaseStringChars(command, szCommand);
// Data is OK?
if (hData == NULL)
{
DdeDisconnect(hConv);
DdeUninitialize(idInst);
return 3;
}
else
{
DdeClientTransaction((LPBYTE) hData, 0xFFFFFFFF, hConv, 0L, 0,
XTYP_EXECUTE, TIMEOUT_ASYNC, NULL);
}
// Clean up
DdeDisconnect(hConv);
DdeUninitialize(idInst);
return 0;
}
void SleepyApi::Impl::Pause(bool doPause)
{
if (!m_conv)
return;
DdeClientTransaction((LPBYTE)(doPause?"pause 1":"pause 0"),7,m_conv,NULL,0,XTYP_EXECUTE,1000,NULL);
}
void DDEPoke(DWORD idInst, HCONV hConv, char* szItem, char* szData)
{
HSZ hszItem = DdeCreateStringHandle(idInst, szItem, 0);
DdeClientTransaction((LPBYTE)szData, (DWORD)(lstrlen(szData)+1),
hConv, hszItem, CF_TEXT,
XTYP_POKE, 3000, NULL);
DdeFreeStringHandle(idInst, hszItem);
}
BOOL CDDEConnection::StopAdvise(const CString& item)
{
DWORD result;
HSZ atom = DDEGetAtom(item);
return (DdeClientTransaction(NULL, 0, hConv,
atom, CF_TEXT, XTYP_ADVSTOP, 5000, &result) ? TRUE : FALSE);
}
//------DDE経由で取得------------------------------------
bool GetUrlByDDE( CString browser, CString &URL )
{
bool ret = false;
DWORD idInst = 0;
UINT result = DdeInitialize( &idInst, DdeCallback,
APPCMD_CLIENTONLY, 0L );
URL = _T("");
if ( result == DMLERR_NO_ERROR ) {
LPSTR lpszApplication = browser.GetBuffer(0);
LPSTR lpszTopic = "WWW_GetWindowInfo";
HSZ hszApplication = DdeCreateStringHandle(
idInst, lpszApplication, CP_WINANSI );
HSZ hszTopic = DdeCreateStringHandle(
idInst, lpszTopic, CP_WINANSI );
HSZ hszItem = DdeCreateStringHandle(
idInst, "-1", CP_WINANSI );
if ( hszApplication && hszTopic && hszItem ) {
HCONV hConv = DdeConnect(idInst, hszApplication, hszTopic, NULL);
if ( hConv ) {
HDDEDATA hData = DdeClientTransaction(
NULL, 0, hConv, hszItem,
CF_TEXT, XTYP_REQUEST, 1000, NULL );
if ( hData ) {
char *pStart = (char *)DdeAccessData( hData, NULL );
if ( pStart ) {
while ( *pStart++ != '"' )
;
if ( *pStart ) {
char *pEnd = pStart;
while ( *pEnd != '"' )
pEnd++;
*pEnd = NUL;
URL = pStart;
ret = true;
}
}
}
DdeDisconnect( hConv );
}
}
if ( hszItem )
DdeFreeStringHandle( idInst, hszItem );
if ( hszTopic )
DdeFreeStringHandle( idInst, hszTopic );
if ( hszApplication )
DdeFreeStringHandle( idInst, hszApplication );
DdeUninitialize( idInst );
}
return ( ret );
}
HDDEDATA DDEconversation::Execute(const char *cmd)
{
DDEstring c(cmd);
DWORD res = NULL;
HDDEDATA hData = DdeClientTransaction(NULL, 0, hConv, c, CF_TEXT, XTYP_REQUEST, 30000, &res);
if (hData == NULL)
DdeGetLastError((DWORD)DDEbase::base);
return hData;
}
BOOL CDDEConnection::Poke(const CString& item, char *data, int size, int format)
{
DWORD result;
if (size < 0)
size = strlen(data);
size ++;
HSZ item_atom = DDEGetAtom(item);
return (DdeClientTransaction((LPBYTE)data, size, hConv,
item_atom, format, XTYP_POKE, 5000, &result) ? TRUE : FALSE);
}
void DDEExecute(DWORD idInst, HCONV hConv, char* szCommand)
{
HDDEDATA hData = DdeCreateDataHandle(idInst, (LPBYTE)szCommand,
lstrlen(szCommand)+1, 0, NULL, CF_TEXT, 0);
if (hData==NULL) {
printf("Command failed: %s\n", szCommand);
}
else {
DdeClientTransaction((LPBYTE)hData, 0xFFFFFFFF, hConv, 0L, 0,
XTYP_EXECUTE, TIMEOUT_ASYNC, NULL);
}
}
/*****************************************************************
* DdeClientTransaction (DDEML.11)
*/
HDDEDATA WINAPI DdeClientTransaction16(LPVOID pData, DWORD cbData, HCONV hConv,
HSZ hszItem, UINT16 wFmt, UINT16 wType,
DWORD dwTimeout, LPDWORD pdwResult)
{
if (cbData != (DWORD)-1)
{
/* pData is not a pointer if cbData is -1, so we linearize the address
* here rather than in the calling code. */
pData = MapSL((SEGPTR)pData);
}
return DdeClientTransaction(pData, cbData, hConv, hszItem,
wFmt, wType, dwTimeout, pdwResult);
}
/***************************************************************************
DDE Exchange
****************************************************************************/
void DDEIntegratorClient::SendDebugMessage( UINT nErrLevel, char* pszMessageText )
{
if (m_hConv == NULL)
return;
static char szBuffer[256];
_itoa( nErrLevel, szBuffer, 10);
strcat( szBuffer, ":");
strcat( szBuffer, pszMessageText);
DdeClientTransaction( (UCHAR*)szBuffer, strlen(szBuffer)+1,
m_hConv, ghszDebugMessageItem,
CF_TEXT, XTYP_POKE, DDE_IDECLIENT_TIMEOUT, NULL);
}
static void take(HCONV hc, const char* name) {
if ( hc != (HCONV)NULL ){
DdeFreeStringHandle(idInst, hszItem);
sprintf(szDDEData, "%s,,0xFFFFFFFF,0x0,,", name);
hszItem = DdeCreateStringHandle ( idInst, (LPTSTR)szDDEData, CP_WINANSI );
hData = DdeClientTransaction ( NULL, 0, hc,
hszItem, wFmt, XTYP_REQUEST, 1000, &dwResult );
if (!hData) {
MessageBox(NULL, szDDEData, "WWW_OpenURL failed", MB_OK);
}
}else{
HandleOutput( "A connection to Netscape via DDE is not established." );
}
}
bool SleepyApi::Impl::IsPaused() const
{
if (!m_conv)
return false;
HDDEDATA res=DdeClientTransaction(NULL,0,m_conv,m_paused,CF_TEXT,XTYP_REQUEST,1000,NULL);
if (!res)
return false;
char help[10];
DdeGetData(res,(LPBYTE)help,sizeof(help),0);
DdeFreeDataHandle(res);
return *help!='0';
}
void DDERequest(DWORD idInst, HCONV hConv, char* szItem, char* sDesc)
{
HSZ hszItem = DdeCreateStringHandle(idInst, szItem, 0);
HDDEDATA hData = DdeClientTransaction(NULL,0,hConv,hszItem,CF_TEXT,
XTYP_ADVSTART/*XTYP_REQUEST*/, TIMEOUT_ASYNC/*5000*/ , NULL);
if (hData==NULL)
{
printf("Request failed: %s\n", szItem);
}
else
{
char szResult[255];
DdeGetData(hData, (unsigned char *)szResult, 255, 0);
printf("%s%s\n", sDesc, szResult);
}
}
JNIEXPORT jbyteArray JNICALL Java_com_google_code_jdde_ddeml_DdeAPI_ClientTransaction
(JNIEnv *env, jclass cls, jint idInst, jbyteArray jpData, jint hConv, jstring jhszItem,
jint wFmt, jint wType, jint dwTimeout, jobject $dwResult)
{
HSZ hszItem = UtilCreateStringHandle(env, idInst, jhszItem);
HDDEDATA pData = NULL;
DWORD dwResult = 0;
if (jpData != NULL) {
jsize cb = env->GetArrayLength(jpData);
jbyte *pSrc = env->GetByteArrayElements(jpData, 0);
pData = DdeCreateDataHandle(idInst, (LPBYTE) pSrc, cb, 0, hszItem, wFmt, 0);
env->ReleaseByteArrayElements(jpData, pSrc, 0);
}
HDDEDATA hddeData = DdeClientTransaction(
(LPBYTE) pData,
0xFFFFFFFF,
(HCONV) hConv,
hszItem,
wFmt,
wType,
dwTimeout,
&dwResult
);
if (pData != NULL) {
DdeFreeDataHandle(pData);
}
UtilFreeStringHandle(idInst, hszItem);
if ($dwResult != NULL) {
SetObjectInPointer(env, $dwResult, NewInteger(env, dwResult));
}
if (hddeData == NULL) {
return NULL;
}
else if (wType == XTYP_REQUEST) {
jbyteArray result = ExtractData(env, hddeData);
DdeFreeDataHandle(hddeData);
return result;
}
return env->NewByteArray(0);
}
static int exec_dde_command (const char *buf, HCONV conversation,
DWORD session)
{
HDDEDATA ret;
int err;
ret = DdeClientTransaction((LPBYTE) buf, strlen(buf) + 1,
conversation, 0, 0, XTYP_EXECUTE,
TRANSACTION_TIMEOUT, 0);
/* MSDN: "The return value is zero for all unsuccessful
transactions"
*/
err = (ret == 0);
return err;
}
void Senddde(char* tempstr)
{
try
{
//Connect to the service and request the topic
if ((hcnv = DdeConnect(idInst, hszService, hszTopic, NULL)) == 0)
{
ColorStop();
return;
}
//Start a DDE transaction
if (DdeClientTransaction((LPBYTE)tempstr, strlen(tempstr)+1,
hcnv, hszItem, CF_TEXT, XTYP_POKE, 5000, &dwResult) == 0)
{
UINT result = DdeGetLastError(idInst);
switch (result)
{
case DMLERR_ADVACKTIMEOUT:
case DMLERR_BUSY:
case DMLERR_DATAACKTIMEOUT:
case DMLERR_DLL_NOT_INITIALIZED:
case DMLERR_EXECACKTIMEOUT:
case DMLERR_INVALIDPARAMETER:
case DMLERR_MEMORY_ERROR:
case DMLERR_NO_CONV_ESTABLISHED:
case DMLERR_NO_ERROR:
case DMLERR_NOTPROCESSED:
case DMLERR_POKEACKTIMEOUT:
case DMLERR_POSTMSG_FAILED:
case DMLERR_REENTRANCY:
case DMLERR_SERVER_DIED:
case DMLERR_UNADVACKTIMEOUT:
default:
ColorStop();
}
}
//Free DDE
DdeDisconnect(hcnv);
}
catch(...)
{
ErrorHandler("Exception thrown in Senddde()!");
}
}
//--------------------
//
BOOL DDEIntegratorClient::CommandToServer( IDE_COMMAND iCommand, char* pszParams )
{
char szCommand[512];
_itoa( (int)iCommand, szCommand, 10);
strcat( szCommand, " ");
if ( pszParams )
strcat( szCommand, pszParams );
HDDEDATA hData = DdeCreateDataHandle( gDDEClientId,
(UCHAR*)szCommand, strlen(szCommand)+1,
0L, ghszCommandItem, CF_TEXT, 0);
if ( hData )
HDDEDATA hDataT= DdeClientTransaction( (UCHAR*)hData, (ULONG)-1L,
m_hConv, ghszCommandItem, CF_TEXT,
XTYP_POKE, DDE_IDECLIENT_TIMEOUT, NULL);
return (BOOL)hData;
}
/***************************************************************************
* *
* FUNCTION : ProcessTransaction() taken from ddeml sample app *
* *
* PURPOSE : Processes synchronous transactions entirely and starts *
* async transactions. Pass in the handle to the URL string. *
* *
* RETURNS : TRUE - If successful. *
* FALSE - otherwise. *
* *
****************************************************************************/
URLProcessorRetCode CConv::ProcessTransaction(DWORD idInst,HSZ hszItem)
{
HWND hwndInfoCtrl = 0;
/*
* Disable callbacks for this conversation now if the XOPT_DISABLEFIRST
* option is set. This tests disabling asynchronous transactions
* before they are completed.
*/
if (fsOptions & XOPT_DISABLEFIRST)
DdeEnableCallback(idInst, hConv, EC_DISABLE);
/*
* Adjust the timeout for asynchronous transactions.
*/
if (fsOptions & XOPT_ASYNC)
ulTimeout = (DWORD)TIMEOUT_ASYNC;
/*
* start transaction with DDEML here
*/
//note: for future use, pass in value for first parameter to retrieve data from transaction.
// ** Future DDE may not support Result Parameter **
ret = DdeClientTransaction(NULL, (DWORD)-1,hConv, hszItem, wFmt,wType,
ulTimeout, (LPDWORD)&Result);
//UINT Error = DdeGetLastError(idInst);
if(!ret)
return enURLErrorDdeProcessTrans;//use DdeGetLastError(idInst) to get more details.
else if (fsOptions & XOPT_ASYNC)
{
/*
* asynchronous successful start - link transaction to window.
*/
//DdeSetUserHandle(hConv, Result, (DWORD)hwndInfoCtrl);
/*
* Abandon started async transaction after initiated if
* XOPT_ABANDONAFTERSTART is chosen. This tests the mid-transaction
* abandoning code.
*/
if (fsOptions & XOPT_ABANDONAFTERSTART)
DdeAbandonTransaction(idInst, hConv, Result);
}
return enURLErrorNone;
}
BOOL CDDEConnection::Execute(char *data, int size, int format)
{
DWORD result;
if (size < 0)
size = strlen(data);
size ++;
HDDEDATA rt = DdeClientTransaction((LPBYTE)data, size, hConv,
NULL, format, XTYP_EXECUTE, 5000, &result);
if (!rt)
{
/*if (bDisconnected)
return TRUE;*/
printf("Warning: DDE result is 0x%x\n", DdeGetLastError(DDEIdInst));
printf("Failed to exe cmd: %s\n", data);
}
return (rt ? TRUE : FALSE);
}
void DDEExecute(const WCHAR* server, const WCHAR* topic, const WCHAR* command)
{
unsigned long inst = 0;
HSZ hszServer = NULL, hszTopic = NULL;
HCONV hconv = NULL;
HDDEDATA hddedata = NULL;
#ifdef _WIN64
CrashIf(str::Len(command) >= (DWORD)-1);
if (str::Len(command) >= (DWORD)-1)
return;
#endif
UINT result = DdeInitialize(&inst, &DdeCallback, APPCMD_CLIENTONLY, 0);
if (result != DMLERR_NO_ERROR)
goto Exit;
hszServer = DdeCreateStringHandle(inst, server, CP_WINNEUTRAL);
if (!hszServer)
goto Exit;
hszTopic = DdeCreateStringHandle(inst, topic, CP_WINNEUTRAL);
if (!hszTopic)
goto Exit;
hconv = DdeConnect(inst, hszServer, hszTopic, 0);
if (!hconv)
goto Exit;
DWORD cbLen = ((DWORD)str::Len(command) + 1) * sizeof(WCHAR);
hddedata = DdeCreateDataHandle(inst, (BYTE*)command, cbLen, 0, 0, CF_UNICODETEXT, 0);
if (!hddedata)
goto Exit;
HDDEDATA answer = DdeClientTransaction((BYTE*)hddedata, (DWORD)-1, hconv, 0, 0, XTYP_EXECUTE, 10000, 0);
if (answer)
DdeFreeDataHandle(answer);
Exit:
if (hddedata)
DdeFreeDataHandle(hddedata);
if (hconv)
DdeDisconnect(hconv);
if (hszTopic)
DdeFreeStringHandle(inst, hszTopic);
if (hszServer)
DdeFreeStringHandle(inst, hszServer);
DdeUninitialize(inst);
}
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);
}
}
char doRequest( char *szCommand )
{
HDDEDATA hddeData;
HSZ hszCommand;
BYTE result;
hszCommand = DdeCreateStringHandle( idInstance, szCommand, CP_WINANSI );
hddeData = DdeClientTransaction( NULL, 0, hConv, hszCommand, CF_TEXT,
XTYP_REQUEST, 500000, NULL );
DdeFreeStringHandle( idInstance, hszCommand );
if( hddeData != (HDDEDATA)NULL ) {
DdeGetData( hddeData, &result, 1, 0 );
DdeFreeDataHandle( hddeData );
return( result );
}
return( 0 );
}
bool DDEExecute(const WCHAR* server, const WCHAR* topic, const WCHAR* command)
{
DWORD inst = 0;
HSZ hszServer = NULL, hszTopic = NULL;
HCONV hconv = NULL;
bool ok = false;
CrashIf(str::Len(command) >= INT_MAX - 1);
if (str::Len(command) >= INT_MAX - 1)
return false;
UINT result = DdeInitialize(&inst, DdeCallback, APPCMD_CLIENTONLY, 0);
if (result != DMLERR_NO_ERROR)
return false;
hszServer = DdeCreateStringHandle(inst, server, CP_WINNEUTRAL);
if (!hszServer)
goto Exit;
hszTopic = DdeCreateStringHandle(inst, topic, CP_WINNEUTRAL);
if (!hszTopic)
goto Exit;
hconv = DdeConnect(inst, hszServer, hszTopic, NULL);
if (!hconv)
goto Exit;
DWORD cbLen = ((DWORD)str::Len(command) + 1) * sizeof(WCHAR);
HDDEDATA answer = DdeClientTransaction((BYTE *)command, cbLen, hconv, 0, CF_UNICODETEXT, XTYP_EXECUTE, 10000, NULL);
if (answer) {
DdeFreeDataHandle(answer);
ok = true;
}
Exit:
if (hconv)
DdeDisconnect(hconv);
if (hszTopic)
DdeFreeStringHandle(inst, hszTopic);
if (hszServer)
DdeFreeStringHandle(inst, hszServer);
DdeUninitialize(inst);
return ok;
}
char *CDDEConnection::Request(const CString& item, int *size, int format)
{
DWORD result;
HSZ atom = DDEGetAtom(item);
HDDEDATA returned_data = DdeClientTransaction(NULL, 0, hConv,
atom, format, XTYP_REQUEST, 5000, &result);
DWORD len = DdeGetData(returned_data, (LPBYTE)(buf_ptr), buf_size, 0);
DdeFreeDataHandle(returned_data);
if (size) *size = (int)len;
if (len > 0)
{
return buf_ptr;
}
else return NULL;
}
bool gcDDEConnection::poke(const char* item, const char* data)
{
DWORD result;
HSZ item_atom = GetDDEManager()->atomFromString(item);
char fdata[255];
Safe::snprintf(fdata, 255, "%s\r\n\0", data);
size_t size = strlen(fdata);
HDDEDATA res = DdeClientTransaction((LPBYTE)fdata, size, m_hConv, item_atom, CF_TEXT, XTYP_POKE, DDE_TIMEOUT, &result);
bool ok = res?true:false;
if ( !ok )
{
printf("DDE poke request failed");
}
return ok;
}
