warsvrsnapin.h

ftpserver very good sample

#ifndef __WARSVRSNAPIN_H_
#define __WARSVRSNAPIN_H_
#include "resource.h"
#include <atlsnap.h>
#include "WarWin32Registry.h"
#include "WarMmcFileTypes.h"

#ifndef WAR_MMC_MISSING_FEATURES_IN_LAME_FRAMEWORK_H
#   include "WarMmcMissingFeaturesInLameFramework.h"
#endif


enum WarImageListIconsE
{
    WAR_IL_SERVERS,
    WAR_IL_SERVICES,
    WAR_IL_LOCK,
    WAR_IL_WINDOWS,
    WAR_IL_USER,
    WAR_IL_WIN_USER,
    WAR_IL_SHARED_FOLDER,
    WAR_IL_SHARED_FOLDER_OPEN,
    WAR_IL_INVALID
};

class CWarSvrStaticNode : public CSnapInItemImpl<CWarSvrStaticNode>
{
public:
	static const GUID* m_NODETYPE;
	static const OLECHAR* m_SZNODETYPE;
	static const OLECHAR* m_SZDISPLAY_NAME;
	static const CLSID* m_SNAPIN_CLASSID;

	CComPtr<IControlbar> m_spControlBar;

	BEGIN_SNAPINCOMMAND_MAP(CWarSvrStaticNode, FALSE)
	END_SNAPINCOMMAND_MAP()

	SNAPINMENUID(IDR_WARSVRSNAPIN_MENU)

	BEGIN_SNAPINTOOLBARID_MAP(CWarSvrStaticNode)
		// Create toolbar resources with button dimensions 16x16 
		// and add an entry to the MAP. You can add multiple toolbars
		// SNAPINTOOLBARID_ENTRY(Toolbar ID)
	END_SNAPINTOOLBARID_MAP()

	CWarSvrStaticNode()
	{
		// Image indexes may need to be modified depending on the images specific to 
		// the snapin.
		memset(&m_scopeDataItem, 0, sizeof(SCOPEDATAITEM));
		m_scopeDataItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_PARAM;
		m_scopeDataItem.displayname = MMC_CALLBACK;
		m_scopeDataItem.nImage = WAR_IL_SERVICES;
		m_scopeDataItem.nOpenImage = WAR_IL_SERVICES;
		m_scopeDataItem.lParam = (LPARAM) this;
		memset(&m_resultDataItem, 0, sizeof(RESULTDATAITEM));
		m_resultDataItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
		m_resultDataItem.str = MMC_CALLBACK;
		m_resultDataItem.nImage = WAR_IL_SERVICES;		// May need modification
		m_resultDataItem.lParam = (LPARAM) this; 

        TCHAR szBuf[256];
		if (::LoadString(_Module.GetResourceInstance(), 
            IDS_STATIC_NODE, szBuf, 256) != 0)
        {
            m_bstrDisplayName = szBuf;
        }
        
        try
        {
            mRegRoot.Open(HKEY_LOCAL_MACHINE, 
                WarWin32Registry::mRootPath,
                KEY_ALL_ACCESS);
        }
        catch(WarException)
        {
           ;
        }

	}

	~CWarSvrStaticNode()
	{
	}

	STDMETHOD(QueryPagesFor)(DATA_OBJECT_TYPES type)
	{
		if (type == CCT_SCOPE || type == CCT_RESULT)
			return S_OK;
		return S_FALSE;
	}

	STDMETHOD(GetScopePaneInfo)(SCOPEDATAITEM *pScopeDataItem);

	STDMETHOD(GetResultPaneInfo)(RESULTDATAITEM *pResultDataItem);

	STDMETHOD(Notify)( MMC_NOTIFY_TYPE event,
		long arg,
		long param,
		IComponentData* pComponentData,
		IComponent* pComponent,
		DATA_OBJECT_TYPES type);

	LPOLESTR GetResultPaneColInfo(int nCol);

    WarWin32Registry mRegRoot;
};

class CWarSvrSnapin;

