public int EnumFilenames(out VisualStudio.OLE.Interop.IEnumString ppEnumString)
 {
     // this method doesn't work.  no matter what I do, EnumString throws
     // a null ref inside of Next
     ppEnumString = new EnumString(this.pathProvider);
     return VSConstants.E_NOTIMPL;
 }

 public void VsTextViewCreated(VisualStudio.TextManager.Interop.IVsTextView textViewAdapter)
 {
     ITextView textView = AdapterService.GetWpfTextView(textViewAdapter);
     if (textView != null) {
         BraceMatcher.WatchBraceHighlights(textView, IronRubyToolsPackage.ComponentModel);
     }
 }

 public override void TextViewCreated(IReplWindow window, VisualStudio.Text.Editor.ITextView view)
 {
     var adapterFactory = IronPythonToolsPackage.ComponentModel.GetService<IVsEditorAdaptersFactoryService>();
     new EditFilter(IronPythonToolsPackage.ComponentModel.GetService<IPythonAnalyzer>(), (IWpfTextView)view, adapterFactory.GetViewAdapter(view));
     window.UseSmartUpDown = IronPythonToolsPackage.Instance.OptionsPage.ReplSmartHistory;
     base.TextViewCreated(window, view);
 }

 public void DismissAllSessions(VisualStudio.Text.Editor.ITextView textView) {
     foreach (var session in _stackMap.GetStackForTextView(textView).Sessions) {
         if (session is ISignatureHelpSession) {
             session.Dismiss();
         }
     }
 }

        public ISignatureHelpSession TriggerSignatureHelp(VisualStudio.Text.Editor.ITextView textView) {
            ObservableCollection<ISignature> sets = new ObservableCollection<ISignature>();
            var session = new MockSignatureHelpSession(
                textView,
                sets,
                textView.TextBuffer.CurrentSnapshot.CreateTrackingPoint(
                    textView.Caret.Position.BufferPosition.Position,
                    PointTrackingMode.Negative
                )
            );

            foreach (var provider in _sigProviders) {
                foreach (var targetContentType in provider.Metadata.ContentTypes) {
                    if (textView.TextBuffer.ContentType.IsOfType(targetContentType)) {
                        var source = provider.Value.TryCreateSignatureHelpSource(textView.TextBuffer);
                        if (source != null) {
                            source.AugmentSignatureHelpSession(session, sets);
                        }
                    }
                }
            }

            if (session.Signatures.Count > 0 && !session.IsDismissed) {
                _stackMap.GetStackForTextView(textView).PushSession(session);
            }

            return session;
        }

 public static void RenderCompleteDiagramToView(VisualStudio visualStudio, ref ArchView view)
 {
     var modelGen = new DiagramGenerator(visualStudio.Solution);
     var tree = modelGen.GenerateDiagram(DiagramDefinition.RootDefault);
     var viewModel = LayerMapper.TreeModelToArchViewModel(tree,true,true);
     view.Diagram.RenderModel(viewModel);
 }

 public VisualStudio.TextManager.Interop.IVsTextBuffer GetBufferAdapter(VisualStudio.Text.ITextBuffer textBuffer) {
     MockVsTextLines textLines;
     if (!textBuffer.Properties.TryGetProperty<MockVsTextLines>(typeof(MockVsTextLines), out textLines)) {
         textBuffer.Properties[typeof(MockVsTextLines)] = textLines = new MockVsTextLines(_serviceProvider, (MockTextBuffer)textBuffer);
     }
     return textLines;
 }

 public bool IsSignatureHelpActive(VisualStudio.Text.Editor.ITextView textView) {
     foreach (var session in _stackMap.GetStackForTextView(textView).Sessions) {
         if (session is ISignatureHelpSession) {
             return true;
         }
     }
     return false;
 }

 public NormalCompletionAnalysis(VsProjectAnalyzer vsProjectAnalyzer, ITextSnapshot snapshot, VisualStudio.Text.ITrackingSpan applicableSpan, VisualStudio.Text.ITextBuffer textBuffer, GetMemberOptions options)
     : base(applicableSpan, textBuffer) {
     _analyzer = vsProjectAnalyzer;
     _snapshot = snapshot;
     _applicableSpan = applicableSpan;
     _textBuffer = textBuffer;
     _options = options;
 }

 public RequireCompletionAnalysis(VsProjectAnalyzer vsProjectAnalyzer, ITextSnapshot snapshot, VisualStudio.Text.ITrackingSpan applicableSpan, VisualStudio.Text.ITextBuffer textBuffer, bool quote)
     : base(applicableSpan, textBuffer) {
     _analyzer = vsProjectAnalyzer;
     _snapshot = snapshot;
     _applicableSpan = applicableSpan;
     _textBuffer = textBuffer;
     _quote = quote;
 }

        internal IPythonAnalyzer PythonAnalyzer = null; // Set by MEF

        #endregion Fields

        #region Methods

        public void VsTextViewCreated(VisualStudio.TextManager.Interop.IVsTextView textViewAdapter)
        {
            // TODO: We should probably only track text views in Python projects or loose files.
            ITextView textView = AdapterService.GetWpfTextView(textViewAdapter);
            if (textView != null) {
                PythonAnalyzer.AnalyzeTextView(textView);
            }
        }

 public ReadOnlyCollection<ISignatureHelpSession> GetSessions(VisualStudio.Text.Editor.ITextView textView) {
     List<ISignatureHelpSession> res = new List<ISignatureHelpSession>();
     foreach (var session in _stackMap.GetStackForTextView(textView).Sessions) {
         if (session is ISignatureHelpSession) {
             res.Add(session as ISignatureHelpSession);
         }
     }
     return new ReadOnlyCollection<ISignatureHelpSession>(res);
 }

        protected override void GotoSource(VisualStudio.Shell.Interop.VSOBJGOTOSRCTYPE gotoType)
        {
            // We do not support the "Goto Reference"
            if (VSOBJGOTOSRCTYPE.GS_REFERENCE == gotoType)
            {
                return;
            }

            base.OpenSourceFile();
        }

        public override int? EditFilterQueryStatus(ref VisualStudio.OLE.Interop.OLECMD cmd, IntPtr pCmdText) {
            var activeView = CommonPackage.GetActiveTextView(_serviceProvider);
            if (activeView != null && activeView.TextBuffer.ContentType.IsOfType(PythonCoreConstants.ContentType)) {
                cmd.cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
            } else {
                cmd.cmdf = (uint)(OLECMDF.OLECMDF_INVISIBLE);
            }

            return VSConstants.S_OK;
        }

 private static void RefactoringSetup(TestWorkspace workspace, CodeRefactoringProvider provider, List<CodeAction> refactorings, out ICodeActionEditHandlerService editHandler, out EditorLayerExtensionManager.ExtensionManager extensionManager, out VisualStudio.Text.ITextBuffer textBuffer)
 {
     var document = GetDocument(workspace);
     var span = document.GetSyntaxRootAsync().Result.Span;
     var context = new CodeRefactoringContext(document, span, (a) => refactorings.Add(a), CancellationToken.None);
     provider.ComputeRefactoringsAsync(context).Wait();
     var action = refactorings.Single();
     editHandler = workspace.ExportProvider.GetExportedValue<ICodeActionEditHandlerService>();
     extensionManager = document.Project.Solution.Workspace.Services.GetService<IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
     textBuffer = document.GetTextAsync().Result.Container.GetTextBuffer();
 }

        public override int? EditFilterQueryStatus(ref VisualStudio.OLE.Interop.OLECMD cmd, IntPtr pCmdText) {
            var view = CommonPackage.GetActiveTextView(_serviceProvider);
            var analyzer = view?.GetAnalyzerAtCaret(_serviceProvider);
            var pythonCaret = view?.GetPythonCaret();
            if (view != null && analyzer != null && pythonCaret.HasValue) {
                cmd.cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
            } else {
                cmd.cmdf = (uint)(OLECMDF.OLECMDF_INVISIBLE);
            }

            return VSConstants.S_OK;
        }

        protected override int QueryStatusCommand(uint itemid, ref Guid pguidCmdGroup, uint cCmds, VisualStudio.OLE.Interop.OLECMD[] prgCmds, IntPtr pCmdText) {
            if (pguidCmdGroup == GuidList.guidOfficeSharePointCmdSet) {
                for (int i = 0; i < prgCmds.Length; i++) {
                    // Report it as supported so that it's not routed any
                    // further, but disable it and make it invisible.
                    prgCmds[i].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_INVISIBLE);
                }
                return VSConstants.S_OK;
            }

            return base.QueryStatusCommand(itemid, ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
        }

 public void VsTextViewCreated(VisualStudio.TextManager.Interop.IVsTextView textViewAdapter) {
     // TODO: We should probably only track text views in Python projects or loose files.
     ITextView textView = AdapterService.GetWpfTextView(textViewAdapter);
     
     if (textView != null) {
         var analyzer = textView.GetAnalyzer(_serviceProvider);
         if (analyzer != null) {
             var monitorResult = analyzer.MonitorTextBuffer(textView, textView.TextBuffer);
             textView.Closed += TextView_Closed;
         }
     }
 }

        public override int? EditFilterQueryStatus(ref VisualStudio.OLE.Interop.OLECMD cmd, IntPtr pCmdText)
        {
            var activeView = CommonPackage.GetActiveTextView();
            if (activeView != null && activeView.TextBuffer.ContentType.IsOfType(RubyCoreConstants.ContentType)) {
                if (activeView.Selection.IsEmpty || activeView.Selection.Mode == TextSelectionMode.Box) {
                    cmd.cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED);
                } else {
                    cmd.cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
                }
            } else {
                cmd.cmdf = (uint)(OLECMDF.OLECMDF_INVISIBLE);
            }

            return VSConstants.S_OK;
        }

        public int? GetDesiredIndentation(VisualStudio.Text.ITextSnapshotLine line) {
            var dte = (EnvDTE.DTE)NodejsPackage.GetGlobalService(typeof(EnvDTE.DTE));

            var props = dte.get_Properties("TextEditor", "Node.js");
            switch ((EnvDTE._vsIndentStyle)(int)props.Item("IndentStyle").Value) {
                case EnvDTE._vsIndentStyle.vsIndentStyleNone:
                    return null;
                case EnvDTE._vsIndentStyle.vsIndentStyleDefault:
                    return DoBlockIndent(line);
                case EnvDTE._vsIndentStyle.vsIndentStyleSmart:
                    return DoSmartIndent(line);
            }

            return null;
        }