/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */
//	File to handle DDE remote control commands.

#include "stdafx.h"

#include "genframe.h"

#include "wfedde.h"
#include "ddectc.h"
#include "regproto.h"
#include "winclose.h"
#include "presentm.h"
#include "urlecho.h"
#include "mainfrm.h"
#include "prefapi.h"    // Added so that prefs can be referenced (Dave Hyatt - 8/13/97)
#include "net.h"        // Added so cache can be referenced (8/18/97)
#include "netcache.h"    // Ditto
#include "cxprint.h"    // The printing context... used for PrintWindow and PrintURL (8/27/97)
#include "animecho.h"

//	Our DDE instance identifier.
DWORD CDDEWrapper::m_dwidInst;

//	Wether or not DDE was successfully initialized.
BOOL CDDEWrapper::m_bDDEActive;

//	Our array of hsz strings.
HSZ CDDEWrapper::m_hsz[CDDEWrapper::m_MaxHSZ];

//	A list of all current conversations.  The PtrToPtr map was used since
//		the pointers are known to be 32 bits long, and the HCONV is a 
//		DWORD or possibly a pointer, and WordToPtr just wouldn't cut it
//		with 16 bits and all.
CMapPtrToPtr CDDEWrapper::m_ConvList;

//	Command filter for DDEML
DWORD CDDEWrapper::m_dwafCmd;

//	Call back function for use with DDEML
FARPROC CDDEWrapper::m_pfnCallBack;

//	Array of acceptable clipboard formats in our CallBack
//	Null terminate, please.
UINT CDDEWrapper::m_cfFmts[] = { CF_TEXT, 0 };

//	Purpose:	Initialize our DDE layer
//	Arguments:	void
//	Returns:	void
//	Comments:	Sets all CDDEWrapper static members and makes our DDE
//					service available to the DDEML.
//				We won't warn the user on an invalid initialization,
//					as they probably won't be using this DDE layer if
//					they have a screwed up setup....
//	Revision History:
//		12-28-94	created GAB
void DDEStartup()
{
	//	Initialize all CDDEWrapper static members here.
	//	No CDDEWrapper instances exist at this point.
	//	Note that m_cfFmts is already intialized, m_ConvList should
	//		be initially already empty.
	CDDEWrapper::m_dwidInst = 0L;
	CDDEWrapper::m_bDDEActive = FALSE;
	for(int i_counter = 0; i_counter < CDDEWrapper::m_MaxHSZ;
		i_counter++)	{
		CDDEWrapper::m_hsz[i_counter] = NULL;
	}
	CDDEWrapper::m_dwafCmd = APPCLASS_STANDARD
        | CBF_FAIL_SELFCONNECTIONS;
	CDDEWrapper::m_pfnCallBack = NULL;

#ifdef XP_WIN16
	//	Find out if we can even use DDEML (must be in protected mode).
	//	Undoubtedly, this is the case since we must be in protected
	//		mode to use WINSOCK services, but just to be anal....
	//  GetWinFlags() has been removed in MSVC 2.0 and the analog doesn't
	//      look like it does the same thing.  chouck 29-Dec-94
	if(!(GetWinFlags() & WF_PMODE))	{
		//	Not in protected mode, can not continue with DDEML
		return;
	}
#endif
	
	//	Set up our callback function to be registered with DDEML.
	CDDEWrapper::m_pfnCallBack = (FARPROC)NetscapeDDECallBack;
		
	//	DDEML initialization, don't do anything on failure.
	if(DdeInitialize(&CDDEWrapper::m_dwidInst,
		(PFNCALLBACK)CDDEWrapper::m_pfnCallBack,
		CDDEWrapper::m_dwafCmd, 0L))	{
		//	Unable to initialize, don't continue.
		return;
	}
	
	//	We're DDEed.
	CDDEWrapper::m_bDDEActive = TRUE;
	
	//	Load in all frequently used HSZs.
	//	Unfortunately, there is really no good way to detect any errors
	//		on these string intializations, so let the blame land
	//		where it will if something fails; we could actually just
	//		call shutdown and return if need be....
	// Ugh.  I hate CStrings reason #59:  passing it as a (char *) requires
	//   a nasty cast like the one below.  Chouck 29-Dec-94
	CString CS;
	
	CS.LoadString(IDS_DDE_SERVICE_NAME);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_OPENURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_OpenURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_SHOWFILE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ShowFile] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_ACTIVATE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Activate] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_LISTWINDOWS);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ListWindows] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_GETWINDOWINFO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_GetWindowInfo] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_PARSEANCHOR);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ParseAnchor] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_EXIT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Exit] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_REGISTERPROTOCOL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterProtocol] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERPROTOCOL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterProtocol] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_REGISTERVIEWER);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterViewer] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_QUERYVIEWER);
	CDDEWrapper::m_hsz[CDDEWrapper::m_QueryViewer] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_VIEWDOCFILE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ViewDocFile] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERVIEWER);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterViewer] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_REGISTERURLECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterURLEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_URLECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_URLEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERURLECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterURLEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_REGISTERWINDOWCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterWindowChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_WINDOWCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_WindowChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERWINDOWCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterWindowChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_BEGINPROGRESS);
	CDDEWrapper::m_hsz[CDDEWrapper::m_BeginProgress] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_SETPROGRESSRANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_SetProgressRange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_MAKINGPROGRESS);
	CDDEWrapper::m_hsz[CDDEWrapper::m_MakingProgress] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_ENDPROGRESS);
	CDDEWrapper::m_hsz[CDDEWrapper::m_EndProgress] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_ALERT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Alert] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_VERSION);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Version] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_CANCELPROGRESS);
	CDDEWrapper::m_hsz[CDDEWrapper::m_CancelProgress] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_QUERYURLFILE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_QueryURLFile] =
	    DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
	    (char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_LISTFRAMECHILDREN);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ListFrameChildren] =
	    DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
	    (char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_GETFRAMEPARENT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_GetFrameParent] =
	    DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
	    (char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_REGISTERSTATUSBARCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterStatusBarChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_STATUSBARCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_StatusBarChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERSTATUSBARCHANGE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterStatusBarChange] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_NAVIGATEBACK);
	CDDEWrapper::m_hsz[CDDEWrapper::m_NavigateBack] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_NAVIGATEFORWARD);
	CDDEWrapper::m_hsz[CDDEWrapper::m_NavigateForward] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_RELOAD);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Reload] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_STOP);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Stop] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_GETDOCWIDTH);
	CDDEWrapper::m_hsz[CDDEWrapper::m_GetDocumentWidth] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_GETDOCHEIGHT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_GetDocumentHeight] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_USERAGENT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UserAgent] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_CACHE_CLEARCACHE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Cache_ClearCache] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_CACHE_FILENAME);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Cache_Filename] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_CACHE_INCACHE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Cache_InCache] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_CACHE_REMOVEURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Cache_RemoveURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_CACHE_ADDURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_Cache_AddURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_REMOVEURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_RemoveURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_ADDURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_AddURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_INHISTORY);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_InHistory] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_CLEARHISTORY);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_ClearHistory] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_NUMENTRIES);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_NumEntries] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_HISTORY_GETENTRY);
	CDDEWrapper::m_hsz[CDDEWrapper::m_History_GetEntry] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);

    CS.LoadString(IDS_DDE_GETWINDOWID);
	CDDEWrapper::m_hsz[CDDEWrapper::m_GetWindowID] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_SUPPORTSMIMETYPE);
	CDDEWrapper::m_hsz[CDDEWrapper::m_SupportsMimeType] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_EXECUTEJAVASCRIPT);
	CDDEWrapper::m_hsz[CDDEWrapper::m_ExecuteJavaScript] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_PRINTWINDOW);
	CDDEWrapper::m_hsz[CDDEWrapper::m_PrintWindow] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
    CS.LoadString(IDS_DDE_PRINTURL);
	CDDEWrapper::m_hsz[CDDEWrapper::m_PrintURL] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);

	// Added by DWH 4/98
	CS.LoadString(IDS_DDE_REGISTERANIMATIONECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_RegisterAnimationEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_UNREGISTERANIMATIONECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_UnRegisterAnimationEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);
	CS.LoadString(IDS_DDE_ANIMATIONECHO);
	CDDEWrapper::m_hsz[CDDEWrapper::m_AnimationEcho] =
		DdeCreateStringHandle(CDDEWrapper::m_dwidInst,
		(char *)(const char *)CS, CP_WINANSI);

	//	Register our Name Service with DDEML; we are prepared to rock.
	//	Ignore any error, we could call shutdown if need really be....
	DdeNameService(CDDEWrapper::m_dwidInst,
		CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName], NULL,
		DNS_REGISTER);
	
	TRACE("DDE started, forgive me, father....\n");
}

//	Purpose:	Shut down any intitialization that occurred previously
//	Arguments:	void
//	Returns:	void
//	Comments:	Won't call any DDE functions if there is no need.
//	Revision History:
//		12-28-94	created GAB
void DDEShutdown()
{
	//	First see if we're DDEed.
        if(CDDEWrapper::m_bDDEActive == TRUE) {

		//	Turn off all our name services.
		DdeNameService(CDDEWrapper::m_dwidInst,
            CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName], NULL,
			DNS_UNREGISTER);
		
		//	Get rid of all our HSZ strings.
		//	We have to finish up all DDE calls before we call DdeUnInitialize
		//		(that's the current theory), so just do this and don't
		//		worry about the side effects if we can't unitialize.
		for(int i_counter = 0; i_counter < CDDEWrapper::m_MaxHSZ;
			i_counter++)	{
			if(CDDEWrapper::m_hsz[i_counter] != NULL)	{
				//	Ignore errors.  No proper way to handle them on wind
				//		down.  Will not hurt initialization at a later
				//		time as Windows recycles these strings.
				DdeFreeStringHandle(CDDEWrapper::m_dwidInst,
					CDDEWrapper::m_hsz[i_counter]);
				CDDEWrapper::m_hsz[i_counter] = NULL;
			}
		}		
	
		//	We have no real way of recognizing why we can't deinitialize
		//		our DDE layer, so just return if unable....
		if(DdeUninitialize(CDDEWrapper::m_dwidInst) == 0)	{
			//	System won't let us unitialize.
			//	Just return without disabling the callback and current
			//		conversations; it will be up to the system to clean
			//		this up and handle the abscense of any missing HSZs...
			TRACE("Couldn't shut down DDE.\n");
			return;
		}
		
		//	Reset value for consistancy....  Someone, one day, might
		//		for some reason shut us down, and then restart.  Best
		//		not to keep state between periods.
		CDDEWrapper::m_dwidInst = 0L;
		CDDEWrapper::m_bDDEActive = FALSE;
		CDDEWrapper::m_dwafCmd = 0L;
	}
	
	//	Erase the pointer to the callback.
	CDDEWrapper::m_pfnCallBack = NULL;
	
	//	DDEML and the CallBack are dead.
	//	Kill off any dead conversation objects that we have, unbiased.
	//	Chances are, that if we receive appropriate disconnects when
	//		deinitializing, that we won't have any conversations anyhow,
	//		though I can't guarantee windows is so well thought out in
	//		this regard.
	//	It should be noted here that the list management is actually
	//		maintained by the CDDEWrapper constructor, and destructor,
	//		respectively.
	CDDEWrapper *pWrap;
	void *vp_dump, *vp_wrap;
	POSITION pos;
	while(CDDEWrapper::m_ConvList.IsEmpty() != 0)	{
		pos = CDDEWrapper::m_ConvList.GetStartPosition();
		
		if(pos == NULL)	{
			//	don't know how this would happen.
			//	don't let it happen though.
			break;
		}

		//	Get the valid pointer to the DDEWrapper
		CDDEWrapper::m_ConvList.GetNextAssoc(pos, vp_dump, vp_wrap);
		pWrap = (CDDEWrapper *)vp_wrap;
			
		//	Is this a valid entry anyhow?
		if(pWrap != NULL)	{
			//	Actually remove the object from memory
			delete pWrap;
		}
	}
	
	//	Shutdown complete.
	//	If someone needed to, they could call our startup function
	//		again and start this whole thing over again now.
	TRACE("DDE shutdown is complete.\n");
}

