/// <summary> /// Adds the item template to project. /// </summary> /// <param name="instance">The instance.</param> /// <param name="templateInfos">The template infos.</param> public static void AddItemTemplateToProjects( this Solution2 instance, IEnumerable <ItemTemplateInfo> templateInfos) { IEnumerable <Project> projects = instance.GetProjects(); TraceService.WriteError("AddItemTemplateToProjects project count=" + projects.Count()); foreach (ItemTemplateInfo info in templateInfos) { Project project = projects.FirstOrDefault(x => x.Name.EndsWith(info.ProjectSuffix)); if (project != null) { project.AddToFolderFromTemplate(info.FolderName, info.TemplateName, info.FileName); } else { TraceService.WriteError("AddItemTemplateToProjects cannot find project " + info.ProjectSuffix); foreach (Project projectItem in projects) { string projectName = projectItem.Name; TraceService.WriteError("AddItemTemplateToProjects project " + projectName); } } } }
/// <summary> /// Replaces the text. /// </summary> /// <param name="instance">The instance.</param> /// <param name="findText">The find text.</param> /// <param name="replaceText">The replace text.</param> /// <param name="saveFiles">if set to <c>true</c> [save files].</param> /// <returns>True or false.</returns> public static bool ReplaceText( this DTE2 instance, string findText, string replaceText, bool saveFiles) { TraceService.WriteLine("DTEExtensions::ReplaceText from '" + findText + "' to '" + replaceText + "'"); bool replaced = true; Find2 find2 = (Find2)instance.Find; vsFindResult findResults = find2.FindReplace( vsFindAction.vsFindActionReplaceAll, findText, (int)vsFindOptions.vsFindOptionsFromStart, replaceText, vsFindTarget.vsFindTargetSolution, string.Empty, string.Empty, vsFindResultsLocation.vsFindResultsNone); if (findResults == vsFindResult.vsFindResultNotFound) { replaced = false; TraceService.WriteError("Unable to replace text from:-" + findText + " to:- " + replaceText); } if (saveFiles) { instance.SaveAll(); } return(replaced); }
/// <summary> /// Translates the specified from. /// </summary> /// <param name="from">From.</param> /// <returns></returns> public CustomRenderers Translate(string from) { TraceService.WriteLine("CustomRenderers::Translate " + from); CustomRenderers customRenderers = new CustomRenderers(); try { XDocument doc = XDocument.Load(@from); if (doc.Root != null) { TraceService.WriteDebugLine(doc.Root.Value); customRenderers.HelpLink = this.GetHelpLink(doc.Root); customRenderers.Groups = this.GetGroups(doc.Root); } } catch (Exception exception) { TraceService.WriteError(exception); } return(customRenderers); }
/// <summary> /// Gets the first class. /// </summary> /// <param name="instance">The instance.</param> /// <returns>The first class.</returns> public static CodeClass GetFirstClass(this ProjectItem instance) { TraceService.WriteLine("ProjectItemExtensions::GetFirstClass file=" + instance.Name); IEnumerable <CodeClass> codeClasses = instance.FileCodeModel.CodeElements.OfType <CodeClass>(); if (!codeClasses.Any()) { CodeNamespace codeNamespace = instance.GetFirstNameSpace(); if (codeNamespace != null) { foreach (CodeElement codeElement in codeNamespace.Children) { if (codeElement.Kind == vsCMElement.vsCMElementClass) { return(codeElement as CodeClass); } } } else { TraceService.WriteError("ProjectItemExtensions::GetFirstClass cannot find namespace"); } } else { return(codeClasses.FirstOrDefault()); } return(null); }
/// <summary> /// Gets the plugins. /// </summary> /// <param name="uri">The URI.</param> /// <returns>The plugins.</returns> public Plugins GetPlugins(string uri) { TraceService.WriteLine("PluginFactory::GetPlugins url=" + uri); if (this.cachingService.Plugins.ContainsKey(uri)) { TraceService.WriteLine("Using cache"); return(this.cachingService.Plugins[uri]); } Plugins plugins = this.pluginsTranslator.Translate(uri); if (plugins != null) { if (plugins.Items != null) { TraceService.WriteLine("PluginFactory::GetPlugins pluginCount=" + plugins.Items.Count()); this.cachingService.Plugins.Add(uri, plugins); } else { TraceService.WriteLine("PluginFactory::GetPlugins has no plugins"); } } else { TraceService.WriteError("PluginFactory::GetPlugins is null url=" + uri); } return(plugins); }
/// <summary> /// Processes the specified form. /// </summary> /// <param name="effectViewModel">The effect view model.</param> internal void Process(EffectViewModel effectViewModel) { TraceService.WriteLine("EffectsController::Process"); this.VisualStudioService.WriteStatusBarMessage(NinjaMessages.NinjaIsRunning); try { TraceService.WriteLine("EffectsController::Process GetTextTemplates"); IEnumerable <TextTemplateInfo> textTemplates = this.effectFactory.GetTextTemplates( effectViewModel.RequestedName, this.SettingsService.EffectDirectory); IEnumerable <string> messages = this.textTemplatingService.AddTextTemplates( NinjaMessages.AddingEffect, textTemplates); //// show the readme. this.ShowReadMe("Add Xamarin Forms Effect", messages); } catch (Exception exception) { TraceService.WriteError("Cannot create effect exception=" + exception.Message); } }
/// <summary> /// Deletes the command. /// </summary> /// <param name="commandName">Name of the command.</param> protected void DeleteCommand(string commandName) { TraceService.WriteLine("CommandManager::DeleteCommand commandName=" + commandName); try { Commands2 commands = (Commands2)this.VsInstance.ApplicationObject.Commands; CommandBarPopup toolsMenuPopUp = this.VsInstance.ApplicationObject.GetToolsMenuPopUp(); CommandBar commandBar = null; for (int i = 1; i <= toolsMenuPopUp.CommandBar.Controls.Count; i++) { if (toolsMenuPopUp.CommandBar.Controls[i].Caption == commandName) { TraceService.WriteLine("CommandManager::DeleteCommand commandFound in collection commandName=" + commandName); CommandBarPopup commandBarPopup = (CommandBarPopup)toolsMenuPopUp.CommandBar.Controls[i]; commandBar = commandBarPopup.CommandBar; break; } } if (commandBar != null) { TraceService.WriteLine("Command found and will be deleted ommandName=" + commandName); commandBar.Delete(); } } catch (Exception exception) { TraceService.WriteError("exception=" + exception.Message); TraceService.WriteError("stackTrace=" + exception.StackTrace); } }
/// <summary> /// Processes the specified form. /// </summary> /// <param name="customRendererViewModel">The custom renderer view model.</param> internal void Process(CustomRendererViewModel customRendererViewModel) { TraceService.WriteLine("CustomerRendererController::Process"); this.VisualStudioService.WriteStatusBarMessage(NinjaMessages.NinjaIsRunning); try { TraceService.WriteLine("CustomerRendererController::Process GetTextTemplates"); IEnumerable <TextTemplateInfo> textTemplates = this.customRendererFactory.GetTextTemplates( customRendererViewModel.RequestedName, this.SettingsService.CustomRendererDirectory, customRendererViewModel.SelectedCustomRendererItem, customRendererViewModel.CodeBlock); IEnumerable <string> messages = this.textTemplatingService.AddTextTemplates( NinjaMessages.AddingCustomRenderer, textTemplates); //// show the readme. this.ShowReadMe("Add Xamarin Forms Custom Renderer", messages); } catch (Exception exception) { TraceService.WriteError("Cannot create custom renderer exception=" + exception.Message); } }
/// <summary> /// Builds the source file. /// </summary> /// <param name="project">The project.</param> /// <param name="extensionSource">The extensionSource.</param> /// <param name="extensionDestination">The extension destination.</param> /// <param name="friendlyName">Name of the friendly.</param> internal void BuildSourceFile( Project project, string extensionSource, string extensionDestination, string friendlyName) { try { const string PlaceHolderText = "#PlaceHolder#"; string message = string.Format("BuildSourceFile Project Name={0} friendlyName={1}", project.Name, friendlyName); TraceService.WriteLine(message); string sourceFile = friendlyName + "PluginBootstrap.cs"; //// now we need to sort out the item template! project.AddToFolderFromTemplate("Bootstrap", "MvvmCross.Plugin.zip", sourceFile); ProjectItem projectItem = project.GetProjectItem(sourceFile); //// if we find the project item replace the text in it else use the find/replace window. if (projectItem != null) { TextSelection textSelection = projectItem.DTE.ActiveDocument.Selection; textSelection.SelectAll(); textSelection.ReplacePattern(PlaceHolderText, friendlyName); projectItem.Save(); } } catch (Exception exception) { TraceService.WriteError("BuildSourceFile " + exception.Message); } }
/// <summary> /// Sets the start up project. /// </summary> public void SetStartUpProject() { if (this.IsNewSolution) { return; } string startUpProject = this.SettingsService.StartUpProject; TraceService.WriteLine("StartUpProject=" + startUpProject); if (startUpProject != string.Empty) { IProjectService projectService = this.visualStudioService.GetProjectServiceBySuffix(startUpProject); if (projectService != null) { this.visualStudioService.SolutionService.SetStartUpProject(projectService.Name); } else { TraceService.WriteError("Cannot find StartUpProject=" + startUpProject); } } }
/// <summary> /// Processes the specified form. /// </summary> /// <param name="dependencyServiceViewModel">The dependency service view model.</param> internal void Process(DependencyServiceViewModel dependencyServiceViewModel) { TraceService.WriteLine("DependencyServicesController::Process"); this.VisualStudioService.WriteStatusBarMessage(NinjaMessages.NinjaIsRunning); try { TraceService.WriteLine("DependencyServicesController::Process GetTextTemplates"); IEnumerable <TextTemplateInfo> textTemplates = this.dependencyServicesFactory.GetTextTemplates( dependencyServiceViewModel.RequestedName, dependencyServiceViewModel.MethodComment, dependencyServiceViewModel.MethodReturnType, dependencyServiceViewModel.MethodName, this.SettingsService.DependencyDirectory); IEnumerable <string> messages = this.textTemplatingService.AddTextTemplates( NinjaMessages.AddingDependencyService, textTemplates); //// show the readme. this.ShowReadMe("Add Xamarin Forms Dependency Service", messages); } catch (Exception exception) { TraceService.WriteError("Cannot create dependency service exception=" + exception.Message); } }
/// <summary> /// Completed the nuget updates. /// </summary> internal void NugetCompleted() { TraceService.WriteLine("NugetService::NugetCompleted"); if (this.documentEvents != null) { this.RemoveEventHandlers(); } this.ExecutePostNugetCommands(); this.ExecutePostNugetFileOperations(); this.visualStudioService.DTEService.CollapseSolution(); if (this.ResumeReSharper) { try { //// this could fail - so catch exception. this.visualStudioService.DTEService.ExecuteCommand(Settings.ResumeReSharperCommand); } catch (Exception exception) { TraceService.WriteError("Error Resuming ReSharper exception=" + exception.Message); } } }
/// <summary> /// Shows the read me. /// </summary> /// <param name="function">The function.</param> /// <param name="messages">The messages.</param> /// <param name="closeDocuments">if set to <c>true</c> [close documents].</param> /// <param name="collapseSolution">if set to <c>true</c> [collapse solution].</param> protected void ShowReadMe( string function, IEnumerable <string> messages, bool closeDocuments = true, bool collapseSolution = true) { TraceService.WriteLine("BaseController::ShowReadMe " + function); //// never quite got to the bottom this but sometimes closing documents/collapsing the solution fails. //// this isnt that important - but we need to show the readme file - so catch the error. try { //// close any open documents. if (closeDocuments) { this.VisualStudioService.DTEService.CloseDocuments(); } //// now collapse the solution! if (collapseSolution) { this.VisualStudioService.DTEService.CollapseSolution(); } } catch (Exception exception) { TraceService.WriteError("Error closing documents/solution exception=" + exception.Message); } try { string readMePath = this.GetReadMePath(); TraceService.WriteLine("BaseController::ShowReadMe path=" + readMePath); //// now construct the ReadMe.txt this.ReadMeLines.AddRange(messages); this.ReadMeService.AddLines( readMePath, function, this.ReadMeLines, TraceService.ErrorMessages, this.GetTraceMessages(false)); this.VisualStudioService.DTEService.OpenFile(readMePath); //// reset the messages - if we don't do this we get the previous messages! this.readmeLines = new List <string>(); } catch (Exception exception) { TraceService.WriteError("BaseController::ShowReadMe Showing ReadMe Error :-" + exception.Message); } }
/// <summary> /// Processes the specified form. /// </summary> /// <param name="plugins">The plugins.</param> internal void Process(IEnumerable <Plugin> plugins) { TraceService.WriteLine("PluginsController::Process"); this.VisualStudioService.WriteStatusBarMessage(NinjaMessages.NinjaIsRunning); try { List <string> messages = new List <string>(); this.VisualStudioService.WriteStatusBarMessage(NinjaMessages.UpdatingFiles); this.VisualStudioService.DTEService.SaveAll(); List <string> commands = plugins.Select(plugin => plugin.GetNugetCommandStrings( this.VisualStudioService, this.SettingsService, this.SettingsService.UsePreReleaseMvvmCrossNugetPackages)).ToList(); if (commands.Any()) { if (this.SettingsService.ProcessNugetCommands) { this.nugetService.Execute( this.GetReadMePath(), commands, this.SettingsService.SuspendReSharperDuringBuild); } string message = NinjaMessages.NugetDownload; if (this.SettingsService.UseLocalNuget) { message += " (using local " + this.SettingsService.LocalNugetName + ")"; } this.VisualStudioService.WriteStatusBarMessage(message); } if (this.SettingsService.OutputNugetCommandsToReadMe) { messages.Add(string.Join(Environment.NewLine, commands)); } this.ReadMeService.AddLines( this.GetReadMePath(), "Add MvvmCross Plugins", messages, TraceService.ErrorMessages, this.GetTraceMessages(false)); } catch (Exception exception) { TraceService.WriteError("Cannot create plugins exception=" + exception.Message); } }
/// <summary> /// Adds the item template to project. /// </summary> /// <param name="instance">The instance.</param> /// <param name="templateInfos">The template infos.</param> /// <returns> /// The messages. /// </returns> public static IEnumerable <string> AddItemTemplateToProjects( this Solution2 instance, IEnumerable <ItemTemplateInfo> templateInfos) { string method = "SolutionExtensions::AddItemTemplateToProjects "; TraceService.WriteLine(method); List <string> messages = new List <string>(); IEnumerable <Project> projects = instance.GetProjects(); IEnumerable <Project> projectItems = projects as Project[] ?? projects.ToArray(); foreach (ItemTemplateInfo info in templateInfos) { Project project = projectItems.FirstOrDefault(x => x.Name.EndsWith(info.ProjectSuffix)); if (project != null) { string context = project.Name + " (template=" + info.TemplateName + ") fileName=" + info.FileName; TraceService.WriteLine(method + context); try { if (project.AddItemToFolderFromTemplate(info.TemplateName, info.FileName)) { messages.Add(info.FileName + " added to " + project.Name + " project (template=" + info.TemplateName + ")"); } } catch (Exception exception) { TraceService.WriteError(method + context + " exception=" + exception.Message); messages.Add(method + context + " exception=" + exception.Message); } } else { TraceService.WriteError(method + " cannot find project " + info.ProjectSuffix); foreach (string projectName in projectItems .Select(projectItem => projectItem.Name)) { TraceService.WriteError(method + " project " + projectName); messages.Add(info.FileName + " added to " + projectName + " project (template=" + info.TemplateName + ")"); } } } return(messages); }
/// <summary> /// Runs this instance. /// </summary> public void Run() { TraceService.WriteHeader("ProjectsController::Run"); //// we open the nuget package manager console so we don't have a wait condition later! this.nugetService.OpenNugetWindow(); this.projectFactory.RegisterWizardData(); WizardFrameViewModel viewModel = this.ShowDialog <WizardFrameViewModel>(new WizardView()); try { if (viewModel.Continue) { ProjectsViewModel projectsViewModel = (ProjectsViewModel)viewModel.GetWizardStepViewModel("ProjectsViewModel").ViewModel; ApplicationOptionsViewModel applicationOptionsViewModel = (ApplicationOptionsViewModel)viewModel.GetWizardStepViewModel("ApplicationOptionsViewModel").ViewModel; NinjaCoderOptionsViewModel ninjaCoderOptionsViewModel = (NinjaCoderOptionsViewModel)viewModel.GetWizardStepViewModel("NinjaCoderOptionsViewModel").ViewModel; ApplicationSamplesOptionsViewModel applicationSamplesOptionsViewModel = (ApplicationSamplesOptionsViewModel)viewModel.GetWizardStepViewModel("ApplicationSamplesOptionsViewModel").ViewModel; ViewsViewModel viewsViewModel = (ViewsViewModel)viewModel.GetWizardStepViewModel("ViewsViewModel").ViewModel; PluginsViewModel pluginsViewModel = (PluginsViewModel)viewModel.GetWizardStepViewModel("PluginsViewModel").ViewModel; NugetPackagesViewModel nugetPackagesViewModel = (NugetPackagesViewModel)viewModel.GetWizardStepViewModel("NugetPackagesViewModel").ViewModel; XamarinFormsLabsViewModel xamarinFormsLabsViewModel = (XamarinFormsLabsViewModel)viewModel.GetWizardStepViewModel("XamarinFormsLabsViewModel").ViewModel; this.Process( projectsViewModel, applicationOptionsViewModel, ninjaCoderOptionsViewModel, applicationSamplesOptionsViewModel, viewsViewModel, pluginsViewModel, nugetPackagesViewModel, xamarinFormsLabsViewModel); } } catch (Exception exception) { //// TODO : this needs refactoring. this.VisualStudioService.WriteStatusBarMessage(string.Empty); TraceService.WriteError(exception); //// put the error messages in the readme! this.messages.InsertRange(0, TraceService.ErrorMessages); TraceService.ErrorMessages = new List <string>(); this.CreateReadMe(true, true); } }
/// <summary> /// Implements the interface. /// </summary> /// <param name="instance">The instance.</param> /// <param name="constructor">The constructor.</param> /// <param name="variable">The variable.</param> public static void ImplementInterface( this CodeClass instance, CodeFunction constructor, string variable) { TraceService.WriteLine("CodeClassExtensions::ImplementInterface file=" + variable); //// now add in the interfaces! //// split the variable string string[] parts = variable.Split(' '); constructor.AddParameter(parts[1], parts[0]); //// we need to add the variable. //// variable could already exist! try { instance.ImplementVariable(parts[1], parts[0], true); } catch (Exception) { TraceService.WriteError("variable already exists " + parts[1]); } //// now do the wiring up of the interface and variable! EditPoint editPoint = constructor.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); string code = string.Format("this.{0} = {1};", parts[1], parts[1]); editPoint.InsertCodeLine(code); //// now update the constructor document comments. string paramComment = string.Format("<param name=\"{0}\">The {0}.</param>{1}", parts[1], Environment.NewLine); string currentComment = constructor.DocComment; int index = currentComment.LastIndexOf("</summary>", StringComparison.Ordinal); StringBuilder sb = new StringBuilder(); if (index != -1) { sb.Append(currentComment.Substring(0, index + 10)); sb.Append(paramComment); sb.Append(currentComment.Substring(index + 10)); TraceService.WriteLine("comment added=" + paramComment); } constructor.DocComment = sb.ToString(); }
/// <summary> /// Adds to folder from template. /// </summary> /// <param name="instance">The instance.</param> /// <param name="folderName">Name of the folder.</param> /// <param name="templateName">Name of the template.</param> /// <param name="fileName">Name of the file.</param> /// <param name="createFolder">if set to <c>true</c> [create folder].</param> /// <returns>True or False.</returns> public static bool AddToFolderFromTemplate( this Project instance, string folderName, string templateName, string fileName, bool createFolder) { TraceService.WriteLine("ProjectExtensions::AddToFolderFromTemplate project=" + instance.Name); string path = instance.Properties.Item("FullPath").Value; ProjectItems projectItems = instance.ProjectItems; //// this supports passing of folder name - currently used by viewmodels and views. //// may not be required if we refactor the item templates to embed the directory. if (createFolder) { ProjectItem folderProjectItem = instance.ProjectItems .Cast <ProjectItem>() .FirstOrDefault(projectItem => projectItem.Name == folderName); //// if the folder doesn't exist create it. if (folderProjectItem == null) { folderProjectItem = instance.ProjectItems.AddFolder(folderName); } projectItems = folderProjectItem.ProjectItems; path = folderProjectItem.Properties.Item("FullPath").Value; } Solution2 solution = instance.DTE.Solution as Solution2; string templatePath = solution.GetProjectItemTemplate(templateName); if (templatePath != null) { string filePath = string.Format(@"{0}\{1}\{2}", path, folderName, fileName); if (File.Exists(filePath) == false) { projectItems.AddFromTemplate(templatePath, fileName); } return(true); } TraceService.WriteError("ProjectExtensions::AddToFolderFromTemplate Cannot find template " + templateName); return(false); }
/// <summary> /// Add item to the menu. /// </summary> /// <param name="vsCommandInfo">The command info.</param> protected virtual void AddMenuItem(VSCommandInfo vsCommandInfo) { TraceService.WriteLine("CommandManager::AddMenuItem Name=" + vsCommandInfo.Name); //// This try/catch block can be duplicated if you wish to add multiple commands to be handled by your Add-in, //// just make sure you also update the QueryStatus/Exec method to include the new command names. try { Commands2 commands = (Commands2)this.VSInstance.ApplicationObject.Commands; object[] context = new object[] { }; TraceService.WriteLine("CommandManager::AddMenuItem Adding command name=" + vsCommandInfo.Name); IEnumerable <Command> currentCommands = commands.Cast <Command>(); foreach (Command command in currentCommands .Where(command => command.Name == vsCommandInfo.Name)) { TraceService.WriteLine("CommandManager::AddMenuItem Deleting Command already in memory name=" + vsCommandInfo.Name); command.Delete(); break; } vsCommandInfo.Command = commands.AddNamedCommand2( vsCommandInfo.AddIn, vsCommandInfo.Name, vsCommandInfo.ButtonText, vsCommandInfo.Tooltip, vsCommandInfo.UseOfficeResources, vsCommandInfo.BitmapResourceId, ref context); vsCommandInfo.Command.AddControl(vsCommandInfo.ParentCommand, vsCommandInfo.Position); this.commandInfos.Add(vsCommandInfo); } catch (ArgumentException exception) { //// If we are here, then the exception is probably because a command with that name //// already exists. If so there is no need to recreate the command and we can //// safely ignore the exception. TraceService.WriteError("CommandManager::AddMenuItem ArgumentException"); TraceService.WriteLine("commandName=" + vsCommandInfo.Name); TraceService.WriteError("message=" + exception.Message); TraceService.WriteError("parameterName=" + exception.ParamName); TraceService.WriteError("stackTrace=" + exception.StackTrace); } }
/// <summary> /// Gets the project path. /// </summary> /// <param name="instance">The instance.</param> /// <returns>The project path.</returns> public static string GetProjectPath(this Project instance) { string path = string.Empty; try { path = Path.GetDirectoryName(instance.FullName); } catch (Exception exception) { TraceService.WriteError("ProjectExtensions::GetProjectPath exception=" + exception.Message); } return(path); }
/// <summary> /// Sorts the and remove using statements. /// </summary> /// <param name="instance">The instance.</param> public static void SortAndRemoveUsingStatements(this ProjectItem instance) { try { string ConstantsvsViewKindCode = "{7651A701-06E5-11D1-8EBD-00A0C90F26EA}"; Window window = instance.Open(ConstantsvsViewKindCode); window.Activate(); instance.DTE.ExecuteCommand("Edit.RemoveAndSort"); } catch (Exception exception) { TraceService.WriteError("SortAndRemoveUsingStatements " + exception.Message); } }
/// <summary> /// Moves the using statements. /// </summary> /// <param name="instance">The instance.</param> public static void MoveUsingStatements(this ProjectItem instance) { List <string> usingStatements = new List <string>(); try { foreach (CodeElement codeElement in instance.FileCodeModel.CodeElements) { //// assume the using statements come before the required namespace. if (codeElement.Kind == vsCMElement.vsCMElementImportStmt) { TextPoint startPoint = codeElement.StartPoint; TextPoint endPoint = codeElement.EndPoint; string text = startPoint.CreateEditPoint().GetText(endPoint); usingStatements.Add(text); } else if (codeElement.Kind == vsCMElement.vsCMElementNamespace) { TextPoint nameSpacePoint = codeElement.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = nameSpacePoint.CreateEditPoint(); foreach (string statement in usingStatements) { editPoint.Insert("\t" + statement + "\n"); } } } //// now perform the deletes. for (int i = 1; i <= instance.FileCodeModel.CodeElements.Count; i++) { CodeElement codeElement = instance.FileCodeModel.CodeElements.Item(i); if (codeElement.Kind == vsCMElement.vsCMElementImportStmt) { instance.FileCodeModel.Remove(codeElement); } } } catch (Exception exception) { TraceService.WriteError("MoveUsingStatements " + exception.Message); } }
/// <summary> /// Suspends the resharper if requested. /// </summary> public void SuspendResharperIfRequested() { if (this.settingsService.SuspendReSharperDuringBuild) { TraceService.WriteLine("SuspendResharper"); try { //// this could fail so catch exception. this.visualStudioService.DTEService.ExecuteCommand(Settings.SuspendReSharperCommand); } catch (Exception exception) { TraceService.WriteError("Error Suspending ReSharper exception=" + exception.Message); } } }
/// <summary> /// Sorts the and remove using statements. /// </summary> /// <param name="instance">The instance.</param> public static void SortAndRemoveUsingStatements(this ProjectItem instance) { TraceService.WriteLine("ProjectItemExtensions::SortAndRemoveUsingStatements in file " + instance.Name); try { Window window = instance.Open(VSConstants.VsViewKindCode); window.Activate(); instance.DTE.ExecuteCommand("Edit.RemoveAndSort"); } catch (Exception exception) { TraceService.WriteError("SortAndRemoveUsingStatements " + exception.Message); } }
/// <summary> /// Adds the converters. /// </summary> public void AddConverters() { this.AddTraceHeader("AddConverters"); if (this.visualStudioService.IsMvvmCrossSolution) { string templatesPath = this.settingsService.ConvertersTemplatesPath; List <ItemTemplateInfo> itemTemplateInfos = this.visualStudioService.GetFolderTemplateInfos(templatesPath, "Converters"); ItemTemplatesForm form = new ItemTemplatesForm(itemTemplateInfos); form.ShowDialog(); if (form.Continue) { this.visualStudioService.DTE2.WriteStatusBarMessage("Ninja Coder is running...."); Project project = this.visualStudioService.CoreProject; if (project != null) { foreach (ItemTemplateInfo templateInfo in form.RequiredTemplates) { TraceService.WriteLine("MvvmCrossController::AddConverters adding from template path " + templatesPath + " template=" + templateInfo.FileName); project.AddToFolderFromTemplate("Converters", templateInfo.FileName, templateInfo.FriendlyName + ".cs"); } //// now collapse the solution! this.visualStudioService.DTE2.CollapseSolution(); this.visualStudioService.DTE2.WriteStatusBarMessage("Ninja Coder has completed the adding of the converters."); } else { TraceService.WriteError("MvvmCrossController::AddConverters Cannot find Core project"); } } } else { MessageBox.Show("This solution is not a MvvmCross solution.", Settings.ApplicationName); } }
/// <summary> /// Replaces the text. /// </summary> /// <param name="instance">The instance.</param> /// <param name="text">The text.</param> /// <param name="replacementText">The replacement text.</param> /// <param name="findOptions">The find options.</param> public static void ReplaceText( this ProjectItem instance, string text, string replacementText, int findOptions = (int)vsFindOptions.vsFindOptionsMatchCase) { TraceService.WriteLine("ProjectItemExtensions::ReplaceText in file " + instance.Name + " from '" + text + "' to '" + replacementText + "'"); if (instance.Kind == VSConstants.VsProjectItemKindPhysicalFolder) { foreach (ProjectItem projectItem in instance.ProjectItems.Cast <ProjectItem>()) { projectItem.ReplaceText(text, replacementText); } return; } try { Window window = instance.Open(VSConstants.VsViewKindCode); if (window != null) { window.Activate(); TextSelection textSelection = instance.DTE.ActiveDocument.Selection; textSelection.SelectAll(); bool replaced = textSelection.ReplacePattern(text, replacementText, findOptions); TraceService.WriteLine(replaced ? "Replaced" : "NOT replaced"); instance.Save(); } else { TraceService.WriteLine("Could not open window to do replacement for " + instance.Name); } } catch (Exception exception) { TraceService.WriteError("Replacing Text failed for " + instance.Name + " exception=" + exception); } }
/// <summary> /// Moves the using statements. /// </summary> /// <param name="instance">The instance.</param> public static void MoveUsingStatements(this ProjectItem instance) { TraceService.WriteLine("ProjectItemExtensions::MoveUsingStatements in file " + instance.Name); List <string> usingStatements = new List <string>(); try { foreach (CodeElement codeElement in instance.FileCodeModel.CodeElements) { //// assume the using statements come before the required namespace. switch (codeElement.Kind) { case vsCMElement.vsCMElementImportStmt: TextPoint startPoint = codeElement.StartPoint; TextPoint endPoint = codeElement.EndPoint; string text = startPoint.CreateEditPoint().GetText(endPoint); usingStatements.Add(text); break; case vsCMElement.vsCMElementNamespace: TextPoint nameSpacePoint = codeElement.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = nameSpacePoint.CreateEditPoint(); foreach (string statement in usingStatements) { editPoint.Insert("\t" + statement + "\n"); } break; } } instance.DeleteNameSpaceUsingStatements(); } catch (Exception exception) { TraceService.WriteError("MoveUsingStatements " + exception.Message); } }
/// <summary> /// Runs this instance. /// </summary> public void Run() { this.AddTraceHeader("ServicesController", "Run"); if (this.VisualStudioService.IsMvvmCrossSolution) { string templatesPath = this.SettingsService.ServicesTemplatesPath; List <ItemTemplateInfo> itemTemplateInfos = this.VisualStudioService.GetFolderTemplateInfos(templatesPath, "Services"); ServicesForm form = new ServicesForm(this.GetViewModelNames(), itemTemplateInfos, this.SettingsService.DisplayLogo); form.ShowDialog(); if (form.Continue) { this.WriteStatusBarMessage("Ninja Coder is running...."); Project project = this.VisualStudioService.CoreProject; if (project != null) { List <string> messages = this.servicesService.AddServices( this.VisualStudioService, form.RequiredTemplates, form.ImplementInViewModel, form.IncludeUnitTests); //// show the readme. this.ShowReadMe("Add Services", messages); this.WriteStatusBarMessage("Ninja Coder has completed the adding of the services."); } else { TraceService.WriteError("ServicesController::AddServices Cannot find Core project"); } } } else { this.ShowNotMvvmCrossSolutionMessage(); } }
/// <summary> /// Lists all commands. /// </summary> protected void ListAllCommands() { TraceService.WriteLine("CommandManager::ListAllCommands"); try { Commands2 commands = (Commands2)this.VsInstance.ApplicationObject.Commands; CommandBarPopup toolsMenuPopUp = this.VsInstance.ApplicationObject.GetToolsMenuPopUp(); for (int i = 1; i <= toolsMenuPopUp.CommandBar.Controls.Count; i++) { TraceService.WriteLine(toolsMenuPopUp.CommandBar.Controls[i].Caption); } } catch (Exception exception) { TraceService.WriteError("exception=" + exception.Message); } }
/// <summary> /// Gets the folder. /// </summary> /// <param name="instance">The instance.</param> /// <param name="folderName">Name of the folder.</param> /// <returns>The folder.</returns> public static ProjectItem GetFolder( this Project instance, string folderName) { TraceService.WriteDebugLine("ProjectExtensions::GetFolder project=" + instance.Name + " folderName=" + folderName); try { List <ProjectItem> projectItems = instance.ProjectItems?.Cast <ProjectItem>().ToList(); return(projectItems?.Where(projectItem => projectItem.Kind == VSConstants.VsProjectItemKindPhysicalFolder) .FirstOrDefault(projectItem => projectItem.Name == folderName)); } catch (Exception exception) { TraceService.WriteError("exception=" + exception.Message); return(null); } }