path: root/private/ole32/com/dde/server/doc.cxx

/***************************************************************************\
* Module Name: Doc.c Document Main module
*
* Purpose: Includes All the document level object communication related.
*
* Created: Oct 1990.
*
* Copyright (c) 1990, 1991  Microsoft Corporation
*
* History:
*    Raor (../10/1990)    Designed, coded (modified for 2.0)
*
\***************************************************************************/

#include "ole2int.h"
//#include "cmacs.h"
#include <dde.h>

#include "srvr.h"
#include "ddedebug.h"
#include "valid.h"
ASSERTDATA

extern  ATOM     aStdClose;
extern  ATOM     aStdShowItem;
extern  ATOM     aStdDoVerbItem;
extern  ATOM     aStdDocName;
extern  ATOM     aTrue;
extern  ATOM     aFalse;

extern  HANDLE   hddeRename;
extern  HWND     hwndRename;

#ifdef _CHICAGO_
#define szDDEViewObj "DDE ViewObj"
#else
#define szDDEViewObj L"DDE ViewObj"
#endif


// HRESULT DdeHandleIncomingCall(HWND hwndCli, WORD wCallType);

//
// Call CoHandleIncomingCall which will call the message filter
// Note: only call this functions with:
//  -  CALLTYPE_TOPLEVEL  ... for synchranous calls
//  -  CALLTYPE_ASYNC     ... for async calls
//
HRESULT DdeHandleIncomingCall(HWND hwndCli, WORD wCallType)
{

    Assert(!"DdeHandleIncomingCall not implemented");

    return(RPC_E_CALL_REJECTED);

    // Review: bug: get the correcr hwnd
    switch ( /* CoHandleIncomingCall(hwndCli, wCallType, NULL) */ wCallType) {
    default:
    case SERVERCALL_ISHANDLED:  // call can be proccesed
	return NOERROR;

    case SERVERCALL_REJECTED:       // call rejected
	return  ResultFromScode(RPC_E_CALL_REJECTED);

    case SERVERCALL_RETRYLATER: // call should be retried later
	return  ResultFromScode(RPC_E_DDE_BUSY);
    }
}


INTERNAL CDefClient::Create
(
    LPSRVR      lhOLESERVER,
    LPUNKNOWN   lpunkObj,
    LPOLESTR       lpdocName,
    const BOOL  fSetClientSite,
    const BOOL  fDoAdvise,
    const BOOL  fRunningInSDI,  // optional
    HWND FAR*   phwnd   	// optional
)
{
    LPSRVR      lpsrvr   = NULL;
    LPCLIENT    lpclient = NULL;
    HANDLE      hclient  = NULL;
    HRESULT     hresult  = NOERROR;

    intrDebugOut((DEB_ITRACE,
		  "0 _IN CDefClient::Create(lpsrvr=%x,lpdocName=%ws)\n",
		  lhOLESERVER,WIDECHECK(lpdocName)));

    // REVIEW: server's termination has already started. Are
    // we going to see this condition in the synchronous mode.
    lpsrvr = (LPSRVR)lhOLESERVER;
    if (lpsrvr && lpsrvr->m_bTerminate)
    {
	Assert(0);
	return ReportResult(0, RPC_E_DDE_REVOKE, 0, 0);
    }

#ifdef FIREWALLS
    PROBE_READ(lpunkObj);
    PROBE_READ(lpmkObj);
    PROBE_WRITE(lplhobj);
#endif

    lpclient = new CDefClient (/*pUnkOuter==*/NULL);;

    Assert(lpclient->m_pUnkOuter);

    lpclient->m_aItem         = wGlobalAddAtom (/*lpszObjName*/lpdocName);
    lpclient->m_fRunningInSDI = fRunningInSDI;
    lpclient->m_psrvrParent   = lpsrvr;
    // A doc has itself as its containing document
    lpclient->m_pdoc          = lpclient;

    ErrRtnH (lpunkObj->QueryInterface (IID_IOleObject,
					(LPLPVOID) &lpclient->m_lpoleObj));

    ErrRtnH (lpunkObj->QueryInterface (IID_IDataObject,
					(LPLPVOID) &lpclient->m_lpdataObj));

    // Lock object; do after the QI so that ReleaseObjPtrs will unlock correctly
    lpclient->m_fLocked =
		(NOERROR==CoLockObjectExternal (lpunkObj, TRUE, /*dont care*/ FALSE));

    if (!(lpclient->m_hwnd = DdeCreateWindowEx(0, gOleWindowClass,szDDEViewObj,
	  WS_CHILD,0,0,0,0,lpsrvr->m_hwnd,NULL, g_hinst, NULL)))
    {
	intrDebugOut((DEB_ITRACE,"CDefClient::Create() couldn't create window\n"));
	goto errRtn;
    }

    // fix up the WindowProc entry point.
    SetWindowLong(lpclient->m_hwnd, GWL_WNDPROC, (LONG)DocWndProc);

    if (fDoAdvise)
    {
	// This is for Packager, in particular, and manual links.
	// If client does not advise on any data, we still need
	// to do an OLE advise so we can get OnClose notifications.
	ErrRtnH (lpclient->DoOle20Advise (OLE_CLOSED, (CLIPFORMAT)0));
    }

    intrDebugOut((DEB_ITRACE,"  Doc window %x created\n",lpclient->m_hwnd));

    // Set out parm (window)
    if (phwnd != NULL)
    {
	*phwnd = lpclient->m_hwnd;
    }

    if (fSetClientSite)
    {
	// Should not set the client site if the object has not been
	// initialized yet, by BindMoniker (i.e. PersistFile::Load)
	// or PersistStorage::Load
	if (lpclient->SetClientSite() != NOERROR)
	{
	    goto errRtn;
	}
    }

    Putsi(lpclient->m_cRef);

    SetWindowLong (lpclient->m_hwnd, 0, (LONG)lpclient);
    SetWindowWord (lpclient->m_hwnd, WW_LE, WC_LE);
    SetWindowLong (lpclient->m_hwnd,WW_HANDLE,
		   (GetWindowLong (lpsrvr->m_hwnd, WW_HANDLE)));

    hresult = NOERROR;

exitRtn:

    intrDebugOut((DEB_ITRACE,
		  "0 _OUT CDefClient::Create(lpsrvr=%x,lpdocName=%ws) hr=%x\n",
		  lhOLESERVER,
		  WIDECHECK(lpdocName),
		  hresult));


    return(hresult);
errRtn:
    intrDebugOut((DEB_ITRACE,"CDefClient::Create() in error handling routine\n"));
    if (lpclient)
    {
	if (lpclient->m_hwnd)
            SSDestroyWindow (lpclient->m_hwnd);

	if (lpclient->m_aItem)
	    GlobalDeleteAtom (lpclient->m_aItem);
	delete lpclient;
    }
    hresult = E_OUTOFMEMORY;
    goto exitRtn;
}