//	Purpose:	A callback function for the DDEML DLL, and to possibly
//					multiplex custom calls in from our own application.
//	Arguments:	type	Specifies the type of the current transation.
//				fmt		Specifies the format in which data is to be sent
//							or received
//				hconv	Identifies the conversation associated with the
//							current transaction
//				hsz1	Identifies a string, the context of which is
//							decided by the current transaction type
//				hsz2	ditto
//				hData	Identifies some DDE data, the context of which is
//							decided by the current transaction type
//				dwData1	Specifies tranaction specific data
//				dwData2	ditto
//	Returns:	HDDEDATA	The actual return type is relative to the
//								type of the transaction.
//	Comments:	Multiplexes all conversations to their appropriate
//					CDDEWrapper instance, or ignores them.
//				Due to the nature of Callbacks, and exported functions,
//					DO NOT USE TRACES HERE, or GPF.
//				The code will have to be air tight first time through,
//					be careful.
//	Revision History:
//		12-28-94	created GAB
//		12-30-94	Began fleshing out else ifs and switch statement
//						to multiplex DDE transactions.
//					This is likely to be one of the most monstrous
//						functions I'll ever write.
HDDEDATA 
CALLBACK 
#ifndef XP_WIN32
_export 
#endif
NetscapeDDECallBack(UINT type, UINT fmt,
	HCONV hconv, HSZ hsz1, HSZ hsz2, HDDEDATA hData, DWORD dwData1,
	DWORD dwData2)
{
	//	First, are we correctly initialized?
	if(CDDEWrapper::m_bDDEActive == FALSE)	{
		return(NULL);
	}
	
	//	Do we support the format they are requesting?
	//	Fall through on not specified.
	if(fmt)	{
		//	Look through our list of supported formats, until we hit
		//		NULL at the end.
		for(int i_counter = 0; 1; i_counter++)	{
			if(CDDEWrapper::m_cfFmts[i_counter] == 0)	{
				//	End of list, and no match, fail.
				return(NULL);
			}
			if(CDDEWrapper::m_cfFmts[i_counter] == fmt)	{
				//	Matched, so break.
				break;
			}
		}
	}
	
	//	Depending on the class of transaction, we return different data.
	if(type & XCLASS_BOOL)	{
		//	Must return (HDDEDATA)TRUE or (HDDEDATA)FALSE
		switch(type)	{
		case XTYP_ADVSTART:	{
			//	We are the server.
			//	A client specified the XTYP_ADVSTART in a call to
			//		DdeClientTransaction
			break;
		}
		case XTYP_CONNECT:	{
			//	We are the server.
			//	A client call the DdeConnect specifying a service and
			//		topic name which we support.
			HSZ& hszTopic = hsz1;
			HSZ& hszService = hsz2;
			
			//	Deny the connection if the service name is not the
			//		one we are taking connections for.
			if(hszService !=
				CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName])	{
				return((HDDEDATA)FALSE);
			}
			
			//	Now, the topic can be NULL, or it can be any one of our
			//		topic names to be accepted.
			if(hszTopic == NULL)	{
				return((HDDEDATA)TRUE);
			}
			
			//	Go through all our topics, see if we match.
			if(0 != CDDEWrapper::EnumTopic(hszTopic))	{
				return((HDDEDATA)TRUE);
			}
			
			//	Topic not supported
			return((HDDEDATA)FALSE);
		}
		default:
			//	unknown
			return((HDDEDATA)FALSE);
		}
		
		//	Break handled here
		return((HDDEDATA)FALSE);
	}
	else if(type & XCLASS_DATA)	{
		//	Must return DDE data handle, CBR_BLOCK, or NULL
		switch(type)	{
		case XTYP_ADVREQ:	{
			//	We are the server.
			//	We called DdePostAdvise indicating that the data of
			//		an item in the advise loop had changed.
			break;
		}
		case XTYP_REQUEST:	{
			//	We are the server.
			//	A client said XTYP_REQUEST in DdeClientTransaction
			HSZ& hszTopic = hsz1;
			HSZ& hszItem = hsz2;
			
			//	Get the object associated with this conversation,
			//		and let it handle the request.
			CDDEWrapper *pWrap = CDDEWrapper::GetConvObj(hconv);
			if(pWrap != NULL)	{
				return(pWrap->RequestHandler(hszTopic, hszItem));
			}			
			break;
		}
		case XTYP_WILDCONNECT:	{
			//	We are the server
			//	A client called DdeConnect or DdeConnectList specifying
			//		NULL for the service name, the topic name, or both
			HSZ& hszTopic = hsz1;
			HSZ& hszService = hsz2;
			
			//	One way we can deny this type of connection is
			//		if the service name is not null, and is not our
			//		service name.
			if(hszService != NULL)	{
				if(hszService !=
					CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName])	{
					return(NULL);
				}
			}
			
			//	The only other way we can deny this type of connection
			//		is if the topic name is not one that we support.
			//	Skip the service name.
			if(hszTopic != NULL)	{
				if(0 == CDDEWrapper::EnumTopic(hszTopic))	{
					//	Topic wasn't matched.
					return(NULL);
				}
			}
			
			//	Obviously, we're going to be accepting this connection.
			//	We have to return all matching service/topic pairs
			//		that were given to us.
			//	Get an array of HSZPAIRs that is big enough to take
			//		all our topics.
			HSZPAIR ahszpair[CDDEWrapper::m_MaxHSZ + 1 -
				CDDEWrapper::m_TopicStart];
				
			//	Match up all service/topic matches.
			int i_depth = 0;
			for(int i_counter = CDDEWrapper::m_TopicStart; i_counter <
				CDDEWrapper::m_MaxHSZ; i_counter++)	{				
				//	See if we are over an appropriate topic.
				if(hszTopic == NULL || hszTopic ==
					CDDEWrapper::m_hsz[i_counter])	{
					//	Assign stuff over, don't care about service name,
					//		we only have one.
					ahszpair[i_depth].hszSvc =
						CDDEWrapper::m_hsz[CDDEWrapper::m_ServiceName];
					ahszpair[i_depth].hszTopic =
						CDDEWrapper::m_hsz[i_counter];
						
					//	We are one further in the array.
					i_depth++;
				}
			}
			
			//	Cap off the list with some NULLs, i_depth is correctly
			//		set.
			ahszpair[i_depth].hszSvc = NULL;
			ahszpair[i_depth].hszTopic = NULL;
			i_depth++;
			
			//	Create the array in the DDE way.
			HDDEDATA pData = DdeCreateDataHandle(CDDEWrapper::m_dwidInst,
				(unsigned char *) &ahszpair, 
				sizeof(HSZPAIR) * i_depth, 
				0L, 
				NULL,
				fmt,
				0);				
			
			//	Return it.  Don't care on failure, as it will be NULL
			//		anyhow.
			return(pData);
		}
		default:
			//	unknown
			return(NULL);
		}
		
		//	Break handled here
		return(NULL);
	}
	else if(type & XCLASS_FLAGS)	{
		//	Must return DDE_FACK, DDE_BUSY, or DDE_FNOTPROCESSED
		switch(type)	{
		case XTYP_ADVDATA:	{
			//	We are the client.
			//	The server gave us a data handle.
			break;
		}
		case XTYP_EXECUTE:	{
			//	We are the server.
			//	A client said XTYP_EXECUTE in DdeClientTransaction
			break;
		}
		case XTYP_POKE:	{
			//	We are the Server
			//	A client said XTYP_POKE in DdeClientTransaction
			HSZ& hszTopic = hsz1;
			HSZ& hszItem = hsz2;
			HDDEDATA& hDataPoke = hData;

			//	Get the object associated with this conversation,
			//		and let it handle the request.
			CDDEWrapper *pWrap = CDDEWrapper::GetConvObj(hconv);
			if(pWrap != NULL)	{
				return(pWrap->PokeHandler(hszTopic, hszItem, hDataPoke));
			}			
			break;
		}
		default:
			//	unknown
			return(DDE_FNOTPROCESSED);
		}
		
		//	Break handled here
		return(DDE_FNOTPROCESSED);
	}
	else if(type & XCLASS_NOTIFICATION)	{
		//	Must return NULL, as the return value is ignored
		switch(type)	{
		case XTYP_ADVSTOP:	{
			//	We are the server
			//	A client said XTYP_ADVSTOP in DdeClientTransaction
			break;
		}
		case XTYP_CONNECT_CONFIRM:	{
			//	We are the server.
			//	We returned 1 to a XTYP_CONNECT transaction.
			
			//	This callback is mainly to inform us of the conversation
			//		handle that now exists, but we will actually be
			//		creating an instance of an object to handle this
			//		conversation from now on.
			HSZ& hszTopic = hsz1;
			HSZ& hszService = hsz2;
			
			//	Create the object, correctly initialized so that
			//		it understands the service, topic, and conversation
			//		it is handling.
			//	It will add itself to the conversation list.
			CDDEWrapper *pObject = new CDDEWrapper(hszService, hszTopic,
				hconv);
			break;
		}
		case XTYP_DISCONNECT:	{
			//	We are either client/server
			//	The partner in the conversation called DdeDisconnect
			//		causing both client/server to receive this.
			
			//	Find out which conversation object we are dealing with.
			CDDEWrapper *pWrapper = CDDEWrapper::GetConvObj(hconv);
			
			//	Simply delete it.
			//	The object takes care of removing itself from the list.
			if(pWrapper != NULL)	{
				delete pWrapper;
			}
			break;
		}
		case XTYP_ERROR:	{
			//	We are either client/server
			//	A serious error has occurred.
			//	DDEML doesn't have any resources left to guarantee
			//		good communication.
			break;
		}
		case XTYP_REGISTER:	{
			//	We are either client/server
			//	A server application used DdeNameService to register
			//		a new service name.
			break;
		}
		case XTYP_UNREGISTER:	{
			//	We are either client/server
			//	A server applciation used DdeNameService to unregister
			//		an old service name.
			break;
		}
		case XTYP_XACT_COMPLETE:	{
			//	We are the client
			//	An asynchronous tranaction, sent when the client specified
			//		the TIMEOUT_ASYNC flag in DdeClientTransaction has
			//		concluded.
			break;
		}
		default:
			//	unknown
			return(NULL);
		}
		return(NULL);
	}

	//	Unknown class type
	return(NULL);
}


//	Purpose:	Construct a DDEWrapper object
//	Arguments:	hszService	The name of the service we are handling.
//				hszTopic	The name of the topic we are handling.
//				hConv		The handle of the conversation we are
//								handling.
//	Returns:	nothing
//	Comments:	Handles all created objects internally through a map.
//	Revision History:
//		12-30-94	created GAB
CDDEWrapper::CDDEWrapper(HSZ hszService, HSZ hszTopic, HCONV hConv)
{
	//	Set our members passed in.
	m_hszService = hszService;
	m_hszTopic = hszTopic;
	m_hConv = hConv;
	
	//	Figure out our enumerated service number.
	//	We know this anyhow, we only have one service name at this
	//		point.
	m_iService = m_ServiceName;
	
	//	Figure out our enumerated topic number.
	m_iTopic = EnumTopic(hszTopic);
	
	//	Add ourselves to the current map of conversations.
	m_ConvList.SetAt((void *)hConv, this);
}

//	Purpose:	Destory a CDDEWrapper object
//	Arguments:	void
//	Returns:	nothing
//	Comments:	Removes us from the internally handled list
//	Revision History:
//		12-30-94	created GAB
CDDEWrapper::~CDDEWrapper()
{
	//	Remove ourselves from the list of current conversations.
	m_ConvList.RemoveKey((void *)m_hConv);
}

//	Purpose:	Figure out which wrapper is associated with a conversation.
//	Arguments:	hConv	The conversation to find out about.
//	Returns:	CDDEWrapper *	A pointer to the CDDEWrapper that is
//									handling the conversation, or NULL
//									if none is present.
//	Comments:	Shouldn't ever return NULL really.
//	Revision History:
//		12-30-94	created GAB
CDDEWrapper *CDDEWrapper::GetConvObj(HCONV hConv)
{
	//	Query our static map of conversations for the object.
	void *pWrap;
	
	if(m_ConvList.Lookup((void *)hConv, pWrap) == 0)	{
		return(NULL);
	}
	return((CDDEWrapper *)pWrap);
}

//	Purpose:	Return the offset of the hsz topic string in our static
//					m_hsz array
//	Arguments:	hsz	The HSZ string to find in our array
//	Returns:	int	The offset into the array, also correlating to
//						it's enumerated value.  If not found, the
//						returned failure value is 0.
//	Comments:	Mainly coded to remove redundant lookups.  Modularity...
//	Revision History:
//		12-30-94	created GAB
int CDDEWrapper::EnumTopic(HSZ& hsz)
{
	int i_retval = 0;
	int i_counter;
	
	//	Just start looking for the HSZ string in our static array.
	for(i_counter = m_TopicStart; i_counter < m_MaxHSZ; i_counter++)
	{
		if(m_hsz[i_counter] == hsz)	{
			i_retval = i_counter;
			break;
		}
	}
	
	return(i_retval);
}

//	Purpose:	Scan in the arguments with a specified format.
//	Arguments:	hszArgs	The string containing the arguments, in string
//							format.
//				pFormat	The format (order) that the strings will be
//							scanned in.
//				...		Variable number of parameters, decided by
//							pFormat, that the values will be stored in.
//	Returns:	void
//	Comments:	Data should always be an exact match, no need for
//					errors, do it right the first time.
//				See below, as there will be some funky heuristics
//					going on regarding some parameters and how they
//					are represented.
//				Of course, only pointers should be passed in as the
//					variable number of arguments.
//				->Appropriate type casting here is a must, as we could
//					possibly overwrite, or underwrite, data.  This
//					also means that all the parameters passed in must
//					be correct!
//				Never call this function with an empty format!
//	Revision History:
//		12-31-94	created GAB
void CDDEWrapper::ScanArgs(HSZ& hszArgs, const char *pFormat, ...)
{
	//	Initialize variable number of argumetns.
	va_list VarList;
	va_start(VarList, pFormat);	
	
	//	Set up some variables we are going to use.
	int i_ArgNum = 0;
	char *pScan = (char *)pFormat;
	char *pExtract;
	
	//	Loop through the arguments we are going to parse.
	while(pScan && *pScan)	{
		//	What argument are we currently looking for?
		//	Extract it's value from our HSZ
		i_ArgNum++;
		pExtract = ExtractArg(hszArgs, i_ArgNum);
	
		//	Check it for currently supported types
		if(0 == strncmp(pScan, "DW", 2))	{
			//	Why, it's a DWORD.
			//	Take the pointer to it off our argument list.
			DWORD *pWord;
			pWord = va_arg(VarList, DWORD *);
			
			//	If there is nothing to scan, use a default value.
			if(pExtract == NULL)	{
				*pWord = 0x0;
			}
			else	{
				//	Take the value.
                *pWord = strtoul(pExtract, NULL, 0);
				//sscanf(pExtract, "%lu", pWord);
			}
		}
		else if(0 == strncmp(pScan, "QCS", 3))	{
			//	A quoted CString
			CString *pCS = va_arg(VarList, CString *);
			
			if(pExtract == NULL)	{
				pCS->Empty();
			}
			else	{
				//	Fun thing about a qouted string, is that we need
				//		to compress and '\"' into '"'.
				//	Extractions took off the leading and ending quotes.
				char *pCopy = pExtract;
				while(*pCopy)	{
					if(*pCopy == '\\' && *(pCopy + 1) == '\"')	{
						pCopy++;
					}
					
					*pCS += *pCopy;
					pCopy++;
				}
			}
		}
		else if(0 == strncmp(pScan, "CS", 2))	{
			//	A CString
			CString *pCS = va_arg(VarList, CString *);

			if(pExtract == NULL)	{
				pCS->Empty();
			}
			else	{
				//	Just copy.
				*pCS = pExtract;
			}
		}
		else if(0 == strncmp(pScan, "BL", 2))	{
			//	A boolean
			TwoByteBool *pBool = va_arg(VarList, TwoByteBool *);
			
			if(pExtract == NULL)	{
				*pBool = FALSE;
			}
			else	{
				//	Compare for a TRUE or a FALSE
				if(0 == stricmp(pExtract, "TRUE"))	{
					*pBool = TRUE;
				}
				else	{
					*pBool = FALSE;
				}
			}
		}
		else	{
			//	Doh!, not supported, just break out of the while loop.
			ASSERT(0);
			break;
		}
		
		//	Go on to the next argument in our format string.
		pScan = SkipToNextFormat(pScan);
		
		//	Free the memory that was used during extraction.
		if(pExtract != NULL)	{
			delete pExtract;
		}
	}
	
	//	Done with variable number of arguments
	va_end(VarList);
}


//	Purpose:	Scan in the arguments with a specified format.
//	Arguments:	hArgs	The string containing the arguments, in string
//							format (must convert to HSZ first).
//				pFormat	The format (order) that the strings will be
//							scanned in.
//				...		Variable number of parameters, decided by
//							pFormat, that the values will be stored in.
//	Returns:	void
//	Comments:	Data should always be an exact match, no need for
//					errors, do it right the first time.
//				See below, as there will be some funky heuristics
//					going on regarding some parameters and how they
//					are represented.
//				Of course, only pointers should be passed in as the
//					variable number of arguments.
//				->Appropriate type casting here is a must, as we could
//					possibly overwrite, or underwrite, data.  This
//					also means that all the parameters passed in must
//					be correct!
//				Never call this function with an empty format!
//	Revision History:
//		01-05-95	created GAB
void CDDEWrapper::ScanDataArgs(HDDEDATA& hArgs, const char *pFormat, ...)
{
	char *pDataArgs = (char *)DdeAccessData(hArgs, NULL);
	
	//	Initialize variable number of argumetns.
	va_list VarList;
	va_start(VarList, pFormat);	
	
	//	With DATA args, it will be possible that with only one argument,
	//		that we are receiving raw data.
	//	Use this method.
	if(strchr(pFormat, ',') == NULL)	{
		//	Only one argument.
		if(strcmp(pFormat, "DW") == 0)	{
			DWORD *pWord;
			pWord = va_arg(VarList, DWORD *);
			*pWord = *(DWORD *)pDataArgs;
			DdeUnaccessData(hArgs);
			va_end(VarList);
			return;
		}
		else if(strcmp(pFormat, "BL") == 0)	{
			TwoByteBool *pBool;
			pBool = va_arg(VarList, TwoByteBool *);
			*pBool = *(TwoByteBool *)pDataArgs;
			DdeUnaccessData(hArgs);
			va_end(VarList);
			return;
		}
	}

	//	Convert our hArgs to HSZ format.
	HSZ hszArgs = DdeCreateStringHandle(m_dwidInst, pDataArgs,
		CP_WINANSI);
	DdeUnaccessData(hArgs);	

	//	Set up some variables we are going to use.
	int i_ArgNum = 0;
	char *pScan = (char *)pFormat;
	char *pExtract;
	
	//	Loop through the arguments we are going to parse.
	while(pScan && *pScan)	{
		//	What argument are we currently looking for?
		//	Extract it's value from our HSZ
		i_ArgNum++;
		pExtract = ExtractArg(hszArgs, i_ArgNum);
	
		//	Check it for currently supported types
		if(0 == strncmp(pScan, "DW", 2))	{
			//	Why, it's a DWORD.
			//	Take the pointer to it off our argument list.
			DWORD *pWord;
			pWord = va_arg(VarList, DWORD *);
			
			//	If there is nothing to scan, use a default value.
			if(pExtract == NULL)	{
				*pWord = 0x0;
			}
			else	{
				//	Take the value.
                *pWord = strtoul(pExtract, NULL, 0);
				//sscanf(pExtract, "%lu", pWord);
			}
		}
		else if(0 == strncmp(pScan, "QCS", 3))	{
			//	A quoted CString
			CString *pCS = va_arg(VarList, CString *);
			
			if(pExtract == NULL)	{
				pCS->Empty();
			}
			else	{
				//	Fun thing about a qouted string, is that we need
				//		to compress and '\"' into '"'.
				//	Extractions took off the leading and ending quotes.
				char *pCopy = pExtract;
				while(*pCopy)	{
					if(*pCopy == '\\' && *(pCopy + 1) == '\"')	{
						pCopy++;
					}
					
					*pCS += *pCopy;
					pCopy++;
				}
			}
		}
		else if(0 == strncmp(pScan, "CS", 2))	{
			//	A CString
			CString *pCS = va_arg(VarList, CString *);

			if(pExtract == NULL)	{
				pCS->Empty();
			}
			else	{
				//	Just copy.
				*pCS = pExtract;
			}
		}
		else if(0 == strncmp(pScan, "BL", 2))	{
			//	A boolean
			TwoByteBool *pBool = va_arg(VarList, TwoByteBool *);
			
			if(pExtract == NULL)	{
				*pBool = FALSE;
			}
			else	{
				//	Compare for a TRUE or a FALSE
				if(0 == stricmp(pExtract, "TRUE"))	{
					*pBool = TRUE;
				}
				else	{
					*pBool = FALSE;
				}
			}
		}
		else	{
			//	Doh!, not supported, just break out of the while loop.
			ASSERT(0);
			break;
		}
		
		//	Go on to the next argument in our format string.
		pScan = SkipToNextFormat(pScan);
		
		//	Free the memory that was used during extraction.
		if(pExtract != NULL)	{
			delete pExtract;
		}
	}
	
	//	Done with variable number of arguments
	va_end(VarList);
	
	//	Free off our created HSZ string.
	DdeFreeStringHandle(m_dwidInst, hszArgs);
}


