// OPCServerDlg.cpp : implementation file
//


#include "mexOPC.h"
#include "stdafx.h"
#include "OPCServerDlg.h"
#include "OPC ClientDoc.h"
#include <LMCONS.H>
#include <lmserver.h>
#include "Resource.h"
#define __GUID_DEFINED__
#include "OPCDa_Cats.c"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
const CLSID CLSID_OPCServerList = {0x13486D51,0x4821,0x11D2,{0xA4,0x94,0x3C,0xB3,0x06,0xC1,0x00,0x00}};
CONST ULONG NEXT_COUNT = 100; // number of elements to request when calling Next
extern OPCClientDoc* pDoc;
/////////////////////////////////////////////////////////////////////////////
// OPCServerDlg dialog


OPCServerDlg::OPCServerDlg(CWnd* pParent /*=NULL*/)
   : CDialog(OPCServerDlg::IDD, pParent)
{
   m_Enumerated = FALSE;
   memset( &m_clsid, 0, sizeof(m_clsid) );
   m_catid = CATID_OPCDAServer20;
   //{{AFX_DATA_INIT(OPCServerDlg)
   m_Node = _T("Test6");
   m_Server = _T("");
   m_currentServer = _T("");
	m_synctime = 4000;
	//}}AFX_DATA_INIT
}

OPCServerDlg::~OPCServerDlg()
{
   POSITION pos = m_Servers.GetHeadPosition();
   while( pos )
   {
      delete m_Servers.GetNext( pos );
   }
}

void OPCServerDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(OPCServerDlg)
   DDX_CBString(pDX, IDC_NODE, m_Node);
   DDX_Text(pDX, IDC_SERVER, m_Server);
	DDX_Text(pDX, IDC_SYNCTIME, m_synctime);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(OPCServerDlg, CDialog)
   //{{AFX_MSG_MAP(OPCServerDlg)
   ON_BN_CLICKED(IDC_REFRESH, OnRefresh)
   ON_CBN_DROPDOWN(IDC_NODE, OnDropdownNode)
   ON_CBN_SELCHANGE(IDC_NODE, OnSelchangeNode)
   ON_LBN_SELCHANGE(IDC_SERVER_LIST, OnSelchangeServerList)
   ON_LBN_DBLCLK(IDC_SERVER_LIST, OnDblclkServerList)
   ON_BN_CLICKED(IDC_SERVERS10, OnServers10)
   ON_BN_CLICKED(IDC_SERVERS20, OnServers20)
	ON_WM_CLOSE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// OPCServerDlg message handlers

//**************************************************************************
BOOL OPCServerDlg::OnInitDialog()
{
   CWaitCursor wait;
   CDialog::OnInitDialog();

   CheckRadioButton(IDC_SERVERS10, IDC_SERVERS20, IDC_SERVERS20);
   // Fill in the list of OPC servers
   GetOPCServers();

   return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

//**************************************************************************
BOOL OPCServerDlg::EnumerateNodes(LPNETRESOURCE lpnr)
{

	CComboBox* pNodes = (CComboBox*)GetDlgItem(IDC_NODE);
	HANDLE hEnum = 0;
	//only enumerate nodes in context(in net neighbour)
	DWORD dwResult = WNetOpenEnum(RESOURCE_CONTEXT,
                     RESOURCETYPE_ANY,
                     RESOURCEUSAGE_CONTAINER, //infact this parameter is ignored
                     lpnr,              // NULL first time this function is called
                     &hEnum);           // handle to resource

	if (dwResult != NO_ERROR)
		return FALSE;
	
	DWORD cbBuffer = 16384;      // 16K buffer
	LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) GlobalAlloc(GPTR, cbBuffer);

	do
	{
		DWORD cEntries = 0xFFFFFFFF; // enumerate all possible entries
		dwResult = WNetEnumResource(hEnum,
									&cEntries,
									lpnrLocal,
									&cbBuffer);
		if (dwResult == NO_ERROR)
		{
			for( DWORD i = 0; i < cEntries; i++)
			{
				// If this NETRESOURCE is a container, call the function
				// recursively.
				if(RESOURCEUSAGE_CONTAINER ==(lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER))
				{
					//here we only list node, ignore any container
					if(RESOURCEDISPLAYTYPE_SERVER == lpnrLocal[i].dwDisplayType )
					{
						CString node(lpnrLocal[i].lpRemoteName);
						int index = node.Find( _T("\\") );
						if( index > -1 )
							node = node.Mid(index+2);
						if( pNodes )
							pNodes->AddString(node);
					}
				}
			}
		}
	}
	while(dwResult != ERROR_NO_MORE_ITEMS);

	GlobalFree((HGLOBAL) lpnrLocal);

	dwResult = WNetCloseEnum(hEnum);

	pNodes->SetWindowText(m_Node);
	
	if (dwResult != NO_ERROR)
		return FALSE;
   
	return TRUE;
}

