VST3::Hosting::anonymous_namespace{module_win32.cpp} Namespace Reference

Classes
struct	Ole
class	Win32Module

Functions
bool	checkVST3Package (filesystem::path &p)
bool	isFolderSymbolicLink (const filesystem::path &p)
Optional< std::string >	getKnownFolder (REFKNOWNFOLDERID folderID)
VST3::Optional< filesystem::path >	resolveShellLink (const filesystem::path &p)
void	findFilesWithExt (const filesystem::path &path, const std::string &ext, Module::PathList &pathList, bool recursive=true)
void	findModules (const filesystem::path &path, Module::PathList &pathList)
Optional< filesystem::path >	getContentsDirectoryFromModuleExecutablePath (const std::string &modulePath)

Variables
constexpr auto	architectureString = "x86-win"

Function Documentation

checkVST3Package()

bool VST3::Hosting::anonymous_namespace{module_win32.cpp}::checkVST3Package

(

filesystem::path &

p

)

Definition at line 193 of file module_win32.cpp.

{
   auto filename = p.filename ();
   p /= "Contents";
   p /= architectureString;
   p /= filename;
   auto hFile = CreateFileW (reinterpret_cast<LPCWSTR> (p.c_str ()), GENERIC_READ, FILE_SHARE_READ,
                             nullptr, OPEN_EXISTING, 0, nullptr);
   if (hFile != INVALID_HANDLE_VALUE)
   {
      CloseHandle (hFile);
      return true;
   }
   return false;
}

References architectureString.

Referenced by findFilesWithExt().

Here is the caller graph for this function:

findFilesWithExt()

void VST3::Hosting::anonymous_namespace{module_win32.cpp}::findFilesWithExt	(	const filesystem::path &	path,
		const std::string &	ext,
		Module::PathList &	pathList,
		bool	recursive = true
	)

Definition at line 289 of file module_win32.cpp.

{
   for (auto& p : filesystem::directory_iterator (path))
   {
#if USE_FILESYSTEM
      filesystem::path finalPath (p);
      if (isFolderSymbolicLink (p))
      {
         if (auto res = resolveShellLink (p))
         {
            finalPath = *res;
            if (!filesystem::exists (finalPath))
               continue;
         }
         else
            continue;
      }
      const auto& cpExt = finalPath.extension ();
      if (cpExt == ext)
      {
         filesystem::path vstPath (finalPath);
         if (checkVST3Package (vstPath))
         {
            pathList.push_back (vstPath.generic_string ());
            continue;
         }
      }
 
      if (filesystem::is_directory (finalPath))
      {
         if (recursive)
            findFilesWithExt (finalPath, ext, pathList, recursive);
      }
      else if (cpExt == ext)
         pathList.push_back (finalPath.generic_string ());
#else
      const auto& cp = p.path ();
      const auto& cpExt = cp.extension ();
      if (cpExt == ext)
      {
         if ((p.status ().type () == filesystem::file_type::directory) ||
             isFolderSymbolicLink (p))
         {
            filesystem::path finalPath (p);
            if (checkVST3Package (finalPath))
            {
               pathList.push_back (finalPath.generic_u8string ());
               continue;
            }
            findFilesWithExt (cp, ext, pathList, recursive);
         }
         else
            pathList.push_back (cp.generic_u8string ());
      }
      else if (recursive)
      {
         if (p.status ().type () == filesystem::file_type::directory)
         {
            findFilesWithExt (cp, ext, pathList, recursive);
         }
         else if (cpExt == ".lnk")
         {
            if (auto resolvedLink = resolveShellLink (cp))
            {
               if (resolvedLink->extension () == ext)
               {
                  if (filesystem::is_directory (*resolvedLink) ||
                      isFolderSymbolicLink (*resolvedLink))
                  {
                     filesystem::path finalPath (*resolvedLink);
                     if (checkVST3Package (finalPath))
                     {
                        pathList.push_back (finalPath.generic_u8string ());
                        continue;
                     }
                     findFilesWithExt (*resolvedLink, ext, pathList, recursive);
                  }
                  else
                     pathList.push_back (resolvedLink->generic_u8string ());
               }
               else if (filesystem::is_directory (*resolvedLink))
               {
                  const auto& str = resolvedLink->generic_u8string ();
                  if (cp.generic_u8string ().compare (0, str.size (), str.data (),
                                                      str.size ()) != 0)
                     findFilesWithExt (*resolvedLink, ext, pathList, recursive);
               }
            }
         }
      }
#endif
   }
}

References checkVST3Package(), findFilesWithExt(), isFolderSymbolicLink(), resolveShellLink(), and str.

Referenced by findFilesWithExt(), and findModules().

