public BottomMargin(IWpfTextView textView, IClassifierAggregatorService classifier, ITextDocumentFactoryService documentService) { _textView = textView; _classifier = classifier.GetClassifier(textView.TextBuffer); _foregroundBrush = new SolidColorBrush((Color)FindResource(VsColors.CaptionTextKey)); _backgroundBrush = new SolidColorBrush((Color)FindResource(VsColors.ScrollBarBackgroundKey)); this.Background = _backgroundBrush; this.ClipToBounds = true; _lblEncoding = new TextControl("Encoding"); this.Children.Add(_lblEncoding); _lblContentType = new TextControl("Content type"); this.Children.Add(_lblContentType); _lblClassification = new TextControl("Classification"); this.Children.Add(_lblClassification); _lblSelection = new TextControl("Selection"); this.Children.Add(_lblSelection); UpdateClassificationLabel(); UpdateContentTypeLabel(); UpdateContentSelectionLabel(); if (documentService.TryGetTextDocument(textView.TextDataModel.DocumentBuffer, out _doc)) { _doc.FileActionOccurred += FileChangedOnDisk; UpdateEncodingLabel(_doc); } textView.Caret.PositionChanged += CaretPositionChanged; }
public double Validate(IClassifier classifier, Dataset csvReader) { SplitDataset(csvReader.Input, csvReader.Output); classifier.Learn(_trainingDataset, _trainingOutput); var predictedValues = new int[_testOutput.Length]; for (int i = 0; i < _testDataSet.GetLength(0); i++) { for (int j = 0; j < _testDataSet.GetLength(1); j++) { var prediction = classifier.Predict(GetLineOfTestDataset(i)); predictedValues[i] = prediction; } } var numberOfTrues = 0; for (int i = 0; i < _testOutput.Length; i++) { if (predictedValues[i] == _testOutput[i]) { numberOfTrues++; } } double accuracy = Convert.ToDouble(numberOfTrues) / Convert.ToDouble(_testOutput.Length); return(accuracy); }
/// <summary> /// Gets the classifier for specified text buffer. /// </summary> /// <param name="buffer">The buffer.</param> /// <returns>Classifier for specified text buffer.</returns> public IClassifier GetClassifier(ITextBuffer buffer) { var dte = (DTE)ServiceProvider.GetService(typeof(DTE)); var configuration = dte.Properties["Output Colorer", "General"]; if (buffer.ContentType.IsOfType(BuildOutputContentType)) { if (_buildOutputClassifier == null) { var settings = (IEnumerable<ColorerFormatSetting>)configuration.Item("BuildOutputSettings").Value; _buildOutputClassifier = new OutputClassifier(ClassificationRegistry, settings); } return _buildOutputClassifier; } if (buffer.ContentType.IsOfType(DebugOutputContentType)) { if (_debugOutputClassifier == null) { var settings = (IEnumerable<ColorerFormatSetting>)configuration.Item("DebugOutputSettings").Value; _debugOutputClassifier = new OutputClassifier(ClassificationRegistry, settings); } return _debugOutputClassifier; } if (buffer.ContentType.IsOfType(FindResultsContentType)) { return _findResultsClassifier ?? (_findResultsClassifier = new FindResultsClassifier(ClassificationRegistry)); } return null; }
//===================================================================== /// <summary> /// Constructor /// </summary> /// <param name="textView">The text view to use</param> /// <param name="serviceProvider">The service provider to use</param> /// <param name="aggregator">The classifier tag aggregator to use</param> /// <param name="navigator">The text structure navigator to use</param> /// <param name="state">The Ctrl key state tracker to use</param> public GoToDefinitionMouseProcessor(IWpfTextView textView, SVsServiceProvider serviceProvider, IClassifier aggregator, ITextStructureNavigator navigator, CtrlKeyState state) { this.TextView = textView; this.ServiceProvider = serviceProvider; this.ctrlState = state; this.aggregator = aggregator; this.navigator = navigator; this.ctrlState.CtrlKeyStateChanged += (sender, args) => { if (this.ctrlState.Enabled) { this.TryHighlightItemUnderMouse(this.RelativeToView(Mouse.PrimaryDevice.GetPosition(this.TextView.VisualElement))); } else { this.SetHighlightSpan(null, null); } }; // Some other points to clear the highlight span: this.TextView.LostAggregateFocus += (sender, args) => this.SetHighlightSpan(null, null); this.TextView.VisualElement.MouseLeave += (sender, args) => this.SetHighlightSpan(null, null); }
public void Edit(IClassifier classifier) { Debug.Assert(classifier != null, "Extractor must be supplied to allow editing."); var window = new AddEditClassifierWindow(); var data = new AddEditClassifier(window, true); window.DataContext = data; window.Owner = Application.Current.MainWindow; data.Name = classifier.Name; data.Field = classifier.Field; data.Pattern = classifier.Pattern; data.Mode = classifier.Mode; data.Type = classifier.Type; var dialogResult = window.ShowDialog(); if (dialogResult != null && (bool)dialogResult) { classifier.Name = data.Name; classifier.Pattern = data.Pattern; classifier.Mode = data.Mode; classifier.Field = data.Field; classifier.Type = data.Type; } }
private static double Score(Observation obs, IClassifier classifier) { if (classifier.Predict(obs.Pixels) == obs.Label) return 1.0; else return 0.0; }
public void VsTextViewCreated(IVsTextView textViewAdapter) { IWpfTextView textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter); IClassifier classifier = ClassifierService.GetClassifier(textView.TextBuffer); AddCommandFilter(textViewAdapter, new ExpandCommand(textView, CompletionBroker, UndoProvider, classifier)); }
internal void RemoveTagger(SpellCheckerTagger tagger) { _activeTaggers.Remove(tagger); if (_activeTaggers.Count == 0) { // Last tagger was disposed of. This is means there are no longer any open views on the buffer so we can safely shut down // spell checking for that buffer. _buffer.ChangedLowPriority -= this.OnBufferChange; _provider.RemoveSpellChecker(this); _isDisposed = true; _buffer.Properties.RemoveProperty(typeof(SpellChecker)); IDisposable classifierDispose = _classifier as IDisposable; if (classifierDispose != null) { classifierDispose.Dispose(); } _classifier = null; } }
private bool IsDocString(ITextView textWindow, SnapshotPoint point) { var aggregator = _serviceProvider.GetComponentModel().GetService <IClassifierAggregatorService>(); IClassifier classifier = aggregator.GetClassifier(textWindow.TextBuffer); var curLine = point.GetContainingLine(); var tokens = classifier.GetClassificationSpans(curLine.Extent); // TODO: Is null the right check for not having tokens? for (int i = curLine.LineNumber - 1; i >= 0 && tokens == null; i--) { tokens = classifier.GetClassificationSpans(curLine.Extent); if (tokens != null) { break; } i = i - 1; } if (tokens == null) { return(false); } // Tokens is NOT None here. // If first token found on a line is only token and is string literal, // we're in a doc string. Because multiline, can't be "" or ''. return(tokens.Count == 1 && tokens[0].ClassificationType.IsOfType(PredefinedClassificationTypeNames.String)); }
public CommentTextTagger(ITextBuffer buffer, IClassifier classifier) { _buffer = buffer; _classifier = classifier; classifier.ClassificationChanged += ClassificationChanged; }
// Set the parameters for the classifier public void SetParameters(object sender, EventArgs e) { // Check that we have training data if (!HasTrainingData) { MessageBox.Show("Please load training data first"); return; } // Show the parameters window and get the parameters SetTrainParamsForm paramsForm = new SetTrainParamsForm( ); if (paramsForm.ShowDialog( ) == DialogResult.OK) { // The number of inputs equals the length of the feature vector int numInputs = trainData.Samples[0].FeatureVector.Count; // The remaining parameters are configurable int numHiddenNodes = paramsForm.NumHiddenNodes; double learningRate = paramsForm.LearningRate; int maxRepetitions = paramsForm.MaxRepetitions; // Create the classifier classifier = new SimpleNeuralNet1( numInputs, numHiddenNodes, learningRate, maxRepetitions); } else { MessageBox.Show("Please set the training parameters"); return; } }
public SimpleSuggestedActions(SimpleSuggestedActionsProvider provider, ITextView textView, ITextBuffer textBuffer) { m_provider = provider; m_textView = textView; m_textBuffer = textBuffer; m_classifier = GeneralAsmClassifier.GetClassifier(textBuffer); }
public PkgdefErrorTagger(IWpfTextView view, IClassifierAggregatorService classifier, ErrorListProvider errorlist, ITextDocument document) { _view = view; _classifier = classifier.GetClassifier(view.TextBuffer); _errorlist = errorlist; _document = document; }
public ClassifierInstance(IClassifier classifier, double[] featureScaling, double[] featureShift, string[] trainedIdentifiers) { this.classifier = classifier; this.featureScaling = featureScaling; this.featureShift = featureShift; this.trainedIdentifiers = trainedIdentifiers; }
public GetClassesCommand( IClassifier <double> classifier, Func <Option <IFeatureCollection, Exception> > featureCollectionProvider) { this.classifier = classifier; this.featureCollectionProvider = featureCollectionProvider; }
public VsctCompletionSource(ITextBuffer buffer, IClassifierAggregatorService classifier, ITextStructureNavigatorSelectorService navigator, string file) { _classifier = classifier.GetClassifier(buffer); _navigator = navigator.GetTextStructureNavigator(buffer); _parser = new VsctParser(this, file); }
private static void ClassifyFile(MarkdownTestFilesFixture fixture, string fileName) { string testFile = fixture.GetDestinationPath(fileName); string content = fixture.LoadDestinationFile(fileName); TextBufferMock textBuffer = new TextBufferMock(content, MdContentTypeDefinition.ContentType); MdClassifierProvider classifierProvider = new MdClassifierProvider(); EditorShell.Current.CompositionService.SatisfyImportsOnce(classifierProvider); IClassifier cls = classifierProvider.GetClassifier(textBuffer); IList <ClassificationSpan> spans = cls.GetClassificationSpans(new SnapshotSpan(textBuffer.CurrentSnapshot, new Span(0, textBuffer.CurrentSnapshot.Length))); string actual = ClassificationWriter.WriteClassifications(spans); string baselineFile = testFile + ".colors"; if (_regenerateBaselineFiles) { baselineFile = Path.Combine(fixture.SourcePath, @"Classification\", Path.GetFileName(testFile)) + ".colors"; TestFiles.UpdateBaseline(baselineFile, actual); } else { TestFiles.CompareToBaseLine(baselineFile, actual); } }
public NavigableSymbolSource(IServiceProvider serviceProvider, ITextBuffer buffer, IClassifier classifier, ITextStructureNavigator textNavigator) { _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)); _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer)); _classifier = classifier ?? throw new ArgumentNullException(nameof(classifier)); _textNavigator = textNavigator ?? throw new ArgumentNullException(nameof(textNavigator)); }
public static string GetTypeScriptStringValue(this IWpfTextView textView, IClassifier classifier, IStandardClassificationService standardClassifications) { var buffers = textView.BufferGraph.GetTextBuffers(b => b.ContentType.IsOfType("TypeScript") && textView.GetSelection("TypeScript").HasValue&& textView.GetSelection("TypeScript").Value.Snapshot.TextBuffer == b); if (!buffers.Any()) { return(null); } int position = textView.Caret.Position.BufferPosition; if (position == textView.TextBuffer.CurrentSnapshot.Length) { position = position - 1; } var span = new SnapshotSpan(textView.TextBuffer.CurrentSnapshot, position, 1); var cspans = classifier.GetClassificationSpans(span); var text = cspans .Where(s => s.ClassificationType == standardClassifications.StringLiteral) .Select(s => s.Span.GetText()) .FirstOrDefault(); return(text != null?text.Substring(1, text.Length - 2) : null); }
internal Tagger(IClassificationTypeRegistryService typeRegistry, ITextView textView, IClassificationFormatMap formatMap, IClassifier classifier) { _classifier = classifier; _colorizer = textView.Properties.GetOrCreateSingletonProperty(() => new Colorizer(typeRegistry)); _formatMap = formatMap; textView.LayoutChanged += OnLayoutChangedEvent; }
static IEnumerable <IClassifier> CreateCommands(Assembly assembly) { int count = 0; foreach (Type type in assembly.GetTypes()) { if (typeof(IClassifier).IsAssignableFrom(type)) { IClassifier result = Activator.CreateInstance(type) as IClassifier; if (result != null) { count++; yield return(result); } } } if (count == 0) { string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName)); throw new ApplicationException( $"Can't find any type which implements IClassifier in {assembly} from {assembly.Location}.\n" + $"Available types: {availableTypes}"); } }
public BottomMargin(IWpfTextView textView, IClassifierAggregatorService classifier, ITextDocumentFactoryService documentService) { _textView = textView; _classifier = classifier.GetClassifier(textView.TextBuffer); SetResourceReference(BackgroundProperty, EnvironmentColors.ScrollBarBackgroundBrushKey); ClipToBounds = true; _lblEncoding = new TextControl("Encoding"); Children.Add(_lblEncoding); _lblContentType = new TextControl("Content type"); Children.Add(_lblContentType); _lblClassification = new TextControl("Classification"); Children.Add(_lblClassification); _lblSelection = new TextControl("Selection"); Children.Add(_lblSelection); UpdateClassificationLabel(); UpdateContentTypeLabel(); UpdateContentSelectionLabel(); if (documentService.TryGetTextDocument(textView.TextDataModel.DocumentBuffer, out _doc)) { _doc.FileActionOccurred += FileChangedOnDisk; UpdateEncodingLabel(_doc); } textView.Caret.PositionChanged += CaretPositionChanged; }
//===================================================================== /// <summary> /// Constructor /// </summary> /// <param name="buffer">The text buffer</param> /// <param name="classifier">The classifier</param> public RMarkdownTextTagger(ITextBuffer buffer, IClassifier classifier) { this.buffer = buffer; this.classifier = classifier; this.classifier.ClassificationChanged += this.ClassificationChanged; }
public void Edit(IClassifier classifier) { Debug.Assert(classifier != null, "Extractor must be supplied to allow editing."); var window = new AddEditClassifierWindow(); var data = new AddEditClassifier(window, true); window.DataContext = data; window.Owner = Application.Current.MainWindow; data.Name = classifier.Name; data.Field = classifier.Field; data.Pattern = classifier.Pattern; data.Mode = classifier.Mode; data.Type = classifier.Type; bool? dialogResult = window.ShowDialog(); if (dialogResult != null && (bool)dialogResult) { classifier.Name = data.Name; classifier.Pattern = data.Pattern; classifier.Mode = data.Mode; classifier.Field = data.Field; classifier.Type = data.Type; } }
protected void CheckOnlineClassification(IClassifier <T> classifier, String inputDoc, T expectedResult, Analyzer analyzer, String textFieldName, String classFieldName, Query query) { AtomicReader atomicReader = null; try { PopulateSampleIndex(analyzer); atomicReader = SlowCompositeReaderWrapper.Wrap(indexWriter.Reader); classifier.Train(atomicReader, textFieldName, classFieldName, analyzer, query); ClassificationResult <T> classificationResult = classifier.AssignClass(inputDoc); NotNull(classificationResult.AssignedClass); AreEqual(expectedResult, classificationResult.AssignedClass, "got an assigned class of " + classificationResult.AssignedClass); IsTrue(classificationResult.Score > 0, "got a not positive score " + classificationResult.Score); UpdateSampleIndex(analyzer); ClassificationResult <T> secondClassificationResult = classifier.AssignClass(inputDoc); Equals(classificationResult.AssignedClass, secondClassificationResult.AssignedClass); Equals(classificationResult.Score, secondClassificationResult.Score); } finally { if (atomicReader != null) { atomicReader.Dispose(); } } }
public StringTemplateBraceMatchingTagger(ITextView textView, ITextBuffer sourceBuffer, IClassifier aggregator) : base(textView, sourceBuffer, aggregator, _matchingCharacters) { Contract.Requires<ArgumentNullException>(textView != null, "textView"); Contract.Requires<ArgumentNullException>(sourceBuffer != null, "sourceBuffer"); Contract.Requires<ArgumentNullException>(aggregator != null, "aggregator"); }
public FeaturesInDecisionOut(IReader reader, IClassifier classifier) { DataReader = reader; DataReader.OnReadFinished = OnReadFinished; ExecutionMethod = DataReader.Start; Classifier = classifier; }
public void PutClassifier(string label, IClassifier classifier) { if (!this._modelMapping.Keys.Contains(label)) { this._modelMapping.Add(label, classifier); } }
public AsmDocMouseHandler( IWpfTextView view, IOleCommandTarget commandTarget, IClassifier aggregator, ITextStructureNavigator navigator, CtrlKeyState state, AsmDudeTools asmDudeTools) { //AsmDudeToolsStatic.Output_INFO("AsmDocMouseHandler:constructor: file=" + AsmDudeToolsStatic.GetFileName(view.TextBuffer)); this._view = view; this._commandTarget = commandTarget; this._state = state; this._aggregator = aggregator; this._navigator = navigator; this._asmDudeTools = asmDudeTools; this._state.CtrlKeyStateChanged += (sender, args) => { if (Settings.Default.AsmDoc_On) { if (this._state.Enabled) { this.TryHighlightItemUnderMouse(this.RelativeToView(Mouse.PrimaryDevice.GetPosition(this._view.VisualElement))); } else { this.Set_Highlight_Span(null); } } }; // Some other points to clear the highlight span: this._view.LostAggregateFocus += (sender, args) => this.Set_Highlight_Span(null); this._view.VisualElement.MouseLeave += (sender, args) => this.Set_Highlight_Span(null); }
public GoToDefMouseHandler(IWpfTextView view, IOleCommandTarget commandTarget, IClassifier aggregator, ITextStructureNavigator navigator, CtrlKeyState state) { _view = view; _commandTarget = commandTarget; _state = state; _aggregator = aggregator; _navigator = navigator; _state.CtrlKeyStateChanged += (sender, args) => { if (_state.Enabled) { this.TryHighlightItemUnderMouse(RelativeToView(Mouse.PrimaryDevice.GetPosition(_view.VisualElement))); } else { this.SetHighlightSpan(null); } }; // Some other points to clear the highlight span: _view.LostAggregateFocus += (sender, args) => this.SetHighlightSpan(null); _view.VisualElement.MouseLeave += (sender, args) => this.SetHighlightSpan(null); }
public static void IrisClassifierTest(IClassifier classifier) { var data = TestDataset.Iris(); data.Shuffle(new Random(1)); var split = (int)(data.Count * 0.8); var trainingSet = data.Take(split).ToList(); var validationSet = data.Skip(split) .Select(x => new Tuple <double[], double>(x.Take(x.Length - 1).ToArray(), x.Last())) .ToList(); classifier.Train(trainingSet); var correctlyPredicted = 0; var incorrectlyPredicted = 0; validationSet.ForEach(x => { if (Math.Abs(classifier.Predict(x.Item1) - x.Item2) < 0.00001) { correctlyPredicted++; } else { incorrectlyPredicted++; } }); var percentCorrect = ((correctlyPredicted + 0.0) / (correctlyPredicted + incorrectlyPredicted)); percentCorrect.ShouldBeGreaterThanOrEqualTo(0.90); }
#pragma warning restore 649, 169 #region IWpfTextViewCreationListener /// <summary> /// Called when a text view having matching roles is created over a text data model having a matching content type. /// Instantiates a CodeCoverageAdornment manager when the textView is created. /// </summary> /// <param name="textView">The <see cref="IWpfTextView"/> upon which the adornment should be placed</param> public void TextViewCreated(IWpfTextView textView) { IClassifier classifier = _classifierService.GetClassifier(textView.TextBuffer); // The adornment will listen to any event that changes the layout (text changes, scrolling, etc) new TestsAdornment(textView, classifier, _classificationRegistry, _formatMap); }
private double CalculatePooledAUC(IClassifier classifier, Dataset dataset) { double final = 0; int labelSize = dataset.Metadata.Target.Values.Length; double[][] values = new double[labelSize][]; int index = 0; for (int exampleIndex = 0; exampleIndex < dataset.Size; exampleIndex++) { values[index] = new double[2]; Example example = dataset[exampleIndex]; bool[] actualFlags = example.LabelFlags; Prediction prediction = classifier.Classify(example); for (int classIndex = 1; classIndex < labelSize; classIndex++) { values[index][0] = prediction.Probabilities[classIndex]; values[index][1] = actualFlags[classIndex] ? 1 : 0; index++; } } return(final); }
private double CalculateAverageAUC(IClassifier classifier, Dataset dataset) { double final = 0; int labelSize = dataset.Metadata.Target.Values.Length; double[][] values = new double[dataset.Size][]; double area = 0; double weight = 1.0 / (double)labelSize - 1; for (int classIndex = 0; classIndex < labelSize; classIndex++) { int index = 0; for (int exampleIndex = 0; exampleIndex < dataset.Size; exampleIndex++) { values[index] = new double[2]; Example example = dataset[exampleIndex]; bool[] actualFlags = example.LabelFlags; Prediction prediction = classifier.Classify(example); values[index][0] = prediction.Probabilities[classIndex]; values[index][1] = actualFlags[classIndex] ? 1 : 0; index++; } Curve curve = this._curveBuilder.CreateCurve(values); area += weight * curve.CalculateArea(); } return(final); }
public EditorConfigCompletionSource(ITextBuffer buffer, IClassifierAggregatorService classifier, ITextStructureNavigatorSelectorService navigator, ImageSource glyph) { _buffer = buffer; _classifier = classifier.GetClassifier(buffer); _navigator = navigator; _glyph = glyph; }
public static double Correct(IEnumerable<Observation> validationSet, IClassifier classifier) { return validationSet .Select(obs => Score(obs, classifier)) .Average(); }
internal Linguist(IClassifier aggregator, IClassificationTypeRegistryService registry) { InstallFiles.Install(); Styles.Init(); Languages.Init(registry); m_aggregator = aggregator; }
public static ClassifierBuildResult Create(IClassifier classifier, double error) { return new ClassifierBuildResult { Classifier = classifier, Error = error }; }
public TextViewDocument(ITextDocument document, ICaret caret, IClassifier classifier, IClassificationStyler classificationStyler) { _document = document; _classifier = classifier; _classificationStyler = classificationStyler; Buffer.Changed += OnBufferChange; Caret = caret; }
private static int PredictBagLabel(IClassifier<SparseBag> classifier, BagTestData[] bags, SparseBag bagToTest) { var sparseBags = BagTestData.ToSparseBags(bags); classifier.Train(sparseBags); return classifier.PredictWinner(bagToTest); }
public AntlrIntellisenseCommandFilter(IVsTextView textViewAdapter, AntlrIntellisenseController controller) : base(textViewAdapter, controller) { var textView = Controller.Provider.EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter); var textBuffer = textView.TextBuffer; _classifier = Controller.Provider.ClassifierAggregatorService.GetClassifier(textView.TextBuffer); _textStructureNavigator = Controller.Provider.TextStructureNavigatorSelectorService.GetTextStructureNavigator(textBuffer); }
public TextViewDocument(ITextDocument document, ICaret caret, IClassifier classifier, IClassificationStyler classificationStyler) { _document = document; _classifier = classifier; _classificationStyler = classificationStyler; _classificationStyler.Changed += (Sender, Args) => RemoveCachedLinesFrom(0); Buffer.Changed += OnBufferChange; Caret = caret; }
internal GherkinSyntaxHighlighter( IClassifier classifier, IClassificationTypeRegistryService classificationTypeRegistryService, ILanguagePatternMatcher languagePatternMatcher) { this.classifier = classifier; this.classificationTypeRegistryService = classificationTypeRegistryService; this.languagePatternMatcher = languagePatternMatcher; }
GoToDefinitionAdorner(IWpfTextView textTextView, IComponentModel componentModel) { _textView = textTextView; _classicationFormatMapService = componentModel.GetService<IClassificationFormatMapService>(); _classifier = componentModel.GetService<IViewClassifierAggregatorService>().GetClassifier(textTextView); _adornmentLayer = textTextView.GetAdornmentLayer(AdornerName); _textView.Closed += OnTextViewClosed; }
/// <summary> /// Attaches events for invoking Statement completion /// </summary> public IntellisenseController(IntellisenseControllerProvider provider, ITextView textView) { _textView = textView; _provider = provider; _classifier = _provider._classifierAgg.GetClassifier(_textView.TextBuffer); _editOps = provider._EditOperationsFactory.GetEditorOperations(textView); _incSearch = provider._IncrementalSearch.GetIncrementalSearch(textView); _textView.MouseHover += TextViewMouseHover; textView.Properties.AddProperty(typeof(IntellisenseController), this); // added so our key processors can get back to us }
public PkgdefCompletionSource(ITextBuffer buffer, IClassifierAggregatorService classifier, ITextStructureNavigatorSelectorService navigator, IGlyphService glyphService) { _buffer = buffer; _classifier = classifier.GetClassifier(buffer); _navigator = navigator; _glyphService = glyphService; _defaultGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphGroupField, StandardGlyphItem.GlyphItemPublic); _snippetGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphCSharpExpansion, StandardGlyphItem.GlyphItemPublic); }
public CmdCompletionSource(ITextBuffer buffer, IClassifierAggregatorService classifier, IGlyphService glyphService, ITextStructureNavigator textStructureNavigator) { _buffer = buffer; _classifier = classifier.GetClassifier(buffer); _keywordGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphGroupVariable, StandardGlyphItem.GlyphItemPublic); _environmentGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphAssembly, StandardGlyphItem.GlyphItemPublic); _labelGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphArrow, StandardGlyphItem.GlyphItemPublic); _textStructureNavigator = textStructureNavigator; }
public VsctCompletionSource(ITextBuffer buffer, IClassifierAggregatorService classifier, ITextStructureNavigatorSelectorService navigator, IGlyphService glyphService) { _buffer = buffer; _classifier = classifier.GetClassifier(buffer); _navigator = navigator; _glyphService = glyphService; _defaultGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphGroupField, StandardGlyphItem.GlyphItemPublic); _builtInGlyph = glyphService.GetGlyph(StandardGlyphGroup.GlyphGroupProperty, StandardGlyphItem.TotalGlyphItems); _imageService = ExtensibilityToolsPackage.GetGlobalService(typeof(SVsImageService)) as IVsImageService2; }
public static bool IsClassifiedAsJavaScript(IClassifier classifier, SnapshotPoint startPoint) { if (startPoint == null) return false; var spans = classifier.GetClassificationSpans(new SnapshotSpan(startPoint, 1)); var span = spans.FirstOrDefault(); if (span == null) return false; return span.ClassificationType.Classification.StartsWith("Script ", StringComparison.OrdinalIgnoreCase); }
public static ClassifierBuildResult Create(IClassifier classifier, TextDocument[] trainingSet, string targetTag) { var errorsCount = trainingSet.Count(x => classifier.IsClassifierWrong(x, targetTag)); var error = errorsCount * 1.0 / trainingSet.Length; return new ClassifierBuildResult { Classifier = classifier, Error = error }; }
public ScoreModel(TrainModel trainedModel, int K = 3) { if (!trainedModel.Trained) throw new Exception("TrainModel must be trained first"); this.trainedModel = trainedModel; ConfussionMatrix = new int[trainedModel.NumberofClasses, trainedModel.NumberofClasses]; if (trainedModel.cType == ClassifierType.Bayesian) classifier = new BayesianClassifier(trainedModel); else if (trainedModel.cType == ClassifierType.KNearestNeighbour) classifier = new KNearestNeighbour(trainedModel, K); }
public AutoWrapper(SVsServiceProvider serviceProvider, IClassifierAggregatorService aggregatorService, IWpfTextView textView) { var service = serviceProvider.GetService<CommentatorService>(); this.options = service.GetOptions(); this.view = textView; this.classifier = aggregatorService.GetClassifier(this.view.TextBuffer); this.view.TextBuffer.Changed += this.TextBuffer_Changed; this.view.Closed += this.View_Closed; }
public SnapshotParser(ITextSnapshot snapshot, IClassifier classifier) { Snapshot = snapshot; Classifier = classifier; ClassificationSpans = Classifier.GetClassificationSpans(new SnapshotSpan(Snapshot, 0, snapshot.Length)); foreach (ClassificationSpan s in ClassificationSpans) SpanIndex.Add(s.Span.Start.Position, s); CurrentPoint = Snapshot.GetLineFromLineNumber(0).Start; if (SpanIndex.ContainsKey(0)) CurrentSpan = SpanIndex[0]; }
internal static bool FindMatchingBrace(ILanguageBlockManager lbm, IClassifier classifier, SnapshotPoint startPoint, bool findClosing, char open, char close, int maxLines, ref bool maxLinesReached, out SnapshotSpan pairSpan) { // Get script block we're working in // lbm will be null if this is not in an HTML file var scriptBlock = lbm != null ? JScriptEditorUtil.GetJavaScriptBlockSpans(lbm) .Single(b => b.Start <= startPoint.Position && b.End >= startPoint.Position) : new BlockSpan(0, startPoint.Snapshot.TextBuffer.CurrentSnapshot.Length, true); return findClosing ? FindMatchingCloseChar(scriptBlock, classifier, startPoint, open, close, maxLines, ref maxLinesReached, out pairSpan) : FindMatchingOpenChar(scriptBlock, classifier, startPoint, close, open, maxLines, ref maxLinesReached, out pairSpan); }
public static bool IsClassifiedAs(IClassifier classifier, SnapshotPoint startPoint, params string[] names) { if (startPoint == null) return false; var spans = classifier.GetClassificationSpans(new SnapshotSpan(startPoint, 1)); var span = spans.FirstOrDefault(); if (span == null) return false; if (names.Contains(span.ClassificationType.Classification)) return true; return false; }
public void AddClassifier(IProjectionBuffer projectionBuffer, ITextBuffer textBuffer, IClassifier classifer) { var elisionInfo = new ElisionInfo(textBuffer, classifer, _bufGraphFact.CreateBufferGraph(projectionBuffer)); _elisionBuffers.Add(elisionInfo); classifer.ClassificationChanged += (sender, args) => { var classChanged = ClassificationChanged; if (classChanged != null) { foreach (var span in elisionInfo.BufferGraph.MapDownToBuffer(args.ChangeSpan, SpanTrackingMode.EdgeExclusive, projectionBuffer)) { classChanged(this, new ClassificationChangedEventArgs(span)); } } }; }
public static void HandleReturn(IWpfTextView view, IClassifier classifier) { int curLine = view.Caret.Position.BufferPosition.GetContainingLine().LineNumber; int startLine = curLine; // skip blank lines as far as calculating indentation goes... bool hasNonWhiteSpace = false; string lineText; ITextSnapshotLine line; do { line = view.TextSnapshot.GetLineFromLineNumber(curLine); if (curLine == startLine) { // if we're in the middle of a line only consider text to the left for white space detection lineText = line.GetText().Substring(0, view.Caret.Position.BufferPosition.Position - view.Caret.Position.BufferPosition.GetContainingLine().Start); } else { lineText = line.GetText(); } foreach (char c in lineText) { if (!Char.IsWhiteSpace(c)) { hasNonWhiteSpace = true; break; } } if (!hasNonWhiteSpace) { curLine--; } } while (!hasNonWhiteSpace && curLine > 0); int indentation = CalculateIndentation(lineText, line, view, classifier); if (curLine != startLine) { // enter on a blank line, don't re-indent instead just maintain the current indentation indentation = Math.Min(indentation, (view.Caret.Position.BufferPosition.Position - view.Caret.ContainingTextViewLine.Start.Position)); } using (var edit = view.TextBuffer.CreateEdit()) { if (view.Selection.IsActive) { foreach (var span in view.Selection.SelectedSpans) { edit.Delete(span); } } edit.Insert(view.Caret.Position.BufferPosition.Position, view.Options.GetNewLineCharacter()); if (view.Options.IsConvertTabsToSpacesEnabled()) { edit.Insert(view.Caret.Position.BufferPosition.Position, new String(' ', indentation)); } else { edit.Insert(view.Caret.Position.BufferPosition.Position, new String('\t', indentation / view.Options.GetTabSize())); } edit.Apply(); } view.Caret.EnsureVisible(); }
public VisualsFactory(ITextView textView, IClassifier classifier, Double maxLineWidth) { _textView = textView; _classifier = classifier; _maxLineWidth = maxLineWidth; /* * DocumentType("text.xml") = XmlWordClassificationLookup * DocumentType("C#"), DocumentType("VB"), DocumentType("text") = ClassificationFormatMap * Else = DefaultClassificationFormatMap */ _classificationFormatMap = Connector.Assets.ClassificationFormatMapSelector.Invoke(_textView.TextBuffer.DocumentType); _paragraphProperties = new TextFormattingParagraphProperties(); }