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

#include "stdafx.h"
#include <windowsx.h>
#include "NETCMD.h"
#include "BmpWnd.h"
#include "AddDlg.h"
#include "LTPacket.h"

// my user defined commands
#define INETCMD_FLIP INETCMD_USER_CUSTOM
#define INETCMD_GET  INETCMD_USER_CUSTOM + 1

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

BEGIN_MESSAGE_MAP(CNETCMDApp, CWinApp)
	//{{AFX_MSG_MAP(CNETCMDApp)
	//}}AFX_MSG_MAP
	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_bServerStarted =  FALSE;
   m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
   m_aKids = NULL;
   m_pActiveKid = NULL;
   m_aBitmaps = NULL;
}

void CNETCMDDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CNETCMDDlg)
	DDX_Control(pDX, IDC_LEADNETCTRL1, m_LEADNet1);
//	DDX_Control(pDX, IDC_LEADDLGCTRL1, m_LEADDlg1);
	DDX_Control(pDX, IDC_LEADCTRL1, 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()
	//}}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
	
   UNLOCKSUPPORT(m_LEADNet1);

   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_LEADDlg1.SetEnableMethodErrors(FALSE);
   m_bRemoteLoaded = FALSE;
   m_bRemoteCreated = FALSE;
   m_nLastBitmapID = -1;
   m_nLastWindowID = -1;
   UpdateMenuStatus();
   StatusUpdate("Ready.");

   m_LEADNet1.ShowWindow(SW_HIDE);
   m_LEAD1.ShowWindow(SW_HIDE);

   CoInitialize(NULL);
   HRESULT hr;
   m_pRasterKrnDlg = NULL;
   hr = CoCreateInstance(
      CLSID_LEADRasterDlgKrn_D, 
      NULL, 
      CLSCTX_ALL, 
      IID_ILEADRasterDlgKrn_D, 
      (void**)&m_pRasterKrnDlg 
      );
   if (FAILED(hr)){DisplayLEADError(ERROR_INV_PARAMETER);EndDialog(0); return FALSE;}
   m_pRasterKrnDlg->InitDlg(INIT_WITH_COLOR); 
   m_pRasterKrnDlg->EnableMethodErrors = FALSE;

   m_pRasterFileDlg=NULL;
   hr = CoCreateInstance(
      CLSID_LEADRasterDlgFile_D, 
      NULL, 
      CLSCTX_ALL, 
      IID_ILEADRasterDlgFile_D, 
      (void**)&m_pRasterFileDlg
      );
   if (FAILED(hr)){DisplayLEADError(ERROR_INV_PARAMETER);EndDialog(0); return FALSE;}
   m_pRasterFileDlg->EnableMethodErrors = 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.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_bServerStarted)
      {
         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_LEADNet1.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_LEADNet1.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() 
{
   CBitmapWnd *pBitmapWnd=NULL;
   TCHAR szCurPath [MAX_PATH];
   short nRet;
    
   memset (szCurPath, 0, MAX_PATH*sizeof(TCHAR));
   GetCurrentDirectory (MAX_PATH, szCurPath);

   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);
   
   m_LEAD1.SetEnableMethodErrors(FALSE);
   
   if(nRet == 0 && m_pRasterFileDlg->GetDialogStatus() == DLG_OK)
   {
      nRet = m_LEAD1.Load(m_pRasterFileDlg->GetFileName(), 0, m_pRasterFileDlg->GetPageNumber(), 1);
      if(nRet == 0)
      {
         pBitmapWnd = CreateNewBitmapWnd((LPCSTR)m_pRasterFileDlg->GetFileName(), 0, 0, 100, 100);
         pBitmapWnd->m_LEAD1.SetBitmap(m_LEAD1.GetBitmap());
         m_pActiveKid = pBitmapWnd;
         m_LEAD1.SetBitmap(0);
      }
      else
         if(nRet == 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("Error Opening File!", "Error", MB_OK);
   }
   else
   {
      if(m_pRasterFileDlg->GetDialogStatus() != DLG_CANCEL) 
         DisplayLEADError(nRet);
   }
   UpdateMenuStatus();
   SetCurrentDirectory (szCurPath);
}

CBitmapWnd * CNETCMDDlg::CreateNewBitmapWnd(CString csCaption, long nLeft, long nTop, long nWidth, long nHeight)
{
   CBitmapWnd *pBitmapWnd=NULL;
   pBitmapWnd = (CBitmapWnd *)new CBitmapWnd;
   m_lKids++;
   pBitmapWnd->m_pOwner = this;
   pBitmapWnd->Create(IDD_BITMAPWND, this);
   pBitmapWnd->SetWindowText(csCaption);
   pBitmapWnd->SetWindowPos(NULL, nLeft, nTop, nWidth, nHeight, SWP_SHOWWINDOW);
	pBitmapWnd->SetIcon(m_hIcon, TRUE);			// Set big icon
	pBitmapWnd->SetIcon(m_hIcon, FALSE);		// Set small icon

   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);
   }
}

