/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1996-2002 Microsoft Corporation
//
//  Module Name:
//      CluAdmExDataObj.h
//
//  Implementation File:
//      CCluAdmExDataObject.cpp
//
//  Description:
//      Definition of the CCluAdmExDataObject class, which is the IDataObject
//      class used to transfer data between a cluster management tool and the
//      extension DLL handlers.
//
//  Author:
//      David Potter (davidp)   June 4, 1996
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef __CLUADMEXDATAOBJ_H_
#define __CLUADMEXDATAOBJ_H_

/////////////////////////////////////////////////////////////////////////////
//  Include Files
/////////////////////////////////////////////////////////////////////////////

#ifndef __cluadmex_h__
#include "CluAdmEx.h"           // for IIDs
#endif

#ifndef __cluadmexhostsvr_h__
#include "CluAdmExHostSvr.h"    // for CLSIDs
#endif

#ifndef __CLUSOBJ_H_
#include "ClusObj.h"            // for CClusterObject
#endif

/////////////////////////////////////////////////////////////////////////////
// Type Declarations
/////////////////////////////////////////////////////////////////////////////

typedef BOOL (*PFGETRESOURCENETWORKNAME)(
                    OUT BSTR lpszNetName,
                    IN OUT DWORD * pcchNetName,
                    IN OUT PVOID pvContext
                    );

/////////////////////////////////////////////////////////////////////////////
// Forward Class Declarations
/////////////////////////////////////////////////////////////////////////////

class CCluAdmExDataObject;

/////////////////////////////////////////////////////////////////////////////
// External Class Declarations
/////////////////////////////////////////////////////////////////////////////

class CClusterObject;