INTERNAL CDefClient::Revoke (BOOL fRelease)
{
    Puts ("DefClient::Revoke "); Puth(this); Puta(m_aItem); Putn();

    ChkC(this);


    ReleaseObjPtrs();

    // We are done with this CDefClient but someone may still have a reference
    // to an instance of one of our nested classes.  In particular, an advise
    // holder may be holding on to our sink, or an item may have a pointer
    // to us if we are its parent document.  So we cannot actually do a
    // "delete this".
    // The corresponding AddRef is in CDefClient::Create
    // or CDefClient::RegisterItem

    m_pUnkOuter->Release();

    Puts ("DefClient::Revoke done\r\n");
    return NOERROR;
}



INTERNAL CDefClient::ReleaseObjPtrs
    (void)
{
    intrDebugOut((DEB_ITRACE,
		  "%p _IN CDefClient::ReleaseObjPtrs\n",
		  this));
		
    ULONG ulResult;

    if (m_lpoleObj && m_fLocked)
    {
	// Unlock object.  Set m_fLocked to FALSE first to prevent reentrant
	// problems (unlock causes close which causes this routine to be called)

		m_fLocked = FALSE;
		CoLockObjectExternal(m_lpoleObj, FALSE, TRUE);
    }
    if (m_lpoleObj)
    {
	if (m_fDidSetClientSite)
	    m_lpoleObj->SetClientSite(NULL);
	DoOle20UnAdviseAll();
	Assert (m_lpoleObj);
	if (m_lpoleObj)
	{
	    ulResult = m_lpoleObj->Release();	
	    m_lpoleObj = NULL;
	}
	intrDebugOut((DEB_ITRACE,
		      "%p _OUT ::ReleaseObjPtrs lpoleObj ulResult=%x\n",
			      this,ulResult));
    }
    if (m_lpdataObj)
    {
	// Must do it this way because the Release can cause recursion
	LPDATAOBJECT pdata = m_lpdataObj;
	m_lpdataObj = NULL;
	ulResult = pdata->Release();
	intrDebugOut((DEB_ITRACE,
		      "%p _OUT ::ReleaseObjPtrs pdata ulResult=%x\n",
		      this,ulResult));
    }

    intrDebugOut((DEB_ITRACE,
		  "%p _OUT CDefClient::ReleaseObjPtrs\n",
		  this));
    return NOERROR;
}
#if 000
//RevokeAllDocs : revokes all the doc objects attached to a given
//server.

INTERNAL_(HRESULT) CDDEServer::RevokeAllDocObjs ()
{

    HWND    hwnd;
    HWND    hwndnext;
    LPCLIENT    lpclient;
    Puts ("RevokeAllDocObjs\r\n");
    ChkS(this);

    hwnd = GetWindow (m_hwnd, GW_CHILD);

    // Go thru each of the child windows and revoke the corresponding
    // document. Doc windows are child windows for the server window.

    while (hwnd){
	// sequence is important
	hwndnext = GetWindow (hwnd, GW_HWNDNEXT);
	lpclient = ((LPCLIENT)GetWindowLong (hwnd, 0));
	lpclient->Revoke();
	hwnd =  hwndnext;
    }
    return NOERROR;
}
#endif

// FindDoc: Given a doc obj, searches for the doc obj
// in the given class factory tree. returns true if the
// doc obj is available.


INTERNAL_(LPCLIENT)  CDDEServer::FindDocObj
(
LPSTR   lpdocname
)
{
    ATOM	aItem;
    HWND	hwnd;
    LPCLIENT    lpclient;

    ChkS(this);
    aItem = (ATOM)GlobalFindAtomA (lpdocname);
    Assert (IsWindowValid (m_hwnd));
    hwnd = GetWindow (m_hwnd, GW_CHILD);
    Assert (NULL==hwnd || IsWindowValid (hwnd));

    while (hwnd)
    {
	lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);
	if (lpclient->m_aItem == aItem)
	{
	    intrDebugOut((DEB_ITRACE,
		          "FindDocObj found %s lpclient=%x\n",
			  lpdocname,
			  lpclient));
	    return lpclient;
	}
	hwnd = GetWindow (hwnd, GW_HWNDNEXT);
    }
    return NULL;
}