//	Purpose:	Create an argument list, as HDDEDATA
//	Arguments:	pFormat	The format of the argument list
//				...		The viarables correlating to the format
//	Returns:	HSZ	The argument list (a string, really)
//	Comments:	HSZ is the return type because this will mainly
//					be used to create return values back to the
//					server.
//				Do not screw up and pass in the wrong arguments, or
//					a wrong format.
//				Only pointers are accepted as arguments, because if
//					a NULL is passed in, then it will be considered
//					an optional non-existant argument.  If this is
//					not the case, then pass in a valid pointer,
//					pointing to a valid argument.
//	Revision History:
//		01-05-95	created GAB
HSZ CDDEWrapper::MakeItemArgs(const char *pFormat, ...)
{
	//	Safety dance
	char *pTraverse = (char *)pFormat;	
	if(pTraverse == NULL || *pTraverse == '\0')	{
		return(NULL);
	}

	//	Set up for variable number of arguments.
	va_list VarList;
	va_start(VarList, pFormat);

	//	Real simple.
	//	Go through our format, and append the string representation
	//		to our developing return value.
	char caNumpad[64];
	CString csBuffer;
	CString csRetval;
	
	while(*pTraverse)	{
		//	Erase temp data from our last pass.
		caNumpad[0] = '\0';
		csBuffer.Empty();
	
		//	Compare our current format to the known formats
		if(0 == strncmp(pTraverse, "DW", 2))	{
			//	A DWORD.
			DWORD *pWord = va_arg(VarList, DWORD *);
			
			if(pWord != NULL)	{			
				sprintf(caNumpad, "%lu", *pWord);
				csRetval += caNumpad;
			}
		}
		else if(0 == strncmp(pTraverse, "CS", 2))	{
			//	A CString, not quoted
			CString *pCS = va_arg(VarList, CString *);
			
			if(pCS != NULL)	{
				csRetval += *pCS;
			}
		}
		else if(0 == strncmp(pTraverse, "QCS", 3))	{
			//	A quoted CString
			CString *pQCS = va_arg(VarList, CString *);
			
			if(pQCS != NULL)	{
				csRetval += '\"';
				
				//	Need to escape any '"' to '\"', literally.
				char *pConvert = (char *)(const char *)*pQCS;
				while(*pConvert != '\0')	{
					if(*pConvert == '\"')	{
						csRetval += '\\';
					}
					csRetval += *pConvert;
					pConvert++;
				}
				csRetval += '\"';
			}
		}
		else if(0 == strncmp(pTraverse, "BL", 2))	{
			//	A boolean
			TwoByteBool *pBool = va_arg(VarList, TwoByteBool *);
			
			if(pBool != NULL)	{
				if(*pBool != FALSE)	{
					csRetval += "TRUE";
				}
				else	{
					csRetval += "FALSE";
				}
			}
		}
		else	{
			//	Unhandled format, just get out of loop.
			ASSERT(0);
			break;
		}
		
		//	Go on to next type
		pTraverse = SkipToNextFormat(pTraverse);
		
		//	See if we need a comma
		if(*pTraverse != '\0')	{
			csRetval += ',';
		}
	}

	//	Done with varargs.
	va_end(VarList);
	
	//	Make sure we're atleast returning something.
	if(csRetval.IsEmpty())	{
		return(NULL);
	}

	//	Return our resultant HSZ, created from our string, and
	//		the DDEML will own this once we return it.
	HSZ Final = DdeCreateStringHandle(m_dwidInst, (char *)
		(const char *)csRetval, CP_WINANSI);
	return(Final);
}


//	Purpose:	Create an argument list, as HDDEDATA
//	Arguments:	pFormat	The format of the argument list
//				...		The viarables correlating to the format
//	Returns:	HDDEDATA	The argument list (a string, really)
//	Comments:	HDDEDATA is the return type because this will mainly
//					be used to create return values back to the
//					client.
//				Do not screw up and pass in the wrong arguments, or
//					a wrong format.
//				Only pointers are accepted as arguments, because if
//					a NULL is passed in, then it will be considered
//					an optional non-existant argument.  If this is
//					not the case, then pass in a valid pointer,
//					pointing to a valid argument.
//	Revision History:
//		01-02-95	created GAB
HDDEDATA CDDEWrapper::MakeArgs(const char *pFormat, ...)
{
	//	Safety dance
	char *pTraverse = (char *)pFormat;	
	if(pTraverse == NULL || *pTraverse == '\0')	{
		return(NULL);
	}

	//	Set up for variable number of arguments.
	va_list VarList;
	va_start(VarList, pFormat);

	//	Real simple.
	//	Go through our format, and append the string representation
	//		to our developing return value.
	char caNumpad[64];
	CString csBuffer;
	CString csRetval;
	
	while(*pTraverse)	{
		//	Erase temp data from our last pass.
		caNumpad[0] = '\0';
		csBuffer.Empty();
	
		//	Compare our current format to the known formats
		if(0 == strncmp(pTraverse, "DW", 2))	{
			//	A DWORD.
			DWORD *pWord = va_arg(VarList, DWORD *);
			
			if(pWord != NULL)	{			
				sprintf(caNumpad, "%lu", *pWord);
				csRetval += caNumpad;
			}
		}
		else if(0 == strncmp(pTraverse, "CS", 2))	{
			//	A CString, not quoted
			CString *pCS = va_arg(VarList, CString *);
			
			if(pCS != NULL)	{
				csRetval += *pCS;
			}
		}
		else if(0 == strncmp(pTraverse, "QCS", 3))	{
			//	A quoted CString
			CString *pQCS = va_arg(VarList, CString *);
			
			if(pQCS != NULL)	{
				csRetval += '\"';
				
				//	Need to escape any '"' to '\"', literally.
				char *pConvert = (char *)(const char *)*pQCS;
				while(*pConvert != '\0')	{
					if(*pConvert == '\"')	{
						csRetval += '\\';
					}
					csRetval += *pConvert;
					pConvert++;
				}
				csRetval += '\"';
			}
		}
		else if(0 == strncmp(pTraverse, "BL", 2))	{
			//	A boolean
			TwoByteBool *pBool = va_arg(VarList, TwoByteBool *);
			
			if(pBool != NULL)	{
				if(*pBool != FALSE)	{
					csRetval += "TRUE";
				}
				else	{
					csRetval += "FALSE";
				}
			}
		}
		else	{
			//	Unhandled format, just get out of loop.
			ASSERT(0);
			break;
		}
		
		//	Go on to next type
		pTraverse = SkipToNextFormat(pTraverse);
		
		//	See if we need a comma
		if(*pTraverse != '\0')	{
			csRetval += ',';
		}
	}

	//	Done with varargs.
	va_end(VarList);
	
	//	Make sure we're atleast returning something.
	if(csRetval.IsEmpty())	{
		return(NULL);
	}

	//	Return our resultant HDDEDATA, created from our string, be
	//		sure to copy over the terminating NULL, no offset, no
	//		item association, this is text, and the DDEML will own
	//		this once we return it.
	HDDEDATA Final;
	TRACE("Returning HDDEDATA:  %s\n", (const char *)csRetval);
	Final = DdeCreateDataHandle(m_dwidInst,
#ifdef XP_WIN16
		(void *)(const char *)csRetval, 
#else
		(LPBYTE)(const char *)csRetval,
#endif	 
 		csRetval.GetLength() + 1, 0, m_hsz[m_ServiceName],
		CF_TEXT, 0);

	//	Okay, we're not supposed to know this, but the minimum data size of this
	//		object is in increments of 32.  So we're going to do a little proactive
	//		writing to it if need be.
	//	THIS IS A HACK.
	//	I just recently figured out that we need to return actual raw data to the
	//		calling application, so handle it here for now.
	//	This only happens if we have only one argument, check for commas.
	//	Forget the speed considerations, anyone using DDE is insane anyhow.
	if(strchr(pFormat, ',') == NULL)	{
		if(strcmp(pFormat, "BL") == 0)	{
			//	Scan in the value.
			TwoByteBool bData = FALSE;
			if(csRetval == "TRUE")	{
				bData = TRUE;
			}
			DdeFreeDataHandle(Final);
			
			Final = DdeCreateDataHandle(m_dwidInst, (unsigned char *) &bData, sizeof(TwoByteBool), 0, m_hsz[m_ServiceName], CF_TEXT, 0);			
		}
		else if(strcmp(pFormat, "DW") == 0)	{
			//	Scan in the value.
			DWORD dwData;
            dwData = strtoul(csRetval, NULL, 0);
			//sscanf(csRetval, "%lu", &dwData);
			DdeFreeDataHandle(Final);
			
			//	Reset the value in a binary way.
			Final = DdeCreateDataHandle(m_dwidInst, (unsigned char *) &dwData, sizeof(DWORD), 0, m_hsz[m_ServiceName], CF_TEXT, 0);			
		}
	}

	return(Final);
}


//	Purpose:	Move the pointer passed in to the next argument
//	Arguments:	pFormat	the format string wanting to be incremented
//	Returns:	char *	The next format.
//	Comments:	
//	Revision History:
//		01-01-95	created GAB
char *CDDEWrapper::SkipToNextFormat(char *pFormat)
{
	//	Safety dance
	if(pFormat == NULL || *pFormat == '\0')	{
		return(pFormat);
	}

	//	The next format is directly after a ','
	while(*pFormat != ',' && *pFormat != '\0')	{
		pFormat++;
	}
	if(*pFormat == ',')	{
		pFormat++;
	}
	
	return(pFormat);
}


//	Purpose:	Return an allocated char array conatining the contents
//					of a specified argument.
//	Arguments:	hszArgs	The HSZ of all arguments
//				iArg	Integer specifying which argument to extract.
//	Returns:	char *	The allocated array containing the contents of
//							argument iArg, or NULL if there is no such
//							argument or if the argument was empty.
//	Comments:	Quoted strings are counted as only one argument, though
//					the quotes are not copied into the return string.
//	Revision History:
//		01-01-95	created GAB
char *CDDEWrapper::ExtractArg(HSZ& hszArgs, int iArg)
{
	//	Allocate some memory to retrieve infomation from out HSZ.
	DWORD dwLength = DdeQueryString(m_dwidInst, hszArgs, NULL, 0L,
		CP_WINANSI) + 1;
	char *pTraverse = new char[dwLength];
	char *pRemove = pTraverse;
	if(pTraverse == NULL)	{
		return(NULL);
	}	
	DdeQueryString(m_dwidInst, hszArgs, pTraverse, dwLength, CP_WINANSI);
	
	//	safety dance
	if(*pTraverse == '\0' || iArg < 1)	{
		delete(pRemove);
		return(NULL);
	}
	
	//	Need to decrement the argument we're looking for, as the very
	//		first argument has no ',' at the beginning.
	iArg--;
	
	//	Search through the arguments, seperated by ','.
	while(iArg)	{
		//	Special handling of quoted strings.
		if(*pTraverse == '\"')	{
			//	Find the ending quote.
			while(*pTraverse != '\0')	{
				pTraverse++;
				if(*pTraverse == '\"')	{
					pTraverse++;	//	One beyond, please
					break;
				}
				else if(*pTraverse == '\\')	{
					//	Attempting to embed a quoted, perhaps....
					if(*(pTraverse + 1) == '\"')	{
						pTraverse++;
					}
				}
			}
		}
		//	Find the next comma
		while(*pTraverse != '\0' && *pTraverse != ',')	{
			pTraverse++;
		}

		//	Go beyond a comma
		if(*pTraverse == ',')	{
			pTraverse++;
		}
		
		//	Okay, we're at the next argument, decrement our argument
		//		count.
		iArg--;
		
		//	By chance, if we're at the end of the string, break out of
		//		the loop.
		if(*pTraverse == '\0')	{
			break;
		}
	}
	
	//	Handle empty arguments here.
	if(*pTraverse == ',' || *pTraverse == '\0')	{
		delete(pRemove);
		return(NULL);
	}
	
	//	Count chars up to next comma, plus 1 (end of string stuff)
	int iLength = 1;
	char *pCounter = pTraverse;
	TwoByteBool bQuoted = FALSE;
	
	//	specially handle quoted strings
	if(*pCounter == '\"')	{
		//	Go past initial quote.
		pCounter++;
		bQuoted = TRUE;

		//	Find the ending quote.
		while(*pCounter != '\0')	{
			if(*pCounter == '\"')	{
				break;
			}
			else if(*pCounter == '\\')	{
				//	Attempting to embed a quoted, perhaps....
				if(*(pCounter + 1) == '\"')	{
					pCounter++;
					iLength++;
				}
			}
			
			pCounter++;
			iLength++;
		}
	}
	//	Go to next comma
	while(*pCounter != '\0' && *pCounter != ',')	{
		iLength++;
		pCounter++;
	}
	
	//	Subtrace one to ignore ending quote if we were quoted....
	if(bQuoted == TRUE)	{
		iLength--;
	}
	
	//	Argument's of length 1 are of no interest.
	if(iLength == 1)	{
		delete(pRemove);
		return(NULL);
	}
	
	//	Okay, allocate some memory for the string, we'll copy it over.
	char *pRetVal = new char[iLength];
	
	if(*pTraverse == '\"')	{
		pTraverse++;
	}	
	strncpy(pRetVal, pTraverse, iLength - 1);
	pRetVal[iLength - 1] = '\0';
	
	delete(pRemove);

	//	If pRetval begins with a caret, then detect if this is a file.
	//	We will substitue in file data if this is the case.
	if(pRetVal && *pRetVal == '^')	{
		char *pFilename = pRetVal + 1;

		if(*pFilename)	{
			CFileStatus cfs;
			BOOL bValid = CFile::GetStatus(pFilename, cfs);
			if(bValid)	{
				//	We have a file.
				//	Allocate the number of bytes + 1 (for null termination).
				char *pFileData = NULL;
				TRY	{
					pFileData = new char[cfs.m_size + 1];
				}
				CATCH(CException, e)	{
					pFileData = NULL;
				}
				END_CATCH

				if(pFileData != NULL)	{
					TRY	{
                        //  Leave as shared readable for DDE apps looking into the file early.
						CFile cf(pFilename, CFile::modeRead | CFile::shareDenyWrite);

						//	Read in the data.
						cf.Read(pFileData, CASTSIZE_T(cfs.m_size));

						//	Null terminate.
						pFileData[cfs.m_size] = '\0';
					}
					CATCH(CException, e)	{
						//	Opening or reading of the file failed.
						delete pFileData;
						pFileData = NULL;
					}
					END_CATCH
				}

				//	If we have file data, swap with the return value.
				if(pFileData)	{
					delete(pRetVal);
					pRetVal = pFileData;
				}
			}
		}
	}

	return(pRetVal);
}