void CNETCMDDlg::OnFileSave() 
{
   short nRet;
   
   if(m_lKids <= 0 )
      return ;

   m_pRasterFileDlg->PutFileDlgFlags(0);
   m_pRasterFileDlg->PutDialogTitle("Save A File");
   m_pRasterFileDlg->PutUIFlags(SAVE_SHOW_FILEOPTIONS_MULTIPAGE |
                                 SAVE_SHOW_FILEOPTIONS_QFACTOR);
       
   nRet = m_pRasterFileDlg->ShowSaveDlg((long)this->m_hWnd);
   if(nRet == 0 && m_pRasterFileDlg->GetDialogStatus() == DLG_OK) 
   {
      nRet = m_pActiveKid->SaveToFile((LPTSTR)m_pRasterFileDlg->GetFileName(),
                                      m_pRasterFileDlg->GetSaveFormat(),
                                      m_pRasterFileDlg->GetSaveBitsPerPixel(),
                                      m_pRasterFileDlg->GetSaveQFactor(),
                                      m_pRasterFileDlg->GetSaveMulti());
      if(nRet != 0)
         MessageBox("Error Saving File!", "Error", MB_OK);
   }
   else
   {
      if(m_pRasterFileDlg->GetDialogStatus() != DLG_CANCEL)
         MessageBox("Error Saving File!", "Error", MB_OK);
   }
   UpdateMenuStatus();
}

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

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

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

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

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

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

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

void CNETCMDDlg::OnServerStartup() 
{
   short nRet;

   nRet = m_LEADNet1.InetServerInit(&m_hServer, 1000);
   if(nRet == 0)
   {
      StatusUpdate("Server Started.");
      m_bServerStarted = TRUE;
   }
   else
   {
      StatusUpdate("Error Starting Server.");
      m_bServerStarted = FALSE;
   }
   
   UpdateMenuStatus();
}

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