BOOL PostAckToClient(HWND hwndClient,HWND hwndServer,ATOM aItem,DWORD retval)
{
    HRESULT hr = TRUE;
    intrDebugOut((DEB_ITRACE,
		  "0 _IN PostAckToClient(hwndClient=%x,hwndServer=%x,aItem=%x(%ws)\n",
		  hwndClient,
		  hwndServer,
		  aItem,
		  wAtomName(aItem)));

    DWORD status = 0;
    SET_MSG_STATUS (retval, status);

    LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_ACK,status,aItem);

    if (!PostMessageToClient (hwndClient,
			      WM_DDE_ACK,
			      (UINT)hwndServer,
			      lp))
    {
		DDEFREE(WM_DDE_ACK,lp);
		hr = FALSE;
    }
    intrDebugOut((DEB_ITRACE,
		  "0 _OUT PostAckToClient returns %x\n",
		  hr));

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   DocHandleIncomingCall
//
//  Synopsis:	Setup and call the CallControl to dispatch a call to the doc
//
//  Effects:    A call has been made from the client that requires us to call
//		into our server. This must be routed through the call control.
//		This routine sets up the appropriate data structures, and
//		calls into the CallControl. The CallControl will in turn
//		call DocDispatchIncomingCall to actually process the call.
//
//		This routine should only be called by the DocWndProc
//
//
//  Arguments:  [pDocData] -- Points to DOCDISPATCHDATA for this call
//			      This contains all required information for
//			      handling the message.
//
//  Requires:
//
//  Returns:	If an error is returned, it is assumed that the Dispatch
//		routine was not reached. DocDispatchIncomingCall() should
//		not be returning an error.
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    6-05-94   kevinro Commented/cleaned
//
//  Notes:
//
//  This is a co-routine with DocDispatchIncomingCall. See that routine
//  for more details
//
//----------------------------------------------------------------------------
INTERNAL DocHandleIncomingCall(PDOCDISPATCHDATA pDocData)
{
    HRESULT hresult = NOERROR;
    DISPATCHDATA dispatchdata;
    DWORD callcat;

    intrAssert(pDocData != NULL);

    intrDebugOut((DEB_ITRACE,
		  "0 _IN DocHandleIncomingCall lpclient=%x pDocData=%x\n",
		  pDocData->lpclient,
		  pDocData));

    //
    // TERMINATE messages must always be handled ASYNC, and cannot
    // be rejected.
    //
    if (pDocData->msg == WM_DDE_TERMINATE)
    {
	callcat = CALLCAT_ASYNC;
    }
    else
    {
	callcat = CALLCAT_SYNCHRONOUS;
    }

    dispatchdata.pData = (LPVOID) pDocData;
    pDocData->wDispFunc = DDE_DISP_DOCWNDPROC;

    RPCOLEMESSAGE	 rpcMsg;
    RPC_SERVER_INTERFACE RpcInterfaceInfo;
    DWORD		 dwFault;

    rpcMsg.iMethod = 0;
    rpcMsg.Buffer = &dispatchdata;
    rpcMsg.cbBuffer = sizeof(dispatchdata);
    rpcMsg.reserved2[1] = &RpcInterfaceInfo;
    *MSG_TO_IIDPTR(&rpcMsg) = GUID_NULL;


    IRpcStubBuffer * pStub = &(pDocData->lpclient->m_pCallMgr);
    IRpcChannelBuffer * pChannel = &(pDocData->lpclient->m_pCallMgr);
    hresult = STAInvoke(&rpcMsg, callcat, pStub, pChannel, NULL, &dwFault);

    intrDebugOut((DEB_ITRACE,
		  "0 _OUT DocHandleIncomingCall hresult=%x\n",
		  hresult));

    return(hresult);
}