/////////////////////////////////////////////////////////////////////////////
//++
//
//  class CCluAdmExDataObject
//
//  Description:
//      Encapsulates the IDataObject interface for exchanging data with
//      extension DLL handlers.
//
//  Inheritance:
//      CCluAdmExDataObject
//      CComObjectRootEx<>, CComCoClass<>, <interface classes>
//
//--
/////////////////////////////////////////////////////////////////////////////
class CCluAdmExDataObject :
    public CComObjectRootEx< CComSingleThreadModel >,
    public CComCoClass< CCluAdmExDataObject, &CLSID_CoCluAdmExHostSvrData >,
    public ISupportErrorInfo,
    public IGetClusterUIInfo,
    public IGetClusterDataInfo,
    public IGetClusterObjectInfo,
    public IGetClusterNodeInfo,
    public IGetClusterGroupInfo,
    public IGetClusterResourceInfo,
    public IGetClusterNetworkInfo,
    public IGetClusterNetInterfaceInfo
{
public:
    //
    // Construction
    //

    // Default constructor
    CCluAdmExDataObject( void )
    {
        m_pco = NULL;
        m_lcid = NULL;
        m_hfont = NULL;
        m_hicon = NULL;

        m_pfGetResNetName = NULL;

//      m_pModuleState = AfxGetModuleState();
//      ATLASSERT( m_pModuleState != NULL );

    } //*** CCluAdmExDataObject()

    // Destructor
    virtual ~CCluAdmExDataObject( void )
    {
//      m_pModuleState = NULL;

    } //*** ~CCluAdmExDataObject()

    // Second-phase constructor.
    void Init(
        IN OUT CClusterObject * pco,
        IN LCID                 lcid,
        IN HFONT                hfont,
        IN HICON                hicon
        )
    {
        ATLASSERT( pco != NULL );
        ATLASSERT( pco->Pci() != NULL );
        ATLASSERT( pco->Pci()->Hcluster() != NULL );

        // Save parameters.
        m_pco = pco;
        m_lcid = lcid;
        m_hfont = hfont;
        m_hicon = hicon;

    } //*** Init()

    //
    // Map interfaces to this class.
    //
    BEGIN_COM_MAP( CCluAdmExDataObject )
        COM_INTERFACE_ENTRY( IGetClusterUIInfo )
        COM_INTERFACE_ENTRY( IGetClusterDataInfo )
        COM_INTERFACE_ENTRY( IGetClusterObjectInfo )
        COM_INTERFACE_ENTRY( IGetClusterNodeInfo )
        COM_INTERFACE_ENTRY( IGetClusterGroupInfo )
        COM_INTERFACE_ENTRY( IGetClusterResourceInfo )
        COM_INTERFACE_ENTRY( IGetClusterNetworkInfo )
        COM_INTERFACE_ENTRY( IGetClusterNetInterfaceInfo )
        COM_INTERFACE_ENTRY( ISupportErrorInfo )
    END_COM_MAP()

    DECLARE_NOT_AGGREGATABLE( CCluAdmExDataObject )

protected:
    //
    // Properties of this data object.
    //

    CClusterObject *    m_pco;          // Cluster object being extended.
    LCID                m_lcid;         // Locale ID of resources to be loaded by extension.
    HFONT               m_hfont;        // Font for all text.
    HICON               m_hicon;        // Icon for upper left corner.

    PFGETRESOURCENETWORKNAME    m_pfGetResNetName;          // Pointer to static function for getting net name for resource.
    PVOID                       m_pvGetResNetNameContext;   // Context for m_pfGetResNetName;

    static const IID * s_rgiid[];       // Array of interface IDs supported by this class.

    //
    // Accessor methods.
    //

    HCLUSTER Hcluster( void ) const
    {
        ATLASSERT( m_pco != NULL );
        ATLASSERT( m_pco->Pci() != NULL );

        return m_pco->Pci()->Hcluster();

    } //*** Hcluster()

    CClusterObject *    Pco( void ) const       { return m_pco; }
    LCID                Lcid( void ) const      { return m_lcid; }
    HFONT               Hfont( void ) const     { return m_hfont; }
    HICON               Hicon( void ) const     { return m_hicon; }

public:
    PFGETRESOURCENETWORKNAME PfGetResNetName( void ) const { return m_pfGetResNetName; }

    // Set the function pointer for getting the resource name
    void SetPfGetResNetName( PFGETRESOURCENETWORKNAME pfGetResNetName, PVOID pvContext )
    {
        m_pfGetResNetName = pfGetResNetName;
        m_pvGetResNetNameContext = pvContext;

    } //*** SetPfGetResNetName()

public:
    //
    // ISupportsErrorInfo methods.
    //

    // Determine if interface supports IErrorInfo
    STDMETHOD( InterfaceSupportsErrorInfo )( REFIID riid )
    {
        const IID ** piid;

        for ( piid = s_rgiid ; *piid != NULL ; piid++ )
        {
            if ( InlineIsEqualGUID( **piid, riid ) )
            {
                return S_OK;
            } // if:  matching IID found
        }
        return S_FALSE;

    } //*** InterfaceSupportsErrorInfo()

public:
    //
    // IGetClusterUIInfo methods.
    //

    // Get the locale of the running program
    STDMETHOD_( LCID, GetLocale )( void )
    {
        return Lcid();

    } //*** GetLocale()

    // Get the font to use for text on property pages
    STDMETHOD_( HFONT, GetFont )( void )
    {
        return Hfont();

    } //*** GetFont()

    // Get the icon to use for the upper left corner
    STDMETHOD_( HICON, GetIcon )( void )
    {
        return Hicon();

    } //*** GetIcon()

public:
    //
    // IGetClusterDataInfo methods.
    //

    // Get the name of the cluster
    STDMETHOD( GetClusterName )(
        OUT BSTR        lpszName,
        IN OUT LONG *   pcchName
        )
    {
        ATLASSERT( Pco() != NULL );
        ATLASSERT( Pco()->Pci() != NULL );

        HRESULT hr;

        //
        // Validate parameters.
        //
        if ( pcchName == NULL )
        {
            return E_INVALIDARG;
        }

        //
        // Copy the name to the caller's buffer.
        //
        hr = GetStringProperty(
                Pco()->Pci()->RstrName(),
                lpszName,
                pcchName
                );

        return hr;

    } //*** GetClusterName()

    // Get a handle to the cluster
    STDMETHOD_( HCLUSTER, GetClusterHandle )( void )
    {
        return Hcluster();

    } //*** GetClusterHandle()

    // Get the number of objects currently selected
    STDMETHOD_( LONG, GetObjectCount )( void )
    {
        //
        // We only support one selected object at a time for now.
        //
        return 1;

    } //*** GetObjectCount()

public:
    //
    // IGetClusterObjectInfo methods.
    //

    // Get the name of the object at the specified index
    STDMETHOD( GetObjectName )(
        IN LONG         nObjIndex,
        OUT BSTR        lpszName,
        IN OUT LONG *   pcchName
        )
    {
        ATLASSERT( Pco() != NULL );

        HRESULT hr;

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if ( (nObjIndex != 0) || (pcchName == NULL) )
        {
            return E_INVALIDARG;
        } // if:  wrong object index or no count buffer

        //
        // Copy the name to the caller's buffer.
        //
        hr = GetStringProperty(
                Pco()->RstrName(),
                lpszName,
                pcchName
                );

        return hr;

    } //*** GetObjectName()

    // Get the type of the object at the specified index
    STDMETHOD_( CLUADMEX_OBJECT_TYPE, GetObjectType )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if ( nObjIndex == 1 )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return (CLUADMEX_OBJECT_TYPE) -1;
        }  // if:  invalid argument

        return Pco()->Cot();

    } //*** GetObjectType()

