de/dd4/shelwapi_8cpp_source.html

//----------------------------------------------------------------------------

// ObjectWindows

// Copyright (c) 1995, 1996 by Borland International, All Rights Reserved

//

/// \file

/// Implementations of Windows light-weight utility APIs:

///    TSHReg, TSHPath

//----------------------------------------------------------------------------

#include <owl/pch.h>

#include <owl/defs.h>

#include <owl/shelwapi.h>

#include <owl/module.h>


namespace owl {


////////////////////////////////////////////////////////////////////

//

// class TSHReg

// ~~~~~ ~~~~~~

// delay loading SHLWAPI.DLL

  static const tchar shellStr[]            = _T("SHLWAPI.DLL");


  static const char DuplicateKeyStr[]       = "SHRegDuplicateHKey";

# if defined(UNICODE)

  static const char DeleteEmptyKeyStr[]      = "SHDeleteEmptyKeyW";

  static const char DeleteKeyStr[]          = "SHDeleteKeyW";

  static const char DeleteValueStr[]        = "SHDeleteValueW";

  static const char GetValueStr[]            = "SHGetValueW";

  static const char SetValueStr[]            = "SHSetValueW";

  static const char QueryValueExStr[]        = "SHQueryValueExW";

  static const char EnumKeyExStr[]          = "SHEnumKeyExW";

  static const char EnumValueStr[]           = "SHEnumValueW";

  static const char QueryInfoKeyStr[]         = "SHQueryInfoKeyW";

  static const char CopyKeyStr[]              = "SHCopyKeyW";

  static const char RegGetPathStr[]          = "SHRegGetPathW";

  static const char RegSetPathStr[]         = "SHRegSetPathW";

# else

  static const char DeleteEmptyKeyStr[]      = "SHDeleteEmptyKeyA";

  static const char DeleteKeyStr[]          = "SHDeleteKeyA";

  static const char DeleteValueStr[]        = "SHDeleteValueA";

  static const char GetValueStr[]            = "SHGetValueA";

  static const char SetValueStr[]            = "SHSetValueA";

  static const char QueryValueExStr[]        = "SHQueryValueExA";

  static const char EnumKeyExStr[]          = "SHEnumKeyExA";

  static const char EnumValueStr[]           = "SHEnumValueA";

  static const char QueryInfoKeyStr[]        = "SHQueryInfoKeyA";

  static const char CopyKeyStr[]             = "SHCopyKeyA";

  static const char RegGetPathStr[]         = "SHRegGetPathA";

  static const char RegSetPathStr[]         = "SHRegSetPathA";

# endif


//

// Returns TModule object wrapping the handle of the SHLWAPI.DLL module

//

TModule&


TSHReg::GetModule()

{

  static TModule shellModule(shellStr, true, true, false);

  return shellModule;

}

TSHReg::GetModule() {…}


DWORD


TSHReg::DeleteEmptyKey(HKEY hkey, LPCTSTR pszSubKey)

{

  static TModuleProc2<DWORD,HKEY,LPCTSTR>

         deleteEmptyKey(GetModule(), DeleteEmptyKeyStr);

  return deleteEmptyKey(hkey,pszSubKey);

}

TSHReg::DeleteEmptyKey(HKEY hkey, LPCTSTR pszSubKey) {…}


DWORD


TSHReg::DeleteKey(HKEY hkey, LPCTSTR pszSubKey)

{

  static TModuleProc2<DWORD,HKEY,LPCTSTR>

         deleteKey(GetModule(), DeleteKeyStr);

  return deleteKey(hkey,pszSubKey);

}

TSHReg::DeleteKey(HKEY hkey, LPCTSTR pszSubKey) {…}


HKEY


TSHReg::DuplicateKey(HKEY hkey)

{

  static TModuleProc1<HKEY,HKEY>

         duplicateKey(GetModule(), DuplicateKeyStr);

  return duplicateKey(hkey);

}

TSHReg::DuplicateKey(HKEY hkey) {…}


DWORD


TSHReg::DeleteValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue)

{

  static TModuleProc3<DWORD,HKEY,LPCTSTR,LPCTSTR>

         deleteValue(GetModule(), DeleteValueStr);

  return deleteValue(hkey, pszSubKey, pszValue);

}

TSHReg::DeleteValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue) {…}


DWORD


TSHReg::GetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)

{

  static TModuleProc6<DWORD,HKEY,LPCTSTR,LPCTSTR,LPDWORD,LPVOID,LPDWORD>

         getValue(GetModule(), GetValueStr);

  return getValue(hkey, pszSubKey, pszValue, pdwType, pvData, pcbData);

}

TSHReg::GetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData) {…}


DWORD


TSHReg::SetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData)

{

  static TModuleProc6<DWORD,HKEY,LPCTSTR,LPCTSTR,DWORD,LPCVOID,DWORD>

         setValue(GetModule(), SetValueStr);

  return setValue(hkey, pszSubKey, pszValue, dwType, pvData, cbData);

}

TSHReg::SetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData) {…}


DWORD


TSHReg::QueryValueEx(HKEY hkey, LPCTSTR pszValue, LPDWORD pdwReserved, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)

{

  static TModuleProc6<DWORD,HKEY,LPCTSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD>

         queryValueEx(GetModule(), QueryValueExStr);

  return queryValueEx(hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);

}

TSHReg::QueryValueEx(HKEY hkey, LPCTSTR pszValue, LPDWORD pdwReserved, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData) {…}


LONG


TSHReg::EnumKeyEx(HKEY hkey, DWORD dwIndex, LPTSTR pszName, LPDWORD pcchName)

{

  static TModuleProc4<LONG,HKEY,DWORD,LPTSTR,LPDWORD>

         enumKeyEx(GetModule(), EnumKeyExStr);

  return enumKeyEx(hkey, dwIndex, pszName, pcchName);

}

TSHReg::EnumKeyEx(HKEY hkey, DWORD dwIndex, LPTSTR pszName, LPDWORD pcchName) {…}


LONG


TSHReg::EnumValue(HKEY hkey, DWORD dwIndex, LPTSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)

{

  static TModuleProc7<LONG,HKEY,DWORD,LPTSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD>

         enumValue(GetModule(), EnumValueStr);

  return enumValue(hkey, dwIndex, pszValueName, pcchValueName, pdwType, pvData, pcbData);

}

