staticnode.cpp

ftpserver very good sample

#include "StdAfx.h"
#include <Shlwapi.h>
#include <Shlobj.H>
#include "WarMmcSnapin.h"
#include "StaticNode.h"   // class implemented
#include "WarCollector.h"
#include "WmsNodeService.h"
#include "WarIfServer.h"

/////////////////////////////// PUBLIC ///////////////////////////////////////

//============================= LIFECYCLE ====================================

// {1BD645EF-4228-44aa-9AC5-DD3501D709C1}
const GUID CStaticNode::thisGuid = 
{ 0x1bd645ef, 0x4228, 0x44aa, { 0x9a, 0xc5, 0xdd, 0x35, 0x1, 0xd7, 0x9, 0xc1 } };


CStaticNode::CStaticNode() :
mIsInitialized(false)
{
}
 
CStaticNode::~CStaticNode()
{
}

//============================= OPERATORS ====================================
//============================= OPERATIONS ===================================

const _TCHAR *CStaticNode::GetDisplayName(int nCol) 
{   
    static _TCHAR szDisplayName[256] = {0};

    if (Initialize())
    {
        LoadString(g_hinst, 
            IDS_SNAPINNAME, 
            szDisplayName, 
            sizeof(szDisplayName));
        
        if (*snapInData.m_host != 0) {
            _tcscat(szDisplayName, _T(" ("));
            _tcscat(szDisplayName, snapInData.m_host);
            _tcscat(szDisplayName, _T(")"));
        }   
    }
    return szDisplayName; 
}

const GUID & CStaticNode::getNodeType() 
{ 
    return thisGuid; 
}

const int CStaticNode::GetBitmapIndex() 
{ 
    return NICON_WORKSTATION; 
}

bool CStaticNode::Initialize()
{
    if (mIsInitialized)
        return true;

    mIsInitialized = true;

    try
    {
        mWarRootPtr = new WarIfRoot;
        mWarRootPtr->Open(WAR_VENDOR, snapInData.m_fIsRadioLocalMachine ? NULL : snapInData.m_host);
    }
    catch(WarException)
    {
        return false;
    }


    return true;
}


//============================= CALLBACK    ===================================

HRESULT CStaticNode::OnExpand(IConsoleNameSpace *pConsoleNameSpace, IConsole *pConsole, HSCOPEITEM parent)
{   
    if (!Initialize())
        return E_UNEXPECTED;

    SCOPEDATAITEM sdi;
    
    if (GetHandle() == NULL) {
        SetHandle((HANDLE)parent);
    }

    if (!bExpanded) 
    {
        // create the child nodes, then expand them
        WarIfRoot::strlist_t my_svrlist;

        try
        {
            mWarRootPtr->EnumServers(my_svrlist);
        }
        catch(WarException& e)
        {
            WarCollector<TCHAR> err_msg;

            err_msg << "Error enumerating services.\r\n"
                << e
                << war_endl;

            ::MessageBox(NULL, err_msg.GetValue().c_str(), 
                _T("Error"), 
                MB_OK | MB_ICONSTOP);  
            return E_UNEXPECTED;
        }

        for (WarIfRoot::strlist_t::const_iterator P = my_svrlist.begin()
            ; P != my_svrlist.end()
            ; ++P)
        {
            war_if_server_ptr_t new_svr_ptr;
            WmsNodeService *pnew_node = NULL;

            try
            {
                new_svr_ptr = mWarRootPtr->GetServer(P->c_str());
                pnew_node = new WmsNodeService(new_svr_ptr);
            }
            catch(WarException& ex)
            {
                WarCollector<TCHAR> err_msg;
                
                err_msg << "Error opening service ("
                    << P->c_str()
                    << "). \r\n"
                    << ex
                    << war_endl;
                
                ::MessageBox(NULL, err_msg.GetValue().c_str(), 
                    _T("Error"), 
                    MB_OK | MB_ICONWARNING);
                continue;
            }

            ZeroMemory(&sdi, sizeof(SCOPEDATAITEM));
            sdi.mask = SDI_STR|   // Displayname is valid
                SDI_PARAM     |   // lParam is valid
                SDI_IMAGE     |   // nImage is valid
                SDI_OPENIMAGE |   // nOpenImage is valid
                SDI_PARENT;
            
            sdi.relativeID  = (HSCOPEITEM)parent;
            sdi.nImage      = pnew_node->GetBitmapIndex();
            sdi.nOpenImage  = pnew_node->GetBitmapIndex();
            sdi.displayname = MMC_CALLBACK;
            sdi.lParam      = (LPARAM)pnew_node;     // The cookie
            
            HRESULT hr = pConsoleNameSpace->InsertItem(&sdi);
            _ASSERT( SUCCEEDED(hr) );
            
            pnew_node->SetHandle((HANDLE)sdi.ID);
        }
    }
    
    return S_OK;
}

//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================
/////////////////////////////// PROTECTED  ///////////////////////////////////

