TnbFileName.h

[詳解]

#pragma once
#include "TnbFile.h"
#include "TnbStrEx.h"
#include "TnbDntStr.h"
#ifndef _WIN32_WCE
 #include <SHLWAPI.h>
 #include <shellapi.h>
 #pragma comment(lib,"SHLWAPI.lib")
 #include <ShObjIdl.h>
 #include <ShlGuid.h>
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN
 #ifndef FOF_NOERRORUI
  #define FOF_NOERRORUI              0x0400  // don't put up error UI
 #endif
#endif
 
 
 
class CFileName
{
public:
 
    CFileName(void) : m_strName(TNB::GetProcessPath()), m_boIsExists(false)
    {
        IsExist();
    }
 
    CFileName(LPCTSTR lpszName) : m_boIsExists(false)
    {
        operator=(lpszName);
    }
 
    CFileName(LPCTSTR lpszName, bool dummy) : m_boIsExists(false)
    {
        m_strName = lpszName;
        m_strName.TrimRight('\\');
        IsExist();
    }
 
    CFileName& operator=(LPCTSTR lpszName)
    {
#ifndef _WIN32_WCE
        CStr s1, s2;
        bool r = !! ::PathSearchAndQualify(lpszName, s1.GetBuffer(MAX_PATH), MAX_PATH);
        s1.ReleaseBuffer();
        if ( r )
        {
            r = (::GetLongPathName(s1, s2.GetBuffer(MAX_PATH), MAX_PATH) != 0);
            s2.ReleaseBuffer();
        }
        if ( r )
        {
            m_strName = s2;
        }
        else
#endif
        {
            m_strName = lpszName;
        }
        m_strName.TrimRight('\\');
        IsExist();
        return *this;
    }
 
    void Set(LPCTSTR lpszName, const WIN32_FILE_ATTRIBUTE_DATA& tFileAttr)
    {
        m_strName = lpszName;
        m_strName.TrimRight('\\');
        m_tInfo = tFileAttr;
        m_boIsExists = true;
    }
 
    void Set(LPCTSTR lpszPath, const WIN32_FIND_DATA& t)
    {
        m_strName.Format(_T("%s\\%s"), lpszPath, t.cFileName);
        m_strName.Replace(_T("\\\\"), _T("\\"));
        m_strName.TrimRight('\\');
        m_tInfo.dwFileAttributes    = t.dwFileAttributes;
        m_tInfo.ftCreationTime      = t.ftCreationTime;
        m_tInfo.ftLastAccessTime    = t.ftLastAccessTime;
        m_tInfo.ftLastWriteTime     = t.ftLastWriteTime;
        m_tInfo.nFileSizeHigh       = t.nFileSizeHigh;
        m_tInfo.nFileSizeLow        = t.nFileSizeLow;
        m_boIsExists = true;
    }
 
    bool IsSameFile(LPCTSTR lpszName) const
    {
        CFileName N(lpszName);
        CStr str = N.GetFullShortName();
        return str.CompareNoCase(GetFullShortName()) == 0;
    }
 
    operator LPCTSTR(void) const
    {
        return m_strName;
    }
 
    CStr GetFullName(void) const
    {
        return m_strName;
    }
 
    CStr GetFullShortName(void) const
    {
        #ifndef _WIN32_WCE
            CStr str;
            ::GetShortPathName(m_strName, str.GetBuffer(MAX_PATH), MAX_PATH);
            str.ReleaseBuffer();
            return str;
        #else
            return m_strName;
        #endif
    }
 
