工具管理操作类介绍

操作类CToolBoxCtr是被主对话框调用的。所有的底层操作都是由CToolBoxCtr实现的。

功能：

     1、单例模式

    2、添加工具信息

    3、删除工具信息

    4、获取添加工具的图标信息。

    5、启动添加的工具

    6、初始化的时候，从配置文件读取上次添加的工具信息

    7、退出的时候，更新工具信息到配置文件里。

#include "StdAfx.h"
#include "ToolBoxCtr.h"

// 单例模式
CToolBoxCtr * CToolBoxCtr::m_pInstance = NULL;

CToolBoxCtr::CToolBoxCtr(void)
{
    m_toolFileInfoArray.RemoveAll();

    m_strWorkDir = GetCurrentFolder();

    m_strConfigFile.Format(_T("%s\\%s"), m_strWorkDir, TOOLBOXFILE);

    m_imageList.Create(32, 32, ILC_COLOR32, 0, 5);
    m_imageList.SetBkColor(DLG_BKCOLOR);
    ReadConfigFile();
}

CToolBoxCtr::~CToolBoxCtr(void)
{
    SaveConfigFile();
    ClearToolFileInfoArray();
}

CToolBoxCtr * CToolBoxCtr::GetInstance()
{
    if (NULL == m_pInstance)
    {
        m_pInstance = new CToolBoxCtr();
    }

    return m_pInstance;
}

void CToolBoxCtr::Destroy()
{
    if (NULL != m_pInstance)
    {
        delete m_pInstance;
        m_pInstance = NULL;
    }
}

void CToolBoxCtr::ClearToolFileInfoArray()
{
    for (int i = 0; i < m_toolFileInfoArray.GetCount(); i++)
    {
        delete m_toolFileInfoArray[i];
        m_toolFileInfoArray[i] = NULL;
    }

    m_toolFileInfoArray.RemoveAll();
}

// 读取工具信息
void CToolBoxCtr::ReadConfigFile()
{
    CStdioFile file;

    // 以只读模式打开
    if (!file.Open(m_strConfigFile, CFile::modeRead))
    {
         return;
    }

    CToolFileInfo * pToolFileInfo = NULL;
    CString strLine;

    while (file.ReadString(strLine))
    {
        strLine = strLine.Trim();

        // 注释，跳过
        if (strLine.IsEmpty()
            || 0 == strLine.Left(1).Compare(Comment_Flag))
        {
            continue;
        }
        else if (0 == strLine.Left(1).Compare(ToolInfoLeft_Flag)
               && 0 == strLine.Right(1).Compare(ToolInfoRight_Flag))
        {
            if (NULL != pToolFileInfo)
            {
                m_toolFileInfoArray.Add(pToolFileInfo);
            }
            pToolFileInfo = new CToolFileInfo();
        }
        else if (NULL != pToolFileInfo)
        {
            int index = strLine.Find(_T("="));

            if (Not_Find != index)
            {
                CString strLeft = strLine.Left(index).Trim();
                CString strRight = strLine.Mid(index + 1).Trim();

                if (strLeft.IsEmpty())
                {
                    continue;
                }

                if (0 == strLeft.CompareNoCase(ToolInfoName))
                {
                    pToolFileInfo->SetToolName(strRight);
                }
                else if (0 == strLeft.CompareNoCase(ToolInfoPath))
                {
                    if (strRight.IsEmpty() || !PathFileExists(strRight))
                    {
                        delete pToolFileInfo;
                        pToolFileInfo = NULL;
                        continue;
                    }
                    pToolFileInfo->SetToolPath(strRight);
                    GetFileIconFromPath(pToolFileInfo);
                }
            }
        }
    }

    if (NULL != pToolFileInfo)
    {
        m_toolFileInfoArray.Add(pToolFileInfo);
    }

    file.Close();
}

void CToolBoxCtr::SaveConfigFile()
{
    CStdioFile file;
    if (!file.Open(m_strConfigFile, CFile::modeCreate | CFile::modeReadWrite))
    {
        return;
    }

    CString strLine;

    for (int i = 0; i < m_toolFileInfoArray.GetCount(); i++)
    {
        strLine.Format(_T("[ToolInfo%d]\r\n"), i + 1);
        file.WriteString(strLine);

        strLine.Format(_T("ToolName = %s\r\n"), m_toolFileInfoArray[i]->GetToolName());
        file.WriteString(strLine);

        strLine.Format(_T("ToolPath = %s\r\n\r\n"), m_toolFileInfoArray[i]->GetToolPath());
        file.WriteString(strLine);
    }

    file.Close();
}