//**************************************************************************

BOOL OPCServerDlg::GetOPCServers(LPTSTR node)
{
   CListBox* pList = (CListBox*)GetDlgItem( IDC_SERVER_LIST );
   USES_CONVERSION;

   CWaitCursor wait;
   ASSERT_VALID(pList);
   pList->ResetContent();
   int selection = 0;

   // New 2.0 method using component categories
   IOPCServerList* pServers=NULL;

   COSERVERINFO si;
   MULTI_QI  qi;

   si.dwReserved1 = 0;
   si.pwszName = NULL;
   if( node && node[0] != 0 )
      si.pwszName = T2OLE(node);
   si.pAuthInfo = NULL;
   si.dwReserved2 = 0;

   qi.pIID = &IID_IOPCServerList;
   qi.pItf = NULL;
   qi.hr = 0;

   HRESULT hr = CoCreateInstanceEx(CLSID_OPCServerList, NULL, CLSCTX_ALL, &si, 1, &qi);
   if (FAILED(hr) || FAILED(qi.hr))
   {
      CString msg(_T("Please install the OPC 2.0 Components."));
      if( !m_Node.IsEmpty() )
         msg.Format(_T("Please install the OPC 2.0 Components on %s."), (LPCTSTR)m_Node);
      AfxMessageBox(msg);
      CDialog::OnCancel();
      return FALSE;
   }
   pServers = (IOPCServerList*)qi.pItf;

   IEnumGUID *pEnumGUID=NULL;
   hr = pServers->EnumClassesOfCategories(1, &m_catid, 1, &m_catid, &pEnumGUID);
   if( SUCCEEDED(hr) )
   {
      unsigned long count;
      CLSID clsid[NEXT_COUNT];

      do
      {
         hr = pEnumGUID->Next(NEXT_COUNT, clsid, &count);
         for( ULONG index=0; index<count; index++ )
         {
            LPOLESTR pszProgID;
            LPOLESTR pszUserType;
            HRESULT hr2 = pServers->GetClassDetails(clsid[index], &pszProgID, &pszUserType);
            if (SUCCEEDED(hr2))
            {
               OPCServerInfo* pServerInfo = new OPCServerInfo(pszProgID, pszUserType, clsid[index] );
               m_Servers.AddTail( pServerInfo );
               CString name;
               name.Format( _T("%s  (%s)"),
                           (LPCTSTR)pServerInfo->m_ProgID,
                           (LPCTSTR)pServerInfo->m_Description );
               int pos = pList->AddString( name );
               pList->SetItemData( pos, (DWORD)pServerInfo );
               if( m_Server == pServerInfo->m_ProgID )
                  selection = pos;

               CoTaskMemFree(pszProgID);
               CoTaskMemFree(pszUserType);
            }
         }
      }
      while ( hr==S_OK );
      pEnumGUID->Release();
   }
   pServers->Release();

  
   if( pList->GetCount() > 0 )
      pList->SetCurSel(selection);

   OnSelchangeServerList();

   return TRUE;
}

//**************************************************************************
// allow double-click selection on a server
void OPCServerDlg::OnDblclkServerList()
{
   OnSelchangeServerList();
   OnOK();
}