    CStr GetFileName(void) const
    {
        INT_PTR p = m_strName.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 )
        {
            return m_strName.Mid(p + 1);
        }
        return m_strName;
    }
 
    CStr GetFileTitle(void) const
    {
        CStr s = GetFileName();
        INDEX idx = s.Find(_T('.'));
        if ( idx != INVALID_INDEX )
        {
            s = s.Left(idx);
        }
        return s;
    }
 
    CStr GetShortName(void) const
    {
        CStr s = GetFullShortName();
        INT_PTR p = s.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 )
        {
            return s.Mid(p + 1);
        }
        return s;
    }
 
    CStr GetExtName(void) const
    {
        INT_PTR p = m_strName.ReverseFind('.');
        INT_PTR p1 = m_strName.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 && p1 < p )
        {
            return m_strName.Mid(p + 1);
        }
        return _T("");
    }
 
    CStr GetPathName(void) const
    {
        INT_PTR p = m_strName.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 )
        {
            return m_strName.Left(p);
        }
        return m_strName;
    }
 
    LONGLONG GetSize(void) const
    {
        LONGLONG r = -1;
        if ( m_boIsExists )
        {
            LARGE_INTEGER i;
            i.HighPart = m_tInfo.nFileSizeHigh;
            i.LowPart = m_tInfo.nFileSizeLow;
            r = i.QuadPart;
        }
        return r;
    }
 
