private IEnumerable <IOleUndoUnit> GetUndoUnits(IOleUndoManager undoManager) { // Unfortunately, EnumUndoable returns the units in oldest-first order. undoManager.EnumUndoable(out var undoUnitEnumerator); if (undoUnitEnumerator == null) { yield break; } const int BatchSize = 100; while (true) { IOleUndoUnit[] fetchedUndoUnits = new IOleUndoUnit[BatchSize]; undoUnitEnumerator.Next(BatchSize, fetchedUndoUnits, out var fetchedCount); for (int i = 0; i < fetchedCount; i++) { yield return(fetchedUndoUnits[i]); } if (fetchedCount < BatchSize) { break; } } }
private IEnumerable <IOleUndoUnit> GetUndoUnits(IOleUndoManager undoManager) { IEnumOleUndoUnits undoUnitEnumerator; try { // Unfortunately, EnumUndoable returns the units in oldest-first order. undoManager.EnumUndoable(out undoUnitEnumerator); } catch (COMException) { yield break; } const int BatchSize = 100; var fetchedUndoUnits = new IOleUndoUnit[BatchSize]; while (true) { undoUnitEnumerator.Next(BatchSize, fetchedUndoUnits, out var fetchedCount); for (var i = 0; i < fetchedCount; i++) { yield return(fetchedUndoUnits[i]); } if (fetchedCount < BatchSize) { break; } } }
protected virtual int Do(IOleUndoManager oleUndoManager) { try { if (unitState == UndoUnitState.Undoing) { UndoAction(); } else { RedoAction(); } unitState = (unitState == UndoUnitState.Undoing) ? UndoUnitState.Redoing : UndoUnitState.Undoing; if (oleUndoManager != null) { oleUndoManager.Add(this); } return(VSConstants.S_OK); } catch (COMException e) { return(e.ErrorCode); } catch { return(VSConstants.E_ABORT); } finally { } }
protected override void OnClose() { // unhook from Undo related services if (_undoManager != null) { IVsLinkCapableUndoManager linkCapableUndoMgr = (IVsLinkCapableUndoManager)_undoManager; if (linkCapableUndoMgr != null) { linkCapableUndoMgr.UnadviseLinkedUndoClient(); } // Throw away the undo stack etc. // It is important to “zombify†the undo manager when the owning object is shutting down. // This is done by calling IVsLifetimeControlledObject.SeverReferencesToOwner on the undoManager. // This call will clear the undo and redo stacks. This is particularly important to do if // your undo units hold references back to your object. It is also important if you use // "mdtStrict" linked undo transactions as this sample does (see IVsLinkedUndoTransactionManager). // When one object involved in linked undo transactions clears its undo/redo stacks, then // the stacks of the other documents involved in the linked transaction will also be cleared. IVsLifetimeControlledObject lco = (IVsLifetimeControlledObject)_undoManager; lco.SeverReferencesToOwner(); _undoManager = null; } IOleComponentManager mgr = GetService(typeof(SOleComponentManager)) as IOleComponentManager; mgr.FRevokeComponent(_componentId); Dispose(true); base.OnClose(); }
private bool TryUninstallAndAddRedoAction( string source, string packageName, string versionOpt, bool includePrerelease, EnvDTE.DTE dte, EnvDTE.Project dteProject, IOleUndoManager undoManager ) { var uninstalled = TryUninstallPackage(packageName, dte, dteProject); if (uninstalled) { // if the install succeeded, then add an uninstall item to the undo manager. undoManager?.Add( new InstallPackageUndoUnit( this, source, packageName, versionOpt, includePrerelease, dte, dteProject, undoManager ) ); } return(uninstalled); }
public void Do(IOleUndoManager pUndoManager) { // docs say this can be null. if (pUndoManager != null) { // use this as the undo unit also. pUndoManager.Open(this); } var units = _children; _children = new List <IOleUndoUnit>(); // Invoke child units in reverse order. for (var i = units.Count - 1; i >= 0; i--) { var child = units[i]; child.Do(pUndoManager); } if (pUndoManager != null) { NativeMethods.ThrowOnFailure(pUndoManager.Close(this, 1)); } }
protected override void OnClose() { // unhook from Undo related services if (_undoManager != null) { IVsLinkCapableUndoManager linkCapableUndoMgr = (IVsLinkCapableUndoManager)_undoManager; if (linkCapableUndoMgr != null) { linkCapableUndoMgr.UnadviseLinkedUndoClient(); } // Throw away the undo stack etc. // It is important to “zombify†the undo manager when the owning object is shutting down. // This is done by calling IVsLifetimeControlledObject.SeverReferencesToOwner on the undoManager. // This call will clear the undo and redo stacks. This is particularly important to do if // your undo units hold references back to your object. It is also important if you use // "mdtStrict" linked undo transactions as this sample does (see IVsLinkedUndoTransactionManager). // When one object involved in linked undo transactions clears its undo/redo stacks, then // the stacks of the other documents involved in the linked transaction will also be cleared. IVsLifetimeControlledObject lco = (IVsLifetimeControlledObject)_undoManager; lco.SeverReferencesToOwner(); _undoManager = null; } IOleComponentManager mgr = GetService(typeof(SOleComponentManager)) as IOleComponentManager; mgr?.FRevokeComponent(_componentId); Dispose(true); base.OnClose(); }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); if (fromProject != null) { var reference = fromProject.MetadataReferences.OfType <PortableExecutableReference>() .FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath, _filePath)); if (reference == null) { try { reference = MetadataReference.CreateFromFile(_filePath); } catch (IOException) { return; } var updatedProject = fromProject.AddMetadataReference(reference); Workspace.TryApplyChanges(updatedProject.Solution); } } }
/// <summary> /// IOleUndoUnit member - called when user selects to undo/redo an action /// </summary> public void Do(IOleUndoManager pUndoManager) { // do all PrependUnits List <IOleUndoUnit> prepunits = HandleUnits(PrependUnits, pUndoManager); if (isUndo) { Undo(); } else { Redo(); } // do all AppendUnits List <IOleUndoUnit> appunits = HandleUnits(AppendUnits, pUndoManager); this.AppendUnits.Clear(); this.PrependUnits.Clear(); this.AppendUnits.AddRange(appunits); this.PrependUnits.AddRange(prepunits); // add this to the opposite stack pUndoManager.Add(this); // undo unit becomes redo unit isUndo = !isUndo; }
public UninstallPackageUndoUnit( PackageInstallerService packageInstallerService, string source, string packageName, string versionOpt, EnvDTE.DTE dte, EnvDTE.Project dteProject, IOleUndoManager undoManager) : base(packageInstallerService, source, packageName, versionOpt, dte, dteProject, undoManager) { }
private bool TryUninstallAndAddRedoAction(string source, string packageName, string versionOpt, EnvDTE.DTE dte, EnvDTE.Project dteProject, IOleUndoManager undoManager) { var uninstalled = TryUninstallPackage(packageName, dte, dteProject); if (uninstalled) { // if the install succeeded, then add an uninstall item to the undo manager. undoManager?.Add(new InstallPackageUndoUnit(this, source, packageName, versionOpt, dte, dteProject, undoManager)); } return uninstalled; }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> SetLayerActiveRecord.Do"); #endif ViewModel.Layer newLayer = Controller.StateMachine.Find(Id) as ViewModel.Layer; ViewModel.Layer oldLayer = Controller.StateMachine.Find(OldLayerId) as ViewModel.Layer; Designer.CurrentLayer = newLayer; }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine($@">>> ListValuedPropertyChangedRecord.Do (Property {PropertyName}, Value: {ArrayToString(Value)})"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ObjectModel.TrackableObject trackableObject = Controller.StateMachine.Find(Id); trackableObject?.SetProperty(PropertyName, Value); } }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); if (fromProject != null) { var updatedProject = AddDocument(fromProject); Workspace.TryApplyChanges(updatedProject.Solution); } }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); if (fromProject != null && GetDocumentIds(fromProject).Contains(DocumentId)) { var updatedProject = fromProject.RemoveDocument(DocumentId); Workspace.TryApplyChanges(updatedProject.Solution); } }
public override void Do(IOleUndoManager pUndoManager) { packageInstallerService.TryInstallAndAddUndoAction( source, packageName, versionOpt, includePrerelease, dte, dteProject, undoManager ); }
public void Do(IOleUndoManager pUndoManager) { // Using FirstOrDefault because we only need to rename one document, as that will get // applied to linked files. var documentId = _workspace.CurrentSolution.GetDocumentIdsWithFilePath(_filePath).FirstOrDefault(); if (documentId != null) { var updatedSolution = _workspace.CurrentSolution.WithDocumentName(documentId, _toName); _workspace.TryApplyChanges(updatedSolution); } }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); var reference = fromProject?.MetadataReferences.OfType<PortableExecutableReference>() .FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath, _filePath)); if (reference != null) { var updatedProject = fromProject.RemoveMetadataReference(reference); Workspace.TryApplyChanges(updatedProject.Solution); } }
private IOleUndoManager GetUndoManager() { if (oleUndoManager == null) { Guid SID_SOleUndoManager = new Guid("D001F200-EF97-11CE-9BC9-00AA00608E01"); Guid IID_IOleUndoManager = new Guid("D001F200-EF97-11CE-9BC9-00AA00608E01"); UCOMIServiceProvider isp = (UCOMIServiceProvider)htmlDoc; IntPtr ip = isp.QueryService(ref SID_SOleUndoManager, ref IID_IOleUndoManager); oleUndoManager = (IOleUndoManager)Marshal.GetObjectForIUnknown(ip); } return(oleUndoManager); }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); var reference = fromProject?.MetadataReferences.OfType <PortableExecutableReference>() .FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath, _filePath)); if (reference != null) { var updatedProject = fromProject.RemoveMetadataReference(reference); Workspace.TryApplyChanges(updatedProject.Solution); } }
private async Task DoAsync(IOleUndoManager pUndoManager) { try { await DoWorkerAsync(pUndoManager).ConfigureAwait(false); } catch (OperationCanceledException) { } catch (Exception e) when(FatalError.ReportAndCatch(e)) { } }
protected override async Task DoWorkerAsync(IOleUndoManager pUndoManager) { var description = string.Format(ServicesVSResources.Installing_0, packageName); using var context = this.packageInstallerService._operationExecutor.BeginExecute(NugetTitle, description, allowCancellation: true, showProgress: false); using var scope = context.AddScope(allowCancellation: true, description); await packageInstallerService.TryInstallAndAddUndoActionAsync( source, packageName, version, includePrerelease, projectGuid, dte, dteProject, undoManager, new UIThreadOperationContextProgressTracker(scope), context.UserCancellationToken).ConfigureAwait(false); }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> AddEventTypeRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.EventType newEventType = new EventType(Controller, this); Controller.StateMachine.EventTypes.Add(newEventType); Controller.UndoManager.Add(new DeleteEventTypeRecord(Controller, newEventType)); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> AddGroupRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.Group newGroup = new ViewModel.Group(Controller, this); Controller.StateMachine.Groups.Add(newGroup); Controller.UndoManager.Add(new DeleteGroupRecord(Controller, newGroup)); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> AddTransitionRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.Transition newTransition = new ViewModel.Transition(Controller, this); Controller.StateMachine.Transitions.Add(newTransition); Controller.UndoManager.Add(new DeleteTransitionRecord(Controller, newTransition)); } }
public virtual void Do(IOleUndoManager undoManager) { if (undoManager != null) undoManager.Add(this); if (Undo) HandleUndo(); else HandleRedo(); //invert the undo state Undo = !Undo; }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> AddActionReferenceRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.ActionReference newActionReference = new ViewModel.ActionReference(Controller, this); newActionReference.Transition.ActionReferences.Insert(Slot, newActionReference); Controller.UndoManager.Add(new DeleteActionReferenceRecord(Controller, newActionReference)); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> DeleteEventTypeRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.EventType targetEventType = Controller.StateMachine.EventTypes.Where(e => e.Id == Id).First(); AddEventTypeRecord addEventTypeRecord = new AddEventTypeRecord(Controller, targetEventType); Controller.StateMachine.EventTypes.Remove(targetEventType); Controller.UndoManager.Add(addEventTypeRecord); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> DeleteGroupRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.Group targetGroup = Controller.StateMachine.Groups.Where(s => s.Id == Id).First(); AddGroupRecord addGroupRecord = new AddGroupRecord(Controller, targetGroup); Controller.StateMachine.Groups.Remove(targetGroup); Controller.UndoManager.Add(addGroupRecord); } }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); var toProject = currentSolution.GetProject(_toProjectId); if (fromProject != null && toProject != null && fromProject.ProjectReferences.Any(p => p.ProjectId == _toProjectId)) { var updatedProject = fromProject.RemoveProjectReference(new ProjectReference(_toProjectId)); Workspace.TryApplyChanges(updatedProject.Solution); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> DeleteActionReferenceRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.Transition targetTransition = Controller.StateMachine.Find(TransitionId) as ViewModel.Transition; ViewModel.ActionReference targetActionReference = targetTransition.ActionReferences[Slot]; targetTransition.ActionReferences.RemoveAt(Slot); Controller.UndoManager.Add(new AddActionReferenceRecord(Controller, targetActionReference, Slot)); } }
public override void Do(IOleUndoManager pUndoManager) { var currentSolution = Workspace.CurrentSolution; var fromProject = currentSolution.GetProject(FromProjectId); var toProject = currentSolution.GetProject(_toProjectId); if (fromProject != null && toProject != null && !fromProject.ProjectReferences.Any(p => p.ProjectId == _toProjectId)) { var updatedProject = fromProject.AddProjectReference(new ProjectReference(_toProjectId)); Workspace.TryApplyChanges(updatedProject.Solution); } }
public override void Do(IOleUndoManager pUndoManager) { #if DEBUGUNDOREDO Debug.WriteLine(">>> DeleteLayerMemberRecord.Do"); #endif using (new ViewModel.ViewModelController.GuiChangeBlock(Controller)) { ViewModel.Layer layer = Controller.StateMachine.Find(LayerId) as ViewModel.Layer; ObjectModel.ITransitionEndpoint member = Controller.StateMachine.Find(MemberId) as ObjectModel.ITransitionEndpoint; ObjectModel.LayerPosition layerPosition = Controller.StateMachine.Find(Id) as ObjectModel.LayerPosition; Controller.UndoManager.Add(new AddLayerMemberRecord(Controller, layerPosition, member)); member.LayerPositions.Remove(layerPosition); layer.Members.Remove(member); } }
public UninstallPackageUndoUnit( PackageInstallerService packageInstallerService, string source, string packageName, string versionOpt, bool includePrerelease, Guid projectGuid, EnvDTE.DTE dte, EnvDTE.Project dteProject, IOleUndoManager undoManager) : base(packageInstallerService, source, packageName, versionOpt, includePrerelease, projectGuid, dte, dteProject, undoManager) { }
private IOleUndoManager GetUndoManager(ITextBuffer subjectBuffer) { var adapter = _editorAdaptersFactoryService.GetBufferAdapter(subjectBuffer); if (adapter != null) { IOleUndoManager manager = null; if (ErrorHandler.Succeeded(adapter.GetUndoManager(out manager))) { return(manager); } } return(null); }
protected BaseUndoUnit( PackageInstallerService packageInstallerService, string source, string packageName, string versionOpt, EnvDTE.DTE dte, EnvDTE.Project dteProject, IOleUndoManager undoManager) { this.packageInstallerService = packageInstallerService; this.packageName = packageName; this.versionOpt = versionOpt; this.dte = dte; this.dteProject = dteProject; this.undoManager = undoManager; }
public void Do(IOleUndoManager pUndoManager) { // docs say this can be null. if (pUndoManager != null) { // use this as the undo unit also. pUndoManager.Open(this); } var units = _children; _children = new List<IOleUndoUnit>(); // Invoke child units in reverse order. for (var i = units.Count - 1; i >= 0; i--) { var child = units[i]; child.Do(pUndoManager); } if (pUndoManager != null) { NativeMethods.ThrowOnFailure(pUndoManager.Close(this, 1)); } }
/// <summary> /// Called after the WindowPane has been sited with an IServiceProvider from the environment /// protected override void Initialize() { base.Initialize(); // Create and initialize the editor #region Register with IOleComponentManager IOleComponentManager componentManager = (IOleComponentManager)GetService(typeof(SOleComponentManager)); if (this._componentId == 0 && componentManager != null) { OLECRINFO[] crinfo = new OLECRINFO[1]; crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO)); crinfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime | (uint)_OLECRF.olecrfNeedPeriodicIdleTime; crinfo[0].grfcadvf = (uint)_OLECADVF.olecadvfModal | (uint)_OLECADVF.olecadvfRedrawOff | (uint)_OLECADVF.olecadvfWarningsOff; crinfo[0].uIdleTimeInterval = 100; int hr = componentManager.FRegisterComponent(this, crinfo, out this._componentId); ErrorHandler.Succeeded(hr); } #endregion System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(EditorPane)); #region Hook Undo Manager // Attach an IOleUndoManager to our WindowFrame. Merely calling QueryService // for the IOleUndoManager on the site of our IVsWindowPane causes an IOleUndoManager // to be created and attached to the IVsWindowFrame. The WindowFrame automaticall // manages to route the undo related commands to the IOleUndoManager object. // Thus, our only responsibilty after this point is to add IOleUndoUnits to the // IOleUndoManager (aka undo stack). _undoManager = (IOleUndoManager)GetService(typeof(SOleUndoManager)); // In order to use the IVsLinkedUndoTransactionManager, it is required that you // advise for IVsLinkedUndoClient notifications. This gives you a callback at // a point when there are intervening undos that are blocking a linked undo. // You are expected to activate your document window that has the intervening undos. if (_undoManager != null) { IVsLinkCapableUndoManager linkCapableUndoMgr = (IVsLinkCapableUndoManager)_undoManager; if (linkCapableUndoMgr != null) { linkCapableUndoMgr.AdviseLinkedUndoClient(this); } } #endregion // hook up our XmlEditorService es = GetService(typeof(XmlEditorService)) as XmlEditorService; _store = es.CreateXmlStore(); _store.UndoManager = _undoManager; _model = _store.OpenXmlModel(new Uri(_fileName)); // This is the user control hosted by the tool window; Note that, even if this class implements IDisposable, // we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on // the object returned by the Content property. _vsDesignerControl = new VsDesignerControl(_service, new ViewModel(_store, _model, this, _textBuffer)); base.Content = _vsDesignerControl; RegisterIndependentView(true); IMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as IMenuCommandService; if (null != mcs) { // Now create one object derived from MenuCommnad for each command defined in // the CTC file and add it to the command service. // For each command we have to define its id that is a unique Guid/integer pair, then // create the OleMenuCommand object for this command. The EventHandler object is the // function that will be called when the user will select the command. Then we add the // OleMenuCommand to the menu service. The addCommand helper function does all this for us. AddCommand(mcs, VSConstants.GUID_VSStandardCommandSet97, (int)VSConstants.VSStd97CmdID.NewWindow, new EventHandler(OnNewWindow), new EventHandler(OnQueryNewWindow)); AddCommand(mcs, VSConstants.GUID_VSStandardCommandSet97, (int)VSConstants.VSStd97CmdID.ViewCode, new EventHandler(OnViewCode), new EventHandler(OnQueryViewCode)); } }
public int GetUndoManager(out IOleUndoManager ppUndoManager) { return _textBuffer.GetUndoManager(out ppUndoManager); }
/// <summary> /// This class is a decoroator over an IOleUndoManager. It allows a "scope" to be started, and then all subsequent Add() /// call will attach the undo unit to a single ParentUndoUnit. When the "scope" is closed, the ParentUndoUnit is /// added to the "wrapped" IOleUndoManager. This lets multiple undo/redo units be undone in one action by the user. /// </summary> public ParentUndoManager(IOleUndoManager wrappedUndoManager) { _wrappedUndoManager = wrappedUndoManager; }
private IOleUndoManager GetUndoManager() { if (oleUndoManager == null) { Guid SID_SOleUndoManager = new Guid("D001F200-EF97-11CE-9BC9-00AA00608E01"); Guid IID_IOleUndoManager = new Guid("D001F200-EF97-11CE-9BC9-00AA00608E01"); UCOMIServiceProvider isp = (UCOMIServiceProvider)htmlDoc; IntPtr ip = isp.QueryService(ref SID_SOleUndoManager, ref IID_IOleUndoManager); oleUndoManager = (IOleUndoManager)Marshal.GetObjectForIUnknown(ip); } return oleUndoManager; }
public int GetUndoManager(out IOleUndoManager ppUndoManager) { ppUndoManager = null; return VSConstants.E_NOTIMPL; }
public override void Do(IOleUndoManager pUndoManager) { packageInstallerService.TryUninstallAndAddRedoAction(source, packageName, versionOpt, dte, dteProject, undoManager); }
/// <summary> /// The get undo manager. /// </summary> /// <param name="ppUndoManager"> /// The pp undo manager. /// </param> /// <returns> /// The get undo manager. /// </returns> /// <exception cref="Exception"> /// </exception> public int GetUndoManager(out IOleUndoManager ppUndoManager) { throw new Exception("The method or operation is not implemented."); }
public abstract void Do(IOleUndoManager pUndoManager);
public override void Do(IOleUndoManager pUndoManager) { packageInstallerService.TryInstallAndAddUndoAction( source, packageName, versionOpt, includePrerelease, dte, dteProject, undoManager); }
public int GetUndoManager(out IOleUndoManager ppUndoManager) { ppUndoManager = null; return VSConstants.S_OK; }