//**************************************************************************
// Refresh the server list using the selected Node name
void OPCServerDlg::OnRefresh()
{
   UpdateData();
   GetOPCServers(m_Node.GetBuffer(0));
}

//**************************************************************************
// Automatically search for servers when the node name changes ?
void OPCServerDlg::OnSelchangeNode()
{
    
}

//**************************************************************************
void OPCServerDlg::OnSelchangeServerList()
{
   CWaitCursor wait;
   UpdateData();

   CListBox* pList = (CListBox*)GetDlgItem( IDC_SERVER_LIST );
   int index = pList->GetCurSel();
   OPCServerInfo* pServerInfo = (OPCServerInfo*)pList->GetItemData(index);
   if( pServerInfo && (DWORD)pServerInfo != LB_ERR )
   {
      m_clsid = pServerInfo->m_clsid;
      m_Server = pServerInfo->m_ProgID;
   }

   UpdateData( FALSE );
}

//**************************************************************************
void OPCServerDlg::OnDropdownNode()
{
   if( !m_Enumerated )
   {
      CWaitCursor wait;
      // Fill in the list of network nodes
      EnumerateNodes(NULL);
      m_Enumerated = TRUE;
   }
}

//**************************************************************************
void OPCServerDlg::OnOK()
{
   CWaitCursor wait;
   UpdateData();

   // Look for a matching server name
   POSITION pos = m_Servers.GetHeadPosition();
   while( pos )
   {
      OPCServerInfo* pServerInfo = m_Servers.GetNext( pos );
      if(m_Server == pServerInfo->m_ProgID)
      {
         m_clsid = pServerInfo->m_clsid;
         CDialog::OnOK();
      }
   }

   // If not found, Get CLSID from the ProgID
   USES_CONVERSION;
   IOPCServerList* pServers=NULL;

   COSERVERINFO si;
   MULTI_QI  qi;

   si.dwReserved1 = 0;
   si.pwszName = NULL;
   if( !m_Node.IsEmpty() )
      si.pwszName = T2OLE(m_Node.GetBuffer(0));
   si.pAuthInfo = NULL;
   si.dwReserved2 = 0;

   qi.pIID = &IID_IOPCServerList;
   qi.pItf = NULL;
   qi.hr = 0;

   HRESULT hr = CoCreateInstanceEx(CLSID_OPCServerList, NULL, CLSCTX_ALL, &si, 1, &qi);
   if (FAILED(hr) || FAILED(qi.hr))
   {
      CString msg(_T("Please install the OPC 2.0 Components."));
      if( !m_Node.IsEmpty() )
         msg.Format(_T("Please install the OPC 2.0 Components on %s."), (LPCTSTR)m_Node);
      AfxMessageBox(msg);
      CDialog::OnCancel();
      return;
   }
   pServers = (IOPCServerList*)qi.pItf;
   hr = pServers->CLSIDFromProgID(T2OLE(m_Server.GetBuffer(0)), &m_clsid);
   pServers->Release();
   if (FAILED(hr))
   {
      CString msg;
      msg.Format(_T("Error locating '%s'."), (LPCTSTR)m_Server);
      if( !m_Node.IsEmpty() )
         msg.Format(_T("Error locating '%s' on %s."), (LPCTSTR)m_Server, (LPCTSTR)m_Node);
      AfxMessageBox(msg);
      CDialog::OnCancel();
      return;
   }
   
}

void OPCServerDlg::OnServers10()
{
   UpdateData();
   m_catid = CATID_OPCDAServer10;
   GetOPCServers(m_Node.GetBuffer(0));
}

void OPCServerDlg::OnServers20()
{
   UpdateData();
   m_catid = CATID_OPCDAServer20;
   GetOPCServers(m_Node.GetBuffer(0));
}

void OPCServerDlg::OnCancel() 
{
	// TODO: Add extra cleanup here
	CDialog::OnCancel();
}


void OPCServerDlg::OnClose() 
{
	// TODO: Add your message handler code here and/or call default
	CDialog::OnClose();
}