// NETCMD.cpp : Defines the class behaviors for the application.
//

#include "stdafx.h"
#include <windowsx.h>

#include "leadrasterview.h"
#include "leadraster.h"
///#include "leadrasterdlg.h"
//#include "leadrastersavetype.h"

#include "NETCMD.h"
#include "BmpWnd.h"
#include "AddDlg.h"

#include "..\\..\\..\\..\\include\\l_com.h"
#include "..\\..\\..\\..\\include\\ltkey.h"

/////////////////////////////////////////////////////////////////////////////
// CNETCMDApp

BEGIN_MESSAGE_MAP(CNETCMDApp, CWinApp)
	//{{AFX_MSG_MAP(CNETCMDApp)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG
	ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CNETCMDApp construction

CNETCMDApp::CNETCMDApp()
{
	// TODO: add construction code here,
	// Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CNETCMDApp object

CNETCMDApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CNETCMDApp initialization

BOOL CNETCMDApp::InitInstance()
{
	AfxEnableControlContainer();

	// Standard initialization
	// If you are not using these features and wish to reduce the size
	//  of your final executable, you should remove from the following
	//  the specific initialization routines you do not need.

#ifdef _AFXDLL
	Enable3dControls();			// Call this when using MFC in a shared DLL
#else
	Enable3dControlsStatic();	// Call this when linking to MFC statically
#endif

	CNETCMDDlg dlg;
	m_pMainWnd = &dlg;
	int nResponse = dlg.DoModal();
	if (nResponse == IDOK)
	{
		// TODO: Place code here to handle when the dialog is
		//  dismissed with OK
	}
	else if (nResponse == IDCANCEL)
	{
		// TODO: Place code here to handle when the dialog is
		//  dismissed with Cancel
	}

	// Since the dialog has been closed, return FALSE so that we exit the
	//  application, rather than start the application's message pump.
	return FALSE;
}

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CNETCMDDlg dialog

CNETCMDDlg::CNETCMDDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CNETCMDDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CNETCMDDlg)
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
   m_aKids = NULL;
   m_pActiveKid = NULL;
   m_aBitmaps = NULL;

   m_pltRasIO = NULL;
   m_pltRasProc = NULL;

   m_nSendListNum = 0;
   m_picomps = NULL;
   m_nServerStarted = FALSE;

   m_pLEADNet = NULL;
   m_pRasterInetSink = NULL;
}

void CNETCMDDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CNETCMDDlg)
//	DDX_Control(pDX, IDC_LEADDLGCTRL1, m_LEADDlg1);
	DDX_Control(pDX, IDC_LEADRASTERVIEW1, m_LEAD1);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CNETCMDDlg, CDialog)
	//{{AFX_MSG_MAP(CNETCMDDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
	ON_COMMAND(ID_FILE_SAVE, OnFileSave)
	ON_COMMAND(ID_FILE_EXIT, OnFileExit)
	ON_WM_CLOSE()
	ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
	ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
	ON_COMMAND(ID_SERVER_STARTUP, OnServerStartup)
	ON_COMMAND(ID_SERVER_SHUTDOWN, OnServerShutdown)
	ON_COMMAND(ID_SERVER_CLOSEALLCONNECTIONS, OnServerCloseallconnections)
	ON_UPDATE_COMMAND_UI(ID_SERVER_STARTUP, OnUpdateServerStartup)
	ON_UPDATE_COMMAND_UI(ID_SERVER_SHUTDOWN, OnUpdateServerShutdown)
	ON_UPDATE_COMMAND_UI(ID_SERVER_CLOSEALLCONNECTIONS, OnUpdateServerCloseallconnections)
	ON_COMMAND(ID_SERVER_CONNECTTOREMOTESERVER, OnServerConnecttoremoteserver)
	ON_COMMAND(ID_SERVER_DISCONNECTFROMREMOTESERVER, OnServerDisconnectfromremoteserver)
	ON_UPDATE_COMMAND_UI(ID_SERVER_CONNECTTOREMOTESERVER, OnUpdateServerConnecttoremoteserver)
	ON_UPDATE_COMMAND_UI(ID_SERVER_DISCONNECTFROMREMOTESERVER, OnUpdateServerDisconnectfromremoteserver)
	ON_COMMAND(ID_LOCAL_LOADBITMAP, OnLocalLoadbitmap)
	ON_COMMAND(ID_LOCAL_SAVEBITMAP, OnLocalSavebitmap)
	ON_UPDATE_COMMAND_UI(ID_LOCAL_LOADBITMAP, OnUpdateLocalLoadbitmap)
	ON_UPDATE_COMMAND_UI(ID_LOCAL_SAVEBITMAP, OnUpdateLocalSavebitmap)
	ON_COMMAND(ID_REMOTE_LOADBITMAP, OnRemoteLoadbitmap)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_LOADBITMAP, OnUpdateRemoteLoadbitmap)
	ON_COMMAND(ID_REMOTE_CREATEWINDOW, OnRemoteCreatewindow)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_CREATEWINDOW, OnUpdateRemoteCreatewindow)
	ON_COMMAND(ID_REMOTE_ATTACHBITMAPTOWINDOW, OnRemoteAttachbitmaptowindow)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_ATTACHBITMAPTOWINDOW, OnUpdateRemoteAttachbitmaptowindow)
	ON_COMMAND(ID_REMOTE_SAVEBITMAP, OnRemoteSavebitmap)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_SAVEBITMAP, OnUpdateRemoteSavebitmap)
	ON_COMMAND(ID_REMOTE_FLIPBITMAP, OnRemoteFlipbitmap)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_FLIPBITMAP, OnUpdateRemoteFlipbitmap)
	ON_COMMAND(ID_REMOTE_GETBITMAP, OnRemoteGetbitmap)
	ON_UPDATE_COMMAND_UI(ID_REMOTE_GETBITMAP, OnUpdateRemoteGetbitmap)
	ON_COMMAND(ID_LOCAL_SENDBITMAP, OnLocalSendbitmap)
	ON_UPDATE_COMMAND_UI(ID_LOCAL_SENDBITMAP, OnUpdateLocalSendbitmap)
	ON_WM_DESTROY()
	ON_WM_ACTIVATE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CNETCMDDlg message handlers

