TnbFilePathManager.h

[詳解]

#pragma once
#ifdef _WIN32_WCE
    #error TnbFilePathManager.h is only supported on Windows NT Series platforms.
#endif // _WIN32_WCE
 
#include "TnbFile.h"
#include "TnbStrEx.h"
 
#include <SHLWAPI.h>
#pragma comment(lib,"SHLWAPI.lib")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CFilePathManager
{
public:
 
    static CStr GetPathName(LPCTSTR lpszFullPath)
    {
        CStr str = lpszFullPath;
        INT_PTR p = str.ReverseFindOneOf(_T("\\/"));
        if ( p >= 0 )
        {
            return str.Left(p + 1);
        }
        return str;
    }
    
    static CStr GetCurrentPath(void)
    {
        CStr str;
        DWORD dwRc = ::GetCurrentDirectory(MAX_PATH, str.GetBuffer(MAX_PATH));
        str.ReleaseBuffer();
        ASSERTLIB( dwRc != 0 );
        IgnoreUnusedValue(dwRc);
        return str;
    }
 
    CFilePathManager(void) 
        : m_strCurrentPath(GetCurrentPath()), m_strManagePath(GetProcessPath())
    {
        ::SetCurrentDirectory(m_strManagePath);
    }
 
    ~CFilePathManager(void)
    {
        ::SetCurrentDirectory(m_strCurrentPath);
    }
 
    void ResetPath(bool boIsManagePath = true) const
    {
        ::SetCurrentDirectory(m_strCurrentPath);
    }
 
    CStr GetPath(void) const
    {
        return m_strManagePath;
    }
    
    bool SetPath(LPCTSTR lpszPath)
    {
        ::Sleep(0);
        bool boRc = !! ::SetCurrentDirectory(lpszPath);
        if ( boRc )
        {
            m_strManagePath = GetCurrentPath();
        }
        return boRc;
    }
 
    bool SetPathOfFile(LPCTSTR lpszFile)
    {
        return SetPath(GetPathName(lpszFile));
    }
 
    CStr GetRelativePathTo(LPCTSTR path) const
    {
        if ( IsRelative(path) )
        {
            //== 相対パス
            return path;
        }
        //== 絶対パス
        CStr s;
        BOOL r = ::PathRelativePathTo(s.GetBuffer(MAX_PATH),
                            GetPath(),
                            FILE_ATTRIBUTE_DIRECTORY,
                            path,
                            FILE_ATTRIBUTE_ARCHIVE);
        s.ReleaseBuffer();
        if ( ! r )
        {
            s.Empty();
        }
        return s;
    }
 
    CStr GetCanonicalize(LPCTSTR path) const
    {
        if ( ! IsRelative(path) )
        {
            //== 絶対パス
            return path;
        }
        //== 相対パスだ
        CStr s;
        BOOL r = ::PathCanonicalize(s.GetBuffer(MAX_PATH), GetPath() + _T("\\") + path);
        s.ReleaseBuffer();
        if ( ! r )
        {
            s.Empty();
        }
        return s;
    }
 
    CFileReader Open(LPCTSTR lpszFile, LPCTSTR lpszPath = NULL) const
    {
        CStr path = lpszPath;
        CFileReader fileHandle;
        CStr strFullpath;
        //
        loop ( iType, 3 )
        {
            if ( iType == 0 || iType == 1 )
            {
                //0;指定パス 1;EXEパス から
                if ( iType == 0 && path.IsEmpty() )
                {
                    continue;
                }
                if ( iType == 1 )
                {
                    path = GetProcessPath();
                }
                //
                if ( ! ::PathIsRelative(lpszFile) )
                {
                    //絶対パス
                    continue;
                }
                //
                if ( ! ::PathSearchAndQualify(
                            CStr::Fmt(_T("%s\\%s"), path, lpszFile),
                            strFullpath.GetBuffer(MAX_PATH),
                            MAX_PATH))
                {
                    continue;
                }
                strFullpath.ReleaseBuffer();
            }
            else
            {
                //パス補完なし
                strFullpath = lpszFile;
            }
            //
            {
                TCHAR atcBuf[MAX_PATH];
                ::GetShortPathName(strFullpath, atcBuf, MAX_PATH);
                ::GetLongPathName(atcBuf, strFullpath.GetBuffer(MAX_PATH), MAX_PATH);
                strFullpath.ReleaseBuffer();
            }
            //
            if ( fileHandle.Open(strFullpath, true) )
            {
                break;
            }
        }
        return fileHandle;
    }
 
    static bool IsRelative(LPCTSTR lpszPath)
    {
        return !! ::PathIsRelative(lpszPath);
    }
 
private:
    CStr m_strCurrentPath;      
    CStr m_strManagePath;       
};
 
 
 
}; // TNB