private void Workspace_DocumentOpened(object sender, DocumentEventArgs e)
 {
     lock (_gate)
     {
         _openDocumentContexts.Add(e.Document.Id, Task.Run(() => GetConventionContextAsync(e.Document.FilePath, CancellationToken.None)));
     }
 }

		void HandleDocumentClosed (object sender, DocumentEventArgs e)
		{
			if (e.Document == null || e.Document.Editor == null || e.Document.Editor.Parent == null) return;

			e.Document.Editor.Parent.ButtonReleaseEvent -= HandleButtonReleaseEvent;
			e.Document.Editor.Parent.MotionNotifyEvent -= HandleMotionNotifyEvent;
		}

            private void OnDocumentActiveContextChanged(object sender, DocumentEventArgs e)
            {
                var document = SubjectBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();

                if (document != null && document.Id == e.Document.Id)
                {
                    this.RaiseChanged();
                }
            }

 private void OnDocumentOpened(object sender, DocumentEventArgs e)
 {
     InvokeBelowInputPriority(() =>
     {
         if (!_isDisposed)
         {
             SetReadOnly(e.Document);
         }
     });
 }

 private void OnDocumentClosed(object sender, DocumentEventArgs e)
 {
     // The buffer is gone by now, so we don't need to remove the read-only region from it, just clean up our dictionary.
     InvokeBelowInputPriority(() =>
     {
         if (_readOnlyRegions != null)
         {
             _readOnlyRegions.Remove(e.Document.Id);
         }
     });
 }

        private void Workspace_DocumentClosed(object sender, DocumentEventArgs e)
        {
            lock (_gate)
            {
                if (_openDocumentContexts.TryGetValue(e.Document.Id, out var contextTask))
                {
                    _openDocumentContexts.Remove(e.Document.Id);

                    // Ensure we dispose the context, which we'll do asynchronously
                    contextTask.ContinueWith(
                        t => t.Result.Dispose(),
                        CancellationToken.None,
                        TaskContinuationOptions.OnlyOnRanToCompletion,
                        TaskScheduler.Default);
                }
            }
        }

		void HandleDocumentOpened (object sender, DocumentEventArgs e)
		{
			if (!(e.Document.Project is DotNetProject) || !e.Document.IsFile)
				return;
			string ext = e.Document.FileName;
			if (!ext.EndsWith (".addin.xml") && !ext.EndsWith (".addin"))
				return;
			
			var data = AddinData.GetAddinData ((DotNetProject)e.Document.Project);
			if (data != null) {
				IWorkbenchWindow window = e.Document.Window;
				var adesc = data.AddinRegistry.ReadAddinManifestFile (e.Document.FileName);
				
				window.AttachViewContent (new ExtensionEditorView (adesc, data));
				window.AttachViewContent (new ExtensionPointsEditorView (adesc, data));
			}
			
		}

 private void OnDocumentOpened(object sender, DocumentEventArgs args)
 {
     this.Parse(args.Document);
 }

 private void OnDocumentOpened(object sender, DocumentEventArgs e)
 {
     InvokeBelowInputPriority(() => TrackDocument(e.Document.Id));
 }

 private void events_DocumentClosing(DocumentEventArgs ea)
 {
     UpdateMarkerList();
 }

 private void OnDocumentClosed(object sender, DocumentEventArgs args)
 {
     this.CancelParse(args.Document.Id);
 }

 private void OnDocumentOpened(object sender, DocumentEventArgs args)
 {
     if (_workspace != null)
     {
         ParseIfThisDocument(null, args.Document.Project.Solution, args.Document.Id);
     }
 }

 /// <summary>
 /// The event handler is creating a new document.
 /// </summary>
 /// <param name="args"></param>
 protected override void NewDocumentCreatedEventHandler(DocumentEventArgs args)
 {
     args.Document.AttachPlugin(this);
 }

 private void OnDocumentClosed(object sender, DocumentEventArgs e)
 {
     var asyncToken = _listener.BeginAsyncOperation("OnDocumentClosed");
     _eventProcessingQueue.ScheduleTask(
         () => EnqueueWorkItemAsync(e.Document, InvocationReasons.DocumentClosed), _shutdownToken).CompletesAsyncOperation(asyncToken);
 }

 private void OnDocumentActiveContextChanged(object sender, DocumentEventArgs e)
 {
     Reanalyze(e.Document.Project.Solution.Workspace, documentIds: SpecializedCollections.SingletonEnumerable(e.Document.Id));
 }

		void WorkbenchDocumentClosed (object sender, DocumentEventArgs e)
		{
			e.Document.DocumentParsed -= HandleDocumentParsed;
		}

		void WorkbenchDocumentOpened (object sender, DocumentEventArgs e)
		{
			e.Document.DocumentParsed += HandleDocumentParsed;
		}

        private void DocEventsOnDocumentOpened(object sender, DocumentEventArgs args)
        {
            try
            {
                var solution = GetSolution();
                if (solution == null)
                    return;

                HandleActivity(args.Document.FileName, false);
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("DocEventsOnDocumentOpened : " + ex.Message);
            }
        }

 /// <summary>
 /// The event handler that occurs before you save the document.
 /// </summary>
 /// <param name="args"></param>
 protected override void SavingDocumentEventHandler(DocumentEventArgs args)
 {
     VariablesEventHandler();
 }

 /// <summary>
 /// The event handler open the document.
 /// </summary>
 /// <param name="args"></param>
 protected override void DocumentOpenEventHandler(DocumentEventArgs args)
 {
     args.Document.AttachPlugin(this);
 }