#ifndef _WIN32_WCE
    LONGLONG GetSizeOnDisk(void) const
    {
        LONGLONG r = -1;
        ::SetLastError(NO_ERROR);
        CStr fn = GetFullName();
        WIN32_FILE_ATTRIBUTE_DATA t;
        if ( ::GetFileAttributesEx(fn, GetFileExInfoStandard, &t) )
        {
            LARGE_INTEGER l;
            if ( (t.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 )
            {
                // DIR の場合
                l.HighPart = t.nFileSizeHigh;
                l.LowPart = t.nFileSizeLow;
                r = l.QuadPart;
            }
            else
            {
                // FILE の場合
                DWORD h;
                l.LowPart = ::GetCompressedFileSize(fn, &h);
                if ( ::GetLastError() == 0 )
                {
                    l.HighPart = h;
                    r = l.QuadPart;
                    // クラスタサイズ、セクターサイズ
                    DWORD sectorsPerCluster;
                    DWORD bytesPerSector;
                    DWORD numberOfFreeClusters;
                    DWORD totalNumberOfClusters;
                    if ( ::GetDiskFreeSpace(GetPathName(), &sectorsPerCluster, &bytesPerSector, &numberOfFreeClusters, &totalNumberOfClusters) )
                    {
                        DWORD d = sectorsPerCluster * bytesPerSector; // セクター byte数
                        r = (r + d - 1) / d * d;
                    }
                    else
                    {
                        r = -1;
                    }
                }
            }
        }
        return r;
    }
 
    DWORD GetBytesOfCluster(void) const
    {
        if ( m_boIsExists )
        {
            CStr fn = GetFullName();
            if ( ! IsDirectory() )
            {
                fn = GetPathName();
            }
            // クラスタサイズ、セクターサイズ
            DWORD sectorsPerCluster;
            DWORD bytesPerSector;
            DWORD numberOfFreeClusters;
            DWORD totalNumberOfClusters;
            if ( ::GetDiskFreeSpace(GetPathName(), &sectorsPerCluster, &bytesPerSector, &numberOfFreeClusters, &totalNumberOfClusters) )
            {
                return sectorsPerCluster * bytesPerSector; // セクター byte数
            }
        }
        return 0;
    }
#endif
 
    bool GetAttributeData(LPWIN32_FILE_ATTRIBUTE_DATA P) const
    {
        bool r = IsExist();
        if ( r && P != NULL )
        {
            *P = m_tInfo;
        }
        return r;
    }
 
    bool GetFindData(LPWIN32_FIND_DATA P) const
    {
        bool r = IsExist();
        if ( r && P != NULL )
        {
            STRLIB::Copy(P->cFileName, GetFileName());
            P->dwFileAttributes = m_tInfo.dwFileAttributes;
            P->ftCreationTime   = m_tInfo.ftCreationTime;
            P->ftLastAccessTime = m_tInfo.ftLastAccessTime;
            P->ftLastWriteTime  = m_tInfo.ftLastWriteTime;
            P->nFileSizeHigh    = m_tInfo.nFileSizeHigh;
            P->nFileSizeLow = m_tInfo.nFileSizeLow;
            #if !defined(_WIN32_WCE)
                STRLIB::Copy(P->cAlternateFileName, GetShortName());
            #endif
        }
        return r;
    }
 
    CStr InsertAtEndOfName(LPCTSTR lpsz, LPCTSTR lpszExt = NULL) const
    {
        CStr s = GetFullName();
        INT_PTR p = s.ReverseFind('.');
        INT_PTR p1 = s.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 && p1 < p )
        {
            if ( lpszExt != NULL )
            {
                return s.Left(p) + lpsz + _T(".") + lpszExt;
            }
            return s.Left(p) + lpsz + s.Mid(p);
        }
        if ( lpszExt != NULL )
        {
            return s + lpsz + _T(".") + lpszExt;
        }
        return s + lpsz;
    }
    
    bool IsExist(void) const
    {
        m_boIsExists = ms_GetInfo(m_strName, &m_tInfo);
        return m_boIsExists;
    }
 
    bool IsReadOnly(void) const { return m_IsAttr(FILE_ATTRIBUTE_READONLY); }
 
    bool IsDirectory(void) const { return m_IsAttr(FILE_ATTRIBUTE_DIRECTORY); }
 
    bool IsCompressed(void) const { return m_IsAttr(FILE_ATTRIBUTE_COMPRESSED); }
 
    bool IsSystem(void) const { return m_IsAttr(FILE_ATTRIBUTE_SYSTEM); }
 
    bool IsHidden(void) const { return m_IsAttr(FILE_ATTRIBUTE_HIDDEN); }
 
    bool IsTemporary(void) const { return m_IsAttr(FILE_ATTRIBUTE_TEMPORARY); }
 
    bool IsNormal(void) const { return m_IsAttr(FILE_ATTRIBUTE_NORMAL); }
 
    bool IsArchived(void) const { return m_IsAttr(FILE_ATTRIBUTE_ARCHIVE); }
 
    CFileTimeEx GetLastWriteTime(void) const
    {
        CFileTimeEx ft;
        if ( m_boIsExists ){ ft = m_tInfo.ftLastWriteTime; }
        return ft;
    }
 
    CFileTimeEx GetLastAccessTime(void) const
    {
        CFileTimeEx ft;
        if ( m_boIsExists ){ ft = m_tInfo.ftLastAccessTime; }
        return ft;
    }
 
    CFileTimeEx GetCreationTime(void) const
    {
        CFileTimeEx ft;
        if ( m_boIsExists ){ ft = m_tInfo.ftCreationTime; }
        return ft;
    }
 
    bool SetReadOnly(void){ return m_SetAttr(FILE_ATTRIBUTE_READONLY); }
 
    bool SetHidden(void){ return m_SetAttr(FILE_ATTRIBUTE_HIDDEN); }
 
    bool SetNormal(void){ return m_SetAttr(FILE_ATTRIBUTE_NORMAL); }
 
    DWORD SetTime(const CFileTimeEx& timeCreation, const CFileTimeEx& timeLastAccess, const CFileTimeEx& timeLastWrite)
    {
        CFileWriter file;
        if ( file.Open(m_strName) )
        {
            ::SetLastError(0);
            file.SetTime(timeCreation, timeLastAccess, timeLastWrite);
        }
        return ::GetLastError();
    }
 
    CStrVector GetFiles(LPCTSTR lpszOpt = _T("\\*.*"))
    {
        CStrVector vstrResult;
        if ( IsDirectory() )
        {
            WIN32_FIND_DATA t;
            HANDLE h = ::FindFirstFile(m_strName + lpszOpt, &t);
            if ( h != INVALID_HANDLE_VALUE )
            {
                while ( true )
                {
                    if ( t.cFileName[0] != '.' )
                    {
                        vstrResult.Add(CStr::Fmt(_T("%s\\%s"), m_strName, t.cFileName));
                    }
                    if ( ! ::FindNextFile(h, &t) )
                    {
                        ::FindClose(h);
                        break;
                    }
                }
            }
        }
        return vstrResult;
    }
 
    bool MakeDirectory(void)
    {
        if ( ! ::CreateDirectory(m_strName, NULL) )
        {
            DWORD e = ::GetLastError();
            if ( e == ERROR_NOT_READY )
            {
                return false;
            }
            if ( e != ERROR_ALREADY_EXISTS )
            {
                CStr n = GetPathName();
                if ( m_strName == n )
                {
                    return false;
                }
                CFileName(n).MakeDirectory();
                if ( ! ::CreateDirectory(m_strName, NULL) )
                {
                    return false;
                }
            }
        }
        IsExist();
        return true;
    }
 
    bool Rename(LPCTSTR lpszNew, bool boIsAllowUndo = false, bool boIsSilent = true)
    {
        if ( IsExist() )
        {
            CFileName fnNew = m_FullPath(lpszNew);
            if ( m_ShFileOp(FO_RENAME, fnNew, boIsAllowUndo, boIsSilent) )
            {
                //成功
                *this = fnNew;
                return true;
            }
        }
        return false;
    }
 
    bool Remove(bool boIsAllowUndo = false, bool boIsSilent = true)
    {
        if ( IsExist() && m_ShFileOp(FO_DELETE, NULL, boIsAllowUndo, boIsSilent) )
        {
            //成功
            IsExist();
            return true;
        }
        return false;
    }
 
    bool CopyTo(LPCTSTR lpszNew, bool boIsAllowUndo = false, bool boIsSilent = true)
    {
        if ( IsExist() && m_ShFileOp(FO_COPY, m_FullPath(lpszNew), boIsAllowUndo, boIsSilent) )
        {
            return true;
        }
        return false;
    }
 
    bool MoveTo(LPCTSTR lpszNew, bool boIsAllowUndo = false, bool boIsSilent = true)
    {
        if ( IsExist() )
        {
            CFileName fnNew = m_FullPath(lpszNew);
            if ( m_ShFileOp(FO_MOVE, fnNew, boIsAllowUndo, boIsSilent) )
            {
                //成功
                *this = fnNew;
                return true;
            }
        }
        return false;
    }
 
    CStr CopyEx(LPCTSTR lpszNew, bool boIsAllowUndo = false)
    {
        if ( IsExist() && ! IsDirectory() )
        {
            CStr s = lpszNew;
            if ( IsExist(s) )
            {
                CStr p1 = s;
                CStr p2;
                INT_PTR f1 = s.ReverseFind('.');
                INT_PTR f2 = s.ReverseFindOneOf(_T("\\/"));
                if ( f1 >= 0 && f2 < f1 )
                {
                    p1 = s.Left(f1);
                    p2 = s.Mid(f1);
                }
                loop ( i, 100000 )
                {
                    s.Format(_T("%s(%d)%s"), p1, i + 1, p2);
                    if ( ! IsExist(s) )
                    {
                        if ( CopyTo(s, boIsAllowUndo, true) )
                        {
                            return s;
                        }
                        break;
                    }
                }
            }
            else
            {
                if ( CopyTo(s, boIsAllowUndo, true) )
                {
                    return s;
                }
            }
        }
        return _T("");
    }
 
    bool MakeShortcut(LPCTSTR lpszLinkName, LPCTSTR lpszDescription, LPCTSTR lpszParameter = NULL) const
    {
#ifndef _WIN32_WCE
        // ShellLink 作成
        IShellLink* pSL = NULL;
        HRESULT hr = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, 
                        IID_IShellLink, reinterpret_cast<LPVOID*>(&pSL));
        if ( SUCCEEDED(hr) )
        { 
            pSL->SetPath(m_strName);
            pSL->SetWorkingDirectory(GetPathName());
            pSL->SetDescription(lpszDescription);
            if ( lpszParameter != NULL )
            {
                pSL->SetArguments(lpszParameter);
            }
            // ShellLink から PersistFile を得る
            IPersistFile* pPF = NULL; 
            hr = pSL->QueryInterface(IID_IPersistFile, reinterpret_cast<LPVOID*>(&pPF));
            if ( SUCCEEDED(hr) ) 
            { 
                hr = pPF->Save(CUnicode(lpszLinkName), TRUE);
                pPF->Release();
                pPF = NULL;
            } 
            pSL->Release();
            pSL = NULL;
        }
        return SUCCEEDED(hr);