class CWarSvrSnapinComponent : public CComObjectRootEx<CComSingleThreadModel>,
	public CSnapInObjectRoot<2, CWarSvrSnapin >,
	public IExtendPropertySheetImpl<CWarSvrSnapinComponent>,
	public IExtendContextMenuImpl<CWarSvrSnapinComponent>,
	public IExtendControlbarImpl<CWarSvrSnapinComponent>,
	public IPersistStreamInit,
	public IComponentImpl<CWarSvrSnapinComponent>
{
public:
BEGIN_COM_MAP(CWarSvrSnapinComponent)
	COM_INTERFACE_ENTRY(IComponent)
    COM_INTERFACE_ENTRY(IExtendPropertySheet)
    COM_INTERFACE_ENTRY(IExtendContextMenu)
    COM_INTERFACE_ENTRY(IExtendControlbar)
	COM_INTERFACE_ENTRY(IPersistStreamInit)
END_COM_MAP()

public:
	CWarSvrSnapinComponent()
	{
	}

	STDMETHOD(Notify)(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, long arg, long param)
	{
		if (lpDataObject != NULL)
			return IComponentImpl<CWarSvrSnapinComponent>::Notify(lpDataObject, event, arg, param);
		// TODO : Add code to handle notifications that set lpDataObject == NULL.
		return E_NOTIMPL;
	}

	STDMETHOD(GetClassID)(CLSID *pClassID)
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapinComponent::GetClassID"));
	}	

	STDMETHOD(IsDirty)()
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapinComponent::IsDirty"));
	}

	STDMETHOD(Load)(IStream *pStm)
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapinComponent::Load"));
	}

	STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty)
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapinComponent::Save"));
	}

	STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize)
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapinComponent::GetSizeMax"));
	}

	STDMETHOD(InitNew)()
	{
		ATLTRACE(_T("CWarSvrSnapinComponent::InitNew\n"));
		return S_OK;
	}


};

class CWarSvrSnapin : public CComObjectRootEx<CComSingleThreadModel>,
public CSnapInObjectRoot<1, CWarSvrSnapin>,
	public IComponentDataImpl<CWarSvrSnapin, CWarSvrSnapinComponent>,
	public IExtendPropertySheetImpl<CWarSvrSnapin>,
	public IExtendContextMenuImpl<CWarSvrSnapin>,
	public IPersistStreamInit,
	public CComCoClass<CWarSvrSnapin, &CLSID_WarSvrSnapin>
{
public:
	CWarSvrSnapin()
        : mbIsDirty(false)
	{
		m_pNode = new CWarSvrStaticNode;
		_ASSERTE(m_pNode != NULL);
		m_pComponentData = this;
	}

	~CWarSvrSnapin()
	{
		delete m_pNode;
		m_pNode = NULL;
	}

BEGIN_COM_MAP(CWarSvrSnapin)
	  COM_INTERFACE_ENTRY(IComponentData)
    COM_INTERFACE_ENTRY(IExtendPropertySheet)
    COM_INTERFACE_ENTRY(IExtendContextMenu)
	COM_INTERFACE_ENTRY(IPersistStreamInit)
END_COM_MAP()

//DECLARE_REGISTRY_RESOURCEID(IDR_WARSVRSNAPIN)
DECLARE_REGISTRY_RESOURCEID(IDR_WARSVRSNAPIN) 

DECLARE_NOT_AGGREGATABLE(CWarSvrSnapin)

	STDMETHOD(GetClassID)(CLSID *pClassID)
	{
		ATLTRACENOTIMPL(_T("CWarSvrSnapin::GetClassID"));
	}	

	STDMETHOD(IsDirty)()
	{
        return mbIsDirty ? S_OK : S_FALSE;
	}

	STDMETHOD(Load)(IStream *pStm)
	{
		return S_OK; 
	}

	STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty)
	{
        if (fClearDirty)
            mbIsDirty = false;
		return S_OK; 
	}

	STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize)
	{
        pcbSize->QuadPart = 0;
		return S_OK; 
	}

	STDMETHOD(InitNew)()
	{
		return S_OK;
	}

	STDMETHOD(Initialize)(LPUNKNOWN pUnknown);

    static HRESULT LoadImages(IImageList*);

	static void WINAPI ObjectMain(bool bStarting)
	{
		if (bStarting)
			CSnapInItem::Init();
	}

    STDMETHOD(Notify)(LPDATAOBJECT lpDataObject,MMC_NOTIFY_TYPE event,long arg,long param)
	{
		HRESULT hr = S_FALSE;
		if(lpDataObject != NULL)
		{
			hr= IComponentDataImpl<CWarSvrSnapin, CWarSvrSnapinComponent>::Notify(lpDataObject,event,arg,param);
		}
		else
		{
            
			if(event == MMCN_PROPERTY_CHANGE)
            {
                WarMmcFuckLameMicrosoftForNotImplementingThis *p = 
                    (WarMmcFuckLameMicrosoftForNotImplementingThis *)param;
                hr = p->OnMmcNotifyChange();

                m_spConsole->UpdateAllViews(NULL, MMCN_PROPERTY_CHANGE, param);
			}
		}
		return hr;
	}