BOOL CNETCMDDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	CString strAboutMenu;
	strAboutMenu.LoadString(IDS_ABOUTBOX);
	if (!strAboutMenu.IsEmpty())
	{
		pSysMenu->AppendMenu(MF_SEPARATOR);
		pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
   HRESULT hr = ::CoCreateInstance (CLSID_LEADRasterInet, NULL, CLSCTX_ALL, IID_ILEADRasterInet, (void **)&m_pLEADNet);
   if (FAILED (hr) || (!m_pLEADNet))
   {
      AfxMessageBox (TEXT("Could Not Create LEAD NET COM OBJECT ..."));
      EndDialog (IDCANCEL);
      return TRUE;
   }

   m_pRasterKrnDlg = NULL;
   hr = ::CoCreateInstance(CLSID_LEADRasterDlgKrn, NULL, CLSCTX_ALL,
            IID_ILEADRasterDlgKrn, (void**)&m_pRasterKrnDlg);
   if (FAILED (hr) || (m_pRasterKrnDlg == NULL))
   {
      m_pRasterKrnDlg ->Release ();
      m_pRasterKrnDlg = NULL;
   }
   m_pRasterKrnDlg->InitDlg(INIT_WITH_COLOR);
   
   m_pRasterFileDlg = NULL;
   hr = ::CoCreateInstance(CLSID_LEADRasterDlgFile, NULL, CLSCTX_ALL,
            IID_ILEADRasterDlgFile, (void**)&m_pRasterFileDlg);
   if (FAILED (hr) || (m_pRasterFileDlg == NULL))
   {
      m_pRasterFileDlg->Release ();
      m_pRasterFileDlg = NULL;
   }
   
   m_pLEADNet->PutEnableMethodErrors(FALSE);
   m_pLEADNet->PutEnableUseLEADRasterVariant(TRUE);
   {
      //create a temp LEADRaster object and use it
      //to unlock support for the Inet object
      HRESULT hr = S_OK;
      IClassFactory2 *pCF2=NULL;
      CLSID clsid;
      ILEADRaster *pRaster=NULL;
#ifndef _UNICODE
      static const WCHAR BASED_CODE _szID[] = L"LEADRaster.LEADRaster";
#else
      static const WCHAR BASED_CODE _szID[] = L"LEADRaster_U.LEADRaster_U";
#endif

      CLSIDFromProgID(_szID, &clsid);

      hr = CoGetClassObject(clsid, CLSCTX_ALL, NULL, IID_IClassFactory, (void**)&pCF2);
      if (FAILED (hr))
      {
         AfxMessageBox (TEXT("Failed To Create A Class Factory Object, The Demo will not work properly ..."));
      }
      else
      {
         //This object is licensed, so we need to pass a license key
         static const WCHAR BASED_CODE _szLic[] = L"LEADTOOLS OCX Copyright (c) 1991-2004 LEAD Technologies, Inc.";
         BSTR lpLic = SysAllocString(_szLic);
         pCF2->CreateInstanceLic(NULL, NULL, IID_IUnknown, lpLic, (void**)&pRaster);
         SysFreeString(lpLic);
         pCF2->Release();

         //Unlock the Internet features.
         //Note that TESTKEY is a sample key and will not work in your toolkit.
         UNLOCKSUPPORT(*pRaster);
         pRaster->Release();

         //Instantiate the sink class and hold a pointer to it.
         m_pRasterInetSink = new CRasterInetSink;
         m_pRasterInetSink->m_pDlg = this;

         //Establish a connection between source and sink.
         LPUNKNOWN pInetUnkSink = m_pRasterInetSink->GetIDispatch(FALSE);
         AfxConnectionAdvise(m_pLEADNet, DIID__LTRASINETEvents, pInetUnkSink, FALSE, &m_dwInetCookie);
      }
   }
      
   CRect rc;
   rc.SetRect(0,0,0,0);
   m_StatusBar.Create(WS_CHILD|WS_VISIBLE|CCS_BOTTOM, rc, this, 999);

   m_lKids = 0;
   m_hServer = 0;
   m_hRemoteServer = 0;
   m_nCommandID = 0;
   m_nBitmapID = 0;
   m_pRasterFileDlg->PutEnableMethodErrors(FALSE);
   m_bRemoteLoaded = FALSE;
   m_bRemoteCreated = FALSE;
   m_nLastBitmapID = -1;
   m_nLastWindowID = -1;
   UpdateMenuStatus();
   StatusUpdate("Ready.");

   m_LEAD1.ShowWindow(SW_HIDE);

   CoCreateInstance (CLSID_LEADRasterIO, NULL, CLSCTX_ALL, IID_ILEADRasterIO, (void **)&m_pltRasIO);
   if (!m_pltRasIO)
      return FALSE;

   m_pltRasIO->PutEnableMethodErrors (FALSE);

   CoCreateInstance (CLSID_LEADRasterProcess, NULL, CLSCTX_ALL, IID_ILEADRasterProcess, (void **)&m_pltRasProc);
   if (!m_pltRasProc)
   {
      m_pltRasIO->Release ();
      return FALSE;
   }

   m_pltRasProc->PutEnableMethodErrors (FALSE);

   return TRUE;  // return TRUE  unless you set the focus to a control
}