//+---------------------------------------------------------------------------
//
//  Function:   DocDispatchIncomingCall
//
//  Synopsis:   Dispatch a call into the client.
//
//  Effects:	This is a co-routine to DocHandleIncomingCall. This routine
//		is called to implement functions that call into the CDefClient
//		object. It is dispatched by the call control stuff, and helps
//		to insure the server is ready to accept these calls.
//
//		This routine is coded as a continuation of the DocWndProc.
//		There is a switch on the message. Each message does slightly
//		different things. The code to handle each message was snatched
//		from the original DocWndProc, before it was converted to the
//		new call control mechanism.
//		
//
//  Arguments:  [pDocData] --	Points to Doc Dispatch Data, which are the
//				parameters to DocWndProc which need processing
//
//  Requires:
//		pDocData cannot be NULL
//
//  Returns:
//		This routine will always return NOERROR. There are no useful
//		error returns to be made from here. If you decide to return
//		an error, check the DocHandleIncomingCall and DocWndProc to be
//		sure the error paths are correctly handled. Some of the
//		cases do additional error processing in the DocWndProc on
//		error.
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    6-05-94   kevinro Commented/cleaned
//
//  Notes:
//
//----------------------------------------------------------------------------
INTERNAL DocDispatchIncomingCall(PDOCDISPATCHDATA pDocData)
{
    LPCLIENT    	lpclient = pDocData->lpclient;
    BOOL		fack;
    HANDLE      	hdata =  pDocData->hdata;
    ATOM		aItem =  pDocData->aItem;
    WPARAM		wParam = pDocData->wParam;
    HWND		hwnd = 	 pDocData->hwnd;
    HRESULT     	retval;



    intrDebugOut((DEB_ITRACE,
		  "0 _IN DocDispatchIncomingCall pDocData(%x)\n",
		  pDocData));

    intrAssert(pDocData);

    //
    // This switch statement is intended to continue the functionality found
    // in the DocWndProc. These routines are directly interrelated to the
    // same cases in DocWndProc, and need special care before changing.
    //
    switch (pDocData->msg)
    {
    case WM_DDE_TERMINATE:
	{
	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_TERMINATE hwnd=%x \n",
			  pDocData->hwnd));

	    //
	    // Here is a fine hack for you. 32-bit applications appear to shut
	    // down slightly differently than 16-bit applications. There is a
	    // problem with Lotus Notes interacting with 32-bit OFFICE apps.
	    // When notes has done an OleCreateFromFile, it starts the
	    // 32-bit hidden, and does a normal DDE conversation. However,
	    // on termination, the 32-bit Doc Window was going away during
	    // this routine. Since the world is now multi-tasking, Lotus
	    // Notes was seeing its server window die because we get
	    // pre-empted during DeleteItemsFromList giving the 16-bit app a
	    // chance to run. Since Lotus is in the
	    // standard OleQueryReleaseStatus() loop, it will detect that the
	    // server has shutdown BEFORE it gets the terminate message.
	    // Go figure. So, insure that we post the reply DDE_TERMINATE
	    // before destroying our window, or the 16-bit applications
	    // won't like us.
	    //
	    PostMessageToClient ((HWND)wParam, WM_DDE_TERMINATE,
			    (UINT) hwnd, NULL);

	    // Client initiated the termination. So, we should remove
	    // his window from any of our doc or items' lists.
	    lpclient->DeleteFromItemsList ((HWND)wParam
					    /*, lpclient->m_fEmbed*/);

	    ChkC (lpclient);


	    // REVIEW: If the termination is sent from the client side,
	    // lpoleObj will not be NULL.
	    if (lpclient->m_cClients == 0 && lpclient->m_fEmbed)
	    {
		Assert (lpclient->m_chk==chkDefClient);
		lpclient->ReleaseAllItems ();
		Assert (lpclient->m_chk==chkDefClient);
		Assert (NULL==lpclient->m_lpoleObj &&
			NULL==lpclient->m_lpdataObj) ;

	    }
	    break;
	}

    case WM_DDE_EXECUTE:
	{

	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_EXECUTE hwnd=%x hdata=%x\n",
			  pDocData->hwnd,
			  pDocData->hdata));

            //
	    // The following state variables appear to be used by
	    // the execute code.
	    //
	    lpclient->m_ExecuteAck.f        = TRUE;  // assume we will need to
	    lpclient->m_ExecuteAck.hdata    = hdata;
	    lpclient->m_ExecuteAck.hwndFrom = (HWND)wParam;
	    lpclient->m_ExecuteAck.hwndTo   = hwnd;

	    //
	    // In the event that the command is a StdClose, we need
	    // to force the client to stay around for the duration of
	    // the call.
	    //
	    lpclient->m_pUnkOuter->AddRef();

	    retval = lpclient->DocExecute (hdata);

	    if (lpclient->m_ExecuteAck.f)
	    {
		lpclient->SendExecuteAck (retval);
	    }

	    lpclient->m_pUnkOuter->Release();
	    break;

	}
    case WM_DDE_POKE:
	{
	    int iStdItem;
	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_POKE hwnd=%x aItem=%x(%ws) hdata=%x\n",
			  hwnd,
			  aItem,
			  wAtomName(aItem),
			  hdata));

	    if (iStdItem = GetStdItemIndex (aItem))
	    {
		retval = lpclient->PokeStdItems ((HWND)wParam,
						 aItem,
						 hdata,
						 iStdItem);
	    }
	    else
	    {
		retval = lpclient->PokeData ((HWND)wParam,
					     aItem,
					     hdata);
		    // This is allowed to fail.  PowerPoint tries to poke
		    // data with cfFormat=="StdSave" and "StdFont"
	    }

	    if (!PostAckToClient((HWND)wParam,hwnd,aItem,retval))
	    {
		goto errRtn;
	    }
	    break;
	}
    case WM_DDE_ADVISE:
	{
	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_ADVISE hwnd=%x aItem=%x(%ws) hdata=%x\n",
			  hwnd,
			  aItem,
			  wAtomName(aItem),
			  hdata));

	    if (IsAdviseStdItems (aItem))
	    {
		retval = lpclient->AdviseStdItems ((HWND)wParam,
						   aItem,
						   hdata,
						   (BOOL FAR *)&fack);
	    }
	    else
	    {
		retval = lpclient->AdviseData ((HWND)wParam,
					       aItem,
					       hdata,
					       (BOOL FAR *)&fack);
	    }

            if (fack)
	    {
		if (!PostAckToClient((HWND)wParam,hwnd,aItem,retval))
		{
		    GlobalFree(hdata);
		}
            }
            else if (aItem != NULL)
	    {
                GlobalDeleteAtom (aItem);
	    }
	    break;
	}
    case WM_DDE_UNADVISE:
	{
	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_UNADVISE hwnd=%x aItem=%x(%ws)\n",
			  hwnd,
			  aItem,
			  wAtomName(aItem)));

	    retval = lpclient->UnAdviseData ((HWND)wParam, aItem);

	    if (!PostAckToClient((HWND)wParam,hwnd,aItem,retval))
	    {
		goto errRtn;
	    }
	    break;
	}
    case WM_DDE_REQUEST:
	{
	    intrDebugOut((DEB_ITRACE,
			  "DDIC: WM_DDE_REQUEST hwnd=%x aItem=%x(%ws) cfFormat=%x\n",
			  hwnd,
			  aItem,
			  wAtomName(aItem),
			  (USHORT)LOWORD(pDocData->lParam)));

	    retval = lpclient->RequestData ((HWND)wParam,
					    aItem,
					    LOWORD(pDocData->lParam),
					    (HANDLE FAR *)&hdata);

	    if (retval == NOERROR)
	    {
		// post the data message and we are not asking for any
		// acknowledge.

		intrDebugOut((DEB_ITRACE,
			      "DDIC: posting WM_DDE_DATA\n"));
	
		LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_DATA,hdata,aItem);
		if (!PostMessageToClient ((HWND)wParam, WM_DDE_DATA, (UINT) hwnd,lp))
		{
		    // hdata will be freed by the client because fRelease
		    // was set to true by MakeDdeData (called by RequestData)

		    DDEFREE(WM_DDE_DATA,lp);
		    goto errRtn;
		}
	    }
	    else
	    {
		if (!PostAckToClient((HWND)wParam,hwnd,aItem,retval))
		{
		    goto errRtn;
		}
    	    }
	    break;
	}
    default:
	//
	// Whoops, this is very bad. We should never get here.
	//
	intrAssert(!"Unknown MSG in DocWndProc: Very Bad indeed");


    }

exitRtn:
    intrDebugOut((DEB_ITRACE,
		  "0 _OUT DocDispatchIncomingCall pDocData(%x) hr = 0\n",
		  pDocData));

    return(NOERROR);
errRtn:
    intrDebugOut((DEB_IERROR,
		  "***** ERROR DDIC pDocData(%x) Post ACK failed. \n",
		  pDocData));

    if (aItem != NULL)
    {
	GlobalDeleteAtom (aItem);
    }
    goto exitRtn;
}