TSHReg::EnumValue(HKEY hkey, DWORD dwIndex, LPTSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData) {…}


LONG


TSHReg::QueryInfoKey(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen)

{

  static TModuleProc5<LONG,HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD>

         queryInfoKey(GetModule(), QueryInfoKeyStr);

  return queryInfoKey(hkey, pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);

}

TSHReg::QueryInfoKey(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen) {…}


// recursive key copy

DWORD


TSHReg::CopyKey(HKEY hkeySrc, LPCTSTR szSrcSubKey, HKEY hkeyDest, DWORD fReserved)

{

  static TModuleProc4<DWORD,HKEY,LPCTSTR,HKEY,DWORD>

         copyKey(GetModule(), CopyKeyStr);

  return copyKey(hkeySrc, szSrcSubKey, hkeyDest, fReserved);

}

TSHReg::CopyKey(HKEY hkeySrc, LPCTSTR szSrcSubKey, HKEY hkeyDest, DWORD fReserved) {…}


// Getting and setting file system paths with environment variables

DWORD


TSHReg::RegGetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, LPTSTR pszPath, DWORD dwFlags)

{

  static TModuleProc5<DWORD,HKEY,LPCTSTR,LPCTSTR,LPTSTR,DWORD>

         regGetPath(GetModule(), RegGetPathStr);

  return regGetPath(hkey, pcszSubKey, pcszValue, pszPath, dwFlags);

}

TSHReg::RegGetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, LPTSTR pszPath, DWORD dwFlags) {…}


DWORD


TSHReg::RegSetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, LPCTSTR pcszPath, DWORD dwFlags)

{

  static TModuleProc5<DWORD,HKEY,LPCTSTR,LPCTSTR,LPCTSTR,DWORD>

         regSetPath(GetModule(), RegSetPathStr);

  return regSetPath(hkey, pcszSubKey, pcszValue, pcszPath, dwFlags);

}

TSHReg::RegSetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, LPCTSTR pcszPath, DWORD dwFlags) {…}


////////////////////////////////////////////////////////////////////

//

// class TSHPath

// ~~~~~ ~~~~~~


# if defined(UNICODE)

  static const char AddBackslashStr[]                = "PathAddBackslashW";

  static const char AddExtensionStr[]                = "PathAddExtensionW";

  static const char AppendStr[]                      = "PathAppendW";

  static const char BuildRootStr[]                   = "PathBuildRootW";

  static const char CanonicalizeStr[]                 = "PathCanonicalizeW";

  static const char CombineStr[]                     = "PathCombineW";

  static const char CompactPathStr[]                 = "PathCompactPathW";

  static const char CompactPathExStr[]              = "PathCompactPathExW";

  static const char CommonPrefixStr[]                = "PathCommonPrefixW";

  static const char FileExistsStr[]                 = "PathFileExistsW";

  static const char FindExtensionStr[]               = "PathFindExtensionW";

  static const char FindFileNameStr[]               = "PathFindFileNameW";

  static const char FindNextComponentStr[]           = "PathFindNextComponentW";

  static const char FindOnPathStr[]                 = "PathFindOnPathW";

  static const char GetArgsStr[]                     = "PathGetArgsW";

  static const char FindSuffixArrayStr[]              = "PathFindSuffixArrayW";

  static const char IsLFNFileSpecStr[]                = "PathIsLFNFileSpecW";

  static const char GetCharTypeStr[]                  = "PathGetCharTypeW";

  static const char GetDriveNumberStr[]             = "PathGetDriveNumberW";

  static const char IsDirectoryStr[]                 = "PathIsDirectoryW";

  static const char IsDirectoryEmptyStr[]           = "PathIsDirectoryEmptyW";

  static const char IsFileSpecStr[]                 = "PathIsFileSpecW";

  static const char IsPrefixStr[]                   = "PathIsPrefixW";

  static const char IsRelativeStr[]                 = "PathIsRelativeW";

  static const char IsRootStr[]                     = "PathIsRootW";

  static const char IsSameRootStr[]                   = "PathIsSameRootW";

  static const char IsUNCStr[]                       = "PathIsUNCW";

  static const char IsNetworkPathStr[]               = "PathIsNetworkPathW";

  static const char IsUNCServerStr[]                 = "PathIsUNCServerW";

  static const char IsUNCServerShareStr[]            = "PathIsUNCServerShareW";

  static const char IsContentTypeStr[]               = "PathIsContentTypeW";

  static const char IsURLStr[]                       = "PathIsURLW";

  static const char MakePrettyStr[]                  = "PathMakePrettyW";

  static const char MatchSpecStr[]                  = "PathMatchSpecW";

  static const char ParseIconLocationStr[]          = "PathParseIconLocationW";

  static const char QuoteSpacesStr[]                = "PathQuoteSpacesW";

  static const char RelativePathToStr[]             = "PathRelativePathToW";

  static const char RemoveArgsStr[]                 = "PathRemoveArgsW";

  static const char RemoveBackslashStr[]            = "PathRemoveBackslashW";

  static const char RemoveBlanksStr[]               = "PathRemoveBlanksW";

  static const char RemoveExtensionStr[]            = "PathRemoveExtensionW";

  static const char RemoveFileSpecStr[]             = "PathRemoveFileSpecW";

  static const char RenameExtensionStr[]            = "PathRenameExtensionW";

  static const char SearchAndQualifyStr[]           = "PathSearchAndQualifyW";

  static const char SetDlgItemPathStr[]             = "PathSetDlgItemPathW";

  static const char SkipRootStr[]                   = "PathSkipRootW";

  static const char StripPathStr[]                  = "PathStripPathW";

  static const char StripToRootStr[]                = "PathStripToRootW";

  static const char UnquoteSpacesStr[]              = "PathUnquoteSpacesW";

  static const char MakeSystemFolderStr[]           = "PathMakeSystemFolderW";

  static const char UnmakeSystemFolderStr[]         = "PathUnmakeSystemFolderW";

  static const char IsSystemFolderStr[]             = "PathIsSystemFolderW";

  static const char UndecorateStr[]                 = "PathUndecorateW";

  static const char UnExpandEnvStringsStr[]          = "PathUnExpandEnvStringsW";

  static const char UnExpandEnvStringsForUserStr[]  = "PathUnExpandEnvStringsForUserW";