//	Purpose:	Handle XTYP_REQUEST calls for this conversation.
//	Arguments:	hszTopic	The topic-name of the conversation
//				hszItem		The item-name under this topic
//	Returns:	HDDEDATA	Mainly, we will just pass back the return
//								values of functions that we call
//								depending upon our topic name.  Look
//								there.
//	Comments:	Second level muliplexor, for topics under an already
//					multiplexed conversation.
//				Server only code, here.
//				I would have used function tables to index into the
//					appropriate function on topic type, but the
//					topics are not neccessarily grouped together in
//					the same range as thier topic number.
//	Revision History:
//		12-30-94	created GAB
HDDEDATA CDDEWrapper::RequestHandler(HSZ& hszTopic, HSZ& hszItem)
{
	//	Ensure this conversation is about the topic we think it is.
	if(m_hsz[m_iTopic] != hszTopic)	{
		return(NULL);
	}

	TRACE("REQUEST topic %d\n", m_iTopic);
	
	//	Switch on all possible request topics, and pass params on down.
	switch(m_iTopic)	{
	case m_OpenURL:
		return(OpenURL(hszItem));
	case m_ShowFile:
		return(ShowFile(hszItem));
	case m_Activate:
		return(Activate(hszItem));
	case m_ListWindows:
		return(ListWindows(hszItem));
	case m_GetWindowInfo:
		return(GetWindowInfo(hszItem));
	case m_ParseAnchor:
		return(ParseAnchor(hszItem));
	case m_RegisterProtocol:
		return(RegisterProtocol(hszItem));
	case m_UnRegisterProtocol:
		return(UnRegisterProtocol(hszItem));
	case m_RegisterViewer:
		return(RegisterViewer(hszItem));
	case m_UnRegisterViewer:
		return(UnRegisterViewer(hszItem));
	case m_RegisterWindowChange:
		return(RegisterWindowChange(hszItem));
	case m_UnRegisterWindowChange:
		return(UnRegisterWindowChange(hszItem));
	case m_BeginProgress:
		return(BeginProgress(hszItem));
	case m_MakingProgress:
		return(MakingProgress(hszItem));
	case m_EndProgress:
		return(EndProgress(hszItem));
	case m_Version:
		return(Version(hszItem));
	case m_QueryURLFile:
	    return(QueryURLFile(hszItem));
	case m_ListFrameChildren:
		return(ListFrameChildren(hszItem));
	case m_GetFrameParent:
		return(GetFrameParent(hszItem));
    // Start of the Netscape 5.0 topics (Dave Hyatt - 8/13/97)
	case m_RegisterStatusBarChange: 
		return(RegisterStatusBarChange(hszItem));
	case m_UnRegisterStatusBarChange:
		return(UnRegisterStatusBarChange(hszItem)); 
	case m_NavigateBack:
		return(NavigateBack(hszItem));	
	case m_NavigateForward:
		return (NavigateForward(hszItem));	
	case m_Stop:
		return (Stop(hszItem));
	case m_Reload:
		return (Reload(hszItem));
    case m_UserAgent:
        return (UserAgent(hszItem));
    case m_Cache_ClearCache:
        return (ClearCache(hszItem));
    case m_Cache_Filename:
        return (CacheFilename(hszItem));
    case m_Cache_InCache:
        return (InCache(hszItem));
    case m_Cache_RemoveURL:
        return (CacheRemoveURL(hszItem));
    case m_Cache_AddURL:
        return (CacheAddURL(hszItem));
    case m_History_ClearHistory:
        return (ClearHistory(hszItem));
    case m_History_AddURL:
        return (HistoryAddURL(hszItem));
    case m_History_RemoveURL:
        return (HistoryRemoveURL(hszItem));
    case m_History_InHistory:
        return (InHistory(hszItem));
    case m_History_NumEntries:
        return (HistoryNumEntries(hszItem));
    case m_History_GetEntry:
        return (HistoryGetEntry(hszItem));
    case m_GetWindowID:
        return (GetWindowID(hszItem));
    case m_SupportsMimeType:
        return (SupportsMimeType(hszItem));
    case m_ExecuteJavaScript:
        return (ExecuteJavaScript(hszItem));
    case m_PrintWindow:
        return (PrintWindow(hszItem));
    case m_PrintURL:
        return (PrintURL(hszItem));

	}

	//	Default, should never reach.
	return(NULL);
}

//	Purpose:	Handle XTYP_POKE calls for this conversation.
//	Arguments:	hszTopic	The topic-name of the conversation
//				hszItem		The item-name under this topic
//				hData		Identifies data the client is sending to
//								this server conversation.
//	Returns:	HDDEDATA	Mainly, we will just pass back the return
//								values of functions that we call
//								depending upon our topic name.  Look
//								there.
//	Comments:	Second level muliplexor, for topics under an already
//					multiplexed conversation.
//				Server only code, here.
//				I would have used function tables to index into the
//					appropriate function on topic type, but the
//					topics are not neccessarily grouped together in
//					the same range as thier topic number.
//	Revision History:
//		12-30-94	created GAB
HDDEDATA CDDEWrapper::PokeHandler(HSZ& hszTopic, HSZ& hszItem,
	HDDEDATA& hData)
{
	//	Ensure this conversation is about the topic we think it is.
	if(m_hsz[m_iTopic] != hszTopic)	{
		return(NULL);
	}
	
	TRACE("POKE topic %d\n", m_iTopic);
	
	//	Switch on all possible poke topics, and pass params on down.
	switch(m_iTopic)	{
	case m_Exit:
		return(Exit(hszItem, hData));
	case m_SetProgressRange:
		return(SetProgressRange(hszItem, hData));
	case m_RegisterURLEcho:
		return(RegisterURLEcho(hszItem, hData));
	case m_UnRegisterURLEcho:
		return(UnRegisterURLEcho(hszItem, hData));
	case m_RegisterAnimationEcho:
		return(RegisterAnimationEcho(hszItem, hData));
	case m_UnRegisterAnimationEcho:
		return(UnRegisterAnimationEcho(hszItem, hData));
	case m_WindowChange:
		return(WindowChange(hszItem, hData));
	case m_CancelProgress:
		return(CancelProgress(hszItem, hData));
	}

	//	Default, should never reach.
	return((HDDEDATA)DDE_FNOTPROCESSED);
}

//	Purpose:	Bring Netscape to the top of all other applications,
//					and show the windows specified.  This will restore
//					minimized Netscape icons.
//	Arguments:	hszItem	A string representing our real parameters.
//	Returns:	HDDEDATA	Returns the ID of the window that was
//								activated and has focus.
//							NULL on failure.
//	Comments:	Parameters within hszItem are
//					WindowID,Flags
//				WindowID is the handle of the window to restore, or bring
//					to the top.  -1 means don't care, I suppose.
//				Flags is currently reserved for later use, so just
//					ignore it.
//	Revision History:
//		12-31-94	created GAB
HDDEDATA CDDEWrapper::Activate(HSZ& hszItem)
{
	DWORD ReturnID = 0L;

	//	Obtain our arguments.
	DWORD WindowID;
	DWORD Flags;
	ScanArgs(hszItem, "DW,DW", &WindowID, &Flags);
	
	//	If we have a specified WindowID, attempt to activate it.
	if(WindowID != 0xFFFFFFFF && WindowID != 0x0)	{
		//	See if it's a valid Window ID
		CFrameWnd *pWnd = FEU_FindFrameByID(WindowID, MWContextBrowser);
		if(pWnd != NULL)	{
			if(pWnd->IsIconic())	{
				pWnd->ShowWindow(SW_RESTORE);
			}
            ::SetWindowPos(pWnd->GetSafeHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
#ifdef XP_WIN32
            pWnd->SetForegroundWindow();
#endif
			
			//	Success, set the return value.
			ReturnID = WindowID;
        }
	}
	else if(WindowID != 0x0)	{
		//	If we have no windows, then it's time to create a new one.
		//	This is a valid possibility, since we could be doing some
		//		type of background work through OLE.
		if(XP_ContextCount(MWContextBrowser, TRUE) == 0)	{
			CFE_CreateNewDocWindow(NULL, NULL);
		}
	
		//	We're just supposed to bring ourselves to the front.
		//	Return the WindowID of the window up front.
		//	Since if there wasn't an active window, then we created one,
		//		the value returned by the below should never be NULL.
		CFrameWnd *pWnd = FEU_GetLastActiveFrame(MWContextBrowser);
		if(pWnd != NULL)	{
			if(pWnd->IsIconic())	{
				pWnd->ShowWindow(SW_RESTORE);
			}
            ::SetWindowPos(pWnd->GetSafeHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
#ifdef XP_WIN32
            pWnd->SetForegroundWindow();
#endif

			//	Success, set the return value.
			CFrameGlue *pGlue = CFrameGlue::GetFrameGlue(pWnd);
			if(pGlue != NULL)	{
				if(pGlue->GetActiveContext() != NULL)	{
					ReturnID = pGlue->GetActiveContext()->GetContextID();
				}
				else if(pGlue->GetMainContext() != NULL)	{
					ReturnID = pGlue->GetMainContext()->GetContextID();
				}
			}
		}
	}

    if(ReturnID)    {
        //  Activate it for real.
        CAbstractCX *pCX = CAbstractCX::FindContextByID(ReturnID);
        if(pCX && pCX->IsFrameContext() && pCX->GetContext()->type == MWContextBrowser)  {
            CWinCX *pWinCX = (CWinCX *)pCX;
            if(pWinCX->GetFrame() && pWinCX->GetFrame()->GetFrameWnd())   {
                pWinCX->
                    GetFrame()->
                    GetFrameWnd()->
                    SetActiveView(pWinCX->GetView(), TRUE);
            }
        }
    }
	
	// HDDEDATA hData = DdeCreateDataHandle(m_dwidInst, &ReturnID, sizeof(DWORD), 0, NULL, 0, 0);
	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}


//	Purpose:	Retrieves a URL from the net, and either dumps it into
//					a file, or displays it in a given frame.
//	Arguments:	hszArgs	A string representing our real parameters.
//	Returns:	HDDEDATA	Returns the actual WindowID of the window
//								the performed the open, where 0 means
//								the operation failed, and 0xFFFFFFFF
//								means the data was not of an appropriate
//								MIME type to display in a Web browser....
//	Comments:	Parameters within hszItem are
//					URL,[FileSpec],WindowID,Flags,[FormData],[MIMEType],
//						[ProgressApp]
//						URL is the location to load
//						FileSpec is the file to dump the load to
//						WindowID is the window to load into, 0 meaning
//							a new window, 0xFFFFFFFF means the default
//							window.
//						Flags are:
//							0x1	Ignore document cache
//							0x2	Ignore image cache
//							0x4	Operate in the background (?)
//						FormData allows the POSTing of a form.
//						MIMEType specifies the form data mime type.
//						ProgressApp can be named, which is a DDE server
//							that will handle progress messages....
//						
//	Revision History:
//		01-02-95	created GAB
HDDEDATA CDDEWrapper::OpenURL(HSZ& hszArgs)
{
	DWORD dwReturn = 0L;
	
	//	Obtain our arguments.
	CString csURL;
	CString csFileSpec;
	DWORD dwWindowID;
	DWORD dwFlags;
	CString csFormData;
	CString csMimeType;
	CString csProgressApp;
	ScanArgs(hszArgs, "QCS,QCS,DW,DW,QCS,QCS,CS", &csURL, &csFileSpec,
		&dwWindowID, &dwFlags, &csFormData, &csMimeType,
		&csProgressApp);
		
	//	This is very important.
	//	If the client specified a server callback service, then we need
	//		to save this right now.
	//	It will be used in WWW_Alert, WWW_BeginProgress,
	//		WWW_SetProgressRange, WWW_MakingProgress, and WWW_EndProgress.
	m_csProgressApp = csProgressApp;
	
	//	Get the appropriate window.
	if(dwWindowID == 0)	{
		//	They want a new window.
		if(NULL != CFE_CreateNewDocWindow(NULL, NULL))	{
			//	Window ID is no longer 0.
			dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
		}
	}
	else if(dwWindowID == 0xFFFFFFFF)	{
		//	They want the current frame....
		//	See if we even have one.
		if(XP_ContextCount(MWContextBrowser, TRUE) == 0)	{
			if(NULL != CFE_CreateNewDocWindow(NULL, NULL))	{
				//	Window ID is no longer 0.
				dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
			}
			else	{
				dwWindowID = 0;
			}
		}
		else	{
			if(FEU_GetLastActiveFrame(MWContextBrowser) != NULL)	{
				//	Should be safe.
				dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
			}
			else	{
                //  No last active frame, but more than one window....
                //  Just create a new one.  Can't pick one up arbitrarily.
                if(NULL != CFE_CreateNewDocWindow(NULL, NULL))  {
					dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
                }
                else {
				    dwWindowID = 0;
                }
			}
		}
	}
	else	{
		//	They are requesting a specific frame.
		//	See if we've got it.
		if(FEU_FindFrameByID(dwWindowID, MWContextBrowser) == NULL)	{
			dwWindowID = 0;
		}
	}
	
	//	Get the frame
    CAbstractCX *pCX = CAbstractCX::FindContextByID(dwWindowID);
    if(!pCX || !pCX->IsFrameContext() || !pCX->GetContext() || pCX->GetContext()->type != MWContextBrowser)
    {
        dwWindowID = 0;
    }
	
	//	See if the window exists, a value of 0 means failure at this
	//		point.
	if(dwWindowID == 0)	{
		//	Well, either the window didn't exist, or we couldn't create
		//		a new window.
		return(MakeArgs("DW", &dwWindowID));
	}
	
	//	So far so good.  Our current return value will be the window ID,
	//		until another failure further along.
	dwReturn = dwWindowID;
	
	//	Decide whether or not to force a reload.
	NET_ReloadMethod Reload = NET_DONT_RELOAD;
	if(dwFlags & 0x1 || dwFlags & 0x2)	{
		Reload = NET_NORMAL_RELOAD;
	}
	
	//	Create the URL structure to load up the URL.
	URL_Struct *pURL = NET_CreateURLStruct(csURL,  Reload);
	
	//	See if we've got some form to POST.
	if(csFormData.IsEmpty() != TRUE)	{
		//	We don't allow anything but a post....
		pURL->method = URL_POST_METHOD;
		
		//	We need to fill in the post data, memory is freed by netlib.
		char *cp_FormData = (char *)XP_ALLOC(csFormData.GetLength() + 1);
		strcpy(cp_FormData, csFormData);
		pURL->post_data = cp_FormData;

		//	Set the length of the data, don't include our final NULL
		//		I suppose.
		pURL->post_data_size = csFormData.GetLength();
		
		//	We need to manually fill in the Content-type:
		//	If there's not one specified, we default to
		//		applications/x-www-form-urlencoded
		if(csMimeType.IsEmpty() != TRUE)	{
			StrAllocCopy(pURL->post_headers, "Content-type: ");
			StrAllocCat(pURL->post_headers, csMimeType);			
		}
		else	{
			StrAllocCopy(pURL->post_headers,
				"Content-type: application/x-www-form-urlencoded");
		}
		StrAllocCat(pURL->post_headers, CRLF);

		//	Also now need to fill in content-length....
		char aBuffer[1024];
		sprintf(aBuffer, "Content-length: %d", csFormData.GetLength());
		StrAllocCat(pURL->post_headers, aBuffer);
		StrAllocCat(pURL->post_headers, CRLF);
	}
	
	//	Have the URL load.  We simply can't block our return value until
	//		all connections are completed for the window because we
	//		hose all the messaging.
	MWContext *pContext = pCX->GetContext();
    
	//	Here we should set up all progress callbacks.
	//	So whenever we get an Alert, or any progress messages, we'll
	//		be sending it on down to this callback.
	//	This must be cleared in GetURL_exit_routine
	if(csProgressApp.IsEmpty() == FALSE && pContext != NULL)	{
		//	Set up a progress app for this one.
		CNcapiUrlData *pNcapi = new CNcapiUrlData(ABSTRACTCX(pContext), pURL);
		pNcapi->SetProgressServer(csProgressApp);
	}

	if(pContext != NULL)	{
		if(csFileSpec.IsEmpty())	{
			//	Load up.
			ABSTRACTCX(pContext)->GetUrl(pURL, FO_CACHE_AND_PRESENT);
		}
		else	{
			//	Load to file.		
			//	Protect against re-entrancy
			if(pContext->save_as_name)	{
				XP_FREE(pContext->save_as_name);
				pContext->save_as_name = NULL;
			}
			pContext->save_as_name = strdup(csFileSpec);

			//	Load up.
			ABSTRACTCX(pContext)->GetUrl(pURL, FO_CACHE_AND_SAVE_AS);
	    }
	}
    
	return(MakeArgs("DW", &dwReturn));
}


//	Purpose:	Register a DDE viewer
//	Arguments:	hszItem	The arguement string.
//	Returns:	HDDEDATA	A boolean indicating success or failure of
//								the registration.
//	Comments:	Parameters withing hszItem are
//					qcsApplication	The DDE server which will handle
//										the requests.
//					qcsMIMEType		The mime type that the viewer wants
//										to handle.
//					dwFlags	Flags on how to handle:
//								0x00000001	Platform specific open document command.
//								0x00000002	Use of a QueryViewer DDE command, to ask for a file spec.
//								0x00000004	Use ViewDocFile DDE command.
//								0x00000008	Use ViewDocData, not supported.
//				The only registration we allow will be FO_PRESENT
//				There is a default if the flags is 0, which is
//					ViewDocFile method.
//	Revision History:
//		01-06-94	created GAB
HDDEDATA CDDEWrapper::RegisterViewer(HSZ& hszItem)
{
	//	Scan in our arguments.
	CString csApplication;
	CString csMimeType;
	DWORD dwFlags;
	ScanArgs(hszItem, "QCS,QCS,DW", &csApplication, &csMimeType, &dwFlags);
	
	TwoByteBool bRetval = TRUE;
	
	//	Extract out if we are going to be using the QueryViewer command.
	TwoByteBool bQueryViewer = (dwFlags & 0x2UL) != 0UL ? TRUE : FALSE;
	if(bQueryViewer == TRUE)	{
		dwFlags ^= 0x2;
	}
	
	//	Screen any flags we don't support
	if(dwFlags != 0x1 && dwFlags != 0x4)	{
		bRetval = FALSE;
		return(MakeArgs("BL", &bRetval));
	}
	
	//	Make sure the application and mime type aren't empty.
	if(csApplication.IsEmpty() || csMimeType.IsEmpty())	{
		bRetval = FALSE;
		return(MakeArgs("BL", &bRetval));
	}
	
	//	Build a special data object to be handed to each stream.
	//	Basically this will contain the DDE server to contact once we
	//		are receiving data, and will contain the flag representing
	//		how the data should be handled.
	//	We will also be marking this MimeType as un overrideable, until
	//		it is unregistered.
	CDDEStreamData *pCData = new CDDEStreamData(csApplication, csMimeType,
		dwFlags, bQueryViewer);

	//	Register a special converter for the mime type.
	if(FALSE == WPM_RegisterContentTypeConverter(
		(char *)(const char *)csMimeType, FO_PRESENT,
		(void *)pCData, dde_stream, TRUE))	{

		//	Couldn't do it, another remote control client is already
		//		using this mime type.
		delete pCData;
		bRetval = FALSE;		
	}
	
	return(MakeArgs("BL", &bRetval));
}


//	Purpose:	Determine the URL a temp file came from.
//	Arguments:	hszItem	The arguement string.
//	Returns:	HDDEDATA	The URL, or NULL on failure.
//	Comments:	Parameters withing hszItem are
//					qcsFileName	The file name to look up.
//	Revision History:
//		03-21-95	created GAB
HDDEDATA CDDEWrapper::QueryURLFile(HSZ& hszItem)
{
	//	Scan in our arguments.
	CString csFileName;
	ScanArgs(hszItem, "QCS", &csFileName);
    csFileName.MakeLower();
	
	CString csRetval;
	
    //  Find out if the file name is one we know about.
    csRetval = theApp.GetProfileString("Temporary File URL Resolution", csFileName, "");

    if(csRetval.IsEmpty())  {
        return(NULL);
    }
	
	return(MakeArgs("QCS", &csRetval));
}


//	Purpose:	Unregisters on the fly a DDE content type converter.
//	Arguments:	hszItem	Our arguments, in a string
//	Returns:	HDDEDATA	A boolean indicating the success of the
//								operation, which should always be TRUE.
//	Comments:	Our real arguments inside hszItem are
//					qcsApplication	The DDE server to unregister
//					qcsMimeType		The Mime type to unregister
//				The only registration we allow will be FO_PRESENT
//	Revision History:
//		01-06-95	created GAB
HDDEDATA CDDEWrapper::UnRegisterViewer(HSZ& hszItem)
{
	//	Retrieve our arguments.
	CString csApplication;
	CString csMimeType;
	ScanArgs(hszItem, "QCS,QCS", &csApplication, &csMimeType);
	
	TwoByteBool bRetval = TRUE;

	if(csApplication.IsEmpty() || csMimeType.IsEmpty())	{
		bRetval = FALSE;
		return(MakeArgs("BL", &bRetval));
	}
	
	CDDEStreamData *pCData =
		(CDDEStreamData *)WPM_UnRegisterContentTypeConverter(csApplication,
		csMimeType, FO_PRESENT);
		
	if(pCData == NULL)	{
		bRetval = FALSE;
	}
	else	{
		delete pCData;
	}

	return(MakeArgs("BL", &bRetval));
}


//	Purpose:	Connect to a service using a specific topic
//	Arguments:	cpService	The service name of the DDE server
//				hszTopic	The topic of the conversation to the server
//	Returns:	CDDEWrapper *	The conversation object if established,
//									otherwise NULL.
//	Comments:	Generic connection establishment.
//	Revision History:
//		01-05-95	created GAB
CDDEWrapper *CDDEWrapper::ClientConnect(const char *cpService,
	HSZ& hszTopic)
{
	CDDEWrapper *pConv = NULL;

	//	Make the service name into an HSZ.
	HSZ hszService = DdeCreateStringHandle(m_dwidInst, 
	                                       (char *) cpService,
										   CP_WINANSI);
	if(hszService == NULL)	{
		return(NULL);
	}
	
	//	Establish the connection.
	HCONV hConv = DdeConnect(m_dwidInst, hszService, hszTopic, NULL);
	if(hConv != NULL)	{
		//	We have a connection, all that's left to do is to create
		//		a CDDEWrapper, we'll be creating it with the wrong
		//		service name of course, but client connections no
		//		longer really care about the service connection number,
		//		all they need is the conversation handle.
		pConv = new CDDEWrapper(m_hsz[m_ServiceName], hszTopic, hConv);
	}
		
	//	Free off our created hsz.
	DdeFreeStringHandle(m_dwidInst, hszService);
	
	//	Our return value, sir.
	return(pConv);
}


//	Purpose:	Send the service app a begin progress verb.
//	Arguments:	pNcapi	The url data causing this to occur.
//				pService	The service name to connect to.
//				dwWindowID	The windowID which has progressed.
//				pMessage	The message to show in the server.
//	Returns:	DWORD	The transaction ID that the server sends us
//							to use in all other progress verbs.
//	Comments:	Netscape is a DDE client in this function.
//	Revision History:
//		01-05-95	created GAB
//		10-17-95	modified to use CNcapiUrlData
DWORD CDDEWrapper::BeginProgress(CNcapiUrlData *pNcapi, const char *pService,
	DWORD dwWindowID, const char *pMessage)
{
	DWORD dwTransactionID;

	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService, m_hsz[m_BeginProgress]);
	
	//	If we didn't connect, don't let the document try this again
	//		for this progress.
	if(pConv == NULL)	{
		pNcapi->ClearProgressServer();
		return(0L);
	}	

	//	Save our conversation, in case the server decides to disconnect
	//		behind our backs.
	HCONV hSaveConv = pConv->m_hConv;

	//	Create our Item arguemnts.
	CString csTemp = pMessage;
	HSZ hszItem = MakeItemArgs("DW,QCS", &dwWindowID, &csTemp);
	
	//	Do the transaction, expect a transaction ID back.
	HDDEDATA ddeTransaction = DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_REQUEST, m_Timeout, NULL);
	
	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv != NULL)	{
		delete pConv;
	}
	
	if(ddeTransaction == NULL)	{
		//	Server didn't want to process this.
		//	Don't try them again.
		pNcapi->ClearProgressServer();
	
		dwTransactionID = 0L;
	}
	else	{
		//	Scan in the progress ID, and get rid of the handle.
		//	Well, it would seem that they're not following their own
		//		spec.  They send us raw data, get it that way.
		//ScanArgs(ddeTransaction, "DW", &dwTransactionID);
		if(ddeTransaction != NULL)	{
			ScanDataArgs(ddeTransaction, "DW", &dwTransactionID);
			DdeFreeDataHandle(ddeTransaction);
		}
		else	{
			dwTransactionID = 0L;
		}
	}

	//	If the transaction ID is 0, then they don't want progress.
	if(dwTransactionID == 0)	{
		pNcapi->ClearProgressServer();
	}
	
	return(dwTransactionID);
}


