TnbFileVersion.h

[詳解]

#pragma once
#include "TnbStr.h"
 
 
 
#ifndef _WIN32_WCE
 #include <Winver.h>
 #pragma comment(lib,"version.lib")
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CFileVersion
{
public:
 
    CFileVersion(void) : m_pFileInfo(NULL), m_pLangCodePage(NULL), m_langCodePageSize(0)
    {
    }
 
    bool IsValid(void) const
    {
        return m_pFileInfo != NULL;
    }
 
    bool Open(LPCTSTR lpszFile = NULL, HINSTANCE hInst = NULL)
    {
        CStr strFile;
        if ( lpszFile != NULL )
        {
            strFile = lpszFile;
        }
        else
        {
            ::GetModuleFileName(hInst, strFile.GetBuffer(MAX_PATH), MAX_PATH);
            strFile.ReleaseBuffer();
        }
        DWORD dummy;
        DWORD size = ::GetFileVersionInfoSize(strFile.GetBuffer(), &dummy);
        if ( size != 0)
        {
            m_workMem.Resize(size);
            ZeroMemory(m_workMem, size);
            if ( ::GetFileVersionInfo(strFile.GetBuffer(), 0, size, m_workMem) )
            {
                UINT uLen;
                if ( ::VerQueryValue(m_workMem, _T("\\"), reinterpret_cast<LPVOID*>(&m_pFileInfo), &uLen) )
                {
                    if ( m_pFileInfo->dwSignature == VS_FFI_SIGNATURE )
                    {
                        if ( ::VerQueryValue(m_workMem,
                            _T("\\VarFileInfo\\Translation"),
                            reinterpret_cast<LPVOID*>(&m_pLangCodePage),
                            &m_langCodePageSize) )
                        {
                            m_langCodePageSize /= sizeof(DWORD);
                            strFile.ReleaseBuffer();
                            m_fileName = strFile;
                            return true;
                        }
                    }
                }
            }
        }
        Close();
        return false;
    }
 
    void Close(void)
    {
        m_workMem.Free();
        m_pFileInfo = NULL;
        m_pLangCodePage = NULL;
        m_langCodePageSize = 0;
        m_fileName.Empty();
    }
 
    const VS_FIXEDFILEINFO* GetFileInfo(void) const
    {
        return m_pFileInfo;
    }
 
    VS_FIXEDFILEINFO* GetFileInfo(void)
    {
        return m_pFileInfo;
    }
 
    CStr Get(LPCTSTR lpszType, WORD wLanguage = 0) const
    {
        LPVOID P = m_GetTextPtr(lpszType, wLanguage);
        if ( P != NULL )
        {
            if ( HasUnicodeType() )
            {
                return CStr(reinterpret_cast<LPCWSTR>(P));
            }
            else
            {
                return CStr(reinterpret_cast<LPCSTR>(P));
            }
        }
        return CStr();
    }
 
    CStr GetAboutText(LPCTSTR lpszVerText, WORD wLanguage = 0) const
    {
        if ( ! IsValid() ){ return CStr(); }
        return CStr::Fmt(_T("%s %s %s\n\n%s")
            , Get(_T("FileDescription"))
            , lpszVerText
            , GetFileVersionText()
            , GetCopyrightText()
        );
    }
 
    CStr GetCopyrightText(WORD wLanguage = 0) const
    {
        if ( ! IsValid() ){ return CStr(); }
        return CStr::Fmt(_T("%s %s"),
                Get(_T("LegalCopyright"), wLanguage),
                Get(_T("CompanyName"), wLanguage));
    }
 
    CStr GetFileVersionText(WORD wLanguage = 0) const
    {
        return m_GetVersionText(_T("FileVersion"), wLanguage);
    }
 
    CStr GetProductVersionText(WORD wLanguage = 0) const
    {
        return m_GetVersionText(_T("ProductVersion"), wLanguage);
    }
 
    bool IsSpecialBuild(void) const
    {
        if ( IsValid() )
        {
            DWORD f = m_pFileInfo->dwFileFlags & m_pFileInfo->dwFileFlagsMask;
            return (f & VS_FF_SPECIALBUILD) != 0;
        }
        return false;
    }
 
    bool IsPrivateBuild(void) const
    {
        if ( IsValid() )
        {
            DWORD f = m_pFileInfo->dwFileFlags & m_pFileInfo->dwFileFlagsMask;
            return (f & VS_FF_PRIVATEBUILD) != 0;
        }
        return false;
    }
 
#ifndef _WIN32_WCE
 
    INT_PTR Modify(LPCTSTR lpszType, LPCTSTR lpszValue, WORD wLanguage = 0)
    {
        INT_PTR res = -1;
        if ( IsValid() )
        {
            LPVOID P = m_GetTextPtr(lpszType, wLanguage);
            if ( P != NULL )
            {
                if ( HasUnicodeType() )
                {
                    LPWSTR lpsz = reinterpret_cast<LPWSTR>(P);
                    res = STRLIB::GetLen(lpsz);
                    CUnicode val = lpszValue;
                    STRLIB::Copy(lpsz, val.Left(res));
                }
                else
                {
                    LPSTR lpsz = reinterpret_cast<LPSTR>(P);
                    res = STRLIB::GetLen(lpsz);
                    CAscii val = lpszValue;
                    STRLIB::Copy(lpsz, val.Left(res));
                }
            }
        }
        return res;
    }
 
    INT_PTR ModifyFileVersion(WORD v1, WORD v2, WORD v3, WORD v4, WORD wLanguage = 0)
    {
        if ( IsValid() )
        {
            CStr s;
            s.Format(_T("%d,%d,%d,%d"), v1, v2, v3, v4);
            m_pFileInfo->dwFileVersionMS = MAKELONG(v2, v1);
            m_pFileInfo->dwFileVersionLS = MAKELONG(v4, v3);
            return Modify(_T("FileVersion"), s, wLanguage);
        }
        return -1;
    }
 
    INT_PTR ModifyProductVersion(WORD v1, WORD v2, WORD v3, WORD v4, WORD wLanguage = 0)
    {
        if ( IsValid() )
        {
            CStr s;
            s.Format(_T("%d,%d,%d,%d"), v1, v2, v3, v4);
            m_pFileInfo->dwProductVersionMS = MAKELONG(v2, v1);
            m_pFileInfo->dwProductVersionLS = MAKELONG(v4, v3);
            return Modify(_T("ProductVersion"), s, wLanguage);
        }
        return -1;
    }
 
    bool WritePush(void)
    {
        if ( IsValid() )
        {
            HANDLE h = ::BeginUpdateResource(m_fileName, FALSE);
            if ( h != NULL )
            {
                bool r = !! ::UpdateResource(h, 
                                    RT_VERSION, MAKEINTRESOURCE(VS_VERSION_INFO), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                                    m_workMem.Ref(), ToDword(m_workMem.GetSize()));
                r &= !! ::EndUpdateResource(h, FALSE);
                return r;
            }
        }
        return false;
    }
 
#endif // _WIN32_WCE
 
protected:
 
    virtual void OnGetVerisonText(CStr& _str, DWORD flag, WORD wLanguage) const
    {
        if ( (flag & VS_FF_SPECIALBUILD) != 0 )
        {
            _str += _T(" ");
            _str += Get(_T("SpecialBuild"), wLanguage);
        }
        if ( (flag & VS_FF_PRIVATEBUILD) != 0 )
        {
            _str += _T(" ");
            _str += Get(_T("PrivateBuild"), wLanguage);
        }
        if ( (flag & VS_FF_PRERELEASE) != 0 )
        {
            _str += _T(" [PreRelease版]");
        }
        if ( (flag & VS_FF_DEBUG) != 0 )
        {
            _str += _T(" ≪Debug版≫");
        }
    }
 
private:
    struct TLangAndCodePage
    {
        WORD wLanguage; 
        WORD wCodePage; 
    };
    mutable CWorkMem    m_workMem;          
    VS_FIXEDFILEINFO*   m_pFileInfo;        
    TLangAndCodePage*   m_pLangCodePage;    
    UINT                m_langCodePageSize; 
    CStr                m_fileName;         
    LPVOID m_GetTextPtr(LPCTSTR lpszType, WORD wLanguage = 0) const
    {
        if ( IsValid() )
        {
            // 各言語とコードページのファイルの説明を読み取る。
            for ( UINT i = 0; i < m_langCodePageSize; i++ )
            {
                if ( wLanguage == 0 || m_pLangCodePage[i].wLanguage == wLanguage )
                {
                    CStr strKey;
                    strKey.Format(
                            _T("\\StringFileInfo\\%04x%04x\\%s"),
                            m_pLangCodePage[i].wLanguage,       //Lang
                            m_pLangCodePage[i].wCodePage,       //Code
                            lpszType);
                    // i 番目の言語とコードページのファイルの説明を取得する。
                    UINT dmy;
                    if ( HasUnicodeType() )
                    {
                        CUnicode s = strKey;
                        LPWSTR P;
                        if ( ::VerQueryValueW(m_workMem,
                                s.GetBuffer(),
                                reinterpret_cast<LPVOID*>(&P),
                                &dmy) )
                        {
                            return P;
                        }
                    }
                    else
                    {
                        #ifndef _WIN32_WCE
                        CAscii s = strKey;
                        LPSTR P;
                        if ( ::VerQueryValueA(m_workMem,
                                s.GetBuffer(),
                                reinterpret_cast<LPVOID*>(&P),
                                &dmy) )
                        {
                            return P;
                        }
                        #endif
                    }
                }
            }
        }
        return NULL;
    }
 
    bool HasUnicodeType(void) const
    {
        bool r = false;
        if ( m_pFileInfo != NULL )
        {
            switch ( m_pFileInfo->dwFileOS )
            {
            case VOS_DOS_WINDOWS16:
            case VOS_OS216_PM16:
                break;
            default:
                r = true;
                break;
            }
        }
        return r;
    }
 
    CStr m_GetVersionText(LPCTSTR lpszVer, WORD wLanguage = 0) const
    {
        CStr s;
        if ( IsValid() )
        {
            s = Get(lpszVer, wLanguage);
            DWORD f = m_pFileInfo->dwFileFlags & m_pFileInfo->dwFileFlagsMask;
            OnGetVerisonText(s, f, wLanguage);
        }
        return s;
    }
};
 
 
 
}; // TNB
 
 
 
#ifdef _TnbDOXYGEN  //Document作成用シンボル
 
struct VS_FIXEDFILEINFO 
{ 
};
 
#endif // _TnbDOXYGEN