private void OnDeleteRecipe(object sender, EventArgs e) { if (this.lstRecipes.SelectedItems.Count != 1) { return; } if (MessageBox.Show(this, Configuration.Resources.PackageManager_ConfirmDeleteReference, this.Text, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes) { try { ReferenceInfo refinfo = (ReferenceInfo)lstRecipes.SelectedItems[0].Tag; IAssetReferenceService refsvc = (IAssetReferenceService) ServiceHelper.GetService(refinfo.Reference, typeof(IAssetReferenceService)); refsvc.Remove(refinfo.Reference); this.lstRecipes.Items.Remove(lstRecipes.SelectedItems[0]); if (this.lstRecipes.Items.Count != 0) { this.lstRecipes.SelectedIndices.Clear(); this.lstRecipes.SelectedIndices.Add(0); } else { this.txtDescription.Clear(); } } catch (Exception ex) { ErrorHelper.Show((IUIService)GetService(typeof(IUIService)), ex); } } }
/// <summary> /// Removes the previously added reference, if it was created /// </summary> public override void Undo() { if (newReference != null) { IAssetReferenceService referenceService = (IAssetReferenceService)GetService(typeof(IAssetReferenceService)); referenceService.Remove(newReference); } }
/// <summary> /// Removes the previously added reference, if it was created /// </summary> public override void Undo() { if (addedReference != null) { IAssetReferenceService referenceService = GetService <IAssetReferenceService>(true); referenceService.Remove(addedReference); } }
/// <summary> /// <seealso cref="IAction.Undo"/> /// </summary> public override void Undo() { IAssetReferenceService referenceService = GetService <IAssetReferenceService>(true); foreach (IAssetReference asset in this.referencesAdded) { referenceService.Remove(asset); } referencesAdded.Clear(); }
/// <summary> /// Removes the previously added reference /// </summary> public override void Undo() { IAssetReferenceService service = GetService <IAssetReferenceService>(true); if (reference != null) { service.Remove(reference); reference = null; } }
public override void Execute() { if (OldReference == null) { return; } IRecipeManagerService manager = (IRecipeManagerService) ServiceHelper.GetService(this, typeof(IRecipeManagerService)); // Add the references to the target package. GuidancePackage package = manager.GetPackage(targetPackage); IAssetReferenceService referenceService = (IAssetReferenceService) ServiceHelper.GetService(package, typeof(IAssetReferenceService), this); IPersistenceService persist = (IPersistenceService) ServiceHelper.GetService(this, typeof(IPersistenceService)); try { IDictionary state = persist.LoadState(package.Configuration.Name, OldReference); if ((target != null) && !(target is DummyDTE.EmptyDteElement)) { //We have to get the real object Project for case of Solution Folder object realTarget = target; if (target is SolutionFolder) { realTarget = ((SolutionFolder)target).Parent; } if (OldReference is VsBoundReference) { ((VsBoundReference)OldReference).SetTarget(realTarget); } else if (OldReference is BoundTemplateReference) { ((BoundTemplateReference)OldReference).BoundReference.SetTarget(realTarget); } referenceService.Add(OldReference, state); } } catch (Exception ex) { if (OldReference != null) { referenceService.Remove(OldReference); } ErrorHelper.Show(this.Site, ex); } }
/// <summary> /// It creates a dynamic recipe in order to show a dialog that asks the user /// to introduce new targets for all dangling references /// </summary> private void PerformRestore() { if (referencesToFix.Count == 0) { return; } #region Asking to the user string msg; string details; BuildMessage(out msg, out details); if (ErrorHelper.Ask(Properties.Resources.ReferenceRestoreService_StartTitle, msg, details, Properties.Resources.ReferenceRestoreService_ResolveButton, Properties.Resources.ReferenceRestoreService_RemoveButton) == System.Windows.Forms.DialogResult.No) { IAssetReferenceService referenceService = null; GuidancePackage lastPackage = null; foreach (FixupReference lostReference in referencesToFix) { if (lastPackage != lostReference.OwningPackage) { referenceService = (IAssetReferenceService)ServiceHelper.GetService(lostReference.OwningPackage, typeof(IAssetReferenceService), this); } referenceService.Remove(lostReference.OldReference); } return; } #endregion // The pending FixupReferences we added to the list will be ordered // by the template they were in, so we can just build a wizard page // for each group of X of fields for fixup. int maxfields = 5; // Used to create configuration attributes XmlDocument xmlfactory = new XmlDocument(); // Create a package dynamically. Config.GuidancePackage package = CreateDynamicPackage(); Config.Recipe recipe; ArrayList arguments; ArrayList actions; CreateDynamicRecipe(package, out recipe, out arguments, out actions); Page lastpage = null; ArrayList pages = new ArrayList(); ArrayList fields = new ArrayList(maxfields); Hashtable argumentNamesUsed = new Hashtable(7); int nPages = referencesToFix.Count / maxfields; if ((referencesToFix.Count % maxfields) != 0) { nPages++; } Hashtable referenceDictionary = CreateFixupPages(maxfields, xmlfactory, arguments, actions, ref lastpage, pages, ref fields, nPages); lastpage.Fields = new Field[fields.Count]; fields.CopyTo(lastpage.Fields, 0); recipe.Arguments = new Config.Argument[arguments.Count]; arguments.CopyTo(recipe.Arguments, 0); if (recipe.Actions == null) { recipe.Actions = new Config.RecipeActions(); } recipe.Actions.Action = new Config.Action[actions.Count]; actions.CopyTo(recipe.Actions.Action, 0); Wizard wizard = new Wizard(); wizard.SchemaVersion = "1.0"; wizard.Pages = new Page[pages.Count]; pages.CopyTo(wizard.Pages, 0); // Get the wizard in XML form so that it's passed to the recipe execution. SerializeToAny(recipe, wizard); EnableAndExecute(package, referenceDictionary); }
private ExecutionResult Execute(string recipe, IAssetReference reference, IDictionary arguments) { if (recipe == null) { throw new ArgumentNullException("recipe"); } ThrowIfAlreadyExecutingRecipe(); Config.Recipe config = ThrowIfRecipeNotConfigured(recipe); ReferenceService referenceService = null; try { string appliesTo = GetReferenceAppliesToOrErrorMessage(reference); this.TraceInformation(Properties.Resources.Recipe_StartingExecution, recipe, reference != null ? String.Format(Properties.Resources.Recipe_ReferenceApplied, appliesTo) : ""); // This "parent" loader service is the one we created in OnSited that // wraps the one provided by the recipe manager itself, and adds resolution // relative to the package assembly location. ITypeResolutionService loader = GetService <ITypeResolutionService>(true); // Create the recipe from the configuration. currentRecipe = new Recipe(config); currentReference = reference; // Setup the alias resolution "gateway" loader service. // This resolves aliases defined for the recipe only. // This service will go away together with the recipe. currentRecipe.AddService(typeof(ITypeResolutionService), new AliasResolutionService( config.TypeAliasesByName, loader)); bool isPersisted; IPersistenceService persistenceService; arguments = LoadPersitedState(reference, arguments, out isPersisted, out persistenceService); // Construct the dictionary service. We don't pass the arguments at this // point as we want to go over the process of setting each in turn, so they are validated. DictionaryService dictionarysvc = new DictionaryService(null); AddService(typeof(IDictionaryService), dictionarysvc); // Expose the IComponentChangeService implementation too. AddService(typeof(IComponentChangeService), dictionarysvc); if (arguments != null && arguments.Count > 0) { bool shouldUpdateState = InitializeDictionaryService(arguments, dictionarysvc); // Persist changes if appropriate. if (isPersisted && shouldUpdateState) { persistenceService.SaveState(Configuration.Name, reference, arguments); } } // Construct the dictionary service, passing the persisted state (or null) as well // as the arguments configuration. // Site and execute the recipe. Add(currentRecipe); referenceService = new ReferenceService(); currentRecipe.AddService(typeof(IReferenceService), referenceService); bool allowsuspend = (reference != null && reference is IBoundAssetReference) || (arguments != null); EnsureInitializeMetadataForCurrentRecipe(); ExecutionResult result = currentRecipe.Execute(allowsuspend); this.TraceInformation(Properties.Resources.Recipe_ExecutionResult, result); if (result == ExecutionResult.Finish) { // If recipe is not recurrent and it's a bound reference, remove it. if (!currentRecipe.Configuration.Recurrent && reference is IBoundAssetReference) { IAssetReferenceService refsvc = GetService <IAssetReferenceService>(true); refsvc.Remove(reference); // Remove the persisted state. persistenceService.RemoveState(Configuration.Name, reference); } // Fire the AfterRecipeExecution event // note this will happen only when the recipe is finished (not suspend nor cancelled) if (AfterRecipeExecution != null) { this.AfterRecipeExecution(this, new RecipeEventArgs(config, isExecutingRecipeFromTemplate)); } } return(result); } finally { #region Cleanup if (referenceService != null) { currentRecipe.RemoveService(typeof(IReferenceService)); } // Remove recipe from container. Remove(currentRecipe); // Remove services we added. RemoveService(typeof(IDictionaryService)); RemoveService(typeof(IComponentChangeService)); // Dispose and clean current variables. if (currentRecipe != null) { currentRecipe.Dispose(); currentRecipe = null; } currentReference = null; #endregion Cleanup // Write a separator on the trace. this.TraceInformation(new string('-', 150)); } }