//+---------------------------------------------------------------------------
//
//  Function:   DocWndProc
//
//  Synopsis:   Document Window Procedure
//
//  Effects:    Processes DDE messages for a document window.
//
//  Arguments:  [hwnd] --
//		[msg] --
//		[wParam] --
//		[lParam] --
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    6-05-94   kevinro Commented/cleaned
//
//  Notes:
//
//  When running in a VDM, it is possible that this window was dispatched
//  without having a full window handle. This happens when the getmessage
//  was dispatched from 16-bit. Therefore, we need to convert the hwnd to
//  a full hwnd before doing any comparision functions.
//
//----------------------------------------------------------------------------
STDAPI_(LRESULT) DocWndProc (
HWND        hwndIn,
UINT        msg,
WPARAM      wParam,
LPARAM      lParam
)
{

    //
    // Since this is the DocWndProc, we aren't going to initialize
    // any of the local variables. This function is called as a WNDPROC,
    // which is pretty often.
    //

    DOCDISPATCHDATA	docData;
    LPCLIENT    	lpclient;
    WORD		status=0;
    HANDLE      	hdata;
    ATOM		aItem;
    HRESULT     	retval;
    LPOLEOBJECT 	lpoleObj;
    HWND		hwnd;
    DebugOnly (HWND     hwndClient;)

    // REVIEW: We need to take care of the bug, related to
    // Excel. Excel does the sys level connection and sends
    // terminates immediately before making the connection
    // to the doc level. If we send release to classfactory
    // app may revoke the classfactory.


    // REVIEW: It may not be necessary to do the blocking.
    // ReVIEW: For fixing the ref count right way for
    // CreateInstance Vs. WM_DDE_INIT

#ifdef  LATER
    if (AddMessage (hwnd, msg, wParam, lParam, WT_DOC))
	return 0L;
#endif

    switch (msg){

    case WM_CREATE:
	intrDebugOut((DEB_ITRACE,
		      "DocWndProc: CreateWindow hwndIn=%x\n",
		      hwndIn));
	    break;


    case WM_DDE_INITIATE:
	hwnd = ConvertToFullHWND(hwndIn);
	intrAssert(IsWindowValid(hwnd));
	lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);

	intrDebugOut((DEB_ITRACE,
		      "DocWndProc: WM_DDE_INITIATE hwnd=%x\n",
		      hwnd));

        ChkC(lpclient);


	// REVIEW: We may not allow  initiates to get thru
        // while we are waiting for terminates. So, this case
        // may not arise

        // Need to verify that m_pCI is not NULL during incoming
	// calls from the client.
	//
	if (lpclient->m_fCallData)
	{
	    intrDebugOut((DEB_ITRACE,
		"DocWndProc: No initiates while waiting on terminate\n"));
		
                break;
        }
	// if we are the document then respond.

	if (! (lpclient->m_aItem == (ATOM)(HIWORD(lParam))))
	{
		break;
	}

	// We can enterain this client. Put this window in the client list
	// and acknowledge the initiate.

	if (!AddClient ((LPHANDLE)&lpclient->m_hcli, (HWND)wParam, (HWND)wParam))
	{
		break;
	}


	// post the acknowledge
	DuplicateAtom (LOWORD(lParam));
	DuplicateAtom (HIWORD(lParam));
	SSSendMessage ((HWND)wParam, WM_DDE_ACK, (WPARAM)hwnd, lParam);

	lpclient->m_cClients++;
	lpclient->m_fCreatedNotConnected = FALSE;
	lpoleObj = lpclient->m_lpoleObj;

	// we have added an addref because of createinstance.

	if (lpclient->m_bCreateInst)
	{
	    lpclient->m_bCreateInst = FALSE;
	}

	return 1L; // fAckSent
	break;


    case WM_DDE_EXECUTE:
       {
	    hwnd = ConvertToFullHWND(hwndIn);
	    intrAssert(IsWindowValid(hwnd));
	    lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);

	    hdata = GET_WM_DDE_EXECUTE_HDATA(wParam,lParam);
	    intrDebugOut((DEB_ITRACE,
			  "DocWndProc: WM_DDE_EXECUTE hwnd=%x hdata=%x\n",
			  hwnd,
			  hdata));

	    ChkC(lpclient);

#ifdef  FIREWALLS
	    // find the client in the client list.
	    hwndClient = FindClient (lpclient->m_hcli, (HWND)wParam, FALSE);
	    AssertSz (hwndClient, "Client is missing from the server");
#endif
	    if (!IsWindowValid	((HWND)wParam) || lpclient->m_fCallData)
	    {
		if (lpclient->m_fCallData)
		{
		    // This means the terminate has already been sent
		    // to this window (from AdviseSink::OnClose) so
		    // we can ignore the StdCloseDocument.
                }
		else
		{
		    intrAssert(!"Execute received from dead sending window");
		}
		// Since we are not sending an ACK, the sender will not
		// have the chance to free the hCommands handle.
                DDEFREE(WM_DDE_ACK,lParam);
		// GlobalFree (hdata);
                break;
	    }

	    //
	    // Fill in the used items in DocData
	    //
	    docData.hwnd = hwnd;
	    docData.msg = msg;
	    docData.wParam = wParam;
	    docData.hdata = hdata;
	    docData.lpclient = lpclient;

	    retval = DocHandleIncomingCall(&docData);

	    //
	    // If error return, then we didn't call DocDispatchIncomingCall
	    // and therefore need to send a NACK
	    //
	    if (retval != NOERROR)
	    {
		lpclient->SendExecuteAck (retval);
	    }
	    break;
       }
       case WM_DDE_TERMINATE:
	    hwnd = ConvertToFullHWND(hwndIn);
	    intrAssert(IsWindowValid(hwnd));
	    lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);

	    intrDebugOut((DEB_ITRACE,
			  "DocWndProc: WM_DDE_TERMINATE hwnd=%x\n",
			  hwnd));

	    ChkC(lpclient);

	    //
	    // If m_fCallData, then we are are waiting for a terminate, which
	    // means we generated the original terminate message. If
	    // this is so, then we are waiting for a reply to the
	    // terminate. Set the AckState and break;
	    //
	    if (lpclient->m_fCallData)
	    {
		lpclient->SetCallState(SERVERCALLEX_ISHANDLED);
                break;
	    }


#ifdef _DEBUG
	    // find the client in the client list.
	    hwndClient = (HWND)FindClient (lpclient->m_hcli,(HWND)wParam, FALSE);
	    AssertSz(hwndClient, "Client is missing from the server");
