workspaceinfo.cpp

一个统计文件大小和程序信息的插件程序(vc或vc.net下使用)

/***************************************************************************/
/* NOTE:                                                                   */
/* This document is copyright (c) by Oz Solomonovich, and is bound by the  */
/* MIT open source license (www.opensource.org/licenses/mit-license.html). */
/* See License.txt for more information.                                   */
/***************************************************************************/

#include "stdafx.h"
#include "WorkspaceInfo.h"

#include "ExtrnSrc\WWhizInterface2.h"
#include "ExtrnSrc\WWhizInterface2Loader.h"

IWorkspaceInfo *g_pWorkspaceInfo = NULL;

class Auto_Destruct_WorkspaceInfo
{
public:
    ~Auto_Destruct_WorkspaceInfo()
    {
        delete g_pWorkspaceInfo;
        g_pWorkspaceInfo = NULL;
    }
} auto_var;


#ifdef TARGET_VC6

class CProjectFile_VC6 : public IProjectFile
{
protected:
    WWhizFile *m_pFile;

public:
    CProjectFile_VC6(WWhizFile *pFile) : m_pFile(pFile)
    {
        ASSERT(pFile != NULL);
    }

    virtual ~CProjectFile_VC6() {};

    virtual CString GetPath() const
    {
        return (LPCTSTR)m_pFile->GetFullName();
    }

    virtual CString GetExt() const
    {
        return (LPCTSTR)m_pFile->GetExt();
    }
};

class CWorkspaceProject_VC6 : public IWorkspaceProject
{
protected:
    WWhizProject *m_pPrj;

public:
    CWorkspaceProject_VC6(WWhizProject *pPrj) : m_pPrj(pPrj)
    {
        ASSERT(pPrj != NULL);
    }

    virtual ~CWorkspaceProject_VC6() {}

    virtual CString GetName() const
    {
        return (LPCTSTR)m_pPrj->GetName();
    }

    virtual int GetFileCount() const
    {
        return m_pPrj->GetFileList().GetCount();
    }

    virtual IProjectFile *GetFile(int iIndex) const
    {
        return new CProjectFile_VC6(m_pPrj->GetFileList().Get(iIndex));
    }
};


class CWorkspaceInfo_VC6 : public IWorkspaceInfo
{
protected:
    WWhizInterface *m_pWWI;

    enum 
    { 
        FILTER_NDX_WORKSPACE = 0,
        FILTER_NDX_ACTIVEPRJ = 1 
    };

public:
    CWorkspaceInfo_VC6(IApplication *pApplication)
    {
        m_pWWI = WWhizInterface2Create(AfxGetInstanceHandle(), 
            pApplication);
        if (!m_pWWI) throw "Could not load WWhiz";
    }

    virtual ~CWorkspaceInfo_VC6() 
    {
        WWhizInterface2Destroy();    
    };

    virtual void Refresh()
    {
        m_pWWI->RefreshFileList();
    }

    virtual CString GetWorkspaceName() const
    {
        return (LPCTSTR)m_pWWI->GetWorkspaceName();
    }

    virtual int GetProjectCount() const
    {
        return m_pWWI->GetProjectList().GetProjectCount();
    }

    virtual IWorkspaceProject *GetProject(int iIndex) const 
    {
        ASSERT(iIndex >= 0);
        ASSERT(iIndex < GetProjectCount());
        return new CWorkspaceProject_VC6(
            m_pWWI->GetProjectList().GetProjectByIndex(iIndex));
    }


    virtual int GetWorkspaceFilterCount() const
    {
        return 2;
    }

    virtual LPCTSTR GetWorkspaceFilterName(int iFilterIndex) const
    {
        switch (iFilterIndex)
        {
            case FILTER_NDX_WORKSPACE:
                return "Workspace";
                
            case FILTER_NDX_ACTIVEPRJ:
                return "Active Project";

            default:
                ASSERT(0);
        }
        return "";
    }