public:
    //
    // IGetClusterNodeInfo methods.
    //

    // Get the handle to the node at the specified index
    STDMETHOD_( HNODE, GetNodeHandle )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if (   (nObjIndex == 1)
            || (Pco()->Cot() != CLUADMEX_OT_NODE) )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return NULL;
        }  // if:  invalid argument

        CClusNodeInfo * pni = reinterpret_cast< CClusNodeInfo * >( Pco() );
        return pni->Hnode();

    } //*** GetNodeHandle()

public:
    //
    // IGetClusterGroupInfo methods.
    //

    // Get the handle to the group at the specified index
    STDMETHOD_( HGROUP, GetGroupHandle )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if (   (nObjIndex == 1)
            || (Pco()->Cot() != CLUADMEX_OT_GROUP) )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return NULL;
        }  // if:  invalid argument

        CClusGroupInfo * pgi = reinterpret_cast< CClusGroupInfo * >( Pco() );
        return pgi->Hgroup();

    } //*** GetGroupHandle()

public:
    //
    // IGetClusterResourceInfo methods.
    //

    // Get the handle to the resource at the specified index
    STDMETHOD_( HRESOURCE, GetResourceHandle )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if (   (nObjIndex == 1)
            || (Pco()->Cot() != CLUADMEX_OT_RESOURCE) )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return NULL;
        }  // if:  invalid argument

        CClusResInfo * pri = reinterpret_cast< CClusResInfo * >( Pco() );
        return pri->Hresource();

    } //*** GetResourceHandle()

    // Get the type of the resource at the specified index
    STDMETHOD( GetResourceTypeName )(
        IN LONG         nObjIndex,
        OUT BSTR        lpszResourceTypeName,
        IN OUT LONG *   pcchResTypeName
        )
    {
        ATLASSERT( Pco() != NULL );

        HRESULT         hr;
        CClusResInfo *  pri = reinterpret_cast< CClusResInfo * >( Pco() );

        //
        // Validate parameters.
        // We only support one selected object at a time for now.
        //
        if (   (nObjIndex != 0)
            || (pcchResTypeName == NULL)
            || (Pco()->Cot() != CLUADMEX_OT_RESOURCE) )
        {
            return E_INVALIDARG;
        }  // if:  invalid argument

        //
        // Copy the name to the caller's buffer.
        //
        ATLASSERT( pri->Prti() != NULL );
        hr = GetStringProperty(
                pri->Prti()->RstrName(),
                lpszResourceTypeName,
                pcchResTypeName
                );

        return hr;

    } //*** GetResourceTypeName()

    // Get the network name for the resource at the specified index
    STDMETHOD_( BOOL, GetResourceNetworkName )(
        IN LONG         nObjIndex,
        OUT BSTR        lpszNetName,
        IN OUT ULONG *  pcchNetName
        )
    {
        ATLASSERT( Pco() != NULL );

        BOOL            bSuccess = FALSE;
        CClusResInfo *  pri = reinterpret_cast< CClusResInfo * >( Pco() );

        try
        {
            //
            // Validate parameters.
            // We only support one selected object at a time for now.
            //
            if (   (nObjIndex != 0)
                || (pcchNetName == NULL)
                || (*pcchNetName < MAX_COMPUTERNAME_LENGTH)
                || (Pco()->Cot() != CLUADMEX_OT_RESOURCE) )
            {
                SetLastError( (DWORD) E_INVALIDARG );
                return FALSE;
            }  // if:  invalid argument

            //
            // If there is a function for getting this information, call it.
            // Otherwise, handle it ourselves.
            //
            if ( PfGetResNetName() != NULL )
            {
                bSuccess = (*PfGetResNetName())( lpszNetName, pcchNetName, m_pvGetResNetNameContext );
            } // if:  function specified for getting this info
            else
            {
                bSuccess = pri->BGetNetworkName( lpszNetName, pcchNetName );
            } // if:  no function specified for getting this info
        } // try
        catch (...)
        {
            bSuccess = FALSE;
            SetLastError( (DWORD) E_INVALIDARG );
        }  // catch:  anything

        return bSuccess;

    } //*** GetResourceNetworkName()