//	Purpose:	Tell the DDE server our progress range.
//	Arguments:	pNcapi	The url data initiating this request.
//				pService	The server's service name.
//				dwTransactionID	The transaction ID of this progress.
//				dwMaxRange	The max range that we can achieve.
//	Returns:	void
//	Comments:	Netscape is the DDE client.
//	Revision History:
//		01-05-94	created GAB
//		10-17-95	modified to use CNcapiUrlData
void CDDEWrapper::SetProgressRange(CNcapiUrlData *pNcapi, const char *pService,
	DWORD dwTransactionID, DWORD dwMaxRange)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService,
		m_hsz[m_SetProgressRange]);
	
	//	If we didn't connect, don't let the document try this again
	//		for this progress.
	if(pConv == NULL)	{
		pNcapi->ClearProgressServer();
		return;
	}

	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our item arguments.
	HSZ hszItem = MakeItemArgs("DW,DW", &dwTransactionID, &dwMaxRange);

	//	Do the transaction, expect nothing back XTYP_POKE
	if(FALSE == DdeClientTransaction(NULL, 0L, hSaveConv, hszItem,
		CF_TEXT, XTYP_POKE, m_Timeout, NULL))	{
		//	For some reason, this didn't fly.
		//	Don't let the document try this again.
		pNcapi->ClearProgressServer();
	}

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	pConv = GetConvObj(hSaveConv);
	if(pConv != NULL)	{
		delete pConv;
	}
}


//	Purpose:	Tell the DDE server that we have made progress.
//	Arguments:	pNcapi	The document initiating this request.
//				pServic	The server's service name
//				dwTransactionID	The transaction ID to send with the
//							message, aquired by a begin progress call.
//				pMessage	A message to send to the server, explaining
//								the progress message.
//				dwCurrent	A number, representing a range, which
//								was set by a set progress range call.
//	Returns:	TwoByteBool	TRUE	The server would like to discontinue
//									the download.
//						FALSE	Continue downloading.
//	Comments:	Netscape is a DDE client.
//	Revision History:
//		01-05-95	created GAB
//		10-17-95	modified to use CNcapiUrlData
TwoByteBool CDDEWrapper::MakingProgress(CNcapiUrlData *pNcapi, const char *pService,
	DWORD dwTransactionID, const char *pMessage, DWORD dwCurrent)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService,
		m_hsz[m_MakingProgress]);
	
	//	If we didn't connect, don't let the document try this again
	//		for this progress.
	if(pConv == NULL)	{
		pNcapi->ClearProgressServer();
		return(FALSE);
	}

	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our item arguments.
	CString csMessage = pMessage;
	HSZ hszItem = MakeItemArgs("DW,QCS,DW", &dwTransactionID, &csMessage,
		&dwCurrent);

	//	Do the transaction, expect a TwoByteBool back.
	HDDEDATA ddeTransaction = DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_REQUEST, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
	
	TwoByteBool bResult = FALSE;
	
	if(ddeTransaction == NULL)	{
		//	Server didn't want to process this.
		//	Don't try them again.
		pNcapi->ClearProgressServer();
	}
	else	{
		//	Scan in the progress ID, and get rid of the handle.
		if(ddeTransaction != NULL)	{
			ScanDataArgs(ddeTransaction, "BL", &bResult);
			DdeFreeDataHandle(ddeTransaction);
		}
		else	{
			bResult = FALSE;
		}
	}
	
	return(bResult);
}


//	Purpose:	Tell the DDE server that the progress is ending.
//	Arguments:	pNcapi	The document initiating the request
//				pService	The server's service name
//				dwTransactionID	The transaction ID of these progress
//									messages.
//	Returns:	TwoByteBool	A success or failure boolean, we really don't
//							care, and will always end.
//				BUT WAIT, the spec says this, but in reality, it isn't
//							done.
//	Comments:	Netscape is the DDE client.
//	Revision History:
//		01-05-95	created GAB
//		10-17-95	modified to use CNcapiUrlData
void CDDEWrapper::EndProgress(CNcapiUrlData *pNcapi, const char *pService,
	DWORD dwTransactionID)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService,
		m_hsz[m_EndProgress]);
	
	//	If we didn't connect, don't let the document try this again
	//		for this progress.
	if(pConv == NULL)	{
		pNcapi->ClearProgressServer();
		return;
	}

	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our item arguments.
	HSZ hszItem = MakeItemArgs("DW", &dwTransactionID);

	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_POKE, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
}


//	Purpose:	Send our progress app an error message.
//	Arguments:	pDoc	The document requesting this action
//				pService	The server's service name
//				pMessage	The message to send
//	Returns:	DWORD	The button pushed by the remote app, or error (0)
//							on failuer.
//	Comments:	All servers should consider this message as a failure to
//					load.
//	Revision History:
//		01-05-95	created GAB
//		10-17-95	modified to use CNcapiUrlData
DWORD CDDEWrapper::AlertProgress(CNcapiUrlData *pNcapi, const char *pService,
	const char *pMessage)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService,
		m_hsz[m_Alert]);
	
	//	If we didn't connect, simply return, not everyone will have
	//		this verb.
	if(pConv == NULL)	{
		return(m_PushedError);
	}

	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our item arguments.
	CString csMessage = pMessage;
	DWORD dwType = m_AlertError;	// error box
	DWORD dwButtons = m_ButtonOk;	//	What buttons to show
	HSZ hszItem = MakeItemArgs("QCS,DW,DW", &csMessage, &dwType,
		&dwButtons);

	//	Do the transaction
	HDDEDATA ddeTransaction = DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_REQUEST, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
	
	DWORD dwResult = 0L;
	
	if(ddeTransaction != NULL)	{
		//	Scan in the return value, and get rid of the handle.
		ScanDataArgs(ddeTransaction, "DW", &dwResult);
		DdeFreeDataHandle(ddeTransaction);
	}
	
	return(dwResult);
}

//	Purpose:	Send our progress app a confirmation message.
//	Arguments:	pNcapi	The document requesting this action
//				pService	The server's service name
//				pMessage	The message to send
//	Returns:	DWORD	The button pushed by the remote app, or error (0)
//							on failuer.
//	Comments:
//	Revision History:
//		10-17-95	created
DWORD CDDEWrapper::ConfirmProgress(CNcapiUrlData *pNcapi, const char *pService,
	const char *pMessage)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(pService,
		m_hsz[m_Alert]);
	
	//	If we didn't connect, simply return, not everyone will have
	//		this verb.
	if(pConv == NULL)	{
		return(m_PushedError);
	}

	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our item arguments.
	CString csMessage = pMessage;
	DWORD dwType = m_AlertQuestion;	// error box
	DWORD dwButtons = m_ButtonYesNo;	//	What buttons to show
	HSZ hszItem = MakeItemArgs("QCS,DW,DW", &csMessage, &dwType,
		&dwButtons);

	//	Do the transaction
	HDDEDATA ddeTransaction = DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_REQUEST, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);
	
	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
	
	DWORD dwResult = 0L;
	
	if(ddeTransaction != NULL)	{
		//	Scan in the return value, and get rid of the handle.
		ScanDataArgs(ddeTransaction, "DW", &dwResult);
		DdeFreeDataHandle(ddeTransaction);
	}
	
	return(dwResult);
}


