bool FVisualStudioSourceCodeAccessor::AddSourceFiles(const TArray<FString>& AbsoluteSourcePaths, const TArray<FString>& AvailableModules)
{
// This requires DTE - there is no fallback for this operation when DTE is not available
#if VSACCESSOR_HAS_DTE
bool bSuccess = true;
struct FModuleNameAndPath
{
FString ModuleBuildFilePath;
FString ModulePath;
FName ModuleName;
};
TArray<FModuleNameAndPath> ModuleNamesAndPaths;
ModuleNamesAndPaths.Reserve(AvailableModules.Num());
for (const FString& AvailableModule : AvailableModules)
{
static const int32 BuildFileExtensionLen = FString(TEXT(".Build.cs")).Len();
// AvailableModule is the relative path to the .Build.cs file
FModuleNameAndPath ModuleNameAndPath;
ModuleNameAndPath.ModuleBuildFilePath = FPaths::ConvertRelativePathToFull(AvailableModule);
ModuleNameAndPath.ModulePath = FPaths::GetPath(ModuleNameAndPath.ModuleBuildFilePath);
ModuleNameAndPath.ModuleName = *FPaths::GetCleanFilename(ModuleNameAndPath.ModuleBuildFilePath).LeftChop(BuildFileExtensionLen);
ModuleNamesAndPaths.Add(ModuleNameAndPath);
}
struct FModuleNewSourceFiles
{
FModuleNameAndPath ModuleNameAndPath;
TArray<FString> NewSourceFiles;
};
// Work out which module each source file will be in
TMap<FName, FModuleNewSourceFiles> ModuleToNewSourceFiles;
{
const FModuleNameAndPath* LastSourceFilesModule = nullptr;
for (const FString& SourceFile : AbsoluteSourcePaths)
{
// First check to see if this source file is in the same module as the last source file - this is usually the case, and saves us a lot of string compares
if (LastSourceFilesModule && SourceFile.StartsWith(LastSourceFilesModule->ModulePath))
{
FModuleNewSourceFiles& ModuleNewSourceFiles = ModuleToNewSourceFiles.FindChecked(LastSourceFilesModule->ModuleName);
ModuleNewSourceFiles.NewSourceFiles.Add(SourceFile);
continue;
}
// Look for the module which will contain this file
LastSourceFilesModule = nullptr;
for (const FModuleNameAndPath& ModuleNameAndPath : ModuleNamesAndPaths)
{
if (SourceFile.StartsWith(ModuleNameAndPath.ModulePath))
{
LastSourceFilesModule = &ModuleNameAndPath;
FModuleNewSourceFiles& ModuleNewSourceFiles = ModuleToNewSourceFiles.FindOrAdd(ModuleNameAndPath.ModuleName);
ModuleNewSourceFiles.ModuleNameAndPath = ModuleNameAndPath;
ModuleNewSourceFiles.NewSourceFiles.Add(SourceFile);
break;
}
}
// Failed to find the module for this source file?
if (!LastSourceFilesModule)
{
UE_LOG(LogVSAccessor, Warning, TEXT("Cannot add source file '%s' as it doesn't belong to a known module"), *SourceFile);
bSuccess = false;
}
}
}
TComPtr<EnvDTE::_DTE> DTE;
const FString SolutionPath = GetSolutionPath();
if (AccessVisualStudioViaDTE(DTE, SolutionPath, GetPrioritizedVisualStudioVersions(SolutionPath)) == EAccessVisualStudioResult::VSInstanceIsOpen)
{
TComPtr<EnvDTE::_Solution> Solution;
if (SUCCEEDED(DTE->get_Solution(&Solution)) && Solution)
{
// Process each module
for (const auto& ModuleNewSourceFilesKeyValue : ModuleToNewSourceFiles)
{
const FModuleNewSourceFiles& ModuleNewSourceFiles = ModuleNewSourceFilesKeyValue.Value;
const FString& ModuleBuildFilePath = ModuleNewSourceFiles.ModuleNameAndPath.ModuleBuildFilePath;
auto ANSIModuleBuildFilePath = StringCast<ANSICHAR>(*ModuleBuildFilePath);
FComBSTR COMStrModuleBuildFilePath(ANSIModuleBuildFilePath.Get());
TComPtr<EnvDTE::ProjectItem> BuildFileProjectItem;
if (SUCCEEDED(Solution->FindProjectItem(COMStrModuleBuildFilePath, &BuildFileProjectItem)) && BuildFileProjectItem)
{
// We found the .Build.cs file in the existing solution - now we need its parent ProjectItems as that's what we'll be adding new content to
TComPtr<EnvDTE::ProjectItems> ModuleProjectFolder;
if (SUCCEEDED(BuildFileProjectItem->get_Collection(&ModuleProjectFolder)) && ModuleProjectFolder)
{
for (const FString& SourceFile : AbsoluteSourcePaths)
{
const FString ProjectRelativeSourceFilePath = SourceFile.Mid(ModuleNewSourceFiles.ModuleNameAndPath.ModulePath.Len());
TArray<FString> SourceFileParts;
ProjectRelativeSourceFilePath.ParseIntoArray(SourceFileParts, TEXT("/"), true);
if (SourceFileParts.Num() == 0)
{
// This should never happen as it means we somehow have no filename within the project directory
bSuccess = false;
continue;
}
TComPtr<EnvDTE::ProjectItems> CurProjectItems = ModuleProjectFolder;
// Firstly we need to make sure that all the folders we need exist - this also walks us down to the correct place to add the file
for (int32 FilePartIndex = 0; FilePartIndex < SourceFileParts.Num() - 1 && CurProjectItems; ++FilePartIndex)
{
const FString& SourceFilePart = SourceFileParts[FilePartIndex];
auto ANSIPart = StringCast<ANSICHAR>(*SourceFilePart);
FComBSTR COMStrFilePart(ANSIPart.Get());
::VARIANT vProjectItemName;
vProjectItemName.vt = VT_BSTR;
vProjectItemName.bstrVal = COMStrFilePart;
TComPtr<EnvDTE::ProjectItem> ProjectItem;
if (SUCCEEDED(CurProjectItems->Item(vProjectItemName, &ProjectItem)) && !ProjectItem)
{
// Add this part
CurProjectItems->AddFolder(COMStrFilePart, nullptr, &ProjectItem);
}
if (ProjectItem)
{
ProjectItem->get_ProjectItems(&CurProjectItems);
}
else
{
CurProjectItems = nullptr;
}
}
if (!CurProjectItems)
{
// Failed to find or add all the path parts
bSuccess = false;
continue;
}
// Now we add the file to the project under the last folder we found along its path
auto ANSIPath = StringCast<ANSICHAR>(*SourceFile);
FComBSTR COMStrFileName(ANSIPath.Get());
TComPtr<EnvDTE::ProjectItem> FileProjectItem;
if (SUCCEEDED(CurProjectItems->AddFromFile(COMStrFileName, &FileProjectItem)))
{
bSuccess &= true;
}
}
// Save the updated project to avoid a message when closing VS
TComPtr<EnvDTE::Project> Project;
if (SUCCEEDED(ModuleProjectFolder->get_ContainingProject(&Project)) && Project)
{
Project->Save(nullptr);
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Cannot add source files as we failed to get the parent items container for the '%s' item"), *ModuleBuildFilePath);
bSuccess = false;
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Cannot add source files as we failed to find '%s' in the solution"), *ModuleBuildFilePath);
bSuccess = false;
}
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Cannot add source files as Visual Studio failed to return a solution when queried"));
bSuccess = false;
}
}
else
{
UE_LOG(LogVSAccessor, Verbose, TEXT("Cannot add source files as Visual Studio is either not open or not responding"));
bSuccess = false;
}
return bSuccess;
#endif
return false;
}
bool FVSAccessorModule::OpenVisualStudioFileAtLineInternal(const FString& FullPath, int32 LineNumber, int32 ColumnNumber)
{
// Check that the file actually exists first
if (!FPaths::FileExists(FullPath))
{
OpenFileFailed.Broadcast(FullPath);
return false;
}
// Initialize the com library, if not already by this thread
if (!FWindowsPlatformMisc::CoInitialize())
{
UE_LOG(LogVSAccessor, Error, TEXT( "ERROR - Could not initialize COM library!" ));
return false;
}
bool bDefer = false, bSuccess = false;
CComPtr<EnvDTE::_DTE> DTE;
if (AccessVisualStudio(DTE, SolutionPath, Locations))
{
// Set Focus on Visual Studio
CComPtr<EnvDTE::Window> MainWindow;
if (SUCCEEDED(DTE->get_MainWindow(&MainWindow)) &&
SUCCEEDED(MainWindow->Activate()))
{
// Get ItemOperations
CComPtr<EnvDTE::ItemOperations> ItemOperations;
if (SUCCEEDED(DTE->get_ItemOperations(&ItemOperations)))
{
// Open File
auto ANSIPath = StringCast<ANSICHAR>(*FullPath);
CComBSTR COMStrFileName(ANSIPath.Get());
CComBSTR COMStrKind(EnvDTE::vsViewKindTextView);
CComPtr<EnvDTE::Window> Window;
if (SUCCEEDED(ItemOperations->OpenFile(COMStrFileName, COMStrKind, &Window)))
{
// Scroll to Line Number
CComPtr<EnvDTE::Document> Document;
CComPtr<IDispatch> SelectionDispatch;
CComPtr<EnvDTE::TextSelection> Selection;
if (SUCCEEDED(DTE->get_ActiveDocument(&Document)) &&
SUCCEEDED(Document->get_Selection(&SelectionDispatch)) &&
SUCCEEDED(SelectionDispatch->QueryInterface(&Selection)) &&
SUCCEEDED(Selection->GotoLine(LineNumber, true)))
{
if (ColumnNumber > 0 &&
SUCCEEDED(Selection->MoveToLineAndOffset(LineNumber, ColumnNumber, false)))
{
bSuccess = true;
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't goto column number '%i' of line '%i' in '%s'"), ColumnNumber, LineNumber, *FullPath);
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't goto line number '%i' in '%s'"), LineNumber, *FullPath);
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't open file '%s'."), *FullPath);
}
VSLaunchFinished( true );
}
else
{
UE_LOG(LogVSAccessor, Log, TEXT("Couldn't get item operations. Visual Studio may still be initializing."), *FullPath);
bDefer = true;
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't set focus on Visual Studio."));
}
}
else
{
bDefer = true;
// We can't process until we're in the main thread, if we aren't initially defer until we are
if ( IsInGameThread() )
{
// If we haven't already attempted to launch VS do so now
if (!IsVSLaunchInProgress())
{
// If there's no valid instance of VS running, run one if we have it installed
if ( !RunVisualStudioAndOpenSolution() )
{
bDefer = false;
}
else
{
VSLaunchStarted();
}
}
}
}
// If we have attempted to launch VS, and it's taken too long, timeout so the user can try again
if ( IsVSLaunchInProgress() && ( FPlatformTime::Seconds() - VSLaunchTime ) > 300 )
{
// We need todo this incase the process died or was kill prior to the code gaining focus of it
bDefer = false;
VSLaunchFinished( false );
// We failed to open the solution and file, so lets just use the platforms default opener.
FPlatformProcess::LaunchFileInDefaultExternalApplication( *FullPath );
}
// Defer the request until VS is available to take hold of
if ( bDefer )
{
const FString DeferCommand = FString::Printf( TEXT( "OPEN_VS %s %d %d" ), *FullPath, LineNumber, ColumnNumber);
LaunchVSDeferred.Broadcast( DeferCommand );
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't access Visual Studio"));
}
// Uninitialize the com library, if we initialized it above (don't call if S_FALSE)
FWindowsPlatformMisc::CoUninitialize();
return bSuccess;
}
bool FVisualStudioSourceCodeAccessor::OpenVisualStudioFilesInternalViaDTE(const TArray<FileOpenRequest>& Requests, bool& bWasDeferred)
{
ISourceCodeAccessModule& SourceCodeAccessModule = FModuleManager::LoadModuleChecked<ISourceCodeAccessModule>(TEXT("SourceCodeAccess"));
// Initialize the com library, if not already by this thread
if (!FWindowsPlatformMisc::CoInitialize())
{
UE_LOG(LogVSAccessor, Error, TEXT( "ERROR - Could not initialize COM library!" ));
return false;
}
bool bDefer = false, bSuccess = false;
TComPtr<EnvDTE::_DTE> DTE;
const FString SolutionPath = GetSolutionPath();
switch (AccessVisualStudioViaDTE(DTE, SolutionPath, GetPrioritizedVisualStudioVersions(SolutionPath)))
{
case EAccessVisualStudioResult::VSInstanceIsOpen:
{
// Set Focus on Visual Studio
TComPtr<EnvDTE::Window> MainWindow;
if (SUCCEEDED(DTE->get_MainWindow(&MainWindow)) &&
SUCCEEDED(MainWindow->Activate()))
{
// Get ItemOperations
TComPtr<EnvDTE::ItemOperations> ItemOperations;
if (SUCCEEDED(DTE->get_ItemOperations(&ItemOperations)))
{
for ( const FileOpenRequest& Request : Requests )
{
// Check that the file actually exists first
if ( !FPaths::FileExists(Request.FullPath) )
{
SourceCodeAccessModule.OnOpenFileFailed().Broadcast(Request.FullPath);
bSuccess |= false;
continue;
}
// Open File
auto ANSIPath = StringCast<ANSICHAR>(*Request.FullPath);
FComBSTR COMStrFileName(ANSIPath.Get());
FComBSTR COMStrKind(EnvDTE::vsViewKindTextView);
TComPtr<EnvDTE::Window> Window;
if ( SUCCEEDED(ItemOperations->OpenFile(COMStrFileName, COMStrKind, &Window)) )
{
// If we've made it this far - we've opened the file. it doesn't matter if
// we successfully get to the line number. Everything else is gravy.
bSuccess |= true;
// Scroll to Line Number
TComPtr<EnvDTE::Document> Document;
TComPtr<IDispatch> SelectionDispatch;
TComPtr<EnvDTE::TextSelection> Selection;
if ( SUCCEEDED(DTE->get_ActiveDocument(&Document)) &&
SUCCEEDED(Document->get_Selection(&SelectionDispatch)) &&
SelectionDispatch && SUCCEEDED(SelectionDispatch->QueryInterface(&Selection)) &&
SUCCEEDED(Selection->GotoLine(Request.LineNumber, VARIANT_TRUE)) )
{
if ( !SUCCEEDED(Selection->MoveToLineAndOffset(Request.LineNumber, Request.ColumnNumber, false)) )
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't goto column number '%i' of line '%i' in '%s'"), Request.ColumnNumber, Request.LineNumber, *Request.FullPath);
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't goto line number '%i' in '%s'"), Request.LineNumber, *Request.FullPath);
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't open file '%s'."), *Request.FullPath);
}
}
VSLaunchFinished( true );
}
else
{
UE_LOG(LogVSAccessor, Log, TEXT("Couldn't get item operations. Visual Studio may still be initializing."));
bDefer = true;
}
}
else
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't set focus on Visual Studio."));
}
}
break;
case EAccessVisualStudioResult::VSInstanceIsNotOpen:
{
bDefer = true;
// We can't process until we're in the main thread, if we aren't initially defer until we are
if ( IsInGameThread() )
{
// If we haven't already attempted to launch VS do so now
if ( !IsVSLaunchInProgress() )
{
// If there's no valid instance of VS running, run one if we have it installed
if ( !RunVisualStudioAndOpenSolution() )
{
bDefer = false;
}
else
{
VSLaunchStarted();
}
}
}
}
break;
case EAccessVisualStudioResult::VSInstanceIsBlocked:
{
// VS may be open for the solution we want, but we can't query it right now as it's blocked for some reason
// Defer this operation so we can try it again later should VS become unblocked
bDefer = true;
}
break;
default:
// Do nothing if we failed the VS detection, otherwise we could get stuck in a loop of constantly
// trying to open a VS instance since we can't detect that one is already running
bDefer = false;
break;
}
if ( !bSuccess )
{
// If we have attempted to launch VS, and it's taken too long, timeout so the user can try again
if ( IsVSLaunchInProgress() && ( FPlatformTime::Seconds() - VSLaunchTime ) > 300 )
{
// We need todo this in case the process died or was kill prior to the code gaining focus of it
bDefer = false;
VSLaunchFinished(false);
// We failed to open the solution and file, so lets just use the platforms default opener.
for ( const FileOpenRequest& Request : Requests )
{
FPlatformProcess::LaunchFileInDefaultExternalApplication(*Request.FullPath);
}
}
// Defer the request until VS is available to take hold of
if ( bDefer )
{
FScopeLock Lock(&DeferredRequestsCriticalSection);
DeferredRequests.Append(Requests);
}
else if ( !bSuccess )
{
UE_LOG(LogVSAccessor, Warning, TEXT("Couldn't access Visual Studio"));
}
}
// Uninitialize the com library, if we initialized it above (don't call if S_FALSE)
FWindowsPlatformMisc::CoUninitialize();
bWasDeferred = bDefer;
return bSuccess;
}