public:
    //
    // IGetClusterNetworkInfo methods.
    //

    // Get the handle to the network at the specified index
    STDMETHOD_( HNETWORK, GetNetworkHandle )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        // Validate parameters.
        // We only support one selected object at a time for now.
        if (   (nObjIndex == 1)
            || (Pco()->Cot() != CLUADMEX_OT_NETWORK) )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return NULL;
        }  // if:  invalid argument

        CClusNetworkInfo * pni = reinterpret_cast< CClusNetworkInfo * >( Pco() );
        return pni->Hnetwork();

    } //*** GetNetworkHandle()

public:
    //
    // IGetClusterNetInterfaceInfo methods.
    //

    // Get the handle to the network interface at the specified index
    STDMETHOD_( HNETINTERFACE, GetNetInterfaceHandle )(
        IN LONG nObjIndex
        )
    {
        ATLASSERT( Pco() != NULL );

        // Validate parameters.
        // We only support one selected object at a time for now.
        if (   (nObjIndex == 1)
            || (Pco()->Cot() != CLUADMEX_OT_NETINTERFACE) )
        {
            SetLastError( (DWORD) E_INVALIDARG );
            return NULL;
        }  // if:  invalid argument

        CClusNetIFInfo * pnii = reinterpret_cast< CClusNetIFInfo * >( Pco() );
        return pnii->Hnetinterface();

    } //*** GetNetInterfaceHandle()

// Implementation
protected:
//  AFX_MODULE_STATE *          m_pModuleState;         // Required for resetting our state during callbacks.

    // Get a string property
    STDMETHOD( GetStringProperty )(
        IN const CString &  rstrNameSource,
        OUT BSTR            lpszName,
        IN OUT LONG *       pcchName
        )
    {
        ATLASSERT( pcchName != NULL );

        LONG    cchName = 0;
        HRESULT hr = S_OK;

        //
        // Save the length to copy.
        //
        try
        {
            cchName = *pcchName;
            *pcchName = rstrNameSource.GetLength() + 1;
        } // try
        catch (...)
        {
            hr = E_INVALIDARG;
            goto Cleanup;
        }  // catch:  anything

        //
        // If only the length is being requested, return it now.
        //
        if ( lpszName == NULL )
        {
            hr = S_OK;
            goto Cleanup;
        } // if:  no name buffer specified

        //
        // If a buffer is specified and it is too small, return an error.
        //
        if ( cchName < *pcchName )
        {
            hr = ERROR_MORE_DATA;
            goto Cleanup;
        } // if:  buffer too small

        //
        // Copy the data.
        //
        hr = StringCchCopyNW( lpszName, cchName, rstrNameSource, rstrNameSource.GetLength() );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:  error copying data

    Cleanup:

        return hr;

    } //*** GetStringProperty()

};  //*** class CCluAdmExDataObject

/////////////////////////////////////////////////////////////////////////////
// Class Data
/////////////////////////////////////////////////////////////////////////////
_declspec( selectany ) const IID * CCluAdmExDataObject::s_rgiid[] = 
{
    &IID_IGetClusterDataInfo,
    &IID_IGetClusterObjectInfo,
    &IID_IGetClusterNodeInfo,
    &IID_IGetClusterGroupInfo,
    &IID_IGetClusterResourceInfo,
    &IID_IGetClusterNetworkInfo,
    &IID_IGetClusterNetInterfaceInfo,
    NULL
};

/////////////////////////////////////////////////////////////////////////////

#endif // __CLUADMEXDATAOBJ_H_