void CNETCMDDlg::UpdateMenuStatus(void)
{
   CMenu* pMenu=NULL;
   pMenu = GetMenu();
   m_LEAD1.ShowWindow(SW_HIDE);
   if(pMenu)
   {
      pMenu->EnableMenuItem(ID_FILE_SAVE, MF_BYCOMMAND | (((m_lKids>0) && m_pActiveKid)?MF_ENABLED:MF_DISABLED|MF_GRAYED));

      pMenu->EnableMenuItem(ID_EDIT_COPY, MF_BYCOMMAND | (((m_lKids>0) && m_pActiveKid)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
      pMenu->EnableMenuItem(ID_EDIT_PASTE, MF_BYCOMMAND | ((m_LEAD1.GetRaster().Paste(PASTE_ISREADY))?MF_ENABLED:MF_DISABLED|MF_GRAYED));

      pMenu->EnableMenuItem(ID_LOCAL_SAVEBITMAP, MF_BYCOMMAND | (((m_lKids > 0) && m_pActiveKid)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
      pMenu->EnableMenuItem(ID_LOCAL_SENDBITMAP, MF_BYCOMMAND | (((m_lKids > 0) && m_pActiveKid && (m_hRemoteServer!=0))?MF_ENABLED:MF_DISABLED|MF_GRAYED));

      if (m_nServerStarted)
      {
         pMenu->EnableMenuItem(ID_SERVER_STARTUP, MF_BYCOMMAND | ((m_hServer==0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_SERVER_SHUTDOWN, MF_BYCOMMAND | ((m_hServer!=0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_SERVER_CLOSEALLCONNECTIONS, MF_BYCOMMAND | ((m_pLEADNet->GetConnectListNum() > 0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));

         pMenu->EnableMenuItem(ID_SERVER_CONNECTTOREMOTESERVER, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_SERVER_DISCONNECTFROMREMOTESERVER, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));

         pMenu->EnableMenuItem(ID_REMOTE_LOADBITMAP, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_CREATEWINDOW, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_ATTACHBITMAPTOWINDOW, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_SAVEBITMAP, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_FLIPBITMAP, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_GETBITMAP, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
      }
      else
      {
         if (m_hRemoteServer)
            pMenu->EnableMenuItem(ID_SERVER_STARTUP, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         else
            pMenu->EnableMenuItem(ID_SERVER_STARTUP, MF_BYCOMMAND | ((m_hServer==0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));

         pMenu->EnableMenuItem(ID_SERVER_SHUTDOWN, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_SERVER_CLOSEALLCONNECTIONS, MF_BYCOMMAND | (MF_DISABLED|MF_GRAYED));

         pMenu->EnableMenuItem(ID_SERVER_CONNECTTOREMOTESERVER, MF_BYCOMMAND | ((m_hRemoteServer==0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_SERVER_DISCONNECTFROMREMOTESERVER, MF_BYCOMMAND | ((m_hRemoteServer!=0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));

         int m_Connections = m_pLEADNet->GetConnectListNum();
         pMenu->EnableMenuItem(ID_REMOTE_LOADBITMAP, MF_BYCOMMAND | ((m_Connections>0)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_CREATEWINDOW, MF_BYCOMMAND | (((m_Connections>0) && !m_bRemoteCreated && m_bRemoteLoaded)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_ATTACHBITMAPTOWINDOW, MF_BYCOMMAND | (((m_Connections>0) && m_bRemoteCreated && m_bRemoteLoaded)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_SAVEBITMAP, MF_BYCOMMAND | (((m_Connections>0) && m_bRemoteLoaded)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_FLIPBITMAP, MF_BYCOMMAND | (((m_Connections>0) && m_bRemoteLoaded)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
         pMenu->EnableMenuItem(ID_REMOTE_GETBITMAP, MF_BYCOMMAND | (((m_Connections>0) && m_bRemoteLoaded)?MF_ENABLED:MF_DISABLED|MF_GRAYED));
      }
   }
}

void CNETCMDDlg::StatusUpdate(CString cs)
{
   m_StatusBar.SetText(cs, 0, 0);
}

void CNETCMDDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CNETCMDDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CNETCMDDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CNETCMDDlg::OnFileOpen() 
{
   short nRet;
   TCHAR szCurPath [MAX_PATH];
   CBitmapWnd *pBitmapWnd=NULL;
   
   memset (szCurPath, 0, MAX_PATH*sizeof(TCHAR));
   GetCurrentDirectory (MAX_PATH, szCurPath);

   m_pRasterFileDlg->PutEnableMethodErrors (FALSE);
   m_pRasterFileDlg->PutFileDlgFlags(0);
   m_pRasterFileDlg->PutDialogTitle("Open A File");
   m_pRasterFileDlg->PutEnableShowPreview(TRUE);
   m_pRasterFileDlg->PutFilter("All |*.*|CMP|*.cmp|JPEG|*.jpg");
   m_pRasterFileDlg->PutFilterIndex(2); //look for *.cmp first
   m_pRasterFileDlg->PutUIFlags(OPEN_SHOW_MULTIPAGE |
                                 OPEN_SHOW_FILEINFO |
                                 OPEN_SHOW_PREVIEW |                            
                                 OPEN_USEFILESTAMP );

   nRet= m_pRasterFileDlg->ShowOpenDlg((long)this->m_hWnd);
   if(nRet == 0)
   {
      if(m_pRasterFileDlg->GetDialogStatus() ==  DLG_OK)
      {      
         short iRet;
         int nPage = m_pRasterFileDlg->GetPageNumber();
         LPDISPATCH pltRasterDisp = m_LEAD1.GetRaster().m_lpDispatch;

         CString csFileName;

         csFileName = (LPCTSTR)m_pRasterFileDlg->FileName;

         m_pltRasIO->PutEnableMethodErrors (FALSE);
         iRet = m_pltRasIO->Load(pltRasterDisp, (LPCTSTR)csFileName, 0, nPage, 1);
         if(!iRet)
         {
            pBitmapWnd = CreateNewBitmapWnd(csFileName, 0, 0, 200, 200, TRUE);
            pBitmapWnd->m_LEAD1.GetRaster().SetBitmap(m_LEAD1.GetRaster().GetBitmap());
            m_pActiveKid = pBitmapWnd;
         }
         else
            if(iRet = ERROR_PDF_BAD_INITIALIZATION_FILES)
            {
               if( IDYES == MessageBox ( TEXT("LEADTOOLS PDF plugin is not found, do you want to download the plugin now?"),
                                         TEXT("Open File"),MB_ICONEXCLAMATION | MB_YESNO))
               {
                  ShellExecute(m_hWnd, TEXT("open"), TEXT("http://www.leadtools.com/ReleaseDownloads/v14/LEADTOOLSPDFRuntime.exe"), 
                               NULL, NULL, SW_SHOWNORMAL);
               }
            }
            else
               MessageBox(TEXT("Error Opening File!"), TEXT("Error"), MB_OK);
      }
   }
   
   UpdateMenuStatus();
   SetCurrentDirectory (szCurPath);
   
}

CBitmapWnd * CNETCMDDlg::CreateNewBitmapWnd(CString csCaption, long nLeft, long nTop, long nWidth, long nHeight, BOOL bRecalc)
{
   CBitmapWnd *pBitmapWnd=NULL;
   pBitmapWnd = (CBitmapWnd *)new CBitmapWnd;
   m_lKids++;
   pBitmapWnd->m_pOwner = this;
   pBitmapWnd->Create(IDD_BITMAPWND, this);
   pBitmapWnd->SetWindowText(csCaption);
   if (bRecalc)
      RecalcSize (pBitmapWnd, (int&)nWidth, (int&)nHeight);
   pBitmapWnd->SetWindowPos(NULL, nLeft, nTop, nWidth, nHeight, SWP_SHOWWINDOW);
   pBitmapWnd->m_LEAD1.SetBackErase (FALSE);

   RedimKids();
   AddKid(pBitmapWnd);

   return pBitmapWnd;
}

void CNETCMDDlg::RedimKids(void)
{
   if(!m_aKids)
      m_aKids = (long*)GlobalAllocPtr(GMEM_MOVEABLE|GMEM_ZEROINIT, sizeof(CBitmapWnd*) * m_lKids);
   else
      m_aKids = (long*)GlobalReAllocPtr(m_aKids, sizeof(CBitmapWnd*) * m_lKids, GMEM_MOVEABLE|GMEM_ZEROINIT);
}

void CNETCMDDlg::AddKid(CBitmapWnd *pKid)
{
   m_aKids[m_lKids - 1] = (long)pKid;
   SortKids();
}

void CNETCMDDlg::SortKids(void)
{
   long i;
   long j;
   long Temp=0;

   for(i=m_lKids - 1; i>=0; i--)
   {
      for(j=i; j>=0; j--)
      {
         if(m_aKids[j] < m_aKids[i])
         {
            Temp      = m_aKids[i];
            m_aKids[i] = m_aKids[j];
            m_aKids[j] = Temp;
         }
      }
   }
}

void CNETCMDDlg::RemoveKid(CBitmapWnd* pKid)
{
   long i;
   for(i=0; i<m_lKids; i++)
   {
      if(m_aKids[i] == (long)pKid)
         m_aKids[i] = 0;
   }
   SortKids();
}

CBitmapWnd* CNETCMDDlg::FindKid(HWND hKid)
{
   long i;
   for(i=0; i<m_lKids; i++)
   {
      if(m_aKids[i] && (((CBitmapWnd*)m_aKids[i])->m_hWnd==hKid))
         return((CBitmapWnd*)m_aKids[i]);
   }
   return NULL;
}

void CNETCMDDlg::FreeKids(void)
{
   if(m_aKids)
   {
      long i;
      for(i=0; i<m_lKids; i++)
      {
         if(m_aKids[i] && ((CBitmapWnd*)m_aKids[i])->m_hWnd)
            DeleteKid((CBitmapWnd*)m_aKids[i]);
      }
      GlobalFreePtr(m_aKids);
      m_aKids = NULL;
   }
}

void CNETCMDDlg::DeleteKid(CBitmapWnd* pKid)
{
   if(pKid)
   {
      //pKid->DestroyWindow();
      delete(pKid);
   }

   UpdateMenuStatus();
}

void CNETCMDDlg::OnFileSave() 
{
   short nRet;
   TCHAR szCurPath [MAX_PATH];

   memset (szCurPath, 0, MAX_PATH*sizeof(TCHAR));
   GetCurrentDirectory (MAX_PATH, szCurPath);
   
   m_pRasterFileDlg->PutFileDlgFlags(0);
   m_pRasterFileDlg->PutDialogTitle("Save A File");
   m_pRasterFileDlg->PutBitmap(m_pActiveKid->m_LEAD1.GetRaster().GetBitmap());
   m_pRasterFileDlg->PutUIFlags(SAVE_SHOW_FILEOPTIONS_MULTIPAGE | 
                                 SAVE_SHOW_FILEOPTIONS_PROGRESSIVE | 
                                 SAVE_SHOW_FILEOPTIONS_QFACTOR| 
                                 SAVE_SHOW_FILEOPTIONS_STAMP | 
                                 SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS| 
                                 SAVE_SHOW_FILEOPTIONS_J2KOPTIONS | 
                                 SAVE_AUTOPROCESS 
                                 );

   nRet= m_pRasterFileDlg->ShowSaveDlg((long)this->m_hWnd);
   if(nRet != 0)
   {
      MessageBox(TEXT("Error Saving File!"), TEXT("Error"), MB_OK);    
   }

   UpdateMenuStatus();
   SetCurrentDirectory (szCurPath);
   
}

void CNETCMDDlg::OnFileExit() 
{
   FreeKids();
   FreeLBitmaps();
   EndDialog(IDOK);
}

void CNETCMDDlg::OnClose() 
{
	CDialog::OnClose();
}

void CNETCMDDlg::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnEditCopy() 
{
   m_pActiveKid->m_LEAD1.GetRaster().Copy(COPY_EMPTY | COPY_DIB | COPY_DDB | COPY_PALETTE);
   UpdateMenuStatus();
}

void CNETCMDDlg::OnEditPaste() 
{
   CBitmapWnd *pBitmapWnd=NULL;
   short nRet;
   
   nRet = m_LEAD1.GetRaster().Paste(0);
   if(nRet != 0)
      MessageBox(TEXT("Error Pasting From Clipboard!"), TEXT("Error"), MB_OK);
   else
   {
      pBitmapWnd = CreateNewBitmapWnd("Clipboard Data", 0, 0, 200, 200, TRUE);
      pBitmapWnd->m_LEAD1.GetRaster().SetBitmap(m_LEAD1.GetRaster().GetBitmap());
      m_pActiveKid = pBitmapWnd;
   }
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateEditCopy(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnServerStartup() 
{
   short nRet;

   nRet = m_pLEADNet->InetServerInit(1000);
   m_hServer = m_pLEADNet->GetInetServerHandle();
   if(nRet == 0)
   {
      StatusUpdate("Server Started.");
      m_nServerStarted = TRUE;
   }
   else
      StatusUpdate("Error Starting Server.");

   UpdateMenuStatus();
}

void CNETCMDDlg::OnServerShutdown() 
{
   ShutDownConnections(TRUE);
   ShutDownServer(TRUE);
   m_nServerStarted = FALSE;
   UpdateMenuStatus();
   StatusUpdate("Server Stopped.");
}

void CNETCMDDlg::ShutDownServer(BOOL bGraceful)
{
   if(m_hServer != 0)
   {
      m_pLEADNet->InetServerClose(m_hServer);
      m_hServer = 0;
   }
   m_bRemoteLoaded = FALSE;
   m_bRemoteCreated = FALSE;
   UpdateMenuStatus();
}

void CNETCMDDlg::OnServerCloseallconnections() 
{
   ShutDownConnections(TRUE);
   UpdateMenuStatus();
   StatusUpdate("Ready.");
}

void CNETCMDDlg::ShutDownConnections(BOOL bGraceful)
{
   // disconnect all connections
   while(m_pLEADNet->GetConnectListNum() > 0)
      m_pLEADNet->InetDisconnect(m_pLEADNet->GetConnectList(0));

   m_bRemoteLoaded = FALSE;
   m_bRemoteCreated = FALSE;
   UpdateMenuStatus();
}


void CNETCMDDlg::OnUpdateServerStartup(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateServerShutdown(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateServerCloseallconnections(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnServerConnecttoremoteserver() 
{
   CAddressDlg dlg;
   short nRet;
   
   dlg.m_csAddress = "";
   if(dlg.DoModal() == IDOK)
   {
      m_szAddress = dlg.m_csAddress;
      nRet = m_pLEADNet->InetConnect(m_szAddress.AllocSysString(), 1000);
      if(nRet == ERROR_HOST_RESOLVE)
         MessageBox(TEXT("Failed to connect - bad URL"), TEXT("Error"), MB_OK);
      else if (nRet != 0)
      {
         CString csOut;
         csOut.Format(TEXT("Error %d trying to connect"), nRet);
         MessageBox(csOut, TEXT("Error"), MB_OK);
      }
      else
         StatusUpdate("Connecting to " + m_szAddress);
   }
}

void CNETCMDDlg::OnServerDisconnectfromremoteserver() 
{
   DisconnectRemoteServer(TRUE);
   UpdateMenuStatus();
}

void CNETCMDDlg::DisconnectRemoteServer(BOOL bGraceful)
{
   if(m_hRemoteServer != 0)
   {
      m_pLEADNet->InetDisconnect(m_hRemoteServer);
      m_hRemoteServer = 0;
      m_bRemoteLoaded = FALSE;
      m_bRemoteCreated = FALSE;
   }
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateServerConnecttoremoteserver(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateServerDisconnectfromremoteserver(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

BEGIN_EVENTSINK_MAP(CNETCMDDlg, CDialog)
   //{{AFX_EVENTSINK_MAP(CNETCMDDlg)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

void CNETCMDDlg::OnInetAccept(short iServer) 
{
   short iComp;
   short nRet;
   short i;
   CString sz1;
   CString sz2;
   BOOL bfound;
   BSTR bstr1;
   BSTR bstr2;
   
   nRet = m_pLEADNet->InetAcceptConnect(iServer);
   iComp = m_pLEADNet->GetInetConnectedComputer();
   if(nRet == 0)
   {
      // add connection to send list
      m_pLEADNet->InetGetHostName(iComp, HOST_NAME_IP);
      bstr1 = m_pLEADNet->GetInetHostName();
      sz1 = bstr1;
      bfound = FALSE;
      if(m_pLEADNet->GetSendListNum() > 0)
      {
         for(i=0; i<m_pLEADNet->GetSendListNum(); i++)
         {
            m_pLEADNet->InetGetHostName(m_pLEADNet->GetSendList(i), HOST_NAME_IP);
            bstr2 = m_pLEADNet->GetInetHostName();
            sz2 = bstr2;
            if(sz1 == sz2)
               bfound = TRUE;
         }
      }
      if(!bfound)
         m_pLEADNet->PutSendList(m_pLEADNet->GetSendListNum(), iComp);
      StatusUpdate("Connection accepted.");
   }
   else
      StatusUpdate("Error Accepting a Connection.");
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetConnected(short iComputer) 
{
   CString szOut;
   CString szHost;
   BSTR bstrHost;
   short nRet;
   short i;
   CString sz1;
   CString sz2;
   BSTR bstr1;
   BSTR bstr2;
   BOOL bfound;
    
   szOut = "Connected to ";

   nRet = m_pLEADNet->InetGetHostName(iComputer, HOST_NAME_IP);
   bstrHost = m_pLEADNet->GetInetHostName();

   szHost = bstrHost;
   if(nRet != 0)
      szOut = szOut + m_szAddress;
   else
      szOut = szOut + szHost;

   StatusUpdate(szOut);
         
   if(m_hRemoteServer != 0)
   {
      m_pLEADNet->InetDisconnect(m_hRemoteServer);
      m_hRemoteServer = 0;
   }
   m_hRemoteServer = iComputer;
    
   m_pLEADNet->InetGetHostName(m_hRemoteServer, HOST_NAME_IP);
   bstr1 = m_pLEADNet->GetInetHostName();
   sz1 = bstr1;
   bfound = FALSE;
   if(m_pLEADNet->GetSendListNum() > 0)
   {
      for(i=0; i<m_pLEADNet->GetSendListNum(); i++)
      {
         m_pLEADNet->InetGetHostName(m_pLEADNet->GetSendList(i), HOST_NAME_IP);
         bstr2 = m_pLEADNet->GetInetHostName();
         sz2 = bstr2;
         if(sz1 == sz2)
            bfound = TRUE;
      }
   }
   if(!bfound)
      m_pLEADNet->PutSendList(m_pLEADNet->GetSendListNum(), m_hRemoteServer);
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetDisconnected(short iComputer) 
{
   CString szOut;
   
   // is our connection to the remote server closed?
   if(iComputer = m_hRemoteServer)
   {
      szOut = "Connection to the remote server was closed.";
      m_hRemoteServer = 0;
      StatusUpdate(szOut);
      m_bRemoteLoaded = FALSE;
      m_bRemoteCreated = FALSE;
   }
   UpdateMenuStatus();
   StatusUpdate("Connection closed");
}

void CNETCMDDlg::OnInetReceiveBitmap(short iComputer, long hBitmap) 
{
   CBitmapWnd *pBitmapWnd=NULL;

   pBitmapWnd = CreateNewBitmapWnd("Bitmap Received From Remote", 0, 0, 200, 200, FALSE);
   pBitmapWnd->m_LEAD1.GetRaster().SetBitmap(hBitmap);
   StatusUpdate("Bitmap Received From Remote.");
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetReceiveCmd(short iComputer, short InetCommand, long nCommandID, short nError, LPDISPATCH Params, long nExtraDataSize, ILEADRasterVariant * ExtraData) 
{
   short nStatus;
   CString szOut;
   CString szTmp;
   CBitmapWnd *pBitmapWnd=NULL;
   ILEADRasterInetPacket * Packet = NULL;
   short nRet;

   Params->QueryInterface (IID_ILEADRasterInetPacket, (void **)&Packet);
   if (!Packet)
      return;

   nStatus = ERROR_FEATURE_NOT_SUPPORTED;

   szOut.Format(TEXT("Command %d id=%d, nError=%d nParams=%d received"), 
                 InetCommand, nCommandID, nError, Packet->GetParamCount());

   if(nExtraDataSize > 0)
   {
      szTmp.Format(TEXT(", nExtraDataSize=%d"), nExtraDataSize);
      szOut = szOut + szTmp;
   }
   OutputDebugString(szOut);
   OutputDebugString(TEXT("\n"));
    
   if(nError != 0)
      nStatus = ERROR_TRANSFER_ABORTED;
   else
   {
      switch(InetCommand)
      {
      case INETCMD_LOAD:
         // check the validity of the parameters
         if((Packet->GetParamCount() == 4) && (Packet->GetParamType(0) == PARAM_TYPE_STRING) &&
            (Packet->GetParamType(1) == PARAM_TYPE_INT32) && (Packet->GetParamType(2) == PARAM_TYPE_INT32) &&
            (Packet->GetParamType(3) == PARAM_TYPE_UINT32))
         {
            //*
            CString Cmmand1 = (PSTR)(Packet->GetParamValue(0)->StringValue);
            short command2 = (short)Packet->GetParamValue(1)->LongValue;
            nStatus = ProcessLoadCommand(Cmmand1, command2);
            if(nStatus == 1)
            {
               szOut.Format(TEXT("Received LoadBitmapCmd - Loaded Bitmap %d ID=%d"), 
                             Packet->GetParamValue(0), m_nBitmapID);

               StatusUpdate(szOut);
            }
            else
               nStatus = ERROR_INV_PARAMETER; // invalid parameters

            RemoveSendList(iComputer);
            m_pLEADNet->InetSendLoadRsp(nCommandID, m_nBitmapID, 0, NULL, nStatus);
            AddSendList ();

            return;
         }
         break;

      case INETCMD_CREATE_WIN:
         // check the validity of the parameters
         if((Packet->GetParamCount() == 8) && (Packet->GetParamType(0) == PARAM_TYPE_STRING) &&
            (Packet->GetParamType(1) == PARAM_TYPE_STRING) && (Packet->GetParamType(2) == PARAM_TYPE_UINT32) &&
            (Packet->GetParamType(3) == PARAM_TYPE_INT32) && (Packet->GetParamType(4) == PARAM_TYPE_INT32) &&
            (Packet->GetParamType(5) == PARAM_TYPE_INT32) && (Packet->GetParamType(6) == PARAM_TYPE_INT32) &&
            (Packet->GetParamType(7) == PARAM_TYPE_UINT32))
         {
            long nWindowID;
            nWindowID = ProcessCreateWinCommand(iComputer,
                                                (PSTR)Packet->GetParamValue(1)->StringValue,
                                                Packet->GetParamValue(3)->LongValue,
                                                Packet->GetParamValue(4)->LongValue,
                                                Packet->GetParamValue(5)->LongValue,
                                                Packet->GetParamValue(6)->LongValue);

            RemoveSendList(iComputer);
            nRet = m_pLEADNet->InetSendCreateWinRsp(nCommandID, nWindowID, 0, NULL, 1);
            AddSendList ();
            
            return;
         }
         break;

      case INETCMD_ATTACH_BITMAP:
         if((Packet->GetParamCount() == 2) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32) &&
            (Packet->GetParamType(1) == PARAM_TYPE_UINT32))
         {
            nStatus = ProcessAttachBitmapCommand((long)Packet->GetParamValue(0)->DoubleValue,
                                                 (long)Packet->GetParamValue(1)->DoubleValue);

            RemoveSendList(iComputer);
            nRet = m_pLEADNet->InetSendAttachBitmapRsp(nCommandID, 0, NULL, nStatus);
            AddSendList ();
            
            return;
         }
         break;

      case INETCMD_SAVE:
         if((Packet->GetParamCount() == 6) && (Packet->GetParamType(0) == PARAM_TYPE_STRING) &&
            (Packet->GetParamType(1) == PARAM_TYPE_UINT32) && (Packet->GetParamType(2) == PARAM_TYPE_INT32) &&
            (Packet->GetParamType(3) == PARAM_TYPE_INT32) && (Packet->GetParamType(4) == PARAM_TYPE_INT32) &&
            (Packet->GetParamType(5) == PARAM_TYPE_UINT32))
         {
            nStatus = ProcessSaveCommand((PSTR)Packet->GetParamValue(0)->StringValue,
                                         (long)Packet->GetParamValue(1)->DoubleValue /*ulVal*/,
                                         Packet->GetParamValue(2)->LongValue,
                                         Packet->GetParamValue(3)->LongValue,
                                         Packet->GetParamValue(4)->LongValue,
                                         (long)Packet->GetParamValue(5)->DoubleValue/*ulVal*/);
            
            RemoveSendList(iComputer);
            nRet = m_pLEADNet->InetSendSaveRsp(nCommandID, 0, NULL, nStatus);
            AddSendList ();

            return;
         }
         else
            nStatus = ERROR_INV_PARAMETER;
         break;

      case INETCMD_FLIP:
         if((Packet->GetParamCount() == 1) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32))
         {
            RemoveSendList(iComputer);
            nStatus = ProcessFlipCommand((long)Packet->GetParamValue(0)->DoubleValue /*ulVal*/);
            AddSendList ();
         }
         else
            nStatus = ERROR_INV_PARAMETER;
         break;

      case INETCMD_GET:
         if((Packet->GetParamCount() == 1) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32))
         {
            RemoveSendList(iComputer);
            nStatus = ProcessGetCommand((long)Packet->GetParamValue(0)->DoubleValue /*ulVal*/);
            AddSendList ();
         }
         else
            nStatus = ERROR_INV_PARAMETER;
         break;

      case INETCMD_CREATEDWNDCLOSED:
         if((Packet->GetParamCount() == 1) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32))
         {
            if (Packet->GetParamValue(0)->DoubleValue/*ulVal*/ ==/* (unsigned long)*/m_nLastWindowID)
               m_bRemoteCreated = FALSE;

            nStatus = 1;
            StatusUpdate("Created Window Was Closed By The Server ...");

            break;
         }

         break;

      }
   }
   //return an error response
   m_pLEADNet->InetSendRsp((InetCmdType)InetCommand, nCommandID, NULL, 0, NULL, nStatus);
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetReceiveRsp(short iComputer, short InetCommand, long nCommandID, short nError, short nStatus, LPDISPATCH Params, long nExtraDataSize, /*const VARIANT FAR&*/ILEADRasterVariant * ExtraData) 
{
   CString szOut;
   CString szTmp;
   ILEADRasterInetPacket * Packet = NULL;

   Params->QueryInterface (IID_ILEADRasterInetPacket, (void **)&Packet);
     
   szOut.Format(TEXT("Command %d id=%d, nError=%d nStatus=%d, nParams=%d received"), 
                 InetCommand, nCommandID, nError, nStatus, Packet->GetParamCount());

   if(nExtraDataSize > 0)
   {
      szTmp.Format(TEXT(", nExtraDataSize=%d"), nExtraDataSize);
      szOut = szOut + szTmp;
   }
   OutputDebugString(szOut);
   OutputDebugString(TEXT("\n"));
    
   if(nError != 0)
      return;

   switch(InetCommand)
   {
   case INETCMD_LOAD:
      if((nStatus == 0) || (nStatus == 1))
      {
         if((Packet->GetParamCount() == 1) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32))
         {
            m_nLastBitmapID = (long) Packet->GetParamValue(0)->DoubleValue/*.ulVal*/;
            StatusUpdate("Load SUCCEEDED!");
            m_bRemoteLoaded = TRUE;
         }
         else
         {
            szOut.Format(TEXT("Load failed with error code %d"), nStatus);
            StatusUpdate(szOut);
         }
      }
      break;
            
   case INETCMD_CREATE_WIN:
      if((nStatus == 0) || (nStatus == 1))
      {
         if((Packet->GetParamCount() == 1) && (Packet->GetParamType(0) == PARAM_TYPE_UINT32))
         {
            m_nLastWindowID = (long) Packet->GetParamValue(0)->DoubleValue/*.ulVal*/;
            StatusUpdate("CreateWin SUCCEEDED!");
            m_bRemoteCreated = TRUE;
         }
      }
      else
      {
         szOut.Format(TEXT("Create Window failed with error code %d"), nStatus);
         StatusUpdate(szOut);
      }
      break;
   case INETCMD_SAVE:
      if((nStatus == 0) || (nStatus == 1))
         StatusUpdate("Save SUCCEEDED!");
      else
      {
         szOut.Format(TEXT("Save failed with error code %d"), nStatus);
         StatusUpdate(szOut);
      }
      break;
   }
   UpdateMenuStatus();
}

void CNETCMDDlg::OnLocalLoadbitmap() 
{
   LocalLoadBitmap();
   UpdateMenuStatus();
}

void CNETCMDDlg::LocalLoadBitmap(void)
{
   CString szFilename;
   CString szOut;
   CBitmapWnd *pBitmapWnd=NULL;
   
   m_LEAD1.GetRaster().SetBitmap(0);
   szFilename = TEXT("..\\images\\sample1.cmp");

   short iRet;
   LPDISPATCH pltRasterDisp = m_LEAD1.GetRaster().m_lpDispatch;
   BSTR strFileName = szFilename.AllocSysString();

   iRet = m_pltRasIO->Load(pltRasterDisp, strFileName, 24, 1, 1);
   if(!iRet)
   {
      szOut = TEXT("Local bitmap: ") + szFilename;
      pBitmapWnd = CreateNewBitmapWnd("Local Bitmap", 0, 0, 200, 200, TRUE);
      pBitmapWnd->m_LEAD1.GetRaster().SetBitmap(m_LEAD1.GetRaster().GetBitmap());
      m_LEAD1.GetRaster().SetBitmap(0);
      UpdateMenuStatus();
      szOut.Format(TEXT("Local Bitmap Loaded - %s."), szFilename);
      StatusUpdate(szOut);
   }
}

void CNETCMDDlg::OnLocalSavebitmap() 
{
   LocalSaveBitmap();
}

void CNETCMDDlg::LocalSaveBitmap(void)
{
   CString szFilename;
   CString szOut;
   
   if(m_pActiveKid && (m_pActiveKid->m_LEAD1.GetRaster().GetBitmap()!=0))
   {
      szFilename = "..\\images\\local.cmp";

      short iRet;
      BSTR strFileName = szFilename.AllocSysString ();
      LPDISPATCH pltRasterDisp = m_pActiveKid->m_LEAD1.GetRaster().m_lpDispatch;

      iRet = m_pltRasIO->Save (pltRasterDisp, strFileName, FILE_CMP, 0, (QFactorConstants)2, 0);
      if (iRet)
      {
         AfxMessageBox (TEXT("Failed to Save File."));
      }
      szOut.Format(TEXT("Local Bitmap Saved - %s."), szFilename);
      StatusUpdate(szOut);
   }
}

void CNETCMDDlg::OnUpdateLocalLoadbitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnUpdateLocalSavebitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::OnRemoteLoadbitmap() 
{
   short nRet;
   CString csOut;
   
   m_nCommandID++;
   nRet = m_pLEADNet->InetSendLoadCmd(m_nCommandID,TEXT("..\\images\\sample2.cmp"), 0, 1);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendLoadCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendLoadCmd Executed.");
}

void CNETCMDDlg::OnUpdateRemoteLoadbitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

short CNETCMDDlg::ProcessLoadCommand(CString csFile, short nBPP)
{
   short nStatus = 0;
   CLEADRasterView * pLead = NULL;
   
   pLead = CreateNewLeadBitmap();
   if (!pLead)
      return nStatus;


   short iRet;
   BSTR strFileName = csFile.AllocSysString ();
   LPDISPATCH pltRasterDisp = pLead->GetRaster().m_lpDispatch;

   iRet = m_pltRasIO->Load(pltRasterDisp, strFileName, nBPP, 0, -1);
   if(!iRet)
   {
      ::SetWindowLong(pLead->m_hWnd, GWL_USERDATA, m_nBitmapID);
      nStatus = 1;
   }
   else
   {
      RemoveLBitmap(pLead);
      DeleteLBitmap(pLead);
      m_nBitmapID--;
      RedimLBitmaps();
      SortLBitmaps();
   }
   
   return nStatus;
}

static const WCHAR BASED_CODE _szLicString[] =
	L"LEADTOOLS OCX Copyright (c) 1991-2004 LEAD Technologies, Inc.";

CLEADRasterView * CNETCMDDlg::CreateNewLeadBitmap(void)
{
   CRect rc;
   CLEADRasterView *pLead=NULL;
   BSTR lpLic = SysAllocString(_szLicString);

   pLead = (CLEADRasterView *)new CLEADRasterView;
   m_nBitmapID++;
   
   rc.SetRect(0, 0, 1, 1);
   BOOL x = pLead->Create(TEXT(""), 0,rc,this,0,NULL,FALSE);
   pLead->ShowWindow(SW_HIDE);
   SysFreeString(lpLic);

   RedimLBitmaps();
   AddLBitmap(pLead);

   return pLead;
}

void CNETCMDDlg::RedimLBitmaps(void)
{
   if(!m_aBitmaps)
      m_aBitmaps = (long*)GlobalAllocPtr(GMEM_MOVEABLE|GMEM_ZEROINIT, sizeof(CLEADRasterView*) * m_nBitmapID);
   else
      m_aBitmaps = (long*)GlobalReAllocPtr(m_aBitmaps, sizeof(CLEADRasterView*) * m_nBitmapID, GMEM_MOVEABLE|GMEM_ZEROINIT);
}

void CNETCMDDlg::AddLBitmap(CLEADRasterView *pLead)
{
   m_aBitmaps[m_nBitmapID - 1] = (long)pLead;
   SortLBitmaps();
}

void CNETCMDDlg::SortLBitmaps(void)
{
   long i;
   long j;
   long Temp=0;

   for(i=m_nBitmapID - 1; i>=0; i--)
   {
      for(j=i; j>=0; j--)
      {
         if(m_aBitmaps[j] < m_aBitmaps[i])
         {
            Temp          = m_aBitmaps[i];
            m_aBitmaps[i] = m_aBitmaps[j];
            m_aBitmaps[j] = Temp;
         }
      }
   }
}

void CNETCMDDlg::RemoveLBitmap(CLEADRasterView * pLead)
{
   long i;
   for(i=0; i<m_nBitmapID; i++)
   {
      if(m_aBitmaps[i] == (long)pLead)
         m_aBitmaps[i] = 0;
   }
   SortLBitmaps();
}

CLEADRasterView* CNETCMDDlg::FindLBitmap(long nBitmapID)
{
   long i;
   long id;
   for(i=0; i<m_nBitmapID; i++)
   {
      if(m_aBitmaps[i] && (((CLEADRasterView*)m_aBitmaps[i])->m_hWnd))
      {
         id = ::GetWindowLong(((CLEADRasterView*)m_aBitmaps[i])->m_hWnd, GWL_USERDATA);
         if(id == nBitmapID)
            return((CLEADRasterView*)m_aBitmaps[i]);
      }
   }
   return NULL;
}

void CNETCMDDlg::FreeLBitmaps(void)
{
   if(m_aBitmaps)
   {
      long i;
      for(i=0; i<m_nBitmapID; i++)
      {
         if(m_aBitmaps[i] && ((CLEADRasterView*)m_aBitmaps[i])->m_hWnd)
            DeleteLBitmap((CLEADRasterView*)m_aBitmaps[i]);
         else if(m_aBitmaps[i])
            delete ((CLEADRasterView*)m_aBitmaps[i]);
      }
      GlobalFreePtr(m_aBitmaps);
      m_aBitmaps = NULL;
   }
}

void CNETCMDDlg::DeleteLBitmap(CLEADRasterView* pLead)
{
   if(pLead)
   {
      pLead->GetRaster().SetBitmap(0);
      delete(pLead);
   }
}

void CNETCMDDlg::OnRemoteCreatewindow() 
{
   short nRet;
   CString csOut;
   
   m_nCommandID++;
   nRet = m_pLEADNet->InetSendCreateWinCmd(m_nCommandID,
                                          "", "Window Created By Remote", 
                                          0, 100, 100, 200, 200, 0);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendCreateWinCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendCreateWinCmd Executed.");
}

void CNETCMDDlg::OnUpdateRemoteCreatewindow(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

long CNETCMDDlg::ProcessCreateWinCommand(short iComputer, CString csCaption, long nLeft, long nTop, long nWidth, long nHeight)
{
   CBitmapWnd *pBitmapWnd=NULL;
   pBitmapWnd = CreateNewBitmapWnd(csCaption, nLeft, nTop, nWidth, nHeight, FALSE);
   pBitmapWnd->m_iComputer = iComputer;
   return (long)pBitmapWnd->m_hWnd;
}

void CNETCMDDlg::OnRemoteAttachbitmaptowindow() 
{
   short nRet;
   CString csOut;
   
   m_nCommandID++;
   nRet = m_pLEADNet->InetSendAttachBitmapCmd(m_nCommandID, m_nLastBitmapID, m_nLastWindowID);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendAttachBitmapCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendAttachBitmapCmd Executed.");

   m_bRemoteCreated = FALSE;
}

void CNETCMDDlg::OnUpdateRemoteAttachbitmaptowindow(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

short CNETCMDDlg::ProcessAttachBitmapCommand(long nBitmapID, long nWindowID)
{
   CLEADRasterView *pLead=NULL;
   CBitmapWnd *pBitmapWnd=NULL;

   // find the bitmap
   pLead = FindLBitmap(nBitmapID);
   if(!pLead)
      return ERROR_INV_PARAMETER;

   // find the window
   pBitmapWnd = FindKid((HWND)nWindowID);
   if(!pBitmapWnd)
      return ERROR_INV_PARAMETER;

   // OK, now attach
   pBitmapWnd->m_LEAD1.GetRaster().SetBitmap(pLead->GetRaster().GetBitmap());
   ::SetWindowLong(pBitmapWnd->m_hWnd, GWL_USERDATA, nBitmapID);
   return 0;
}

void CNETCMDDlg::OnRemoteSavebitmap() 
{
   short nRet;
   CString csOut;
   
   m_nCommandID++;
   nRet = m_pLEADNet->InetSendSaveCmd(m_nCommandID, m_nLastBitmapID,
                                     "..\\images\\remote.tif",
                                     FILE_TIF, 0, 0, TRUE);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendSaveCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendSaveCmd Executed.");
}

void CNETCMDDlg::OnUpdateRemoteSavebitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

short CNETCMDDlg::ProcessSaveCommand(CString csFile, long nBitmapID, long nFormat, long nBPP, long nQFactor, long bMP)
{
   CLEADRasterView *pLead=NULL;
   short nModify;

   //find the bitmap
   pLead = FindLBitmap(nBitmapID);

   if(!pLead)
      return ERROR_INV_PARAMETER;

   if(bMP)
      nModify = SAVE_APPEND;
   else
      nModify = 0;

   short iRet;
   BSTR strFileName = csFile.AllocSysString ();
   LPDISPATCH pltRasterDisp = pLead->GetRaster().m_lpDispatch;

   ::DeleteFile (csFile.LockBuffer());
   csFile.ReleaseBuffer ();
   iRet = m_pltRasIO->Save (pltRasterDisp, strFileName, (RasterFileConstants)nFormat, (short)nBPP, (QFactorConstants)nQFactor, nModify);

   return (0);
}

//const CLSID CLSID_LTInetPacket = {0x00120035,0xB1BA,0x11CE,{0xAB,0xC6,0xF5,0xB2,0xE7,0x9D,0x9E,0x3F}};

void CNETCMDDlg::OnRemoteFlipbitmap() 
{
   short nRet;
   CString csOut;
   ILEADRasterInetPacket * Packet = NULL;
   char szText[]="This is Flip";   
   IDispatch *pDisp=NULL;
   ILEADRasterVariant * pltRasVar = NULL;
   HRESULT hr = ::CoCreateInstance(CLSID_LEADRasterVariant, NULL, CLSCTX_ALL,
                                   IID_ILEADRasterVariant, (void **)&pltRasVar);
   if (FAILED(hr) || !pltRasVar)
      return ;

   m_nCommandID++;
   
   hr = CoCreateInstance(CLSID_LEADRasterInetPacket, NULL, CLSCTX_ALL, IID_ILEADRasterInetPacket, (void**)&Packet);
   //Packet.AttachDispatch(pDisp);
   
   Packet->PutParamCount(1);
   pltRasVar->Type = VALUE_ULONG;
   pltRasVar->DoubleValue = m_nLastBitmapID;
   Packet->PutParamValue(0, pltRasVar);
   Packet->PutParamType(0, PARAM_TYPE_UINT32);


   pltRasVar->Type = VALUE_ARRAY_BYTE;
   pltRasVar->ItemCount = strlen(szText)+1;
   for (unsigned int i = 0; i < strlen(szText)+1; i++)
      pltRasVar->PutShortItemValue(i, szText[i]);

   nRet = m_pLEADNet->InetSendCmd(INETCMD_FLIP, m_nCommandID, Packet, strlen(szText) + 1, pltRasVar /*&var*/);

   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendCmd Executed.");

   
   pltRasVar->Release();
}

void CNETCMDDlg::OnUpdateRemoteFlipbitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

short CNETCMDDlg::ProcessFlipCommand(long nBitmapID)
{
   short nStatus = 0;
   LPDISPATCH pltRasterDisp = NULL;
   CLEADRasterView *pLead=NULL;
   CBitmapWnd *pBitmapWnd=NULL;

   // find the bitmap
   pLead = FindLBitmap(nBitmapID);

   if(!pLead)
      return ERROR_INV_PARAMETER;

   // find the window
   long i;
   long id;
   for(i=0; i<m_lKids; i++)
   {
      if(m_aKids[i] && ((CBitmapWnd*)m_aKids[i])->m_hWnd)
      {
         id = ::GetWindowLong(((CBitmapWnd*)m_aKids[i])->m_hWnd, GWL_USERDATA);
         if(id == nBitmapID)
         {
            pltRasterDisp = ((CBitmapWnd*)m_aKids[i])->m_LEAD1.GetRaster().m_lpDispatch;
            nStatus = m_pltRasProc->Flip (pltRasterDisp);
         }
      }
   }

   pltRasterDisp = pLead->GetRaster().m_lpDispatch;
   nStatus = m_pltRasProc->Flip (pltRasterDisp);

   if(nStatus==0)
      nStatus=1;

   return nStatus;
}

void CNETCMDDlg::OnRemoteGetbitmap() 
{
   short nRet;
   CString csOut;
   ILEADRasterInetPacket * Packet;
   char szText[]="This is Get";
   //HRESULT hr;
   IDispatch *pDisp=NULL;
   ILEADRasterVariant * pltRasVar = NULL;
   HRESULT hr = ::CoCreateInstance(CLSID_LEADRasterVariant, NULL, CLSCTX_ALL,
                                   IID_ILEADRasterVariant, (void **)&pltRasVar);
   if (FAILED(hr) || !pltRasVar)
      return ;

   m_nCommandID++;
   
   hr = CoCreateInstance(CLSID_LEADRasterInetPacket, NULL, CLSCTX_ALL, IID_ILEADRasterInetPacket, (void**)&Packet);
   //Packet.AttachDispatch(pDisp);
   
   Packet->PutParamCount(1);

   pltRasVar->Type = VALUE_ULONG;
   pltRasVar->DoubleValue = m_nLastBitmapID;
   Packet->PutParamValue(0, pltRasVar);
   Packet->PutParamType(0, PARAM_TYPE_UINT32);


   pltRasVar->Type = VALUE_ARRAY_BYTE;
   pltRasVar->ItemCount = strlen(szText) + 1;
   for (unsigned int i = 0; i < strlen(szText) + 1; i++)
      pltRasVar->PutShortItemValue(i, szText[i]);

   nRet = m_pLEADNet->InetSendCmd((InetCmdType)(INETCMD_USER_CUSTOM + 1)/*INETCMD_GET*/, m_nCommandID, Packet, strlen(szText) + 1, pltRasVar );

   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format(TEXT("ERROR %d calling InetSendCmd."), nRet);
      StatusUpdate(csOut);
   }
   else
      StatusUpdate("InetSendCmd Executed.");

   pltRasVar->Release();
}

void CNETCMDDlg::OnUpdateRemoteGetbitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

short CNETCMDDlg::ProcessGetCommand(long nBitmapID)
{
   short nStatus;
   CLEADRasterView *pLead=NULL;
   CBitmapWnd *pBitmapWnd=NULL;

   // find the bitmap
   pLead = FindLBitmap(nBitmapID);

   if(!pLead)
      return ERROR_INV_PARAMETER;

   nStatus = m_pLEADNet->InetSendBitmap(pLead->GetRaster().m_lpDispatch, FILE_CMP, 0, QFACTOR_PQ1);
   if(nStatus==0)
      nStatus=1;
   return nStatus;
}

void CNETCMDDlg::OnLocalSendbitmap() 
{
   LocalSendBitmap();
}

void CNETCMDDlg::OnUpdateLocalSendbitmap(CCmdUI* pCmdUI) 
{
   UpdateMenuStatus();
}

void CNETCMDDlg::LocalSendBitmap(void)
{
   short nRet;
   CString szOut;
   
   if(m_pActiveKid && (m_pActiveKid->m_LEAD1.GetRaster().GetBitmap()!=0))
   {
      nRet = m_pLEADNet->InetSendBitmap(m_pActiveKid->m_LEAD1.GetRaster().m_lpDispatch, FILE_CMP, 0, QFACTOR_PQ1);
      szOut.Format(TEXT("Local Bitmap Sent - %d."), nRet);
      StatusUpdate(szOut);
   }
}

void CNETCMDDlg::RemoveSendList(int iComp)
{
    int i;
    
    m_nSendListNum = m_pLEADNet->GetSendListNum();
    
    m_picomps = (int *)GlobalAllocPtr (GHND, m_nSendListNum * sizeof(int));

    for (i = 0 ; i < m_nSendListNum ; i++)
       m_picomps[i] = m_pLEADNet->GetSendList(i);

    for (i = 1 ; i < m_nSendListNum ; i++)
        m_pLEADNet->PutSendList(i, 0);
    
    m_pLEADNet->PutSendList(0, iComp);
}

void CNETCMDDlg::AddSendList()
{
    int i;
    
    for (i = 0 ; i < m_nSendListNum ; i++)
       m_pLEADNet->PutSendList(i, m_picomps[i]);

    GlobalFreePtr (m_picomps);
    m_picomps = NULL;
}

void CNETCMDDlg::OnDestroy() 
{
	CDialog::OnDestroy();
	
   FreeKids();
   FreeLBitmaps();

   if (m_pltRasIO)
      m_pltRasIO->Release ();

   if (m_pltRasProc)
      m_pltRasProc->Release ();

   if (m_pLEADNet)
      m_pLEADNet->Release ();

   if (m_pRasterFileDlg)
      m_pRasterFileDlg->Release ();
    
   m_pRasterKrnDlg->FreeDlg();
   
   if(m_pRasterKrnDlg)
      m_pRasterKrnDlg->Release ();
   
   m_pRasterFileDlg = NULL;

   m_pltRasIO = NULL;
   m_pltRasProc = NULL;
   m_pLEADNet = NULL;
}

void CNETCMDDlg::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
{
   UpdateMenuStatus ();
   CDialog::OnActivate(nState, pWndOther, bMinimized);
}

void CNETCMDDlg::RecalcSize(CBitmapWnd * pBmp, int & cx, int & cy)
{
   m_LEAD1.GetRaster().SetScaleMode (3); // Pixels
   
   if (m_LEAD1.GetRaster().GetBitmapWidth() < cx)
      cx = (int)m_LEAD1.GetRaster().GetBitmapWidth() + ::GetSystemMetrics (SM_CYHSCROLL);
   if (m_LEAD1.GetRaster().GetBitmapHeight() < cy)
      cy = (int)m_LEAD1.GetRaster().GetBitmapHeight() + ::GetSystemMetrics (SM_CYCAPTION) + ::GetSystemMetrics (SM_CYVSCROLL);
}