private void Create(ITextView textView, IEditorOptions editorOptions = null)
{
_textView = textView;
_textBuffer = textView.TextBuffer;
_snapshot = _textBuffer.CurrentSnapshot;
_textBuffer.Changed += delegate { _snapshot = _textBuffer.CurrentSnapshot; };
_globalSettings = new Vim.GlobalSettings();
_localSettings = new LocalSettings(_globalSettings, FSharpOption.CreateForReference(editorOptions), FSharpOption.CreateForReference(textView));
_markMap = new MarkMap(new TrackingLineColumnService());
_vimData = new VimData();
_search = VimUtil.CreateSearchService(_globalSettings);
_jumpList = VimUtil.CreateJumpList();
_statusUtil = new Mock<IStatusUtil>(MockBehavior.Strict);
_navigator = VimUtil.CreateTextStructureNavigator(_textView, WordKind.NormalWord);
_motionUtil = new MotionUtil(
_textView,
_markMap,
_localSettings,
_search,
_navigator,
_jumpList,
_statusUtil.Object,
VimUtil.GetWordUtil(textView),
_vimData);
}
/// <summary>
/// Writes a set of images based on the settings specified in a ImagePropertiesInfo object.
/// </summary>
/// <param name="imageInfo">the image properties</param>
/// <param name="allowEnlargement">if true, generated images will be scaled larger than the source image (if the imageInfo sizes are larger) </param>
public void WriteImages(ImagePropertiesInfo imageInfo, bool allowEnlargement, ImageDecoratorInvocationSource invocationSource, CreateFileCallback inlineFileCreator, CreateFileCallback linkedFileCreator, IEditorOptions clientOptions)
{
string inlinePrefix = imageInfo.LinkTarget == LinkTargetType.IMAGE ? "_thumb" : "";
ImageFilter inlineFilter = ImageFilterDecoratorAdapter.CreateImageDecoratorsFilter(imageInfo, ImageEmbedType.Embedded, invocationSource, clientOptions);
ImageFilter targetFilter = ImageFilterDecoratorAdapter.CreateImageDecoratorsFilter(imageInfo, ImageEmbedType.Linked, invocationSource, clientOptions);
using (Bitmap inlineBitmap = new Bitmap(imageInfo.ImageSourceUri.LocalPath))
{
string imgPath = writeImage(inlineBitmap, imageInfo.ImageSourceUri.LocalPath, inlinePrefix, inlineFilter, inlineFileCreator);
string inlineImgPath = new Uri(UrlHelper.CreateUrlFromPath(imgPath)).ToString();
imageInfo.InlineImageUrl = inlineImgPath;
}
//Generate the link image
//Warning! this imageInfo.LinkTarget check must be done after the inline image because the resize
// decorator will set the default link target for the image the first time it
// is applied.
//imageInfo.LinkTarget = origLinkTarget;
if (imageInfo.LinkTarget == LinkTargetType.IMAGE && !ImageDecoratorDirective.ShouldSuppressLinked)
{
using (Bitmap targetBitmap = new Bitmap(imageInfo.ImageSourceUri.LocalPath))
{
string anchorPath = writeImage(targetBitmap, imageInfo.ImageSourceUri.LocalPath, "", targetFilter, linkedFileCreator);
string targetUrl = new Uri(UrlHelper.CreateUrlFromPath(anchorPath)).ToString();
imageInfo.LinkTargetUrl = targetUrl;
}
}
}
//private GLControl glControl;
#region Constructors and Destructors
public Base3DEditor(
IComponentContext context, IEditorOptions<Base3DEditorOptions> options, Base3DEditorContent content)
{
this.options = options;
this.content = content;
this.graphicsContext = context.Resolve<ToeGraphicsContext>();
this.camera = new EditorCamera(context.Resolve<IEditorOptions<EditorCameraOptions>>());
this.camera.PropertyChanged += this.OnCameraPropertyChanged;
this.InitializeComponent();
this.Dock = DockStyle.Fill;
//this.glControl = new GLControl(GraphicsMode.Default, 1, 0, GraphicsContextFlags.Default);
//this.glControl.Dock = DockStyle.Fill;
this.glControl.Load += this.GLControlLoad;
this.glControl.Paint += this.GLControlPaint;
this.glControl.Resize += this.GLControlResize;
this.Controls.Add(this.glControl);
this.glControl.MouseMove += this.OnSceneMouseMove;
this.glControl.MouseEnter += this.OnSceneMouseEnter;
this.glControl.MouseLeave += this.OnSceneMouseLeave;
this.glControl.MouseWheel += this.OnSceneMouseWheel;
this.glControl.KeyDown += this.OnControlKeyDown;
this.glControl.KeyUp += this.OnControlKeyUp;
this.glControl.GotFocus += this.OnSceneGotFocus;
this.glControl.LostFocus += this.OnSceneLostFocus;
this.Camera.LookAt(new Vector3(512, 64, 1024), new Vector3(0, 0, 0));
this.CameraController = new TargetCameraController { Camera = this.Camera };
this.yUpToolStripMenuItem.Click += this.SelectYUp;
this.zUpToolStripMenuItem.Click += this.SelectZUp;
this.UpdateCoordinateSystemIcon();
this.UpdateLighingIcon();
this.UpdateWireframeIcon();
this.UpdateNormalIcon();
}
/// <summary>Returns the span for the selected line. Extends it if it is a part of a multi line statement or declaration.</summary>
private Task<IEnumerable<SnapshotSpan>> GetExpandedLineAsync(IEditorOptions editorOptions, CommandArgs args, CancellationToken cancellationToken)
{
IEnumerable<SnapshotSpan> selectedSpans = GetSelectedLine(args.TextView);
var candidateSubmission = GetSubmissionFromSelectedSpans(editorOptions, selectedSpans);
return CanParseSubmission(candidateSubmission)
? Task.FromResult(selectedSpans)
: ExpandSelectionAsync(selectedSpans, args, cancellationToken);
}
private ImageFilterDecoratorAdapter(ImagePropertiesInfo imageInfo, ImageEmbedType embedType, ImageDecoratorInvocationSource invocationSource, IEditorOptions editorOptions)
{
_decoratorsList = imageInfo.ImageDecorators;
_imageInfo = imageInfo;
_embedType = embedType;
_invocationSource = invocationSource;
_editorOptions = editorOptions;
}
public bool LoadOption(IEditorOptions options, string optionName)
{
if (_settingsStore != null)
{
return _settingsStore.LoadOption(options, optionName);
}
return false;
}
string ISendToInteractiveSubmissionProvider.GetSelectedText(IEditorOptions editorOptions, CommandArgs args, CancellationToken cancellationToken)
{
IEnumerable<SnapshotSpan> selectedSpans = args.TextView.Selection.IsEmpty
? GetExpandedLineAsync(editorOptions, args, cancellationToken).WaitAndGetResult(cancellationToken)
: args.TextView.Selection.GetSnapshotSpansOnBuffer(args.SubjectBuffer).Where(ss => ss.Length > 0);
return GetSubmissionFromSelectedSpans(editorOptions, selectedSpans);
}
public void Setup()
{
_synchronizer = new EditorToSettingSynchronizer(EditorUtil.FactoryService.Vim);
_buffer = EditorUtil.FactoryService.Vim.CreateBuffer(EditorUtil.CreateTextView(""));
_localSettings = _buffer.LocalSettings;
_globalSettings = _localSettings.GlobalSettings;
_editorOptions = _localSettings.EditorOptions.Value;
}
public TemplateTypingCommandHandler(
ITextView textView,
ITextBuffer textBuffer,
IEditorOptions editorOptions,
IEditorOperations editorOperations)
#if DEV14_OR_LATER
: base(textView, _ => textBuffer)
#else
: base(textView, textBuffer)
public static IElisionBuffer CreateElisionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IEditorOptions editorOptions,
params SnapshotSpan[] exposedSpans)
{
return factoryService.CreateElisionBufferWithoutIndentation(
editorOptions,
(IEnumerable<SnapshotSpan>)exposedSpans);
}
public void Create(params string[] lines)
{
_textView = EditorUtil.CreateTextView(lines);
_vimData = new VimData();
_editorOptions = EditorUtil.FactoryService.EditorOptionsFactory.GetOptions(_textView);
_textView.Caret.MoveTo(new SnapshotPoint(_textView.TextSnapshot, 0));
_textBuffer = _textView.TextBuffer;
_factory = new MockRepository(MockBehavior.Strict);
_registerMap = VimUtil.CreateRegisterMap(MockObjectFactory.CreateClipboardDevice(_factory).Object);
_host = _factory.Create<IVimHost>();
_jumpList = _factory.Create<IJumpList>();
_editorOperations = _factory.Create<IEditorOperations>();
_editorOperations.Setup(x => x.AddAfterTextBufferChangePrimitive());
_editorOperations.Setup(x => x.AddBeforeTextBufferChangePrimitive());
_globalSettings = _factory.Create<IVimGlobalSettings>();
_globalSettings.SetupGet(x => x.Magic).Returns(true);
_globalSettings.SetupGet(x => x.SmartCase).Returns(false);
_globalSettings.SetupGet(x => x.IgnoreCase).Returns(true);
_globalSettings.SetupGet(x => x.IsVirtualEditOneMore).Returns(false);
_globalSettings.SetupGet(x => x.UseEditorIndent).Returns(false);
_globalSettings.SetupGet(x => x.UseEditorSettings).Returns(false);
_globalSettings.SetupGet(x => x.VirtualEdit).Returns(String.Empty);
_globalSettings.SetupGet(x => x.WrapScan).Returns(true);
_settings = MockObjectFactory.CreateLocalSettings(_globalSettings.Object, _factory);
_settings.SetupGet(x => x.AutoIndent).Returns(false);
_settings.SetupGet(x => x.GlobalSettings).Returns(_globalSettings.Object);
_settings.SetupGet(x => x.ExpandTab).Returns(true);
_settings.SetupGet(x => x.TabStop).Returns(4);
_outlining = _factory.Create<IOutliningManager>();
_outlining
.Setup(x => x.ExpandAll(It.IsAny<SnapshotSpan>(), It.IsAny<Predicate<ICollapsed>>()))
.Returns<IEnumerable<ICollapsible>>(null);
_globalSettings.SetupGet(x => x.ShiftWidth).Returns(2);
_statusUtil = _factory.Create<IStatusUtil>();
_searchService = VimUtil.CreateSearchService(_globalSettings.Object);
_undoRedoOperations = VimUtil.CreateUndoRedoOperations(_statusUtil.Object);
var data = new OperationsData(
vimData: _vimData,
vimHost: _host.Object,
editorOperations: _editorOperations.Object,
textView: _textView,
outliningManager: FSharpOption.Create(_outlining.Object),
jumpList: _jumpList.Object,
localSettings: _settings.Object,
undoRedoOperations: _undoRedoOperations,
registerMap: _registerMap,
editorOptions: _editorOptions,
keyMap: null,
statusUtil: _statusUtil.Object,
foldManager: null,
searchService: _searchService,
wordUtil: VimUtil.GetWordUtil(_textView));
_operationsRaw = new CommonOperations(data);
_operations = _operationsRaw;
}
public EditorToSettingSynchronizerTest()
{
_synchronizer = new EditorToSettingSynchronizer(EditorOptionsFactoryService, Vim);
_buffer = CreateVimBuffer("");
_localSettings = _buffer.LocalSettings;
_globalSettings = _localSettings.GlobalSettings;
_editorOptions = _buffer.TextView.Options;
}
public void Setup()
{
_synchronizer = new EditorToSettingSynchronizer(EditorUtil.FactoryService.EditorOptionsFactory, EditorUtil.FactoryService.Vim);
var textView = EditorUtil.CreateTextView("");
_buffer = EditorUtil.FactoryService.Vim.CreateVimBuffer(textView);
_localSettings = _buffer.LocalSettings;
_globalSettings = _localSettings.GlobalSettings;
_editorOptions = EditorUtil.FactoryService.EditorOptionsFactory.GetOptions(textView);
}
public TemplateTypingCommandHandler(
ITextView textView,
ITextBuffer textBuffer,
IEditorOptions editorOptions,
IEditorOperations editorOperations)
: base(textView, _ => textBuffer)
{
_editorOperations = editorOperations;
_editorOptions = editorOptions;
}
public TabOptionsListener(IWpfTextView textView)
{
TextView = textView;
Options = textView.Options;
Options.OptionChanged += OnTextViewOptionChanged;
TextView.Closed += TextViewOnClosed;
_OnConvertTabsToSpacesOptionChanged();
OnIndentSizeOptionChanged();
}
internal static void SetEditorOptions(IEditorOptions options, Guid languageServiceGuid)
{
IVsTextManager textMgr = (IVsTextManager)InteractiveWindowPackage.GetGlobalService(typeof(SVsTextManager));
var langPrefs = new LANGPREFERENCES[1];
langPrefs[0].guidLang = languageServiceGuid;
ErrorHandler.ThrowOnFailure(textMgr.GetUserPreferences(null, null, langPrefs, null));
options.SetOptionValue(DefaultTextViewHostOptions.ChangeTrackingId, false);
options.SetOptionValue(DefaultOptions.ConvertTabsToSpacesOptionId, langPrefs[0].fInsertTabs == 0);
options.SetOptionValue(DefaultOptions.TabSizeOptionId, (int)langPrefs[0].uTabSize);
options.SetOptionValue(DefaultOptions.IndentSizeOptionId, (int)langPrefs[0].uIndentSize);
}
public RemoteHostClientService(
Workspace workspace,
IDiagnosticAnalyzerService analyzerService,
IEditorOptions globalEditorOptions) :
base()
{
_gate = new object();
_workspace = workspace;
_analyzerService = analyzerService;
_globalEditorOptions = globalEditorOptions;
}
public static IElisionBuffer CreateElisionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IEditorOptions editorOptions,
IContentType contentType,
IEnumerable<SnapshotSpan> exposedSpans)
{
var spans = new NormalizedSnapshotSpanCollection(exposedSpans);
if (spans.Count > 0)
{
// BUG(6335): We have to make sure that the spans refer to the current snapshot of
// the buffer.
var buffer = spans.First().Snapshot.TextBuffer;
var currentSnapshot = buffer.CurrentSnapshot;
spans = new NormalizedSnapshotSpanCollection(
spans.Select(s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive)));
}
contentType = contentType ?? factoryService.ProjectionContentType;
var elisionBuffer = factoryService.CreateElisionBuffer(
null, spans, ElisionBufferOptions.None, contentType);
if (spans.Count > 0)
{
var snapshot = spans.First().Snapshot;
var buffer = snapshot.TextBuffer;
// We need to figure out the shorted indentation level of the exposed lines. We'll
// then remove that indentation from all lines.
var indentationColumn = DetermineIndentationColumn(editorOptions, spans);
var spansToElide = new List<Span>();
foreach (var span in spans)
{
var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start);
var endLineNumber = snapshot.GetLineNumberFromPosition(span.End);
for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++)
{
var line = snapshot.GetLineFromLineNumber(lineNumber);
var lineOffsetOfColumn = line.GetLineOffsetFromColumn(indentationColumn, editorOptions);
spansToElide.Add(Span.FromBounds(line.Start, line.Start + lineOffsetOfColumn));
}
}
elisionBuffer.ElideSpans(new NormalizedSpanCollection(spansToElide));
}
return elisionBuffer;
}
public EditorToSettingSynchronizerTest()
{
_synchronizer = new EditorToSettingSynchronizer();
var textView = CreateTextView();
var globalSettings = new GlobalSettings();
_localSettings = new LocalSettings(globalSettings);
_windowSettings = new WindowSettings(globalSettings);
_editorOptions = textView.Options;
_vimBuffer = new Mock<IVimBuffer>(MockBehavior.Strict);
_vimBuffer.SetupGet(x => x.LocalSettings).Returns(_localSettings);
_vimBuffer.SetupGet(x => x.WindowSettings).Returns(_windowSettings);
_vimBuffer.SetupGet(x => x.TextView).Returns(textView);
}
public GenericSceneEditor(
IEditorEnvironment editorEnvironment,
IComponentContext context,
ToeGraphicsContext graphicsContext,
IEditorOptions<Base3DEditorOptions> options)
{
this.editorEnvironment = editorEnvironment;
this.context = context;
this.graphicsContext = graphicsContext;
this.options = options;
this.history = new CommandHistory();
this.InitializeComponent();
this.InitializeEditor();
}
public AnimEditor(
IEditorEnvironment editorEnvironment,
IResourceManager resourceManager,
IComponentContext context,
IEditorOptions<Base3DEditorOptions> options,
Base3DEditorContent content)
: base(context, options, content)
{
this.editorEnvironment = editorEnvironment;
this.resourceManager = resourceManager;
this.InitializeComponent();
this.InitializeEditor();
base.RenderScene += this.RenderAnimScene;
}
public static IProjectionBuffer CreateProjectionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IContentTypeRegistryService registryService,
IEditorOptions editorOptions,
ITextSnapshot snapshot,
string separator,
params LineSpan[] exposedLineSpans)
{
return factoryService.CreateProjectionBufferWithoutIndentation(
registryService,
editorOptions,
snapshot,
separator,
suffixOpt: null,
exposedLineSpans: exposedLineSpans);
}
public MainEditorWindow(IComponentContext context, IEditorOptions<MainEditorWindowOptions> options)
{
this.context = context;
this.options = options;
this.InitializeComponent();
this.fileTabs.SelectedIndexChanged += this.RebindToEditor;
if (options.Options.RecentFiles == null)
{
options.Options.RecentFiles = new ObservableCollection<string>();
}
options.Options.RecentFiles.CollectionChanged += this.ResetRecentFilesMenu;
this.ResetRecentFilesMenu(
options.Options.RecentFiles, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
public TextureEditor(
IEditorEnvironment editorEnvironment,
IResourceManager resourceManager,
IComponentContext context,
ToeGraphicsContext graphicsContext,
IEditorOptions<Base3DEditorOptions> options,
Base3DEditorContent content)
: base(context, options, content)
{
this.editorEnvironment = editorEnvironment;
this.resourceManager = resourceManager;
this.graphicsContext = graphicsContext;
this.InitializeComponent();
this.InitializeEditor();
base.RenderScene += this.RenderTexScene;
}
public MaterialPreview(
MaterialEditor editor,
ToeGraphicsContext graphicsContext,
IComponentContext context,
IEditorOptions<Base3DEditorOptions> options,
Base3DEditorContent content,
IStreamConverterFactory streamConverterFactory)
: base(context, options, content)
{
this.editor = editor;
this.graphicsContext = graphicsContext;
this.Camera.Ortho = false;
this.Camera.ZNear = 16.0f;
this.Camera.ZFar = 2048.0f;
base.RenderScene += this.RenderMaterialScene;
this.box = BoxBuilder.BuildSoftEdgedBox(250, streamConverterFactory);
}
public ModelEditor(
IEditorEnvironment editorEnvironment,
IResourceManager resourceManager,
IComponentContext context,
ToeGraphicsContext graphicsContext,
IEditorOptions<Base3DEditorOptions> options,
ICommandHistory history)
{
this.editorEnvironment = editorEnvironment;
this.resourceManager = resourceManager;
this.context = context;
this.graphicsContext = graphicsContext;
this.options = options;
this.history = history;
this.dataContext.DataContextChanged += ResetModel;
this.InitializeComponent();
this.InitializeEditor();
}
public AddNewItemForm(
IEditorOptions<AddNewItemFormOptions> editorOptions, IEnumerable<IResourceEditorFactory> resourceFileFormats)
{
this.editorOptions = editorOptions;
this.InitializeComponent();
var directoryHistory = this.Options.DirectoryHistory;
if (directoryHistory.Count == 0)
{
this.txtFolder.Text = Directory.GetCurrentDirectory();
}
else
{
this.txtFolder.Text = directoryHistory[directoryHistory.Count - 1];
var autoCompleteSource = new AutoCompleteStringCollection();
autoCompleteSource.AddRange(directoryHistory.ToArray());
this.txtFolder.AutoCompleteCustomSource = autoCompleteSource;
this.txtFolder.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
this.txtFolder.AutoCompleteSource = AutoCompleteSource.CustomSource;
}
if (resourceFileFormats != null)
{
foreach (var fileFormat in resourceFileFormats)
{
ListViewGroup group = null;
foreach (var format in fileFormat.SupportedFormats)
{
if (format.CanCreate)
{
if (group == null)
{
group = new ListViewGroup(fileFormat.Name);
this.listView1.Groups.Add(group);
}
this.listView1.Items.Add(new ListViewItem(format.Name, group) { Tag = format });
}
}
}
}
}
public CommandFilter(
IVsTextView textView,
IWpfTextView wpfTextView,
IHtmlBuilderService htmlBuilderService,
IRtfBuilderService rtfBuilderService,
IEditorOperations editorOperations,
ITextUndoHistory undoHistory,
IEditorOptions editorOptions,
IViewPrimitives viewPrimitives,
ITelemetrySession telemetrySession)
{
_htmlBuilderService = htmlBuilderService;
_rtfBuilderService = rtfBuilderService;
_undoHistory = undoHistory;
_textView = wpfTextView;
_editorOperations = editorOperations;
_editorOptions = editorOptions;
_viewPrimitives = viewPrimitives;
_telemetrySession = telemetrySession;
textView.AddCommandFilter(this, out _nextCommandTargetInChain);
}
public static bool GetAutoInsertAttributeValue(this IEditorOptions options) => options.GetOptionValue(XmlOptions.AutoInsertAttributeValue);
public EditFilter(System.IServiceProvider serviceProvider, ITextView textView, IEditorOperations editorOps, IEditorOptions editorOptions, IIntellisenseSessionStack intellisenseStack, IComponentModel compModel)
{
_serviceProvider = serviceProvider;
_textView = textView;
_editorOps = editorOps;
_intellisenseStack = intellisenseStack;
_compModel = compModel;
var agg = _compModel.GetService <IClassifierAggregatorService>();
_classifier = agg.GetClassifier(textView.TextBuffer);
_incSearch = _compModel.GetService <IIncrementalSearchFactoryService>().GetIncrementalSearch(_textView);
_broker = _compModel.GetService <ICompletionBroker>();
_editorOptions = editorOptions;
}
public SmartIndent(WorkspaceDocument <ITextBuffer> document, IEditorOptions options)
{
this.document = document ?? throw new ArgumentNullException(nameof(document));
this.options = options ?? throw new ArgumentNullException(nameof(options));
}
protected override async Task <Control> OnGetViewControlAsync(CancellationToken token, DocumentViewContent view)
{
// FIXME: move this to the end of the .ctor after fixing margin options responsiveness
UpdateLineNumberMarginOption();
var fileModel = (TextBufferFileModel)Model;
TextDocument = fileModel.TextDocument;
TextBuffer = TextDocument.TextBuffer;
UpdateTextBufferRegistration();
var roles = GetAllPredefinedRoles();
ITextBuffer projectionBuffer = null;
foreach (var projectionBufferProvider in Imports.ProjectionBufferProviders)
{
if (projectionBufferProvider.Value.TryGetProjectionBuffer(TextBuffer, out projectionBuffer))
{
break;
}
}
var dataModel = new ProjectionTextDataModel(TextBuffer, projectionBuffer);
//we have multiple copies of VacuousTextDataModel for back-compat reasons
#pragma warning disable CS0436 // Type conflicts with imported type
var viewModel = UIExtensionSelector.InvokeBestMatchingFactory(
Imports.TextViewModelProviders,
dataModel.ContentType,
roles,
provider => provider.CreateTextViewModel(dataModel, roles),
Imports.ContentTypeRegistryService,
Imports.GuardedOperations,
this) ?? new VacuousTextViewModel(dataModel);
#pragma warning restore CS0436 // Type conflicts with imported type
TextView = CreateTextView(viewModel, roles);
control = CreateControl();
commandService = Imports.EditorCommandHandlerServiceFactory.GetService(TextView);
EditorOperations = (EditorOperationsInterface)Imports.EditorOperationsProvider.GetEditorOperations(TextView);
EditorOptions = Imports.EditorOptionsFactoryService.GetOptions(TextView);
TextBufferOptions = Imports.EditorOptionsFactoryService.GetOptions(TextView.TextBuffer);
UpdateTextEditorOptions(this, EventArgs.Empty);
contentProviders = new List <IEditorContentProvider> (Imports.EditorContentProviderService.GetContentProvidersForView(TextView));
TextView.Properties [typeof(DocumentController)] = this;
infoBarPresenter = Imports.InfoBarPresenterFactory?.TryGetInfoBarPresenter(TextView);
InstallAdditionalEditorOperationsCommands();
UpdateBufferOptions();
SubscribeToEvents();
// Set up this static event handling just once
if (globalOptions == null)
{
globalOptions = Imports.EditorOptionsFactoryService.GlobalOptions;
// From Mono.TextEditor.TextEditorOptions
const double ZOOM_FACTOR = 1.1f;
const int ZOOM_MIN_POW = -4;
const int ZOOM_MAX_POW = 8;
var ZOOM_MIN = Math.Pow(ZOOM_FACTOR, ZOOM_MIN_POW);
var ZOOM_MAX = Math.Pow(ZOOM_FACTOR, ZOOM_MAX_POW);
#if !WINDOWS
globalOptions.SetMinZoomLevel(ZOOM_MIN * 100);
globalOptions.SetMaxZoomLevel(ZOOM_MAX * 100);
#endif
OnConfigurationZoomLevelChanged(null, EventArgs.Empty);
globalOptions.OptionChanged += OnGlobalOptionsChanged;
// Check for option changing in old editor
TextEditorFactory.ZoomLevel.Changed += OnConfigurationZoomLevelChanged;
}
// Content providers can provide additional content
NotifyContentChanged();
await Load(false);
return(control);
}
private static int CalculateIndentation(
string baseline,
ITextSnapshotLine line,
IEditorOptions options,
PythonTextBufferInfo buffer
)
{
var snapshot = line.Snapshot;
if (snapshot.TextBuffer != buffer.Buffer)
{
throw new ArgumentException("buffer mismatch");
}
int indentation = GetIndentation(baseline, options.GetTabSize());
int tabSize = options.GetIndentSize();
var tokens = buffer.GetTokens(line).ToList();
while (tokens.Count > 0 && IsWhitespace(tokens[tokens.Count - 1].Category))
{
tokens.RemoveAt(tokens.Count - 1);
}
if (tokens.Count == 0 || IsUnterminatedStringToken(tokens[tokens.Count - 1], snapshot))
{
return(indentation);
}
if (HasExplicitLineJoin(tokens, snapshot))
{
// explicit line continuation, we indent 1 level for the continued line unless
// we're already indented because of multiple line continuation characters.
indentation = GetIndentation(line.GetText(), options.GetTabSize());
var joinedLine = line.LineNumber - 1;
if (joinedLine >= 0)
{
var prevLineTokens = buffer.GetTokens(snapshot.GetLineFromLineNumber(joinedLine)).ToList();
if (prevLineTokens.Count == 0 || !HasExplicitLineJoin(prevLineTokens, snapshot))
{
indentation += tabSize;
}
}
else
{
indentation += tabSize;
}
return(indentation);
}
var tokenStack = new Stack <TrackingTokenInfo?>();
tokenStack.Push(null); // end with an implicit newline
int endAtLine = -1, currentLine = tokens.Last().LineNumber;
foreach (var t in buffer.GetTokensInReverseFromPoint(tokens.Last().ToSnapshotSpan(snapshot).Start))
{
if (t.LineNumber == currentLine)
{
tokenStack.Push(t);
}
else
{
tokenStack.Push(null);
}
if (t.LineNumber == endAtLine)
{
break;
}
else if (t.Category == TokenCategory.Keyword && PythonKeywords.IsOnlyStatementKeyword(t.GetText(snapshot), buffer.LanguageVersion))
{
endAtLine = t.LineNumber - 1;
}
if (t.LineNumber != currentLine)
{
currentLine = t.LineNumber;
if (t.Category != TokenCategory.WhiteSpace && t.Category != TokenCategory.Comment && t.Category != TokenCategory.LineComment)
{
tokenStack.Push(t);
}
}
}
var indentStack = new Stack <LineInfo>();
var current = LineInfo.Empty;
while (tokenStack.Count > 0)
{
var t = tokenStack.Pop();
if (t == null)
{
current.NeedsUpdate = true;
continue;
}
var tline = new Lazy <string>(() => snapshot.GetLineFromLineNumber(t.Value.LineNumber).GetText());
if (IsOpenGrouping(t.Value, snapshot))
{
indentStack.Push(current);
var next = tokenStack.Count > 0 ? tokenStack.Peek() : null;
if (next != null && next.Value.LineNumber == t.Value.LineNumber)
{
// Put indent at same depth as grouping
current = new LineInfo {
Indentation = t.Value.ToSourceSpan().End.Column - 1
};
}
else
{
// Put indent at one indent deeper than this line
current = new LineInfo {
Indentation = GetIndentation(tline.Value, tabSize) + tabSize
};
}
}
else if (IsCloseGrouping(t.Value, snapshot))
{
if (indentStack.Count > 0)
{
current = indentStack.Pop();
}
else
{
current.NeedsUpdate = true;
}
}
else if (IsExplicitLineJoin(t.Value, snapshot))
{
while (t != null && tokenStack.Count > 0)
{
t = tokenStack.Pop();
}
if (!t.HasValue)
{
continue;
}
}
else if (current.NeedsUpdate == true)
{
current = new LineInfo {
Indentation = GetIndentation(tline.Value, tabSize)
};
}
if (ShouldDedentAfterKeyword(t.Value, snapshot)) // dedent after some statements
{
current.ShouldDedentAfter = true;
}
if (IsColon(t.Value, snapshot) && // indent after a colon
indentStack.Count == 0) // except in a grouping
{
current.ShouldIndentAfter = true;
// If the colon isn't at the end of the line, cancel it out.
// If the following is a ShouldDedentAfterKeyword, only one dedent will occur.
current.ShouldDedentAfter = (tokenStack.Count != 0 && tokenStack.Peek() != null);
}
}
indentation = current.Indentation +
(current.ShouldIndentAfter ? tabSize : 0) -
(current.ShouldDedentAfter ? tabSize : 0);
return(indentation);
}
public IWpfTextView CreateTextView(ITextViewModel viewModel, ITextViewRoleSet roles, IEditorOptions parentOptions) => CreateTextView(viewModel, roles, parentOptions, null);
public IWpfTextView CreateTextView(ITextBuffer textBuffer, ITextViewRoleSet roles, IEditorOptions parentOptions) => CreateTextView(textBuffer, roles, parentOptions, null);
/// <summary>
/// Text View constructor.
/// </summary>
/// <param name="textViewModel">The text view model that provides the text to visualize.</param>
/// <param name="roles">Roles for this view.</param>
/// <param name="parentOptions">Parent options for this view.</param>
/// <param name="factoryService">Our handy text editor factory service.</param>
internal TextView(TextEditor textEditor, ITextViewModel textViewModel, ITextViewRoleSet roles, IEditorOptions parentOptions, TextEditorFactoryService factoryService, bool initialize = true)
{
_textEditor = textEditor;
_roles = roles;
_factoryService = factoryService;
this.TextDataModel = textViewModel.DataModel;
this.TextViewModel = textViewModel;
_textBuffer = textViewModel.EditBuffer;
// _visualBuffer = textViewModel.VisualBuffer;
// _textSnapshot = _textBuffer.CurrentSnapshot;
// _visualSnapshot = _visualBuffer.CurrentSnapshot;
_editorOptions = _factoryService.EditorOptionsFactoryService.GetOptions(this);
_editorOptions.Parent = parentOptions;
if (initialize)
{
this.Initialize();
}
}
public static int GetLineOffsetFromColumn(this ITextSnapshotLine line, int column, IEditorOptions editorOptions)
{
return(line.GetText().GetLineOffsetFromColumn(column, editorOptions.GetTabSize()));
}
public static int GetColumnFromLineOffset(this ITextSnapshotLine line, int lineOffset, IEditorOptions editorOptions)
{
return(line.GetText().GetColumnFromLineOffset(lineOffset, editorOptions.GetTabSize()));
}
public static int GetColumnOfFirstNonWhitespaceCharacterOrEndOfLine(this ITextSnapshotLine line, IEditorOptions editorOptions)
{
return(line.GetColumnOfFirstNonWhitespaceCharacterOrEndOfLine(editorOptions.GetTabSize()));
}
IDsWpfTextView CreateTextViewImpl(ITextViewModel textViewModel, ITextViewRoleSet roles, IEditorOptions parentOptions, TextViewCreatorOptions options)
{
var wpfTextView = new WpfTextView(textViewModel, roles, parentOptions, editorOptionsFactoryService, commandService, smartIndentationService, formattedTextSourceFactoryService, viewClassifierAggregatorService, textAndAdornmentSequencerFactoryService, classificationFormatMapService, editorFormatMapService, adornmentLayerDefinitionService, lineTransformProviderService, spaceReservationStackProvider, wpfTextViewConnectionListenerServiceProvider, bufferGraphFactoryService, wpfTextViewCreationListeners);
if (options?.MenuGuid != null)
{
var guidObjectsProvider = new GuidObjectsProvider(wpfTextView, options?.CreateGuidObjects);
menuService.InitializeContextMenu(wpfTextView.VisualElement, options.MenuGuid.Value, guidObjectsProvider, new ContextMenuInitializer(wpfTextView));
}
if (options?.EnableUndoHistory != false)
{
textViewUndoManagerProvider.Value.GetTextViewUndoManager(wpfTextView);
}
TextViewCreated?.Invoke(this, new TextViewCreatedEventArgs(wpfTextView));
return(wpfTextView);
}
public DropShadowBorderDecoratorSettings(ImageDecoratorContext context)
{
Element = context.ImgElement;
editorOptions = context.EditorOptions;
}
public static int GetLineOffsetFromColumn(this ITextSnapshotLine line, int column, IEditorOptions editorOptions)
{
return line.GetText().GetLineOffsetFromColumn(column, editorOptions.GetTabSize());
}
IDnSpyWpfTextView CreateTextViewImpl(ITextViewModel textViewModel, ITextViewRoleSet roles, IEditorOptions parentOptions, TextViewCreatorOptions options, Func <IGuidObjectsProvider> createGuidObjectsProvider = null)
{
var guidObjectsProvider = new GuidObjectsProvider(options?.CreateGuidObjects, createGuidObjectsProvider?.Invoke());
var wpfTextView = new WpfTextView(textViewModel, roles, parentOptions, editorOptionsFactoryService, commandManager, smartIndentationService, formattedTextSourceFactoryService, viewClassifierAggregatorService, textAndAdornmentSequencerFactoryService, classificationFormatMapService, editorFormatMapService, adornmentLayerDefinitionService, lineTransformProviderService, wpfTextViewCreationListeners);
guidObjectsProvider.WpfTextView = wpfTextView;
if (options?.MenuGuid != null)
{
menuManager.InitializeContextMenu(wpfTextView.VisualElement, options.MenuGuid.Value, guidObjectsProvider, new ContextMenuInitializer(wpfTextView));
}
TextViewCreated?.Invoke(this, new TextViewCreatedEventArgs(wpfTextView));
return(wpfTextView);
}
private static int CalculateIndentation(string baseline, ITextSnapshotLine line, IEditorOptions options, IClassifier classifier, ITextView textView)
{
int indentation = GetIndentation(baseline, options.GetTabSize());
int tabSize = options.GetIndentSize();
var tokens = classifier.GetClassificationSpans(line.Extent);
if (tokens.Count > 0 && !IsUnterminatedStringToken(tokens[tokens.Count - 1]))
{
int tokenIndex = tokens.Count - 1;
while (tokenIndex >= 0 &&
(tokens[tokenIndex].ClassificationType.IsOfType(PredefinedClassificationTypeNames.Comment) ||
tokens[tokenIndex].ClassificationType.IsOfType(PredefinedClassificationTypeNames.WhiteSpace)))
{
tokenIndex--;
}
if (tokenIndex < 0)
{
return(indentation);
}
if (Genero4glReverseParser.IsExplicitLineJoin(tokens[tokenIndex]))
{
// explicit line continuation, we indent 1 level for the continued line unless
// we're already indented because of multiple line continuation characters.
indentation = GetIndentation(line.GetText(), options.GetTabSize());
var joinedLine = tokens[tokenIndex].Span.Start.GetContainingLine();
if (joinedLine.LineNumber > 0)
{
var prevLineSpans = classifier.GetClassificationSpans(tokens[tokenIndex].Span.Snapshot.GetLineFromLineNumber(joinedLine.LineNumber - 1).Extent);
if (prevLineSpans.Count == 0 || !Genero4glReverseParser.IsExplicitLineJoin(prevLineSpans[prevLineSpans.Count - 1]))
{
indentation += tabSize;
}
}
else
{
indentation += tabSize;
}
return(indentation);
}
string sline = tokens[tokenIndex].Span.GetText();
var lastChar = sline.Length == 0 ? '\0' : sline[sline.Length - 1];
// use the expression parser to figure out if we're in a grouping...
var spans = textView.BufferGraph.MapDownToFirstMatch(
tokens[tokenIndex].Span,
SpanTrackingMode.EdgePositive,
PythonContentTypePrediciate
);
if (spans.Count == 0)
{
return(indentation);
}
var revParser = new Genero4glReverseParser(
spans[0].Snapshot,
spans[0].Snapshot.TextBuffer,
spans[0].Snapshot.CreateTrackingSpan(
spans[0].Span,
SpanTrackingMode.EdgePositive
)
);
var tokenStack = new List <ClassificationSpan>();
tokenStack.Insert(0, null);
bool endAtNextNull = false;
foreach (var token in revParser)
{
tokenStack.Insert(0, token);
if (token == null && endAtNextNull)
{
break;
}
else if (token != null &&
token.ClassificationType == Genero4glClassifierProvider.Keyword)
{
var tok = Tokens.GetToken(token.Span.GetText());
if (tok != null && Genero4glAst.ValidStatementKeywords.Contains(tok.Kind))
{
switch (tok.Kind)
{
// Handle any tokens that are valid statement keywords in the autocomplete context but not in the "statement start" context
case TokenKind.EndKeyword:
continue;
default:
endAtNextNull = true;
break;
}
}
}
}
var indentStack = new System.Collections.Generic.Stack <LineInfo>();
var current = LineInfo.Empty;
List <CancelIndent> cancelIndent = null;
int cancelIndentStartingAt = -1;
TokenKind firstStatement = TokenKind.EndOfFile;
TokenKind latestIndentChangeToken = TokenKind.EndOfFile;
ClassificationSpan firstToken = null;
for (int i = 0; i < tokenStack.Count; i++)
{
var token = tokenStack[i];
if (token != null && firstToken == null)
{
firstToken = token;
}
if (token == null)
{
current.NeedsUpdate = true;
}
else if (token.IsOpenGrouping())
{
indentStack.Push(current);
var start = token.Span.Start;
var line2 = start.GetContainingLine();
current = new LineInfo
{
Indentation = start.Position - line2.Start.Position + 1
};
}
else if (token.IsCloseGrouping())
{
if (indentStack.Count > 0)
{
current = indentStack.Pop();
}
else
{
current.NeedsUpdate = true;
}
}
else if (Genero4glReverseParser.IsExplicitLineJoin(token))
{
while (token != null && i + 1 < tokenStack.Count)
{
i++;
token = tokenStack[i];
}
}
else if (current.NeedsUpdate == true)
{
var tok = Tokens.GetToken(token.Span.GetText());
if (tok == null || !Genero4glAst.ValidStatementKeywords.Contains(tok.Kind))
{
current.NeedsUpdate = false;
}
else
{
switch (tok.Kind)
{
// Handle any tokens that are valid statement keywords in the autocomplete context but not in the "statement start" context
case TokenKind.EndKeyword:
if (firstStatement != TokenKind.EndOfFile)
{
current.NeedsUpdate = false;
}
else
{
latestIndentChangeToken = tok.Kind;
}
break;
default:
{
if (firstStatement == TokenKind.EndOfFile)
{
firstStatement = tok.Kind;
}
var line2 = token.Span.Start.GetContainingLine();
current = new LineInfo
{
Indentation = GetIndentation(line2.GetText(), tabSize)
};
break;
}
}
}
}
if (token != null && current.ShouldIndentAfter && cancelIndent != null)
{
// Check to see if we have following tokens that would cancel the current indent.
var tok = Tokens.GetToken(token.Span.GetText());
var tokenCategory = token.ClassificationType;
bool allPast = true;
bool cancel = false;
foreach (var ci in cancelIndent)
{
if (ci.TokensAhead < (i - cancelIndentStartingAt))
{
continue;
}
else
{
allPast = false;
if (ci.TokensAhead == (i - cancelIndentStartingAt))
{
if (ci.UseCategory && ci.CancelCategory != null)
{
cancel = tokenCategory == ci.CancelCategory;
}
else if (tok != null)
{
cancel = tok.Kind == ci.CancelToken;
}
if (cancel)
{
break;
}
}
}
}
if (cancel)
{
current.ShouldIndentAfter = false;
}
if (cancel || allPast)
{
cancelIndent = null;
cancelIndentStartingAt = -1;
latestIndentChangeToken = TokenKind.EndOfFile;
}
}
if (token != null && ShouldDedentAfterKeyword(token))
{ // dedent after some statements
current.ShouldDedentAfter = true;
}
TokenKind tempChangeToken;
if (token != null &&
indentStack.Count == 0 &&
firstToken == token &&
ShouldIndentAfterKeyword(token, out tempChangeToken, out cancelIndent))
{ // except in a grouping
if (latestIndentChangeToken != TokenKind.EndKeyword)
{
current.ShouldIndentAfter = true;
}
latestIndentChangeToken = tempChangeToken;
if (cancelIndent != null)
{
cancelIndentStartingAt = i;
}
}
}
if (tokenStack.Count > 2 &&
tokenStack[tokenStack.Count - 2] != null)
{
if (latestIndentChangeToken != TokenKind.EndOfFile &&
_customIndentingRules.ContainsKey(latestIndentChangeToken))
{
var potentialIndent = _customIndentingRules[latestIndentChangeToken](tokenStack, tabSize);
if (potentialIndent != 0)
{
return(potentialIndent);
}
}
// see if we have specific alignment rules
if (firstStatement != TokenKind.EndOfFile &&
_customIndentingRules.ContainsKey(firstStatement))
{
var potentialIndent = _customIndentingRules[firstStatement](tokenStack, tabSize);
if (potentialIndent != 0)
{
return(potentialIndent);
}
}
}
indentation = current.Indentation +
(current.ShouldIndentAfter ? tabSize : 0) -
(current.ShouldDedentAfter ? tabSize : 0);
}
return(indentation);
}
public IDsWpfTextView CreateTextView(ITextBuffer textBuffer, ITextViewRoleSet roles, IEditorOptions parentOptions, TextViewCreatorOptions options)
{
if (textBuffer == null)
{
throw new ArgumentNullException(nameof(textBuffer));
}
if (roles == null)
{
throw new ArgumentNullException(nameof(roles));
}
if (parentOptions == null)
{
throw new ArgumentNullException(nameof(parentOptions));
}
return(CreateTextView(new TextDataModel(textBuffer), roles, parentOptions, options));
}
/// <summary>
/// Writes a set of images based on the settings specified in a ImagePropertiesInfo object.
/// </summary>
/// <param name="imageInfo">the image properties</param>
/// <param name="allowEnlargement">if true, generated images will be scaled larger than the source image (if the imageInfo sizes are larger) </param>
public void WriteImages(ImagePropertiesInfo imageInfo, bool allowEnlargement, ImageDecoratorInvocationSource invocationSource, CreateFileCallback inlineFileCreator, CreateFileCallback linkedFileCreator, IEditorOptions clientOptions)
{
string inlinePrefix = imageInfo.LinkTarget == LinkTargetType.IMAGE ? "_thumb" : "";
ImageFilter inlineFilter = ImageFilterDecoratorAdapter.CreateImageDecoratorsFilter(imageInfo, ImageEmbedType.Embedded, invocationSource, clientOptions);
ImageFilter targetFilter = ImageFilterDecoratorAdapter.CreateImageDecoratorsFilter(imageInfo, ImageEmbedType.Linked, invocationSource, clientOptions);
using (Bitmap inlineBitmap = new Bitmap(imageInfo.ImageSourceUri.LocalPath))
{
string imgPath = writeImage(inlineBitmap, imageInfo.ImageSourceUri.LocalPath, inlinePrefix, inlineFilter, inlineFileCreator);
string inlineImgPath = new Uri(UrlHelper.CreateUrlFromPath(imgPath)).ToString();
imageInfo.InlineImageUrl = inlineImgPath;
}
//Generate the link image
//Warning! this imageInfo.LinkTarget check must be done after the inline image because the resize
// decorator will set the default link target for the image the first time it
// is applied.
//imageInfo.LinkTarget = origLinkTarget;
if (imageInfo.LinkTarget == LinkTargetType.IMAGE && !ImageDecoratorDirective.ShouldSuppressLinked)
{
using (Bitmap targetBitmap = new Bitmap(imageInfo.ImageSourceUri.LocalPath))
{
string anchorPath = writeImage(targetBitmap, imageInfo.ImageSourceUri.LocalPath, "", targetFilter, linkedFileCreator);
string targetUrl = new Uri(UrlHelper.CreateUrlFromPath(anchorPath)).ToString();
imageInfo.LinkTargetUrl = targetUrl;
}
}
}
public IDsWpfTextView CreateTextView(ITextViewModel viewModel, ITextViewRoleSet roles, IEditorOptions parentOptions, TextViewCreatorOptions options)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
if (roles == null)
{
throw new ArgumentNullException(nameof(roles));
}
if (parentOptions == null)
{
throw new ArgumentNullException(nameof(parentOptions));
}
return(CreateTextViewImpl(viewModel, roles, parentOptions, options));
}
WordWrapCommand(IEditorOptionsFactoryService editorOptionsFactoryService)
{
this.editorOptions = editorOptionsFactoryService.GlobalOptions;
}
public SettingsStore(IVsSettingsManager manager, IEditorOptions options)
{
_options = options;
manager.GetWritableSettingsStore((uint)__VsSettingsScope.SettingsScope_UserSettings, out _store);
}
HighlightCurrentLineCommand(IEditorOptionsFactoryService editorOptionsFactoryService)
{
this.editorOptions = editorOptionsFactoryService.GlobalOptions;
}
private static int CalculateIndentation(string baseline, ITextSnapshotLine line, IEditorOptions options, IClassifier classifier, ITextView textView)
{
int indentation = GetIndentation(baseline, options.GetTabSize());
int tabSize = options.GetIndentSize();
var tokens = classifier.GetClassificationSpans(line.Extent);
if (tokens.Count > 0 && !IsUnterminatedStringToken(tokens[tokens.Count - 1]))
{
int tokenIndex = tokens.Count - 1;
while (tokenIndex >= 0 &&
(tokens[tokenIndex].ClassificationType.IsOfType(PredefinedClassificationTypeNames.Comment) ||
tokens[tokenIndex].ClassificationType.IsOfType(PredefinedClassificationTypeNames.WhiteSpace)))
{
tokenIndex--;
}
if (tokenIndex < 0)
{
return(indentation);
}
if (ReverseExpressionParser.IsExplicitLineJoin(tokens[tokenIndex]))
{
// explicit line continuation, we indent 1 level for the continued line unless
// we're already indented because of multiple line continuation characters.
indentation = GetIndentation(line.GetText(), options.GetTabSize());
var joinedLine = tokens[tokenIndex].Span.Start.GetContainingLine();
if (joinedLine.LineNumber > 0)
{
var prevLineSpans = classifier.GetClassificationSpans(tokens[tokenIndex].Span.Snapshot.GetLineFromLineNumber(joinedLine.LineNumber - 1).Extent);
if (prevLineSpans.Count == 0 || !ReverseExpressionParser.IsExplicitLineJoin(prevLineSpans[prevLineSpans.Count - 1]))
{
indentation += tabSize;
}
}
else
{
indentation += tabSize;
}
return(indentation);
}
string sline = tokens[tokenIndex].Span.GetText();
var lastChar = sline.Length == 0 ? '\0' : sline[sline.Length - 1];
// use the expression parser to figure out if we're in a grouping...
var spans = textView.BufferGraph.MapDownToFirstMatch(
tokens[tokenIndex].Span,
SpanTrackingMode.EdgePositive,
PythonContentTypePrediciate
);
if (spans.Count == 0)
{
return(indentation);
}
var revParser = new ReverseExpressionParser(
spans[0].Snapshot,
spans[0].Snapshot.TextBuffer,
spans[0].Snapshot.CreateTrackingSpan(
spans[0].Span,
SpanTrackingMode.EdgePositive
)
);
var tokenStack = new System.Collections.Generic.Stack <ClassificationSpan>();
tokenStack.Push(null); // end with an implicit newline
bool endAtNextNull = false;
foreach (var token in revParser)
{
tokenStack.Push(token);
if (token == null && endAtNextNull)
{
break;
}
else if (token != null &&
token.ClassificationType == revParser.Classifier.Provider.Keyword &&
PythonKeywords.IsOnlyStatementKeyword(token.Span.GetText()))
{
endAtNextNull = true;
}
}
var indentStack = new System.Collections.Generic.Stack <LineInfo>();
var current = LineInfo.Empty;
while (tokenStack.Count > 0)
{
var token = tokenStack.Pop();
if (token == null)
{
current.NeedsUpdate = true;
}
else if (token.IsOpenGrouping())
{
indentStack.Push(current);
var start = token.Span.Start;
var line2 = start.GetContainingLine();
var next = tokenStack.Count > 0 ? tokenStack.Peek() : null;
if (next != null && next.Span.End <= line2.End)
{
current = new LineInfo {
Indentation = start.Position - line2.Start.Position + 1
};
}
else
{
current = new LineInfo {
Indentation = GetIndentation(line2.GetText(), tabSize) + tabSize
};
}
}
else if (token.IsCloseGrouping())
{
if (indentStack.Count > 0)
{
current = indentStack.Pop();
}
else
{
current.NeedsUpdate = true;
}
}
else if (ReverseExpressionParser.IsExplicitLineJoin(token))
{
while (token != null && tokenStack.Count > 0)
{
token = tokenStack.Pop();
}
}
else if (current.NeedsUpdate == true)
{
var line2 = token.Span.Start.GetContainingLine();
current = new LineInfo {
Indentation = GetIndentation(line2.GetText(), tabSize)
};
}
if (token != null && ShouldDedentAfterKeyword(token)) // dedent after some statements
{
current.ShouldDedentAfter = true;
}
if (token != null && token.Span.GetText() == ":" && // indent after a colon
indentStack.Count == 0) // except in a grouping
{
current.ShouldIndentAfter = true;
// If the colon isn't at the end of the line, cancel it out.
// If the following is a ShouldDedentAfterKeyword, only one dedent will occur.
current.ShouldDedentAfter = (tokenStack.Count != 0 && tokenStack.Peek() != null);
}
}
indentation = current.Indentation +
(current.ShouldIndentAfter ? tabSize : 0) -
(current.ShouldDedentAfter ? tabSize : 0);
}
return(indentation);
}
public static DefaultTextViewOptions.IncludeWhitespaces VisibleWhitespaceEnabledTypes(this IEditorOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(options.GetOptionValue <DefaultTextViewOptions.IncludeWhitespaces> (DefaultTextViewOptions.UseVisibleWhitespaceIncludeId));
}
public DefaultSelectionPrimitive(TextView textView, IEditorOptions editorOptions)
{
_textView = textView;
_editorOptions = editorOptions;
}
private static IProjectionBuffer CreateProjectionBuffer(
IProjectionBufferFactoryService factoryService,
IContentTypeRegistryService registryService,
IEditorOptions editorOptions,
ITextSnapshot snapshot,
string separator,
object suffixOpt,
bool trim,
params LineSpan[] exposedLineSpans)
{
var spans = new List <object>();
if (exposedLineSpans.Length > 0)
{
if (exposedLineSpans[0].Start > 0 && !string.IsNullOrEmpty(separator))
{
spans.Add(separator);
spans.Add(editorOptions.GetNewLineCharacter());
}
var snapshotSpanRanges = CreateSnapshotSpanRanges(snapshot, exposedLineSpans);
var indentColumn = trim
? DetermineIndentationColumn(editorOptions, snapshotSpanRanges.Flatten())
: 0;
foreach (var snapshotSpanRange in snapshotSpanRanges)
{
foreach (var snapshotSpan in snapshotSpanRange)
{
var line = snapshotSpan.Snapshot.GetLineFromPosition(snapshotSpan.Start);
var indentPosition = line.GetLineOffsetFromColumn(indentColumn, editorOptions) + line.Start;
var mappedSpan = new SnapshotSpan(snapshotSpan.Snapshot,
Span.FromBounds(indentPosition, snapshotSpan.End));
var trackingSpan = mappedSpan.CreateTrackingSpan(SpanTrackingMode.EdgeExclusive);
spans.Add(trackingSpan);
// Add a newline between every line.
if (snapshotSpan != snapshotSpanRange.Last())
{
spans.Add(editorOptions.GetNewLineCharacter());
}
}
// Add a separator between every set of lines.
if (snapshotSpanRange != snapshotSpanRanges.Last())
{
spans.Add(editorOptions.GetNewLineCharacter());
spans.Add(separator);
spans.Add(editorOptions.GetNewLineCharacter());
}
}
if (snapshot.GetLineNumberFromPosition(snapshotSpanRanges.Last().Last().End) < snapshot.LineCount - 1)
{
spans.Add(editorOptions.GetNewLineCharacter());
spans.Add(separator);
}
}
if (suffixOpt != null)
{
if (spans.Count >= 0)
{
if (!separator.Equals(spans.Last()))
{
spans.Add(editorOptions.GetNewLineCharacter());
spans.Add(separator);
}
spans.Add(editorOptions.GetNewLineCharacter());
}
spans.Add(suffixOpt);
}
return(factoryService.CreateProjectionBuffer(
projectionEditResolver: null,
sourceSpans: spans,
options: ProjectionBufferOptions.None,
contentType: registryService.GetContentType(RoslynPreviewContentType)));
}
public static IProjectionBuffer CreateProjectionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IEditorOptions editorOptions,
IContentType contentType,
IEnumerable <SnapshotSpan> exposedSpans)
{
var spans = new NormalizedSnapshotSpanCollection(exposedSpans);
if (spans.Count > 0)
{
// BUG(6335): We have to make sure that the spans refer to the current snapshot of
// the buffer.
var buffer = spans.First().Snapshot.TextBuffer;
var currentSnapshot = buffer.CurrentSnapshot;
spans = new NormalizedSnapshotSpanCollection(
spans.Select(s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive)));
}
contentType ??= factoryService.ProjectionContentType;
var projectionBuffer = factoryService.CreateProjectionBuffer(
projectionEditResolver: null,
sourceSpans: Array.Empty <object>(),
options: ProjectionBufferOptions.None,
contentType: contentType);
if (spans.Count > 0)
{
var finalSpans = new List <object>();
// We need to figure out the shorted indentation level of the exposed lines. We'll
// then remove that indentation from all lines.
var indentationColumn = DetermineIndentationColumn(editorOptions, spans);
foreach (var span in spans)
{
var snapshot = span.Snapshot;
var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start);
var endLineNumber = snapshot.GetLineNumberFromPosition(span.End);
for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++)
{
// Compute the span clamped to this line
var line = snapshot.GetLineFromLineNumber(lineNumber);
var finalSpanStart = Math.Max(line.Start, span.Start);
var finalSpanEnd = Math.Min(line.EndIncludingLineBreak, span.End);
// We'll only offset if our span doesn't already start at the start of the line. See the similar exclusion in
// DetermineIndentationColumn that this matches.
if (line.Start == finalSpanStart)
{
finalSpanStart += line.GetLineOffsetFromColumn(indentationColumn, editorOptions);
// Paranoia: what if the indentation reversed our ordering?
if (finalSpanStart > finalSpanEnd)
{
finalSpanStart = finalSpanEnd;
}
}
// We don't expect edits to happen while this projection buffer is active. We'll choose EdgeExclusive so
// if they do we don't end up in any cases where there is overlapping source spans.
finalSpans.Add(snapshot.CreateTrackingSpan(Span.FromBounds(finalSpanStart, finalSpanEnd), SpanTrackingMode.EdgeExclusive));
}
}
projectionBuffer.InsertSpans(0, finalSpans);
}
return(projectionBuffer);
}
private static string GetSubmissionFromSelectedSpans(IEditorOptions editorOptions, IEnumerable <SnapshotSpan> selectedSpans) => string.Join(editorOptions.GetNewLineCharacter(), selectedSpans.Select(ss => ss.GetText()));
public static bool GetAutoInsertClosingTag(this IEditorOptions options) => options.GetOptionValue(XmlOptions.AutoInsertClosingTag);
public IWpfTextView CreateTextView(MonoDevelop.Ide.Editor.TextEditor textEditor, ITextViewRoleSet roles = null, IEditorOptions parentOptions = null)
{
if (textEditor == null)
{
throw new ArgumentNullException("textBuffer");
}
ITextBuffer textBuffer = textEditor.GetPlatformTextBuffer();
ITextDataModel dataModel = new VacuousTextDataModel(textBuffer);
ITextViewModel viewModel = UIExtensionSelector.InvokeBestMatchingFactory
(TextViewModelProviders,
dataModel.ContentType,
roles,
(provider) => (provider.CreateTextViewModel(dataModel, roles)),
ContentTypeRegistryService,
this.GuardedOperations,
this) ?? new VacuousTextViewModel(dataModel);
TextView view = new TextView(textEditor, viewModel, roles ?? this.DefaultRoles, parentOptions ?? this.EditorOptionsFactoryService.GlobalOptions, this);
view.Properties.AddProperty(typeof(MonoDevelop.Ide.Editor.TextEditor), textEditor);
this.TextViewCreated?.Invoke(this, new TextViewCreatedEventArgs(view));
return(view);
}
private void ReadSettings(IEditorOptions options)
{
var settings_manager = ServiceProvider.GetService(typeof(SVsSettingsManager)) as IVsSettingsManager;
var store = new SettingsStore(settings_manager, options);
store.Load();
SettingsLoaded = true;
}
public IDnSpyWpfTextView CreateTextView(ITextDataModel dataModel, ITextViewRoleSet roles, IEditorOptions parentOptions, TextViewCreatorOptions options)
{
if (dataModel == null)
{
throw new ArgumentNullException(nameof(dataModel));
}
if (roles == null)
{
throw new ArgumentNullException(nameof(roles));
}
if (parentOptions == null)
{
throw new ArgumentNullException(nameof(parentOptions));
}
return(CreateTextView(new TextViewModel(dataModel), roles, parentOptions, options));
}