//	Purpose:	Ask a DDE server what file we should save a file under,
//					one that we just downloaded.
//	Arguments:	pDData	Our download data, will hold everything needed
//							to establish the conversation.
//	Returns:	void
//	Comments:	Another topic should be called after this one in order
//		to tell the registered viewer that it's document is now ready.
//	Revision History:
//		01-06-95	created GAB
void CDDEWrapper::QueryViewer(CDDEDownloadData *pDData)
{
	//	Get our parameters to establish the conversation.
	CString csService = pDData->m_pCData->m_csServerName;
	
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(csService, m_hsz[m_QueryViewer]);
		
	if(pConv == NULL)	{
		//	There's not much else we can do here, simply return.
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our argument list.
	CString csURL;
	CString csMimeType;
	csMimeType = pDData->m_pCData->m_csMimeType;
	csURL = pDData->m_csURL;
	HSZ hszItem = MakeItemArgs("QCS,QCS", &csURL, &csMimeType); 
	
	//	Do the transaction, expect a FileSpec back.
	HDDEDATA ddeTransaction = DdeClientTransaction(NULL, 0L,
		hSaveConv, hszItem, CF_TEXT, XTYP_REQUEST, m_Timeout, NULL);	

	//	Get rid of our string handle, don't need it anymore; same with the
	//		connection.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}

	if(ddeTransaction == NULL)	{
		//	There's not much else we can do here, simply return.
		return;
	}

	//	Get the file name out of the data returned by the DDE server.
	CString csFileName;
	ScanDataArgs(ddeTransaction, "QCS", &csFileName);
	DdeFreeDataHandle(ddeTransaction);
	
	//	Move it over to where the server wants it.
	TRY	{
		CFile::Rename(pDData->m_csFileName, csFileName);
	}
	CATCH(CFileException, e)	{
		//	Couldn't rename for some reason.
		return;
	}
	END_CATCH

	//	Tell the download data, that it won't be necessary to delete this file.
	//	The viewer will take care of it.
	pDData->m_bDelete = FALSE;
	
	//	Change the name.
	pDData->m_csFileName = csFileName;
	
	//	Done.
	return;
}


//	Purpose: 		Tell a registered viewer that a document of it's type is loaded
//						and in a certain file.
//	Arguments:	pDData	The download instance specific data, contains
//							the file name.
//	Returns:	void
//	Comments:	Function will unregister any viewers that don't respond in
//					a fashion that we deem fit.
//	Revision History:
//		01-08-95	created GAB
void CDDEWrapper::ViewDocFile(CDDEDownloadData *pDData)
{
	//	Get our parameters to establish the conversation.
	CString csService = pDData->m_pCData->m_csServerName;
	
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(csService, m_hsz[m_ViewDocFile]);
		
	if(pConv == NULL)	{
		//	Well, Doh!, the server isn't responding.
		//	Disable it from further being our registered app.
		CString csMimeType = pDData->m_pCData->m_csMimeType;
		WPM_UnRegisterContentTypeConverter(csService, csMimeType,
			FO_PRESENT);
		delete pDData->m_pCData;
		
		//	There's not much else we can do here, simply return.
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;
	
	//	Create our argument list.
	CString csFileSpec = pDData->m_csFileName;
	CString csURL = pDData->m_csURL;
	CString csMimeType = pDData->m_pCData->m_csMimeType;
	DWORD dwWindowID = pDData->m_dwFrameID;
	HSZ hszItem = MakeItemArgs("QCS,QCS,QCS,DW", &csFileSpec, &csURL,
		&csMimeType, &dwWindowID);
		
	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_POKE, m_Timeout, NULL);		

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
	
	//	Done here.
	return;
}

//	Purpose:	Use a shell open to open the file name in our download data.
//	Arguments:	pDData	Data specific to this download.
//	Returns:	void
//	Comments:	Support of another RegisterViewer command.
//	Revision History:
//		01-14-95	created GAB
void CDDEWrapper::OpenDocument(CDDEDownloadData *pDData)
{
	//	Well, we don't really do any DDE per se here, but this is where the
	//		funciton logically belongs.
	//	Attempt to have windows open the file specified.
	//	This is a fire and forget mechanism, though we will unregister the
	//		DDE content type converter on an error.
	HINSTANCE hReturns = ::ShellExecute(::GetDesktopWindow(), NULL, pDData->m_csFileName, NULL, NULL, SW_SHOW);
	if(hReturns <= (HINSTANCE)32)	{
		//	There seemed to have been an error.
		//	Unregister the content type converter now.
		CString csService = pDData->m_pCData->m_csServerName;
		CString csMimeType = pDData->m_pCData->m_csMimeType;
		WPM_UnRegisterContentTypeConverter(csService, csMimeType,
			FO_PRESENT);
		delete pDData->m_pCData;
	}
}


//	Purpose:	Exit the Netscape application.
//	Arguments:	hszItem	Our arguments.
//				hData	Any data in particular that the server is sending us.
//	Returns:	HDDEDATA	Wether or not we completed this operation.
//	Comments:	Netscape will not always exit on this command, since we may be automated.
//	Revision History:
//		01-13-95	created GAB
//		10-17-95	modified to send the last active frame, if around, the
//						ID_APP_EXIT WM_COMMAND message.
HDDEDATA CDDEWrapper::Exit(HSZ& hszItem, HDDEDATA& hData)
{
	//	See if any frame windows are around.
	CFrameWnd *pWnd = FEU_GetLastActiveFrame();
	if(pWnd != NULL)	{
		//	Send it the app exit message.
		pWnd->PostMessage(WM_COMMAND, ID_APP_SUPER_EXIT);
		return((HDDEDATA)DDE_FACK);
	}

    return((HDDEDATA)DDE_FNOTPROCESSED);
}


//	Purpose:	Get some misc information about a Netscape window.
//	Arguments:	hstItem	Our arugments, see below.
//	Returns:	HDDEDATA	Contains
//					qcsUrl	The current URL loaded in the window.
//					qcsTitle	The current title of the window.
//	Comments:	This is useless, but implementable.
//	Revision History:
//		01-13-95	created GAB
HDDEDATA CDDEWrapper::GetWindowInfo(HSZ& hszItem)
{
	//	Retrieve our arguments.
	DWORD dwFrameID;
	ScanArgs(hszItem, "DW", &dwFrameID);
	
	//	We'll let dwFrameID be 0xffffffff for the default window.
	if(dwFrameID == 0xFFFFFFFF)	{
		dwFrameID = FEU_GetLastActiveFrameID(MWContextBrowser);
		if(dwFrameID == 0)	{
			//	This is going to fail, no active window.
			return(NULL);
		}
	}
	
	//	Okay, all we have left to do is obtain the current title of the window,
	//		and the current loaded URL.
    CAbstractCX *pCX = CAbstractCX::FindContextByID(dwFrameID);
    if(pCX && pCX->GetContext() && pCX->GetContext()->type != MWContextBrowser) {
        pCX = NULL;
    }

	if(pCX == NULL)	{
		return(NULL);
	}
	
	//	Get the stuff.
	CString csTitle;
	CString csUrl;
    CString csName;

    if(pCX->GetContext())   {
        if(pCX->GetContext()->title)    {
            csTitle = pCX->GetContext()->title;
        }
	    if(pCX->GetContext()->hist.cur_doc_ptr)	{
		    if(pCX->GetContext()->hist.cur_doc_ptr->address)	{
			    csUrl = pCX->GetContext()->hist.cur_doc_ptr->address;
		    }
	    }
        if(pCX->GetContext()->name)   {
            csName = pCX->GetContext()->name;
        }
    }
	
	//	Create our return arguments.
	return(MakeArgs("QCS,QCS,QCS", &csUrl, &csTitle, &csName));
}

//	Purpose:	List all the open Netscape windows.
//	Arguments:	hszItem	ignored.
//	Returns:	HDDEDATA	An array of DWORDs corresponding to the windows.
//	Comments:	We will manually create the return data in this function,
//					as it follows no previously coded standard.
//				We will not return the ID of the minimized window.
//	Revision History:
//		01-13-94	created GAB
HDDEDATA CDDEWrapper::ListWindows(HSZ& hszItem)
{
	//	Count our windows.
	DWORD dwFrames = XP_ContextCount(MWContextBrowser, FALSE);
	
	//	No frames, don't do this.
	if(dwFrames == 0)	{
		return(NULL);
	}
	
	DWORD *pData = new DWORD[dwFrames + 1];
	DWORD dwCounter = 0;
	
	//	Loop through each context, taking only browser style contexts.
	MWContext *pTraverseContext = NULL;
	CAbstractCX *pTraverseCX = NULL;
	XP_List *pTraverse = XP_GetGlobalContextList();
	while (pTraverseContext = (MWContext *)XP_ListNextObject(pTraverse)) {
		if(pTraverseContext != NULL && ABSTRACTCX(pTraverseContext) != NULL)	{
			pTraverseCX = ABSTRACTCX(pTraverseContext);

			if(pTraverseCX->GetContext()->type == MWContextBrowser &&
				pTraverseCX->IsFrameContext() == TRUE &&
				pTraverseCX->IsDestroyed() == FALSE)	{
				CWinCX *pWinCX = (CWinCX *)pTraverseCX;
				if(pWinCX->GetFrame()->GetFrameWnd() != NULL)	{
					//	Looks like this is the type of context we'll list.
					*(pData + dwCounter) = pWinCX->GetContextID();
					dwCounter++;
				}
			}

		}
	}

	//	Null terminate the list.
	*(pData + dwCounter) = (DWORD)0;

	//	allocate some data to return to the caller.
	HDDEDATA hData = DdeCreateDataHandle(m_dwidInst, (unsigned char *)pData, (dwCounter + 1) * sizeof(DWORD), 0, m_hsz[m_ServiceName],
		CF_TEXT, 0);

	delete [] pData;	
	return(hData);
}


//	Purpose:	Parse a main, and relative URL, returning the fully qualified URL.
//	Arguments:	hszItem	The arguments.  See below.
//	Returns:	HDDEDATA	A null terminated string representing the fully qualified URL.
//	Comments:	Nothing special here, folks.
//	Revision History:
//		01-13-95	created GAB
HDDEDATA CDDEWrapper::ParseAnchor(HSZ& hszItem)
{
	//	Get our arguments.
	CString csMainURL;
	CString csRelativeURL;
	ScanArgs(hszItem, "QCS,QCS", &csMainURL, &csRelativeURL);
	
	//	create the URL.
	char *cpURL = NET_MakeAbsoluteURL((char *)(const char *)csMainURL, (char *)(const char *)csRelativeURL);
	CString csURL;
	if(cpURL != NULL)	{
		csURL = cpURL;
		XP_FREE(cpURL);
	}
	
	//	Create our return value.
	return(MakeArgs("QCS", &csURL));
}

//	Purpose:	Report the current DDE API version back to the caller.
//	Arguments:	hszItem	none and ignored.
//	Returns:	HDDEDATA which actually contains the version.
//	Comments:	Version control information for the API.
//	Revision History:
//		01-17-95	created GAB
HDDEDATA CDDEWrapper::Version(HSZ& hszItem)
{
	return(MakeArgs("DW", &dwDDEVersion));
}

//	Purpose:	Register a particular DDE server to handle URLs of a particular type.
//	Arguments:	hszItem	Arguments, see below.
//	Returns:	HDDEDATA	TRUE	registered
//							FALSE	unable to register, another applciation is handling it.
//	Comments:
//	Revision History:
//		01-18-95	created GAB
HDDEDATA CDDEWrapper::RegisterProtocol(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	CString csProtocol;
	ScanArgs(hszItem, "QCS,QCS", &csServer, &csProtocol);
	
	//	If either is empty, we'll just fail.
	if(csServer.IsEmpty() || csProtocol.IsEmpty())	{
		return(NULL);
	}
	
	//	Need to see if something is already registered to handle this protocol.
	TwoByteBool bRetval = CDDEProtocolItem::DDERegister(csProtocol, csServer);
	
	return(MakeArgs("BL", &bRetval));
}

//	Purpose:	Register a particular DDE server to handle URLs of a particular type.
//	Arguments:	hszItem	Arguments, see below.
//	Returns:	HDDEDATA	TRUE	registered
//							FALSE	unable to register, another applciation is handling it.
//	Comments:
//	Revision History:
//		01-18-95	created GAB
HDDEDATA CDDEWrapper::UnRegisterProtocol(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	CString csProtocol;
	ScanArgs(hszItem, "QCS,QCS", &csServer, &csProtocol);
	
	//	If either is empty, we'll just fail.
	if(csServer.IsEmpty() || csProtocol.IsEmpty())	{
		return(NULL);
	}

	TwoByteBool bRetval = CDDEProtocolItem::DDEUnRegister(csProtocol, csServer);
	return(MakeArgs("BL", &bRetval));	
}

//	Purpose:	Have an external protocol handler open a URL.
//	Arguments:	csServiceName	The name of the external service application.
//				pURL	The URL to perform the load on; contains possible form data also.
//				pContext	The context to load from (windowID).
//				iFormatOut	Wether or not to save the URL.
//	Returns:	TwoByteBool	TRUE	External application handling the request.
//						FALSE	External application failed to handle.
//	Comments:	Will automatically deregister the external applciation if failure to connect.
//	Revision History:
//		01-18-94	created GAB
TwoByteBool CDDEWrapper::OpenURL(CString csProtocol, CString csServiceName, URL_Struct *pURL, MWContext *pContext, FO_Present_Types iFormatOut)
{
	//	Get the conversation going.
	CDDEWrapper *pConv = ClientConnect(csServiceName, m_hsz[m_OpenURL]);

	if(pConv == NULL)	{
		//	Well, Doh!, the server isn't responding.
		//	Disable it from further being our registered app.
		CDDEProtocolItem::DDEUnRegister(csProtocol, csServiceName);
		
		//	There's not much else we can do here, simply return.
		return(FALSE);
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;

	//	See if we need to save the file.
    //  The filename was saved in the context some time ago.
	CString csSaveAs;
    if((iFormatOut & FO_SAVE_AS) == FO_SAVE_AS)   {
	    if(pContext->save_as_name != NULL)	{
		    csSaveAs = pContext->save_as_name;

			//	Steal it from the old context.
			free(pContext->save_as_name);
			pContext->save_as_name = NULL;
	    }
        else    {
            //  There's no name to save it under, so that must mean that the user either
            //      cancelled a save, or we're simply broken.

            //  Be sure to get rid of the conversation too.
	        //	Make sure we still have a conversation, if so, delete the object.
	        DdeDisconnect(hSaveConv);
	        pConv = GetConvObj(hSaveConv);
	        if(pConv)	{
		        delete pConv;
	        }

            return(FALSE);
        }
    }
    //  Screen types we don't want to handle.
    else if((iFormatOut & FO_PRESENT) != FO_PRESENT)    {
        //  Be sure to get rid of the conversation too.
	    //	Make sure we still have a conversation, if so, delete the object.
	    DdeDisconnect(hSaveConv);
	    pConv = GetConvObj(hSaveConv);
	    if(pConv)	{
		    delete pConv;
	    }

        return(FALSE);
    }
	
	//	Create our argument list.
	CString csURL = pURL->address;
	DWORD dwWindowID = FE_GetContextID(pContext);
	DWORD dwFlags = 0UL;
	CString csFormData;
	if(pURL->post_data != NULL)	{
		csFormData = pURL->post_data;
	}
	CString csPostMimeType;
	if(pURL->post_headers != NULL)	{
		//	Need to extract the content type.
		char *pFind = strcasestr(pURL->post_headers, "Content-type:");
		if(pFind != NULL)	{
			while(*pFind != ':')	{
				pFind++;
			}
			pFind++;
			
			while(*pFind != '\0' && isspace(*pFind))	{
				pFind++;
			}
			
			csPostMimeType = pFind;
			csPostMimeType = csPostMimeType.SpanExcluding("\r\n");
		}
	}
	CString csProgressApp;	//	leave empty for now.
	
	HSZ hszItem = MakeItemArgs("QCS,QCS,DW,DW,QCS,QCS,CS", &csURL, &csSaveAs, &dwWindowID, &dwFlags, &csFormData,
		&csPostMimeType, &csProgressApp);
		
	//	Do the transaction, expect return value.
	HDDEDATA hData = DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_REQUEST, m_Timeout, NULL);		

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
	
	//	See if we've gotten a return value.  Failure to give us a value will cause use to unregister the app.
	if(hData == NULL)	{
		CDDEProtocolItem::DDEUnRegister(csProtocol, csServiceName);	
		return(FALSE);
	}
	
	//	We've got a return value.  Determine what it is.
	DWORD dwRetval;
	ScanDataArgs(hData, "DW", &dwRetval);
	DdeFreeDataHandle(hData);
	
	//	Check for failure.
	if(dwRetval == 0 || dwRetval == 0xFFFFFFFFUL)	{
		return(FALSE);
	}
	
	//	Done.
    //  Be sure to let the frame know it's not saving any file, regardless, since we
    //      may have handled it.
	return(TRUE);
}

//	Purpose:	Register a DDE server for URL echo.
//	Arguments:	hszItem	our arguments.
//				hData	Disregard, not used.
//	Returns:	HDDEDATA	Always DDE_FACK, acknowleding that we processed this.
//	Comments:
//	Revision History:
//		01-18-95	created GAB.
HDDEDATA CDDEWrapper::RegisterURLEcho(HSZ& hszItem, HDDEDATA& hData)
{
	//	Scan in our arguments.
	CString csServiceName;
	ScanArgs(hszItem, "QCS", &csServiceName);

	//	Have the URL echo class handle it.
	CDDEEchoItem::DDERegister(csServiceName);

	return((HDDEDATA)DDE_FACK);
}

//	Purpose:	Unregister a DDE server from URL echo.
//	Arguments:	hszItem	our arugumetns.
//				hData	Disregard.
//	Returns:	HDDEDATA	always DDE_FACK, unless invalid
//	Comments:
//	Revision History:
//		01-18-95	created GAB
HDDEDATA CDDEWrapper::UnRegisterURLEcho(HSZ& hszItem, HDDEDATA& hData)
{
	//	Scan in our arguments.
	CString csServiceName;
	ScanArgs(hszItem, "QCS", &csServiceName);

	//	Have the URL echo class handle it.
	if(CDDEEchoItem::DDEUnRegister(csServiceName) == TRUE)  {
	    return((HDDEDATA)DDE_FACK);
    }

    return((HDDEDATA)DDE_FNOTPROCESSED);
}

//	Purpose:	Echo a URL event to a server.
//	Arguments:	pItem	The Echo object causing this (so we can get our service name out of it, and anything else.
//				csURL	The url loaded.
//				csMimeType	The mime type of the url.
//				dwWindowID	The window performing the load.
//				csReferrer	The referrer URL.
//	Returns:	void
//	Comments:
//	Revision History:
//		01-18-95	created GAB
void CDDEWrapper::URLEcho(CDDEEchoItem *pItem, CString& csURL, CString& csMimeType, DWORD dwWindowID, CString& csReferrer)
{
	//	Get the server name.
	CString csServiceName = pItem->GetServiceName();
	
	//	Establish the connection to homeworld.
	CDDEWrapper *pConv = ClientConnect(csServiceName, m_hsz[m_URLEcho]);

	if(pConv == NULL)	{
		//	Well, Doh!, the server isn't responding.
		//	Disable it from further being our registered app.
		CDDEEchoItem::DDEUnRegister(csServiceName);
		
		//	There's not much else we can do here, simply return.
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;

	//	Create our argument list.
	HSZ hszItem = MakeItemArgs("QCS,QCS,DW,QCS", &csURL, &csMimeType, &dwWindowID, &csReferrer);
		
	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_POKE, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
}


// Functions for handling animation echoing (Added by Dave Hyatt 4/98)
HDDEDATA CDDEWrapper::RegisterAnimationEcho(HSZ& hszItem, HDDEDATA& hData)
{
	//	Scan in our arguments.
	CString csServiceName;
	ScanArgs(hszItem, "QCS", &csServiceName);

	//	Have the URL echo class handle it.
	CDDEAnimationEcho::DDERegister(csServiceName);

	return((HDDEDATA)DDE_FACK);
}


HDDEDATA CDDEWrapper::UnRegisterAnimationEcho(HSZ& hszItem, HDDEDATA& hData)
{
	//	Scan in our arguments.
	CString csServiceName;
	ScanArgs(hszItem, "QCS", &csServiceName);

	//	Have the URL echo class handle it.
	if(CDDEAnimationEcho::DDEUnRegister(csServiceName) == TRUE)  {
	    return((HDDEDATA)DDE_FACK);
    }

    return((HDDEDATA)DDE_FNOTPROCESSED);
}

void CDDEWrapper::AnimationEcho(CDDEAnimationEcho *pItem, DWORD dwWindowID, DWORD dwState)
{
	//	Get the server name.
	CString csServiceName = pItem->GetServiceName();
	
	//	Establish the connection to homeworld.
	CDDEWrapper *pConv = ClientConnect(csServiceName, m_hsz[m_AnimationEcho]);

	if(pConv == NULL)	
	{
		CDDEAnimationEcho::DDEUnRegister(csServiceName);
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;

	//	Create our argument list.
	HSZ hszItem = MakeItemArgs("DW,DW", &dwWindowID, &dwState);
		
	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_POKE, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	
	{
		delete pConv;
	}
}


//	Purpose:	Register a DDE server to monitor a certain window's close.
//	Arguments:	hszItem	the argumetns, the server and the window
//	Returns:	HDDEDATA	TRUE or FALSE, FALSE there was no window.
//	Comments:
//	Revision History:
//		01-19-95	created GAB
//
//	Purpose:	Register a particular DDE server to handle URLs of a particular type.
//	Arguments:	hszItem	Arguments, see below.
//	Returns:	HDDEDATA    dwWindowID
//	Comments:
//	Revision History:
//		01-18-95	created GAB
HDDEDATA CDDEWrapper::RegisterWindowChange(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	DWORD dwWindowID;
	ScanArgs(hszItem, "QCS,DW", &csServer, &dwWindowID);
	
	//	If server is empty, we'll just fail.
	if(csServer.IsEmpty())	{
		return(NULL);
	}

	//	Sign up to watch the window, this possibly fails.
	if(FALSE == CDDEWindowChangeItem::DDERegister(csServer, dwWindowID))    {
        dwWindowID = 0;
	}

	
	return(MakeArgs("DW", &dwWindowID));
}

//	Purpose:	Unregister a window to be monitored.
//	Arguments:	hszItem	The arguments, the server ,and the windowID.
//	Returns:	HDDEDATA TRUE or FALSE, FALSE there was no prior registration.
//	Comments:	
//	Revision History:
//		01-19-95	created GAB
HDDEDATA CDDEWrapper::UnRegisterWindowChange(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	DWORD dwWindowID;
	ScanArgs(hszItem, "QCS,DW", &csServer, &dwWindowID);
	
	//	If server is empty, we'll just fail.
	if(csServer.IsEmpty())	{
		return(NULL);
	}

	//	Sign up to watch the window, this possibly fails.
	TwoByteBool bRetval = CDDEWindowChangeItem::DDEUnRegister(csServer, dwWindowID);	
	
	return(MakeArgs("BL", &bRetval));
}

//	Purpose:	Send a message to the registere monitoring server that the window is chaning.
//	Arguments:	pItem	The registry of window close monitors.
//              iChange The type of change ocurring.
//				bExiting	Wether or not we believe Netscape is actually exiting.
//              dwX The X position of the window.
//              dwY The Y position of the window.
//              dwCX    The width of the window.
//              dwCY    The height of the window.
//	Returns:	void
//	Comments:
//	Revision History:
//		01-19-95	created GAB
//      02-01-95    modified extensively to handle multiple different types of window actions.
void CDDEWrapper::WindowChange(CDDEWindowChangeItem *pItem, int iChange, TwoByteBool bExiting, DWORD dwX, DWORD dwY, DWORD dwCX, DWORD dwCY)
{
	//	Get the server name.
	CString csServiceName = pItem->GetServiceName();
	
	//	Establish the connection to homeworld.
	CDDEWrapper *pConv = ClientConnect(csServiceName, m_hsz[m_WindowChange]);

	if(pConv == NULL)	{
		//	Well, Doh!, the server isn't responding.
		//	There's not much else we can do here, simply return.
		//	Unregistration happens elsewhere.
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;

    //  Construct the flags for the call, and our calling format.
    DWORD dwFlags = 0;
    const char *pFormat;
    switch(iChange) {
        case CDDEWindowChangeItem::m_Close: {
            dwFlags |= 0x00000010UL;
            if(bExiting == TRUE)    {
                dwFlags |= 0x00010000UL;
            }
            pFormat = "DW,DW";
            break;
        }
        case CDDEWindowChangeItem::m_Size:  {
            dwFlags |= 0x00000001UL;
            pFormat = "DW,DW,DW,DW,DW,DW";
            break;
        }
        case CDDEWindowChangeItem::m_Maximize:  {
            dwFlags |= 0x00000002UL;
            pFormat = "DW,DW";
            break;
        }
        case CDDEWindowChangeItem::m_Minimize:  {
            dwFlags |= 0x00000008UL;
            pFormat = "DW,DW";
            break;
        }
        case CDDEWindowChangeItem::m_Normalize: {
            dwFlags |= 0x00000004UL;
            pFormat = "DW,DW";
            break;
        }
        default:    {
            //  Not handled, this is bad.
            pFormat = "DW,DW";
            ASSERT(0);
            break;
        }
    }

	//	Create our argument list.
	DWORD dwWindowID = pItem->GetWindowID();
	HSZ hszItem = MakeItemArgs(pFormat, &dwWindowID, &dwFlags, &dwX, &dwY, &dwCX, &dwCY);
		
	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_POKE, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
}

//	Purpose:	Retrieves a file from the local file system and displays it in a given frame.
//	Arguments:	hszArgs	A string representing our real parameters.
//	Returns:	HDDEDATA	Returns the actual WindowID of the window
//								the performed the open, where 0 means
//								the operation failed, and 0xFFFFFFFF
//								means the data was not of an appropriate
//								MIME type to display in a Web browser....
//	Comments:	Parameters within hszItem are
//		qcsFileName	the file on the local file system that Netscape should attempt to load.
//		qcsMimeType is the mime type of the file.
//		dwWindowID is the Netscape window in which to perform the load.
//			A value of 0x0 requests Netscape to load into a new window.
//			A value of 0xFFFFFFFF requests Netscape to load into the last active window.
//		qcsURL is the original URL of the document to reload if necessary.  Will only attempt if can't
//			open the file for reading.
//	Revision History:
//		01-19-95	created GAB
HDDEDATA CDDEWrapper::ShowFile(HSZ& hszArgs)
{
	DWORD dwReturn = 0L;
	
	//	Obtain our arguments.
	CString csFileName;
	CString csMimeType;
	DWORD dwWindowID;
	CString csURL;
	ScanArgs(hszArgs, "QCS,QCS,DW,QCS", &csFileName, &csMimeType, &dwWindowID, &csURL);
		
	//	Get the appropriate window.
	if(dwWindowID == 0)	{
		//	They want a new window.
		if(NULL != CFE_CreateNewDocWindow(NULL, NULL))	{
			//	Window ID is no longer 0.
			dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
		}
	}
	else if(dwWindowID == 0xFFFFFFFF)	{
		//	They want the current frame....
		//	See if we even have one.
		if(XP_ContextCount(MWContextBrowser, TRUE) == 0)	{
			if(NULL != CFE_CreateNewDocWindow(NULL, NULL))	{
				dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
			}
			else	{
				dwWindowID = 0;
			}
		}
		else	{
			if(FEU_GetLastActiveFrame(MWContextBrowser) != NULL)	{
				//	Should be safe.
				dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
			}
			else	{
				dwWindowID = 0;
		        if(NULL != CFE_CreateNewDocWindow(NULL, NULL))	{
			        dwWindowID = FEU_GetLastActiveFrameID(MWContextBrowser);
		        }
			}
		}
	}
	else	{
		//	They are requesting a specific frame.
		//	See if we've got it.
		if(FEU_FindFrameByID(dwWindowID, MWContextBrowser) == NULL)	{
			dwWindowID = 0;
		}
	}
	
	CAbstractCX *pCX = NULL;
    if(dwWindowID)  {
        pCX = CAbstractCX::FindContextByID(dwWindowID);
        if(NULL == pCX ||
            pCX->IsDestroyed() ||
            pCX->IsFrameContext() == FALSE ||
            pCX->GetContext()->type != MWContextBrowser)   {
            dwWindowID = 0;
            pCX = NULL;
        }
    }

	//	See if the window exists, a value of 0 means failure at this
	//		point.
	if(dwWindowID == 0)	{
		//	Well, either the window didn't exist, or we couldn't create
		//		a new window.
		return(MakeArgs("DW", &dwWindowID));
	}
	
	//	So far so good.  Our current return value will be the window ID,
	//		until another failure further along.
	dwReturn = dwWindowID;
	
	//	Create the URL structure to load up the URL.
	//	We do this first by seeing if we can access the file, if so go on, and if
	//		not use the URL that they presented us with.
	URL_Struct *pURL = NULL;
	if(_access(csFileName, 0x4) == -1)	{
		//	Use the URL
		pURL = NET_CreateURLStruct(csURL, NET_DONT_RELOAD);
	}
	else	{
		//	Use the file name.
		CString csURL;
		WFE_ConvertFile2Url(csURL, csFileName);
		pURL = NET_CreateURLStruct(csURL, NET_DONT_RELOAD);	
	}
	
	//	Manually assign in the mime type of the URL struct.
	if(csMimeType.IsEmpty() == FALSE)	{
		pURL->content_type = strdup(csMimeType);
	}
	
	//	Have the URL load.  We simply can't block our return value until
	//		all connections are completed for the window because we
	//		hose all the messaging.
	pCX->GetUrl(pURL, FO_CACHE_AND_PRESENT);
    
	return(MakeArgs("DW", &dwReturn));
}

//	Purpose:    Change our window position/attributes.
//	Arguments:  hszItem Our arguments.
//              hData   Data, ignored.
//	Returns:    HDDEDATA    TRUE or FALSE, depending on successful completion.
//	Comments:   This should probably by XTYP_REQUEST, as they may specify an invalid window ID, but they get the candy they want.
//              They could always check for valid IDs themselves.
//	Revision History:
//      02-01-95    created GAB
HDDEDATA CDDEWrapper::WindowChange(HSZ& hszItem, HDDEDATA& hData)
{
    //  Scan in our argumetnts.
    DWORD dwWindowID;
    DWORD dwFlags;
    DWORD dwX;
    DWORD dwY;
    DWORD dwCX;
    DWORD dwCY;

    ScanArgs(hszItem, "DW,DW,DW,DW,DW,DW", &dwWindowID, &dwFlags, &dwX, &dwY, &dwCX, &dwCY);

    //  Figure out if the frame exists.
    CAbstractCX *pCX = CAbstractCX::FindContextByID(dwWindowID);
    CFrameWnd *pFrame =  FEU_FindFrameByID(dwWindowID);
    if(pFrame == NULL || dwWindowID == 0 || NULL == pCX || pCX->IsGridCell())  {
        return((HDDEDATA)DDE_FNOTPROCESSED);
    }

    TwoByteBool bDidSomething = FALSE;

    //  Figure out, via the flags, what in the hell we are doing.
    if(dwFlags & 0x00000001UL)  {
        //  We're changing size.
        //  X and Y are always significant, though the others may not be....
        if(dwCX == 0)   {
            //  Determine what this should really be.
            RECT rDim;
            pFrame->GetWindowRect(&rDim);
            dwCX = rDim.right - rDim.left;
        }
        if(dwCY == 0)   {
            //  Determine what this should really be.
            RECT rDim;
            pFrame->GetWindowRect(&rDim);
            dwCX = rDim.bottom - rDim.top;
        }

        pFrame->MoveWindow(CASTINT(dwX), CASTINT(dwY), CASTINT(dwCX), CASTINT(dwCY));
        bDidSomething = TRUE;
    }

    if(dwFlags & 0x00000002UL)  {
        //  We're maximizing.
        pFrame->ShowWindow(SW_SHOWMAXIMIZED);
        bDidSomething = TRUE;
    }

    if(dwFlags & 0x00000004UL)  {   
        //  We're normalizing.
        pFrame->ShowWindow(SW_SHOWNORMAL);
        bDidSomething = TRUE;
    }

    if(dwFlags & 0x00000008UL)    {
        //  We're minimizing.
        pFrame->ShowWindow(SW_MINIMIZE);
        bDidSomething = TRUE;
    }

    if(dwFlags & 0x00000010UL)  {
        //  We're closing.
        pFrame->PostMessage(WM_CLOSE);
        bDidSomething = TRUE;
    }

    if(bDidSomething == TRUE)   {
        return((HDDEDATA)DDE_FACK);
    }
    else    {
        return((HDDEDATA)DDE_FNOTPROCESSED);
    }
}

//	Purpose:    Pure hell.
//	Arguments:  hszItem The arguments, the transaction ID to stop loading.
//              hData is ignored.
//	Returns:    HDDEDATA    TRUE, always work.
//	Comments:   We need to traverse all windows, hence all frames, and then documents, to find out the Transaction ID.
//	Revision History:
//      02-01-95    created GAB
//		10-17-95	Modified to search for the transaction ID in a different manner.
HDDEDATA CDDEWrapper::CancelProgress(HSZ& hszItem, HDDEDATA& hData)
{
    //  Get the argument.
    DWORD dwTransactionID;
    ScanArgs(hszItem, "DW", &dwTransactionID);


	//	Go through all contexts, searching for the one with the specific
	//		transaction ID.
	MWContext *pTraverseContext = NULL;
	CAbstractCX *pTraverseCX = NULL;
	XP_List *pTraverse = XP_GetGlobalContextList();
	while (pTraverseContext = (MWContext *)XP_ListNextObject(pTraverse)) {
		if(pTraverseContext != NULL && ABSTRACTCX(pTraverseContext) != NULL)	{
			pTraverseCX = ABSTRACTCX(pTraverseContext);

			if(pTraverseCX->m_pNcapiUrlData != NULL)	{
				if(pTraverseCX->m_pNcapiUrlData->GetTransactionID())	{
					if(pTraverseCX->m_pNcapiUrlData->GetTransactionID() == dwTransactionID)	{
						//	Found it, cancel it.
						pTraverseCX->Interrupt();
				        return((HDDEDATA)DDE_FACK);
					}
				}
			}
		}
	}

	//	Not found, not valid.
    return((HDDEDATA)DDE_FNOTPROCESSED);
}

HDDEDATA CDDEWrapper::ListFrameChildren(HSZ& hszItem)
{
    HDDEDATA hRetval = NULL;
	DWORD dwCXID;
	ScanArgs(hszItem, "DW", &dwCXID);

    CWinCX *pCX = GetContext(dwCXID);
    if(pCX && pCX->IsGridParent()) {
        XP_List *pChildren = pCX->GetContext()->grid_children;
        DWORD dwCount = XP_ListCount(pChildren);
        if(dwCount) {
            //  Allocate a buffer for the children IDs.
            DWORD *pBuf = new DWORD[dwCount + 1];
            if(pBuf)    {
                memset(pBuf, 0, CASTSIZE_T(sizeof(DWORD) * (dwCount + 1)));

                //  Go through the list figuring out the context ID and
                //      assigning it in.
                void *pTraverse;
                DWORD dwIndex = 0;
                while(pTraverse = XP_ListNextObject(pChildren)) {
                    CWinCX *pChildCX = WINCX(((MWContext *)pTraverse));
                    pBuf[dwIndex] = pChildCX->GetContextID();
                    dwIndex++;
                }

                //  Convert
                hRetval = DdeCreateDataHandle(
                    m_dwidInst,
                    (unsigned char *)pBuf,
                    (dwCount + 1) * sizeof(DWORD),
                    0,
                    m_hsz[m_ServiceName],
                    CF_TEXT, 0);

                delete [] pBuf;
                pBuf = NULL;
            }
        }
    }

    return(hRetval);
}

HDDEDATA CDDEWrapper::GetFrameParent(HSZ& hszItem)
{
	DWORD dwCXID;
	ScanArgs(hszItem, "DW", &dwCXID);

    CWinCX *pCX = GetContext(dwCXID);
    if(pCX && pCX->IsGridCell()) {
        DWORD dwParentID = WINCX(pCX->GetParentContext())->GetContextID();
        return(MakeArgs("DW", &dwParentID));
    }

    return(NULL);
}

HDDEDATA CDDEWrapper::RegisterStatusBarChange(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	DWORD dwWindowID;
	ScanArgs(hszItem, "QCS,DW", &csServer, &dwWindowID);
	
	//	If server is empty, we'll just fail.
	if(csServer.IsEmpty())	{
		return(NULL);
	}

	if(FALSE == CDDEStatusBarChangeItem::DDERegister(csServer, dwWindowID))    {
        dwWindowID = 0;
	}
	
	return(MakeArgs("DW", &dwWindowID));
}

HDDEDATA CDDEWrapper::UnRegisterStatusBarChange(HSZ& hszItem)
{
	//	Get our arguments.
	CString csServer;
	DWORD dwWindowID;
	ScanArgs(hszItem, "QCS,DW", &csServer, &dwWindowID);
	
	//	If server is empty, we'll just fail.
	if(csServer.IsEmpty())	{
		return(NULL);
	}

	TwoByteBool bRetval = CDDEStatusBarChangeItem::DDEUnRegister(csServer, dwWindowID);	
	
	return(MakeArgs("BL", &bRetval));
}

void CDDEWrapper::StatusBarChange(CDDEStatusBarChangeItem *pItem, LPCSTR lpStatusMsg)
{
	CString csStatusMsg = lpStatusMsg;

	//	Get the server name.
	CString csServiceName = pItem->GetServiceName();
	
	//	Establish the connection to homeworld.
	CDDEWrapper *pConv = ClientConnect(csServiceName, m_hsz[m_StatusBarChange]);

	if(pConv == NULL)	{
		//	The server isn't responding.
		//	There's not much else we can do here, simply return.
		//	Unregistration happens elsewhere.
		return;
	}
	
	//	Save the conversation, in case the DDE server disconnects behind
	//		our backs.
	HCONV hSaveConv = pConv->m_hConv;

    //  Construct the flags for the call, and our calling format.
    DWORD dwFlags = 0;
    const char *pFormat = "DW,QCS";

	//	Create our argument list.
	DWORD dwWindowID = pItem->GetWindowID();
	HSZ hszItem = MakeItemArgs(pFormat, &dwWindowID, &csStatusMsg);
		
	//	Do the transaction, expect nothing.
	DdeClientTransaction(NULL, 0L, hSaveConv, hszItem, CF_TEXT,
		XTYP_POKE, m_Timeout, NULL);

	//	Cut the cord.
	DdeFreeStringHandle(m_dwidInst, hszItem);
	DdeDisconnect(hSaveConv);

	//	Make sure we still have a conversation, if so, delete the object.
	pConv = GetConvObj(hSaveConv);
	if(pConv)	{
		delete pConv;
	}
}

//Returns : 
//		0  - If incorrect WindowID 
//	   -1  - If Can't go back
//	   ID  - Id of window on which the operation was performed
HDDEDATA CDDEWrapper::NavigateBack(HSZ& hszItem)
{
	DWORD ReturnID = 0x0;

	//	Retrieve our arguments.
	DWORD WindowID;
	ScanArgs(hszItem, "DW", &WindowID);

   if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

   if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
		CFrameGlue *pFrame = CFrameGlue::FindFrameByID(WindowID, MWContextBrowser);
		if(pFrame != NULL)	
		{
			MWContext *pContext = (pFrame->GetMainContext() != NULL) ? pFrame->GetMainContext()->GetContext() : NULL;
			if(pContext != NULL)	
			{
                if(ABSTRACTCX(pContext)->CanAllBack())
                {
				  ABSTRACTCX(pContext)->AllBack();
				  ReturnID = WindowID;
                }
			}
		}
	}

	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}

//Returns : 
//		0  - If incorrect WindowID 
//	   -1  - If Can't go forward
//	   ID  - Id of window on which the operation was performed
HDDEDATA CDDEWrapper::NavigateForward(HSZ& hszItem)
{
	DWORD ReturnID = 0x0;

	//	Retrieve our arguments.
	DWORD WindowID;
	ScanArgs(hszItem, "DW", &WindowID);

   if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

   if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
		CFrameGlue *pFrame = CFrameGlue::FindFrameByID(WindowID, MWContextBrowser);
		if(pFrame != NULL)	
		{
			MWContext *pContext = (pFrame->GetMainContext() != NULL) ? pFrame->GetMainContext()->GetContext() : NULL;
			if(pContext != NULL)	
			{
				if(ABSTRACTCX(pContext)->CanAllForward())
				{
					ABSTRACTCX(pContext)->AllForward();
					//Success, set the return value.
					ReturnID = WindowID;
				}
				//else
			    // ReturnID = 0xFFFFFFFF;
			}
		}
	}

	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}

//Returns : 
//		0  - If incorrect WindowID 
//	   -1  - If Can't Stop
//	   ID  - Id of window on which the operation was performed
HDDEDATA CDDEWrapper::Stop(HSZ& hszItem)
{
	DWORD ReturnID = 0L;

	//	Retrieve our arguments.
	DWORD WindowID;
	ScanArgs(hszItem, "DW", &WindowID);

	if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

   if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
		CFrameGlue *pFrame = CFrameGlue::FindFrameByID(WindowID, MWContextBrowser);
		if(pFrame != NULL)	
		{
			MWContext *pContext = (pFrame->GetMainContext() != NULL) ? pFrame->GetMainContext()->GetContext() : NULL;
			if(pContext != NULL)	
			{
				if(ABSTRACTCX(pContext)->CanAllInterrupt())
				{
					ABSTRACTCX(pContext)->AllInterrupt();
					//Success, set the return value.
					ReturnID = WindowID;
				}
				else
					ReturnID = 0xFFFFFFFF;
			}
		}
	}

	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}

//Returns : 
//		0  - If incorrect WindowID 
//	   -1  - If Can't Reload
//	   ID  - Id of window on which the operation was performed
HDDEDATA CDDEWrapper::Reload(HSZ& hszItem)
{
	DWORD ReturnID = 0L;

	//	Retrieve our arguments.
	DWORD WindowID;
	ScanArgs(hszItem, "DW", &WindowID);

	if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

   if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
		CFrameGlue *pFrame = CFrameGlue::FindFrameByID(WindowID, MWContextBrowser);
		if(pFrame != NULL)	
		{
			MWContext *pContext = (pFrame->GetMainContext() != NULL) ? pFrame->GetMainContext()->GetContext() : NULL;
			if(pContext != NULL)	
			{
				if(ABSTRACTCX(pContext)->CanAllReload())
				{
					ABSTRACTCX(pContext)->AllReload();
					//Success, set the return value.
					ReturnID = WindowID;
				}
				else
					ReturnID = 0xFFFFFFFF;
			}
		}
	}

	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}