void CNETCMDDlg::ShutDownServer(BOOL bGraceful)
{
   if(m_hServer != 0)
   {
      m_LEADNet1.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_LEADNet1.GetConnectListNum() > 0)
      m_LEADNet1.InetDisconnect(m_LEADNet1.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_LEADNet1.InetConnect(m_szAddress, 1000);
      if(nRet == ERROR_HOST_RESOLVE)
         MessageBox("Failed to connect - bad URL", "Error", MB_OK);
      else if (nRet != 0)
      {
         CString csOut;
         csOut.Format("Error %d trying to connect", nRet);
         MessageBox(csOut, "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_LEADNet1.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)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 5 /* InetAccept */, OnInetAcceptLeadnetctrl1, VTS_I2)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 3 /* InetConnected */, OnInetConnectedLeadnetctrl1, VTS_I2)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 4 /* InetDisconnected */, OnInetDisconnectedLeadnetctrl1, VTS_I2)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 1 /* InetReceiveBitmap */, OnInetReceiveBitmapLeadnetctrl1, VTS_I2 VTS_I4)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 12 /* InetReceiveCmd */, OnInetReceiveCmdLeadnetctrl1, VTS_I2 VTS_I2 VTS_I4 VTS_I2 VTS_DISPATCH VTS_I4 VTS_VARIANT)
	ON_EVENT(CNETCMDDlg, IDC_LEADNETCTRL1, 13 /* InetReceiveRsp */, OnInetReceiveRspLeadnetctrl1, VTS_I2 VTS_I2 VTS_I4 VTS_I2 VTS_I2 VTS_DISPATCH VTS_I4 VTS_VARIANT)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

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

void CNETCMDDlg::OnInetConnectedLeadnetctrl1(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_LEADNet1.InetGetHostName(iComputer, HOST_NAME_IP, &bstrHost);
   szHost = bstrHost;
   if(nRet != 0)
      szOut = szOut + m_szAddress;
   else
      szOut = szOut + szHost;

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

void CNETCMDDlg::OnInetDisconnectedLeadnetctrl1(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);
   }
   UpdateMenuStatus();
   StatusUpdate("Connection closed");
}

void CNETCMDDlg::OnInetReceiveBitmapLeadnetctrl1(short iComputer, long hBitmap) 
{
   CBitmapWnd *pBitmapWnd=NULL;
   
   pBitmapWnd = CreateNewBitmapWnd("Bitmap Received From Remote", 0, 0, 100, 100);
   pBitmapWnd->m_LEAD1.SetBitmap(hBitmap);
   StatusUpdate("Bitmap Received From Remote.");
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetReceiveCmdLeadnetctrl1(short iComputer, short InetCommand, long nCommandID, short nError, LPDISPATCH Params, long nExtraDataSize, const VARIANT FAR& ExtraData) 
{
   short nStatus;
   CString szOut;
   CString szTmp;
   CBitmapWnd *pBitmapWnd=NULL;
   CLTInetPacket Packet(Params);
   short nRet;
   
   nStatus = -13;//ERROR_FEATURE_NOT_SUPPORTED;

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

   if(nExtraDataSize > 0)
   {
      szTmp.Format(", nExtraDataSize=%d", nExtraDataSize);
      szOut = szOut + szTmp;
   }
   OutputDebugString(szOut);
   OutputDebugString("\n");
    
   if(nError != 0)
      nStatus = -86;//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))
         {
            nStatus = ProcessLoadCommand(Packet.GetParamValue(0).bstrVal, (short)Packet.GetParamValue(1).lVal);
            if(nStatus == 1)
            {
               szOut.Format("Received LoadBitmapCmd - Loaded Bitmap %d ID=%d", 
                             Packet.GetParamValue(0), m_nBitmapID);

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

            m_LEADNet1.InetSendLoadRsp(nCommandID, m_nBitmapID, 0, NULL, nStatus);
            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(Packet.GetParamValue(1).bstrVal,
                                              Packet.GetParamValue(3).lVal,
                                              Packet.GetParamValue(4).lVal,
                                              Packet.GetParamValue(5).lVal,
                                              Packet.GetParamValue(6).lVal);
            nRet = m_LEADNet1.InetSendCreateWinRsp(nCommandID, nWindowID, 0, NULL, 1);
            return;
         }
         break;

      case INETCMD_ATTACH_BITMAP:
         if((Packet.GetParamCount() == 2) && (Packet.GetParamType(0) == PARAM_TYPE_UINT32) &&
            (Packet.GetParamType(1) == PARAM_TYPE_UINT32))
         {
            nStatus = ProcessAttachBitmapCommand(Packet.GetParamValue(0).ulVal,
                                                 Packet.GetParamValue(1).ulVal);
            nRet = m_LEADNet1.InetSendAttachBitmapRsp(nCommandID, 0, NULL, nStatus);
            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(Packet.GetParamValue(0).bstrVal,
                                         Packet.GetParamValue(1).ulVal,
                                         Packet.GetParamValue(2).lVal,
                                         Packet.GetParamValue(3).lVal,
                                         Packet.GetParamValue(4).lVal,
                                         Packet.GetParamValue(5).ulVal);
            nRet = m_LEADNet1.InetSendSaveRsp(nCommandID, 0, NULL, nStatus);
            return;
         }
         else
            nStatus = -13;//ERROR_INV_PARAMETER;
         break;

      case INETCMD_FLIP:
         if((Packet.GetParamCount() == 1) && (Packet.GetParamType(0) == PARAM_TYPE_UINT32))
            nStatus = ProcessFlipCommand(Packet.GetParamValue(0).ulVal);
         else
            nStatus = -13;//ERROR_INV_PARAMETER;
         break;

      case INETCMD_GET:
         if((Packet.GetParamCount() == 1) && (Packet.GetParamType(0) == PARAM_TYPE_UINT32))
            nStatus = ProcessGetCommand(Packet.GetParamValue(0).ulVal);
         else
            nStatus = -13;//ERROR_INV_PARAMETER;
         break;
      }
   }
   //return an error response
   m_LEADNet1.InetSendRsp(InetCommand, nCommandID, NULL, 0, NULL, nStatus);
   UpdateMenuStatus();
}

void CNETCMDDlg::OnInetReceiveRspLeadnetctrl1(short iComputer, short InetCommand, long nCommandID, short nError, short nStatus, LPDISPATCH Params, long nExtraDataSize, const VARIANT FAR& ExtraData) 
{
   CString szOut;
   CString szTmp;
   CLTInetPacket Packet(Params);
     
   szOut.Format("Command %d id=%d, nError=%d nStatus=%d, nParams=%d received", 
                 InetCommand, nCommandID, nError, nStatus, Packet.GetParamCount());

   if(nExtraDataSize > 0)
   {
      szTmp.Format(", nExtraDataSize=%d", nExtraDataSize);
      szOut = szOut + szTmp;
   }
   OutputDebugString(szOut);
   OutputDebugString("\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 = Packet.GetParamValue(0).ulVal;
            StatusUpdate("Load SUCCEEDED!");
            m_bRemoteLoaded = TRUE;
         }
         else
         {
            szOut.Format("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 = Packet.GetParamValue(0).ulVal;
            StatusUpdate("CreateWin SUCCEEDED!");
            m_bRemoteCreated = TRUE;
         }
      }
      else
      {
         szOut.Format("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("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;
   short nRet;
   
   m_LEAD1.SetBitmap(0);
   szFilename = "..\\images\\sample1.cmp";
   nRet = m_LEAD1.Load(szFilename, 24, 1, 1);
   if(nRet == 0)
   {
      szOut = "Local bitmap: " + szFilename;
      pBitmapWnd = CreateNewBitmapWnd("Local Bitmap", 0, 0, 100, 100);
      pBitmapWnd->m_LEAD1.SetBitmap(m_LEAD1.GetBitmap());
      m_LEAD1.SetBitmap(0);
      UpdateMenuStatus();
      szOut.Format("Local Bitmap Loaded - %s.", szFilename);
      StatusUpdate(szOut);
   }
}

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

void CNETCMDDlg::LocalSaveBitmap(void)
{
   short nRet;
   CString szFilename;
   CString szOut;
   
   if(m_pActiveKid && (m_pActiveKid->m_LEAD1.GetBitmap()!=0))
   {
      szFilename = "..\\images\\sample3.jpg";
      nRet = m_pActiveKid->m_LEAD1.Save(szFilename, FILE_JPEG, 0, 2, 0);
      szOut.Format("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_LEADNet1.InetSendLoadCmd(m_nCommandID, "..\\images\\sample2.cmp", 0, 1);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format("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;
   CLead *pLead=NULL;
   
   pLead = CreateNewLeadBitmap();
   nStatus = pLead->Load(csFile, nBPP, 1, 1);
   if(nStatus == 0)
   {
      ::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-2001 LEAD Technologies, Inc.";

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

   pLead = (CLead *)new CLead;
   m_nBitmapID++;
   
   rc.SetRect(0, 0, 1, 1);
   pLead->Create("", 0,rc,this,0,NULL,FALSE,lpLic);
   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(CLead*) * m_nBitmapID);
   else
      m_aBitmaps = (long*)GlobalReAllocPtr(m_aBitmaps, sizeof(CLead*) * m_nBitmapID, GMEM_MOVEABLE|GMEM_ZEROINIT);
}

void CNETCMDDlg::AddLBitmap(CLead *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(CLead* pLead)
{
   long i;
   for(i=0; i<m_nBitmapID; i++)
   {
      if(m_aBitmaps[i] == (long)pLead)
         m_aBitmaps[i] = 0;
   }
   SortLBitmaps();
}

CLead* CNETCMDDlg::FindLBitmap(long nBitmapID)
{
   long i;
   long id;
   for(i=0; i<m_nBitmapID; i++)
   {
      if(m_aBitmaps[i] && (((CLead*)m_aBitmaps[i])->m_hWnd))
      {
         id = ::GetWindowLong(((CLead*)m_aBitmaps[i])->m_hWnd, GWL_USERDATA);
         if(id == nBitmapID)
            return((CLead*)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] && ((CLead*)m_aBitmaps[i])->m_hWnd)
            DeleteLBitmap((CLead*)m_aBitmaps[i]);
      }
      GlobalFreePtr(m_aBitmaps);
      m_aBitmaps = NULL;
   }
}

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

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

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

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

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

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

short CNETCMDDlg::ProcessAttachBitmapCommand(long nBitmapID, long nWindowID)
{
   CLead *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.SetBitmap(pLead->GetBitmap());
   ::SetWindowLong(pBitmapWnd->m_hWnd, GWL_USERDATA, nBitmapID);
   return 0;
}

void CNETCMDDlg::OnRemoteSavebitmap() 
{
   short nRet;
   CString csOut;
   
   m_nCommandID++;
   nRet = m_LEADNet1.InetSendSaveCmd(m_nCommandID, m_nLastBitmapID,
                                     "..\\images\\remote.tif", 
                                     FILE_TIF, 0, 0, TRUE);
   if((nRet != 0) && (nRet != ERROR_DATA_QUEUED))
   {
      csOut.Format("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)
{
   CLead *pLead=NULL;
   short nModify;

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

   if(!pLead)
      return ERROR_INV_PARAMETER;

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

   return (pLead->Save(csFile, (short)nFormat, (short)nBPP, (short)nQFactor, nModify));
}

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

void CNETCMDDlg::OnRemoteFlipbitmap() 
{
   short nRet;
   CString csOut;
   CLTInetPacket Packet;
   char szText[]="This is Flip";
   VARIANT var;
   SAFEARRAY FAR *psa;
   SAFEARRAYBOUND rgsabound[1];
   VARIANT vaVal;
   HRESULT hr;
   IDispatch *pDisp=NULL;

   m_nCommandID++;
   
   hr = CoCreateInstance(CLSID_LTInetPacket, NULL, CLSCTX_ALL, IID_IDispatch, (void**)&pDisp);
   Packet.AttachDispatch(pDisp);
   
   Packet.SetParamCount(1);
   VariantInit(&vaVal);
   V_VT(&vaVal) = (VT_UI4);
   V_UI4(&vaVal) = m_nLastBitmapID;
   Packet.SetParamValue(0, vaVal);
   Packet.SetParamType(0, PARAM_TYPE_UINT32);
   
   VariantInit(&var);
   rgsabound[0].lLbound = 0;
   rgsabound[0].cElements = lstrlen(szText) + 1;

   psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
   if (psa != NULL)
   {
      SafeArrayLock(psa);
      strcpy((char far *)psa->pvData, szText);
      SafeArrayUnlock(psa);
      V_VT(&var) = (VT_ARRAY | VT_UI1);
      V_ARRAY(&var) = psa;
	
      nRet = m_LEADNet1.InetSendCmd(INETCMD_FLIP, m_nCommandID, Packet, lstrlen(szText) + 1, &var);

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

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

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

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

   if(!pLead)
      return ERROR_INV_PARAMETER;

   nStatus = pLead->Flip();
   if(nStatus!=0)
      return nStatus;

   // 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)
            nStatus = ((CBitmapWnd*)m_aKids[i])->m_LEAD1.Flip();
      }
   }
   if(nStatus==0)
      nStatus=1;
   return nStatus;
}

void CNETCMDDlg::OnRemoteGetbitmap() 
{
   short nRet;
   CString csOut;
   CLTInetPacket Packet;
   char szText[]="This is Get";
   VARIANT var;
   SAFEARRAY FAR *psa;
   SAFEARRAYBOUND rgsabound[1];
   VARIANT vaVal;
   HRESULT hr;
   IDispatch *pDisp=NULL;

   m_nCommandID++;
   
   hr = CoCreateInstance(CLSID_LTInetPacket, NULL, CLSCTX_ALL, IID_IDispatch, (void**)&pDisp);
   Packet.AttachDispatch(pDisp);
   
   Packet.SetParamCount(1);
   VariantInit(&vaVal);
   V_VT(&vaVal) = (VT_UI4);
   V_UI4(&vaVal) = m_nLastBitmapID;
   Packet.SetParamValue(0, vaVal);
   Packet.SetParamType(0, PARAM_TYPE_UINT32);
   
   VariantInit(&var);
   rgsabound[0].lLbound = 0;
   rgsabound[0].cElements = lstrlen(szText) + 1;

   psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
   if (psa != NULL)
   {
      SafeArrayLock(psa);
      strcpy((char far *)psa->pvData, szText);
      SafeArrayUnlock(psa);
      V_VT(&var) = (VT_ARRAY | VT_UI1);
      V_ARRAY(&var) = psa;
	
      nRet = m_LEADNet1.InetSendCmd(INETCMD_GET, m_nCommandID, Packet, lstrlen(szText) + 1, &var);

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

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

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

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

   if(!pLead)
      return ERROR_INV_PARAMETER;

   nStatus = m_LEADNet1.InetSendBitmap(pLead->GetBitmap(), FILE_CMP, 0, 200);
   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.GetBitmap()!=0))
   {
      nRet = m_LEADNet1.InetSendBitmap(m_pActiveKid->m_LEAD1.GetBitmap(), FILE_CMP, 0, 200);
      szOut.Format("Local Bitmap Sent - %d.", nRet);
      StatusUpdate(szOut);
   }
}

int CNETCMDDlg::DisplayLEADError(int nCode)
{
    CString str;

    if(nCode)
    {
        str.Format("A LEADTOOLS error has occured.\nCODE = %d", nCode);
        MessageBox(str);
    }
    return(nCode);
}

void CNETCMDDlg::OnDestroy() 
{
	CDialog::OnDestroy();
	
   m_pRasterKrnDlg->FreeDlg();
   if (m_pRasterKrnDlg != NULL)  m_pRasterKrnDlg->Release();
   if (m_pRasterFileDlg != NULL)  m_pRasterFileDlg->Release();
}