#endif
	    AssertIsDoc (lpclient);
	    Assert (lpclient->m_cClients > 0);
	    lpclient->m_cClients--;
	
	    // Necessary safety bracket
	    lpclient->m_pUnkOuter->AddRef();

	    // terminate has to be handled always
	    // The DocHandleIncomingCall() routine will set the
	    // calltype to be CALLTYPE_ASYNC
	    // async calls are never rejected

	    docData.hwnd = hwnd;
	    docData.msg = msg;
	    docData.wParam = wParam;
	    docData.lpclient = lpclient;

	    retval = DocHandleIncomingCall(&docData);

	    intrAssert(retval == NOERROR);

	    // Necessary safety bracket
	    lpclient->m_pUnkOuter->Release();
	    break;

       case WM_DESTROY:

	    intrDebugOut((DEB_ITRACE,
			  "DocWndProc: WM_DESTROY\n"));
	    break;

       case WM_DDE_POKE:
            {
		hwnd = ConvertToFullHWND(hwndIn);
		intrAssert(IsWindowValid(hwnd));
		lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);
		hdata = GET_WM_DDE_POKE_HDATA(wParam,lParam);
		aItem = GET_WM_DDE_POKE_ITEM(wParam,lParam);
		ChkC(lpclient);

		if (!IsWindowValid  ((HWND) wParam) || lpclient->m_fCallData)
		{
		    // The sending window is invalid or we have already sent a
		    // TERMINATE to it (as indicated by m_pCI != NULL).
		    // We cannot ACK the message, so we must free any
		    // handles or atoms.
		    Warn ("Ignoring message");

		    FreePokeData (hdata);
LDeleteAtom:
		
                if (aItem != NULL)
		{
                    GlobalDeleteAtom (aItem);
		}
                break;
            }

	    docData.hwnd = hwnd;
	    docData.msg = msg;
	    docData.wParam = wParam;
	    docData.hdata = hdata;
	    docData.aItem = aItem;
	    docData.lpclient = lpclient;

            retval = DocHandleIncomingCall(&docData);
            if (retval != NOERROR)
	    {
		SET_MSG_STATUS (retval, status);

		// !!! If the fRelease is false and the post fails
		// then we are not freeing the hdata. Are we supposed to

		// REVIEW: The assumption is
		LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_ACK,status,aItem);
		if (!PostMessageToClient ((HWND)wParam, WM_DDE_ACK, (UINT) hwnd,lp))
		{
		    DDEFREE(WM_DDE_ACK,lp);
		    goto LDeleteAtom;
		}
    	    }
			// johannp: set the busy bit here in the status word
	    break;
       }


    case WM_DDE_ADVISE:
	{
	    hwnd = ConvertToFullHWND(hwndIn);
	    intrAssert(IsWindowValid(hwnd));
	    lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);
	    HANDLE hOptions = GET_WM_DDE_ADVISE_HOPTIONS(wParam,lParam);
	    aItem = GET_WM_DDE_ADVISE_ITEM(wParam,lParam);

	    ChkC(lpclient);
	    if (!IsWindowValid	((HWND)wParam) || lpclient->m_fCallData)
	    {
AdviseErr:
		Warn ("Ignoring advise message");
		//
		// GlobalFree wants a handle, we are giving it a DWORD.
		//
		GlobalFree (hOptions);
		break;
	    }
	    docData.hwnd = hwnd;
	    docData.msg = msg;
	    docData.wParam = wParam;
	    docData.hdata = hOptions;
	    docData.aItem = aItem;
	    docData.lpclient = lpclient;

            retval = DocHandleIncomingCall(&docData);

            if (retval != NOERROR)
            {
		SET_MSG_STATUS (retval, status);

		LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_ACK,status,aItem);

		if (!PostMessageToClient ((HWND)wParam, WM_DDE_ACK, (UINT) hwnd,lp))
		{
		    DDEFREE(WM_DDE_ACK,lp);
		    goto AdviseErr;
		}
	    }
            break;
	}
    case WM_DDE_UNADVISE:
     {
	hwnd = ConvertToFullHWND(hwndIn);
	intrAssert(IsWindowValid(hwnd));
	lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);

	aItem = HIWORD(lParam);
	ChkC(lpclient);
	if (!IsWindowValid  ((HWND)wParam) || lpclient->m_fCallData)
	{
                goto LDeleteAtom;
	}
        docData.hwnd = hwnd;
        docData.msg = msg;
        docData.wParam = wParam;
	docData.aItem = aItem;
        docData.lpclient = lpclient;

	retval = DocHandleIncomingCall(&docData);

	if (retval != NOERROR)
	{
	    SET_MSG_STATUS (retval, status);
	    LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_ACK,status,aItem);

	    if (!PostMessageToClient ((HWND)wParam, WM_DDE_ACK, (UINT) hwnd,lp))
	    {
		DDEFREE(WM_DDE_ACK,lp);
		goto LDeleteAtom;
	    }
	}

	break;
     }
    case WM_DDE_REQUEST:
     {
	hwnd = ConvertToFullHWND(hwndIn);
	intrAssert(IsWindowValid(hwnd));
	lpclient = (LPCLIENT)GetWindowLong (hwnd, 0);

	aItem = HIWORD(lParam);

	ChkC(lpclient);
	if (!IsWindowValid  ((HWND) wParam) || lpclient->m_fCallData)
	{
                goto LDeleteAtom;
	}
        docData.hwnd = hwnd;
        docData.msg = msg;
        docData.wParam = wParam;
	docData.lParam = lParam;
	docData.aItem = aItem;
        docData.lpclient = lpclient;

	retval = DocHandleIncomingCall(&docData);
	if (retval != NOERROR)
	{
	    if (retval == RPC_E_DDE_BUSY)
	    {
		    status = 0x4000;
	    }
	    else
	    {
		    status = 0; // negative acknowledge
	    }

	    LPARAM lp = MAKE_DDE_LPARAM(WM_DDE_ACK,status,aItem);
	    // if request failed, then acknowledge with error.
	    if (!PostMessageToClient ((HWND)wParam, WM_DDE_ACK, (UINT) hwnd,lp))
	    {
		DDEFREE(WM_DDE_ACK,lp);
		goto LDeleteAtom;
	    }
	}
	break;
     }
    default:
	    return SSDefWindowProc (hwndIn, msg, wParam, lParam);

    }

    return 0L;

}




INTERNAL_(void) CDefClient::SendExecuteAck
    (HRESULT hresult)
{
    AssertIsDoc (this);
    WORD  status = NULL;
    SET_MSG_STATUS (hresult, status);

    m_ExecuteAck.f = FALSE;

    LPARAM lParam = MAKE_DDE_LPARAM (WM_DDE_ACK,status,
				     (UINT) m_ExecuteAck.hdata);
    // Post the acknowledge to the client
    if (!PostMessageToClient (m_ExecuteAck.hwndFrom, WM_DDE_ACK,
			      (UINT) m_ExecuteAck.hwndTo, lParam))
    {
	Assert (0);
	// the window either died or post failed, delete the data
	DDEFREE (WM_DDE_ACK,lParam);
	GlobalFree (m_ExecuteAck.hdata);
    }
}



//DocExecute: Interprets the execute command for the
//document conversation.