private:
    bool mbIsDirty;
};

class ATL_NO_VTABLE CWarSvrSnapinAbout : public ISnapinAbout,
	public CComObjectRoot,
	public CComCoClass< CWarSvrSnapinAbout, &CLSID_WarSvrSnapinAbout>
{
public:
	DECLARE_REGISTRY(CWarSvrSnapinAbout, _T("WarSvrSnapinAbout.1"), _T("WarSvrSnapinAbout.1"), IDS_WARSVRSNAPIN_DESC, THREADFLAGS_BOTH);

	BEGIN_COM_MAP(CWarSvrSnapinAbout)
		COM_INTERFACE_ENTRY(ISnapinAbout)
	END_COM_MAP()

	STDMETHOD(GetSnapinDescription)(LPOLESTR *lpDescription)
	{
		USES_CONVERSION;
		TCHAR szBuf[256];
		if (::LoadString(_Module.GetResourceInstance(), IDS_WARSVRSNAPIN_DESC, szBuf, 256) == 0)
			return E_FAIL;

		*lpDescription = (LPOLESTR)CoTaskMemAlloc((lstrlen(szBuf) + 1) * sizeof(OLECHAR));
		if (*lpDescription == NULL)
			return E_OUTOFMEMORY;

		ocscpy(*lpDescription, T2OLE(szBuf));

		return S_OK;
	}

	STDMETHOD(GetProvider)(LPOLESTR *lpName)
	{
		USES_CONVERSION;
		TCHAR szBuf[256];
		if (::LoadString(_Module.GetResourceInstance(), IDS_WARSVRSNAPIN_PROVIDER, szBuf, 256) == 0)
			return E_FAIL;

		*lpName = (LPOLESTR)CoTaskMemAlloc((lstrlen(szBuf) + 1) * sizeof(OLECHAR));
		if (*lpName == NULL)
			return E_OUTOFMEMORY;

		ocscpy(*lpName, T2OLE(szBuf));

		return S_OK;
	}

	STDMETHOD(GetSnapinVersion)(LPOLESTR *lpVersion)
	{
		USES_CONVERSION;
		TCHAR szBuf[256];
		if (::LoadString(_Module.GetResourceInstance(), IDS_WARSVRSNAPIN_VERSION, szBuf, 256) == 0)
			return E_FAIL;

		*lpVersion = (LPOLESTR)CoTaskMemAlloc((lstrlen(szBuf) + 1) * sizeof(OLECHAR));
		if (*lpVersion == NULL)
			return E_OUTOFMEMORY;

		ocscpy(*lpVersion, T2OLE(szBuf));

		return S_OK;
	}

    STDMETHOD(GetSnapinImage)(HICON *hAppIcon)
    {
        if (NULL == hAppIcon)
            return E_POINTER;
        *hAppIcon = static_cast<HICON>(
            ::LoadImage(_Module.GetResourceInstance(),
            MAKEINTRESOURCE(IDI_WARSVR),
            IMAGE_ICON, 0, 0,
            LR_DEFAULTCOLOR));
        return S_OK;
    }

	STDMETHOD(GetStaticFolderImage)(HBITMAP *hSmallImage,
		HBITMAP *hSmallImageOpen,
		HBITMAP *hLargeImage,
		COLORREF *cMask)
	{
        *hSmallImage = LoadBitmap(_Module.GetResourceInstance(),
            MAKEINTRESOURCE(IDB_WARSVR_16));
        *hSmallImageOpen = LoadBitmap(_Module.GetResourceInstance(),
            MAKEINTRESOURCE(IDB_WARSVR_16));
        *hLargeImage = LoadBitmap(_Module.GetResourceInstance(),
            MAKEINTRESOURCE(IDB_WARSVRT_32));
        return S_OK;
    }
};

#endif