# else

  static const char AddBackslashStr[]                = "PathAddBackslashA";

  static const char AddExtensionStr[]                = "PathAddExtensionA";

  static const char AppendStr[]                      = "PathAppendA";

  static const char BuildRootStr[]                  = "PathBuildRootA";

  static const char CanonicalizeStr[]                = "PathCanonicalizeA";

  static const char CombineStr[]                    = "PathCombineA";

  static const char CompactPathStr[]                 = "PathCompactPathA";

  static const char CompactPathExStr[]              = "PathCompactPathExA";

  static const char CommonPrefixStr[]                = "PathCommonPrefixA";

  static const char FileExistsStr[]                 = "PathFileExistsA";

  static const char FindExtensionStr[]               = "PathFindExtensionA";

  static const char FindFileNameStr[]               = "PathFindFileNameA";

  static const char FindNextComponentStr[]           = "PathFindNextComponentA";

  static const char FindOnPathStr[]                 = "PathFindOnPathA";

  static const char GetArgsStr[]                     = "PathGetArgsA";

  static const char FindSuffixArrayStr[]              = "PathFindSuffixArrayA";

  static const char IsLFNFileSpecStr[]                = "PathIsLFNFileSpecA";

  static const char GetCharTypeStr[]                  = "PathGetCharTypeA";

  static const char GetDriveNumberStr[]             = "PathGetDriveNumberA";

  static const char IsDirectoryStr[]                 = "PathIsDirectoryA";

  static const char IsDirectoryEmptyStr[]           = "PathIsDirectoryEmptyA";

  static const char IsFileSpecStr[]                 = "PathIsFileSpecA";

  static const char IsPrefixStr[]                   = "PathIsPrefixA";

  static const char IsRelativeStr[]                 = "PathIsRelativeA";

  static const char IsRootStr[]                      = "PathIsRootA";

  static const char IsSameRootStr[]                 = "PathIsSameRootA";

  static const char IsUNCStr[]                       = "PathIsUNCA";

  static const char IsNetworkPathStr[]               = "PathIsNetworkPathA";

  static const char IsUNCServerStr[]                 = "PathIsUNCServerA";

  static const char IsUNCServerShareStr[]            = "PathIsUNCServerShareA";

  static const char IsContentTypeStr[]               = "PathIsContentTypeA";

  static const char IsURLStr[]                       = "PathIsURLA";

  static const char MakePrettyStr[]                  = "PathMakePrettyA";

  static const char MatchSpecStr[]                  = "PathMatchSpecA";

  static const char ParseIconLocationStr[]          = "PathParseIconLocationA";

  static const char QuoteSpacesStr[]                = "PathQuoteSpacesA";

  static const char RelativePathToStr[]             = "PathRelativePathToA";

  static const char RemoveArgsStr[]                 = "PathRemoveArgsA";

  static const char RemoveBackslashStr[]            = "PathRemoveBackslashA";

  static const char RemoveBlanksStr[]               = "PathRemoveBlanksA";

  static const char RemoveExtensionStr[]            = "PathRemoveExtensionA";

  static const char RemoveFileSpecStr[]             = "PathRemoveFileSpecA";

  static const char RenameExtensionStr[]            = "PathRenameExtensionA";

  static const char SearchAndQualifyStr[]           = "PathSearchAndQualifyA";

  static const char SetDlgItemPathStr[]             = "PathSetDlgItemPathA";

  static const char SkipRootStr[]                   = "PathSkipRootA";

  static const char StripPathStr[]                  = "PathStripPathA";

  static const char StripToRootStr[]                = "PathStripToRootA";

  static const char UnquoteSpacesStr[]              = "PathUnquoteSpacesA";

  static const char MakeSystemFolderStr[]           = "PathMakeSystemFolderA";

  static const char UnmakeSystemFolderStr[]         = "PathUnmakeSystemFolderA";

  static const char IsSystemFolderStr[]             = "PathIsSystemFolderA";

  static const char UndecorateStr[]                 = "PathUndecorateA";

  static const char UnExpandEnvStringsStr[]          = "PathUnExpandEnvStringsA";

  static const char UnExpandEnvStringsForUserStr[]  = "PathUnExpandEnvStringsForUserA";

# endif


//

// Returns TModule object wrapping the handle of the SHLWAPI.DLL module

//

TModule&


TSHPath::GetModule()

{

  static TModule shellModule(shellStr, true, true, false);

  return shellModule;

}

TSHPath::GetModule() {…}


LPTSTR


TSHPath::AddBackslash(LPTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPTSTR>

         addBackslash(GetModule(), AddBackslashStr);

  return addBackslash(pszPath);

}

TSHPath::AddBackslash(LPTSTR pszPath) {…}


BOOL


TSHPath::AddExtension(LPTSTR pszPath, LPCTSTR pszExt)

{

  static TModuleProc2<BOOL,LPTSTR,LPCTSTR>

         addExtension(GetModule(), AddExtensionStr);

  return addExtension(pszPath, pszExt);

}

TSHPath::AddExtension(LPTSTR pszPath, LPCTSTR pszExt) {…}


BOOL


TSHPath::Append(LPTSTR pszPath, LPCTSTR pszMore)

{

  static TModuleProc2<BOOL,LPTSTR,LPCTSTR>

         append(GetModule(), AppendStr);

  return append(pszPath, pszMore);

}

TSHPath::Append(LPTSTR pszPath, LPCTSTR pszMore) {…}


LPTSTR


TSHPath::BuildRoot(LPTSTR pszRoot, int iDrive)

{

  static TModuleProc2<LPTSTR,LPTSTR,int>

         buildRoot(GetModule(), BuildRootStr);

  return buildRoot(pszRoot, iDrive);

}

TSHPath::BuildRoot(LPTSTR pszRoot, int iDrive) {…}


BOOL


TSHPath::Canonicalize(LPTSTR pszBuf, LPCTSTR pszPath)

{

  static TModuleProc2<BOOL,LPTSTR,LPCTSTR>

         canonicalize(GetModule(), CanonicalizeStr);

  return canonicalize(pszBuf, pszPath);

}