INTERNAL CDefClient::DocExecute
    (HANDLE      hdata)
{

    ATOM	    acmd;
    BOOL	    fShow;
    BOOL	    fActivate;

    HANDLE          hdup   = NULL;
    HRESULT           retval = ReportResult(0, S_OOM, 0, 0);

    LPSTR           lpitemname;
    LPSTR           lpopt;
    LPSTR           lpnextarg;
    LPSTR	    lpdata = NULL;
    LPSTR           lpverb = NULL;
    INT 	verb;
    WORD	    wCmdType;

    ChkC(this);

    intrDebugOut((DEB_ITRACE,
		  "%p _IN CDefClient::DocExecute(hdata=%x)\n",
		  this,
		  hdata));

    // !!!Can we modify the string which has been passed to us
    // rather than duplicating the data. This will get some speed
    // and save some space.

    if(!(hdup = UtDupGlobal(hdata,GMEM_MOVEABLE)))
	goto    errRtn;

    if (!(lpdata  = (LPSTR)GlobalLock (hdup)))
	goto    errRtn;

    retval = ReportResult(0, RPC_E_DDE_SYNTAX_EXECUTE, 0, 0);

    intrDebugOut((DEB_ITRACE,
		  "%p _IN CDefClient::DocExecute command=(%s)\n",
		  this,
		  lpdata));

    if(*lpdata++ != '[') // commands start with the left sqaure bracket
	goto  errRtn;

    // scan the command and scan upto the first arg.
    if (!(wCmdType = ScanCommand(lpdata, WT_DOC, &lpnextarg, &acmd)))
	goto errRtn;

    if (wCmdType == NON_OLE_COMMAND) {

#ifdef  LATER
	if (lpsrvr =  (LPSRVR) GetWindowLong (GetParent (hwnd), 0)) {
	    if (!UtilQueryProtocol (lpsrvr->aClass, PROTOCOL_EXECUTE))
		retval = OLE_ERROR_PROTOCOL;
	    else {
#ifdef FIREWALLS
		if (!CheckPointer (lpoledoc, WRITE_ACCESS))
		    AssertSz (0, "Invalid LPOLESERVERDOC");
		else if (!CheckPointer (lpoledoc->lpvtbl, WRITE_ACCESS))
		    AssertSz (0, "Invalid LPOLESERVERDOCVTBL");
		else
		    AssertSz (lpoledoc->lpvtbl->Execute,
			"Invalid pointer to Execute method");
#endif

		retval = (*lpoledoc->lpvtbl->Execute) (lpoledoc, hdata);
	    }

	}
#endif
	AssertSz(0, "Doc level execute is being called");

	goto errRtn;
    }


    //////////////////////////////////////////////////////////////////////////
    //
    // [StdCloseDocument]
    //
    //////////////////////////////////////////////////////////////////////////
    if (acmd == aStdClose){

	LPCLIENT lpclient=NULL;
	// if not terminated by NULL error
	if (*lpnextarg)
	    goto errRtn;

	if ((retval = FindItem (NULL, (LPCLIENT FAR *)&lpclient)) != NOERROR)
	    return retval;
	

	lpclient->m_fGotStdCloseDoc = TRUE;
	retval = lpclient->m_lpoleObj->Close (OLECLOSE_SAVEIFDIRTY);
	goto end;
    }

    //////////////////////////////////////////////////////////////////////////
    //
    // [StdDoVerbItem("itemname", verb, BOOL, BOOL]
    //
    //////////////////////////////////////////////////////////////////////////
    if (acmd == aStdDoVerbItem){
	lpitemname = lpnextarg;

	if(!(lpverb = ScanArg(lpnextarg)))
	    goto errRtn;


    if(!(lpnextarg = ScanNumArg(lpverb, &verb)))
	    goto errRtn;

#ifdef  FIREWALLS
	AssertSz (verb < 9 , "Unexpected verb number");
#endif

	// now scan the show BOOL

	if (!(lpnextarg = ScanBoolArg (lpnextarg, (BOOL FAR *)&fShow)))
	    goto errRtn;

	fActivate = FALSE;

	// if activate BOOL is present, scan it.

	if (*lpnextarg) {
	    if (!(lpnextarg = ScanBoolArg (lpnextarg, (BOOL FAR *)&fActivate)))
		goto errRtn;
	}

	if (*lpnextarg)
	    goto errRtn;

	if (m_fEmbed)
	{
	    // This is a totally bogus call to SetHostNames whose only
	    // purpose is to notify the server that this is an embedded
	    // (not linked) object.
	    if (!m_fDidRealSetHostNames)
	    {
		Puts ("Bogus call to SetHostNames before DoVerb\r\n");
		m_lpoleObj->SetHostNames (OLESTR("Container"), OLESTR("Object"));
	    }
	}
	// REVIEW: We are assuming that calling the Docdoverb method
	// will not post any more DDE messahes.

	retval = DocDoVerbItem (lpitemname, verb, fShow, !fActivate);
	goto end;
    }





    //////////////////////////////////////////////////////////////////////////
    //
    // [StdShowItem("itemname"[, "true"])]
    //
    //////////////////////////////////////////////////////////////////////////
    if (acmd != aStdShowItem)
	goto errRtn;

    lpitemname = lpnextarg;

    if(!(lpopt = ScanArg(lpitemname)))
	goto errRtn;

    // Now scan for optional parameter.

    fActivate = FALSE;

    if (*lpopt) {

	if(!(lpnextarg = ScanBoolArg (lpopt, (BOOL FAR *)&fActivate)))
	    goto errRtn;

	if (*lpnextarg)
	    goto errRtn;


    }

    if (m_fEmbed)
    {
	// This is a totally bogus call to SetHostNames whose only
	// purpose is to notify the server that this is an embedded
	// (not linked) object.
	// REVIEW LINK
	if (!m_fDidRealSetHostNames)
	{
	    Puts ("Bogus call to SetHostNames before ShowItem\r\n");
	    m_lpoleObj->SetHostNames (OLESTR("Container"), OLESTR("Object"));
	}
    }

    retval = DocShowItem (lpitemname, !fActivate);

end:
errRtn:
   if (lpdata)
	GlobalUnlock (hdup);

   if (hdup)
	GlobalFree (hdup);

    intrDebugOut((DEB_ITRACE,
		  "%p _OUT CDefClient::DocExecute(hdata=%x) hresult=%x\n",
		  this,
		  hdata,
		  retval));

   return (HRESULT)retval;
}



