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 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)
{
}
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)
{
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);
if (fromProject != null &&
GetDocumentIds(fromProject).Contains(DocumentId))
{
var updatedProject = fromProject.RemoveDocument(DocumentId);
Workspace.TryApplyChanges(updatedProject.Solution);
}
}
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;
}
