Exemplo n.º 1
0
        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;
                }
            }
        }
Exemplo n.º 2
0
 private void TextViewClosedHandler(object sender, EventArgs e)
 {
     if (IsRegisteredForChangeTracking)
     {
         ViewModelCoordinator.ReleaseViewModel(FileName);
         TextView.Closed -= TextViewClosedHandler;
         TextBuffer.ChangedOnBackground -= TextBufferChangedHandler;
         IsRegisteredForChangeTracking   = false;
     }
 }
Exemplo n.º 3
0
        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();
        }
Exemplo n.º 4
0
        /// <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();
        }