#else
        CStr ln = lpszLinkName;
        CStr fn = m_strName;
        return !! ::SHCreateShortcut(ln.GetBuffer(MAX_PATH), fn.GetBuffer(MAX_PATH));
#endif
    }
    
    bool IsShortcut(void) const
    {
#ifndef _WIN32_WCE
        IShellLink* pSL = NULL;
        HRESULT hr = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, 
                                IID_IShellLink, reinterpret_cast<LPVOID*>(&pSL)); 
        if ( SUCCEEDED(hr) ) 
        { 
            IPersistFile* pPF = NULL; 
            hr = pSL->QueryInterface(IID_IPersistFile, reinterpret_cast<LPVOID*>(&pPF));
            if ( SUCCEEDED(hr) ) 
            { 
                hr = pPF->Load(CUnicode(m_strName), STGM_READ);
                pPF->Release();
                pPF = NULL;
            } 
            pSL->Release(); 
            pSL = NULL;
        } 
        return SUCCEEDED(hr);
#else
        CStr s;
        if ( ::SHGetShortcutTarget(m_strName, s.GetBuffer(MAX_PATH), MAX_PATH) )
        {
            s.ReleaseBuffer();
            return true;
        }
        return false;
#endif
    }
 
    bool ResolveShortcut(CStr& _description, HWND hWnd = NULL)
    {
    #ifndef _WIN32_WCE
        IShellLink* pSL = NULL;
        HRESULT hr = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, 
                                IID_IShellLink, reinterpret_cast<LPVOID*>(&pSL)); 
        if ( SUCCEEDED(hr) ) 
        { 
            IPersistFile* pPF = NULL; 
            hr = pSL->QueryInterface(IID_IPersistFile, reinterpret_cast<LPVOID*>(&pPF));
            if ( SUCCEEDED(hr) ) 
            { 
                hr = pPF->Load(CUnicode(m_strName), STGM_READ);
                if ( hWnd != NULL && SUCCEEDED(hr) ) 
                { 
                    hr = pSL->Resolve(hWnd, 0); 
                }
                WIN32_FIND_DATA wfd; 
                CStr path;
                if ( SUCCEEDED(hr) ) 
                { 
                    hr = pSL->GetPath(path.GetBuffer(MAX_PATH), MAX_PATH, &wfd, SLGP_SHORTPATH); 
                    path.ReleaseBuffer();
                }
                if ( SUCCEEDED(hr) ) 
                { 
                    // Get the description of the target. 
                    hr = pSL->GetDescription(_description.GetBuffer(MAX_PATH), MAX_PATH); 
                    _description.ReleaseBuffer();
                }
                if ( SUCCEEDED(hr) ) 
                {
                    operator=(path);
                }
                pPF->Release();
                pPF = NULL;
            } 
            pSL->Release(); 
            pSL = NULL;
        } 
        return SUCCEEDED(hr);
