public static void SetIncludesForNewProject(VCProject vcProject,
CompilerSpecificationCommandResult compilerSpecsCommandResult,
ProjectInformationCommandResult projectInformation)
{
(IEnumerable <CompilerMacroResult> macros, IEnumerable <string> includes) =
ProjectIncludesManager.FindMacrosAndIncludesForMinTarget(compilerSpecsCommandResult,
projectInformation);
if (macros == null)
{
macros = Enumerable.Empty <CompilerMacroResult>();
}
if (includes == null)
{
includes = Enumerable.Empty <string>();
}
foreach (VCConfiguration2 config in vcProject.Configurations)
{
IVCRulePropertyStorage plcnextCommonPropertiesRule = config.Rules.Item(Constants.PLCnextRuleName);
if (plcnextCommonPropertiesRule == null)
{
MessageBox.Show("PLCnextCommonProperties rule was not found in configuration rules collection.");
}
string joinedMacros = macros.Any() ? string.Join(";",
macros.Select(m => m.Name + (string.IsNullOrEmpty(m.Value.Trim()) ? null : "=" + m.Value)))
: string.Empty;
string joinedIncludes = includes.Any() ? string.Join(";", includes) : string.Empty;
plcnextCommonPropertiesRule.SetPropertyValue(Constants.PLCnextMacrosKey, joinedMacros);
plcnextCommonPropertiesRule.SetPropertyValue(Constants.PLCnextIncludesKey, joinedIncludes);
}
}
private void FetchProjectComponents()
{
ProjectInformationCommandResult projectInformation = _plcncliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_no_include_detection,
Resources.Option_get_project_information_project, $"\"{_projectDirectory}\"") as ProjectInformationCommandResult;
if (projectInformation != null)
{
Components = projectInformation.Entities.Where(e => e.Type.Equals("component"))
.Select(e => $"{e.Namespace}::{e.Name}");
SelectedNamespace = projectInformation.Namespace;
}
}
FindMacrosAndIncludesForMinTarget(CompilerSpecificationCommandResult compilerSpecsCommandResult,
ProjectInformationCommandResult projectInformation)
{
IEnumerable <CompilerMacroResult> macros = Enumerable.Empty <CompilerMacroResult>();
IEnumerable <string> includes = Enumerable.Empty <string>();
TargetResult minCompilerTarget = FindMinTargetForMacros(compilerSpecsCommandResult);
if (minCompilerTarget != null)
{
macros = GetMacrosForTarget(minCompilerTarget, compilerSpecsCommandResult);
}
TargetResult minIncludeTarget = FindMinTargetForIncludes(projectInformation);
includes = GetIncludesForTarget(minIncludeTarget, projectInformation);
return(macros, includes);
}
public ProjectTargetValueEditorModel(IServiceProvider serviceProvider, string projectDirectory)
{
this.serviceProvider = serviceProvider;
IPlcncliCommunication cliCommunication = serviceProvider.GetService(typeof(SPlcncliCommunication)) as IPlcncliCommunication;
if (cliCommunication != null)
{
TargetsCommandResult targetsCommandResult =
cliCommunication.ExecuteCommand(Resources.Command_get_targets, null, typeof(TargetsCommandResult))
as TargetsCommandResult;
InstalledTargets = targetsCommandResult.Targets;
ProjectInformationCommandResult projectInfo = cliCommunication.ExecuteCommand(
Resources.Command_get_project_information, null, typeof(ProjectInformationCommandResult),
Resources.Option_get_project_information_no_include_detection,
Resources.Option_get_project_information_project, $"\"{projectDirectory}\"") as
ProjectInformationCommandResult;
ProjectTargets = projectInfo.Targets;
//TODO extract these commands somewhere after the viewModel.Showmodal call (and possibly asyncron), otherwise the ui seems to be too unresponsive
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void Import(object sender, EventArgs e)
{
DTE2 dte = Package.GetGlobalService(typeof(DTE)) as DTE2;
try
{
bool closed = SolutionSaveService.SaveAndCloseSolution(dte.Solution);
if (!closed)
{
return;
}
}
catch (Exception exception)
{
MessageBox.Show($"Project import could not be started:\n{exception.Message}", "Import failed");
return;
}
ThreadHelper.JoinableTaskFactory.Run(
"Importing project",
async(progress) =>
{
if (_plcncliCommunication == null)
{
MessageBox.Show("Could not import project because no plcncli communication found.");
}
string projectFilePath = string.Empty;
if (OpenImportWizard())
{
string projectDirectory = Path.GetDirectoryName(projectFilePath);
progress.Report(new ThreadedWaitDialogProgressData("Fetching project information."));
ProjectInformationCommandResult projectInformation = await GetProjectInformation();
if (projectInformation == null)
{
return;
}
string projectName = projectInformation.Name;
string projectType = projectInformation.Type;
IEnumerable <TargetResult> projectTargets = projectInformation.Targets;
await CreateVSProject(projectType, projectDirectory, projectName, projectTargets);
MessageBox.Show("If the imported project has source folders different from the standard 'src', they have to be set manually in the project properties.",
"Successfully imported project", MessageBoxButton.OK, MessageBoxImage.Information);
}
bool OpenImportWizard()
{
ImportDialogModel model = new ImportDialogModel();
ImportDialogViewModel viewModel = new ImportDialogViewModel(model);
ImportDialogView view = new ImportDialogView(viewModel);
view.ShowModal();
if (view.DialogResult == true)
{
projectFilePath = model.ProjectFilePath;
return(true);
}
return(false);
}
async Task <ProjectInformationCommandResult> GetProjectInformation()
{
ProjectInformationCommandResult result = null;
await Task.Run(() =>
{
try
{
result = _plcncliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project,
$"\"{projectFilePath}\"") as ProjectInformationCommandResult;
}
catch (PlcncliException ex)
{
result = _plcncliCommunication.ConvertToTypedCommandResult <ProjectInformationCommandResult>(ex.InfoMessages);
throw ex;
}
});
return(result);
}
async Task CreateVSProject(string projectType, string projectDirectory, string projectName, IEnumerable <TargetResult> projectTargets)
{
progress.Report(new ThreadedWaitDialogProgressData("Creating project files."));
bool projectFileCreated = await CreateVSProjectFile();
if (!projectFileCreated)
{
return;
}
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
dte.Solution.Create(projectDirectory, projectName);
dte.Solution.AddFromFile($"{Path.Combine(projectDirectory, projectName)}.vcxproj");
Project project = null;
foreach (Project proj in dte.Solution.Projects)
{
if (proj.Name.Equals(projectName))
{
project = proj;
break;
}
}
if (project == null)
{
MessageBox.Show("Something went wrong during creation of new project. Project was not found in solution.");
return;
}
progress.Report(new ThreadedWaitDialogProgressData("Creating project configurations."));
ProjectConfigurationManager.CreateConfigurationsForAllProjectTargets
(projectTargets.Select(t => t.GetNameFormattedForCommandLine()), project);
//**********delete intermediate**********
string intermediateFolder = Path.Combine(projectDirectory, "intermediate");
if (Directory.Exists(intermediateFolder))
{
Directory.Delete(intermediateFolder, true);
}
//**********add project items to project**********
IEnumerable <string> directories = Directory.GetDirectories(projectDirectory).Where(d => !d.EndsWith("bin"));
IEnumerable <string> projectFiles =
Directory.GetFiles(projectDirectory, "*.*pp", SearchOption.TopDirectoryOnly)
.Concat(Directory.GetFiles(projectDirectory, "*.txt", SearchOption.TopDirectoryOnly))
.Where(f => !f.EndsWith("UndefClang.hpp"))
.Concat(directories.SelectMany(d => Directory.GetFiles(d, "*.*pp", SearchOption.AllDirectories)
.Concat(Directory.GetFiles(d, "*.txt", SearchOption.AllDirectories)))
.Where(f => !f.EndsWith("UndefClang.hpp"))
);
foreach (string file in projectFiles)
{
project.ProjectItems.AddFromFile(file);
}
progress.Report(new ThreadedWaitDialogProgressData("Generating intermediate code."));
GenerateCode();
progress.Report(new ThreadedWaitDialogProgressData("Setting includes and macros."));
SetIncludesAndMacros();
project.Save();
async Task <bool> CreateVSProjectFile()
{
string filePath = Path.Combine(projectDirectory, $"{projectName}.vcxproj");
if (File.Exists(filePath))
{
MessageBox.Show($"Project creation failed because the file {filePath} already exists.");
return(false);
}
string additionalPropertiesKey = "additionalproperties";
string projectTypeKey = "projecttype";
string targetsFileNameKey = "targetsfilename";
Dictionary <string, string> replacementDictionary = new Dictionary <string, string>
{
{ additionalPropertiesKey, string.Empty },
{ projectTypeKey, projectType }
};
if (projectType == Resources.ProjectType_PLM)
{
replacementDictionary[additionalPropertiesKey] = "<PLCnCLIGenerateDT>true</PLCnCLIGenerateDT>";
}
if (projectType == Resources.ProjectType_ConsumableLibrary)
{
replacementDictionary.Add(targetsFileNameKey, "PLCnCLIBuild.targets");
}
else
{
replacementDictionary.Add(targetsFileNameKey, "PLCnCLI.targets");
}
string fileContent = await GetProjectFileTemplate();
Match replaceParameterMatch = ReplaceParameterRegex.Match(fileContent);
while (replaceParameterMatch.Success)
{
string parameter = replaceParameterMatch.Groups["parameter"].Value;
if (!replacementDictionary.ContainsKey(parameter))
{
MessageBox.Show($"The parameter {parameter} could not be replaced in the project file.");
replaceParameterMatch = replaceParameterMatch.NextMatch();
continue;
}
fileContent = fileContent.Replace(replaceParameterMatch.Value, replacementDictionary[parameter]);
replaceParameterMatch = replaceParameterMatch.NextMatch();
}
try
{
File.WriteAllText(filePath, fileContent);
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("PlcNextVSExtension.PlcNextProject.Import.ProjectTemplate.UndefClang.hpp"))
using (StreamReader reader = new StreamReader(stream))
{
string content = await reader.ReadToEndAsync();
File.WriteAllText(Path.Combine(projectDirectory, "UndefClang.hpp"), content);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace ?? string.Empty, $"Exception during writing of {filePath}");
return(false);
}
return(true);
async Task <string> GetProjectFileTemplate()
{
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("PlcNextVSExtension.PlcNextProject.Import.ProjectTemplate.PLCnextImportTemplate.vcxproj"))
using (StreamReader reader = new StreamReader(stream))
{
return(await reader.ReadToEndAsync());
}
}
}
void GenerateCode()
{
_plcncliCommunication.ExecuteCommand(Resources.Command_generate_code, null, null, Resources.Option_generate_code_project, $"\"{projectDirectory}\"");
}
void SetIncludesAndMacros()
{
ProjectInformationCommandResult projectInformation = _plcncliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project, $"\"{projectDirectory}\"") as ProjectInformationCommandResult;
CompilerSpecificationCommandResult compilerSpecsCommandResult =
_plcncliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project, $"\"{projectDirectory}\"") as
CompilerSpecificationCommandResult;
VCProject vcProject = project.Object as VCProject;
ProjectIncludesManager.SetIncludesForNewProject(vcProject, compilerSpecsCommandResult, projectInformation);
}
}
});
}
public void ProjectFinishedGenerating(Project project)
{
try
{
ThreadHelper.ThrowIfNotOnUIThread();
GeneratePLCnCLIProject();
}
catch (Exception e)
{
try
{
project.DTE.Solution.Remove(project);
DeleteProjectDirectory();
DeleteSolutionFolderIfEmpty(project.DTE);
}
catch (Exception)
{}
throw e;
}
void GeneratePLCnCLIProject()
{
_project = project;
VCProject p = _project.Object as VCProject;
//**********create new plcncli project**********
//**********get project type**********
VCConfiguration configuration = p.ActiveConfiguration;
IVCRulePropertyStorage plcnextRule = configuration.Rules.Item(Constants.PLCnextRuleName);
if (plcnextRule == null)
{
throw new NullReferenceException("PLCnextCommonProperties rule was not found in configuration rules collection.");
}
string projectType = plcnextRule.GetUnevaluatedPropertyValue("ProjectType_");
string newProjectCommand = Resources.Command_new_plmproject;
List <string> newProjectArguments = new List <string>
{
Resources.Option_new_project_output, $"\"{_projectDirectory}\"",
Resources.Option_new_project_projectNamespace, _projectNamespace
};
if (!projectType.Equals(Resources.ProjectType_ConsumableLibrary))
{
newProjectArguments.Add(Resources.Option_new_project_componentName);
newProjectArguments.Add(_componentName);
if (projectType.Equals(Resources.ProjectType_PLM))
{
newProjectArguments.Add(Resources.Option_new_project_programName);
newProjectArguments.Add(_programName);
}
}
if (projectType.Equals(Resources.ProjectType_ACF))
{
newProjectCommand = Resources.Command_new_acfproject;
}
else if (projectType.Equals(Resources.ProjectType_ConsumableLibrary))
{
newProjectCommand = Resources.Command_new_consumablelibrary;
}
_plcncliCommunication.ExecuteCommand(newProjectCommand, null, null, newProjectArguments.ToArray());
//**********create configurations**********
ProjectConfigurationManager.CreateConfigurationsForAllProjectTargets
(_projectTargets.Select(t => t.GetNameFormattedForCommandLine()), project);
foreach (TargetResult target in _projectTargets)
{
//**********set project target**********
_plcncliCommunication.ExecuteCommand(Resources.Command_set_target, null, null,
Resources.Option_set_target_add, Resources.Option_set_target_name, target.Name,
Resources.Option_set_target_version, target.Version, Resources.Option_set_target_project,
$"\"{_projectDirectory}\"");
}
//add project items to project
IEnumerable <string> projectFiles =
Directory.GetFiles(_projectDirectory, "*.*pp", SearchOption.AllDirectories)
.Concat(Directory.GetFiles(_projectDirectory, "*.txt", SearchOption.AllDirectories))
.Where(f => !f.EndsWith("UndefClang.hpp"));
foreach (string file in projectFiles)
{
project.ProjectItems.AddFromFile(file);
}
//**********generate code**********
_plcncliCommunication.ExecuteCommand(Resources.Command_generate_code, null, null, Resources.Option_generate_code_project, $"\"{_projectDirectory}\"");
ProjectInformationCommandResult projectInformation = _plcncliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project, $"\"{_projectDirectory}\"") as ProjectInformationCommandResult;
CompilerSpecificationCommandResult compilerSpecsCommandResult =
_plcncliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project, $"\"{_projectDirectory}\"") as
CompilerSpecificationCommandResult;
ProjectIncludesManager.SetIncludesForNewProject(p, compilerSpecsCommandResult, projectInformation);
}
}
public static void UpdateIncludesAndMacrosForExistingProject(VCProject vcProject,
IEnumerable <CompilerMacroResult> oldMacros,
CompilerSpecificationCommandResult newCompilerSpecs,
IEnumerable <string> oldIncludes,
ProjectInformationCommandResult newProjectInformation)
{
var(newMacros, newIncludes) =
ProjectIncludesManager.FindMacrosAndIncludesForMinTarget(newCompilerSpecs,
newProjectInformation);
if (newMacros == null)
{
newMacros = Enumerable.Empty <CompilerMacroResult>();
}
if (newIncludes == null)
{
newIncludes = Enumerable.Empty <string>();
}
IVCRulePropertyStorage plcnextCommonPropertiesRule = vcProject.ActiveConfiguration.Rules.Item(Constants.PLCnextRuleName);
foreach (VCConfiguration2 config in vcProject.Configurations)
{
plcnextCommonPropertiesRule = config.Rules.Item(Constants.PLCnextRuleName);
CheckIncludesVariableIsInProjectIncludes(config);
CheckMacrosVariableIsInProjectMacros(config);
DeleteObsoleteIncludes();
DeleteObsoleteMacros();
void DeleteObsoleteIncludes()
{
string savedIncludes = plcnextCommonPropertiesRule.GetUnevaluatedPropertyValue(Constants.PLCnextIncludesKey);
if (!string.IsNullOrEmpty(savedIncludes) || oldIncludes == null || !oldIncludes.Any())
{
return;
}
IVCRulePropertyStorage rule = config.Rules.Item(Constants.VCppIncludesRuleName);
IEnumerable <string> currentIncludes = rule.GetUnevaluatedPropertyValue(Constants.VCppIncludesKey)
.Split(';')
.Where(i => !oldIncludes.Contains(i));
rule.SetPropertyValue(Constants.VCppIncludesKey, currentIncludes.Any() ?
string.Join(";", currentIncludes) : string.Empty);
}
void DeleteObsoleteMacros()
{
string savedMacros = plcnextCommonPropertiesRule.GetUnevaluatedPropertyValue(Constants.PLCnextMacrosKey);
if (!string.IsNullOrEmpty(savedMacros) || oldMacros == null || !oldMacros.Any())
{
return;
}
IVCRulePropertyStorage clRule = config.Rules.Item(Constants.CLRuleName);
IEnumerable <CompilerMacroResult> currentMacros =
clRule.GetUnevaluatedPropertyValue(Constants.VCPreprocessorsKey)
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Select(m => m.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries))
.Select(m => new CompilerMacroResult {
Name = m[0], Value = m.Length == 2 ? m[1].Trim() : null
});
currentMacros = currentMacros.Where(m => !oldMacros.Any(y => y.Name.Equals(m.Name) &&
(y.Value != null ?
(m.Value == null ?
string.IsNullOrEmpty(y.Value.Trim()) :
y.Value.Trim().Equals(m.Value.Trim())) :
string.IsNullOrEmpty(m.Value?.Trim()))));
IEnumerable <string> macros = currentMacros.Select(m => m.Name + (string.IsNullOrEmpty(m.Value?.Trim()) ? string.Empty : ("=" + m.Value)));
clRule.SetPropertyValue(Constants.VCPreprocessorsKey, macros.Any() ? string.Join(";", macros) : string.Empty);
}
}
plcnextCommonPropertiesRule.SetPropertyValue(Constants.PLCnextIncludesKey, newIncludes.Any() ?
string.Join(";", newIncludes) :
string.Empty);
plcnextCommonPropertiesRule.SetPropertyValue(Constants.PLCnextMacrosKey, newMacros.Any() ?
string.Join(";", newMacros.Select(m => m.Name + (string.IsNullOrEmpty(m.Value?.Trim()) ? string.Empty : ("=" + m.Value))))
: string.Empty);
void CheckIncludesVariableIsInProjectIncludes(VCConfiguration2 config)
{
IVCRulePropertyStorage rule = config.Rules.Item(Constants.VCppIncludesRuleName);
string currentIncludes = rule.GetUnevaluatedPropertyValue(Constants.VCppIncludesKey);
if (!currentIncludes.Split(';').Where(i => i.Trim().Equals($"$({Constants.PLCnextIncludesKey})", StringComparison.OrdinalIgnoreCase)).Any())
{
string includes = string.IsNullOrEmpty(currentIncludes) ? $"$({Constants.PLCnextIncludesKey})"
: string.Join(";", currentIncludes, $"$({Constants.PLCnextIncludesKey})");
rule.SetPropertyValue(Constants.VCppIncludesKey, includes);
}
}
void CheckMacrosVariableIsInProjectMacros(VCConfiguration2 config)
{
IVCRulePropertyStorage clRule = config.Rules.Item(Constants.CLRuleName);
string currentMacros =
clRule.GetUnevaluatedPropertyValue(Constants.VCPreprocessorsKey);
if (!currentMacros.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Where(m => m.Trim()
.Equals($"$({Constants.PLCnextMacrosKey})", StringComparison.OrdinalIgnoreCase))
.Any())
{
string macros = string.IsNullOrEmpty(currentMacros) ? $"$({Constants.PLCnextMacrosKey})"
: string.Join(";", currentMacros, $"$({Constants.PLCnextMacrosKey})");
clRule.SetPropertyValue(Constants.VCPreprocessorsKey, macros);
}
}
}
private static IEnumerable <string> GetIncludesForTarget(TargetResult target, ProjectInformationCommandResult projectInformation)
{
return(projectInformation?.IncludePaths
.Where(x => x.Targets == null ||
!x.Targets.Any() ||
(target != null && x.Targets.Any(t => t.Name.Equals(target.Name) &&
t.LongVersion.Equals(target.LongVersion))
)
)
.Select(p => p.PathValue));
}
public static TargetResult FindMinTargetForIncludes(ProjectInformationCommandResult projectInformation)
{
return(projectInformation?.Targets
.Where(t => t.Available == true)
.MinTarget());
}
private void UpdateIncludesOnBeforeSave(VCProject p, string projectDirectory)
{
var(includesSaved, macrosSaved) = ProjectIncludesManager.CheckSavedIncludesAndMacros(p);
IEnumerable <string> includesBefore = null;
IEnumerable <CompilerMacroResult> macrosBefore = null;
try
{
ThreadHelper.JoinableTaskFactory.Run("Updating includes and macros", async(progress) =>
{
await Task.Run(() => GetIncludesAndMacros());
void GetIncludesAndMacros()
{
if (!includesSaved)
{
progress.Report(new ThreadedWaitDialogProgressData("Fetching project information"));
ProjectInformationCommandResult projectInformationBefore = null;
try
{
projectInformationBefore = cliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project,
$"\"{projectDirectory}\"") as ProjectInformationCommandResult;
}
catch (PlcncliException ex)
{
projectInformationBefore = cliCommunication.ConvertToTypedCommandResult <ProjectInformationCommandResult>(ex.InfoMessages);
}
includesBefore = projectInformationBefore?.IncludePaths.Select(x => x.PathValue);
if (includesBefore == null)
{
includesBefore = Enumerable.Empty <string>();
}
}
if (!macrosSaved)
{
progress.Report(new ThreadedWaitDialogProgressData("Fetching compiler information"));
CompilerSpecificationCommandResult compilerSpecsBefore = null;
try
{
compilerSpecsBefore = cliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project,
$"\"{projectDirectory}\"") as CompilerSpecificationCommandResult;
}
catch (PlcncliException ex)
{
compilerSpecsBefore = cliCommunication.ConvertToTypedCommandResult <CompilerSpecificationCommandResult>(ex.InfoMessages);
}
macrosBefore = compilerSpecsBefore?.Specifications.FirstOrDefault()
?.CompilerMacros.Where(m => !m.Name.StartsWith("__has_include(")) ?? Enumerable.Empty <CompilerMacroResult>();
}
}
});
this.vcProject = p;
this.projectDirectory = p.ProjectDirectory;
this.wrapper = new IncludesAndMacrosWrapper(includesBefore, macrosBefore);
}
catch (Exception e)
{
Reset();
try
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsActivityLog log = Package.GetGlobalService(typeof(SVsActivityLog)) as IVsActivityLog;
log.LogEntry((uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR, this.ToString(),
"An error occurred while updating the includes: " + e.Message + e.StackTrace);
}
catch (Exception) { /*try to log error in activity log*/ }
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void SetTargets(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
IServiceProvider serviceProvider = package;
Project project = GetProject();
if (project == null)
{
return;
}
string projectDirectory = Path.GetDirectoryName(project.FullName);
//show dialog
ProjectTargetValueEditorModel model = new ProjectTargetValueEditorModel(serviceProvider, projectDirectory);
ProjectTargetValueEditorViewModel viewModel = new ProjectTargetValueEditorViewModel(model);
ProjectTargetValueEditorView view = new ProjectTargetValueEditorView(viewModel);
view.ShowModal();
if (view.DialogResult == true)
{
if (!(serviceProvider.GetService(typeof(SPlcncliCommunication)) is IPlcncliCommunication cliCommunication))
{
MessageBox.Show("Could not set project targets because no plcncli communication found.");
return;
}
VCProject p = project.Object as VCProject;
bool needProjectInformation = false;
bool needCompilerInformation = false;
var(includesSaved, macrosSaved) = ProjectIncludesManager.CheckSavedIncludesAndMacros(p);
needProjectInformation = !includesSaved;
needCompilerInformation = !macrosSaved;
IEnumerable <string> includesBefore = null;
IEnumerable <CompilerMacroResult> macrosBefore = Enumerable.Empty <CompilerMacroResult>();
CompilerSpecificationCommandResult compilerSpecsAfter = null;
ProjectInformationCommandResult projectInformationAfter = null;
IVsTaskStatusCenterService taskCenter = Package.GetGlobalService(typeof(SVsTaskStatusCenterService)) as IVsTaskStatusCenterService;
ITaskHandler taskHandler = taskCenter.PreRegister(
new TaskHandlerOptions()
{
Title = $"Setting project targets"
},
new TaskProgressData());
Task task = Task.Run(async() =>
{
try
{
if (needProjectInformation)
{
ProjectInformationCommandResult projectInformationBefore = null;
try
{
projectInformationBefore = cliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project,
$"\"{projectDirectory}\"") as ProjectInformationCommandResult;
}
catch (PlcncliException ex)
{
try
{
projectInformationBefore = cliCommunication.ConvertToTypedCommandResult <ProjectInformationCommandResult>(ex.InfoMessages);
}
catch (PlcncliException) {}
}
includesBefore = projectInformationBefore?.IncludePaths.Select(x => x.PathValue);
if (includesBefore == null)
{
includesBefore = Enumerable.Empty <string>();
}
}
if (needCompilerInformation)
{
CompilerSpecificationCommandResult compilerSpecsBefore = null;
try
{
compilerSpecsBefore = cliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project,
$"\"{projectDirectory}\"") as CompilerSpecificationCommandResult;
}
catch (PlcncliException ex)
{
compilerSpecsBefore = cliCommunication.ConvertToTypedCommandResult <CompilerSpecificationCommandResult>(ex.InfoMessages);
}
macrosBefore = compilerSpecsBefore?.Specifications.FirstOrDefault()
?.CompilerMacros.Where(m => !m.Name.StartsWith("__has_include(")) ?? Enumerable.Empty <CompilerMacroResult>();
}
SetTargets();
try
{
projectInformationAfter = cliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project,
$"\"{projectDirectory}\"") as ProjectInformationCommandResult;
}
catch (PlcncliException ex)
{
projectInformationAfter = cliCommunication.ConvertToTypedCommandResult <ProjectInformationCommandResult>(ex.InfoMessages);
}
try
{
compilerSpecsAfter = cliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project,
$"\"{projectDirectory}\"") as CompilerSpecificationCommandResult;
}
catch (PlcncliException ex)
{
compilerSpecsAfter = cliCommunication.ConvertToTypedCommandResult <CompilerSpecificationCommandResult>(ex.InfoMessages);
}
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
ProjectConfigurationManager.CreateConfigurationsForAllProjectTargets
(projectInformationAfter?.Targets.Select(t => t.GetNameFormattedForCommandLine()), project);
ProjectIncludesManager.UpdateIncludesAndMacrosForExistingProject(p, macrosBefore,
compilerSpecsAfter, includesBefore, projectInformationAfter);
p.Save();
ProjectIncludesManager.AddTargetsFileToOldProjects(p);
void SetTargets()
{
foreach (TargetResult target in model.TargetsToAdd)
{
cliCommunication.ExecuteCommand(Resources.Command_set_target, null, null,
Resources.Option_set_target_add, Resources.Option_set_target_project,
$"\"{projectDirectory}\"",
Resources.Option_set_target_name, target.Name, Resources.Option_set_target_version,
$"\"{target.LongVersion}\"");
}
foreach (TargetResult target in model.TargetsToRemove)
{
cliCommunication.ExecuteCommand(Resources.Command_set_target, null, null,
Resources.Option_set_target_remove, Resources.Option_set_target_project,
$"\"{projectDirectory}\"",
Resources.Option_set_target_name, target.Name, Resources.Option_set_target_version,
$"\"{target.LongVersion}\"");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace ?? string.Empty, "Exception during setting of targets");
throw ex;
}
});
taskHandler.RegisterTask(task);
}
}
public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind,
object[] customParams)
{
string itemName = replacementsDictionary["$safeitemname$"];
ThreadHelper.ThrowIfNotOnUIThread();
if (automationObject is DTE dte)
{
object activeProjects = dte.ActiveSolutionProjects;
Array activeProjectsArray = (Array)activeProjects;
if (activeProjectsArray.Length > 0)
{
Project project = (Project)activeProjectsArray.GetValue(0);
if (project != null)
{
IEnumerable <string> validProjectTypes = Enumerable.Empty <string>();
string itemType = string.Empty;
GetWizardDataFromTemplate();
string projectDirectory = Path.GetDirectoryName(project.FullName);
ProjectInformationCommandResult projectInformation = _plcncliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult),
Resources.Option_get_project_information_no_include_detection,
Resources.Option_get_project_information_project, $"\"{projectDirectory}\"") as ProjectInformationCommandResult;
string projecttype = projectInformation.Type;
if (projecttype == null || !validProjectTypes.Contains(projecttype))
{
MessageBox.Show(
$"This template is not available for the selected project. The template is available for the project types" +
$"{validProjectTypes.Aggregate(string.Empty, (s1, s2) => s1 + $"\n'{s2}'")}\nbut the selected project is of type\n'{projecttype}'.",
"Template not available for project type",
MessageBoxButton.OK, MessageBoxImage.Error);
throw new WizardBackoutException();
}
NewItemModel model = new NewItemModel(_plcncliCommunication, projectDirectory, itemType);
NewItemViewModel viewModel = new NewItemViewModel(model);
NewItemDialogView view = new NewItemDialogView(viewModel);
bool?result = view.ShowModal();
if (result != null && result == true)
{
try
{
if (itemType.Equals(Resources.ItemType_program))
{
_plcncliCommunication.ExecuteCommand(Resources.Command_new_program, null, null,
Resources.Option_new_program_project, $"\"{projectDirectory}\"",
Resources.Option_new_program_name, itemName,
Resources.Option_new_program_component, model.SelectedComponent,
Resources.Option_new_program_namespace, model.SelectedNamespace);
}
else if (itemType.Equals(Resources.ItemType_component))
{
string command = Resources.Command_new_component;
if (projecttype.Equals(Resources.ProjectType_ACF))
{
command = Resources.Command_new_acfcomponent;
}
_plcncliCommunication.ExecuteCommand(command, null, null,
Resources.Option_new_component_project, $"\"{projectDirectory}\"",
Resources.Option_new_component_name, itemName,
Resources.Option_new_component_namespace, model.SelectedNamespace);
}
string[] itemFiles = Directory.GetFiles(Path.Combine(projectDirectory, "src"), $"{itemName}.*pp");
foreach (string itemFile in itemFiles)
{
project.ProjectItems.AddFromFile(itemFile);
}
_plcncliCommunication.ExecuteCommand(Resources.Command_generate_code, null, null,
Resources.Option_generate_code_project, $"\"{projectDirectory}\"");
}catch (PlcncliException e)
{
MessageBox.Show(e.Message, "Error occured", MessageBoxButton.OK, MessageBoxImage.Error);
throw new WizardBackoutException();
}
}
void GetWizardDataFromTemplate()
{
string wizardData = replacementsDictionary["$wizarddata$"];
XDocument document = XDocument.Parse(wizardData);
XNamespace nspace = document.Root.GetDefaultNamespace();
validProjectTypes = document.Element(nspace + "Data").Element(nspace + "ValidProjectTypes")
.Descendants(nspace + "Type").Select(e => e.Value);
itemType =
document.Element(nspace + "Data").Element(nspace + "ItemType").Value;
}
}
}
}
}