INTERNAL_(HRESULT)   CDefClient::DocShowItem
(
LPSTR       lpAnsiitemname,
BOOL        fAct
)
{
    LPCLIENT        lpclient;
    HRESULT     	retval;
    LPOLEOBJECT lpoleObj;

    ChkC(this);
    WCHAR	lpitemname[MAX_STR];

    if (MultiByteToWideChar(CP_ACP,0,lpAnsiitemname,-1,lpitemname,MAX_STR) == FALSE)
    {
	Assert(!"Unable to convert characters");
	return(E_UNEXPECTED);
    }

    if ((retval = FindItem (lpitemname, (LPCLIENT FAR *)&lpclient))
	   != NOERROR)
       return retval;

    ChkC(lpclient);

    lpoleObj = lpclient->m_lpoleObj;


#ifdef FIREWALLS1
	if (!CheckPointer (lpoleObj->lpvtbl, WRITE_ACCESS))
	    AssertSz (0, "Invalid LPOLEOBJECTVTBL");
	else
	    AssertSz (lpoleObj->lpvtbl->DoVerb,
		"Invalid pointer to DoVerb method");
#endif

    // protocol sends false for activating and TRUE for not activating.
    // for api send TRUE for avtivating and FALSE for not activating.
    return lpclient->m_lpoleObj->DoVerb(OLEVERB_SHOW, NULL, NULL, NULL, NULL, NULL);
}



INTERNAL_(HRESULT)   CDefClient::DocDoVerbItem
(
LPSTR       lpAnsiitemname,
WORD        verb,
BOOL        fShow,
BOOL        fAct
)
{
    LPCLIENT   	lpclient;
    HRESULT     retval;

    WCHAR	lpitemname[MAX_STR];

    if (MultiByteToWideChar(CP_ACP,0,lpAnsiitemname,-1,lpitemname,MAX_STR) == FALSE)
    {
	Assert(!"Unable to convert characters");
	return(E_UNEXPECTED);
    }

    ChkC(this);
    Puts ("DefClient::DocDoVerbItem\r\n");
    if ((retval = FindItem (lpitemname, (LPCLIENT FAR *)&lpclient))
	   != NOERROR)
       return retval;
    ChkC(lpclient);

#ifdef FIREWALLS1
	if (!CheckPointer (lpclient->lpoleObj->lpvtbl, WRITE_ACCESS))
	    AssertSz (0, "Invalid LPOLEOBJECTVTBL");
	else
	    AssertSz (lpclient->lpoleObj->lpvtbl->DoVerb,
		"Invalid pointer to DoVerb method");
#endif

    // pass TRUE to activate and False not to activate. Differnt from
    // protocol.

    retval = lpclient->m_lpoleObj->DoVerb(verb, NULL, &m_OleClientSite, NULL, NULL, NULL);
    // Apparently an obsolete version of Lotus Notes is the only
    // container (other than Cltest) that sets fShow=FALSE
    if (!fShow && lpclient->m_lpoleObj && lpclient->m_fEmbed)
	lpclient->m_lpoleObj->DoVerb(OLEIVERB_HIDE, NULL, &m_OleClientSite, NULL, NULL, NULL);
    return retval;
}

INTERNAL CDefClient::DoInitNew()
{
	HRESULT hresult;
	ATOM aClass;
	LPPERSISTSTORAGE pPersistStg=NULL;
	
	hresult = m_lpoleObj->QueryInterface(IID_IPersistStorage,
 								(LPLPVOID)&pPersistStg);
	if (hresult == NOERROR)
	{
		CLSID clsid;
		RetZ (pPersistStg);
		ErrRtnH (CreateILockBytesOnHGlobal ((HGLOBAL)NULL,
							   /*fDeleteOnRelease*/ TRUE,
							   &m_plkbytNative));
  	    ErrZS (m_plkbytNative, E_OUTOFMEMORY);

        ErrRtnH (StgCreateDocfileOnILockBytes
						(m_plkbytNative,
						 grfCreateStg, 0,
						 &m_pstgNative));

   	    ErrZS (m_pstgNative, E_OUTOFMEMORY);

    		aClass = m_psrvrParent->m_cnvtyp == cnvtypTreatAs ? m_psrvrParent->m_aOriginalClass
								: m_psrvrParent->m_aClass;
		// Write appropriate class tag
		ErrZS (CLSIDFromAtom (aClass,(LPCLSID)&clsid),
				       REGDB_E_CLASSNOTREG);
		ErrRtnH (WriteClassStg (m_pstgNative, clsid));

		// Provide server with a storage to use for its persistent
		// storage, i.e., native data.  We remember this IStorage and the
		// ILockBytes it is built on.
        ErrRtnH (pPersistStg->InitNew(m_pstgNative));
		m_fGotEditNoPokeNativeYet = FALSE;
		
		// Now that we have initialized the object, we are allowed to
		// set the client site, and advise.
		ErrRtnH (SetClientSite());

		// This is for Packager, in particular.  If client does not advise
		// on any data, we still need to do an OLE advise so we can get
		// OnClose notifications.
		DoOle20Advise (OLE_CLOSED, (CLIPFORMAT)0);
	}
	else
	{
		AssertSz (0, "Can't get IPersistStorage from OleObj\r\n");
	}

	m_fEmbed = TRUE;
	
errRtn:
   if (pPersistStg)
   		pPersistStg->Release();
	return hresult;
}


// FreePokeData: Frees the poked dats.
INTERNAL_(void) FreePokeData
(
HANDLE  hdde
)
{
    DDEPOKE FAR * lpdde;
    Puts ("FreePokeData\r\n");

    if (hdde) {
	if (lpdde = (DDEPOKE FAR *) GlobalLock (hdde)) {
	    GlobalUnlock (hdde);
	    FreeGDIdata (*(LPHANDLE)lpdde->Value, lpdde->cfFormat);
	}

	GlobalFree (hdde);
    }
}



// Returns TRUE if GDI format else returns FALSE

INTERNAL_(BOOL) FreeGDIdata
(
HANDLE  	hData,
CLIPFORMAT      cfFormat
)
{
    Puts ("FreeGDIData\r\n");
    if (cfFormat == CF_METAFILEPICT) {
	LPMETAFILEPICT  lpMfp;

	if (lpMfp = (LPMETAFILEPICT) GlobalLock (hData)) {
	    GlobalUnlock (hData);
	    DeleteMetaFile (lpMfp->hMF);
	}

	GlobalFree (hData);
    }
    else if (cfFormat == CF_BITMAP)
	DeleteObject (hData);
    else if (cfFormat == CF_DIB)
	GlobalFree (hData);
    else
	return FALSE;

    return TRUE;
}