#else
        CStr s;
        if ( ::SHGetShortcutTarget(m_strName, s.GetBuffer(MAX_PATH), MAX_PATH) )
        {
            s.ReleaseBuffer();
            operator=(s);
            _description.Empty();
            return true;
        }
        return false;
#endif
    }
 
    bool ResolveShortcut(void)
    {
        CStr s;
        return ResolveShortcut(s, NULL);
    }
    
    static bool IsExist(LPCTSTR lpszPath)
    {
        return CFileName(lpszPath).IsExist();
    }
 
private:
    bool m_IsAttr(DWORD dwCheck) const
    {
        if ( m_boIsExists )
        {
            return (m_tInfo.dwFileAttributes & dwCheck) != 0;
        }
        return false;
    }
    bool m_SetAttr(DWORD dwAttr)
    {
        bool r = !! ::SetFileAttributes(m_strName, dwAttr);
        m_boIsExists = ms_GetInfo(m_strName, &m_tInfo);
        return r;
    }
    static bool ms_GetInfo(LPCTSTR lpszName, LPWIN32_FILE_ATTRIBUTE_DATA P)
    {
        WIN32_FIND_DATA t;
        HANDLE h = ::FindFirstFile(lpszName, &t);
        if ( h != INVALID_HANDLE_VALUE )
        {
            ::FindClose(h);
            P->dwFileAttributes = t.dwFileAttributes;
            P->ftCreationTime   = t.ftCreationTime;
            P->ftLastAccessTime = t.ftLastAccessTime;
            P->ftLastWriteTime  = t.ftLastWriteTime;
            P->nFileSizeHigh    = t.nFileSizeHigh;
            P->nFileSizeLow     = t.nFileSizeLow;
            return true;
        }
        return false;
    }
    CStr m_FullPath(LPCTSTR lpszName)
    {
        #ifndef _WIN32_WCE
            CStr str;
            if ( ::PathIsRelative(lpszName) )
            {
                str = CStr::Fmt(_T("%s\\%s"), GetPathName(), lpszName);
            }
            else
            {
                str = lpszName;
            }
            return str;
        #else
            return lpszName;
        #endif
    }
    bool m_ShFileOp(WORD wFunc, LPCTSTR lpszTo, bool boIsAllowUndo, bool boIsSilent)
    {
        CDoubleNullTerminateStr strdntFrom(m_strName);
        return m_ShFileOp(wFunc, strdntFrom, lpszTo, boIsAllowUndo, boIsSilent);
    }
    bool m_ShFileOp(WORD wFunc, const CDoubleNullTerminateStr& strdntFrom, LPCTSTR lpszTo, 
                bool boIsAllowUndo, bool boIsSilent)
    {
        SHFILEOPSTRUCT tFileOp;
        CDoubleNullTerminateStr strdntTo(lpszTo);
        tFileOp.hwnd    = NULL;                         // ウィンドウハンドル
        tFileOp.wFunc   = wFunc;                        // 実行する操作
        tFileOp.pFrom   = strdntFrom;                   // 対象ファイル名
        tFileOp.pTo     = NULL;                         // 目的ファイル名
        if ( lpszTo != NULL )
        {
            tFileOp.pTo = strdntTo;
        }
        tFileOp.fFlags  = 0;                            // Flag
        if ( boIsSilent )
        {
            tFileOp.fFlags |= FOF_SILENT        // 経過ダイアログ無し
                            | FOF_NOCONFIRMATION// 確認で「すべて」指定
                            | FOF_NOERRORUI;    // エラー時、ダイアログを出さない
        }
        if ( boIsAllowUndo )
        {
            tFileOp.fFlags |= FOF_ALLOWUNDO;    //UNDO
        }
        tFileOp.fAnyOperationsAborted = FALSE;          // [out]結果
        tFileOp.hNameMappings = NULL;                   // [out]ファイル名マッピングオブジェクト
        tFileOp.lpszProgressTitle = _T("");
        return ::SHFileOperation(&tFileOp) == 0;
    }
    CStr                                m_strName;      
    mutable bool                        m_boIsExists;   
    mutable WIN32_FILE_ATTRIBUTE_DATA   m_tInfo;        
};
 
 
 
}; // TNB