TSHPath::Canonicalize(LPTSTR pszBuf, LPCTSTR pszPath) {…}


LPTSTR


TSHPath::Combine(LPTSTR pszDest, LPCTSTR pszDir, LPCTSTR pszFile)

{

  static TModuleProc3<LPTSTR,LPTSTR,LPCTSTR,LPCTSTR>

         combine(GetModule(), CombineStr);

  return combine(pszDest, pszDir, pszFile);

}

TSHPath::Combine(LPTSTR pszDest, LPCTSTR pszDir, LPCTSTR pszFile) {…}


BOOL


TSHPath::CompactPath(HDC hDC, LPTSTR pszPath, UINT dx)

{

  static TModuleProc3<BOOL,HDC,LPTSTR,UINT>

         compactPath(GetModule(), CompactPathStr);

  return compactPath(hDC, pszPath, dx);

}

TSHPath::CompactPath(HDC hDC, LPTSTR pszPath, UINT dx) {…}


BOOL


TSHPath::CompactPathEx(LPTSTR pszOut, LPCTSTR pszSrc, UINT cchMax, DWORD dwFlags)

{

  static TModuleProc4<BOOL,LPTSTR,LPCTSTR,UINT,DWORD>

         compactPathEx(GetModule(), CompactPathExStr);

  return compactPathEx(pszOut, pszSrc, cchMax, dwFlags);

}

TSHPath::CompactPathEx(LPTSTR pszOut, LPCTSTR pszSrc, UINT cchMax, DWORD dwFlags) {…}


int


TSHPath::CommonPrefix(LPCTSTR pszFile1, LPCTSTR pszFile2, LPTSTR achPath)

{

  static TModuleProc3<int,LPCTSTR,LPCTSTR,LPTSTR>

         commonPrefix(GetModule(), CommonPrefixStr);

  return commonPrefix(pszFile1, pszFile2, achPath);

}

TSHPath::CommonPrefix(LPCTSTR pszFile1, LPCTSTR pszFile2, LPTSTR achPath) {…}


BOOL


TSHPath::FileExists(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         fileExists(GetModule(), FileExistsStr);

  return fileExists(pszPath);

}

TSHPath::FileExists(LPCTSTR pszPath) {…}


LPTSTR


TSHPath::FindExtension(LPCTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPCTSTR>

         findExtension(GetModule(), FindExtensionStr);

  return findExtension(pszPath);

}

TSHPath::FindExtension(LPCTSTR pszPath) {…}


LPTSTR


TSHPath::FindFileName(LPCTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPCTSTR>

         findFileName(GetModule(), FindFileNameStr);

  return findFileName(pszPath);

}

TSHPath::FindFileName(LPCTSTR pszPath) {…}


LPTSTR


TSHPath::FindNextComponent(LPCTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPCTSTR>

         findNextComponent(GetModule(), FindNextComponentStr);

  return findNextComponent(pszPath);

}

TSHPath::FindNextComponent(LPCTSTR pszPath) {…}


BOOL


TSHPath::FindOnPath(LPTSTR pszPath, LPCTSTR * ppszOtherDirs)

{

  static TModuleProc2<BOOL,LPTSTR,LPCTSTR*>

         findOnPath(GetModule(), FindOnPathStr);

  return findOnPath(pszPath, ppszOtherDirs);

}

TSHPath::FindOnPath(LPTSTR pszPath, LPCTSTR * ppszOtherDirs) {…}


LPTSTR


TSHPath::GetArgs(LPCTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPCTSTR>

         getArgs(GetModule(), GetArgsStr);

  return getArgs(pszPath);

}

TSHPath::GetArgs(LPCTSTR pszPath) {…}


LPCTSTR


TSHPath::FindSuffixArray(LPCTSTR pszPath, const LPCTSTR *apszSuffix, int iArraySize)

{

  static TModuleProc3<LPCTSTR,LPCTSTR,const LPCTSTR *,int>

         findSuffixArray(GetModule(), FindSuffixArrayStr);

  return findSuffixArray(pszPath, apszSuffix, iArraySize);

}

TSHPath::FindSuffixArray(LPCTSTR pszPath, const LPCTSTR *apszSuffix, int iArraySize) {…}


BOOL


TSHPath::IsLFNFileSpec(LPCTSTR lpName)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isLFNFileSpec(GetModule(), IsLFNFileSpecStr);

  return isLFNFileSpec(lpName);

}

TSHPath::IsLFNFileSpec(LPCTSTR lpName) {…}


UINT


TSHPath::GetCharType(tchar ch)

{

  static TModuleProc1<UINT,tchar>

         getCharType(GetModule(), GetCharTypeStr);

  return getCharType(ch);

}

TSHPath::GetCharType(tchar ch) {…}


int


TSHPath::GetDriveNumber(LPCTSTR pszPath)

{

  static TModuleProc1<int,LPCTSTR>

         getDriveNumber(GetModule(), GetDriveNumberStr);

  return getDriveNumber(pszPath);

}