//Returns : 
//		0  - If incorrect WindowID 
//	   -1  - If Can't Reload
//	   ID  - Id of window on which the operation was performed
HDDEDATA CDDEWrapper::UserAgent(HSZ& hszItem)
{
    CString csVersion = theApp.ResolveAppVersion();
    return MakeArgs("QCS", &csVersion);
}

HDDEDATA CDDEWrapper::ClearCache(HSZ& hszItem)
{
    TwoByteBool returnVal = FALSE;

    int32 nSize;

    // This would fail if the pref were locked, but it's what is done
    // in the prefs dialog
    if (!PREF_PrefIsLocked("browser.cache.disk_cache_size"))
    {
      PREF_GetIntPref("browser.cache.disk_cache_size", &nSize);
      PREF_SetIntPref("browser.cache.disk_cache_size", 0);
	  PREF_SetIntPref("browser.cache.disk_cache_size", nSize);
      returnVal = TRUE;
    }

    return MakeArgs("BL", &returnVal);
}

HDDEDATA CDDEWrapper::InCache(HSZ& hszItem)
{
    TwoByteBool retVal = FALSE;
    CString url;
    ScanArgs(hszItem, "QCS", &url);

    URL_Struct* url_s = NET_CreateURLStruct(url, NET_NORMAL_RELOAD); 
	int i;
    if (url_s) 
    {
        i = NET_FindURLInCache(url_s, NULL);
    }
    
    retVal = (i != 0);

    NET_FreeURLStruct(url_s);

    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::CacheFilename(HSZ& hszItem)
{
    CString retVal = "";
    CString url;
    ScanArgs(hszItem, "QCS", &url);

    URL_Struct* url_s = NET_CreateURLStruct(url, NET_NORMAL_RELOAD); 
	if (url_s) 
	{ 
		NET_FindURLInCache(url_s, NULL); 
	}
	if (url_s && url_s->cache_file && *url_s->cache_file)
	{
		retVal = WH_FileName(url_s->cache_file, xpCache);
    }
    
    
    NET_FreeURLStruct(url_s);

    return MakeArgs("QCS", &retVal);
}

HDDEDATA CDDEWrapper::CacheRemoveURL(HSZ& hszItem)
{
    TwoByteBool retVal = FALSE;
    CString url;
    ScanArgs(hszItem, "QCS", &url);

    URL_Struct* url_s = NET_CreateURLStruct(url, NET_NORMAL_RELOAD); 
	if (url_s) 
    {
        NET_RemoveURLFromCache(url_s);
        retVal = TRUE;
    }

    NET_FreeURLStruct(url_s);


    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::CacheAddURL(HSZ& hszItem)
{
    TwoByteBool retVal = FALSE;
    CString url;

    ScanArgs(hszItem, "QCS", &url);
    CAbstractCX* theContext = CAbstractCX::FindContextByID(fetchLastActiveWindow());
    MWContext* mwContext = theContext->GetContext();
    URL_Struct* url_s = NET_CreateURLStruct(url, NET_NORMAL_RELOAD); 
	if (url_s) 
    {
        // Fetch and cache only
        ABSTRACTCX(mwContext)->GetUrl(url_s, FO_CACHE_ONLY);
        retVal = TRUE;
    }

    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::ClearHistory(HSZ& hszItem)
{
    TwoByteBool returnVal = FALSE;

    int32 nSize;

    // This would fail if the pref were locked, but it's what is done
    // in the prefs dialog
    if (!PREF_PrefIsLocked("browser.link_expiration"))
    {
      PREF_GetIntPref("browser.link_expiration", &nSize);
	  PREF_SetIntPref("browser.link_expiration", 0);
	  PREF_SetIntPref("browser.link_expiration", nSize);
      returnVal = TRUE;
    }
    return MakeArgs("BL", &returnVal);
}

HDDEDATA CDDEWrapper::HistoryAddURL(HSZ& hszItem)
{
   TwoByteBool retVal = FALSE;
   CString url;

   ScanArgs(hszItem, "QCS", &url);
   URL_Struct* url_s = NET_CreateURLStruct(url, NET_NORMAL_RELOAD); 
   CAbstractCX *theContext = CAbstractCX::FindContextByID(fetchLastActiveWindow());
   //MWContext *mwContext = theContext->GetContext();
   
    if (url_s) 
    {
        theContext->GetUrl(url_s, FO_CACHE_ONLY);
        GH_UpdateGlobalHistory(url_s);
        GH_UpdateURLTitle(url_s, (char*)(const char*)url, FALSE);
        retVal = TRUE;
    }
    
    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::HistoryRemoveURL(HSZ& hszItem)
{
   TwoByteBool retVal = FALSE;
   CString url;

   ScanArgs(hszItem, "QCS", &url);
   
   GHHANDLE theHistory = GH_GetContext(eGH_NameSort, NULL, NULL, NULL, NULL);
   int recNo = GH_GetRecordNum(theHistory, (char*)((const char*)url));
   if (recNo != -1)
   {
       GH_DeleteRecord(theHistory, recNo, FALSE);
       GH_ReleaseContext(theHistory, FALSE);
       retVal = TRUE;
   }

    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::HistoryNumEntries(HSZ& hszItem)
{

   DWORD retVal = 0;
   GHHANDLE theHistory = GH_GetContext(eGH_NameSort, NULL, NULL, NULL, NULL);
   retVal = GH_GetNumRecords(theHistory);
   return MakeArgs("DW", &retVal);
}

HDDEDATA CDDEWrapper::HistoryGetEntry(HSZ& hszItem)
{
   CString title;
   CString url;
   DWORD lastAccessed = 0;
   DWORD firstAccessed = 0;
   DWORD visitCount = 0;

   DWORD recNo = 0;
   DWORD retVal = 0;

   ScanArgs(hszItem, "DW", &recNo);
   
   GHHANDLE theHistory = GH_GetContext(eGH_NameSort, NULL, NULL, NULL, NULL);
   gh_HistEntry* historyEntry = GH_GetRecord(theHistory, recNo);
   if (historyEntry != NULL)
   {
      title = historyEntry->pszName;
      url = historyEntry->address;
      lastAccessed = historyEntry->last_accessed;
      firstAccessed = historyEntry->first_accessed;
      visitCount = historyEntry->iCount;
      return MakeArgs("QCS,QCS,DW,DW,DW", &url, &title, &firstAccessed, &lastAccessed, &visitCount);

   }
   return MakeArgs("DW", &retVal);
}

HDDEDATA CDDEWrapper::InHistory(HSZ& hszItem)
{
   TwoByteBool retVal = FALSE;
   CString url;

   ScanArgs(hszItem, "QCS", &url);
   
    int i = GH_CheckGlobalHistory((char*)(const char*)url);
    if (i != -1)
           retVal = TRUE;
    
    return MakeArgs("BL", &retVal);
}

HDDEDATA CDDEWrapper::GetWindowID(HSZ& hszItem)
{

    CString name;
    DWORD WindowID;

    ScanArgs(hszItem, "QCS,DW", &name, &WindowID);
    if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

    DWORD retVal = 0x0;

    if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
		CFrameGlue *pFrame = CFrameGlue::FindFrameByID(WindowID, MWContextBrowser);
		if(pFrame != NULL)	
		{
			MWContext *pContext = (pFrame->GetMainContext() != NULL) ? pFrame->GetMainContext()->GetContext() : NULL;
			if(pContext != NULL)	
            {
                // We have a reference point.... find the named window
                MWContext* returnContext = XP_FindNamedContextInList(pContext, (char*)(const char*)name);
                if (returnContext != NULL)
                    retVal = WINCX(pContext)->GetContextID();
            }
        }
    }

    return MakeArgs("DW", &retVal);
}

HDDEDATA CDDEWrapper::SupportsMimeType(HSZ& hszItem)
{


  return 0;  
}
HDDEDATA CDDEWrapper::ExecuteJavaScript(HSZ& hszItem)
{


  return 0;
}

HDDEDATA CDDEWrapper::PrintWindow(HSZ& hszItem)
{
 	DWORD ReturnID = 0L;

	//	Retrieve our arguments.
	DWORD WindowID;
	ScanArgs(hszItem, "DW", &WindowID);

	if (WindowID == 0xFFFFFFFF)
       WindowID = fetchLastActiveWindow();

    if(WindowID != 0x0)	
	{
		//	See if it's a valid Window ID
        CWinCX* pContext = GetContext(WindowID);
        if(pContext != NULL)	
		{
				if(pContext->CanPrint())
				{
					pContext->Print();
					//Success, set the return value.
					ReturnID = WindowID;
				}
				else
					ReturnID = 0xFFFFFFFF;
		}
	}

	HDDEDATA hData = MakeArgs("DW", &ReturnID);
	return(hData);
}

HDDEDATA CDDEWrapper::PrintURL(HSZ& hszItem)
{
 TwoByteBool retVal = TRUE;
 CString url;
 CString printer;
 CString driver;
 CString port;

 ScanArgs(hszItem, "QCS,QCS,QCS,QCS", &url, &printer, &driver, &port);

 char* pr = NULL;
 char* dr = NULL;
 char* pt = NULL;
 if (!printer.IsEmpty())
     pr = (char*)(const char*)printer;
 if (!driver.IsEmpty())
     dr = (char*)(const char*)driver;
 if (!port.IsEmpty())
     pt = (char*)(const char*)port; 
 
 CPrintCX::AutomatedPrint((char*)(const char*)url, pr, dr, pt);

 
 return MakeArgs("BL", &retVal);
}

CGenericView *CDDEWrapper::GetView(DWORD dwContextID)
{
    CGenericView *pRetval = NULL;

    CWinCX *pCX = GetContext(dwContextID);
    if(pCX) {
        pRetval = pCX->GetView();
    }

    return(pRetval);
}

CFrameGlue *CDDEWrapper::GetFrame(DWORD dwContextID)
{
    CFrameGlue *pRetval = NULL;

    CWinCX *pCX = GetContext(dwContextID);
    if(pCX) {
        pRetval = pCX->GetFrame();
    }

    return(pRetval);
}

CWinCX *CDDEWrapper::GetContext(DWORD dwContextID)
{
    CWinCX *pRetval = NULL;

    CAbstractCX *pAbstract = CAbstractCX::FindContextByID(dwContextID);
    if(pAbstract && pAbstract->IsDestroyed() == FALSE)   {
        //  Must be a window, and a MWContextBrowser.
        if(pAbstract->IsFrameContext() && pAbstract->GetContext()->type == MWContextBrowser)  {
            pRetval = VOID2CX(pAbstract, CWinCX);
        }
    }

    return(pRetval);
}

DWORD CDDEWrapper::fetchLastActiveWindow()
{
    return FEU_GetLastActiveFrameID(MWContextBrowser);
}