    virtual int GetWorkspaceFilterProjectCount(int iFilterIndex) const
    {
        switch (iFilterIndex)
        {
            case FILTER_NDX_WORKSPACE:
                return GetProjectCount();
                
            case FILTER_NDX_ACTIVEPRJ:
                return 1;

            default:
                ASSERT(0);
        }
        return 0;
    }

    virtual IWorkspaceProject *GetWorkspaceFilterProject(int iFilterIndex,
        int iProjectIndex) const
    {
        switch (iFilterIndex)
        {
            case FILTER_NDX_WORKSPACE:
                return GetProject(iProjectIndex);
                
            case FILTER_NDX_ACTIVEPRJ:
            {
                WWhizProject *pWWPrj = m_pWWI->GetCurrentProject();
                if (!pWWPrj) return NULL;
                return new CWorkspaceProject_VC6(pWWPrj);
            }

            default:
                ASSERT(0);
        }
        return NULL;
    }
};

void InitializeWorkspaceInfo_VC6(IApplication *pApplication)
{
    ASSERT(g_pWorkspaceInfo == NULL);
    ASSERT(pApplication != NULL);
    try
    {
        g_pWorkspaceInfo = new CWorkspaceInfo_VC6(pApplication);
    }
    catch (...)
    {
    }
}

#endif // TARGET_VC6


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

#ifdef TARGET_VC7

class CProjectFile_VC7 : public IProjectFile
{
protected:
    CString m_strPath;

public:
    CProjectFile_VC7(const CString& strPath) : m_strPath(strPath)
    {
    }

    virtual ~CProjectFile_VC7() {};

    virtual CString GetPath() const
    {
        return m_strPath;
    }

    virtual CString GetExt() const
    {
        CString sPath = m_strPath;
        int dotPos = sPath.ReverseFind('.');
        ASSERT(dotPos >= 0);
        sPath.Delete(0, dotPos + 1);
        return sPath;
    }
};

class CWorkspaceProject_VC7 : public IWorkspaceProject
{
protected:
    typedef CComPtr<EnvDTE::Project>      DTEProject;
    typedef CComPtr<EnvDTE::ProjectItem>  DTEProjectItem;
    typedef CComPtr<EnvDTE::ProjectItems> DTEProjectItems;
    DTEProject m_pPrj;
    CStringArray m_Files;

public:
    CWorkspaceProject_VC7(DTEProject pPrj) : m_pPrj(pPrj)
    {
        ASSERT(pPrj != NULL);

        DTEProjectItems pItems;
        if (SUCCEEDED(pPrj->get_ProjectItems(&pItems)))
        {
            RecurseAddProjectFiles(pItems);
        }
    }

    virtual ~CWorkspaceProject_VC7()
    {
    }

    void RecurseAddProjectFiles(DTEProjectItems& pItems) 
    {
        if (pItems == NULL) return;

        LONG cItems;
        if (SUCCEEDED(pItems->get_Count(&cItems)))
        {
            for (int i = 1; i <= cItems; ++i)
            {
                DTEProjectItem pItem;
                if (SUCCEEDED(pItems->Item(CComVariant(i), &pItem)))
                {
                    // make sure this item is rooted at this level
                    DTEProjectItems pCollection;
                    if (!SUCCEEDED(pItem->get_Collection(&pCollection))  ||
                        pCollection != pItems)
                    {
                        continue;
                    }

                    if (IsAFile(pItem))
                    {
                        CComBSTR bStr;
                        if (SUCCEEDED(pItem->get_FileNames(1, &bStr)))
                        {
                            m_Files.Add(CString(bStr));
                        }
                    }

                    DTEProjectItems pSubItems;
                    if (SUCCEEDED(pItem->get_ProjectItems(&pSubItems))  &&
                        pSubItems != NULL)
                    {
                        RecurseAddProjectFiles(pSubItems);
                    }
                }
            }
        }