Here is the call graph for this function:

Here is the caller graph for this function:

findModules()

void VST3::Hosting::anonymous_namespace{module_win32.cpp}::findModules	(	const filesystem::path &	path,
		Module::PathList &	pathList
	)

Definition at line 385 of file module_win32.cpp.

{
   if (filesystem::exists (path))
      findFilesWithExt (path, ".vst3", pathList);
}

References findFilesWithExt().

Here is the call graph for this function:

getContentsDirectoryFromModuleExecutablePath()

Optional< filesystem::path > VST3::Hosting::anonymous_namespace{module_win32.cpp}::getContentsDirectoryFromModuleExecutablePath

(

const std::string &

modulePath

)

Definition at line 392 of file module_win32.cpp.

{
   filesystem::path path (modulePath);
 
   path = path.parent_path ();
   if (path.filename () != architectureString)
      return {};
   path = path.parent_path ();
   if (path.filename () != "Contents")
      return {};
 
   return Optional<filesystem::path> {std::move (path)};
}

References architectureString.

getKnownFolder()

Optional< std::string > VST3::Hosting::anonymous_namespace{module_win32.cpp}::getKnownFolder

(

REFKNOWNFOLDERID

folderID

)

Definition at line 232 of file module_win32.cpp.

{
   PWSTR wideStr {};
   if (FAILED (SHGetKnownFolderPath (folderID, 0, nullptr, &wideStr)))
      return {};
   return StringConvert::convert (wideStr);
}

isFolderSymbolicLink()

bool VST3::Hosting::anonymous_namespace{module_win32.cpp}::isFolderSymbolicLink

(

const filesystem::path &

p

)

Definition at line 210 of file module_win32.cpp.

{
#if USE_FILESYSTEM
   if (/*filesystem::exists (p) &&*/ filesystem::is_symlink (p))
      return true;
#else
   std::wstring wString = p.generic_wstring ();
   auto attrib = GetFileAttributesW (reinterpret_cast<LPCWSTR> (wString.c_str ()));
   if (attrib & FILE_ATTRIBUTE_REPARSE_POINT)
   {
      auto hFile = CreateFileW (reinterpret_cast<LPCWSTR> (wString.c_str ()), GENERIC_READ,
                                FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
      if (hFile == INVALID_HANDLE_VALUE)
         return true;
      else
         CloseHandle (hFile);
   }
#endif
   return false;
}

Referenced by findFilesWithExt().

Here is the caller graph for this function:

resolveShellLink()

VST3::Optional< filesystem::path > VST3::Hosting::anonymous_namespace{module_win32.cpp}::resolveShellLink

(

const filesystem::path &

p

)

Definition at line 241 of file module_win32.cpp.

{
#if USE_FILESYSTEM
   return {filesystem::read_symlink (p)};
#else
#if USE_OLE
   Ole::instance ();
 
   IShellLink* shellLink = nullptr;
   if (!SUCCEEDED (CoCreateInstance (CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
                                     IID_IShellLink, reinterpret_cast<LPVOID*> (&shellLink))))
      return {};
 
   IPersistFile* persistFile = nullptr;
   if (!SUCCEEDED (
           shellLink->QueryInterface (IID_IPersistFile, reinterpret_cast<void**> (&persistFile))))
      return {};
 
   if (!SUCCEEDED (persistFile->Load (p.wstring ().data (), STGM_READ)))
      return {};
 
   if (!SUCCEEDED (shellLink->Resolve (nullptr, MAKELONG (SLR_NO_UI, 500))))
      return {};
 
   WCHAR resolvedPath[MAX_PATH];
   if (!SUCCEEDED (shellLink->GetPath (resolvedPath, MAX_PATH, nullptr, SLGP_SHORTPATH)))
      return {};
 
   std::wstring longPath;
   longPath.resize (MAX_PATH);
   auto numChars =
       GetLongPathNameW (resolvedPath, const_cast<wchar_t*> (longPath.data ()), MAX_PATH);
   if (!numChars)
      return {};
   longPath.resize (numChars);
 
   persistFile->Release ();
   shellLink->Release ();
 
   return {filesystem::path (longPath)};
#else
   // TODO for ARM
   return {};
#endif
#endif
}

Referenced by findFilesWithExt().

Here is the caller graph for this function:

Variable Documentation

architectureString

constexpr auto VST3::Hosting::anonymous_namespace{module_win32.cpp}::architectureString = "x86-win"

constexpr

Definition at line 96 of file module_win32.cpp.

Referenced by checkVST3Package(), getContentsDirectoryFromModuleExecutablePath(), and VST3::Hosting::anonymous_namespace{module_win32.cpp}::Win32Module::load().