public void VsTextViewCreated(IVsTextView textViewAdapter)
{
TextView = AdapterService.GetWpfTextView(textViewAdapter);
if (TextView == null)
{
return;
}
TextBuffer = TextView.TextBuffer as ITextBuffer2;
if (TextBuffer == null)
{
return;
}
if (TextView.TextBuffer.Properties.ContainsProperty(typeof(ITextDocument)))
{
FileName = (TextView.TextBuffer.Properties[typeof(ITextDocument)] as ITextDocument).FilePath;
if (System.IO.Path.GetExtension(FileName).ToLower() == EditorFactory.Extension.ToLower() &&
textViewAdapter.GetBuffer(out IVsTextLines textLines) == VSConstants.S_OK)
{
Model = ViewModelCoordinator.GetViewModel(FileName, textLines);
TextView.Closed += TextViewClosedHandler;
TextBuffer.ChangedOnBackground += TextBufferChangedHandler;
IsRegisteredForChangeTracking = true;
}
}
}
private void TextViewClosedHandler(object sender, EventArgs e)
{
if (IsRegisteredForChangeTracking)
{
ViewModelCoordinator.ReleaseViewModel(FileName);
TextView.Closed -= TextViewClosedHandler;
TextBuffer.ChangedOnBackground -= TextBufferChangedHandler;
IsRegisteredForChangeTracking = false;
}
}
protected override void OnClose()
{
ThreadHelper.ThrowIfNotOnUIThread();
if (_thisPackage.ActiveDesignerControl == Content)
{
_thisPackage.ActiveDesignerControl = null;
}
ViewModelCoordinator.ReleaseViewModel(FileName);
// 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();
}
/// <summary>
/// Called after the WindowPane has been sited with an IServiceProvider from the environment
///
protected override void Initialize()
{
ThreadHelper.ThrowIfNotOnUIThread();
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
ComponentResourceManager resources = new 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
_model = ViewModelCoordinator.GetViewModel(_fileName, _textBuffer);
_model.UndoManager = _undoManager;
// Set up the build action for this file
SetBuildAction(_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 DesignerControl(_thisPackage, _model, GetService(typeof(STrackSelection)) as ITrackSelection);
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)VSStd97CmdID.ViewCode,
new EventHandler(OnViewCode), new EventHandler(OnQueryViewCode));
}
InitializeToolbox();
}