TSHPath::GetDriveNumber(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsDirectory(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isDirectory(GetModule(), IsDirectoryStr);

  return isDirectory(pszPath);

}

TSHPath::IsDirectory(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsDirectoryEmpty(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isDirectoryEmpty(GetModule(), IsDirectoryEmptyStr);

  return isDirectoryEmpty(pszPath);

}

TSHPath::IsDirectoryEmpty(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsFileSpec(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isFileSpec(GetModule(), IsFileSpecStr);

  return isFileSpec(pszPath);

}

TSHPath::IsFileSpec(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsPrefix(LPCTSTR pszPrefix, LPCTSTR pszPath)

{

  static TModuleProc2<BOOL,LPCTSTR,LPCTSTR>

         isPrefix(GetModule(), IsPrefixStr);

  return isPrefix(pszPrefix, pszPath);

}

TSHPath::IsPrefix(LPCTSTR pszPrefix, LPCTSTR pszPath) {…}


BOOL


TSHPath::IsRelative(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isRelative(GetModule(), IsRelativeStr);

  return isRelative(pszPath);

}

TSHPath::IsRelative(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsRoot(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isRoot(GetModule(), IsRootStr);

  return isRoot(pszPath);

}

TSHPath::IsRoot(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsSameRoot(LPCTSTR pszPath1, LPCTSTR pszPath2)

{

  static TModuleProc2<BOOL,LPCTSTR,LPCTSTR>

         isSameRoot(GetModule(), IsSameRootStr);

  return isSameRoot(pszPath1, pszPath2);

}

TSHPath::IsSameRoot(LPCTSTR pszPath1, LPCTSTR pszPath2) {…}


BOOL


TSHPath::IsUNC(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isUNC(GetModule(), IsUNCStr);

  return isUNC(pszPath);

}

TSHPath::IsUNC(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsNetworkPath(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isNetworkPath(GetModule(), IsNetworkPathStr);

  return isNetworkPath(pszPath);

}

TSHPath::IsNetworkPath(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsUNCServer(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isUNCServer(GetModule(), IsUNCServerStr);

  return isUNCServer(pszPath);

}

TSHPath::IsUNCServer(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsUNCServerShare(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isUNCServerShare(GetModule(), IsUNCServerShareStr);

  return isUNCServerShare(pszPath);

}

TSHPath::IsUNCServerShare(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsContentType(LPCTSTR pszPath, LPCTSTR pszContentType)

{

  static TModuleProc2<BOOL,LPCTSTR,LPCTSTR>

         isContentType(GetModule(), IsContentTypeStr);

  return isContentType(pszPath,pszContentType);

}

TSHPath::IsContentType(LPCTSTR pszPath, LPCTSTR pszContentType) {…}


BOOL


TSHPath::IsURL(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         isURL(GetModule(), IsURLStr);

  return isURL(pszPath);

}

TSHPath::IsURL(LPCTSTR pszPath) {…}


BOOL


TSHPath::MakePretty(LPTSTR pszPath)

{

  static TModuleProc1<BOOL,LPTSTR>

         makePretty(GetModule(), MakePrettyStr);

  return makePretty(pszPath);

}

TSHPath::MakePretty(LPTSTR pszPath) {…}


BOOL


TSHPath::MatchSpec(LPCTSTR pszFile, LPCTSTR pszSpec)

{

  static TModuleProc2<BOOL,LPCTSTR,LPCTSTR>

         matchSpec(GetModule(), MatchSpecStr);

  return matchSpec(pszFile, pszSpec);

}

TSHPath::MatchSpec(LPCTSTR pszFile, LPCTSTR pszSpec) {…}


int


TSHPath::ParseIconLocation(LPTSTR pszIconFile)

{

  static TModuleProc1<int,LPTSTR>

         parseIconLocation(GetModule(), ParseIconLocationStr);

  return parseIconLocation(pszIconFile);

}

TSHPath::ParseIconLocation(LPTSTR pszIconFile) {…}


void


TSHPath::QuoteSpaces(LPTSTR lpsz)

{

  static TModuleProcV1<LPTSTR>

         quoteSpaces(GetModule(), QuoteSpacesStr);

  quoteSpaces(lpsz);

}

TSHPath::QuoteSpaces(LPTSTR lpsz) {…}


BOOL


TSHPath::RelativePathTo(LPTSTR pszPath, LPCTSTR pszFrom, DWORD dwAttrFrom, LPCTSTR pszTo, DWORD dwAttrTo)

{

  static TModuleProc5<BOOL,LPTSTR,LPCTSTR,DWORD,LPCTSTR,DWORD>

         relativePathTo(GetModule(), RelativePathToStr);

  return relativePathTo(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);

}

TSHPath::RelativePathTo(LPTSTR pszPath, LPCTSTR pszFrom, DWORD dwAttrFrom, LPCTSTR pszTo, DWORD dwAttrTo) {…}


void


TSHPath::RemoveArgs(LPTSTR pszPath)

{

  static TModuleProcV1<LPTSTR>

         removeArgs(GetModule(), RemoveArgsStr);

  removeArgs(pszPath);

}

TSHPath::RemoveArgs(LPTSTR pszPath) {…}


LPTSTR


TSHPath::RemoveBackslash(LPTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPTSTR>

         removeBackslash(GetModule(), RemoveBackslashStr);

  return removeBackslash(pszPath);

}

TSHPath::RemoveBackslash(LPTSTR pszPath) {…}


void


TSHPath::RemoveBlanks(LPTSTR pszPath)

{

  static TModuleProcV1<LPTSTR>

         removeBlanks(GetModule(), RemoveBlanksStr);

  removeBlanks(pszPath);

}

TSHPath::RemoveBlanks(LPTSTR pszPath) {…}


void


TSHPath::RemoveExtension(LPTSTR pszPath)

{

  static TModuleProcV1<LPTSTR>

         removeExtension(GetModule(), RemoveExtensionStr);

  removeExtension(pszPath);

}

TSHPath::RemoveExtension(LPTSTR pszPath) {…}


BOOL


TSHPath::RemoveFileSpec(LPTSTR pszPath)

{

  static TModuleProc1<BOOL,LPTSTR>

         removeFileSpec(GetModule(), RemoveFileSpecStr);

  return removeFileSpec(pszPath);

}

TSHPath::RemoveFileSpec(LPTSTR pszPath) {…}


BOOL


TSHPath::RenameExtension(LPTSTR pszPath, LPCTSTR pszExt)

{

  static TModuleProc2<BOOL,LPTSTR,LPCTSTR>

         renameExtension(GetModule(), RenameExtensionStr);

  return renameExtension(pszPath, pszExt);

}

TSHPath::RenameExtension(LPTSTR pszPath, LPCTSTR pszExt) {…}


BOOL


TSHPath::SearchAndQualify(LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf)

{

  static TModuleProc3<BOOL,LPCTSTR,LPTSTR,UINT>

         searchAndQualify(GetModule(), SearchAndQualifyStr);

  return searchAndQualify(pszPath, pszBuf, cchBuf);

}

TSHPath::SearchAndQualify(LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf) {…}


void


TSHPath::SetDlgItemPath(HWND hDlg, int id, LPCTSTR pszPath)

{

  static TModuleProcV3<HWND,int,LPCTSTR>

         setDlgItemPath(GetModule(), SetDlgItemPathStr);

  setDlgItemPath(hDlg, id, pszPath);

}

TSHPath::SetDlgItemPath(HWND hDlg, int id, LPCTSTR pszPath) {…}


LPTSTR


TSHPath::SkipRoot(LPCTSTR pszPath)

{

  static TModuleProc1<LPTSTR,LPCTSTR>

         skipRoot(GetModule(), SkipRootStr);

  return skipRoot(pszPath);

}

TSHPath::SkipRoot(LPCTSTR pszPath) {…}


void


TSHPath::StripPath(LPTSTR pszPath)

{

  static TModuleProcV1<LPTSTR>

         stripPath(GetModule(), StripPathStr);

  stripPath(pszPath);

}

TSHPath::StripPath(LPTSTR pszPath) {…}


BOOL


TSHPath::StripToRoot(LPTSTR pszPath)

{

  static TModuleProc1<BOOL,LPTSTR>

         stripToRoot(GetModule(), StripToRootStr);

  return stripToRoot(pszPath);

}

TSHPath::StripToRoot(LPTSTR pszPath) {…}


void


TSHPath::UnquoteSpaces(LPTSTR lpsz)

{

  static TModuleProcV1<LPTSTR>

         unquoteSpaces(GetModule(), UnquoteSpacesStr);

  unquoteSpaces(lpsz);

}

TSHPath::UnquoteSpaces(LPTSTR lpsz) {…}


BOOL


TSHPath::MakeSystemFolder(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         makeSystemFolder(GetModule(), MakeSystemFolderStr);

  return makeSystemFolder(pszPath);

}

TSHPath::MakeSystemFolder(LPCTSTR pszPath) {…}


BOOL


TSHPath::UnmakeSystemFolder(LPCTSTR pszPath)

{

  static TModuleProc1<BOOL,LPCTSTR>

         unmakeSystemFolder(GetModule(), UnmakeSystemFolderStr);

  return unmakeSystemFolder(pszPath);

}

TSHPath::UnmakeSystemFolder(LPCTSTR pszPath) {…}


BOOL


TSHPath::IsSystemFolder(LPCTSTR pszPath, DWORD dwAttrb)

{

  static TModuleProc2<BOOL,LPCTSTR,DWORD>

         isSystemFolder(GetModule(), IsSystemFolderStr);

  return isSystemFolder(pszPath,dwAttrb);

}

TSHPath::IsSystemFolder(LPCTSTR pszPath, DWORD dwAttrb) {…}


void


TSHPath::Undecorate(LPTSTR pszPath)

{

  static TModuleProcV1<LPTSTR>

         undecorate(GetModule(), UndecorateStr);

  undecorate(pszPath);

}

TSHPath::Undecorate(LPTSTR pszPath) {…}


BOOL


TSHPath::UnExpandEnvStrings(LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf)

{

  static TModuleProc3<BOOL,LPCTSTR,LPTSTR,UINT>

         pathUnExpandEnvStrings(GetModule(), UnExpandEnvStringsStr);

  return pathUnExpandEnvStrings(pszPath, pszBuf, cchBuf);

}

TSHPath::UnExpandEnvStrings(LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf) {…}


BOOL


TSHPath::UnExpandEnvStringsForUser(HANDLE hToken, LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf)

{

  static TModuleProc4<BOOL,HANDLE,LPCTSTR,LPTSTR,UINT>

         pathUnExpandEnvStringsForUser(GetModule(), UnExpandEnvStringsForUserStr);

  return pathUnExpandEnvStringsForUser(hToken, pszPath, pszBuf, cchBuf);

}

TSHPath::UnExpandEnvStringsForUser(HANDLE hToken, LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf) {…}


} // OWL namespace

/* ========================================================================== */


VarType
Definition safearray.h:14

owl::TModule
ObjectWindows dynamic-link libraries (DLLs) construct an instance of TModule, which acts as an object...
Definition module.h:75

owl::TSHPath::UnExpandEnvStrings
static BOOL UnExpandEnvStrings(LPCTSTR pszPath, TCHAR *pszBuf, UINT cchBuf)
Takes a fully qualified path, and replaces several folder names with their associated environment str...
Definition shelwapi.cpp:725

owl::TSHPath::IsSystemFolder
static BOOL IsSystemFolder(LPCTSTR pszPath, DWORD dwAttrb)
Determines if an existing folder contains the attributes that make it a system folder.
Definition shelwapi.cpp:708

owl::TSHPath::IsPrefix
static BOOL IsPrefix(LPCTSTR pszPrefix, LPCTSTR pszPath)
Searches a path to determine if it contains a valid prefix of the type passed by pszPrefix.
Definition shelwapi.cpp:476

owl::TSHPath::RemoveBlanks
static void RemoveBlanks(TCHAR *pszPath)
Removes all leading and trailing spaces from a string.
Definition shelwapi.cpp:612

owl::TSHPath::FindOnPath
static BOOL FindOnPath(TCHAR *pszPath, LPCTSTR *ppszOtherDirs)
Searches for a file.
Definition shelwapi.cpp:404

owl::TSHPath::StripToRoot
static BOOL StripToRoot(TCHAR *pszPath)
Removes all parts of the path except for the root information.
Definition shelwapi.cpp:676

owl::TSHPath::RelativePathTo
static BOOL RelativePathTo(TCHAR *pszPath, LPCTSTR pszFrom, DWORD dwAttrFrom, LPCTSTR pszTo, DWORD dwAttrTo)
Creates a relative path from one file or folder to another.
Definition shelwapi.cpp:588

owl::TSHPath::FindExtension
static TCHAR * FindExtension(LPCTSTR pszPath)
Searches a path for an extension.
Definition shelwapi.cpp:380

owl::TSHPath::IsLFNFileSpec
static BOOL IsLFNFileSpec(LPCTSTR lpName)
Determines whether or not a file name is in long format.
Definition shelwapi.cpp:428

owl::TSHPath::IsNetworkPath
static BOOL IsNetworkPath(LPCTSTR pszPath)
Determines whether a path string represents a network resource.
Definition shelwapi.cpp:516

owl::TSHPath::FindNextComponent
static TCHAR * FindNextComponent(LPCTSTR pszPath)
Parses a path for the next path component.
Definition shelwapi.cpp:396

owl::TSHPath::ParseIconLocation
static int ParseIconLocation(TCHAR *pszIconFile)
Parses a file location string containing a file location and icon index, and returns separate values.
Definition shelwapi.cpp:572

owl::TSHPath::SetDlgItemPath
static void SetDlgItemPath(HWND hDlg, int id, LPCTSTR pszPath)
Sets the text of a child control in a window or dialog box, using PathCompactPath to make sure the pa...
Definition shelwapi.cpp:652

owl::TSHPath::MatchSpec
static BOOL MatchSpec(LPCTSTR pszFile, LPCTSTR pszSpec)
Searches a string using a DOS wild card match type.
Definition shelwapi.cpp:564

owl::TSHPath::IsUNCServer
static BOOL IsUNCServer(LPCTSTR pszPath)
Determines if a string is a valid UNC (universal naming convention) for a server path only.
Definition shelwapi.cpp:524

owl::TSHPath::RemoveArgs
static void RemoveArgs(TCHAR *pszPath)
Removes any arguments from a given path.
Definition shelwapi.cpp:596

owl::TSHPath::AddExtension
static BOOL AddExtension(TCHAR *pszPath, LPCTSTR pszExt)
Adds a file extension to a path string.
Definition shelwapi.cpp:308

owl::TSHPath::RemoveExtension
static void RemoveExtension(TCHAR *pszPath)
Removes the file extension from a path, if there is one.
Definition shelwapi.cpp:620

owl::TSHPath::UnExpandEnvStringsForUser
static BOOL UnExpandEnvStringsForUser(HANDLE hToken, LPCTSTR pszPath, TCHAR *pszBuf, UINT cchBuf)
Definition shelwapi.cpp:733

owl::TSHPath::GetDriveNumber
static int GetDriveNumber(LPCTSTR pszPath)
Searches a path for a drive letter within the range of 'A' to 'Z' and returns the corresponding drive...
Definition shelwapi.cpp:444

owl::TSHPath::QuoteSpaces
static void QuoteSpaces(TCHAR *lpsz)
Searches a path for spaces.
Definition shelwapi.cpp:580

owl::TSHPath::CommonPrefix
static int CommonPrefix(LPCTSTR pszFile1, LPCTSTR pszFile2, TCHAR *achPath)
Compares two paths to determine if they share a common prefix.
Definition shelwapi.cpp:364

owl::TSHPath::UnquoteSpaces
static void UnquoteSpaces(TCHAR *lpsz)
Removes quotes from the beginning and end of a path.
Definition shelwapi.cpp:684

owl::TSHPath::GetModule
static TModule & GetModule()
Definition shelwapi.cpp:293

owl::TSHPath::Undecorate
static void Undecorate(TCHAR *pszPath)
Removes the decoration from a path string.
Definition shelwapi.cpp:716

owl::TSHPath::SkipRoot
static TCHAR * SkipRoot(LPCTSTR pszPath)
Parses a path, ignoring the drive letter or UNC server/share path parts.
Definition shelwapi.cpp:660

owl::TSHPath::BuildRoot
static TCHAR * BuildRoot(TCHAR *pszRoot, int iDrive)
Creates a root path from a given drive number.
Definition shelwapi.cpp:324

owl::TSHPath::MakePretty
static BOOL MakePretty(TCHAR *pszPath)
Converts a path to all lowercase characters to give the path a consistent appearance.
Definition shelwapi.cpp:556

owl::TSHPath::Append
static BOOL Append(TCHAR *pszPath, LPCTSTR pMore)
Appends one path to the end of another.
Definition shelwapi.cpp:316

owl::TSHPath::IsDirectoryEmpty
static BOOL IsDirectoryEmpty(LPCTSTR pszPath)
Determines whether or not a specified path is an empty directory.
Definition shelwapi.cpp:460

owl::TSHPath::StripPath
static void StripPath(TCHAR *pszPath)
Removes the path portion of a fully qualified path and file.
Definition shelwapi.cpp:668

owl::TSHPath::AddBackslash
static TCHAR * AddBackslash(TCHAR *pszPath)
Adds a backslash to the end of a string to create the correct syntax for a path.
Definition shelwapi.cpp:300

owl::TSHPath::IsRoot
static BOOL IsRoot(LPCTSTR pszPath)
Parses a path to determine if it is a directory root.
Definition shelwapi.cpp:492

owl::TSHPath::IsContentType
static BOOL IsContentType(LPCTSTR pszPath, LPCTSTR pszContentType)
Determines if a file's registered content type matches the specified content type.
Definition shelwapi.cpp:540

owl::TSHPath::IsRelative
static BOOL IsRelative(LPCTSTR pszPath)
Searches a path and determines if it is relative.
Definition shelwapi.cpp:484

owl::TSHPath::RemoveFileSpec
static BOOL RemoveFileSpec(TCHAR *pszPath)
Removes the trailing file name and backslash from a path, if it has them.
Definition shelwapi.cpp:628

owl::TSHPath::IsFileSpec
static BOOL IsFileSpec(LPCTSTR pszPath)
Searches a path for any path delimiting characters (for example, ':' or '\' ).
Definition shelwapi.cpp:468

owl::TSHPath::GetArgs
static TCHAR * GetArgs(LPCTSTR pszPath)
Finds the command line arguments within a given path.
Definition shelwapi.cpp:412

owl::TSHPath::Canonicalize
static BOOL Canonicalize(TCHAR *pszBuf, LPCTSTR pszPath)
Canonicalizes a path.
Definition shelwapi.cpp:332

owl::TSHPath::CompactPath
static BOOL CompactPath(HDC hDC, TCHAR *pszPath, UINT dx)
Truncates a file path to fit within a given pixel width by replacing path components with ellipses.
Definition shelwapi.cpp:348

owl::TSHPath::IsURL
static BOOL IsURL(LPCTSTR pszPath)
Tests a given string to determine if it conforms to a valid URL format.
Definition shelwapi.cpp:548

owl::TSHPath::IsUNCServerShare
static BOOL IsUNCServerShare(LPCTSTR pszPath)
Determines if a string is a valid universal naming convention (UNC) share path, \\server\share.
Definition shelwapi.cpp:532

owl::TSHPath::IsUNC
static BOOL IsUNC(LPCTSTR pszPath)
Determines if the string is a valid UNC (universal naming convention) for a server and share path.
Definition shelwapi.cpp:508

owl::TSHPath::GetCharType
static UINT GetCharType(tchar ch)
Determines the type of character with respect to a path.
Definition shelwapi.cpp:436

owl::TSHPath::IsDirectory
static BOOL IsDirectory(LPCTSTR pszPath)
Verifies that a path is a valid directory.
Definition shelwapi.cpp:452

owl::TSHPath::FindSuffixArray
static LPCTSTR FindSuffixArray(LPCTSTR pszPath, const LPCTSTR *apszSuffix, int iArraySize)
Determines if a given file name has one of a list of suffixes.
Definition shelwapi.cpp:420

owl::TSHPath::FindFileName
static TCHAR * FindFileName(LPCTSTR pszPath)
Searches a path for a file name.
Definition shelwapi.cpp:388

owl::TSHPath::UnmakeSystemFolder
static BOOL UnmakeSystemFolder(LPCTSTR pszPath)
Removes the attributes from a folder that make it a system folder.
Definition shelwapi.cpp:700

owl::TSHPath::FileExists
static BOOL FileExists(LPCTSTR pszPath)
Determines whether a path to a file system object such as a file or directory is valid.
Definition shelwapi.cpp:372

owl::TSHPath::Combine
static TCHAR * Combine(TCHAR *pszDest, LPCTSTR pszDir, LPCTSTR pszFile)
Concatenates two strings that represent properly formed paths into one path, as well as any relative ...
Definition shelwapi.cpp:340

owl::TSHPath::MakeSystemFolder
static BOOL MakeSystemFolder(LPCTSTR pszPath)
Gives an existing folder the proper attributes to become a system folder.
Definition shelwapi.cpp:692

owl::TSHPath::RemoveBackslash
static TCHAR * RemoveBackslash(TCHAR *pszPath)
Removes the trailing backslash from a given path.
Definition shelwapi.cpp:604

owl::TSHPath::SearchAndQualify
static BOOL SearchAndQualify(LPCTSTR pszPath, TCHAR *pszBuf, UINT cchBuf)
Determines if a given path is correctly formatted and fully qualified.
Definition shelwapi.cpp:644

owl::TSHPath::RenameExtension
static BOOL RenameExtension(TCHAR *pszPath, LPCTSTR pszExt)
Replaces the extension of a file name with a new extension.
Definition shelwapi.cpp:636

owl::TSHPath::IsSameRoot
static BOOL IsSameRoot(LPCTSTR pszPath1, LPCTSTR pszPath2)
Compares two paths to determine if they have a common root component.
Definition shelwapi.cpp:500

owl::TSHPath::CompactPathEx
static BOOL CompactPathEx(TCHAR *pszOut, LPCTSTR pszSrc, UINT cchMax, DWORD dwFlags)
Definition shelwapi.cpp:356

owl::TSHReg::DeleteKey
static DWORD DeleteKey(HKEY hkey, LPCTSTR pszSubKey)
DeleteKey mimics RegDeleteKey as it behaves on Win95 - deletes a subkey and all its values and descen...
Definition shelwapi.cpp:72

owl::TSHReg::QueryInfoKey
static LONG QueryInfoKey(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen)
Retrieves information about a specified registry key.
Definition shelwapi.cpp:136

owl::TSHReg::SetValue
static DWORD SetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData)
Definition shelwapi.cpp:104

owl::TSHReg::CopyKey
static DWORD CopyKey(HKEY hkeySrc, LPCTSTR szSrcSubKey, HKEY hkeyDest, DWORD fReserved)
Recursively copies the subkeys and values of the source subkey to the destination key.
Definition shelwapi.cpp:145

owl::TSHReg::QueryValueEx
static DWORD QueryValueEx(HKEY hkey, LPCTSTR pszValue, LPDWORD pdwReserved, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
This functions work just like RegQueryValueEx, except if the data type is REG_EXPAND_SZ,...
Definition shelwapi.cpp:112

owl::TSHReg::DeleteEmptyKey
static DWORD DeleteEmptyKey(HKEY hkey, LPCTSTR pszSubKey)
DeleteEmptyKey mimics RegDeleteKey as it behaves on NT - delete the subkey only if it does not contai...
Definition shelwapi.cpp:64

owl::TSHReg::DuplicateKey
static HKEY DuplicateKey(HKEY hkey)
Duplicates a registry key's HKEY handle.
Definition shelwapi.cpp:80

owl::TSHReg::DeleteValue
static DWORD DeleteValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue)
These functions open the key, get/set/delete the value, then close the key.
Definition shelwapi.cpp:88

owl::TSHReg::EnumKeyEx
static LONG EnumKeyEx(HKEY hkey, DWORD dwIndex, TCHAR *pszName, LPDWORD pcchName)
Enumerates the subkeys of the specified open registry key.
Definition shelwapi.cpp:120

owl::TSHReg::GetValue
static DWORD GetValue(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
Definition shelwapi.cpp:96

owl::TSHReg::EnumValue
static LONG EnumValue(HKEY hkey, DWORD dwIndex, TCHAR *pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
Enumerates the values of the specified open registry key.
Definition shelwapi.cpp:128

owl::TSHReg::RegGetPath
static DWORD RegGetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, TCHAR *pszPath, DWORD dwFlags)
Retrieves a file path from the registry, expanding environment variables as needed.
Definition shelwapi.cpp:154

owl::TSHReg::GetModule
static TModule & GetModule()
Definition shelwapi.cpp:57

owl::TSHReg::RegSetPath
static DWORD RegSetPath(HKEY hkey, LPCTSTR pcszSubKey, LPCTSTR pcszValue, LPCTSTR pcszPath, DWORD dwFlags)
Takes a file path, replaces folder names with environment strings, and places the resulting string in...
Definition shelwapi.cpp:162

_T
#define _T(x)
Definition cygwin.h:51

pch.h

module.h
Definition of class TModule.

owl
Object Windows Library (OWLNext Core)
Definition animctrl.h:22

owl::tchar
char tchar
Definition defs.h:77

defs.h
General definitions used by all ObjectWindows programs.

shelwapi.h
Definitions of Windows light-weight utility APIs: TSHReg, TSHPath.