/////////////////////////////// PRIVATE    ///////////////////////////////////

BOOL CALLBACK CStaticNode::DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    static privateData *pData = NULL;
    static HWND m_hwndCheckboxOverride;
    
    switch (uMsg)
    {
    case WM_INITDIALOG:
        pData = reinterpret_cast<privateData *>(reinterpret_cast<PROPSHEETPAGE *>(lParam)->lParam);
        
        SendDlgItemMessage(hwndDlg, IDC_CHOOSER_RADIO_LOCAL_MACHINE, BM_SETCHECK, pData->m_fIsRadioLocalMachine, 0L);
        SendDlgItemMessage(hwndDlg, IDC_CHOOSER_RADIO_SPECIFIC_MACHINE, BM_SETCHECK, !pData->m_fIsRadioLocalMachine, 0L);
        
        EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_EDIT_MACHINE_NAME), !pData->m_fIsRadioLocalMachine);
        EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_BUTTON_BROWSE_MACHINENAMES), !pData->m_fIsRadioLocalMachine);
        
        m_hwndCheckboxOverride = ::GetDlgItem(hwndDlg, IDC_CHOOSER_CHECK_OVERRIDE_MACHINE_NAME);
        
        // fill in the supplied machine name (could be us, need to check here first)
        if (*pData->m_host != '\0') 
        {
            ::SetWindowText(GetDlgItem(hwndDlg, IDC_CHOOSER_EDIT_MACHINE_NAME), pData->m_host);
            ::SendMessage(GetDlgItem(hwndDlg, IDC_CHOOSER_RADIO_SPECIFIC_MACHINE), BM_CLICK, 0, 0);
        }
        
        
        return TRUE;
        
    case WM_COMMAND:
        switch (wParam) 
        {
        case IDC_CHOOSER_RADIO_LOCAL_MACHINE:
            pData->m_fIsRadioLocalMachine = TRUE;
            EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_EDIT_MACHINE_NAME), FALSE);
            EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_BUTTON_BROWSE_MACHINENAMES), FALSE);
            break;
            
        case IDC_CHOOSER_RADIO_SPECIFIC_MACHINE:
            pData->m_fIsRadioLocalMachine = FALSE;
            EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_EDIT_MACHINE_NAME), TRUE);
            EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSER_BUTTON_BROWSE_MACHINENAMES), TRUE);
            break;
            
        case IDC_CHOOSER_BUTTON_BROWSE_MACHINENAMES:
            {
                // Fall back to IE-style browser
                BROWSEINFO bi;
                LPITEMIDLIST lpItemIdList;
                LPMALLOC lpMalloc;
                
                if (SUCCEEDED(SHGetSpecialFolderLocation(hwndDlg, CSIDL_NETWORK, &lpItemIdList)))
                {
                    _TCHAR szBrowserCaption[MAX_PATH];
                    LoadString(g_hinst, IDS_COMPUTER_BROWSER_CAPTION, szBrowserCaption, sizeof(szBrowserCaption));
                    
                    bi.hwndOwner = hwndDlg; 
                    bi.pidlRoot = lpItemIdList; 
                    bi.pszDisplayName = pData->m_host; 
                    bi.lpszTitle = szBrowserCaption; 
                    bi.ulFlags = BIF_BROWSEFORCOMPUTER | BIF_EDITBOX; 
                    bi.lpfn = NULL; 
                    bi.lParam = NULL; 
                    bi.iImage = NULL; 
                    
                    if (SHBrowseForFolder(&bi) != NULL) 
                    {
                        if (*pData->m_host != '\0') 
                        {
                            ::SetWindowText(GetDlgItem(hwndDlg, 
                                IDC_CHOOSER_EDIT_MACHINE_NAME), pData->m_host);
                        }
                    }
                    
                    if (SUCCEEDED(SHGetMalloc(&lpMalloc))) 
                    {
                        lpMalloc->Free(lpItemIdList);
                        lpMalloc->Release();
                    }
                }
            }
            break;
            
        case IDC_CHOOSER_CHECK_OVERRIDE_MACHINE_NAME:
            break;
        }
        break;
        
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code) {
            case PSN_SETACTIVE: 
                PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_FINISH);
                break;
                
            case PSN_WIZFINISH: 
                if (pData->m_fIsRadioLocalMachine) {
                    // Return empty string to caller
                    *pData->m_host = '\0';
                } else {
                    // Get the machine name from the edit window
                    GetWindowText(GetDlgItem(hwndDlg, IDC_CHOOSER_EDIT_MACHINE_NAME), 
                        pData->m_host, sizeof(pData->m_host));
                }
                
                // Save the override flag if the caller asked for it
                pData->m_fAllowOverrideMachineNameOut = 
                    SendMessage(m_hwndCheckboxOverride, BM_GETCHECK, 0, 0) == BST_CHECKED ? TRUE : FALSE;
                
                break;
            }
            
            break;
    }
    
    return FALSE;
}