CString CToolBoxCtr::GetCurrentFolder()
{
    char szPath[_MAX_PATH] = {0};
    GetModuleFileName(NULL, szPath, sizeof(szPath));

    char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
    _splitpath_s(szPath, drive, dir, fname, ext);

    CString strPath;
    strPath.Format(_T("%s\\%s"), drive, dir);

    return strPath;
}

void CToolBoxCtr::GetFileIconFromPath(CToolFileInfo * pFileInfo)
{
    if (NULL == pFileInfo)
    {
        return;
    }

    CString strPath = pFileInfo->GetToolPath();
    if (strPath.IsEmpty() || !PathFileExists(strPath))
    {
        return;
    }

    SHFILEINFO stFileInfo;
    :: SHGetFileInfo( strPath, 0, &stFileInfo, sizeof(stFileInfo), 
                     SHGFI_ICON | SHGFI_LARGEICON | SHGFI_TYPENAME);
    m_imageList.Add(stFileInfo.hIcon);

    if (IsExeType(stFileInfo.szTypeName))
    {
        pFileInfo->SetToolType(TToolType_Exe_Yes);
    }
    else
    {
        pFileInfo->SetToolType(TToolType_Exe_No);
    }

}

BOOL CToolBoxCtr::IsExeType(CString strTypeName)
{
    char szType[][20] = {_T("应用程序"), _T("Windows 批处理文件")};

    for (int i = 0; i < sizeof(szType)/sizeof(szType[0]); i++)
    {
        if (0 == strTypeName.CompareNoCase(szType[i]))
        {
            return TRUE;
        }
    }
    return FALSE;
}

void CToolBoxCtr::AddNewTool(CString strToolName, CString strToolPath)
{
    if (strToolName.IsEmpty() 
        || strToolPath.IsEmpty()
        || !PathFileExists(strToolPath))
    {
        return;
    }

    CToolFileInfo * PToolInfo = new CToolFileInfo;
    PToolInfo->SetToolName(strToolName);
    PToolInfo->SetToolPath(strToolPath);
    GetFileIconFromPath(PToolInfo);

    m_toolFileInfoArray.Add(PToolInfo);
}

CString CToolBoxCtr::GetToolNameFromPath(CString strPath)
{
    char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
    _splitpath_s(strPath, drive, dir, fname, ext);

    return fname;
}

void CToolBoxCtr::RemoveTool(int nItem)
{
    if (0 > nItem || nItem > m_toolFileInfoArray.GetCount()-1)
    {
        return;
    }
    delete m_toolFileInfoArray[nItem];
    m_toolFileInfoArray[nItem] = NULL;
    m_toolFileInfoArray.RemoveAt(nItem);
    m_imageList.Remove(nItem);
}

int CToolBoxCtr::RunToolFile(int index)
{
    if (0 > index || index > m_toolFileInfoArray.GetCount()-1)
    {
        return RetCode_ExeRunFailed;
    }

    CToolFileInfo *pFileInfo = m_toolFileInfoArray[index];

    if (NULL == pFileInfo)
    {
        return RetCode_ExeRunFailed;
    }

    CString strCMD;
    strCMD.Format(_T("\"%s\""), pFileInfo->GetToolPath());

    if (TToolType_Exe_Yes == pFileInfo->getToolType())
    {
        STARTUPINFO si;
        PROCESS_INFORMATION pi;

        ZeroMemory( &si, sizeof(si) );
        si.cb = sizeof(si);
        ZeroMemory( &pi, sizeof(pi) );

        if (!CreateProcess(NULL, (LPSTR)(LPCTSTR)strCMD, NULL, NULL, FALSE, 0, NULL,
            NULL, &si, &pi )) 
        {
            return RetCode_ExeRunFailed;
        }
    }
    else
    {
        if (32 >= (int)ShellExecute(NULL, _T("open"), strCMD, NULL,
                                    NULL, SW_SHOWNORMAL))
        {
            return RetCode_FileOpenFailed;
        }
    }

    return RetCode_OK;

}