ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-15 18:46:36 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge vscode 1.67 (#20883)

Browse Source 
* Fix initial build breaks from 1.67 merge (#2514)

* Update yarn lock files

* Update build scripts

* Fix tsconfig

* Build breaks

* WIP

* Update yarn lock files

* Misc breaks

* Updates to package.json

* Breaks

* Update yarn

* Fix breaks

* Breaks

* Build breaks

* Breaks

* Breaks

* Breaks

* Breaks

* Breaks

* Missing file

* Breaks

* Breaks

* Breaks

* Breaks

* Breaks

* Fix several runtime breaks (#2515)

* Missing files

* Runtime breaks

* Fix proxy ordering issue

* Remove commented code

* Fix breaks with opening query editor

* Fix post merge break

* Updates related to setup build and other breaks (#2516)

* Fix bundle build issues

* Update distro

* Fix distro merge and update build JS files

* Disable pipeline steps

* Remove stats call

* Update license name

* Make new RPM dependencies a warning

* Fix extension manager version checks

* Update JS file

* Fix a few runtime breaks

* Fixes

* Fix runtime issues

* Fix build breaks

* Update notebook tests (part 1)

* Fix broken tests

* Linting errors

* Fix hygiene

* Disable lint rules

* Bump distro

* Turn off smoke tests

* Disable integration tests

* Remove failing "activate" test

* Remove failed test assertion

* Disable other broken test

* Disable query history tests

* Disable extension unit tests

* Disable failing tasks
This commit is contained in:
Karl Burtram
2022-10-19 19:13:18 -07:00
committed by GitHub
parent 33c6daaea1
commit 8a3d08f0de
3738 changed files with 192313 additions and 107208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/vs/editor/browser/config/charWidthReader.ts
View File

@@ -3,8 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { isSafari } from 'vs/base/browser/browser';
import { EDITOR_FONT_DEFAULTS } from 'vs/editor/common/config/editorOptions';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { BareFontInfo } from 'vs/editor/common/config/fontInfo';
export const enum CharWidthRequestType {
@@ -64,38 +63,22 @@ class DomCharWidthReader {
}
private _createDomElements(): void {
const fontFamily = this._bareFontInfo.getMassagedFontFamily(isSafari ? EDITOR_FONT_DEFAULTS.fontFamily : null);
const container = document.createElement('div');
container.style.position = 'absolute';
container.style.top = '-50000px';
container.style.width = '50000px';
const regularDomNode = document.createElement('div');
regularDomNode.style.fontFamily = fontFamily;
regularDomNode.style.fontWeight = this._bareFontInfo.fontWeight;
regularDomNode.style.fontSize = this._bareFontInfo.fontSize + 'px';
regularDomNode.style.fontFeatureSettings = this._bareFontInfo.fontFeatureSettings;
regularDomNode.style.lineHeight = this._bareFontInfo.lineHeight + 'px';
regularDomNode.style.letterSpacing = this._bareFontInfo.letterSpacing + 'px';
applyFontInfo(regularDomNode, this._bareFontInfo);
container.appendChild(regularDomNode);
const boldDomNode = document.createElement('div');
boldDomNode.style.fontFamily = fontFamily;
applyFontInfo(boldDomNode, this._bareFontInfo);
boldDomNode.style.fontWeight = 'bold';
boldDomNode.style.fontSize = this._bareFontInfo.fontSize + 'px';
boldDomNode.style.fontFeatureSettings = this._bareFontInfo.fontFeatureSettings;
boldDomNode.style.lineHeight = this._bareFontInfo.lineHeight + 'px';
boldDomNode.style.letterSpacing = this._bareFontInfo.letterSpacing + 'px';
container.appendChild(boldDomNode);
const italicDomNode = document.createElement('div');
italicDomNode.style.fontFamily = fontFamily;
italicDomNode.style.fontWeight = this._bareFontInfo.fontWeight;
italicDomNode.style.fontSize = this._bareFontInfo.fontSize + 'px';
italicDomNode.style.fontFeatureSettings = this._bareFontInfo.fontFeatureSettings;
italicDomNode.style.lineHeight = this._bareFontInfo.lineHeight + 'px';
italicDomNode.style.letterSpacing = this._bareFontInfo.letterSpacing + 'px';
applyFontInfo(italicDomNode, this._bareFontInfo);
italicDomNode.style.fontStyle = 'italic';
container.appendChild(italicDomNode);

383
src/vs/editor/browser/config/configuration.ts
View File

@@ -1,383 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as browser from 'vs/base/browser/browser';
import { FastDomNode } from 'vs/base/browser/fastDomNode';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import * as platform from 'vs/base/common/platform';
import { CharWidthRequest, CharWidthRequestType, readCharWidths } from 'vs/editor/browser/config/charWidthReader';
import { ElementSizeObserver } from 'vs/editor/browser/config/elementSizeObserver';
import { CommonEditorConfiguration, IEnvConfiguration } from 'vs/editor/common/config/commonEditorConfig';
import { EditorOption, EditorFontLigatures, EDITOR_FONT_DEFAULTS } from 'vs/editor/common/config/editorOptions';
import { BareFontInfo, FontInfo, SERIALIZED_FONT_INFO_VERSION } from 'vs/editor/common/config/fontInfo';
import { IDimension } from 'vs/editor/common/editorCommon';
import { IAccessibilityService, AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
import { IEditorConstructionOptions } from 'vs/editor/browser/editorBrowser';
class CSSBasedConfigurationCache {
private readonly _keys: { [key: string]: BareFontInfo; };
private readonly _values: { [key: string]: FontInfo; };
constructor() {
this._keys = Object.create(null);
this._values = Object.create(null);
}
public has(item: BareFontInfo): boolean {
const itemId = item.getId();
return !!this._values[itemId];
}
public get(item: BareFontInfo): FontInfo {
const itemId = item.getId();
return this._values[itemId];
}
public put(item: BareFontInfo, value: FontInfo): void {
const itemId = item.getId();
this._keys[itemId] = item;
this._values[itemId] = value;
}
public remove(item: BareFontInfo): void {
const itemId = item.getId();
delete this._keys[itemId];
delete this._values[itemId];
}
public getValues(): FontInfo[] {
return Object.keys(this._keys).map(id => this._values[id]);
}
}
export function clearAllFontInfos(): void {
CSSBasedConfiguration.INSTANCE.clearCache();
}
export function readFontInfo(bareFontInfo: BareFontInfo): FontInfo {
return CSSBasedConfiguration.INSTANCE.readConfiguration(bareFontInfo);
}
export function restoreFontInfo(fontInfo: ISerializedFontInfo[]): void {
CSSBasedConfiguration.INSTANCE.restoreFontInfo(fontInfo);
}
export function serializeFontInfo(): ISerializedFontInfo[] | null {
const fontInfo = CSSBasedConfiguration.INSTANCE.saveFontInfo();
if (fontInfo.length > 0) {
return fontInfo;
}
return null;
}
export interface ISerializedFontInfo {
readonly version: number;
readonly zoomLevel: number;
readonly pixelRatio: number;
readonly fontFamily: string;
readonly fontWeight: string;
readonly fontSize: number;
readonly fontFeatureSettings: string;
readonly lineHeight: number;
readonly letterSpacing: number;
readonly isMonospace: boolean;
readonly typicalHalfwidthCharacterWidth: number;
readonly typicalFullwidthCharacterWidth: number;
readonly canUseHalfwidthRightwardsArrow: boolean;
readonly spaceWidth: number;
readonly middotWidth: number;
readonly wsmiddotWidth: number;
readonly maxDigitWidth: number;
}
class CSSBasedConfiguration extends Disposable {
public static readonly INSTANCE = new CSSBasedConfiguration();
private _cache: CSSBasedConfigurationCache;
private _evictUntrustedReadingsTimeout: any;
private _onDidChange = this._register(new Emitter<void>());
public readonly onDidChange: Event<void> = this._onDidChange.event;
constructor() {
super();
this._cache = new CSSBasedConfigurationCache();
this._evictUntrustedReadingsTimeout = -1;
}
public override dispose(): void {
if (this._evictUntrustedReadingsTimeout !== -1) {
clearTimeout(this._evictUntrustedReadingsTimeout);
this._evictUntrustedReadingsTimeout = -1;
}
super.dispose();
}
public clearCache(): void {
this._cache = new CSSBasedConfigurationCache();
this._onDidChange.fire();
}
private _writeToCache(item: BareFontInfo, value: FontInfo): void {
this._cache.put(item, value);
if (!value.isTrusted && this._evictUntrustedReadingsTimeout === -1) {
// Try reading again after some time
this._evictUntrustedReadingsTimeout = setTimeout(() => {
this._evictUntrustedReadingsTimeout = -1;
this._evictUntrustedReadings();
}, 5000);
}
}
private _evictUntrustedReadings(): void {
const values = this._cache.getValues();
let somethingRemoved = false;
for (const item of values) {
if (!item.isTrusted) {
somethingRemoved = true;
this._cache.remove(item);
}
}
if (somethingRemoved) {
this._onDidChange.fire();
}
}
public saveFontInfo(): ISerializedFontInfo[] {
// Only save trusted font info (that has been measured in this running instance)
return this._cache.getValues().filter(item => item.isTrusted);
}
public restoreFontInfo(savedFontInfos: ISerializedFontInfo[]): void {
// Take all the saved font info and insert them in the cache without the trusted flag.
// The reason for this is that a font might have been installed on the OS in the meantime.
for (const savedFontInfo of savedFontInfos) {
if (savedFontInfo.version !== SERIALIZED_FONT_INFO_VERSION) {
// cannot use older version
continue;
}
const fontInfo = new FontInfo(savedFontInfo, false);
this._writeToCache(fontInfo, fontInfo);
}
}
public readConfiguration(bareFontInfo: BareFontInfo): FontInfo {
if (!this._cache.has(bareFontInfo)) {
let readConfig = CSSBasedConfiguration._actualReadConfiguration(bareFontInfo);
if (readConfig.typicalHalfwidthCharacterWidth <= 2 || readConfig.typicalFullwidthCharacterWidth <= 2 || readConfig.spaceWidth <= 2 || readConfig.maxDigitWidth <= 2) {
// Hey, it's Bug 14341 ... we couldn't read
readConfig = new FontInfo({
zoomLevel: browser.getZoomLevel(),
pixelRatio: browser.getPixelRatio(),
fontFamily: readConfig.fontFamily,
fontWeight: readConfig.fontWeight,
fontSize: readConfig.fontSize,
fontFeatureSettings: readConfig.fontFeatureSettings,
lineHeight: readConfig.lineHeight,
letterSpacing: readConfig.letterSpacing,
isMonospace: readConfig.isMonospace,
typicalHalfwidthCharacterWidth: Math.max(readConfig.typicalHalfwidthCharacterWidth, 5),
typicalFullwidthCharacterWidth: Math.max(readConfig.typicalFullwidthCharacterWidth, 5),
canUseHalfwidthRightwardsArrow: readConfig.canUseHalfwidthRightwardsArrow,
spaceWidth: Math.max(readConfig.spaceWidth, 5),
middotWidth: Math.max(readConfig.middotWidth, 5),
wsmiddotWidth: Math.max(readConfig.wsmiddotWidth, 5),
maxDigitWidth: Math.max(readConfig.maxDigitWidth, 5),
}, false);
}
this._writeToCache(bareFontInfo, readConfig);
}
return this._cache.get(bareFontInfo);
}
private static createRequest(chr: string, type: CharWidthRequestType, all: CharWidthRequest[], monospace: CharWidthRequest[] | null): CharWidthRequest {
const result = new CharWidthRequest(chr, type);
all.push(result);
if (monospace) {
monospace.push(result);
}
return result;
}
private static _actualReadConfiguration(bareFontInfo: BareFontInfo): FontInfo {
const all: CharWidthRequest[] = [];
const monospace: CharWidthRequest[] = [];
const typicalHalfwidthCharacter = this.createRequest('n', CharWidthRequestType.Regular, all, monospace);
const typicalFullwidthCharacter = this.createRequest('\uff4d', CharWidthRequestType.Regular, all, null);
const space = this.createRequest(' ', CharWidthRequestType.Regular, all, monospace);
const digit0 = this.createRequest('0', CharWidthRequestType.Regular, all, monospace);
const digit1 = this.createRequest('1', CharWidthRequestType.Regular, all, monospace);
const digit2 = this.createRequest('2', CharWidthRequestType.Regular, all, monospace);
const digit3 = this.createRequest('3', CharWidthRequestType.Regular, all, monospace);
const digit4 = this.createRequest('4', CharWidthRequestType.Regular, all, monospace);
const digit5 = this.createRequest('5', CharWidthRequestType.Regular, all, monospace);
const digit6 = this.createRequest('6', CharWidthRequestType.Regular, all, monospace);
const digit7 = this.createRequest('7', CharWidthRequestType.Regular, all, monospace);
const digit8 = this.createRequest('8', CharWidthRequestType.Regular, all, monospace);
const digit9 = this.createRequest('9', CharWidthRequestType.Regular, all, monospace);
// monospace test: used for whitespace rendering
const rightwardsArrow = this.createRequest('→', CharWidthRequestType.Regular, all, monospace);
const halfwidthRightwardsArrow = this.createRequest('￫', CharWidthRequestType.Regular, all, null);
// U+00B7 - MIDDLE DOT
const middot = this.createRequest('·', CharWidthRequestType.Regular, all, monospace);
// U+2E31 - WORD SEPARATOR MIDDLE DOT
const wsmiddotWidth = this.createRequest(String.fromCharCode(0x2E31), CharWidthRequestType.Regular, all, null);
// monospace test: some characters
const monospaceTestChars = '|/-_ilm%';
for (let i = 0, len = monospaceTestChars.length; i < len; i++) {
this.createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Regular, all, monospace);
this.createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Italic, all, monospace);
this.createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Bold, all, monospace);
}
readCharWidths(bareFontInfo, all);
const maxDigitWidth = Math.max(digit0.width, digit1.width, digit2.width, digit3.width, digit4.width, digit5.width, digit6.width, digit7.width, digit8.width, digit9.width);
let isMonospace = (bareFontInfo.fontFeatureSettings === EditorFontLigatures.OFF);
const referenceWidth = monospace[0].width;
for (let i = 1, len = monospace.length; isMonospace && i < len; i++) {
const diff = referenceWidth - monospace[i].width;
if (diff < -0.001 || diff > 0.001) {
isMonospace = false;
break;
}
}
let canUseHalfwidthRightwardsArrow = true;
if (isMonospace && halfwidthRightwardsArrow.width !== referenceWidth) {
// using a halfwidth rightwards arrow would break monospace...
canUseHalfwidthRightwardsArrow = false;
}
if (halfwidthRightwardsArrow.width > rightwardsArrow.width) {
// using a halfwidth rightwards arrow would paint a larger arrow than a regular rightwards arrow
canUseHalfwidthRightwardsArrow = false;
}
// let's trust the zoom level only 2s after it was changed.
const canTrustBrowserZoomLevel = (browser.getTimeSinceLastZoomLevelChanged() > 2000);
return new FontInfo({
zoomLevel: browser.getZoomLevel(),
pixelRatio: browser.getPixelRatio(),
fontFamily: bareFontInfo.fontFamily,
fontWeight: bareFontInfo.fontWeight,
fontSize: bareFontInfo.fontSize,
fontFeatureSettings: bareFontInfo.fontFeatureSettings,
lineHeight: bareFontInfo.lineHeight,
letterSpacing: bareFontInfo.letterSpacing,
isMonospace: isMonospace,
typicalHalfwidthCharacterWidth: typicalHalfwidthCharacter.width,
typicalFullwidthCharacterWidth: typicalFullwidthCharacter.width,
canUseHalfwidthRightwardsArrow: canUseHalfwidthRightwardsArrow,
spaceWidth: space.width,
middotWidth: middot.width,
wsmiddotWidth: wsmiddotWidth.width,
maxDigitWidth: maxDigitWidth
}, canTrustBrowserZoomLevel);
}
}
export class Configuration extends CommonEditorConfiguration {
public static applyFontInfoSlow(domNode: HTMLElement, fontInfo: BareFontInfo): void {
domNode.style.fontFamily = fontInfo.getMassagedFontFamily(browser.isSafari ? EDITOR_FONT_DEFAULTS.fontFamily : null);
domNode.style.fontWeight = fontInfo.fontWeight;
domNode.style.fontSize = fontInfo.fontSize + 'px';
domNode.style.fontFeatureSettings = fontInfo.fontFeatureSettings;
domNode.style.lineHeight = fontInfo.lineHeight + 'px';
domNode.style.letterSpacing = fontInfo.letterSpacing + 'px';
}
public static applyFontInfo(domNode: FastDomNode<HTMLElement>, fontInfo: BareFontInfo): void {
domNode.setFontFamily(fontInfo.getMassagedFontFamily(browser.isSafari ? EDITOR_FONT_DEFAULTS.fontFamily : null));
domNode.setFontWeight(fontInfo.fontWeight);
domNode.setFontSize(fontInfo.fontSize);
domNode.setFontFeatureSettings(fontInfo.fontFeatureSettings);
domNode.setLineHeight(fontInfo.lineHeight);
domNode.setLetterSpacing(fontInfo.letterSpacing);
}
private readonly _elementSizeObserver: ElementSizeObserver;
constructor(
isSimpleWidget: boolean,
options: Readonly<IEditorConstructionOptions>,
referenceDomElement: HTMLElement | null = null,
private readonly accessibilityService: IAccessibilityService
) {
super(isSimpleWidget, options);
this._elementSizeObserver = this._register(new ElementSizeObserver(referenceDomElement, options.dimension, () => this._recomputeOptions()));
this._register(CSSBasedConfiguration.INSTANCE.onDidChange(() => this._recomputeOptions()));
if (this._validatedOptions.get(EditorOption.automaticLayout)) {
this._elementSizeObserver.startObserving();
}
this._register(browser.onDidChangeZoomLevel(_ => this._recomputeOptions()));
this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this._recomputeOptions()));
this._recomputeOptions();
}
public override observeReferenceElement(dimension?: IDimension): void {
this._elementSizeObserver.observe(dimension);
}
public override updatePixelRatio(): void {
this._recomputeOptions();
}
private static _getExtraEditorClassName(): string {
let extra = '';
if (!browser.isSafari && !browser.isWebkitWebView) {
// Use user-select: none in all browsers except Safari and native macOS WebView
extra += 'no-user-select ';
}
if (browser.isSafari) {
// See https://github.com/microsoft/vscode/issues/108822
extra += 'no-minimap-shadow ';
}
if (platform.isMacintosh) {
extra += 'mac ';
}
return extra;
}
protected _getEnvConfiguration(): IEnvConfiguration {
return {
extraEditorClassName: Configuration._getExtraEditorClassName(),
outerWidth: this._elementSizeObserver.getWidth(),
outerHeight: this._elementSizeObserver.getHeight(),
emptySelectionClipboard: browser.isWebKit || browser.isFirefox,
pixelRatio: browser.getPixelRatio(),
zoomLevel: browser.getZoomLevel(),
accessibilitySupport: (
this.accessibilityService.isScreenReaderOptimized()
? AccessibilitySupport.Enabled
: this.accessibilityService.getAccessibilitySupport()
)
};
}
protected readConfiguration(bareFontInfo: BareFontInfo): FontInfo {
return CSSBasedConfiguration.INSTANCE.readConfiguration(bareFontInfo);
}
}

27
src/vs/editor/browser/config/domFontInfo.ts Normal file
View File

@@ -0,0 +1,27 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as browser from 'vs/base/browser/browser';
import { FastDomNode } from 'vs/base/browser/fastDomNode';
import { EDITOR_FONT_DEFAULTS } from 'vs/editor/common/config/editorOptions';
import { BareFontInfo } from 'vs/editor/common/config/fontInfo';
export function applyFontInfo(domNode: FastDomNode<HTMLElement> | HTMLElement, fontInfo: BareFontInfo): void {
if (domNode instanceof FastDomNode) {
domNode.setFontFamily(fontInfo.getMassagedFontFamily(browser.isSafari ? EDITOR_FONT_DEFAULTS.fontFamily : null));
domNode.setFontWeight(fontInfo.fontWeight);
domNode.setFontSize(fontInfo.fontSize);
domNode.setFontFeatureSettings(fontInfo.fontFeatureSettings);
domNode.setLineHeight(fontInfo.lineHeight);
domNode.setLetterSpacing(fontInfo.letterSpacing);
} else {
domNode.style.fontFamily = fontInfo.getMassagedFontFamily(browser.isSafari ? EDITOR_FONT_DEFAULTS.fontFamily : null);
domNode.style.fontWeight = fontInfo.fontWeight;
domNode.style.fontSize = fontInfo.fontSize + 'px';
domNode.style.fontFeatureSettings = fontInfo.fontFeatureSettings;
domNode.style.lineHeight = fontInfo.lineHeight + 'px';
domNode.style.letterSpacing = fontInfo.letterSpacing + 'px';
}
}

339
src/vs/editor/browser/config/editorConfiguration.ts Normal file
View File

@@ -0,0 +1,339 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as browser from 'vs/base/browser/browser';
import * as arrays from 'vs/base/common/arrays';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import * as objects from 'vs/base/common/objects';
import * as platform from 'vs/base/common/platform';
import { ElementSizeObserver } from 'vs/editor/browser/config/elementSizeObserver';
import { FontMeasurements } from 'vs/editor/browser/config/fontMeasurements';
import { migrateOptions } from 'vs/editor/browser/config/migrateOptions';
import { TabFocus } from 'vs/editor/browser/config/tabFocus';
import { ComputeOptionsMemory, ConfigurationChangedEvent, EditorOption, editorOptionsRegistry, FindComputedEditorOptionValueById, IComputedEditorOptions, IEditorOptions, IEnvironmentalOptions } from 'vs/editor/common/config/editorOptions';
import { EditorZoom } from 'vs/editor/common/config/editorZoom';
import { BareFontInfo, FontInfo, IValidatedEditorOptions } from 'vs/editor/common/config/fontInfo';
import { IDimension } from 'vs/editor/common/core/dimension';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { AccessibilitySupport, IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
export interface IEditorConstructionOptions extends IEditorOptions {
/**
* The initial editor dimension (to avoid measuring the container).
*/
dimension?: IDimension;
/**
* Place overflow widgets inside an external DOM node.
* Defaults to an internal DOM node.
*/
overflowWidgetsDomNode?: HTMLElement;
/**
* Enables dropping into the editor.
*
* This shows a preview of the drop location and triggers an `onDropIntoEditor` event.
*/
enableDropIntoEditor?: boolean;
}
export class EditorConfiguration extends Disposable implements IEditorConfiguration {
private _onDidChange = this._register(new Emitter<ConfigurationChangedEvent>());
public readonly onDidChange: Event<ConfigurationChangedEvent> = this._onDidChange.event;
private _onDidChangeFast = this._register(new Emitter<ConfigurationChangedEvent>());
public readonly onDidChangeFast: Event<ConfigurationChangedEvent> = this._onDidChangeFast.event;
public readonly isSimpleWidget: boolean;
private readonly _containerObserver: ElementSizeObserver;
private _isDominatedByLongLines: boolean = false;
private _viewLineCount: number = 1;
private _lineNumbersDigitCount: number = 1;
private _reservedHeight: number = 0;
private readonly _computeOptionsMemory: ComputeOptionsMemory = new ComputeOptionsMemory();
/**
* Raw options as they were passed in and merged with all calls to `updateOptions`.
*/
private readonly _rawOptions: IEditorOptions;
/**
* Validated version of `_rawOptions`.
*/
private _validatedOptions: ValidatedEditorOptions;
/**
* Complete options which are a combination of passed in options and env values.
*/
public options: ComputedEditorOptions;
constructor(
isSimpleWidget: boolean,
options: Readonly<IEditorConstructionOptions>,
container: HTMLElement | null,
@IAccessibilityService private readonly _accessibilityService: IAccessibilityService
) {
super();
this.isSimpleWidget = isSimpleWidget;
this._containerObserver = this._register(new ElementSizeObserver(container, options.dimension));
this._rawOptions = deepCloneAndMigrateOptions(options);
this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
this.options = this._computeOptions();
if (this.options.get(EditorOption.automaticLayout)) {
this._containerObserver.startObserving();
}
this._register(EditorZoom.onDidChangeZoomLevel(() => this._recomputeOptions()));
this._register(TabFocus.onDidChangeTabFocus(() => this._recomputeOptions()));
this._register(this._containerObserver.onDidChange(() => this._recomputeOptions()));
this._register(FontMeasurements.onDidChange(() => this._recomputeOptions()));
this._register(browser.PixelRatio.onDidChange(() => this._recomputeOptions()));
this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => this._recomputeOptions()));
}
private _recomputeOptions(): void {
const newOptions = this._computeOptions();
const changeEvent = EditorOptionsUtil.checkEquals(this.options, newOptions);
if (changeEvent === null) {
// nothing changed!
return;
}
this.options = newOptions;
this._onDidChangeFast.fire(changeEvent);
this._onDidChange.fire(changeEvent);
}
private _computeOptions(): ComputedEditorOptions {
const partialEnv = this._readEnvConfiguration();
const bareFontInfo = BareFontInfo.createFromValidatedSettings(this._validatedOptions, partialEnv.pixelRatio, this.isSimpleWidget);
const fontInfo = this._readFontInfo(bareFontInfo);
const env: IEnvironmentalOptions = {
memory: this._computeOptionsMemory,
outerWidth: partialEnv.outerWidth,
outerHeight: partialEnv.outerHeight - this._reservedHeight,
fontInfo: fontInfo,
extraEditorClassName: partialEnv.extraEditorClassName,
isDominatedByLongLines: this._isDominatedByLongLines,
viewLineCount: this._viewLineCount,
lineNumbersDigitCount: this._lineNumbersDigitCount,
emptySelectionClipboard: partialEnv.emptySelectionClipboard,
pixelRatio: partialEnv.pixelRatio,
tabFocusMode: TabFocus.getTabFocusMode(),
accessibilitySupport: partialEnv.accessibilitySupport
};
return EditorOptionsUtil.computeOptions(this._validatedOptions, env);
}
protected _readEnvConfiguration(): IEnvConfiguration {
return {
extraEditorClassName: getExtraEditorClassName(),
outerWidth: this._containerObserver.getWidth(),
outerHeight: this._containerObserver.getHeight(),
emptySelectionClipboard: browser.isWebKit || browser.isFirefox,
pixelRatio: browser.PixelRatio.value,
accessibilitySupport: (
this._accessibilityService.isScreenReaderOptimized()
? AccessibilitySupport.Enabled
: this._accessibilityService.getAccessibilitySupport()
)
};
}
protected _readFontInfo(bareFontInfo: BareFontInfo): FontInfo {
return FontMeasurements.readFontInfo(bareFontInfo);
}
public getRawOptions(): IEditorOptions {
return this._rawOptions;
}
public updateOptions(_newOptions: Readonly<IEditorOptions>): void {
const newOptions = deepCloneAndMigrateOptions(_newOptions);
const didChange = EditorOptionsUtil.applyUpdate(this._rawOptions, newOptions);
if (!didChange) {
return;
}
this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
this._recomputeOptions();
}
public observeContainer(dimension?: IDimension): void {
this._containerObserver.observe(dimension);
}
public setIsDominatedByLongLines(isDominatedByLongLines: boolean): void {
if (this._isDominatedByLongLines === isDominatedByLongLines) {
return;
}
this._isDominatedByLongLines = isDominatedByLongLines;
this._recomputeOptions();
}
public setModelLineCount(modelLineCount: number): void {
const lineNumbersDigitCount = digitCount(modelLineCount);
if (this._lineNumbersDigitCount === lineNumbersDigitCount) {
return;
}
this._lineNumbersDigitCount = lineNumbersDigitCount;
this._recomputeOptions();
}
public setViewLineCount(viewLineCount: number): void {
if (this._viewLineCount === viewLineCount) {
return;
}
this._viewLineCount = viewLineCount;
this._recomputeOptions();
}
public setReservedHeight(reservedHeight: number) {
if (this._reservedHeight === reservedHeight) {
return;
}
this._reservedHeight = reservedHeight;
this._recomputeOptions();
}
}
function digitCount(n: number): number {
let r = 0;
while (n) {
n = Math.floor(n / 10);
r++;
}
return r ? r : 1;
}
function getExtraEditorClassName(): string {
let extra = '';
if (!browser.isSafari && !browser.isWebkitWebView) {
// Use user-select: none in all browsers except Safari and native macOS WebView
extra += 'no-user-select ';
}
if (browser.isSafari) {
// See https://github.com/microsoft/vscode/issues/108822
extra += 'no-minimap-shadow ';
extra += 'enable-user-select ';
}
if (platform.isMacintosh) {
extra += 'mac ';
}
return extra;
}
export interface IEnvConfiguration {
extraEditorClassName: string;
outerWidth: number;
outerHeight: number;
emptySelectionClipboard: boolean;
pixelRatio: number;
accessibilitySupport: AccessibilitySupport;
}
class ValidatedEditorOptions implements IValidatedEditorOptions {
private readonly _values: any[] = [];
public _read<T>(option: EditorOption): T {
return this._values[option];
}
public get<T extends EditorOption>(id: T): FindComputedEditorOptionValueById<T> {
return this._values[id];
}
public _write<T>(option: EditorOption, value: T): void {
this._values[option] = value;
}
}
export class ComputedEditorOptions implements IComputedEditorOptions {
private readonly _values: any[] = [];
public _read<T>(id: EditorOption): T {
if (id >= this._values.length) {
throw new Error('Cannot read uninitialized value');
}
return this._values[id];
}
public get<T extends EditorOption>(id: T): FindComputedEditorOptionValueById<T> {
return this._read(id);
}
public _write<T>(id: EditorOption, value: T): void {
this._values[id] = value;
}
}
class EditorOptionsUtil {
public static validateOptions(options: IEditorOptions): ValidatedEditorOptions {
const result = new ValidatedEditorOptions();
for (const editorOption of editorOptionsRegistry) {
const value = (editorOption.name === '_never_' ? undefined : (options as any)[editorOption.name]);
result._write(editorOption.id, editorOption.validate(value));
}
return result;
}
public static computeOptions(options: ValidatedEditorOptions, env: IEnvironmentalOptions): ComputedEditorOptions {
const result = new ComputedEditorOptions();
for (const editorOption of editorOptionsRegistry) {
result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
}
return result;
}
private static _deepEquals<T>(a: T, b: T): boolean {
if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
return a === b;
}
if (Array.isArray(a) || Array.isArray(b)) {
return (Array.isArray(a) && Array.isArray(b) ? arrays.equals(a, b) : false);
}
if (Object.keys(a as unknown as object).length !== Object.keys(b as unknown as object).length) {
return false;
}
for (const key in a) {
if (!EditorOptionsUtil._deepEquals(a[key], b[key])) {
return false;
}
}
return true;
}
public static checkEquals(a: ComputedEditorOptions, b: ComputedEditorOptions): ConfigurationChangedEvent | null {
const result: boolean[] = [];
let somethingChanged = false;
for (const editorOption of editorOptionsRegistry) {
const changed = !EditorOptionsUtil._deepEquals(a._read(editorOption.id), b._read(editorOption.id));
result[editorOption.id] = changed;
if (changed) {
somethingChanged = true;
}
}
return (somethingChanged ? new ConfigurationChangedEvent(result) : null);
}
/**
* Returns true if something changed.
* Modifies `options`.
*/
public static applyUpdate(options: IEditorOptions, update: Readonly<IEditorOptions>): boolean {
let changed = false;
for (const editorOption of editorOptionsRegistry) {
if (update.hasOwnProperty(editorOption.name)) {
const result = editorOption.applyUpdate((options as any)[editorOption.name], (update as any)[editorOption.name]);
(options as any)[editorOption.name] = result.newValue;
changed = changed || result.didChange;
}
}
return changed;
}
}
function deepCloneAndMigrateOptions(_options: Readonly<IEditorOptions>): IEditorOptions {
const options = objects.deepClone(_options);
migrateOptions(options);
return options;
}

112
src/vs/editor/browser/config/elementSizeObserver.ts
View File

@@ -4,51 +4,25 @@
*--------------------------------------------------------------------------------------------*/
import { Disposable } from 'vs/base/common/lifecycle';
import { IDimension } from 'vs/editor/common/editorCommon';
interface ResizeObserver {
observe(target: Element): void;
unobserve(target: Element): void;
disconnect(): void;
}
interface ResizeObserverSize {
inlineSize: number;
blockSize: number;
}
interface ResizeObserverEntry {
readonly target: Element;
readonly contentRect: DOMRectReadOnly;
readonly borderBoxSize: ResizeObserverSize;
readonly contentBoxSize: ResizeObserverSize;
}
type ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;
declare const ResizeObserver: {
prototype: ResizeObserver;
new(callback: ResizeObserverCallback): ResizeObserver;
};
import { IDimension } from 'vs/editor/common/core/dimension';
import { Emitter, Event } from 'vs/base/common/event';
export class ElementSizeObserver extends Disposable {
private readonly referenceDomElement: HTMLElement | null;
private readonly changeCallback: () => void;
private width: number;
private height: number;
private resizeObserver: ResizeObserver | null;
private measureReferenceDomElementToken: number;
private _onDidChange = this._register(new Emitter<void>());
public readonly onDidChange: Event<void> = this._onDidChange.event;
constructor(referenceDomElement: HTMLElement | null, dimension: IDimension | undefined, changeCallback: () => void) {
private readonly _referenceDomElement: HTMLElement | null;
private _width: number;
private _height: number;
private _resizeObserver: ResizeObserver | null;
constructor(referenceDomElement: HTMLElement | null, dimension: IDimension | undefined) {
super();
this.referenceDomElement = referenceDomElement;
this.changeCallback = changeCallback;
this.width = -1;
this.height = -1;
this.resizeObserver = null;
this.measureReferenceDomElementToken = -1;
this._referenceDomElement = referenceDomElement;
this._width = -1;
this._height = -1;
this._resizeObserver = null;
this.measureReferenceDomElement(false, dimension);
}
@@ -58,41 +32,30 @@ export class ElementSizeObserver extends Disposable {
}
public getWidth(): number {
return this.width;
return this._width;
}
public getHeight(): number {
return this.height;
return this._height;
}
public startObserving(): void {
if (typeof ResizeObserver !== 'undefined') {
if (!this.resizeObserver && this.referenceDomElement) {
this.resizeObserver = new ResizeObserver((entries) => {
if (entries && entries[0] && entries[0].contentRect) {
this.observe({ width: entries[0].contentRect.width, height: entries[0].contentRect.height });
} else {
this.observe();
}
});
this.resizeObserver.observe(this.referenceDomElement);
}
} else {
if (this.measureReferenceDomElementToken === -1) {
// setInterval type defaults to NodeJS.Timeout instead of number, so specify it as a number
this.measureReferenceDomElementToken = <number><any>setInterval(() => this.observe(), 100);
}
if (!this._resizeObserver && this._referenceDomElement) {
this._resizeObserver = new ResizeObserver((entries) => {
if (entries && entries[0] && entries[0].contentRect) {
this.observe({ width: entries[0].contentRect.width, height: entries[0].contentRect.height });
} else {
this.observe();
}
});
this._resizeObserver.observe(this._referenceDomElement);
}
}
public stopObserving(): void {
if (this.resizeObserver) {
this.resizeObserver.disconnect();
this.resizeObserver = null;
}
if (this.measureReferenceDomElementToken !== -1) {
clearInterval(this.measureReferenceDomElementToken);
this.measureReferenceDomElementToken = -1;
if (this._resizeObserver) {
this._resizeObserver.disconnect();
this._resizeObserver = null;
}
}
@@ -100,25 +63,24 @@ export class ElementSizeObserver extends Disposable {
this.measureReferenceDomElement(true, dimension);
}
private measureReferenceDomElement(callChangeCallback: boolean, dimension?: IDimension): void {
private measureReferenceDomElement(emitEvent: boolean, dimension?: IDimension): void {
let observedWidth = 0;
let observedHeight = 0;
if (dimension) {
observedWidth = dimension.width;
observedHeight = dimension.height;
} else if (this.referenceDomElement) {
observedWidth = this.referenceDomElement.clientWidth;
observedHeight = this.referenceDomElement.clientHeight;
} else if (this._referenceDomElement) {
observedWidth = this._referenceDomElement.clientWidth;
observedHeight = this._referenceDomElement.clientHeight;
}
observedWidth = Math.max(5, observedWidth);
observedHeight = Math.max(5, observedHeight);
if (this.width !== observedWidth || this.height !== observedHeight) {
this.width = observedWidth;
this.height = observedHeight;
if (callChangeCallback) {
this.changeCallback();
if (this._width !== observedWidth || this._height !== observedHeight) {
this._width = observedWidth;
this._height = observedHeight;
if (emitEvent) {
this._onDidChange.fire();
}
}
}
}

275
src/vs/editor/browser/config/fontMeasurements.ts Normal file
View File

@@ -0,0 +1,275 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as browser from 'vs/base/browser/browser';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import { CharWidthRequest, CharWidthRequestType, readCharWidths } from 'vs/editor/browser/config/charWidthReader';
import { EditorFontLigatures } from 'vs/editor/common/config/editorOptions';
import { BareFontInfo, FontInfo, SERIALIZED_FONT_INFO_VERSION } from 'vs/editor/common/config/fontInfo';
/**
* Serializable font information.
*/
export interface ISerializedFontInfo {
readonly version: number;
readonly pixelRatio: number;
readonly fontFamily: string;
readonly fontWeight: string;
readonly fontSize: number;
readonly fontFeatureSettings: string;
readonly lineHeight: number;
readonly letterSpacing: number;
readonly isMonospace: boolean;
readonly typicalHalfwidthCharacterWidth: number;
readonly typicalFullwidthCharacterWidth: number;
readonly canUseHalfwidthRightwardsArrow: boolean;
readonly spaceWidth: number;
readonly middotWidth: number;
readonly wsmiddotWidth: number;
readonly maxDigitWidth: number;
}
class FontMeasurementsImpl extends Disposable {
private _cache: FontMeasurementsCache;
private _evictUntrustedReadingsTimeout: number;
private readonly _onDidChange = this._register(new Emitter<void>());
public readonly onDidChange: Event<void> = this._onDidChange.event;
constructor() {
super();
this._cache = new FontMeasurementsCache();
this._evictUntrustedReadingsTimeout = -1;
}
public override dispose(): void {
if (this._evictUntrustedReadingsTimeout !== -1) {
window.clearTimeout(this._evictUntrustedReadingsTimeout);
this._evictUntrustedReadingsTimeout = -1;
}
super.dispose();
}
/**
* Clear all cached font information and trigger a change event.
*/
public clearAllFontInfos(): void {
this._cache = new FontMeasurementsCache();
this._onDidChange.fire();
}
private _writeToCache(item: BareFontInfo, value: FontInfo): void {
this._cache.put(item, value);
if (!value.isTrusted && this._evictUntrustedReadingsTimeout === -1) {
// Try reading again after some time
this._evictUntrustedReadingsTimeout = window.setTimeout(() => {
this._evictUntrustedReadingsTimeout = -1;
this._evictUntrustedReadings();
}, 5000);
}
}
private _evictUntrustedReadings(): void {
const values = this._cache.getValues();
let somethingRemoved = false;
for (const item of values) {
if (!item.isTrusted) {
somethingRemoved = true;
this._cache.remove(item);
}
}
if (somethingRemoved) {
this._onDidChange.fire();
}
}
/**
* Serialized currently cached font information.
*/
public serializeFontInfo(): ISerializedFontInfo[] {
// Only save trusted font info (that has been measured in this running instance)
return this._cache.getValues().filter(item => item.isTrusted);
}
/**
* Restore previously serialized font informations.
*/
public restoreFontInfo(savedFontInfos: ISerializedFontInfo[]): void {
// Take all the saved font info and insert them in the cache without the trusted flag.
// The reason for this is that a font might have been installed on the OS in the meantime.
for (const savedFontInfo of savedFontInfos) {
if (savedFontInfo.version !== SERIALIZED_FONT_INFO_VERSION) {
// cannot use older version
continue;
}
const fontInfo = new FontInfo(savedFontInfo, false);
this._writeToCache(fontInfo, fontInfo);
}
}
/**
* Read font information.
*/
public readFontInfo(bareFontInfo: BareFontInfo): FontInfo {
if (!this._cache.has(bareFontInfo)) {
let readConfig = this._actualReadFontInfo(bareFontInfo);
if (readConfig.typicalHalfwidthCharacterWidth <= 2 || readConfig.typicalFullwidthCharacterWidth <= 2 || readConfig.spaceWidth <= 2 || readConfig.maxDigitWidth <= 2) {
// Hey, it's Bug 14341 ... we couldn't read
readConfig = new FontInfo({
pixelRatio: browser.PixelRatio.value,
fontFamily: readConfig.fontFamily,
fontWeight: readConfig.fontWeight,
fontSize: readConfig.fontSize,
fontFeatureSettings: readConfig.fontFeatureSettings,
lineHeight: readConfig.lineHeight,
letterSpacing: readConfig.letterSpacing,
isMonospace: readConfig.isMonospace,
typicalHalfwidthCharacterWidth: Math.max(readConfig.typicalHalfwidthCharacterWidth, 5),
typicalFullwidthCharacterWidth: Math.max(readConfig.typicalFullwidthCharacterWidth, 5),
canUseHalfwidthRightwardsArrow: readConfig.canUseHalfwidthRightwardsArrow,
spaceWidth: Math.max(readConfig.spaceWidth, 5),
middotWidth: Math.max(readConfig.middotWidth, 5),
wsmiddotWidth: Math.max(readConfig.wsmiddotWidth, 5),
maxDigitWidth: Math.max(readConfig.maxDigitWidth, 5),
}, false);
}
this._writeToCache(bareFontInfo, readConfig);
}
return this._cache.get(bareFontInfo);
}
private _createRequest(chr: string, type: CharWidthRequestType, all: CharWidthRequest[], monospace: CharWidthRequest[] | null): CharWidthRequest {
const result = new CharWidthRequest(chr, type);
all.push(result);
if (monospace) {
monospace.push(result);
}
return result;
}
private _actualReadFontInfo(bareFontInfo: BareFontInfo): FontInfo {
const all: CharWidthRequest[] = [];
const monospace: CharWidthRequest[] = [];
const typicalHalfwidthCharacter = this._createRequest('n', CharWidthRequestType.Regular, all, monospace);
const typicalFullwidthCharacter = this._createRequest('\uff4d', CharWidthRequestType.Regular, all, null);
const space = this._createRequest(' ', CharWidthRequestType.Regular, all, monospace);
const digit0 = this._createRequest('0', CharWidthRequestType.Regular, all, monospace);
const digit1 = this._createRequest('1', CharWidthRequestType.Regular, all, monospace);
const digit2 = this._createRequest('2', CharWidthRequestType.Regular, all, monospace);
const digit3 = this._createRequest('3', CharWidthRequestType.Regular, all, monospace);
const digit4 = this._createRequest('4', CharWidthRequestType.Regular, all, monospace);
const digit5 = this._createRequest('5', CharWidthRequestType.Regular, all, monospace);
const digit6 = this._createRequest('6', CharWidthRequestType.Regular, all, monospace);
const digit7 = this._createRequest('7', CharWidthRequestType.Regular, all, monospace);
const digit8 = this._createRequest('8', CharWidthRequestType.Regular, all, monospace);
const digit9 = this._createRequest('9', CharWidthRequestType.Regular, all, monospace);
// monospace test: used for whitespace rendering
const rightwardsArrow = this._createRequest('→', CharWidthRequestType.Regular, all, monospace);
const halfwidthRightwardsArrow = this._createRequest('￫', CharWidthRequestType.Regular, all, null);
// U+00B7 - MIDDLE DOT
const middot = this._createRequest('·', CharWidthRequestType.Regular, all, monospace);
// U+2E31 - WORD SEPARATOR MIDDLE DOT
const wsmiddotWidth = this._createRequest(String.fromCharCode(0x2E31), CharWidthRequestType.Regular, all, null);
// monospace test: some characters
const monospaceTestChars = '|/-_ilm%';
for (let i = 0, len = monospaceTestChars.length; i < len; i++) {
this._createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Regular, all, monospace);
this._createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Italic, all, monospace);
this._createRequest(monospaceTestChars.charAt(i), CharWidthRequestType.Bold, all, monospace);
}
readCharWidths(bareFontInfo, all);
const maxDigitWidth = Math.max(digit0.width, digit1.width, digit2.width, digit3.width, digit4.width, digit5.width, digit6.width, digit7.width, digit8.width, digit9.width);
let isMonospace = (bareFontInfo.fontFeatureSettings === EditorFontLigatures.OFF);
const referenceWidth = monospace[0].width;
for (let i = 1, len = monospace.length; isMonospace && i < len; i++) {
const diff = referenceWidth - monospace[i].width;
if (diff < -0.001 || diff > 0.001) {
isMonospace = false;
break;
}
}
let canUseHalfwidthRightwardsArrow = true;
if (isMonospace && halfwidthRightwardsArrow.width !== referenceWidth) {
// using a halfwidth rightwards arrow would break monospace...
canUseHalfwidthRightwardsArrow = false;
}
if (halfwidthRightwardsArrow.width > rightwardsArrow.width) {
// using a halfwidth rightwards arrow would paint a larger arrow than a regular rightwards arrow
canUseHalfwidthRightwardsArrow = false;
}
return new FontInfo({
pixelRatio: browser.PixelRatio.value,
fontFamily: bareFontInfo.fontFamily,
fontWeight: bareFontInfo.fontWeight,
fontSize: bareFontInfo.fontSize,
fontFeatureSettings: bareFontInfo.fontFeatureSettings,
lineHeight: bareFontInfo.lineHeight,
letterSpacing: bareFontInfo.letterSpacing,
isMonospace: isMonospace,
typicalHalfwidthCharacterWidth: typicalHalfwidthCharacter.width,
typicalFullwidthCharacterWidth: typicalFullwidthCharacter.width,
canUseHalfwidthRightwardsArrow: canUseHalfwidthRightwardsArrow,
spaceWidth: space.width,
middotWidth: middot.width,
wsmiddotWidth: wsmiddotWidth.width,
maxDigitWidth: maxDigitWidth
}, true);
}
}
class FontMeasurementsCache {
private readonly _keys: { [key: string]: BareFontInfo };
private readonly _values: { [key: string]: FontInfo };
constructor() {
this._keys = Object.create(null);
this._values = Object.create(null);
}
public has(item: BareFontInfo): boolean {
const itemId = item.getId();
return !!this._values[itemId];
}
public get(item: BareFontInfo): FontInfo {
const itemId = item.getId();
return this._values[itemId];
}
public put(item: BareFontInfo, value: FontInfo): void {
const itemId = item.getId();
this._keys[itemId] = item;
this._values[itemId] = value;
}
public remove(item: BareFontInfo): void {
const itemId = item.getId();
delete this._keys[itemId];
delete this._values[itemId];
}
public getValues(): FontInfo[] {
return Object.keys(this._keys).map(id => this._values[id]);
}
}
export const FontMeasurements = new FontMeasurementsImpl();

165
src/vs/editor/browser/config/migrateOptions.ts Normal file
View File

@@ -0,0 +1,165 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { forEach } from 'vs/base/common/collections';
import { IEditorOptions } from 'vs/editor/common/config/editorOptions';
export interface ISettingsReader {
(key: string): any;
}
export interface ISettingsWriter {
(key: string, value: any): void;
}
export class EditorSettingMigration {
public static items: EditorSettingMigration[] = [];
constructor(
public readonly key: string,
public readonly migrate: (value: any, read: ISettingsReader, write: ISettingsWriter) => void
) { }
apply(options: any): void {
const value = EditorSettingMigration._read(options, this.key);
const read = (key: string) => EditorSettingMigration._read(options, key);
const write = (key: string, value: any) => EditorSettingMigration._write(options, key, value);
this.migrate(value, read, write);
}
private static _read(source: any, key: string): any {
if (typeof source === 'undefined') {
return undefined;
}
const firstDotIndex = key.indexOf('.');
if (firstDotIndex >= 0) {
const firstSegment = key.substring(0, firstDotIndex);
return this._read(source[firstSegment], key.substring(firstDotIndex + 1));
}
return source[key];
}
private static _write(target: any, key: string, value: any): void {
const firstDotIndex = key.indexOf('.');
if (firstDotIndex >= 0) {
const firstSegment = key.substring(0, firstDotIndex);
target[firstSegment] = target[firstSegment] || {};
this._write(target[firstSegment], key.substring(firstDotIndex + 1), value);
return;
}
target[key] = value;
}
}
function registerEditorSettingMigration(key: string, migrate: (value: any, read: ISettingsReader, write: ISettingsWriter) => void): void {
EditorSettingMigration.items.push(new EditorSettingMigration(key, migrate));
}
function registerSimpleEditorSettingMigration(key: string, values: [any, any][]): void {
registerEditorSettingMigration(key, (value, read, write) => {
if (typeof value !== 'undefined') {
for (const [oldValue, newValue] of values) {
if (value === oldValue) {
write(key, newValue);
return;
}
}
}
});
}
/**
* Compatibility with old options
*/
export function migrateOptions(options: IEditorOptions): void {
EditorSettingMigration.items.forEach(migration => migration.apply(options));
}
registerSimpleEditorSettingMigration('wordWrap', [[true, 'on'], [false, 'off']]);
registerSimpleEditorSettingMigration('lineNumbers', [[true, 'on'], [false, 'off']]);
registerSimpleEditorSettingMigration('cursorBlinking', [['visible', 'solid']]);
registerSimpleEditorSettingMigration('renderWhitespace', [[true, 'boundary'], [false, 'none']]);
registerSimpleEditorSettingMigration('renderLineHighlight', [[true, 'line'], [false, 'none']]);
registerSimpleEditorSettingMigration('acceptSuggestionOnEnter', [[true, 'on'], [false, 'off']]);
registerSimpleEditorSettingMigration('tabCompletion', [[false, 'off'], [true, 'onlySnippets']]);
registerSimpleEditorSettingMigration('hover', [[true, { enabled: true }], [false, { enabled: false }]]);
registerSimpleEditorSettingMigration('parameterHints', [[true, { enabled: true }], [false, { enabled: false }]]);
registerSimpleEditorSettingMigration('autoIndent', [[false, 'advanced'], [true, 'full']]);
registerSimpleEditorSettingMigration('matchBrackets', [[true, 'always'], [false, 'never']]);
registerEditorSettingMigration('autoClosingBrackets', (value, read, write) => {
if (value === false) {
write('autoClosingBrackets', 'never');
if (typeof read('autoClosingQuotes') === 'undefined') {
write('autoClosingQuotes', 'never');
}
if (typeof read('autoSurround') === 'undefined') {
write('autoSurround', 'never');
}
}
});
registerEditorSettingMigration('renderIndentGuides', (value, read, write) => {
if (typeof value !== 'undefined') {
write('renderIndentGuides', undefined);
if (typeof read('guides.indentation') === 'undefined') {
write('guides.indentation', !!value);
}
}
});
registerEditorSettingMigration('highlightActiveIndentGuide', (value, read, write) => {
if (typeof value !== 'undefined') {
write('highlightActiveIndentGuide', undefined);
if (typeof read('guides.highlightActiveIndentation') === 'undefined') {
write('guides.highlightActiveIndentation', !!value);
}
}
});
const suggestFilteredTypesMapping: Record<string, string> = {
method: 'showMethods',
function: 'showFunctions',
constructor: 'showConstructors',
deprecated: 'showDeprecated',
field: 'showFields',
variable: 'showVariables',
class: 'showClasses',
struct: 'showStructs',
interface: 'showInterfaces',
module: 'showModules',
property: 'showProperties',
event: 'showEvents',
operator: 'showOperators',
unit: 'showUnits',
value: 'showValues',
constant: 'showConstants',
enum: 'showEnums',
enumMember: 'showEnumMembers',
keyword: 'showKeywords',
text: 'showWords',
color: 'showColors',
file: 'showFiles',
reference: 'showReferences',
folder: 'showFolders',
typeParameter: 'showTypeParameters',
snippet: 'showSnippets',
};
registerEditorSettingMigration('suggest.filteredTypes', (value, read, write) => {
if (value && typeof value === 'object') {
forEach(suggestFilteredTypesMapping, entry => {
const v = value[entry.key];
if (v === false) {
if (typeof read(`suggest.${entry.value}`) === 'undefined') {
write(`suggest.${entry.value}`, false);
}
}
});
write('suggest.filteredTypes', undefined);
}
});

34
src/vs/editor/browser/config/tabFocus.ts Normal file
View File

@@ -0,0 +1,34 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Emitter, Event } from 'vs/base/common/event';
class TabFocusImpl {
private _tabFocus: boolean = false;
private readonly _onDidChangeTabFocus = new Emitter<boolean>();
public readonly onDidChangeTabFocus: Event<boolean> = this._onDidChangeTabFocus.event;
public getTabFocusMode(): boolean {
return this._tabFocus;
}
public setTabFocusMode(tabFocusMode: boolean): void {
if (this._tabFocus === tabFocusMode) {
return;
}
this._tabFocus = tabFocusMode;
this._onDidChangeTabFocus.fire(this._tabFocus);
}
}
/**
* Control what pressing Tab does.
* If it is false, pressing Tab or Shift-Tab will be handled by the editor.
* If it is true, pressing Tab or Shift-Tab will move the browser focus.
* Defaults to false.
*/
export const TabFocus = new TabFocusImpl();

104
src/vs/editor/browser/controller/mouseHandler.ts
View File

@@ -8,17 +8,17 @@ import { StandardWheelEvent, IMouseWheelEvent } from 'vs/base/browser/mouseEvent
import { TimeoutTimer } from 'vs/base/common/async';
import { Disposable } from 'vs/base/common/lifecycle';
import * as platform from 'vs/base/common/platform';
import { HitTestContext, IViewZoneData, MouseTarget, MouseTargetFactory, PointerHandlerLastRenderData } from 'vs/editor/browser/controller/mouseTarget';
import { IMouseTarget, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorMouseEventFactory, GlobalEditorMouseMoveMonitor, createEditorPagePosition } from 'vs/editor/browser/editorDom';
import { HitTestContext, MouseTarget, MouseTargetFactory, PointerHandlerLastRenderData } from 'vs/editor/browser/controller/mouseTarget';
import { IMouseTarget, IMouseTargetViewZoneData, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorMouseEventFactory, GlobalEditorPointerMoveMonitor, createEditorPagePosition, createCoordinatesRelativeToEditor } from 'vs/editor/browser/editorDom';
import { ViewController } from 'vs/editor/browser/view/viewController';
import { EditorZoom } from 'vs/editor/common/config/editorZoom';
import { Position } from 'vs/editor/common/core/position';
import { Selection } from 'vs/editor/common/core/selection';
import { HorizontalPosition } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
import { HorizontalPosition } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
/**
@@ -40,6 +40,7 @@ export function createMouseMoveEventMerger(mouseTargetFactory: MouseTargetFactor
export interface IPointerHandlerHelper {
viewDomNode: HTMLElement;
linesContentDomNode: HTMLElement;
viewLinesDomNode: HTMLElement;
focusTextArea(): void;
dispatchTextAreaEvent(event: CustomEvent): void;
@@ -104,7 +105,25 @@ export class MouseHandler extends ViewEventHandler {
this._register(mouseEvents.onMouseLeave(this.viewHelper.viewDomNode, (e) => this._onMouseLeave(e)));
this._register(mouseEvents.onMouseDown(this.viewHelper.viewDomNode, (e) => this._onMouseDown(e)));
// `pointerdown` events can't be used to determine if there's a double click, or triple click
// because their `e.detail` is always 0.
// We will therefore save the pointer id for the mouse and then reuse it in the `mousedown` event
// for `element.setPointerCapture`.
let mousePointerId: number = 0;
this._register(mouseEvents.onPointerDown(this.viewHelper.viewDomNode, (e, pointerType, pointerId) => {
if (pointerType === 'mouse') {
mousePointerId = pointerId;
}
}));
// The `pointerup` listener registered by `GlobalEditorPointerMoveMonitor` does not get invoked 100% of the times.
// I speculate that this is because the `pointerup` listener is only registered during the `mousedown` event, and perhaps
// the `pointerup` event is already queued for dispatching, which makes it that the new listener doesn't get fired.
// See https://github.com/microsoft/vscode/issues/146486 for repro steps.
// To compensate for that, we simply register here a `pointerup` listener and just communicate it.
this._register(dom.addDisposableListener(this.viewHelper.viewDomNode, dom.EventType.POINTER_UP, (e: PointerEvent) => {
this._mouseDownOperation.onPointerUp();
}));
this._register(mouseEvents.onMouseDown(this.viewHelper.viewDomNode, (e) => this._onMouseDown(e, mousePointerId)));
const onMouseWheel = (browserEvent: IMouseWheelEvent) => {
this.viewController.emitMouseWheel(browserEvent);
@@ -172,7 +191,8 @@ export class MouseHandler extends ViewEventHandler {
return null;
}
return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), editorPos, pos, null);
const relativePos = createCoordinatesRelativeToEditor(this.viewHelper.viewDomNode, editorPos, pos);
return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
}
protected _createMouseTarget(e: EditorMouseEvent, testEventTarget: boolean): IMouseTarget {
@@ -185,11 +205,11 @@ export class MouseHandler extends ViewEventHandler {
);
}
}
return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, testEventTarget ? target : null);
return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, e.relativePos, testEventTarget ? target : null);
}
private _getMouseColumn(e: EditorMouseEvent): number {
return this.mouseTargetFactory.getMouseColumn(e.editorPos, e.pos);
return this.mouseTargetFactory.getMouseColumn(e.relativePos);
}
protected _onContextMenu(e: EditorMouseEvent, testEventTarget: boolean): void {
@@ -231,7 +251,7 @@ export class MouseHandler extends ViewEventHandler {
});
}
public _onMouseDown(e: EditorMouseEvent): void {
public _onMouseDown(e: EditorMouseEvent, pointerId: number): void {
const t = this._createMouseTarget(e, true);
const targetIsContent = (t.type === MouseTargetType.CONTENT_TEXT || t.type === MouseTargetType.CONTENT_EMPTY);
@@ -253,16 +273,16 @@ export class MouseHandler extends ViewEventHandler {
if (shouldHandle && (targetIsContent || (targetIsLineNumbers && selectOnLineNumbers))) {
focus();
this._mouseDownOperation.start(t.type, e);
this._mouseDownOperation.start(t.type, e, pointerId);
} else if (targetIsGutter) {
// Do not steal focus
e.preventDefault();
} else if (targetIsViewZone) {
const viewZoneData = <IViewZoneData>t.detail;
if (this.viewHelper.shouldSuppressMouseDownOnViewZone(viewZoneData.viewZoneId)) {
const viewZoneData = t.detail;
if (shouldHandle && this.viewHelper.shouldSuppressMouseDownOnViewZone(viewZoneData.viewZoneId)) {
focus();
this._mouseDownOperation.start(t.type, e);
this._mouseDownOperation.start(t.type, e, pointerId);
e.preventDefault();
}
} else if (targetIsWidget && this.viewHelper.shouldSuppressMouseDownOnWidget(<string>t.detail)) {
@@ -289,7 +309,7 @@ class MouseDownOperation extends Disposable {
private readonly _createMouseTarget: (e: EditorMouseEvent, testEventTarget: boolean) => IMouseTarget;
private readonly _getMouseColumn: (e: EditorMouseEvent) => number;
private readonly _mouseMoveMonitor: GlobalEditorMouseMoveMonitor;
private readonly _mouseMoveMonitor: GlobalEditorPointerMoveMonitor;
private readonly _onScrollTimeout: TimeoutTimer;
private readonly _mouseState: MouseDownState;
@@ -311,7 +331,7 @@ class MouseDownOperation extends Disposable {
this._createMouseTarget = createMouseTarget;
this._getMouseColumn = getMouseColumn;
this._mouseMoveMonitor = this._register(new GlobalEditorMouseMoveMonitor(this._viewHelper.viewDomNode));
this._mouseMoveMonitor = this._register(new GlobalEditorPointerMoveMonitor(this._viewHelper.viewDomNode));
this._onScrollTimeout = this._register(new TimeoutTimer());
this._mouseState = new MouseDownState();
@@ -332,7 +352,7 @@ class MouseDownOperation extends Disposable {
this._lastMouseEvent = e;
this._mouseState.setModifiers(e);
const position = this._findMousePosition(e, true);
const position = this._findMousePosition(e, false);
if (!position) {
// Ignoring because position is unknown
return;
@@ -348,7 +368,7 @@ class MouseDownOperation extends Disposable {
}
}
public start(targetType: MouseTargetType, e: EditorMouseEvent): void {
public start(targetType: MouseTargetType, e: EditorMouseEvent, pointerId: number): void {
this._lastMouseEvent = e;
this._mouseState.setStartedOnLineNumbers(targetType === MouseTargetType.GUTTER_LINE_NUMBERS);
@@ -381,12 +401,13 @@ class MouseDownOperation extends Disposable {
this._isActive = true;
this._mouseMoveMonitor.startMonitoring(
e.target,
this._viewHelper.viewLinesDomNode,
pointerId,
e.buttons,
createMouseMoveEventMerger(null),
(e) => this._onMouseDownThenMove(e),
(browserEvent?: MouseEvent | KeyboardEvent) => {
const position = this._findMousePosition(this._lastMouseEvent!, true);
const position = this._findMousePosition(this._lastMouseEvent!, false);
if (browserEvent && browserEvent instanceof KeyboardEvent) {
// cancel
@@ -411,7 +432,8 @@ class MouseDownOperation extends Disposable {
if (!this._isActive) {
this._isActive = true;
this._mouseMoveMonitor.startMonitoring(
e.target,
this._viewHelper.viewLinesDomNode,
pointerId,
e.buttons,
createMouseMoveEventMerger(null),
(e) => this._onMouseDownThenMove(e),
@@ -429,6 +451,10 @@ class MouseDownOperation extends Disposable {
this._mouseMoveMonitor.stopMonitoring();
}
public onPointerUp(): void {
this._mouseMoveMonitor.stopMonitoring();
}
public onScrollChanged(): void {
if (!this._isActive) {
return;
@@ -454,9 +480,9 @@ class MouseDownOperation extends Disposable {
this._currentSelection = e.selections[0];
}
private _getPositionOutsideEditor(e: EditorMouseEvent): MouseTarget | null {
private _getPositionOutsideEditor(e: EditorMouseEvent): IMouseTarget | null {
const editorContent = e.editorPos;
const model = this._context.model;
const model = this._context.viewModel;
const viewLayout = this._context.viewLayout;
const mouseColumn = this._getMouseColumn(e);
@@ -467,42 +493,42 @@ class MouseDownOperation extends Disposable {
if (viewZoneData) {
const newPosition = this._helpPositionJumpOverViewZone(viewZoneData);
if (newPosition) {
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, newPosition);
return MouseTarget.createOutsideEditor(mouseColumn, newPosition);
}
}
const aboveLineNumber = viewLayout.getLineNumberAtVerticalOffset(verticalOffset);
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, new Position(aboveLineNumber, 1));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(aboveLineNumber, 1));
}
if (e.posy > editorContent.y + editorContent.height) {
const verticalOffset = viewLayout.getCurrentScrollTop() + (e.posy - editorContent.y);
const verticalOffset = viewLayout.getCurrentScrollTop() + e.relativePos.y;
const viewZoneData = HitTestContext.getZoneAtCoord(this._context, verticalOffset);
if (viewZoneData) {
const newPosition = this._helpPositionJumpOverViewZone(viewZoneData);
if (newPosition) {
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, newPosition);
return MouseTarget.createOutsideEditor(mouseColumn, newPosition);
}
}
const belowLineNumber = viewLayout.getLineNumberAtVerticalOffset(verticalOffset);
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, new Position(belowLineNumber, model.getLineMaxColumn(belowLineNumber)));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(belowLineNumber, model.getLineMaxColumn(belowLineNumber)));
}
const possibleLineNumber = viewLayout.getLineNumberAtVerticalOffset(viewLayout.getCurrentScrollTop() + (e.posy - editorContent.y));
const possibleLineNumber = viewLayout.getLineNumberAtVerticalOffset(viewLayout.getCurrentScrollTop() + e.relativePos.y);
if (e.posx < editorContent.x) {
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, new Position(possibleLineNumber, 1));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, 1));
}
if (e.posx > editorContent.x + editorContent.width) {
return new MouseTarget(null, MouseTargetType.OUTSIDE_EDITOR, mouseColumn, new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber)));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber)));
}
return null;
}
private _findMousePosition(e: EditorMouseEvent, testEventTarget: boolean): MouseTarget | null {
private _findMousePosition(e: EditorMouseEvent, testEventTarget: boolean): IMouseTarget | null {
const positionOutsideEditor = this._getPositionOutsideEditor(e);
if (positionOutsideEditor) {
return positionOutsideEditor;
@@ -515,16 +541,16 @@ class MouseDownOperation extends Disposable {
}
if (t.type === MouseTargetType.CONTENT_VIEW_ZONE || t.type === MouseTargetType.GUTTER_VIEW_ZONE) {
const newPosition = this._helpPositionJumpOverViewZone(<IViewZoneData>t.detail);
const newPosition = this._helpPositionJumpOverViewZone(t.detail);
if (newPosition) {
return new MouseTarget(t.element, t.type, t.mouseColumn, newPosition, null, t.detail);
return MouseTarget.createViewZone(t.type, t.element, t.mouseColumn, newPosition, t.detail);
}
}
return t;
}
private _helpPositionJumpOverViewZone(viewZoneData: IViewZoneData): Position | null {
private _helpPositionJumpOverViewZone(viewZoneData: IMouseTargetViewZoneData): Position | null {
// Force position on view zones to go above or below depending on where selection started from
const selectionStart = new Position(this._currentSelection.selectionStartLineNumber, this._currentSelection.selectionStartColumn);
const positionBefore = viewZoneData.positionBefore;
@@ -540,7 +566,7 @@ class MouseDownOperation extends Disposable {
return null;
}
private _dispatchMouse(position: MouseTarget, inSelectionMode: boolean): void {
private _dispatchMouse(position: IMouseTarget, inSelectionMode: boolean): void {
if (!position.position) {
return;
}
@@ -558,6 +584,8 @@ class MouseDownOperation extends Disposable {
leftButton: this._mouseState.leftButton,
middleButton: this._mouseState.middleButton,
onInjectedText: position.type === MouseTargetType.CONTENT_TEXT && position.detail.injectedText !== null
});
}
}

323
src/vs/editor/browser/controller/mouseTarget.ts
View File

@@ -4,50 +4,26 @@
*--------------------------------------------------------------------------------------------*/
import { IPointerHandlerHelper } from 'vs/editor/browser/controller/mouseHandler';
import { IMouseTarget, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorPagePosition, PageCoordinates } from 'vs/editor/browser/editorDom';
import { IMouseTargetContentEmptyData, IMouseTargetMarginData, IMouseTarget, IMouseTargetContentEmpty, IMouseTargetContentText, IMouseTargetContentWidget, IMouseTargetMargin, IMouseTargetOutsideEditor, IMouseTargetOverlayWidget, IMouseTargetScrollbar, IMouseTargetTextarea, IMouseTargetUnknown, IMouseTargetViewZone, IMouseTargetContentTextData, IMouseTargetViewZoneData, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorPagePosition, PageCoordinates, CoordinatesRelativeToEditor } from 'vs/editor/browser/editorDom';
import { PartFingerprint, PartFingerprints } from 'vs/editor/browser/view/viewPart';
import { ViewLine } from 'vs/editor/browser/viewParts/lines/viewLine';
import { IViewCursorRenderData } from 'vs/editor/browser/viewParts/viewCursors/viewCursor';
import { EditorLayoutInfo, EditorOption } from 'vs/editor/common/config/editorOptions';
import { Position } from 'vs/editor/common/core/position';
import { Range as EditorRange } from 'vs/editor/common/core/range';
import { HorizontalPosition } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import { InjectedText, IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { CursorColumns } from 'vs/editor/common/controller/cursorCommon';
import { HorizontalPosition } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { IViewModel } from 'vs/editor/common/viewModel';
import { CursorColumns } from 'vs/editor/common/core/cursorColumns';
import * as dom from 'vs/base/browser/dom';
import { AtomicTabMoveOperations, Direction } from 'vs/editor/common/controller/cursorAtomicMoveOperations';
import { AtomicTabMoveOperations, Direction } from 'vs/editor/common/cursor/cursorAtomicMoveOperations';
import { PositionAffinity } from 'vs/editor/common/model';
export interface IViewZoneData {
viewZoneId: string;
positionBefore: Position | null;
positionAfter: Position | null;
position: Position;
afterLineNumber: number;
}
export interface IMarginData {
isAfterLines: boolean;
glyphMarginLeft: number;
glyphMarginWidth: number;
lineNumbersWidth: number;
offsetX: number;
}
export interface IEmptyContentData {
isAfterLines: boolean;
horizontalDistanceToText?: number;
}
export interface ITextContentData {
mightBeForeignElement: boolean;
}
import { InjectedText } from 'vs/editor/common/modelLineProjectionData';
const enum HitTestResultType {
Unknown = 0,
Content = 1,
Unknown,
Content,
}
class UnknownHitTestResult {
@@ -85,25 +61,46 @@ export class PointerHandlerLastRenderData {
) { }
}
export class MouseTarget implements IMouseTarget {
export class MouseTarget {
public readonly element: Element | null;
public readonly type: MouseTargetType;
public readonly mouseColumn: number;
public readonly position: Position | null;
public readonly range: EditorRange | null;
public readonly detail: any;
constructor(element: Element | null, type: MouseTargetType, mouseColumn: number = 0, position: Position | null = null, range: EditorRange | null = null, detail: any = null) {
this.element = element;
this.type = type;
this.mouseColumn = mouseColumn;
this.position = position;
private static _deduceRage(position: Position): EditorRange;
private static _deduceRage(position: Position, range: EditorRange | null): EditorRange;
private static _deduceRage(position: Position | null): EditorRange | null;
private static _deduceRage(position: Position | null, range: EditorRange | null = null): EditorRange | null {
if (!range && position) {
range = new EditorRange(position.lineNumber, position.column, position.lineNumber, position.column);
return new EditorRange(position.lineNumber, position.column, position.lineNumber, position.column);
}
this.range = range;
this.detail = detail;
return range ?? null;
}
public static createUnknown(element: Element | null, mouseColumn: number, position: Position | null): IMouseTargetUnknown {
return { type: MouseTargetType.UNKNOWN, element, mouseColumn, position, range: this._deduceRage(position) };
}
public static createTextarea(element: Element | null, mouseColumn: number): IMouseTargetTextarea {
return { type: MouseTargetType.TEXTAREA, element, mouseColumn, position: null, range: null };
}
public static createMargin(type: MouseTargetType.GUTTER_GLYPH_MARGIN | MouseTargetType.GUTTER_LINE_NUMBERS | MouseTargetType.GUTTER_LINE_DECORATIONS, element: Element | null, mouseColumn: number, position: Position, range: EditorRange, detail: IMouseTargetMarginData): IMouseTargetMargin {
return { type, element, mouseColumn, position, range, detail };
}
public static createViewZone(type: MouseTargetType.GUTTER_VIEW_ZONE | MouseTargetType.CONTENT_VIEW_ZONE, element: Element | null, mouseColumn: number, position: Position, detail: IMouseTargetViewZoneData): IMouseTargetViewZone {
return { type, element, mouseColumn, position, range: this._deduceRage(position), detail };
}
public static createContentText(element: Element | null, mouseColumn: number, position: Position, range: EditorRange | null, detail: IMouseTargetContentTextData): IMouseTargetContentText {
return { type: MouseTargetType.CONTENT_TEXT, element, mouseColumn, position, range: this._deduceRage(position, range), detail };
}
public static createContentEmpty(element: Element | null, mouseColumn: number, position: Position, detail: IMouseTargetContentEmptyData): IMouseTargetContentEmpty {
return { type: MouseTargetType.CONTENT_EMPTY, element, mouseColumn, position, range: this._deduceRage(position), detail };
}
public static createContentWidget(element: Element | null, mouseColumn: number, detail: string): IMouseTargetContentWidget {
return { type: MouseTargetType.CONTENT_WIDGET, element, mouseColumn, position: null, range: null, detail };
}
public static createScrollbar(element: Element | null, mouseColumn: number, position: Position): IMouseTargetScrollbar {
return { type: MouseTargetType.SCROLLBAR, element, mouseColumn, position, range: this._deduceRage(position) };
}
public static createOverlayWidget(element: Element | null, mouseColumn: number, detail: string): IMouseTargetOverlayWidget {
return { type: MouseTargetType.OVERLAY_WIDGET, element, mouseColumn, position: null, range: null, detail };
}
public static createOutsideEditor(mouseColumn: number, position: Position): IMouseTargetOutsideEditor {
return { type: MouseTargetType.OUTSIDE_EDITOR, element: null, mouseColumn, position, range: this._deduceRage(position) };
}
private static _typeToString(type: MouseTargetType): string {
@@ -147,11 +144,7 @@ export class MouseTarget implements IMouseTarget {
}
public static toString(target: IMouseTarget): string {
return this._typeToString(target.type) + ': ' + target.position + ' - ' + target.range + ' - ' + target.detail;
}
public toString(): string {
return MouseTarget.toString(this);
return this._typeToString(target.type) + ': ' + target.position + ' - ' + target.range + ' - ' + JSON.stringify((<any>target).detail);
}
}
@@ -223,7 +216,7 @@ class ElementPath {
export class HitTestContext {
public readonly model: IViewModel;
public readonly viewModel: IViewModel;
public readonly layoutInfo: EditorLayoutInfo;
public readonly viewDomNode: HTMLElement;
public readonly lineHeight: number;
@@ -235,7 +228,7 @@ export class HitTestContext {
private readonly _viewHelper: IPointerHandlerHelper;
constructor(context: ViewContext, viewHelper: IPointerHandlerHelper, lastRenderData: PointerHandlerLastRenderData) {
this.model = context.model;
this.viewModel = context.viewModel;
const options = context.configuration.options;
this.layoutInfo = options.get(EditorOption.layoutInfo);
this.viewDomNode = viewHelper.viewDomNode;
@@ -247,17 +240,17 @@ export class HitTestContext {
this._viewHelper = viewHelper;
}
public getZoneAtCoord(mouseVerticalOffset: number): IViewZoneData | null {
public getZoneAtCoord(mouseVerticalOffset: number): IMouseTargetViewZoneData | null {
return HitTestContext.getZoneAtCoord(this._context, mouseVerticalOffset);
}
public static getZoneAtCoord(context: ViewContext, mouseVerticalOffset: number): IViewZoneData | null {
public static getZoneAtCoord(context: ViewContext, mouseVerticalOffset: number): IMouseTargetViewZoneData | null {
// The target is either a view zone or the empty space after the last view-line
const viewZoneWhitespace = context.viewLayout.getWhitespaceAtVerticalOffset(mouseVerticalOffset);
if (viewZoneWhitespace) {
const viewZoneMiddle = viewZoneWhitespace.verticalOffset + viewZoneWhitespace.height / 2;
const lineCount = context.model.getLineCount();
const lineCount = context.viewModel.getLineCount();
let positionBefore: Position | null = null;
let position: Position | null;
let positionAfter: Position | null = null;
@@ -268,7 +261,7 @@ export class HitTestContext {
}
if (viewZoneWhitespace.afterLineNumber > 0) {
// There are more lines above this view zone
positionBefore = new Position(viewZoneWhitespace.afterLineNumber, context.model.getLineMaxColumn(viewZoneWhitespace.afterLineNumber));
positionBefore = new Position(viewZoneWhitespace.afterLineNumber, context.viewModel.getLineMaxColumn(viewZoneWhitespace.afterLineNumber));
}
if (positionAfter === null) {
@@ -292,11 +285,11 @@ export class HitTestContext {
return null;
}
public getFullLineRangeAtCoord(mouseVerticalOffset: number): { range: EditorRange; isAfterLines: boolean; } {
public getFullLineRangeAtCoord(mouseVerticalOffset: number): { range: EditorRange; isAfterLines: boolean } {
if (this._context.viewLayout.isAfterLines(mouseVerticalOffset)) {
// Below the last line
const lineNumber = this._context.model.getLineCount();
const maxLineColumn = this._context.model.getLineMaxColumn(lineNumber);
const lineNumber = this._context.viewModel.getLineCount();
const maxLineColumn = this._context.viewModel.getLineMaxColumn(lineNumber);
return {
range: new EditorRange(lineNumber, maxLineColumn, lineNumber, maxLineColumn),
isAfterLines: true
@@ -304,7 +297,7 @@ export class HitTestContext {
}
const lineNumber = this._context.viewLayout.getLineNumberAtVerticalOffset(mouseVerticalOffset);
const maxLineColumn = this._context.model.getLineMaxColumn(lineNumber);
const maxLineColumn = this._context.viewModel.getLineMaxColumn(lineNumber);
return {
range: new EditorRange(lineNumber, 1, lineNumber, maxLineColumn),
isAfterLines: false
@@ -373,6 +366,7 @@ abstract class BareHitTestRequest {
public readonly editorPos: EditorPagePosition;
public readonly pos: PageCoordinates;
public readonly relativePos: CoordinatesRelativeToEditor;
public readonly mouseVerticalOffset: number;
public readonly isInMarginArea: boolean;
public readonly isInContentArea: boolean;
@@ -380,13 +374,14 @@ abstract class BareHitTestRequest {
protected readonly mouseColumn: number;
constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates) {
constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates, relativePos: CoordinatesRelativeToEditor) {
this.editorPos = editorPos;
this.pos = pos;
this.relativePos = relativePos;
this.mouseVerticalOffset = Math.max(0, ctx.getCurrentScrollTop() + pos.y - editorPos.y);
this.mouseContentHorizontalOffset = ctx.getCurrentScrollLeft() + pos.x - editorPos.x - ctx.layoutInfo.contentLeft;
this.isInMarginArea = (pos.x - editorPos.x < ctx.layoutInfo.contentLeft && pos.x - editorPos.x >= ctx.layoutInfo.glyphMarginLeft);
this.mouseVerticalOffset = Math.max(0, ctx.getCurrentScrollTop() + this.relativePos.y);
this.mouseContentHorizontalOffset = ctx.getCurrentScrollLeft() + this.relativePos.x - ctx.layoutInfo.contentLeft;
this.isInMarginArea = (this.relativePos.x < ctx.layoutInfo.contentLeft && this.relativePos.x >= ctx.layoutInfo.glyphMarginLeft);
this.isInContentArea = !this.isInMarginArea;
this.mouseColumn = Math.max(0, MouseTargetFactory._getMouseColumn(this.mouseContentHorizontalOffset, ctx.typicalHalfwidthCharacterWidth));
}
@@ -397,8 +392,8 @@ class HitTestRequest extends BareHitTestRequest {
public readonly target: Element | null;
public readonly targetPath: Uint8Array;
constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates, target: Element | null) {
super(ctx, editorPos, pos);
constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates, relativePos: CoordinatesRelativeToEditor, target: Element | null) {
super(ctx, editorPos, pos, relativePos);
this._ctx = ctx;
if (target) {
@@ -411,31 +406,47 @@ class HitTestRequest extends BareHitTestRequest {
}
public override toString(): string {
return `pos(${this.pos.x},${this.pos.y}), editorPos(${this.editorPos.x},${this.editorPos.y}), mouseVerticalOffset: ${this.mouseVerticalOffset}, mouseContentHorizontalOffset: ${this.mouseContentHorizontalOffset}\n\ttarget: ${this.target ? (<HTMLElement>this.target).outerHTML : null}`;
return `pos(${this.pos.x},${this.pos.y}), editorPos(${this.editorPos.x},${this.editorPos.y}), relativePos(${this.relativePos.x},${this.relativePos.y}), mouseVerticalOffset: ${this.mouseVerticalOffset}, mouseContentHorizontalOffset: ${this.mouseContentHorizontalOffset}\n\ttarget: ${this.target ? (<HTMLElement>this.target).outerHTML : null}`;
}
public fulfill(type: MouseTargetType.UNKNOWN, position?: Position | null, range?: EditorRange | null): MouseTarget;
public fulfill(type: MouseTargetType.TEXTAREA, position: Position | null): MouseTarget;
public fulfill(type: MouseTargetType.GUTTER_GLYPH_MARGIN | MouseTargetType.GUTTER_LINE_NUMBERS | MouseTargetType.GUTTER_LINE_DECORATIONS, position: Position, range: EditorRange, detail: IMarginData): MouseTarget;
public fulfill(type: MouseTargetType.GUTTER_VIEW_ZONE | MouseTargetType.CONTENT_VIEW_ZONE, position: Position, range: null, detail: IViewZoneData): MouseTarget;
public fulfill(type: MouseTargetType.CONTENT_TEXT, position: Position | null, range: EditorRange | null, detail: ITextContentData): MouseTarget;
public fulfill(type: MouseTargetType.CONTENT_EMPTY, position: Position | null, range: EditorRange | null, detail: IEmptyContentData): MouseTarget;
public fulfill(type: MouseTargetType.CONTENT_WIDGET, position: null, range: null, detail: string): MouseTarget;
public fulfill(type: MouseTargetType.SCROLLBAR, position: Position): MouseTarget;
public fulfill(type: MouseTargetType.OVERLAY_WIDGET, position: null, range: null, detail: string): MouseTarget;
// public fulfill(type: MouseTargetType.OVERVIEW_RULER, position?: Position | null, range?: EditorRange | null, detail?: any): MouseTarget;
// public fulfill(type: MouseTargetType.OUTSIDE_EDITOR, position?: Position | null, range?: EditorRange | null, detail?: any): MouseTarget;
public fulfill(type: MouseTargetType, position: Position | null = null, range: EditorRange | null = null, detail: any = null): MouseTarget {
let mouseColumn = this.mouseColumn;
if (position && position.column < this._ctx.model.getLineMaxColumn(position.lineNumber)) {
private _getMouseColumn(position: Position | null = null): number {
if (position && position.column < this._ctx.viewModel.getLineMaxColumn(position.lineNumber)) {
// Most likely, the line contains foreign decorations...
mouseColumn = CursorColumns.visibleColumnFromColumn(this._ctx.model.getLineContent(position.lineNumber), position.column, this._ctx.model.getTextModelOptions().tabSize) + 1;
return CursorColumns.visibleColumnFromColumn(this._ctx.viewModel.getLineContent(position.lineNumber), position.column, this._ctx.viewModel.model.getOptions().tabSize) + 1;
}
return new MouseTarget(this.target, type, mouseColumn, position, range, detail);
return this.mouseColumn;
}
public fulfillUnknown(position: Position | null = null): IMouseTargetUnknown {
return MouseTarget.createUnknown(this.target, this._getMouseColumn(position), position);
}
public fulfillTextarea(): IMouseTargetTextarea {
return MouseTarget.createTextarea(this.target, this._getMouseColumn());
}
public fulfillMargin(type: MouseTargetType.GUTTER_GLYPH_MARGIN | MouseTargetType.GUTTER_LINE_NUMBERS | MouseTargetType.GUTTER_LINE_DECORATIONS, position: Position, range: EditorRange, detail: IMouseTargetMarginData): IMouseTargetMargin {
return MouseTarget.createMargin(type, this.target, this._getMouseColumn(position), position, range, detail);
}
public fulfillViewZone(type: MouseTargetType.GUTTER_VIEW_ZONE | MouseTargetType.CONTENT_VIEW_ZONE, position: Position, detail: IMouseTargetViewZoneData): IMouseTargetViewZone {
return MouseTarget.createViewZone(type, this.target, this._getMouseColumn(position), position, detail);
}
public fulfillContentText(position: Position, range: EditorRange | null, detail: IMouseTargetContentTextData): IMouseTargetContentText {
return MouseTarget.createContentText(this.target, this._getMouseColumn(position), position, range, detail);
}
public fulfillContentEmpty(position: Position, detail: IMouseTargetContentEmptyData): IMouseTargetContentEmpty {
return MouseTarget.createContentEmpty(this.target, this._getMouseColumn(position), position, detail);
}
public fulfillContentWidget(detail: string): IMouseTargetContentWidget {
return MouseTarget.createContentWidget(this.target, this._getMouseColumn(), detail);
}
public fulfillScrollbar(position: Position): IMouseTargetScrollbar {
return MouseTarget.createScrollbar(this.target, this._getMouseColumn(position), position);
}
public fulfillOverlayWidget(detail: string): IMouseTargetOverlayWidget {
return MouseTarget.createOverlayWidget(this.target, this._getMouseColumn(), detail);
}
public withTarget(target: Element | null): HitTestRequest {
return new HitTestRequest(this._ctx, this.editorPos, this.pos, target);
return new HitTestRequest(this._ctx, this.editorPos, this.pos, this.relativePos, target);
}
}
@@ -443,9 +454,9 @@ interface ResolvedHitTestRequest extends HitTestRequest {
readonly target: Element;
}
const EMPTY_CONTENT_AFTER_LINES: IEmptyContentData = { isAfterLines: true };
const EMPTY_CONTENT_AFTER_LINES: IMouseTargetContentEmptyData = { isAfterLines: true };
function createEmptyContentDataInLines(horizontalDistanceToText: number): IEmptyContentData {
function createEmptyContentDataInLines(horizontalDistanceToText: number): IMouseTargetContentEmptyData {
return {
isAfterLines: false,
horizontalDistanceToText: horizontalDistanceToText
@@ -479,20 +490,20 @@ export class MouseTargetFactory {
return false;
}
public createMouseTarget(lastRenderData: PointerHandlerLastRenderData, editorPos: EditorPagePosition, pos: PageCoordinates, target: HTMLElement | null): IMouseTarget {
public createMouseTarget(lastRenderData: PointerHandlerLastRenderData, editorPos: EditorPagePosition, pos: PageCoordinates, relativePos: CoordinatesRelativeToEditor, target: HTMLElement | null): IMouseTarget {
const ctx = new HitTestContext(this._context, this._viewHelper, lastRenderData);
const request = new HitTestRequest(ctx, editorPos, pos, target);
const request = new HitTestRequest(ctx, editorPos, pos, relativePos, target);
try {
const r = MouseTargetFactory._createMouseTarget(ctx, request, false);
// console.log(r.toString());
// console.log(MouseTarget.toString(r));
return r;
} catch (err) {
// console.log(err);
return request.fulfill(MouseTargetType.UNKNOWN);
return request.fulfillUnknown();
}
}
private static _createMouseTarget(ctx: HitTestContext, request: HitTestRequest, domHitTestExecuted: boolean): MouseTarget {
private static _createMouseTarget(ctx: HitTestContext, request: HitTestRequest, domHitTestExecuted: boolean): IMouseTarget {
// console.log(`${domHitTestExecuted ? '=>' : ''}CAME IN REQUEST: ${request}`);
@@ -500,7 +511,7 @@ export class MouseTargetFactory {
if (request.target === null) {
if (domHitTestExecuted) {
// Still no target... and we have already executed hit test...
return request.fulfill(MouseTargetType.UNKNOWN);
return request.fulfillUnknown();
}
const hitTestResult = MouseTargetFactory._doHitTest(ctx, request);
@@ -515,7 +526,7 @@ export class MouseTargetFactory {
// we know for a fact that request.target is not null
const resolvedRequest = <ResolvedHitTestRequest>request;
let result: MouseTarget | null = null;
let result: IMouseTarget | null = null;
result = result || MouseTargetFactory._hitTestContentWidget(ctx, resolvedRequest);
result = result || MouseTargetFactory._hitTestOverlayWidget(ctx, resolvedRequest);
@@ -528,36 +539,36 @@ export class MouseTargetFactory {
result = result || MouseTargetFactory._hitTestViewLines(ctx, resolvedRequest, domHitTestExecuted);
result = result || MouseTargetFactory._hitTestScrollbar(ctx, resolvedRequest);
return (result || request.fulfill(MouseTargetType.UNKNOWN));
return (result || request.fulfillUnknown());
}
private static _hitTestContentWidget(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestContentWidget(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
// Is it a content widget?
if (ElementPath.isChildOfContentWidgets(request.targetPath) || ElementPath.isChildOfOverflowingContentWidgets(request.targetPath)) {
const widgetId = ctx.findAttribute(request.target, 'widgetId');
if (widgetId) {
return request.fulfill(MouseTargetType.CONTENT_WIDGET, null, null, widgetId);
return request.fulfillContentWidget(widgetId);
} else {
return request.fulfill(MouseTargetType.UNKNOWN);
return request.fulfillUnknown();
}
}
return null;
}
private static _hitTestOverlayWidget(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestOverlayWidget(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
// Is it an overlay widget?
if (ElementPath.isChildOfOverlayWidgets(request.targetPath)) {
const widgetId = ctx.findAttribute(request.target, 'widgetId');
if (widgetId) {
return request.fulfill(MouseTargetType.OVERLAY_WIDGET, null, null, widgetId);
return request.fulfillOverlayWidget(widgetId);
} else {
return request.fulfill(MouseTargetType.UNKNOWN);
return request.fulfillUnknown();
}
}
return null;
}
private static _hitTestViewCursor(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestViewCursor(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
if (request.target) {
// Check if we've hit a painted cursor
@@ -566,7 +577,7 @@ export class MouseTargetFactory {
for (const d of lastViewCursorsRenderData) {
if (request.target === d.domNode) {
return request.fulfill(MouseTargetType.CONTENT_TEXT, d.position, null, { mightBeForeignElement: false });
return request.fulfillContentText(d.position, null, { mightBeForeignElement: false, injectedText: null });
}
}
}
@@ -598,7 +609,7 @@ export class MouseTargetFactory {
cursorVerticalOffset <= mouseVerticalOffset
&& mouseVerticalOffset <= cursorVerticalOffset + d.height
) {
return request.fulfill(MouseTargetType.CONTENT_TEXT, d.position, null, { mightBeForeignElement: false });
return request.fulfillContentText(d.position, null, { mightBeForeignElement: false, injectedText: null });
}
}
}
@@ -606,33 +617,33 @@ export class MouseTargetFactory {
return null;
}
private static _hitTestViewZone(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestViewZone(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
const viewZoneData = ctx.getZoneAtCoord(request.mouseVerticalOffset);
if (viewZoneData) {
const mouseTargetType = (request.isInContentArea ? MouseTargetType.CONTENT_VIEW_ZONE : MouseTargetType.GUTTER_VIEW_ZONE);
return request.fulfill(mouseTargetType, viewZoneData.position, null, viewZoneData);
return request.fulfillViewZone(mouseTargetType, viewZoneData.position, viewZoneData);
}
return null;
}
private static _hitTestTextArea(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestTextArea(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
// Is it the textarea?
if (ElementPath.isTextArea(request.targetPath)) {
if (ctx.lastRenderData.lastTextareaPosition) {
return request.fulfill(MouseTargetType.CONTENT_TEXT, ctx.lastRenderData.lastTextareaPosition, null, { mightBeForeignElement: false });
return request.fulfillContentText(ctx.lastRenderData.lastTextareaPosition, null, { mightBeForeignElement: false, injectedText: null });
}
return request.fulfill(MouseTargetType.TEXTAREA, ctx.lastRenderData.lastTextareaPosition);
return request.fulfillTextarea();
}
return null;
}
private static _hitTestMargin(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestMargin(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
if (request.isInMarginArea) {
const res = ctx.getFullLineRangeAtCoord(request.mouseVerticalOffset);
const pos = res.range.getStartPosition();
let offset = Math.abs(request.pos.x - request.editorPos.x);
const detail: IMarginData = {
let offset = Math.abs(request.relativePos.x);
const detail: IMouseTargetMarginData = {
isAfterLines: res.isAfterLines,
glyphMarginLeft: ctx.layoutInfo.glyphMarginLeft,
glyphMarginWidth: ctx.layoutInfo.glyphMarginWidth,
@@ -644,37 +655,37 @@ export class MouseTargetFactory {
if (offset <= ctx.layoutInfo.glyphMarginWidth) {
// On the glyph margin
return request.fulfill(MouseTargetType.GUTTER_GLYPH_MARGIN, pos, res.range, detail);
return request.fulfillMargin(MouseTargetType.GUTTER_GLYPH_MARGIN, pos, res.range, detail);
}
offset -= ctx.layoutInfo.glyphMarginWidth;
if (offset <= ctx.layoutInfo.lineNumbersWidth) {
// On the line numbers
return request.fulfill(MouseTargetType.GUTTER_LINE_NUMBERS, pos, res.range, detail);
return request.fulfillMargin(MouseTargetType.GUTTER_LINE_NUMBERS, pos, res.range, detail);
}
offset -= ctx.layoutInfo.lineNumbersWidth;
// On the line decorations
return request.fulfill(MouseTargetType.GUTTER_LINE_DECORATIONS, pos, res.range, detail);
return request.fulfillMargin(MouseTargetType.GUTTER_LINE_DECORATIONS, pos, res.range, detail);
}
return null;
}
private static _hitTestViewLines(ctx: HitTestContext, request: ResolvedHitTestRequest, domHitTestExecuted: boolean): MouseTarget | null {
private static _hitTestViewLines(ctx: HitTestContext, request: ResolvedHitTestRequest, domHitTestExecuted: boolean): IMouseTarget | null {
if (!ElementPath.isChildOfViewLines(request.targetPath)) {
return null;
}
if (ctx.isInTopPadding(request.mouseVerticalOffset)) {
return request.fulfill(MouseTargetType.CONTENT_EMPTY, new Position(1, 1), null, EMPTY_CONTENT_AFTER_LINES);
return request.fulfillContentEmpty(new Position(1, 1), EMPTY_CONTENT_AFTER_LINES);
}
// Check if it is below any lines and any view zones
if (ctx.isAfterLines(request.mouseVerticalOffset) || ctx.isInBottomPadding(request.mouseVerticalOffset)) {
// This most likely indicates it happened after the last view-line
const lineCount = ctx.model.getLineCount();
const maxLineColumn = ctx.model.getLineMaxColumn(lineCount);
return request.fulfill(MouseTargetType.CONTENT_EMPTY, new Position(lineCount, maxLineColumn), null, EMPTY_CONTENT_AFTER_LINES);
const lineCount = ctx.viewModel.getLineCount();
const maxLineColumn = ctx.viewModel.getLineMaxColumn(lineCount);
return request.fulfillContentEmpty(new Position(lineCount, maxLineColumn), EMPTY_CONTENT_AFTER_LINES);
}
if (domHitTestExecuted) {
@@ -682,22 +693,22 @@ export class MouseTargetFactory {
// See https://github.com/microsoft/vscode/issues/46942
if (ElementPath.isStrictChildOfViewLines(request.targetPath)) {
const lineNumber = ctx.getLineNumberAtVerticalOffset(request.mouseVerticalOffset);
if (ctx.model.getLineLength(lineNumber) === 0) {
if (ctx.viewModel.getLineLength(lineNumber) === 0) {
const lineWidth = ctx.getLineWidth(lineNumber);
const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
return request.fulfill(MouseTargetType.CONTENT_EMPTY, new Position(lineNumber, 1), null, detail);
return request.fulfillContentEmpty(new Position(lineNumber, 1), detail);
}
const lineWidth = ctx.getLineWidth(lineNumber);
if (request.mouseContentHorizontalOffset >= lineWidth) {
const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
const pos = new Position(lineNumber, ctx.model.getLineMaxColumn(lineNumber));
return request.fulfill(MouseTargetType.CONTENT_EMPTY, pos, null, detail);
const pos = new Position(lineNumber, ctx.viewModel.getLineMaxColumn(lineNumber));
return request.fulfillContentEmpty(pos, detail);
}
}
// We have already executed hit test...
return request.fulfill(MouseTargetType.UNKNOWN);
return request.fulfillUnknown();
}
const hitTestResult = MouseTargetFactory._doHitTest(ctx, request);
@@ -709,45 +720,45 @@ export class MouseTargetFactory {
return this._createMouseTarget(ctx, request.withTarget(hitTestResult.hitTarget), true);
}
private static _hitTestMinimap(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestMinimap(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
if (ElementPath.isChildOfMinimap(request.targetPath)) {
const possibleLineNumber = ctx.getLineNumberAtVerticalOffset(request.mouseVerticalOffset);
const maxColumn = ctx.model.getLineMaxColumn(possibleLineNumber);
return request.fulfill(MouseTargetType.SCROLLBAR, new Position(possibleLineNumber, maxColumn));
const maxColumn = ctx.viewModel.getLineMaxColumn(possibleLineNumber);
return request.fulfillScrollbar(new Position(possibleLineNumber, maxColumn));
}
return null;
}
private static _hitTestScrollbarSlider(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestScrollbarSlider(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
if (ElementPath.isChildOfScrollableElement(request.targetPath)) {
if (request.target && request.target.nodeType === 1) {
const className = request.target.className;
if (className && /\b(slider|scrollbar)\b/.test(className)) {
const possibleLineNumber = ctx.getLineNumberAtVerticalOffset(request.mouseVerticalOffset);
const maxColumn = ctx.model.getLineMaxColumn(possibleLineNumber);
return request.fulfill(MouseTargetType.SCROLLBAR, new Position(possibleLineNumber, maxColumn));
const maxColumn = ctx.viewModel.getLineMaxColumn(possibleLineNumber);
return request.fulfillScrollbar(new Position(possibleLineNumber, maxColumn));
}
}
}
return null;
}
private static _hitTestScrollbar(ctx: HitTestContext, request: ResolvedHitTestRequest): MouseTarget | null {
private static _hitTestScrollbar(ctx: HitTestContext, request: ResolvedHitTestRequest): IMouseTarget | null {
// Is it the overview ruler?
// Is it a child of the scrollable element?
if (ElementPath.isChildOfScrollableElement(request.targetPath)) {
const possibleLineNumber = ctx.getLineNumberAtVerticalOffset(request.mouseVerticalOffset);
const maxColumn = ctx.model.getLineMaxColumn(possibleLineNumber);
return request.fulfill(MouseTargetType.SCROLLBAR, new Position(possibleLineNumber, maxColumn));
const maxColumn = ctx.viewModel.getLineMaxColumn(possibleLineNumber);
return request.fulfillScrollbar(new Position(possibleLineNumber, maxColumn));
}
return null;
}
public getMouseColumn(editorPos: EditorPagePosition, pos: PageCoordinates): number {
public getMouseColumn(relativePos: CoordinatesRelativeToEditor): number {
const options = this._context.configuration.options;
const layoutInfo = options.get(EditorOption.layoutInfo);
const mouseContentHorizontalOffset = this._context.viewLayout.getCurrentScrollLeft() + pos.x - editorPos.x - layoutInfo.contentLeft;
const mouseContentHorizontalOffset = this._context.viewLayout.getCurrentScrollLeft() + relativePos.x - layoutInfo.contentLeft;
return MouseTargetFactory._getMouseColumn(mouseContentHorizontalOffset, options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth);
}
@@ -759,7 +770,7 @@ export class MouseTargetFactory {
return (chars + 1);
}
private static createMouseTargetFromHitTestPosition(ctx: HitTestContext, request: HitTestRequest, spanNode: HTMLElement, pos: Position, injectedText: InjectedText | null): MouseTarget {
private static createMouseTargetFromHitTestPosition(ctx: HitTestContext, request: HitTestRequest, spanNode: HTMLElement, pos: Position, injectedText: InjectedText | null): IMouseTarget {
const lineNumber = pos.lineNumber;
const column = pos.column;
@@ -767,23 +778,23 @@ export class MouseTargetFactory {
if (request.mouseContentHorizontalOffset > lineWidth) {
const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
return request.fulfill(MouseTargetType.CONTENT_EMPTY, pos, null, detail);
return request.fulfillContentEmpty(pos, detail);
}
const visibleRange = ctx.visibleRangeForPosition(lineNumber, column);
if (!visibleRange) {
return request.fulfill(MouseTargetType.UNKNOWN, pos);
return request.fulfillUnknown(pos);
}
const columnHorizontalOffset = visibleRange.left;
if (request.mouseContentHorizontalOffset === columnHorizontalOffset) {
return request.fulfill(MouseTargetType.CONTENT_TEXT, pos, null, { mightBeForeignElement: !!injectedText });
return request.fulfillContentText(pos, null, { mightBeForeignElement: !!injectedText, injectedText });
}
// Let's define a, b, c and check if the offset is in between them...
interface OffsetColumn { offset: number; column: number; }
interface OffsetColumn { offset: number; column: number }
const points: OffsetColumn[] = [];
points.push({ offset: visibleRange.left, column: column });
@@ -793,7 +804,7 @@ export class MouseTargetFactory {
points.push({ offset: visibleRange.left, column: column - 1 });
}
}
const lineMaxColumn = ctx.model.getLineMaxColumn(lineNumber);
const lineMaxColumn = ctx.viewModel.getLineMaxColumn(lineNumber);
if (column < lineMaxColumn) {
const visibleRange = ctx.visibleRangeForPosition(lineNumber, column + 1);
if (visibleRange) {
@@ -812,10 +823,10 @@ export class MouseTargetFactory {
const curr = points[i];
if (prev.offset <= request.mouseContentHorizontalOffset && request.mouseContentHorizontalOffset <= curr.offset) {
const rng = new EditorRange(lineNumber, prev.column, lineNumber, curr.column);
return request.fulfill(MouseTargetType.CONTENT_TEXT, pos, rng, { mightBeForeignElement: !mouseIsOverSpanNode || !!injectedText });
return request.fulfillContentText(pos, rng, { mightBeForeignElement: !mouseIsOverSpanNode || !!injectedText, injectedText });
}
}
return request.fulfill(MouseTargetType.CONTENT_TEXT, pos, null, { mightBeForeignElement: !mouseIsOverSpanNode || !!injectedText });
return request.fulfillContentText(pos, null, { mightBeForeignElement: !mouseIsOverSpanNode || !!injectedText, injectedText });
}
/**
@@ -833,8 +844,8 @@ export class MouseTargetFactory {
if (adjustedPageY <= request.editorPos.y) {
adjustedPageY = request.editorPos.y + 1;
}
if (adjustedPageY >= request.editorPos.y + ctx.layoutInfo.height) {
adjustedPageY = request.editorPos.y + ctx.layoutInfo.height - 1;
if (adjustedPageY >= request.editorPos.y + request.editorPos.height) {
adjustedPageY = request.editorPos.y + request.editorPos.height - 1;
}
const adjustedPage = new PageCoordinates(request.pos.x, adjustedPageY);
@@ -900,7 +911,7 @@ export class MouseTargetFactory {
* Most probably Gecko
*/
private static _doHitTestWithCaretPositionFromPoint(ctx: HitTestContext, coords: ClientCoordinates): HitTestResult {
const hitResult: { offsetNode: Node; offset: number; } = (<any>document).caretPositionFromPoint(coords.clientX, coords.clientY);
const hitResult: { offsetNode: Node; offset: number } = (<any>document).caretPositionFromPoint(coords.clientX, coords.clientY);
if (hitResult.offsetNode.nodeType === hitResult.offsetNode.TEXT_NODE) {
// offsetNode is expected to be the token text
@@ -941,7 +952,7 @@ export class MouseTargetFactory {
private static _snapToSoftTabBoundary(position: Position, viewModel: IViewModel): Position {
const lineContent = viewModel.getLineContent(position.lineNumber);
const { tabSize } = viewModel.getTextModelOptions();
const { tabSize } = viewModel.model.getOptions();
const newPosition = AtomicTabMoveOperations.atomicPosition(lineContent, position.column - 1, tabSize, Direction.Nearest);
if (newPosition !== -1) {
return new Position(position.lineNumber, newPosition + 1);
@@ -958,16 +969,16 @@ export class MouseTargetFactory {
result = this._doHitTestWithCaretPositionFromPoint(ctx, request.pos.toClientCoordinates());
}
if (result.type === HitTestResultType.Content) {
const injectedText = ctx.model.getInjectedTextAt(result.position);
const injectedText = ctx.viewModel.getInjectedTextAt(result.position);
const normalizedPosition = ctx.model.normalizePosition(result.position, PositionAffinity.None);
const normalizedPosition = ctx.viewModel.normalizePosition(result.position, PositionAffinity.None);
if (injectedText || !normalizedPosition.equals(result.position)) {
result = new ContentHitTestResult(normalizedPosition, result.spanNode, injectedText);
}
}
// Snap to the nearest soft tab boundary if atomic soft tabs are enabled.
if (result.type === HitTestResultType.Content && ctx.stickyTabStops) {
result = new ContentHitTestResult(this._snapToSoftTabBoundary(result.position, ctx.model), result.spanNode, result.injectedText);
result = new ContentHitTestResult(this._snapToSoftTabBoundary(result.position, ctx.viewModel), result.spanNode, result.injectedText);
}
return result;
}
@@ -1041,7 +1052,7 @@ class CharWidthReader {
return CharWidthReader._INSTANCE;
}
private readonly _cache: { [cacheKey: string]: number; };
private readonly _cache: { [cacheKey: string]: number };
private readonly _canvas: HTMLCanvasElement;
private constructor() {

23
src/vs/editor/browser/controller/pointerHandler.ts
View File

@@ -8,10 +8,10 @@ import * as platform from 'vs/base/common/platform';
import { EventType, Gesture, GestureEvent } from 'vs/base/browser/touch';
import { Disposable } from 'vs/base/common/lifecycle';
import { IPointerHandlerHelper, MouseHandler, createMouseMoveEventMerger } from 'vs/editor/browser/controller/mouseHandler';
import { IMouseTarget } from 'vs/editor/browser/editorBrowser';
import { IMouseTarget, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { EditorMouseEvent, EditorPointerEventFactory } from 'vs/editor/browser/editorDom';
import { ViewController } from 'vs/editor/browser/view/viewController';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { BrowserFeatures } from 'vs/base/browser/canIUse';
import { TextAreaSyntethicEvents } from 'vs/editor/browser/controller/textAreaInput';
@@ -26,7 +26,7 @@ export class PointerEventHandler extends MouseHandler {
this._register(Gesture.addTarget(this.viewHelper.linesContentDomNode));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Tap, (e) => this.onTap(e)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Change, (e) => this.onChange(e)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e: MouseEvent) => this._onContextMenu(new EditorMouseEvent(e, this.viewHelper.viewDomNode), false)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e: MouseEvent) => this._onContextMenu(new EditorMouseEvent(e, false, this.viewHelper.viewDomNode), false)));
this._lastPointerType = 'mouse';
@@ -50,7 +50,7 @@ export class PointerEventHandler extends MouseHandler {
createMouseMoveEventMerger(this.mouseTargetFactory), MouseHandler.MOUSE_MOVE_MINIMUM_TIME));
this._register(pointerEvents.onPointerUp(this.viewHelper.viewDomNode, (e) => this._onMouseUp(e)));
this._register(pointerEvents.onPointerLeave(this.viewHelper.viewDomNode, (e) => this._onMouseLeave(e)));
this._register(pointerEvents.onPointerDown(this.viewHelper.viewDomNode, (e) => this._onMouseDown(e)));
this._register(pointerEvents.onPointerDown(this.viewHelper.viewDomNode, (e, pointerId) => this._onMouseDown(e, pointerId)));
}
private onTap(event: GestureEvent): void {
@@ -60,7 +60,7 @@ export class PointerEventHandler extends MouseHandler {
event.preventDefault();
this.viewHelper.focusTextArea();
const target = this._createMouseTarget(new EditorMouseEvent(event, this.viewHelper.viewDomNode), false);
const target = this._createMouseTarget(new EditorMouseEvent(event, false, this.viewHelper.viewDomNode), false);
if (target.position) {
// this.viewController.moveTo(target.position);
@@ -77,22 +77,23 @@ export class PointerEventHandler extends MouseHandler {
leftButton: false,
middleButton: false,
onInjectedText: target.type === MouseTargetType.CONTENT_TEXT && target.detail.injectedText !== null
});
}
}
private onChange(e: GestureEvent): void {
if (this._lastPointerType === 'touch') {
this._context.model.deltaScrollNow(-e.translationX, -e.translationY);
this._context.viewModel.viewLayout.deltaScrollNow(-e.translationX, -e.translationY);
}
}
public override _onMouseDown(e: EditorMouseEvent): void {
public override _onMouseDown(e: EditorMouseEvent, pointerId: number): void {
if ((e.browserEvent as any).pointerType === 'touch') {
return;
}
super._onMouseDown(e);
super._onMouseDown(e, pointerId);
}
}
@@ -105,7 +106,7 @@ class TouchHandler extends MouseHandler {
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Tap, (e) => this.onTap(e)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Change, (e) => this.onChange(e)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e: MouseEvent) => this._onContextMenu(new EditorMouseEvent(e, this.viewHelper.viewDomNode), false)));
this._register(dom.addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e: MouseEvent) => this._onContextMenu(new EditorMouseEvent(e, false, this.viewHelper.viewDomNode), false)));
}
private onTap(event: GestureEvent): void {
@@ -113,7 +114,7 @@ class TouchHandler extends MouseHandler {
this.viewHelper.focusTextArea();
const target = this._createMouseTarget(new EditorMouseEvent(event, this.viewHelper.viewDomNode), false);
const target = this._createMouseTarget(new EditorMouseEvent(event, false, this.viewHelper.viewDomNode), false);
if (target.position) {
// Send the tap event also to the <textarea> (for input purposes)
@@ -126,7 +127,7 @@ class TouchHandler extends MouseHandler {
}
private onChange(e: GestureEvent): void {
this._context.model.deltaScrollNow(-e.translationX, -e.translationY);
this._context.viewModel.viewLayout.deltaScrollNow(-e.translationX, -e.translationY);
}
}

473
src/vs/editor/browser/controller/textAreaHandler.ts
View File

@@ -10,8 +10,8 @@ import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import * as platform from 'vs/base/common/platform';
import * as strings from 'vs/base/common/strings';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { CopyOptions, ICompositionData, IPasteData, ITextAreaInputHost, TextAreaInput, ClipboardDataToCopy } from 'vs/editor/browser/controller/textAreaInput';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { CopyOptions, ICompositionData, IPasteData, ITextAreaInputHost, TextAreaInput, ClipboardDataToCopy, TextAreaWrapper } from 'vs/editor/browser/controller/textAreaInput';
import { ISimpleModel, ITypeData, PagedScreenReaderStrategy, TextAreaState, _debugComposition } from 'vs/editor/browser/controller/textAreaState';
import { ViewController } from 'vs/editor/browser/view/viewController';
import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/view/viewPart';
@@ -19,38 +19,84 @@ import { LineNumbersOverlay } from 'vs/editor/browser/viewParts/lineNumbers/line
import { Margin } from 'vs/editor/browser/viewParts/margin/margin';
import { RenderLineNumbersType, EditorOption, IComputedEditorOptions, EditorOptions } from 'vs/editor/common/config/editorOptions';
import { BareFontInfo } from 'vs/editor/common/config/fontInfo';
import { WordCharacterClass, getMapForWordSeparators } from 'vs/editor/common/controller/wordCharacterClassifier';
import { WordCharacterClass, getMapForWordSeparators } from 'vs/editor/common/core/wordCharacterClassifier';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import { ScrollType } from 'vs/editor/common/editorCommon';
import { EndOfLinePreference } from 'vs/editor/common/model';
import { RenderingContext, RestrictedRenderingContext, HorizontalPosition } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext, HorizontalPosition } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
import { IEditorAriaOptions } from 'vs/editor/browser/editorBrowser';
import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'vs/base/browser/ui/mouseCursor/mouseCursor';
import { ColorId, ITokenPresentation, TokenizationRegistry } from 'vs/editor/common/languages';
import { Color } from 'vs/base/common/color';
export interface ITextAreaHandlerHelper {
visibleRangeForPositionRelativeToEditor(lineNumber: number, column: number): HorizontalPosition | null;
export interface IVisibleRangeProvider {
visibleRangeForPosition(position: Position): HorizontalPosition | null;
}
class VisibleTextAreaData {
_visibleTextAreaBrand: void = undefined;
public readonly top: number;
public readonly left: number;
public readonly width: number;
public startPosition: Position | null = null;
public endPosition: Position | null = null;
constructor(top: number, left: number, width: number) {
this.top = top;
this.left = left;
this.width = width;
public visibleTextareaStart: HorizontalPosition | null = null;
public visibleTextareaEnd: HorizontalPosition | null = null;
/**
* When doing composition, the currently composed text might be split up into
* multiple tokens, then merged again into a single token, etc. Here we attempt
* to keep the presentation of the <textarea> stable by using the previous used
* style if multiple tokens come into play. This avoids flickering.
*/
private _previousPresentation: ITokenPresentation | null = null;
constructor(
private readonly _context: ViewContext,
public readonly modelLineNumber: number,
public readonly distanceToModelLineStart: number,
public readonly widthOfHiddenLineTextBefore: number,
public readonly distanceToModelLineEnd: number,
) {
}
public setWidth(width: number): VisibleTextAreaData {
return new VisibleTextAreaData(this.top, this.left, width);
prepareRender(visibleRangeProvider: IVisibleRangeProvider): void {
const startModelPosition = new Position(this.modelLineNumber, this.distanceToModelLineStart + 1);
const endModelPosition = new Position(this.modelLineNumber, this._context.viewModel.model.getLineMaxColumn(this.modelLineNumber) - this.distanceToModelLineEnd);
this.startPosition = this._context.viewModel.coordinatesConverter.convertModelPositionToViewPosition(startModelPosition);
this.endPosition = this._context.viewModel.coordinatesConverter.convertModelPositionToViewPosition(endModelPosition);
if (this.startPosition.lineNumber === this.endPosition.lineNumber) {
this.visibleTextareaStart = visibleRangeProvider.visibleRangeForPosition(this.startPosition);
this.visibleTextareaEnd = visibleRangeProvider.visibleRangeForPosition(this.endPosition);
} else {
// TODO: what if the view positions are not on the same line?
this.visibleTextareaStart = null;
this.visibleTextareaEnd = null;
}
}
definePresentation(tokenPresentation: ITokenPresentation | null): ITokenPresentation {
if (!this._previousPresentation) {
// To avoid flickering, once set, always reuse a presentation throughout the entire IME session
if (tokenPresentation) {
this._previousPresentation = tokenPresentation;
} else {
this._previousPresentation = {
foreground: ColorId.DefaultForeground,
italic: false,
bold: false,
underline: false,
strikethrough: false,
};
}
}
return this._previousPresentation;
}
}
@@ -59,7 +105,7 @@ const canUseZeroSizeTextarea = (browser.isFirefox);
export class TextAreaHandler extends ViewPart {
private readonly _viewController: ViewController;
private readonly _viewHelper: ITextAreaHandlerHelper;
private readonly _visibleRangeProvider: IVisibleRangeProvider;
private _scrollLeft: number;
private _scrollTop: number;
@@ -90,11 +136,11 @@ export class TextAreaHandler extends ViewPart {
public readonly textAreaCover: FastDomNode<HTMLElement>;
private readonly _textAreaInput: TextAreaInput;
constructor(context: ViewContext, viewController: ViewController, viewHelper: ITextAreaHandlerHelper) {
constructor(context: ViewContext, viewController: ViewController, visibleRangeProvider: IVisibleRangeProvider) {
super(context);
this._viewController = viewController;
this._viewHelper = viewHelper;
this._visibleRangeProvider = visibleRangeProvider;
this._scrollLeft = 0;
this._scrollTop = 0;
@@ -141,20 +187,20 @@ export class TextAreaHandler extends ViewPart {
const simpleModel: ISimpleModel = {
getLineCount: (): number => {
return this._context.model.getLineCount();
return this._context.viewModel.getLineCount();
},
getLineMaxColumn: (lineNumber: number): number => {
return this._context.model.getLineMaxColumn(lineNumber);
return this._context.viewModel.getLineMaxColumn(lineNumber);
},
getValueInRange: (range: Range, eol: EndOfLinePreference): string => {
return this._context.model.getValueInRange(range, eol);
return this._context.viewModel.getValueInRange(range, eol);
}
};
const textAreaInputHost: ITextAreaInputHost = {
getDataToCopy: (generateHTML: boolean): ClipboardDataToCopy => {
const rawTextToCopy = this._context.model.getPlainTextToCopy(this._modelSelections, this._emptySelectionClipboard, platform.isWindows);
const newLineCharacter = this._context.model.getEOL();
getDataToCopy: (): ClipboardDataToCopy => {
const rawTextToCopy = this._context.viewModel.getPlainTextToCopy(this._modelSelections, this._emptySelectionClipboard, platform.isWindows);
const newLineCharacter = this._context.viewModel.model.getEOL();
const isFromEmptySelection = (this._emptySelectionClipboard && this._modelSelections.length === 1 && this._modelSelections[0].isEmpty());
const multicursorText = (Array.isArray(rawTextToCopy) ? rawTextToCopy : null);
@@ -162,13 +208,11 @@ export class TextAreaHandler extends ViewPart {
let html: string | null | undefined = undefined;
let mode: string | null = null;
if (generateHTML) {
if (CopyOptions.forceCopyWithSyntaxHighlighting || (this._copyWithSyntaxHighlighting && text.length < 65536)) {
const richText = this._context.model.getRichTextToCopy(this._modelSelections, this._emptySelectionClipboard);
if (richText) {
html = richText.html;
mode = richText.mode;
}
if (CopyOptions.forceCopyWithSyntaxHighlighting || (this._copyWithSyntaxHighlighting && text.length < 65536)) {
const richText = this._context.viewModel.getRichTextToCopy(this._modelSelections, this._emptySelectionClipboard);
if (richText) {
html = richText.html;
mode = richText.mode;
}
}
return {
@@ -184,21 +228,28 @@ export class TextAreaHandler extends ViewPart {
// We know for a fact that a screen reader is not attached
// On OSX, we write the character before the cursor to allow for "long-press" composition
// Also on OSX, we write the word before the cursor to allow for the Accessibility Keyboard to give good hints
if (platform.isMacintosh) {
const selection = this._selections[0];
if (selection.isEmpty()) {
const position = selection.getStartPosition();
const selection = this._selections[0];
if (platform.isMacintosh && selection.isEmpty()) {
const position = selection.getStartPosition();
let textBefore = this._getWordBeforePosition(position);
if (textBefore.length === 0) {
textBefore = this._getCharacterBeforePosition(position);
}
let textBefore = this._getWordBeforePosition(position);
if (textBefore.length === 0) {
textBefore = this._getCharacterBeforePosition(position);
}
if (textBefore.length > 0) {
return new TextAreaState(textBefore, textBefore.length, textBefore.length, position, position);
}
if (textBefore.length > 0) {
return new TextAreaState(textBefore, textBefore.length, textBefore.length, position, position);
}
}
// on Safari, document.execCommand('cut') and document.execCommand('copy') will just not work
// if the textarea has no content selected. So if there is an editor selection, ensure something
// is selected in the textarea.
if (browser.isSafari && !selection.isEmpty()) {
const placeholderText = 'vscode-placeholder';
return new TextAreaState(placeholderText, 0, placeholderText.length, null, null);
}
return TextAreaState.EMPTY;
}
@@ -222,11 +273,12 @@ export class TextAreaHandler extends ViewPart {
},
deduceModelPosition: (viewAnchorPosition: Position, deltaOffset: number, lineFeedCnt: number): Position => {
return this._context.model.deduceModelPositionRelativeToViewPosition(viewAnchorPosition, deltaOffset, lineFeedCnt);
return this._context.viewModel.deduceModelPositionRelativeToViewPosition(viewAnchorPosition, deltaOffset, lineFeedCnt);
}
};
this._textAreaInput = this._register(new TextAreaInput(textAreaInputHost, this.textArea));
const textAreaWrapper = this._register(new TextAreaWrapper(this.textArea.domNode));
this._textAreaInput = this._register(new TextAreaInput(textAreaInputHost, textAreaWrapper, platform.OS, browser));
this._register(this._textAreaInput.onKeyDown((e: IKeyboardEvent) => {
this._viewController.emitKeyDown(e);
@@ -272,42 +324,95 @@ export class TextAreaHandler extends ViewPart {
}));
this._register(this._textAreaInput.onCompositionStart((e) => {
const lineNumber = this._selections[0].startLineNumber;
const column = this._selections[0].startColumn + e.revealDeltaColumns;
this._context.model.revealRange(
// The textarea might contain some content when composition starts.
//
// When we make the textarea visible, it always has a height of 1 line,
// so we don't need to worry too much about content on lines above or below
// the selection.
//
// However, the text on the current line needs to be made visible because
// some IME methods allow to move to other glyphs on the current line
// (by pressing arrow keys).
//
// (1) The textarea might contain only some parts of the current line,
// like the word before the selection. Also, the content inside the textarea
// can grow or shrink as composition occurs. We therefore anchor the textarea
// in terms of distance to a certain line start and line end.
//
// (2) Also, we should not make \t characters visible, because their rendering
// inside the <textarea> will not align nicely with our rendering. We therefore
// will hide (if necessary) some of the leading text on the current line.
const ta = this.textArea.domNode;
const modelSelection = this._modelSelections[0];
const { distanceToModelLineStart, widthOfHiddenTextBefore } = (() => {
// Find the text that is on the current line before the selection
const textBeforeSelection = ta.value.substring(0, Math.min(ta.selectionStart, ta.selectionEnd));
const lineFeedOffset1 = textBeforeSelection.lastIndexOf('\n');
const lineTextBeforeSelection = textBeforeSelection.substring(lineFeedOffset1 + 1);
// We now search to see if we should hide some part of it (if it contains \t)
const tabOffset1 = lineTextBeforeSelection.lastIndexOf('\t');
const desiredVisibleBeforeCharCount = lineTextBeforeSelection.length - tabOffset1 - 1;
const startModelPosition = modelSelection.getStartPosition();
const visibleBeforeCharCount = Math.min(startModelPosition.column - 1, desiredVisibleBeforeCharCount);
const distanceToModelLineStart = startModelPosition.column - 1 - visibleBeforeCharCount;
const hiddenLineTextBefore = lineTextBeforeSelection.substring(0, lineTextBeforeSelection.length - visibleBeforeCharCount);
const widthOfHiddenTextBefore = measureText(hiddenLineTextBefore, this._fontInfo);
return { distanceToModelLineStart, widthOfHiddenTextBefore };
})();
const { distanceToModelLineEnd } = (() => {
// Find the text that is on the current line after the selection
const textAfterSelection = ta.value.substring(Math.max(ta.selectionStart, ta.selectionEnd));
const lineFeedOffset2 = textAfterSelection.indexOf('\n');
const lineTextAfterSelection = lineFeedOffset2 === -1 ? textAfterSelection : textAfterSelection.substring(0, lineFeedOffset2);
const tabOffset2 = lineTextAfterSelection.indexOf('\t');
const desiredVisibleAfterCharCount = (tabOffset2 === -1 ? lineTextAfterSelection.length : lineTextAfterSelection.length - tabOffset2 - 1);
const endModelPosition = modelSelection.getEndPosition();
const visibleAfterCharCount = Math.min(this._context.viewModel.model.getLineMaxColumn(endModelPosition.lineNumber) - endModelPosition.column, desiredVisibleAfterCharCount);
const distanceToModelLineEnd = this._context.viewModel.model.getLineMaxColumn(endModelPosition.lineNumber) - endModelPosition.column - visibleAfterCharCount;
return { distanceToModelLineEnd };
})();
// Scroll to reveal the location in the editor where composition occurs
this._context.viewModel.revealRange(
'keyboard',
true,
new Range(lineNumber, column, lineNumber, column),
Range.fromPositions(this._selections[0].getStartPosition()),
viewEvents.VerticalRevealType.Simple,
ScrollType.Immediate
);
// Find range pixel position
const visibleRange = this._viewHelper.visibleRangeForPositionRelativeToEditor(lineNumber, column);
this._visibleTextArea = new VisibleTextAreaData(
this._context,
modelSelection.startLineNumber,
distanceToModelLineStart,
widthOfHiddenTextBefore,
distanceToModelLineEnd,
);
if (visibleRange) {
this._visibleTextArea = new VisibleTextAreaData(
this._context.viewLayout.getVerticalOffsetForLineNumber(lineNumber),
visibleRange.left,
canUseZeroSizeTextarea ? 0 : 1
);
this._render();
}
this._visibleTextArea.prepareRender(this._visibleRangeProvider);
this._render();
// Show the textarea
this.textArea.setClassName(`inputarea ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME} ime-input`);
this._viewController.compositionStart();
this._context.model.onCompositionStart();
this._context.viewModel.onCompositionStart();
}));
this._register(this._textAreaInput.onCompositionUpdate((e: ICompositionData) => {
if (!this._visibleTextArea) {
return;
}
// adjust width by its size
this._visibleTextArea = this._visibleTextArea.setWidth(measureText(e.data, this._fontInfo));
this._visibleTextArea.prepareRender(this._visibleRangeProvider);
this._render();
}));
@@ -318,15 +423,15 @@ export class TextAreaHandler extends ViewPart {
this.textArea.setClassName(`inputarea ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`);
this._viewController.compositionEnd();
this._context.model.onCompositionEnd();
this._context.viewModel.onCompositionEnd();
}));
this._register(this._textAreaInput.onFocus(() => {
this._context.model.setHasFocus(true);
this._context.viewModel.setHasFocus(true);
}));
this._register(this._textAreaInput.onBlur(() => {
this._context.model.setHasFocus(false);
this._context.viewModel.setHasFocus(false);
}));
}
@@ -336,7 +441,7 @@ export class TextAreaHandler extends ViewPart {
private _getAndroidWordAtPosition(position: Position): [string, number] {
const ANDROID_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:",.<>/?';
const lineContent = this._context.model.getLineContent(position.lineNumber);
const lineContent = this._context.viewModel.getLineContent(position.lineNumber);
const wordSeparators = getMapForWordSeparators(ANDROID_WORD_SEPARATORS);
let goingLeft = true;
@@ -376,7 +481,7 @@ export class TextAreaHandler extends ViewPart {
}
private _getWordBeforePosition(position: Position): string {
const lineContent = this._context.model.getLineContent(position.lineNumber);
const lineContent = this._context.viewModel.getLineContent(position.lineNumber);
const wordSeparators = getMapForWordSeparators(this._context.configuration.options.get(EditorOption.wordSeparators));
let column = position.column;
@@ -395,7 +500,7 @@ export class TextAreaHandler extends ViewPart {
private _getCharacterBeforePosition(position: Position): string {
if (position.column > 1) {
const lineContent = this._context.model.getLineContent(position.lineNumber);
const lineContent = this._context.viewModel.getLineContent(position.lineNumber);
const charBefore = lineContent.charAt(position.column - 2);
if (!strings.isHighSurrogate(charBefore.charCodeAt(0))) {
return charBefore;
@@ -528,6 +633,9 @@ export class TextAreaHandler extends ViewPart {
public prepareRender(ctx: RenderingContext): void {
this._primaryCursorPosition = new Position(this._selections[0].positionLineNumber, this._selections[0].positionColumn);
this._primaryCursorVisibleRange = ctx.visibleRangeForPosition(this._primaryCursorPosition);
if (this._visibleTextArea) {
this._visibleTextArea.prepareRender(ctx);
}
}
public render(ctx: RestrictedRenderingContext): void {
@@ -538,13 +646,66 @@ export class TextAreaHandler extends ViewPart {
private _render(): void {
if (this._visibleTextArea) {
// The text area is visible for composition reasons
this._renderInsideEditor(
null,
this._visibleTextArea.top - this._scrollTop,
this._contentLeft + this._visibleTextArea.left - this._scrollLeft,
this._visibleTextArea.width,
this._lineHeight
);
const visibleStart = this._visibleTextArea.visibleTextareaStart;
const visibleEnd = this._visibleTextArea.visibleTextareaEnd;
const startPosition = this._visibleTextArea.startPosition;
const endPosition = this._visibleTextArea.endPosition;
if (startPosition && endPosition && visibleStart && visibleEnd && visibleEnd.left >= this._scrollLeft && visibleStart.left <= this._scrollLeft + this._contentWidth) {
const top = (this._context.viewLayout.getVerticalOffsetForLineNumber(this._primaryCursorPosition.lineNumber) - this._scrollTop);
const lineCount = this._newlinecount(this.textArea.domNode.value.substr(0, this.textArea.domNode.selectionStart));
let scrollLeft = this._visibleTextArea.widthOfHiddenLineTextBefore;
let left = (this._contentLeft + visibleStart.left - this._scrollLeft);
// See https://github.com/microsoft/vscode/issues/141725#issuecomment-1050670841
// Here we are adding +1 to avoid flickering that might be caused by having a width that is too small.
// This could be caused by rounding errors that might only show up with certain font families.
// In other words, a pixel might be lost when doing something like
// `Math.round(end) - Math.round(start)`
// vs
// `Math.round(end - start)`
let width = visibleEnd.left - visibleStart.left + 1;
if (left < this._contentLeft) {
// the textarea would be rendered on top of the margin,
// so reduce its width. We use the same technique as
// for hiding text before
const delta = (this._contentLeft - left);
left += delta;
scrollLeft += delta;
width -= delta;
}
if (width > this._contentWidth) {
// the textarea would be wider than the content width,
// so reduce its width.
width = this._contentWidth;
}
// Try to render the textarea with the color/font style to match the text under it
const viewLineData = this._context.viewModel.getViewLineData(startPosition.lineNumber);
const startTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(startPosition.column - 1);
const endTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(endPosition.column - 1);
const textareaSpansSingleToken = (startTokenIndex === endTokenIndex);
const presentation = this._visibleTextArea.definePresentation(
(textareaSpansSingleToken ? viewLineData.tokens.getPresentation(startTokenIndex) : null)
);
this.textArea.domNode.scrollTop = lineCount * this._lineHeight;
this.textArea.domNode.scrollLeft = scrollLeft;
this._doRender({
lastRenderPosition: null,
top: top,
left: left,
width: width,
height: this._lineHeight,
useCover: false,
color: (TokenizationRegistry.getColorMap() || [])[presentation.foreground],
italic: presentation.italic,
bold: presentation.bold,
underline: presentation.underline,
strikethrough: presentation.strikethrough
});
}
return;
}
@@ -573,68 +734,82 @@ export class TextAreaHandler extends ViewPart {
if (platform.isMacintosh) {
// For the popup emoji input, we will make the text area as high as the line height
// We will also make the fontSize and lineHeight the correct dimensions to help with the placement of these pickers
this._renderInsideEditor(
this._primaryCursorPosition,
top, left,
canUseZeroSizeTextarea ? 0 : 1, this._lineHeight
);
this._doRender({
lastRenderPosition: this._primaryCursorPosition,
top: top,
left: left,
width: (canUseZeroSizeTextarea ? 0 : 1),
height: this._lineHeight,
useCover: false
});
// In case the textarea contains a word, we're going to try to align the textarea's cursor
// with our cursor by scrolling the textarea as much as possible
this.textArea.domNode.scrollLeft = 1000000;
this.textArea.domNode.scrollLeft = this._primaryCursorVisibleRange.left;
const lineCount = this._newlinecount(this.textArea.domNode.value.substr(0, this.textArea.domNode.selectionStart));
this.textArea.domNode.scrollTop = lineCount * this._lineHeight;
return;
}
this._renderInsideEditor(
this._primaryCursorPosition,
top, left,
canUseZeroSizeTextarea ? 0 : 1, canUseZeroSizeTextarea ? 0 : 1
);
this._doRender({
lastRenderPosition: this._primaryCursorPosition,
top: top,
left: left,
width: (canUseZeroSizeTextarea ? 0 : 1),
height: (canUseZeroSizeTextarea ? 0 : 1),
useCover: false
});
}
private _renderInsideEditor(renderedPosition: Position | null, top: number, left: number, width: number, height: number): void {
this._lastRenderPosition = renderedPosition;
const ta = this.textArea;
const tac = this.textAreaCover;
Configuration.applyFontInfo(ta, this._fontInfo);
ta.setTop(top);
ta.setLeft(left);
ta.setWidth(width);
ta.setHeight(height);
tac.setTop(0);
tac.setLeft(0);
tac.setWidth(0);
tac.setHeight(0);
private _newlinecount(text: string): number {
let result = 0;
let startIndex = -1;
do {
startIndex = text.indexOf('\n', startIndex + 1);
if (startIndex === -1) {
break;
}
result++;
} while (true);
return result;
}
private _renderAtTopLeft(): void {
this._lastRenderPosition = null;
// (in WebKit the textarea is 1px by 1px because it cannot handle input to a 0x0 textarea)
// specifically, when doing Korean IME, setting the textarea to 0x0 breaks IME badly.
this._doRender({
lastRenderPosition: null,
top: 0,
left: 0,
width: (canUseZeroSizeTextarea ? 0 : 1),
height: (canUseZeroSizeTextarea ? 0 : 1),
useCover: true
});
}
private _doRender(renderData: IRenderData): void {
this._lastRenderPosition = renderData.lastRenderPosition;
const ta = this.textArea;
const tac = this.textAreaCover;
Configuration.applyFontInfo(ta, this._fontInfo);
ta.setTop(0);
ta.setLeft(0);
tac.setTop(0);
tac.setLeft(0);
applyFontInfo(ta, this._fontInfo);
ta.setTop(renderData.top);
ta.setLeft(renderData.left);
ta.setWidth(renderData.width);
ta.setHeight(renderData.height);
if (canUseZeroSizeTextarea) {
ta.setWidth(0);
ta.setHeight(0);
tac.setWidth(0);
tac.setHeight(0);
return;
ta.setColor(renderData.color ? Color.Format.CSS.formatHex(renderData.color) : '');
ta.setFontStyle(renderData.italic ? 'italic' : '');
if (renderData.bold) {
// fontWeight is also set by `applyFontInfo`, so only overwrite it if necessary
ta.setFontWeight('bold');
}
ta.setTextDecoration(`${renderData.underline ? ' underline' : ''}${renderData.strikethrough ? ' line-through' : ''}`);
// (in WebKit the textarea is 1px by 1px because it cannot handle input to a 0x0 textarea)
// specifically, when doing Korean IME, setting the textarea to 0x0 breaks IME badly.
ta.setWidth(1);
ta.setHeight(1);
tac.setWidth(1);
tac.setHeight(1);
tac.setTop(renderData.useCover ? renderData.top : 0);
tac.setLeft(renderData.useCover ? renderData.left : 0);
tac.setWidth(renderData.useCover ? renderData.width : 0);
tac.setHeight(renderData.useCover ? renderData.height : 0);
const options = this._context.configuration.options;
@@ -650,28 +825,42 @@ export class TextAreaHandler extends ViewPart {
}
}
interface IRenderData {
lastRenderPosition: Position | null;
top: number;
left: number;
width: number;
height: number;
useCover: boolean;
color?: Color | null;
italic?: boolean;
bold?: boolean;
underline?: boolean;
strikethrough?: boolean;
}
function measureText(text: string, fontInfo: BareFontInfo): number {
// adjust width by its size
const canvasElem = <HTMLCanvasElement>document.createElement('canvas');
const context = canvasElem.getContext('2d')!;
context.font = createFontString(fontInfo);
const metrics = context.measureText(text);
if (browser.isFirefox) {
return metrics.width + 2; // +2 for Japanese...
} else {
return metrics.width;
if (text.length === 0) {
return 0;
}
}
function createFontString(bareFontInfo: BareFontInfo): string {
return doCreateFontString('normal', bareFontInfo.fontWeight, bareFontInfo.fontSize, bareFontInfo.lineHeight, bareFontInfo.fontFamily);
}
const container = document.createElement('div');
container.style.position = 'absolute';
container.style.top = '-50000px';
container.style.width = '50000px';
function doCreateFontString(fontStyle: string, fontWeight: string, fontSize: number, lineHeight: number, fontFamily: string): string {
// The full font syntax is:
// style | variant | weight | stretch | size/line-height | fontFamily
// (https://developer.mozilla.org/en-US/docs/Web/CSS/font)
// But it appears Edge and IE11 cannot properly parse `stretch`.
return `${fontStyle} normal ${fontWeight} ${fontSize}px / ${lineHeight}px ${fontFamily}`;
const regularDomNode = document.createElement('span');
applyFontInfo(regularDomNode, fontInfo);
regularDomNode.style.whiteSpace = 'pre'; // just like the textarea
regularDomNode.append(text);
container.appendChild(regularDomNode);
document.body.appendChild(container);
const res = regularDomNode.offsetWidth;
document.body.removeChild(container);
return res;
}

454
src/vs/editor/browser/controller/textAreaInput.ts
View File

@@ -5,14 +5,13 @@
import * as browser from 'vs/base/browser/browser';
import * as dom from 'vs/base/browser/dom';
import { FastDomNode } from 'vs/base/browser/fastDomNode';
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { IKeyboardEvent, StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { RunOnceScheduler } from 'vs/base/common/async';
import { Emitter, Event } from 'vs/base/common/event';
import { KeyCode } from 'vs/base/common/keyCodes';
import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
import { Mimes } from 'vs/base/common/mime';
import * as platform from 'vs/base/common/platform';
import { OperatingSystem } from 'vs/base/common/platform';
import * as strings from 'vs/base/common/strings';
import { ITextAreaWrapper, ITypeData, TextAreaState, _debugComposition } from 'vs/editor/browser/controller/textAreaState';
import { Position } from 'vs/editor/common/core/position';
@@ -30,11 +29,6 @@ export const CopyOptions = {
forceCopyWithSyntaxHighlighting: false
};
const enum ReadFromTextArea {
Type,
Paste
}
export interface IPasteData {
text: string;
metadata: ClipboardStoredMetadata | null;
@@ -56,16 +50,11 @@ export interface ClipboardStoredMetadata {
}
export interface ITextAreaInputHost {
getDataToCopy(html: boolean): ClipboardDataToCopy;
getDataToCopy(): ClipboardDataToCopy;
getScreenReaderContent(currentState: TextAreaState): TextAreaState;
deduceModelPosition(viewAnchorPosition: Position, deltaOffset: number, lineFeedCnt: number): Position;
}
interface CompositionEvent extends UIEvent {
readonly data: string;
readonly locale: string;
}
interface InMemoryClipboardMetadata {
lastCopiedValue: string;
data: ClipboardStoredMetadata;
@@ -100,7 +89,58 @@ export class InMemoryClipboardMetadataManager {
}
export interface ICompositionStartEvent {
revealDeltaColumns: number;
data: string;
}
export interface ICompleteTextAreaWrapper extends ITextAreaWrapper {
readonly onKeyDown: Event<KeyboardEvent>;
readonly onKeyPress: Event<KeyboardEvent>;
readonly onKeyUp: Event<KeyboardEvent>;
readonly onCompositionStart: Event<CompositionEvent>;
readonly onCompositionUpdate: Event<CompositionEvent>;
readonly onCompositionEnd: Event<CompositionEvent>;
readonly onBeforeInput: Event<InputEvent>;
readonly onInput: Event<InputEvent>;
readonly onCut: Event<ClipboardEvent>;
readonly onCopy: Event<ClipboardEvent>;
readonly onPaste: Event<ClipboardEvent>;
readonly onFocus: Event<FocusEvent>;
readonly onBlur: Event<FocusEvent>;
readonly onSyntheticTap: Event<void>;
setIgnoreSelectionChangeTime(reason: string): void;
getIgnoreSelectionChangeTime(): number;
resetSelectionChangeTime(): void;
hasFocus(): boolean;
}
export interface IBrowser {
isAndroid: boolean;
isFirefox: boolean;
isChrome: boolean;
isSafari: boolean;
}
class CompositionContext {
private _lastTypeTextLength: number;
constructor() {
this._lastTypeTextLength = 0;
}
public handleCompositionUpdate(text: string | null | undefined): ITypeData {
text = text || '';
const typeInput: ITypeData = {
text: text,
replacePrevCharCnt: this._lastTypeTextLength,
replaceNextCharCnt: 0,
positionDelta: 0
};
this._lastTypeTextLength = text.length;
return typeInput;
}
}
/**
@@ -148,8 +188,6 @@ export class TextAreaInput extends Disposable {
// ---
private readonly _host: ITextAreaInputHost;
private readonly _textArea: TextAreaWrapper;
private readonly _asyncTriggerCut: RunOnceScheduler;
private readonly _asyncFocusGainWriteScreenReaderContent: RunOnceScheduler;
@@ -157,13 +195,15 @@ export class TextAreaInput extends Disposable {
private _selectionChangeListener: IDisposable | null;
private _hasFocus: boolean;
private _isDoingComposition: boolean;
private _nextCommand: ReadFromTextArea;
private _currentComposition: CompositionContext | null;
constructor(host: ITextAreaInputHost, private textArea: FastDomNode<HTMLTextAreaElement>) {
constructor(
private readonly _host: ITextAreaInputHost,
private readonly _textArea: ICompleteTextAreaWrapper,
private readonly _OS: OperatingSystem,
private readonly _browser: IBrowser
) {
super();
this._host = host;
this._textArea = this._register(new TextAreaWrapper(textArea));
this._asyncTriggerCut = this._register(new RunOnceScheduler(() => this._onCut.fire(), 0));
this._asyncFocusGainWriteScreenReaderContent = this._register(new RunOnceScheduler(() => this.writeScreenReaderContent('asyncFocusGain'), 0));
@@ -172,14 +212,14 @@ export class TextAreaInput extends Disposable {
this.writeScreenReaderContent('ctor');
this._hasFocus = false;
this._isDoingComposition = false;
this._nextCommand = ReadFromTextArea.Type;
this._currentComposition = null;
let lastKeyDown: IKeyboardEvent | null = null;
this._register(dom.addStandardDisposableListener(textArea.domNode, 'keydown', (e: IKeyboardEvent) => {
this._register(this._textArea.onKeyDown((_e) => {
const e = new StandardKeyboardEvent(_e);
if (e.keyCode === KeyCode.KEY_IN_COMPOSITION
|| (this._isDoingComposition && e.keyCode === KeyCode.Backspace)) {
|| (this._currentComposition && e.keyCode === KeyCode.Backspace)) {
// Stop propagation for keyDown events if the IME is processing key input
e.stopPropagation();
}
@@ -194,178 +234,146 @@ export class TextAreaInput extends Disposable {
this._onKeyDown.fire(e);
}));
this._register(dom.addStandardDisposableListener(textArea.domNode, 'keyup', (e: IKeyboardEvent) => {
this._register(this._textArea.onKeyUp((_e) => {
const e = new StandardKeyboardEvent(_e);
this._onKeyUp.fire(e);
}));
this._register(dom.addDisposableListener(textArea.domNode, 'compositionstart', (e: CompositionEvent) => {
this._register(this._textArea.onCompositionStart((e) => {
if (_debugComposition) {
console.log(`[compositionstart]`, e);
}
if (this._isDoingComposition) {
const currentComposition = new CompositionContext();
if (this._currentComposition) {
// simply reset the composition context
this._currentComposition = currentComposition;
return;
}
this._isDoingComposition = true;
this._currentComposition = currentComposition;
if (
platform.isMacintosh
this._OS === OperatingSystem.Macintosh
&& lastKeyDown
&& lastKeyDown.equals(KeyCode.KEY_IN_COMPOSITION)
&& this._textAreaState.selectionStart === this._textAreaState.selectionEnd
&& this._textAreaState.selectionStart > 0
&& this._textAreaState.value.substr(this._textAreaState.selectionStart - 1, 1) === e.data
&& (lastKeyDown.code === 'ArrowRight' || lastKeyDown.code === 'ArrowLeft')
) {
const isArrowKey = (
lastKeyDown && lastKeyDown.equals(KeyCode.KEY_IN_COMPOSITION)
&& (lastKeyDown.code === 'ArrowRight' || lastKeyDown.code === 'ArrowLeft')
);
if (isArrowKey || browser.isFirefox) {
// Handling long press case on Chromium/Safari macOS + arrow key => pretend the character was selected
// or long press case on Firefox on macOS
if (_debugComposition) {
console.log(`[compositionstart] Handling long press case on macOS + arrow key or Firefox`, e);
}
this._textAreaState = new TextAreaState(
this._textAreaState.value,
this._textAreaState.selectionStart - 1,
this._textAreaState.selectionEnd,
this._textAreaState.selectionStartPosition ? new Position(this._textAreaState.selectionStartPosition.lineNumber, this._textAreaState.selectionStartPosition.column - 1) : null,
this._textAreaState.selectionEndPosition
);
this._onCompositionStart.fire({ revealDeltaColumns: -1 });
return;
// Handling long press case on Chromium/Safari macOS + arrow key => pretend the character was selected
if (_debugComposition) {
console.log(`[compositionstart] Handling long press case on macOS + arrow key`, e);
}
}
if (browser.isAndroid) {
// when tapping on the editor, Android enters composition mode to edit the current word
// so we cannot clear the textarea on Android and we must pretend the current word was selected
this._onCompositionStart.fire({ revealDeltaColumns: -this._textAreaState.selectionStart });
// Pretend the previous character was composed (in order to get it removed by subsequent compositionupdate events)
currentComposition.handleCompositionUpdate('x');
this._onCompositionStart.fire({ data: e.data });
return;
}
this._setAndWriteTextAreaState('compositionstart', TextAreaState.EMPTY);
this._onCompositionStart.fire({ revealDeltaColumns: 0 });
if (this._browser.isAndroid) {
// when tapping on the editor, Android enters composition mode to edit the current word
// so we cannot clear the textarea on Android and we must pretend the current word was selected
this._onCompositionStart.fire({ data: e.data });
return;
}
this._onCompositionStart.fire({ data: e.data });
}));
/**
* Deduce the typed input from a text area's value and the last observed state.
*/
const deduceInputFromTextAreaValue = (couldBeEmojiInput: boolean): [TextAreaState, ITypeData] => {
const oldState = this._textAreaState;
const newState = TextAreaState.readFromTextArea(this._textArea);
return [newState, TextAreaState.deduceInput(oldState, newState, couldBeEmojiInput)];
};
const deduceAndroidCompositionInput = (): [TextAreaState, ITypeData] => {
const oldState = this._textAreaState;
const newState = TextAreaState.readFromTextArea(this._textArea);
return [newState, TextAreaState.deduceAndroidCompositionInput(oldState, newState)];
};
/**
* Deduce the composition input from a string.
*/
const deduceComposition = (text: string): [TextAreaState, ITypeData] => {
const oldState = this._textAreaState;
const newState = TextAreaState.selectedText(text);
const typeInput: ITypeData = {
text: newState.value,
replacePrevCharCnt: oldState.selectionEnd - oldState.selectionStart,
replaceNextCharCnt: 0,
positionDelta: 0
};
return [newState, typeInput];
};
this._register(dom.addDisposableListener(textArea.domNode, 'compositionupdate', (e: CompositionEvent) => {
this._register(this._textArea.onCompositionUpdate((e) => {
if (_debugComposition) {
console.log(`[compositionupdate]`, e);
}
if (browser.isAndroid) {
const currentComposition = this._currentComposition;
if (!currentComposition) {
// should not be possible to receive a 'compositionupdate' without a 'compositionstart'
return;
}
if (this._browser.isAndroid) {
// On Android, the data sent with the composition update event is unusable.
// For example, if the cursor is in the middle of a word like Mic|osoft
// and Microsoft is chosen from the keyboard's suggestions, the e.data will contain "Microsoft".
// This is not really usable because it doesn't tell us where the edit began and where it ended.
const [newState, typeInput] = deduceAndroidCompositionInput();
const newState = TextAreaState.readFromTextArea(this._textArea);
const typeInput = TextAreaState.deduceAndroidCompositionInput(this._textAreaState, newState);
this._textAreaState = newState;
this._onType.fire(typeInput);
this._onCompositionUpdate.fire(e);
return;
}
const [newState, typeInput] = deduceComposition(e.data || '');
this._textAreaState = newState;
const typeInput = currentComposition.handleCompositionUpdate(e.data);
this._textAreaState = TextAreaState.readFromTextArea(this._textArea);
this._onType.fire(typeInput);
this._onCompositionUpdate.fire(e);
}));
this._register(dom.addDisposableListener(textArea.domNode, 'compositionend', (e: CompositionEvent) => {
this._register(this._textArea.onCompositionEnd((e) => {
if (_debugComposition) {
console.log(`[compositionend]`, e);
}
// https://github.com/microsoft/monaco-editor/issues/1663
// On iOS 13.2, Chinese system IME randomly trigger an additional compositionend event with empty data
if (!this._isDoingComposition) {
const currentComposition = this._currentComposition;
if (!currentComposition) {
// https://github.com/microsoft/monaco-editor/issues/1663
// On iOS 13.2, Chinese system IME randomly trigger an additional compositionend event with empty data
return;
}
this._isDoingComposition = false;
this._currentComposition = null;
if (browser.isAndroid) {
if (this._browser.isAndroid) {
// On Android, the data sent with the composition update event is unusable.
// For example, if the cursor is in the middle of a word like Mic|osoft
// and Microsoft is chosen from the keyboard's suggestions, the e.data will contain "Microsoft".
// This is not really usable because it doesn't tell us where the edit began and where it ended.
const [newState, typeInput] = deduceAndroidCompositionInput();
const newState = TextAreaState.readFromTextArea(this._textArea);
const typeInput = TextAreaState.deduceAndroidCompositionInput(this._textAreaState, newState);
this._textAreaState = newState;
this._onType.fire(typeInput);
this._onCompositionEnd.fire();
return;
}
const [newState, typeInput] = deduceComposition(e.data || '');
this._textAreaState = newState;
const typeInput = currentComposition.handleCompositionUpdate(e.data);
this._textAreaState = TextAreaState.readFromTextArea(this._textArea);
this._onType.fire(typeInput);
// isChrome: the textarea is not updated correctly when composition ends
// isFirefox: the textarea is not updated correctly after inserting emojis
// => we cannot assume the text at the end consists only of the composited text
if (browser.isChrome || browser.isFirefox) {
this._textAreaState = TextAreaState.readFromTextArea(this._textArea);
}
this._onCompositionEnd.fire();
}));
this._register(dom.addDisposableListener(textArea.domNode, 'input', () => {
this._register(this._textArea.onInput((e) => {
if (_debugComposition) {
console.log(`[input]`, e);
}
// Pretend here we touched the text area, as the `input` event will most likely
// result in a `selectionchange` event which we want to ignore
this._textArea.setIgnoreSelectionChangeTime('received input event');
if (this._isDoingComposition) {
if (this._currentComposition) {
return;
}
const [newState, typeInput] = deduceInputFromTextAreaValue(/*couldBeEmojiInput*/platform.isMacintosh);
const newState = TextAreaState.readFromTextArea(this._textArea);
const typeInput = TextAreaState.deduceInput(this._textAreaState, newState, /*couldBeEmojiInput*/this._OS === OperatingSystem.Macintosh);
if (typeInput.replacePrevCharCnt === 0 && typeInput.text.length === 1 && strings.isHighSurrogate(typeInput.text.charCodeAt(0))) {
// Ignore invalid input but keep it around for next time
return;
}
this._textAreaState = newState;
if (this._nextCommand === ReadFromTextArea.Type) {
if (typeInput.text !== '' || typeInput.replacePrevCharCnt !== 0) {
this._onType.fire(typeInput);
}
} else {
if (typeInput.text !== '' || typeInput.replacePrevCharCnt !== 0) {
this._firePaste(typeInput.text, null);
}
this._nextCommand = ReadFromTextArea.Type;
if (
typeInput.text !== ''
|| typeInput.replacePrevCharCnt !== 0
|| typeInput.replaceNextCharCnt !== 0
|| typeInput.positionDelta !== 0
) {
this._onType.fire(typeInput);
}
}));
// --- Clipboard operations
this._register(dom.addDisposableListener(textArea.domNode, 'cut', (e: ClipboardEvent) => {
this._register(this._textArea.onCut((e) => {
// Pretend here we touched the text area, as the `cut` event will most likely
// result in a `selectionchange` event which we want to ignore
this._textArea.setIgnoreSelectionChangeTime('received cut event');
@@ -374,48 +382,54 @@ export class TextAreaInput extends Disposable {
this._asyncTriggerCut.schedule();
}));
this._register(dom.addDisposableListener(textArea.domNode, 'copy', (e: ClipboardEvent) => {
this._register(this._textArea.onCopy((e) => {
this._ensureClipboardGetsEditorSelection(e);
}));
this._register(dom.addDisposableListener(textArea.domNode, 'paste', (e: ClipboardEvent) => {
this._register(this._textArea.onPaste((e) => {
// Pretend here we touched the text area, as the `paste` event will most likely
// result in a `selectionchange` event which we want to ignore
this._textArea.setIgnoreSelectionChangeTime('received paste event');
if (ClipboardEventUtils.canUseTextData(e)) {
const [pastePlainText, metadata] = ClipboardEventUtils.getTextData(e);
if (pastePlainText !== '') {
this._firePaste(pastePlainText, metadata);
}
} else {
if (this._textArea.getSelectionStart() !== this._textArea.getSelectionEnd()) {
// Clean up the textarea, to get a clean paste
this._setAndWriteTextAreaState('paste', TextAreaState.EMPTY);
}
this._nextCommand = ReadFromTextArea.Paste;
e.preventDefault();
if (!e.clipboardData) {
return;
}
let [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
if (!text) {
return;
}
// try the in-memory store
metadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
this._onPaste.fire({
text: text,
metadata: metadata
});
}));
this._register(dom.addDisposableListener(textArea.domNode, 'focus', () => {
this._register(this._textArea.onFocus(() => {
const hadFocus = this._hasFocus;
this._setHasFocus(true);
if (browser.isSafari && !hadFocus && this._hasFocus) {
if (this._browser.isSafari && !hadFocus && this._hasFocus) {
// When "tabbing into" the textarea, immediately after dispatching the 'focus' event,
// Safari will always move the selection at offset 0 in the textarea
this._asyncFocusGainWriteScreenReaderContent.schedule();
}
}));
this._register(dom.addDisposableListener(textArea.domNode, 'blur', () => {
if (this._isDoingComposition) {
this._register(this._textArea.onBlur(() => {
if (this._currentComposition) {
// See https://github.com/microsoft/vscode/issues/112621
// where compositionend is not triggered when the editor
// is taken off-dom during a composition
// Clear the flag to be able to write to the textarea
this._isDoingComposition = false;
this._currentComposition = null;
// Clear the textarea to avoid an unwanted cursor type
this.writeScreenReaderContent('blurWithoutCompositionEnd');
@@ -425,13 +439,13 @@ export class TextAreaInput extends Disposable {
}
this._setHasFocus(false);
}));
this._register(dom.addDisposableListener(textArea.domNode, TextAreaSyntethicEvents.Tap, () => {
if (browser.isAndroid && this._isDoingComposition) {
this._register(this._textArea.onSyntheticTap(() => {
if (this._browser.isAndroid && this._currentComposition) {
// on Android, tapping does not cancel the current composition, so the
// textarea is stuck showing the old composition
// Clear the flag to be able to write to the textarea
this._isDoingComposition = false;
this._currentComposition = null;
// Clear the textarea to avoid an unwanted cursor type
this.writeScreenReaderContent('tapWithoutCompositionEnd');
@@ -442,6 +456,11 @@ export class TextAreaInput extends Disposable {
}));
}
_initializeFromTest(): void {
this._hasFocus = true;
this._textAreaState = TextAreaState.readFromTextArea(this._textArea);
}
private _installSelectionChangeListener(): IDisposable {
// See https://github.com/microsoft/vscode/issues/27216 and https://github.com/microsoft/vscode/issues/98256
// When using a Braille display, it is possible for users to reposition the
@@ -466,10 +485,10 @@ export class TextAreaInput extends Disposable {
if (!this._hasFocus) {
return;
}
if (this._isDoingComposition) {
if (this._currentComposition) {
return;
}
if (!browser.isChrome) {
if (!this._browser.isChrome) {
// Support only for Chrome until testing happens on other browsers
return;
}
@@ -547,14 +566,7 @@ export class TextAreaInput extends Disposable {
}
public refreshFocusState(): void {
const shadowRoot = dom.getShadowRoot(this.textArea.domNode);
if (shadowRoot) {
this._setHasFocus(shadowRoot.activeElement === this.textArea.domNode);
} else if (dom.isInDOM(this.textArea.domNode)) {
this._setHasFocus(document.activeElement === this.textArea.domNode);
} else {
this._setHasFocus(false);
}
this._setHasFocus(this._textArea.hasFocus());
}
private _setHasFocus(newHasFocus: boolean): void {
@@ -593,7 +605,7 @@ export class TextAreaInput extends Disposable {
}
public writeScreenReaderContent(reason: string): void {
if (this._isDoingComposition) {
if (this._currentComposition) {
// Do not write to the text area when doing composition
return;
}
@@ -602,7 +614,7 @@ export class TextAreaInput extends Disposable {
}
private _ensureClipboardGetsEditorSelection(e: ClipboardEvent): void {
const dataToCopy = this._host.getDataToCopy(ClipboardEventUtils.canUseTextData(e));
const dataToCopy = this._host.getDataToCopy();
const storedMetadata: ClipboardStoredMetadata = {
version: 1,
isFromEmptySelection: dataToCopy.isFromEmptySelection,
@@ -612,89 +624,91 @@ export class TextAreaInput extends Disposable {
InMemoryClipboardMetadataManager.INSTANCE.set(
// When writing "LINE\r\n" to the clipboard and then pasting,
// Firefox pastes "LINE\n", so let's work around this quirk
(browser.isFirefox ? dataToCopy.text.replace(/\r\n/g, '\n') : dataToCopy.text),
(this._browser.isFirefox ? dataToCopy.text.replace(/\r\n/g, '\n') : dataToCopy.text),
storedMetadata
);
if (!ClipboardEventUtils.canUseTextData(e)) {
// Looks like an old browser. The strategy is to place the text
// we'd like to be copied to the clipboard in the textarea and select it.
this._setAndWriteTextAreaState('copy or cut', TextAreaState.selectedText(dataToCopy.text));
return;
e.preventDefault();
if (e.clipboardData) {
ClipboardEventUtils.setTextData(e.clipboardData, dataToCopy.text, dataToCopy.html, storedMetadata);
}
ClipboardEventUtils.setTextData(e, dataToCopy.text, dataToCopy.html, storedMetadata);
}
private _firePaste(text: string, metadata: ClipboardStoredMetadata | null): void {
if (!metadata) {
// try the in-memory store
metadata = InMemoryClipboardMetadataManager.INSTANCE.get(text);
}
this._onPaste.fire({
text: text,
metadata: metadata
});
}
}
class ClipboardEventUtils {
public static canUseTextData(e: ClipboardEvent): boolean {
if (e.clipboardData) {
return true;
}
return false;
}
public static getTextData(e: ClipboardEvent): [string, ClipboardStoredMetadata | null] {
if (e.clipboardData) {
e.preventDefault();
const text = e.clipboardData.getData(Mimes.text);
let metadata: ClipboardStoredMetadata | null = null;
const rawmetadata = e.clipboardData.getData('vscode-editor-data');
if (typeof rawmetadata === 'string') {
try {
metadata = <ClipboardStoredMetadata>JSON.parse(rawmetadata);
if (metadata.version !== 1) {
metadata = null;
}
} catch (err) {
// no problem!
public static getTextData(clipboardData: DataTransfer): [string, ClipboardStoredMetadata | null] {
const text = clipboardData.getData(Mimes.text);
let metadata: ClipboardStoredMetadata | null = null;
const rawmetadata = clipboardData.getData('vscode-editor-data');
if (typeof rawmetadata === 'string') {
try {
metadata = <ClipboardStoredMetadata>JSON.parse(rawmetadata);
if (metadata.version !== 1) {
metadata = null;
}
} catch (err) {
// no problem!
}
return [text, metadata];
}
throw new Error('ClipboardEventUtils.getTextData: Cannot use text data!');
if (text.length === 0 && metadata === null && clipboardData.files.length > 0) {
// no textual data pasted, generate text from file names
const files: File[] = Array.prototype.slice.call(clipboardData.files, 0);
return [files.map(file => file.name).join('\n'), null];
}
return [text, metadata];
}
public static setTextData(e: ClipboardEvent, text: string, html: string | null | undefined, metadata: ClipboardStoredMetadata): void {
if (e.clipboardData) {
e.clipboardData.setData(Mimes.text, text);
if (typeof html === 'string') {
e.clipboardData.setData('text/html', html);
}
e.clipboardData.setData('vscode-editor-data', JSON.stringify(metadata));
e.preventDefault();
return;
public static setTextData(clipboardData: DataTransfer, text: string, html: string | null | undefined, metadata: ClipboardStoredMetadata): void {
clipboardData.setData(Mimes.text, text);
if (typeof html === 'string') {
clipboardData.setData('text/html', html);
}
throw new Error('ClipboardEventUtils.setTextData: Cannot use text data!');
clipboardData.setData('vscode-editor-data', JSON.stringify(metadata));
}
}
class TextAreaWrapper extends Disposable implements ITextAreaWrapper {
export class TextAreaWrapper extends Disposable implements ICompleteTextAreaWrapper {
public readonly onKeyDown = this._register(dom.createEventEmitter(this._actual, 'keydown')).event;
public readonly onKeyPress = this._register(dom.createEventEmitter(this._actual, 'keypress')).event;
public readonly onKeyUp = this._register(dom.createEventEmitter(this._actual, 'keyup')).event;
public readonly onCompositionStart = this._register(dom.createEventEmitter(this._actual, 'compositionstart')).event;
public readonly onCompositionUpdate = this._register(dom.createEventEmitter(this._actual, 'compositionupdate')).event;
public readonly onCompositionEnd = this._register(dom.createEventEmitter(this._actual, 'compositionend')).event;
public readonly onBeforeInput = this._register(dom.createEventEmitter(this._actual, 'beforeinput')).event;
public readonly onInput = <Event<InputEvent>>this._register(dom.createEventEmitter(this._actual, 'input')).event;
public readonly onCut = this._register(dom.createEventEmitter(this._actual, 'cut')).event;
public readonly onCopy = this._register(dom.createEventEmitter(this._actual, 'copy')).event;
public readonly onPaste = this._register(dom.createEventEmitter(this._actual, 'paste')).event;
public readonly onFocus = this._register(dom.createEventEmitter(this._actual, 'focus')).event;
public readonly onBlur = this._register(dom.createEventEmitter(this._actual, 'blur')).event;
private _onSyntheticTap = this._register(new Emitter<void>());
public readonly onSyntheticTap: Event<void> = this._onSyntheticTap.event;
private readonly _actual: FastDomNode<HTMLTextAreaElement>;
private _ignoreSelectionChangeTime: number;
constructor(_textArea: FastDomNode<HTMLTextAreaElement>) {
constructor(
private readonly _actual: HTMLTextAreaElement
) {
super();
this._actual = _textArea;
this._ignoreSelectionChangeTime = 0;
this._register(dom.addDisposableListener(this._actual, TextAreaSyntethicEvents.Tap, () => this._onSyntheticTap.fire()));
}
public hasFocus(): boolean {
const shadowRoot = dom.getShadowRoot(this._actual);
if (shadowRoot) {
return shadowRoot.activeElement === this._actual;
} else if (dom.isInDOM(this._actual)) {
return document.activeElement === this._actual;
} else {
return false;
}
}
public setIgnoreSelectionChangeTime(reason: string): void {
@@ -711,11 +725,11 @@ class TextAreaWrapper extends Disposable implements ITextAreaWrapper {
public getValue(): string {
// console.log('current value: ' + this._textArea.value);
return this._actual.domNode.value;
return this._actual.value;
}
public setValue(reason: string, value: string): void {
const textArea = this._actual.domNode;
const textArea = this._actual;
if (textArea.value === value) {
// No change
return;
@@ -726,15 +740,15 @@ class TextAreaWrapper extends Disposable implements ITextAreaWrapper {
}
public getSelectionStart(): number {
return this._actual.domNode.selectionDirection === 'backward' ? this._actual.domNode.selectionEnd : this._actual.domNode.selectionStart;
return this._actual.selectionDirection === 'backward' ? this._actual.selectionEnd : this._actual.selectionStart;
}
public getSelectionEnd(): number {
return this._actual.domNode.selectionDirection === 'backward' ? this._actual.domNode.selectionStart : this._actual.domNode.selectionEnd;
return this._actual.selectionDirection === 'backward' ? this._actual.selectionStart : this._actual.selectionEnd;
}
public setSelectionRange(reason: string, selectionStart: number, selectionEnd: number): void {
const textArea = this._actual.domNode;
const textArea = this._actual;
let activeElement: Element | null = null;
const shadowRoot = dom.getShadowRoot(textArea);

128
src/vs/editor/browser/controller/textAreaState.ts
View File

@@ -51,7 +51,7 @@ export class TextAreaState {
}
public toString(): string {
return '[ <' + this.value + '>, selectionStart: ' + this.selectionStart + ', selectionEnd: ' + this.selectionEnd + ']';
return `[ <${this.value}>, selectionStart: ${this.selectionStart}, selectionEnd: ${this.selectionEnd}]`;
}
public static readFromTextArea(textArea: ITextAreaWrapper): TextAreaState {
@@ -64,7 +64,7 @@ export class TextAreaState {
public writeToTextArea(reason: string, textArea: ITextAreaWrapper, select: boolean): void {
if (_debugComposition) {
console.log('writeToTextArea ' + reason + ': ' + this.toString());
console.log(`writeToTextArea ${reason}: ${this.toString()}`);
}
textArea.setValue(reason, this.value);
if (select) {
@@ -98,10 +98,6 @@ export class TextAreaState {
return [anchor, signum * deltaText.length, lineFeedCnt];
}
public static selectedText(text: string): TextAreaState {
return new TextAreaState(text, 0, text.length, null, null);
}
public static deduceInput(previousState: TextAreaState, currentState: TextAreaState, couldBeEmojiInput: boolean): ITypeData {
if (!previousState) {
// This is the EMPTY state
@@ -115,105 +111,37 @@ export class TextAreaState {
if (_debugComposition) {
console.log('------------------------deduceInput');
console.log('PREVIOUS STATE: ' + previousState.toString());
console.log('CURRENT STATE: ' + currentState.toString());
console.log(`PREVIOUS STATE: ${previousState.toString()}`);
console.log(`CURRENT STATE: ${currentState.toString()}`);
}
let previousValue = previousState.value;
let previousSelectionStart = previousState.selectionStart;
let previousSelectionEnd = previousState.selectionEnd;
let currentValue = currentState.value;
let currentSelectionStart = currentState.selectionStart;
let currentSelectionEnd = currentState.selectionEnd;
// Strip the previous suffix from the value (without interfering with the current selection)
const previousSuffix = previousValue.substring(previousSelectionEnd);
const currentSuffix = currentValue.substring(currentSelectionEnd);
const suffixLength = strings.commonSuffixLength(previousSuffix, currentSuffix);
currentValue = currentValue.substring(0, currentValue.length - suffixLength);
previousValue = previousValue.substring(0, previousValue.length - suffixLength);
const previousPrefix = previousValue.substring(0, previousSelectionStart);
const currentPrefix = currentValue.substring(0, currentSelectionStart);
const prefixLength = strings.commonPrefixLength(previousPrefix, currentPrefix);
currentValue = currentValue.substring(prefixLength);
previousValue = previousValue.substring(prefixLength);
currentSelectionStart -= prefixLength;
previousSelectionStart -= prefixLength;
currentSelectionEnd -= prefixLength;
previousSelectionEnd -= prefixLength;
const prefixLength = Math.min(
strings.commonPrefixLength(previousState.value, currentState.value),
previousState.selectionStart,
currentState.selectionStart
);
const suffixLength = Math.min(
strings.commonSuffixLength(previousState.value, currentState.value),
previousState.value.length - previousState.selectionEnd,
currentState.value.length - currentState.selectionEnd
);
const previousValue = previousState.value.substring(prefixLength, previousState.value.length - suffixLength);
const currentValue = currentState.value.substring(prefixLength, currentState.value.length - suffixLength);
const previousSelectionStart = previousState.selectionStart - prefixLength;
const previousSelectionEnd = previousState.selectionEnd - prefixLength;
const currentSelectionStart = currentState.selectionStart - prefixLength;
const currentSelectionEnd = currentState.selectionEnd - prefixLength;
if (_debugComposition) {
console.log('AFTER DIFFING PREVIOUS STATE: <' + previousValue + '>, selectionStart: ' + previousSelectionStart + ', selectionEnd: ' + previousSelectionEnd);
console.log('AFTER DIFFING CURRENT STATE: <' + currentValue + '>, selectionStart: ' + currentSelectionStart + ', selectionEnd: ' + currentSelectionEnd);
}
if (couldBeEmojiInput && currentSelectionStart === currentSelectionEnd && previousValue.length > 0) {
// on OSX, emojis from the emoji picker are inserted at random locations
// the only hints we can use is that the selection is immediately after the inserted emoji
// and that none of the old text has been deleted
let potentialEmojiInput: string | null = null;
if (currentSelectionStart === currentValue.length) {
// emoji potentially inserted "somewhere" after the previous selection => it should appear at the end of `currentValue`
if (currentValue.startsWith(previousValue)) {
// only if all of the old text is accounted for
potentialEmojiInput = currentValue.substring(previousValue.length);
}
} else {
// emoji potentially inserted "somewhere" before the previous selection => it should appear at the start of `currentValue`
if (currentValue.endsWith(previousValue)) {
// only if all of the old text is accounted for
potentialEmojiInput = currentValue.substring(0, currentValue.length - previousValue.length);
}
}
if (potentialEmojiInput !== null && potentialEmojiInput.length > 0) {
// now we check that this is indeed an emoji
// emojis can grow quite long, so a length check is of no help
// e.g. 1F3F4 E0067 E0062 E0065 E006E E0067 E007F ; fully-qualified # 🏴󠁧󠁢󠁥󠁮󠁧󠁿 England
// Oftentimes, emojis use Variation Selector-16 (U+FE0F), so that is a good hint
// http://emojipedia.org/variation-selector-16/
// > An invisible codepoint which specifies that the preceding character
// > should be displayed with emoji presentation. Only required if the
// > preceding character defaults to text presentation.
if (/\uFE0F/.test(potentialEmojiInput) || strings.containsEmoji(potentialEmojiInput)) {
return {
text: potentialEmojiInput,
replacePrevCharCnt: 0,
replaceNextCharCnt: 0,
positionDelta: 0
};
}
}
console.log(`AFTER DIFFING PREVIOUS STATE: <${previousValue}>, selectionStart: ${previousSelectionStart}, selectionEnd: ${previousSelectionEnd}`);
console.log(`AFTER DIFFING CURRENT STATE: <${currentValue}>, selectionStart: ${currentSelectionStart}, selectionEnd: ${currentSelectionEnd}`);
}
if (currentSelectionStart === currentSelectionEnd) {
// composition accept case (noticed in FF + Japanese)
// [blahblah] => blahblah|
if (
previousValue === currentValue
&& previousSelectionStart === 0
&& previousSelectionEnd === previousValue.length
&& currentSelectionStart === currentValue.length
&& currentValue.indexOf('\n') === -1
) {
if (strings.containsFullWidthCharacter(currentValue)) {
return {
text: '',
replacePrevCharCnt: 0,
replaceNextCharCnt: 0,
positionDelta: 0
};
}
}
// no current selection
const replacePreviousCharacters = (previousPrefix.length - prefixLength);
const replacePreviousCharacters = (previousState.selectionStart - prefixLength);
if (_debugComposition) {
console.log('REMOVE PREVIOUS: ' + (previousPrefix.length - prefixLength) + ' chars');
console.log(`REMOVE PREVIOUS: ${replacePreviousCharacters} chars`);
}
return {
@@ -247,8 +175,8 @@ export class TextAreaState {
if (_debugComposition) {
console.log('------------------------deduceAndroidCompositionInput');
console.log('PREVIOUS STATE: ' + previousState.toString());
console.log('CURRENT STATE: ' + currentState.toString());
console.log(`PREVIOUS STATE: ${previousState.toString()}`);
console.log(`CURRENT STATE: ${currentState.toString()}`);
}
if (previousState.value === currentState.value) {
@@ -270,8 +198,8 @@ export class TextAreaState {
const currentSelectionEnd = currentState.selectionEnd - prefixLength;
if (_debugComposition) {
console.log('AFTER DIFFING PREVIOUS STATE: <' + previousValue + '>, selectionStart: ' + previousSelectionStart + ', selectionEnd: ' + previousSelectionEnd);
console.log('AFTER DIFFING CURRENT STATE: <' + currentValue + '>, selectionStart: ' + currentSelectionStart + ', selectionEnd: ' + currentSelectionEnd);
console.log(`AFTER DIFFING PREVIOUS STATE: <${previousValue}>, selectionStart: ${previousSelectionStart}, selectionEnd: ${previousSelectionEnd}`);
console.log(`AFTER DIFFING CURRENT STATE: <${currentValue}>, selectionStart: ${currentSelectionStart}, selectionEnd: ${currentSelectionEnd}`);
}
return {

87
src/vs/editor/browser/controller/coreCommands.ts → src/vs/editor/browser/coreCommands.ts
View File

@@ -11,23 +11,23 @@ import { status } from 'vs/base/browser/ui/aria/aria';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { Command, EditorCommand, ICommandOptions, registerEditorCommand, MultiCommand, UndoCommand, RedoCommand, SelectAllCommand } from 'vs/editor/browser/editorExtensions';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { ColumnSelection, IColumnSelectResult } from 'vs/editor/common/controller/cursorColumnSelection';
import { CursorState, EditOperationType, IColumnSelectData, PartialCursorState } from 'vs/editor/common/controller/cursorCommon';
import { DeleteOperations } from 'vs/editor/common/controller/cursorDeleteOperations';
import { CursorChangeReason } from 'vs/editor/common/controller/cursorEvents';
import { CursorMove as CursorMove_, CursorMoveCommands } from 'vs/editor/common/controller/cursorMoveCommands';
import { TypeOperations } from 'vs/editor/common/controller/cursorTypeOperations';
import { ColumnSelection, IColumnSelectResult } from 'vs/editor/common/cursor/cursorColumnSelection';
import { CursorState, EditOperationType, IColumnSelectData, PartialCursorState } from 'vs/editor/common/cursorCommon';
import { DeleteOperations } from 'vs/editor/common/cursor/cursorDeleteOperations';
import { CursorChangeReason } from 'vs/editor/common/cursorEvents';
import { CursorMove as CursorMove_, CursorMoveCommands } from 'vs/editor/common/cursor/cursorMoveCommands';
import { TypeOperations } from 'vs/editor/common/cursor/cursorTypeOperations';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { Handler, ScrollType } from 'vs/editor/common/editorCommon';
import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
import { VerticalRevealType } from 'vs/editor/common/view/viewEvents';
import { VerticalRevealType } from 'vs/editor/common/viewEvents';
import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
import { KeybindingWeight, KeybindingsRegistry } from 'vs/platform/keybinding/common/keybindingsRegistry';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { IViewModel } from 'vs/editor/common/viewModel';
const CORE_WEIGHT = KeybindingWeight.EditorCore;
@@ -329,34 +329,40 @@ export namespace CoreNavigationCommands {
class BaseMoveToCommand extends CoreEditorCommand {
private readonly _minimalReveal: boolean;
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { minimalReveal: boolean; inSelectionMode: boolean }) {
super(opts);
this._minimalReveal = opts.minimalReveal;
this._inSelectionMode = opts.inSelectionMode;
}
public runCoreEditorCommand(viewModel: IViewModel, args: any): void {
viewModel.model.pushStackElement();
viewModel.setCursorStates(
const cursorStateChanged = viewModel.setCursorStates(
args.source,
CursorChangeReason.Explicit,
[
CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
]
);
viewModel.revealPrimaryCursor(args.source, true);
if (cursorStateChanged) {
viewModel.revealPrimaryCursor(args.source, true, this._minimalReveal);
}
}
}
export const MoveTo: CoreEditorCommand = registerEditorCommand(new BaseMoveToCommand({
id: '_moveTo',
minimalReveal: true,
inSelectionMode: false,
precondition: undefined
}));
export const MoveToSelect: CoreEditorCommand = registerEditorCommand(new BaseMoveToCommand({
id: '_moveToSelect',
minimalReveal: false,
inSelectionMode: true,
precondition: undefined
}));
@@ -398,8 +404,8 @@ export namespace CoreNavigationCommands {
const validatedPosition = viewModel.model.validatePosition(args.position);
const validatedViewPosition = viewModel.coordinatesConverter.validateViewPosition(new Position(args.viewPosition.lineNumber, args.viewPosition.column), validatedPosition);
let fromViewLineNumber = args.doColumnSelect ? prevColumnSelectData.fromViewLineNumber : validatedViewPosition.lineNumber;
let fromViewVisualColumn = args.doColumnSelect ? prevColumnSelectData.fromViewVisualColumn : args.mouseColumn - 1;
const fromViewLineNumber = args.doColumnSelect ? prevColumnSelectData.fromViewLineNumber : validatedViewPosition.lineNumber;
const fromViewVisualColumn = args.doColumnSelect ? prevColumnSelectData.fromViewVisualColumn : args.mouseColumn - 1;
return ColumnSelection.columnSelect(viewModel.cursorConfig, viewModel, fromViewLineNumber, fromViewVisualColumn, validatedViewPosition.lineNumber, args.mouseColumn - 1);
}
});
@@ -446,7 +452,7 @@ export namespace CoreNavigationCommands {
private readonly _isPaged: boolean;
constructor(opts: ICommandOptions & { isPaged: boolean; }) {
constructor(opts: ICommandOptions & { isPaged: boolean }) {
super(opts);
this._isPaged = opts.isPaged;
}
@@ -484,7 +490,7 @@ export namespace CoreNavigationCommands {
private readonly _isPaged: boolean;
constructor(opts: ICommandOptions & { isPaged: boolean; }) {
constructor(opts: ICommandOptions & { isPaged: boolean }) {
super(opts);
this._isPaged = opts.isPaged;
}
@@ -598,7 +604,7 @@ export namespace CoreNavigationCommands {
direction: this._staticArgs.direction,
unit: this._staticArgs.unit,
select: this._staticArgs.select,
value: viewModel.cursorConfig.pageSize
value: dynamicArgs.pageSize || viewModel.cursorConfig.pageSize
};
}
@@ -901,7 +907,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -945,7 +951,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -999,7 +1005,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1077,7 +1083,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1132,7 +1138,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1176,7 +1182,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1250,7 +1256,7 @@ export namespace CoreNavigationCommands {
);
}
viewModel.setScrollTop(desiredScrollTop, ScrollType.Smooth);
viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, ScrollType.Smooth);
}
private _computeDesiredScrollTop(viewModel: IViewModel, args: EditorScroll_.ParsedArguments): number {
@@ -1270,7 +1276,7 @@ export namespace CoreNavigationCommands {
}
const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(new Position(desiredTopModelLineNumber, 1));
return viewModel.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
return viewModel.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
}
let noOfLines: number;
@@ -1282,7 +1288,7 @@ export namespace CoreNavigationCommands {
noOfLines = args.value;
}
const deltaLines = (args.direction === EditorScroll_.Direction.Up ? -1 : 1) * noOfLines;
return viewModel.getScrollTop() + deltaLines * viewModel.cursorConfig.lineHeight;
return viewModel.viewLayout.getCurrentScrollTop() + deltaLines * viewModel.cursorConfig.lineHeight;
}
}
@@ -1394,7 +1400,7 @@ export namespace CoreNavigationCommands {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1452,7 +1458,7 @@ export namespace CoreNavigationCommands {
class LineCommand extends CoreEditorCommand {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1485,7 +1491,7 @@ export namespace CoreNavigationCommands {
class LastCursorLineCommand extends CoreEditorCommand {
private readonly _inSelectionMode: boolean;
constructor(opts: ICommandOptions & { inSelectionMode: boolean; }) {
constructor(opts: ICommandOptions & { inSelectionMode: boolean }) {
super(opts);
this._inSelectionMode = opts.inSelectionMode;
}
@@ -1518,31 +1524,6 @@ export namespace CoreNavigationCommands {
precondition: undefined
}));
export const ExpandLineSelection: CoreEditorCommand = registerEditorCommand(new class extends CoreEditorCommand {
constructor() {
super({
id: 'expandLineSelection',
precondition: undefined,
kbOpts: {
weight: CORE_WEIGHT,
kbExpr: EditorContextKeys.textInputFocus,
primary: KeyMod.CtrlCmd | KeyCode.KeyL
}
});
}
public runCoreEditorCommand(viewModel: IViewModel, args: any): void {
viewModel.model.pushStackElement();
viewModel.setCursorStates(
args.source,
CursorChangeReason.Explicit,
CursorMoveCommands.expandLineSelection(viewModel, viewModel.getCursorStates())
);
viewModel.revealPrimaryCursor(args.source, true);
}
});
export const CancelSelection: CoreEditorCommand = registerEditorCommand(new class extends CoreEditorCommand {
constructor() {
super({

266
src/vs/editor/browser/editorBrowser.ts
View File

@@ -6,20 +6,21 @@
import { Event } from 'vs/base/common/event';
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { IMouseEvent, IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
import { IDisposable } from 'vs/base/common/lifecycle';
import { OverviewRulerPosition, ConfigurationChangedEvent, EditorLayoutInfo, IComputedEditorOptions, EditorOption, FindComputedEditorOptionValueById, IEditorOptions, IDiffEditorOptions } from 'vs/editor/common/config/editorOptions';
import { ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
import { ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/cursorEvents';
import { IPosition, Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { IIdentifiedSingleEditOperation, IModelDecoration, IModelDeltaDecoration, ITextModel, ICursorStateComputer, IWordAtPosition } from 'vs/editor/common/model';
import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent } from 'vs/editor/common/model/textModelEvents';
import { OverviewRulerZone } from 'vs/editor/common/view/overviewZoneManager';
import { IEditorWhitespace } from 'vs/editor/common/viewLayout/linesLayout';
import { IIdentifiedSingleEditOperation, IModelDecoration, IModelDeltaDecoration, ITextModel, ICursorStateComputer, PositionAffinity } from 'vs/editor/common/model';
import { IWordAtPosition } from 'vs/editor/common/core/wordHelper';
import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent } from 'vs/editor/common/textModelEvents';
import { OverviewRulerZone } from 'vs/editor/common/viewModel/overviewZoneManager';
import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
import { IDiffComputationResult } from 'vs/editor/common/services/editorWorkerService';
import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { IEditorWhitespace, IViewModel } from 'vs/editor/common/viewModel';
import { InjectedText } from 'vs/editor/common/modelLineProjectionData';
import { IDiffComputationResult, ILineChange } from 'vs/editor/common/diff/diffComputer';
import { IDimension } from 'vs/editor/common/core/dimension';
/**
* A view zone is a full horizontal rectangle that 'pushes' text down.
@@ -34,8 +35,14 @@ export interface IViewZone {
/**
* The column after which this zone should appear.
* If not set, the maxLineColumn of `afterLineNumber` will be used.
* This is relevant for wrapped lines.
*/
afterColumn?: number;
/**
* If the `afterColumn` has multiple view columns, the affinity specifies which one to use. Defaults to `none`.
*/
afterColumnAffinity?: PositionAffinity;
/**
* Suppress mouse down events.
* If set, the editor will attach a mouse down listener to the view zone and .preventDefault on it.
@@ -133,6 +140,12 @@ export interface IContentWidgetPosition {
* Placement preference for position, in order of preference.
*/
preference: ContentWidgetPositionPreference[];
/**
* Placement preference when multiple view positions refer to the same (model) position.
* This plays a role when injected text is involved.
*/
positionAffinity?: PositionAffinity;
}
/**
* A content widget renders inline with the text and can be easily placed 'near' an editor position.
@@ -142,7 +155,9 @@ export interface IContentWidget {
* Render this content widget in a location where it could overflow the editor's view dom node.
*/
allowEditorOverflow?: boolean;
/**
* Call preventDefault() on mousedown events that target the content widget.
*/
suppressMouseDown?: boolean;
/**
* Get a unique identifier of the content widget.
@@ -162,7 +177,7 @@ export interface IContentWidget {
* the content widget. If a dimension is returned the editor will
* attempt to use it.
*/
beforeRender?(): editorCommon.IDimension | null;
beforeRender?(): IDimension | null;
/**
* Optional function that is invoked after rendering the content
* widget. Is being invoked with the selected position preference
@@ -279,19 +294,11 @@ export const enum MouseTargetType {
*/
OUTSIDE_EDITOR,
}
/**
* Target hit with the mouse in the editor.
*/
export interface IMouseTarget {
export interface IBaseMouseTarget {
/**
* The target element
*/
readonly element: Element | null;
/**
* The target type
*/
readonly type: MouseTargetType;
/**
* The 'approximate' editor position
*/
@@ -304,11 +311,103 @@ export interface IMouseTarget {
* The 'approximate' editor range
*/
readonly range: Range | null;
/**
* Some extra detail.
*/
readonly detail: any;
}
export interface IMouseTargetUnknown extends IBaseMouseTarget {
readonly type: MouseTargetType.UNKNOWN;
}
export interface IMouseTargetTextarea extends IBaseMouseTarget {
readonly type: MouseTargetType.TEXTAREA;
readonly position: null;
readonly range: null;
}
export interface IMouseTargetMarginData {
readonly isAfterLines: boolean;
readonly glyphMarginLeft: number;
readonly glyphMarginWidth: number;
readonly lineNumbersWidth: number;
readonly offsetX: number;
}
export interface IMouseTargetMargin extends IBaseMouseTarget {
readonly type: MouseTargetType.GUTTER_GLYPH_MARGIN | MouseTargetType.GUTTER_LINE_NUMBERS | MouseTargetType.GUTTER_LINE_DECORATIONS;
readonly position: Position;
readonly range: Range;
readonly detail: IMouseTargetMarginData;
}
export interface IMouseTargetViewZoneData {
readonly viewZoneId: string;
readonly positionBefore: Position | null;
readonly positionAfter: Position | null;
readonly position: Position;
readonly afterLineNumber: number;
}
export interface IMouseTargetViewZone extends IBaseMouseTarget {
readonly type: MouseTargetType.GUTTER_VIEW_ZONE | MouseTargetType.CONTENT_VIEW_ZONE;
readonly position: Position;
readonly range: Range;
readonly detail: IMouseTargetViewZoneData;
}
export interface IMouseTargetContentTextData {
readonly mightBeForeignElement: boolean;
/**
* @internal
*/
readonly injectedText: InjectedText | null;
}
export interface IMouseTargetContentText extends IBaseMouseTarget {
readonly type: MouseTargetType.CONTENT_TEXT;
readonly position: Position;
readonly range: Range;
readonly detail: IMouseTargetContentTextData;
}
export interface IMouseTargetContentEmptyData {
readonly isAfterLines: boolean;
readonly horizontalDistanceToText?: number;
}
export interface IMouseTargetContentEmpty extends IBaseMouseTarget {
readonly type: MouseTargetType.CONTENT_EMPTY;
readonly position: Position;
readonly range: Range;
readonly detail: IMouseTargetContentEmptyData;
}
export interface IMouseTargetContentWidget extends IBaseMouseTarget {
readonly type: MouseTargetType.CONTENT_WIDGET;
readonly position: null;
readonly range: null;
readonly detail: string;
}
export interface IMouseTargetOverlayWidget extends IBaseMouseTarget {
readonly type: MouseTargetType.OVERLAY_WIDGET;
readonly position: null;
readonly range: null;
readonly detail: string;
}
export interface IMouseTargetScrollbar extends IBaseMouseTarget {
readonly type: MouseTargetType.SCROLLBAR;
readonly position: Position;
readonly range: Range;
}
export interface IMouseTargetOverviewRuler extends IBaseMouseTarget {
readonly type: MouseTargetType.OVERVIEW_RULER;
}
export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
readonly type: MouseTargetType.OUTSIDE_EDITOR;
}
/**
* Target hit with the mouse in the editor.
*/
export type IMouseTarget = (
IMouseTargetUnknown
| IMouseTargetTextarea
| IMouseTargetMargin
| IMouseTargetViewZone
| IMouseTargetContentText
| IMouseTargetContentEmpty
| IMouseTargetContentWidget
| IMouseTargetOverlayWidget
| IMouseTargetScrollbar
| IMouseTargetOverviewRuler
| IMouseTargetOutsideEditor
);
/**
* A mouse event originating from the editor.
*/
@@ -349,23 +448,11 @@ export interface IEditorAriaOptions {
role?: string;
}
export interface IEditorConstructionOptions extends IEditorOptions {
/**
* The initial editor dimension (to avoid measuring the container).
*/
dimension?: editorCommon.IDimension;
/**
* Place overflow widgets inside an external DOM node.
* Defaults to an internal DOM node.
*/
overflowWidgetsDomNode?: HTMLElement;
}
export interface IDiffEditorConstructionOptions extends IDiffEditorOptions {
/**
* The initial editor dimension (to avoid measuring the container).
*/
dimension?: editorCommon.IDimension;
dimension?: IDimension;
/**
* Place overflow widgets inside an external DOM node.
@@ -403,177 +490,188 @@ export interface ICodeEditor extends editorCommon.IEditor {
* An event emitted when the content of the current model has changed.
* @event
*/
onDidChangeModelContent: Event<IModelContentChangedEvent>;
readonly onDidChangeModelContent: Event<IModelContentChangedEvent>;
/**
* An event emitted when the language of the current model has changed.
* @event
*/
onDidChangeModelLanguage: Event<IModelLanguageChangedEvent>;
readonly onDidChangeModelLanguage: Event<IModelLanguageChangedEvent>;
/**
* An event emitted when the language configuration of the current model has changed.
* @event
*/
onDidChangeModelLanguageConfiguration: Event<IModelLanguageConfigurationChangedEvent>;
readonly onDidChangeModelLanguageConfiguration: Event<IModelLanguageConfigurationChangedEvent>;
/**
* An event emitted when the options of the current model has changed.
* @event
*/
onDidChangeModelOptions: Event<IModelOptionsChangedEvent>;
readonly onDidChangeModelOptions: Event<IModelOptionsChangedEvent>;
/**
* An event emitted when the configuration of the editor has changed. (e.g. `editor.updateOptions()`)
* @event
*/
onDidChangeConfiguration: Event<ConfigurationChangedEvent>;
readonly onDidChangeConfiguration: Event<ConfigurationChangedEvent>;
/**
* An event emitted when the cursor position has changed.
* @event
*/
onDidChangeCursorPosition: Event<ICursorPositionChangedEvent>;
readonly onDidChangeCursorPosition: Event<ICursorPositionChangedEvent>;
/**
* An event emitted when the cursor selection has changed.
* @event
*/
onDidChangeCursorSelection: Event<ICursorSelectionChangedEvent>;
readonly onDidChangeCursorSelection: Event<ICursorSelectionChangedEvent>;
/**
* An event emitted when the model of this editor has changed (e.g. `editor.setModel()`).
* @event
*/
onDidChangeModel: Event<editorCommon.IModelChangedEvent>;
readonly onDidChangeModel: Event<editorCommon.IModelChangedEvent>;
/**
* An event emitted when the decorations of the current model have changed.
* @event
*/
onDidChangeModelDecorations: Event<IModelDecorationsChangedEvent>;
readonly onDidChangeModelDecorations: Event<IModelDecorationsChangedEvent>;
/**
* An event emitted when the tokens of the current model have changed.
* @internal
*/
readonly onDidChangeModelTokens: Event<IModelTokensChangedEvent>;
/**
* An event emitted when the text inside this editor gained focus (i.e. cursor starts blinking).
* @event
*/
onDidFocusEditorText(listener: () => void): IDisposable;
readonly onDidFocusEditorText: Event<void>;
/**
* An event emitted when the text inside this editor lost focus (i.e. cursor stops blinking).
* @event
*/
onDidBlurEditorText(listener: () => void): IDisposable;
readonly onDidBlurEditorText: Event<void>;
/**
* An event emitted when the text inside this editor or an editor widget gained focus.
* @event
*/
onDidFocusEditorWidget(listener: () => void): IDisposable;
readonly onDidFocusEditorWidget: Event<void>;
/**
* An event emitted when the text inside this editor or an editor widget lost focus.
* @event
*/
onDidBlurEditorWidget(listener: () => void): IDisposable;
readonly onDidBlurEditorWidget: Event<void>;
/**
* An event emitted before interpreting typed characters (on the keyboard).
* @event
* @internal
*/
onWillType(listener: (text: string) => void): IDisposable;
readonly onWillType: Event<string>;
/**
* An event emitted after interpreting typed characters (on the keyboard).
* @event
* @internal
*/
onDidType(listener: (text: string) => void): IDisposable;
readonly onDidType: Event<string>;
/**
* An event emitted after composition has started.
*/
onDidCompositionStart(listener: () => void): IDisposable;
readonly onDidCompositionStart: Event<void>;
/**
* An event emitted after composition has ended.
*/
onDidCompositionEnd(listener: () => void): IDisposable;
readonly onDidCompositionEnd: Event<void>;
/**
* An event emitted when editing failed because the editor is read-only.
* @event
*/
onDidAttemptReadOnlyEdit(listener: () => void): IDisposable;
readonly onDidAttemptReadOnlyEdit: Event<void>;
/**
* An event emitted when users paste text in the editor.
* @event
*/
onDidPaste: Event<IPasteEvent>;
readonly onDidPaste: Event<IPasteEvent>;
/**
* An event emitted on a "mouseup".
* @event
*/
onMouseUp: Event<IEditorMouseEvent>;
readonly onMouseUp: Event<IEditorMouseEvent>;
/**
* An event emitted on a "mousedown".
* @event
*/
onMouseDown: Event<IEditorMouseEvent>;
readonly onMouseDown: Event<IEditorMouseEvent>;
/**
* An event emitted on a "mousedrag".
* @internal
* @event
*/
onMouseDrag: Event<IEditorMouseEvent>;
readonly onMouseDrag: Event<IEditorMouseEvent>;
/**
* An event emitted on a "mousedrop".
* @internal
* @event
*/
onMouseDrop: Event<IPartialEditorMouseEvent>;
readonly onMouseDrop: Event<IPartialEditorMouseEvent>;
/**
* An event emitted on a "mousedropcanceled".
* @internal
* @event
*/
onMouseDropCanceled(listener: () => void): IDisposable;
readonly onMouseDropCanceled: Event<void>;
/**
* An event emitted when content is dropped into the editor.
* @internal
* @event
*/
readonly onDropIntoEditor: Event<{ readonly position: IPosition; readonly event: DragEvent }>;
/**
* An event emitted on a "contextmenu".
* @event
*/
onContextMenu: Event<IEditorMouseEvent>;
readonly onContextMenu: Event<IEditorMouseEvent>;
/**
* An event emitted on a "mousemove".
* @event
*/
onMouseMove: Event<IEditorMouseEvent>;
readonly onMouseMove: Event<IEditorMouseEvent>;
/**
* An event emitted on a "mouseleave".
* @event
*/
onMouseLeave: Event<IPartialEditorMouseEvent>;
readonly onMouseLeave: Event<IPartialEditorMouseEvent>;
/**
* An event emitted on a "mousewheel"
* @event
* @internal
*/
onMouseWheel: Event<IMouseWheelEvent>;
readonly onMouseWheel: Event<IMouseWheelEvent>;
/**
* An event emitted on a "keyup".
* @event
*/
onKeyUp: Event<IKeyboardEvent>;
readonly onKeyUp: Event<IKeyboardEvent>;
/**
* An event emitted on a "keydown".
* @event
*/
onKeyDown: Event<IKeyboardEvent>;
readonly onKeyDown: Event<IKeyboardEvent>;
/**
* An event emitted when the layout of the editor has changed.
* @event
*/
onDidLayoutChange: Event<EditorLayoutInfo>;
readonly onDidLayoutChange: Event<EditorLayoutInfo>;
/**
* An event emitted when the content width or content height in the editor has changed.
* @event
*/
onDidContentSizeChange: Event<editorCommon.IContentSizeChangedEvent>;
readonly onDidContentSizeChange: Event<editorCommon.IContentSizeChangedEvent>;
/**
* An event emitted when the scroll in the editor has changed.
* @event
*/
onDidScrollChange: Event<editorCommon.IScrollEvent>;
readonly onDidScrollChange: Event<editorCommon.IScrollEvent>;
/**
* An event emitted when hidden areas change in the editor (e.g. due to folding).
* @event
*/
onDidChangeHiddenAreas: Event<void>;
readonly onDidChangeHiddenAreas: Event<void>;
/**
* Saves current view state of the editor in a serializable object.
@@ -595,7 +693,7 @@ export interface ICodeEditor extends editorCommon.IEditor {
* @id Unique identifier of the contribution.
* @return The contribution or null if contribution not found.
*/
getContribution<T extends editorCommon.IEditorContribution>(id: string): T;
getContribution<T extends editorCommon.IEditorContribution>(id: string): T | null;
/**
* Execute `fn` with the editor's services.
@@ -647,7 +745,7 @@ export interface ICodeEditor extends editorCommon.IEditor {
* Get value of the current model attached to this editor.
* @see {@link ITextModel.getValue}
*/
getValue(options?: { preserveBOM: boolean; lineEnding: string; }): string;
getValue(options?: { preserveBOM: boolean; lineEnding: string }): string;
/**
* Set the value of the current model attached to this editor.
@@ -747,6 +845,11 @@ export interface ICodeEditor extends editorCommon.IEditor {
*/
getLineDecorations(lineNumber: number): IModelDecoration[] | null;
/**
* Get all the decorations for a range (filtering out decorations from other editors).
*/
getDecorationsInRange(range: Range): IModelDecoration[] | null;
/**
* All decorations added through this call will get the ownerId of this editor.
* @see {@link ITextModel.deltaDecorations}
@@ -887,7 +990,7 @@ export interface ICodeEditor extends editorCommon.IEditor {
* Explanation 2: the results of this method will not change if the container of the editor gets repositioned.
* Warning: the results of this method are inaccurate for positions that are outside the current editor viewport.
*/
getScrolledVisiblePosition(position: IPosition): { top: number; left: number; height: number; } | null;
getScrolledVisiblePosition(position: IPosition): { top: number; left: number; height: number } | null;
/**
* Apply the same font settings as the editor to `target`.
@@ -899,6 +1002,8 @@ export interface ICodeEditor extends editorCommon.IEditor {
* @internal
*/
hasModel(): this is IActiveCodeEditor;
setBanner(bannerDomNode: HTMLElement | null, height: number): void;
}
/**
@@ -952,7 +1057,7 @@ export interface IActiveCodeEditor extends ICodeEditor {
* Explanation 2: the results of this method will not change if the container of the editor gets repositioned.
* Warning: the results of this method are inaccurate for positions that are outside the current editor viewport.
*/
getScrolledVisiblePosition(position: IPosition): { top: number; left: number; height: number; };
getScrolledVisiblePosition(position: IPosition): { top: number; left: number; height: number };
}
/**
@@ -981,6 +1086,11 @@ export interface IDiffEditor extends editorCommon.IEditor {
* @internal
*/
readonly ignoreTrimWhitespace: boolean;
/**
* Returns whether the diff editor is rendering side by side or inline.
* @internal
*/
readonly renderSideBySide: boolean;
/**
* Timeout in milliseconds after which diff computation is cancelled.
* @internal
@@ -988,15 +1098,15 @@ export interface IDiffEditor extends editorCommon.IEditor {
readonly maxComputationTime: number;
/**
* @see {@link ICodeEditor.getDomNode}
* @see {@link ICodeEditor.getContainerDomNode}
*/
getDomNode(): HTMLElement;
getContainerDomNode(): HTMLElement;
/**
* An event emitted when the diff information computed by this diff editor has been updated.
* @event
*/
onDidUpdateDiff(listener: () => void): IDisposable;
readonly onDidUpdateDiff: Event<void>;
/**
* Saves current view state of the editor in a serializable object.
@@ -1036,7 +1146,7 @@ export interface IDiffEditor extends editorCommon.IEditor {
/**
* Get the computed diff information.
*/
getLineChanges(): editorCommon.ILineChange[] | null;
getLineChanges(): ILineChange[] | null;
/**
* Get the computed diff information.

241
src/vs/editor/browser/editorDom.ts
View File

@@ -4,9 +4,13 @@
*--------------------------------------------------------------------------------------------*/
import * as dom from 'vs/base/browser/dom';
import { GlobalMouseMoveMonitor } from 'vs/base/browser/globalMouseMoveMonitor';
import { GlobalPointerMoveMonitor } from 'vs/base/browser/globalPointerMoveMonitor';
import { StandardMouseEvent } from 'vs/base/browser/mouseEvent';
import { RunOnceScheduler } from 'vs/base/common/async';
import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { asCssVariableName } from 'vs/platform/theme/common/colorRegistry';
import { ThemeColor } from 'vs/platform/theme/common/themeService';
/**
* Coordinates relative to the whole document (e.g. mouse event's pageX and pageY)
@@ -58,14 +62,54 @@ export class EditorPagePosition {
) { }
}
/**
* Coordinates relative to the the (top;left) of the editor that can be used safely with other internal editor metrics.
* **NOTE**: This position is obtained by taking page coordinates and transforming them relative to the
* editor's (top;left) position in a way in which scale transformations are taken into account.
* **NOTE**: These coordinates could be negative if the mouse position is outside the editor.
*/
export class CoordinatesRelativeToEditor {
_positionRelativeToEditorBrand: void = undefined;
constructor(
public readonly x: number,
public readonly y: number
) { }
}
export function createEditorPagePosition(editorViewDomNode: HTMLElement): EditorPagePosition {
const editorPos = dom.getDomNodePagePosition(editorViewDomNode);
return new EditorPagePosition(editorPos.left, editorPos.top, editorPos.width, editorPos.height);
}
export function createCoordinatesRelativeToEditor(editorViewDomNode: HTMLElement, editorPagePosition: EditorPagePosition, pos: PageCoordinates) {
// The editor's page position is read from the DOM using getBoundingClientRect().
//
// getBoundingClientRect() returns the actual dimensions, while offsetWidth and offsetHeight
// reflect the unscaled size. We can use this difference to detect a transform:scale()
// and we will apply the transformation in inverse to get mouse coordinates that make sense inside the editor.
//
// This could be expanded to cover rotation as well maybe by walking the DOM up from `editorViewDomNode`
// and computing the effective transformation matrix using getComputedStyle(element).transform.
//
const scaleX = editorPagePosition.width / editorViewDomNode.offsetWidth;
const scaleY = editorPagePosition.height / editorViewDomNode.offsetHeight;
// Adjust mouse offsets if editor appears to be scaled via transforms
const relativeX = (pos.x - editorPagePosition.x) / scaleX;
const relativeY = (pos.y - editorPagePosition.y) / scaleY;
return new CoordinatesRelativeToEditor(relativeX, relativeY);
}
export class EditorMouseEvent extends StandardMouseEvent {
_editorMouseEventBrand: void = undefined;
/**
* If the event is a result of using `setPointerCapture`, the `event.target`
* does not necessarily reflect the position in the editor.
*/
public readonly isFromPointerCapture: boolean;
/**
* Coordinates relative to the whole document.
*/
@@ -76,10 +120,19 @@ export class EditorMouseEvent extends StandardMouseEvent {
*/
public readonly editorPos: EditorPagePosition;
constructor(e: MouseEvent, editorViewDomNode: HTMLElement) {
/**
* Coordinates relative to the (top;left) of the editor.
* *NOTE*: These coordinates are preferred because they take into account transformations applied to the editor.
* *NOTE*: These coordinates could be negative if the mouse position is outside the editor.
*/
public readonly relativePos: CoordinatesRelativeToEditor;
constructor(e: MouseEvent, isFromPointerCapture: boolean, editorViewDomNode: HTMLElement) {
super(e);
this.isFromPointerCapture = isFromPointerCapture;
this.pos = new PageCoordinates(this.posx, this.posy);
this.editorPos = createEditorPagePosition(editorViewDomNode);
this.relativePos = createCoordinatesRelativeToEditor(editorViewDomNode, this.editorPos, this.pos);
}
}
@@ -96,7 +149,7 @@ export class EditorMouseEventFactory {
}
private _create(e: MouseEvent): EditorMouseEvent {
return new EditorMouseEvent(e, this._editorViewDomNode);
return new EditorMouseEvent(e, false, this._editorViewDomNode);
}
public onContextMenu(target: HTMLElement, callback: (e: EditorMouseEvent) => void): IDisposable {
@@ -112,11 +165,17 @@ export class EditorMouseEventFactory {
}
public onMouseDown(target: HTMLElement, callback: (e: EditorMouseEvent) => void): IDisposable {
return dom.addDisposableListener(target, 'mousedown', (e: MouseEvent) => {
return dom.addDisposableListener(target, dom.EventType.MOUSE_DOWN, (e: MouseEvent) => {
callback(this._create(e));
});
}
public onPointerDown(target: HTMLElement, callback: (e: EditorMouseEvent, pointerType: string, pointerId: number) => void): IDisposable {
return dom.addDisposableListener(target, dom.EventType.POINTER_DOWN, (e: PointerEvent) => {
callback(this._create(e), e.pointerType, e.pointerId);
});
}
public onMouseLeave(target: HTMLElement, callback: (e: EditorMouseEvent) => void): IDisposable {
return dom.addDisposableNonBubblingMouseOutListener(target, (e: MouseEvent) => {
callback(this._create(e));
@@ -140,7 +199,7 @@ export class EditorPointerEventFactory {
}
private _create(e: MouseEvent): EditorMouseEvent {
return new EditorMouseEvent(e, this._editorViewDomNode);
return new EditorMouseEvent(e, false, this._editorViewDomNode);
}
public onPointerUp(target: HTMLElement, callback: (e: EditorMouseEvent) => void): IDisposable {
@@ -149,9 +208,9 @@ export class EditorPointerEventFactory {
});
}
public onPointerDown(target: HTMLElement, callback: (e: EditorMouseEvent) => void): IDisposable {
return dom.addDisposableListener(target, 'pointerdown', (e: MouseEvent) => {
callback(this._create(e));
public onPointerDown(target: HTMLElement, callback: (e: EditorMouseEvent, pointerId: number) => void): IDisposable {
return dom.addDisposableListener(target, dom.EventType.POINTER_DOWN, (e: PointerEvent) => {
callback(this._create(e), e.pointerId);
});
}
@@ -169,25 +228,26 @@ export class EditorPointerEventFactory {
}
}
export class GlobalEditorMouseMoveMonitor extends Disposable {
export class GlobalEditorPointerMoveMonitor extends Disposable {
private readonly _editorViewDomNode: HTMLElement;
private readonly _globalMouseMoveMonitor: GlobalMouseMoveMonitor<EditorMouseEvent>;
private readonly _globalPointerMoveMonitor: GlobalPointerMoveMonitor<EditorMouseEvent>;
private _keydownListener: IDisposable | null;
constructor(editorViewDomNode: HTMLElement) {
super();
this._editorViewDomNode = editorViewDomNode;
this._globalMouseMoveMonitor = this._register(new GlobalMouseMoveMonitor<EditorMouseEvent>());
this._globalPointerMoveMonitor = this._register(new GlobalPointerMoveMonitor<EditorMouseEvent>());
this._keydownListener = null;
}
public startMonitoring(
initialElement: HTMLElement,
initialElement: Element,
pointerId: number,
initialButtons: number,
merger: EditorMouseEventMerger,
mouseMoveCallback: (e: EditorMouseEvent) => void,
onStopCallback: (browserEvent?: MouseEvent | KeyboardEvent) => void
pointerMoveCallback: (e: EditorMouseEvent) => void,
onStopCallback: (browserEvent?: PointerEvent | KeyboardEvent) => void
): void {
// Add a <<capture>> keydown event listener that will cancel the monitoring
@@ -198,20 +258,163 @@ export class GlobalEditorMouseMoveMonitor extends Disposable {
// Allow modifier keys
return;
}
this._globalMouseMoveMonitor.stopMonitoring(true, e.browserEvent);
this._globalPointerMoveMonitor.stopMonitoring(true, e.browserEvent);
}, true);
const myMerger: dom.IEventMerger<EditorMouseEvent, MouseEvent> = (lastEvent: EditorMouseEvent | null, currentEvent: MouseEvent): EditorMouseEvent => {
return merger(lastEvent, new EditorMouseEvent(currentEvent, this._editorViewDomNode));
const myMerger: dom.IEventMerger<EditorMouseEvent, PointerEvent> = (lastEvent: EditorMouseEvent | null, currentEvent: PointerEvent): EditorMouseEvent => {
return merger(lastEvent, new EditorMouseEvent(currentEvent, true, this._editorViewDomNode));
};
this._globalMouseMoveMonitor.startMonitoring(initialElement, initialButtons, myMerger, mouseMoveCallback, (e) => {
this._globalPointerMoveMonitor.startMonitoring(initialElement, pointerId, initialButtons, myMerger, pointerMoveCallback, (e) => {
this._keydownListener!.dispose();
onStopCallback(e);
});
}
public stopMonitoring(): void {
this._globalMouseMoveMonitor.stopMonitoring(true);
this._globalPointerMoveMonitor.stopMonitoring(true);
}
}
/**
* A helper to create dynamic css rules, bound to a class name.
* Rules are reused.
* Reference counting and delayed garbage collection ensure that no rules leak.
*/
export class DynamicCssRules {
private static _idPool = 0;
private readonly _instanceId = ++DynamicCssRules._idPool;
private _counter = 0;
private readonly _rules = new Map<string, RefCountedCssRule>();
// We delay garbage collection so that hanging rules can be reused.
private readonly _garbageCollectionScheduler = new RunOnceScheduler(() => this.garbageCollect(), 1000);
constructor(private readonly _editor: ICodeEditor) {
}
public createClassNameRef(options: CssProperties): ClassNameReference {
const rule = this.getOrCreateRule(options);
rule.increaseRefCount();
return {
className: rule.className,
dispose: () => {
rule.decreaseRefCount();
this._garbageCollectionScheduler.schedule();
}
};
}
private getOrCreateRule(properties: CssProperties): RefCountedCssRule {
const key = this.computeUniqueKey(properties);
let existingRule = this._rules.get(key);
if (!existingRule) {
const counter = this._counter++;
existingRule = new RefCountedCssRule(key, `dyn-rule-${this._instanceId}-${counter}`,
dom.isInShadowDOM(this._editor.getContainerDomNode())
? this._editor.getContainerDomNode()
: undefined,
properties
);
this._rules.set(key, existingRule);
}
return existingRule;
}
private computeUniqueKey(properties: CssProperties): string {
return JSON.stringify(properties);
}
private garbageCollect() {
for (const rule of this._rules.values()) {
if (!rule.hasReferences()) {
this._rules.delete(rule.key);
rule.dispose();
}
}
}
}
export interface ClassNameReference extends IDisposable {
className: string;
}
export interface CssProperties {
border?: string;
borderColor?: string | ThemeColor;
borderRadius?: string;
fontStyle?: string;
fontWeight?: string;
fontSize?: string;
fontFamily?: string;
textDecoration?: string;
color?: string | ThemeColor;
backgroundColor?: string | ThemeColor;
opacity?: string;
verticalAlign?: string;
cursor?: string;
margin?: string;
padding?: string;
width?: string;
height?: string;
display?: string;
}
class RefCountedCssRule {
private _referenceCount: number = 0;
private _styleElement: HTMLStyleElement;
constructor(
public readonly key: string,
public readonly className: string,
_containerElement: HTMLElement | undefined,
public readonly properties: CssProperties,
) {
this._styleElement = dom.createStyleSheet(
_containerElement
);
this._styleElement.textContent = this.getCssText(this.className, this.properties);
}
private getCssText(className: string, properties: CssProperties): string {
let str = `.${className} {`;
for (const prop in properties) {
const value = (properties as any)[prop] as string | ThemeColor;
let cssValue;
if (typeof value === 'object') {
cssValue = `var(${asCssVariableName(value.id)})`;
} else {
cssValue = value;
}
const cssPropName = camelToDashes(prop);
str += `\n\t${cssPropName}: ${cssValue};`;
}
str += `\n}`;
return str;
}
public dispose(): void {
this._styleElement.remove();
}
public increaseRefCount(): void {
this._referenceCount++;
}
public decreaseRefCount(): void {
this._referenceCount--;
}
public hasReferences(): boolean {
return this._referenceCount > 0;
}
}
function camelToDashes(str: string): string {
return str.replace(/(^[A-Z])/, ([first]) => first.toLowerCase())
.replace(/([A-Z])/g, ([letter]) => `-${letter.toLowerCase()}`);
}

56
src/vs/editor/browser/editorExtensions.ts
View File

@@ -10,12 +10,12 @@ import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService
import { Position } from 'vs/editor/common/core/position';
import { IEditorContribution, IDiffEditorContribution } from 'vs/editor/common/editorCommon';
import { ITextModel } from 'vs/editor/common/model';
import { IModelService } from 'vs/editor/common/services/modelService';
import { IModelService } from 'vs/editor/common/services/model';
import { ITextModelService } from 'vs/editor/common/services/resolverService';
import { MenuId, MenuRegistry, Action2 } from 'vs/platform/actions/common/actions';
import { CommandsRegistry, ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
import { ContextKeyExpr, IContextKeyService, ContextKeyExpression } from 'vs/platform/contextkey/common/contextkey';
import { IConstructorSignature1, ServicesAccessor as InstantiationServicesAccessor, BrandedService } from 'vs/platform/instantiation/common/instantiation';
import { ServicesAccessor as InstantiationServicesAccessor, BrandedService, IInstantiationService, IConstructorSignature } from 'vs/platform/instantiation/common/instantiation';
import { IKeybindings, KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
import { Registry } from 'vs/platform/registry/common/platform';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -27,8 +27,8 @@ import { ILogService } from 'vs/platform/log/common/log';
export type ServicesAccessor = InstantiationServicesAccessor;
export type IEditorContributionCtor = IConstructorSignature1<ICodeEditor, IEditorContribution>;
export type IDiffEditorContributionCtor = IConstructorSignature1<IDiffEditor, IDiffEditorContribution>;
export type IEditorContributionCtor = IConstructorSignature<IEditorContribution, [ICodeEditor]>;
export type IDiffEditorContributionCtor = IConstructorSignature<IDiffEditorContribution, [IDiffEditor]>;
export interface IEditorContributionDescription {
id: string;
@@ -56,7 +56,7 @@ export interface ICommandMenuOptions {
order: number;
when?: ContextKeyExpression;
title: string;
icon?: ThemeIcon
icon?: ThemeIcon;
}
export interface ICommandOptions {
id: string;
@@ -229,7 +229,7 @@ export abstract class EditorCommand extends Command {
/**
* Create a command class that is bound to a certain editor contribution.
*/
public static bindToContribution<T extends IEditorContribution>(controllerGetter: (editor: ICodeEditor) => T): EditorControllerCommand<T> {
public static bindToContribution<T extends IEditorContribution>(controllerGetter: (editor: ICodeEditor) => T | null): EditorControllerCommand<T> {
return class EditorControllerCommandImpl extends EditorCommand {
private readonly _callback: (controller: T, args: any) => void;
@@ -242,7 +242,7 @@ export abstract class EditorCommand extends Command {
public runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void {
const controller = controllerGetter(editor);
if (controller) {
this._callback(controllerGetter(editor), args);
this._callback(controller, args);
}
}
};
@@ -338,8 +338,8 @@ export abstract class EditorAction extends EditorCommand {
protected reportTelemetry(accessor: ServicesAccessor, editor: ICodeEditor) {
type EditorActionInvokedClassification = {
name: { classification: 'SystemMetaData', purpose: 'FeatureInsight', };
id: { classification: 'SystemMetaData', purpose: 'FeatureInsight', };
name: { classification: 'SystemMetaData'; purpose: 'FeatureInsight' };
id: { classification: 'SystemMetaData'; purpose: 'FeatureInsight' };
};
type EditorActionInvokedEvent = {
name: string;
@@ -420,9 +420,11 @@ export abstract class EditorAction2 extends Action2 {
// --- Registration of commands and actions
export function registerModelAndPositionCommand(id: string, handler: (model: ITextModel, position: Position, ...args: any[]) => any) {
export function registerModelAndPositionCommand(id: string, handler: (accessor: ServicesAccessor, model: ITextModel, position: Position, ...args: any[]) => any) {
CommandsRegistry.registerCommand(id, function (accessor, ...args) {
const instaService = accessor.get(IInstantiationService);
const [resource, position] = args;
assertType(URI.isUri(resource));
assertType(Position.isIPosition(position));
@@ -430,39 +432,13 @@ export function registerModelAndPositionCommand(id: string, handler: (model: ITe
const model = accessor.get(IModelService).getModel(resource);
if (model) {
const editorPosition = Position.lift(position);
return handler(model, editorPosition, ...args.slice(2));
return instaService.invokeFunction(handler, model, editorPosition, ...args.slice(2));
}
return accessor.get(ITextModelService).createModelReference(resource).then(reference => {
return new Promise((resolve, reject) => {
try {
const result = handler(reference.object.textEditorModel, Position.lift(position), args.slice(2));
resolve(result);
} catch (err) {
reject(err);
}
}).finally(() => {
reference.dispose();
});
});
});
}
export function registerModelCommand(id: string, handler: (model: ITextModel, ...args: any[]) => any) {
CommandsRegistry.registerCommand(id, function (accessor, ...args) {
const [resource] = args;
assertType(URI.isUri(resource));
const model = accessor.get(IModelService).getModel(resource);
if (model) {
return handler(model, ...args.slice(1));
}
return accessor.get(ITextModelService).createModelReference(resource).then(reference => {
return new Promise((resolve, reject) => {
try {
const result = handler(reference.object.textEditorModel, args.slice(1));
const result = instaService.invokeFunction(handler, reference.object.textEditorModel, Position.lift(position), args.slice(2));
resolve(result);
} catch (err) {
reject(err);
@@ -479,7 +455,7 @@ export function registerEditorCommand<T extends EditorCommand>(editorCommand: T)
return editorCommand;
}
export function registerEditorAction<T extends EditorAction>(ctor: { new(): T; }): T {
export function registerEditorAction<T extends EditorAction>(ctor: { new(): T }): T {
const action = new ctor();
EditorContributionRegistry.INSTANCE.registerEditorAction(action);
return action;
@@ -537,7 +513,7 @@ class EditorContributionRegistry {
private readonly editorContributions: IEditorContributionDescription[];
private readonly diffEditorContributions: IDiffEditorContributionDescription[];
private readonly editorActions: EditorAction[];
private readonly editorCommands: { [commandId: string]: EditorCommand; };
private readonly editorCommands: { [commandId: string]: EditorCommand };
constructor() {
this.editorContributions = [];

666
src/vs/editor/browser/services/abstractCodeEditorService.ts
View File

@@ -3,14 +3,17 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as dom from 'vs/base/browser/dom';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import { IDisposable, DisposableStore, Disposable } from 'vs/base/common/lifecycle';
import * as strings from 'vs/base/common/strings';
import { URI } from 'vs/base/common/uri';
import { ICodeEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { IDecorationRenderOptions } from 'vs/editor/common/editorCommon';
import { IModelDecorationOptions, ITextModel } from 'vs/editor/common/model';
import { IContentDecorationRenderOptions, IDecorationRenderOptions, IThemeDecorationRenderOptions, isThemeColor } from 'vs/editor/common/editorCommon';
import { IModelDecorationOptions, IModelDecorationOverviewRulerOptions, InjectedTextOptions, ITextModel, OverviewRulerLane, TrackedRangeStickiness } from 'vs/editor/common/model';
import { IResourceEditorInput } from 'vs/platform/editor/common/editor';
import { URI } from 'vs/base/common/uri';
import { IColorTheme, IThemeService, ThemeColor } from 'vs/platform/theme/common/themeService';
export abstract class AbstractCodeEditorService extends Disposable implements ICodeEditorService {
@@ -34,13 +37,19 @@ export abstract class AbstractCodeEditorService extends Disposable implements IC
protected readonly _onDecorationTypeRegistered: Emitter<string> = this._register(new Emitter<string>());
public onDecorationTypeRegistered: Event<string> = this._onDecorationTypeRegistered.event;
private readonly _codeEditors: { [editorId: string]: ICodeEditor; };
private readonly _diffEditors: { [editorId: string]: IDiffEditor; };
private readonly _codeEditors: { [editorId: string]: ICodeEditor };
private readonly _diffEditors: { [editorId: string]: IDiffEditor };
protected _globalStyleSheet: GlobalStyleSheet | null;
private readonly _decorationOptionProviders = new Map<string, IModelDecorationOptionsProvider>();
private readonly _editorStyleSheets = new Map<string, RefCountedStyleSheet>();
constructor() {
constructor(
@IThemeService private readonly _themeService: IThemeService,
) {
super();
this._codeEditors = Object.create(null);
this._diffEditors = Object.create(null);
this._globalStyleSheet = null;
}
addCodeEditor(editor: ICodeEditor): void {
@@ -92,12 +101,88 @@ export abstract class AbstractCodeEditorService extends Disposable implements IC
return editorWithWidgetFocus;
}
abstract registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): void;
abstract removeDecorationType(key: string): void;
abstract resolveDecorationOptions(decorationTypeKey: string | undefined, writable: boolean): IModelDecorationOptions;
abstract resolveDecorationCSSRules(decorationTypeKey: string): CSSRuleList | null;
private readonly _transientWatchers: { [uri: string]: ModelTransientSettingWatcher; } = {};
private _getOrCreateGlobalStyleSheet(): GlobalStyleSheet {
if (!this._globalStyleSheet) {
this._globalStyleSheet = this._createGlobalStyleSheet();
}
return this._globalStyleSheet;
}
protected _createGlobalStyleSheet(): GlobalStyleSheet {
return new GlobalStyleSheet(dom.createStyleSheet());
}
private _getOrCreateStyleSheet(editor: ICodeEditor | undefined): GlobalStyleSheet | RefCountedStyleSheet {
if (!editor) {
return this._getOrCreateGlobalStyleSheet();
}
const domNode = editor.getContainerDomNode();
if (!dom.isInShadowDOM(domNode)) {
return this._getOrCreateGlobalStyleSheet();
}
const editorId = editor.getId();
if (!this._editorStyleSheets.has(editorId)) {
const refCountedStyleSheet = new RefCountedStyleSheet(this, editorId, dom.createStyleSheet(domNode));
this._editorStyleSheets.set(editorId, refCountedStyleSheet);
}
return this._editorStyleSheets.get(editorId)!;
}
_removeEditorStyleSheets(editorId: string): void {
this._editorStyleSheets.delete(editorId);
}
public registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): void {
let provider = this._decorationOptionProviders.get(key);
if (!provider) {
const styleSheet = this._getOrCreateStyleSheet(editor);
const providerArgs: ProviderArguments = {
styleSheet: styleSheet,
key: key,
parentTypeKey: parentTypeKey,
options: options || Object.create(null)
};
if (!parentTypeKey) {
provider = new DecorationTypeOptionsProvider(description, this._themeService, styleSheet, providerArgs);
} else {
provider = new DecorationSubTypeOptionsProvider(this._themeService, styleSheet, providerArgs);
}
this._decorationOptionProviders.set(key, provider);
this._onDecorationTypeRegistered.fire(key);
}
provider.refCount++;
}
public removeDecorationType(key: string): void {
const provider = this._decorationOptionProviders.get(key);
if (provider) {
provider.refCount--;
if (provider.refCount <= 0) {
this._decorationOptionProviders.delete(key);
provider.dispose();
this.listCodeEditors().forEach((ed) => ed.removeDecorations(key));
}
}
}
public resolveDecorationOptions(decorationTypeKey: string, writable: boolean): IModelDecorationOptions {
const provider = this._decorationOptionProviders.get(decorationTypeKey);
if (!provider) {
throw new Error('Unknown decoration type key: ' + decorationTypeKey);
}
return provider.getOptions(this, writable);
}
public resolveDecorationCSSRules(decorationTypeKey: string) {
const provider = this._decorationOptionProviders.get(decorationTypeKey);
if (!provider) {
return null;
}
return provider.resolveDecorationCSSRules();
}
private readonly _transientWatchers: { [uri: string]: ModelTransientSettingWatcher } = {};
private readonly _modelProperties = new Map<string, Map<string, any>>();
public setModelProperty(resource: URI, key: string, value: any): void {
@@ -167,7 +252,7 @@ export abstract class AbstractCodeEditorService extends Disposable implements IC
export class ModelTransientSettingWatcher {
public readonly uri: string;
private readonly _values: { [key: string]: any; };
private readonly _values: { [key: string]: any };
constructor(uri: string, model: ITextModel, owner: AbstractCodeEditorService) {
this.uri = uri;
@@ -187,3 +272,558 @@ export class ModelTransientSettingWatcher {
return Object.keys(this._values);
}
}
export class RefCountedStyleSheet {
private readonly _parent: AbstractCodeEditorService;
private readonly _editorId: string;
private readonly _styleSheet: HTMLStyleElement;
private _refCount: number;
public get sheet() {
return this._styleSheet.sheet as CSSStyleSheet;
}
constructor(parent: AbstractCodeEditorService, editorId: string, styleSheet: HTMLStyleElement) {
this._parent = parent;
this._editorId = editorId;
this._styleSheet = styleSheet;
this._refCount = 0;
}
public ref(): void {
this._refCount++;
}
public unref(): void {
this._refCount--;
if (this._refCount === 0) {
this._styleSheet.parentNode?.removeChild(this._styleSheet);
this._parent._removeEditorStyleSheets(this._editorId);
}
}
public insertRule(rule: string, index?: number): void {
const sheet = <CSSStyleSheet>this._styleSheet.sheet;
sheet.insertRule(rule, index);
}
public removeRulesContainingSelector(ruleName: string): void {
dom.removeCSSRulesContainingSelector(ruleName, this._styleSheet);
}
}
export class GlobalStyleSheet {
private readonly _styleSheet: HTMLStyleElement;
public get sheet() {
return this._styleSheet.sheet as CSSStyleSheet;
}
constructor(styleSheet: HTMLStyleElement) {
this._styleSheet = styleSheet;
}
public ref(): void {
}
public unref(): void {
}
public insertRule(rule: string, index?: number): void {
const sheet = <CSSStyleSheet>this._styleSheet.sheet;
sheet.insertRule(rule, index);
}
public removeRulesContainingSelector(ruleName: string): void {
dom.removeCSSRulesContainingSelector(ruleName, this._styleSheet);
}
}
interface IModelDecorationOptionsProvider extends IDisposable {
refCount: number;
getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions;
resolveDecorationCSSRules(): CSSRuleList;
}
export class DecorationSubTypeOptionsProvider implements IModelDecorationOptionsProvider {
private readonly _styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
public refCount: number;
private readonly _parentTypeKey: string;
private _beforeContentRules: DecorationCSSRules | null;
private _afterContentRules: DecorationCSSRules | null;
constructor(themeService: IThemeService, styleSheet: GlobalStyleSheet | RefCountedStyleSheet, providerArgs: ProviderArguments) {
this._styleSheet = styleSheet;
this._styleSheet.ref();
this._parentTypeKey = providerArgs.parentTypeKey!;
this.refCount = 0;
this._beforeContentRules = new DecorationCSSRules(ModelDecorationCSSRuleType.BeforeContentClassName, providerArgs, themeService);
this._afterContentRules = new DecorationCSSRules(ModelDecorationCSSRuleType.AfterContentClassName, providerArgs, themeService);
}
public getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions {
const options = codeEditorService.resolveDecorationOptions(this._parentTypeKey, true);
if (this._beforeContentRules) {
options.beforeContentClassName = this._beforeContentRules.className;
}
if (this._afterContentRules) {
options.afterContentClassName = this._afterContentRules.className;
}
return options;
}
public resolveDecorationCSSRules(): CSSRuleList {
return this._styleSheet.sheet.cssRules;
}
public dispose(): void {
if (this._beforeContentRules) {
this._beforeContentRules.dispose();
this._beforeContentRules = null;
}
if (this._afterContentRules) {
this._afterContentRules.dispose();
this._afterContentRules = null;
}
this._styleSheet.unref();
}
}
interface ProviderArguments {
styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
key: string;
parentTypeKey?: string;
options: IDecorationRenderOptions;
}
export class DecorationTypeOptionsProvider implements IModelDecorationOptionsProvider {
private readonly _disposables = new DisposableStore();
private readonly _styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
public refCount: number;
public description: string;
public className: string | undefined;
public inlineClassName: string | undefined;
public inlineClassNameAffectsLetterSpacing: boolean | undefined;
public beforeContentClassName: string | undefined;
public afterContentClassName: string | undefined;
public glyphMarginClassName: string | undefined;
public isWholeLine: boolean;
public overviewRuler: IModelDecorationOverviewRulerOptions | undefined;
public stickiness: TrackedRangeStickiness | undefined;
public beforeInjectedText: InjectedTextOptions | undefined;
public afterInjectedText: InjectedTextOptions | undefined;
constructor(description: string, themeService: IThemeService, styleSheet: GlobalStyleSheet | RefCountedStyleSheet, providerArgs: ProviderArguments) {
this.description = description;
this._styleSheet = styleSheet;
this._styleSheet.ref();
this.refCount = 0;
const createCSSRules = (type: ModelDecorationCSSRuleType) => {
const rules = new DecorationCSSRules(type, providerArgs, themeService);
this._disposables.add(rules);
if (rules.hasContent) {
return rules.className;
}
return undefined;
};
const createInlineCSSRules = (type: ModelDecorationCSSRuleType) => {
const rules = new DecorationCSSRules(type, providerArgs, themeService);
this._disposables.add(rules);
if (rules.hasContent) {
return { className: rules.className, hasLetterSpacing: rules.hasLetterSpacing };
}
return null;
};
this.className = createCSSRules(ModelDecorationCSSRuleType.ClassName);
const inlineData = createInlineCSSRules(ModelDecorationCSSRuleType.InlineClassName);
if (inlineData) {
this.inlineClassName = inlineData.className;
this.inlineClassNameAffectsLetterSpacing = inlineData.hasLetterSpacing;
}
this.beforeContentClassName = createCSSRules(ModelDecorationCSSRuleType.BeforeContentClassName);
this.afterContentClassName = createCSSRules(ModelDecorationCSSRuleType.AfterContentClassName);
if (providerArgs.options.beforeInjectedText && providerArgs.options.beforeInjectedText.contentText) {
const beforeInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.BeforeInjectedTextClassName);
this.beforeInjectedText = {
content: providerArgs.options.beforeInjectedText.contentText,
inlineClassName: beforeInlineData?.className,
inlineClassNameAffectsLetterSpacing: beforeInlineData?.hasLetterSpacing || providerArgs.options.beforeInjectedText.affectsLetterSpacing
};
}
if (providerArgs.options.afterInjectedText && providerArgs.options.afterInjectedText.contentText) {
const afterInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.AfterInjectedTextClassName);
this.afterInjectedText = {
content: providerArgs.options.afterInjectedText.contentText,
inlineClassName: afterInlineData?.className,
inlineClassNameAffectsLetterSpacing: afterInlineData?.hasLetterSpacing || providerArgs.options.afterInjectedText.affectsLetterSpacing
};
}
this.glyphMarginClassName = createCSSRules(ModelDecorationCSSRuleType.GlyphMarginClassName);
const options = providerArgs.options;
this.isWholeLine = Boolean(options.isWholeLine);
this.stickiness = options.rangeBehavior;
const lightOverviewRulerColor = options.light && options.light.overviewRulerColor || options.overviewRulerColor;
const darkOverviewRulerColor = options.dark && options.dark.overviewRulerColor || options.overviewRulerColor;
if (
typeof lightOverviewRulerColor !== 'undefined'
|| typeof darkOverviewRulerColor !== 'undefined'
) {
this.overviewRuler = {
color: lightOverviewRulerColor || darkOverviewRulerColor,
darkColor: darkOverviewRulerColor || lightOverviewRulerColor,
position: options.overviewRulerLane || OverviewRulerLane.Center
};
}
}
public getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions {
if (!writable) {
return this;
}
return {
description: this.description,
inlineClassName: this.inlineClassName,
beforeContentClassName: this.beforeContentClassName,
afterContentClassName: this.afterContentClassName,
className: this.className,
glyphMarginClassName: this.glyphMarginClassName,
isWholeLine: this.isWholeLine,
overviewRuler: this.overviewRuler,
stickiness: this.stickiness,
before: this.beforeInjectedText,
after: this.afterInjectedText
};
}
public resolveDecorationCSSRules(): CSSRuleList {
return this._styleSheet.sheet.rules;
}
public dispose(): void {
this._disposables.dispose();
this._styleSheet.unref();
}
}
export const _CSS_MAP: { [prop: string]: string } = {
color: 'color:{0} !important;',
opacity: 'opacity:{0};',
backgroundColor: 'background-color:{0};',
outline: 'outline:{0};',
outlineColor: 'outline-color:{0};',
outlineStyle: 'outline-style:{0};',
outlineWidth: 'outline-width:{0};',
border: 'border:{0};',
borderColor: 'border-color:{0};',
borderRadius: 'border-radius:{0};',
borderSpacing: 'border-spacing:{0};',
borderStyle: 'border-style:{0};',
borderWidth: 'border-width:{0};',
fontStyle: 'font-style:{0};',
fontWeight: 'font-weight:{0};',
fontSize: 'font-size:{0};',
fontFamily: 'font-family:{0};',
textDecoration: 'text-decoration:{0};',
cursor: 'cursor:{0};',
letterSpacing: 'letter-spacing:{0};',
gutterIconPath: 'background:{0} center center no-repeat;',
gutterIconSize: 'background-size:{0};',
contentText: 'content:\'{0}\';',
contentIconPath: 'content:{0};',
margin: 'margin:{0};',
padding: 'padding:{0};',
width: 'width:{0};',
height: 'height:{0};',
verticalAlign: 'vertical-align:{0};',
};
class DecorationCSSRules {
private _theme: IColorTheme;
private readonly _className: string;
private readonly _unThemedSelector: string;
private _hasContent: boolean;
private _hasLetterSpacing: boolean;
private readonly _ruleType: ModelDecorationCSSRuleType;
private _themeListener: IDisposable | null;
private readonly _providerArgs: ProviderArguments;
private _usesThemeColors: boolean;
constructor(ruleType: ModelDecorationCSSRuleType, providerArgs: ProviderArguments, themeService: IThemeService) {
this._theme = themeService.getColorTheme();
this._ruleType = ruleType;
this._providerArgs = providerArgs;
this._usesThemeColors = false;
this._hasContent = false;
this._hasLetterSpacing = false;
let className = CSSNameHelper.getClassName(this._providerArgs.key, ruleType);
if (this._providerArgs.parentTypeKey) {
className = className + ' ' + CSSNameHelper.getClassName(this._providerArgs.parentTypeKey, ruleType);
}
this._className = className;
this._unThemedSelector = CSSNameHelper.getSelector(this._providerArgs.key, this._providerArgs.parentTypeKey, ruleType);
this._buildCSS();
if (this._usesThemeColors) {
this._themeListener = themeService.onDidColorThemeChange(theme => {
this._theme = themeService.getColorTheme();
this._removeCSS();
this._buildCSS();
});
} else {
this._themeListener = null;
}
}
public dispose() {
if (this._hasContent) {
this._removeCSS();
this._hasContent = false;
}
if (this._themeListener) {
this._themeListener.dispose();
this._themeListener = null;
}
}
public get hasContent(): boolean {
return this._hasContent;
}
public get hasLetterSpacing(): boolean {
return this._hasLetterSpacing;
}
public get className(): string {
return this._className;
}
private _buildCSS(): void {
const options = this._providerArgs.options;
let unthemedCSS: string, lightCSS: string, darkCSS: string;
switch (this._ruleType) {
case ModelDecorationCSSRuleType.ClassName:
unthemedCSS = this.getCSSTextForModelDecorationClassName(options);
lightCSS = this.getCSSTextForModelDecorationClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationClassName(options.dark);
break;
case ModelDecorationCSSRuleType.InlineClassName:
unthemedCSS = this.getCSSTextForModelDecorationInlineClassName(options);
lightCSS = this.getCSSTextForModelDecorationInlineClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationInlineClassName(options.dark);
break;
case ModelDecorationCSSRuleType.GlyphMarginClassName:
unthemedCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options);
lightCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.dark);
break;
case ModelDecorationCSSRuleType.BeforeContentClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.before);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.before);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.before);
break;
case ModelDecorationCSSRuleType.AfterContentClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.after);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.after);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.after);
break;
case ModelDecorationCSSRuleType.BeforeInjectedTextClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.beforeInjectedText);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.beforeInjectedText);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.beforeInjectedText);
break;
case ModelDecorationCSSRuleType.AfterInjectedTextClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.afterInjectedText);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.afterInjectedText);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.afterInjectedText);
break;
default:
throw new Error('Unknown rule type: ' + this._ruleType);
}
const sheet = this._providerArgs.styleSheet;
let hasContent = false;
if (unthemedCSS.length > 0) {
sheet.insertRule(`${this._unThemedSelector} {${unthemedCSS}}`, 0);
hasContent = true;
}
if (lightCSS.length > 0) {
sheet.insertRule(`.vs${this._unThemedSelector}, .hc-light${this._unThemedSelector} {${lightCSS}}`, 0);
hasContent = true;
}
if (darkCSS.length > 0) {
sheet.insertRule(`.vs-dark${this._unThemedSelector}, .hc-black${this._unThemedSelector} {${darkCSS}}`, 0);
hasContent = true;
}
this._hasContent = hasContent;
}
private _removeCSS(): void {
this._providerArgs.styleSheet.removeRulesContainingSelector(this._unThemedSelector);
}
/**
* Build the CSS for decorations styled via `className`.
*/
private getCSSTextForModelDecorationClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
this.collectCSSText(opts, ['backgroundColor'], cssTextArr);
this.collectCSSText(opts, ['outline', 'outlineColor', 'outlineStyle', 'outlineWidth'], cssTextArr);
this.collectBorderSettingsCSSText(opts, cssTextArr);
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled via `inlineClassName`.
*/
private getCSSTextForModelDecorationInlineClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
this.collectCSSText(opts, ['fontStyle', 'fontWeight', 'textDecoration', 'cursor', 'color', 'opacity', 'letterSpacing'], cssTextArr);
if (opts.letterSpacing) {
this._hasLetterSpacing = true;
}
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled before or after content.
*/
private getCSSTextForModelDecorationContentClassName(opts: IContentDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
if (typeof opts !== 'undefined') {
this.collectBorderSettingsCSSText(opts, cssTextArr);
if (typeof opts.contentIconPath !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.contentIconPath, dom.asCSSUrl(URI.revive(opts.contentIconPath))));
}
if (typeof opts.contentText === 'string') {
const truncated = opts.contentText.match(/^.*$/m)![0]; // only take first line
const escaped = truncated.replace(/['\\]/g, '\\$&');
cssTextArr.push(strings.format(_CSS_MAP.contentText, escaped));
}
this.collectCSSText(opts, ['verticalAlign', 'fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'textDecoration', 'color', 'opacity', 'backgroundColor', 'margin', 'padding'], cssTextArr);
if (this.collectCSSText(opts, ['width', 'height'], cssTextArr)) {
cssTextArr.push('display:inline-block;');
}
}
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled via `glpyhMarginClassName`.
*/
private getCSSTextForModelDecorationGlyphMarginClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
if (typeof opts.gutterIconPath !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconPath, dom.asCSSUrl(URI.revive(opts.gutterIconPath))));
if (typeof opts.gutterIconSize !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconSize, opts.gutterIconSize));
}
}
return cssTextArr.join('');
}
private collectBorderSettingsCSSText(opts: any, cssTextArr: string[]): boolean {
if (this.collectCSSText(opts, ['border', 'borderColor', 'borderRadius', 'borderSpacing', 'borderStyle', 'borderWidth'], cssTextArr)) {
cssTextArr.push(strings.format('box-sizing: border-box;'));
return true;
}
return false;
}
private collectCSSText(opts: any, properties: string[], cssTextArr: string[]): boolean {
const lenBefore = cssTextArr.length;
for (let property of properties) {
const value = this.resolveValue(opts[property]);
if (typeof value === 'string') {
cssTextArr.push(strings.format(_CSS_MAP[property], value));
}
}
return cssTextArr.length !== lenBefore;
}
private resolveValue(value: string | ThemeColor): string {
if (isThemeColor(value)) {
this._usesThemeColors = true;
const color = this._theme.getColor(value.id);
if (color) {
return color.toString();
}
return 'transparent';
}
return value;
}
}
const enum ModelDecorationCSSRuleType {
ClassName = 0,
InlineClassName = 1,
GlyphMarginClassName = 2,
BeforeContentClassName = 3,
AfterContentClassName = 4,
BeforeInjectedTextClassName = 5,
AfterInjectedTextClassName = 6,
}
class CSSNameHelper {
public static getClassName(key: string, type: ModelDecorationCSSRuleType): string {
return 'ced-' + key + '-' + type;
}
public static getSelector(key: string, parentKey: string | undefined, ruleType: ModelDecorationCSSRuleType): string {
let selector = '.monaco-editor .' + this.getClassName(key, ruleType);
if (parentKey) {
selector = selector + '.' + this.getClassName(parentKey, ruleType);
}
if (ruleType === ModelDecorationCSSRuleType.BeforeContentClassName) {
selector += '::before';
} else if (ruleType === ModelDecorationCSSRuleType.AfterContentClassName) {
selector += '::after';
}
return selector;
}
}

4
src/vs/editor/browser/services/bulkEditService.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { TextEdit, WorkspaceEdit, WorkspaceEditMetadata, WorkspaceFileEdit, WorkspaceFileEditOptions, WorkspaceTextEdit } from 'vs/editor/common/modes';
import { TextEdit, WorkspaceEdit, WorkspaceEditMetadata, WorkspaceFileEdit, WorkspaceFileEditOptions, WorkspaceTextEdit } from 'vs/editor/common/languages';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IProgress, IProgressStep } from 'vs/platform/progress/common/progress';
import { IDisposable } from 'vs/base/common/lifecycle';
@@ -70,10 +70,12 @@ export interface IBulkEditOptions {
token?: CancellationToken;
showPreview?: boolean;
label?: string;
code?: string;
quotableLabel?: string;
undoRedoSource?: UndoRedoSource;
undoRedoGroupId?: number;
confirmBeforeUndo?: boolean;
respectAutoSaveConfig?: boolean;
}
export interface IBulkEditResult {

662
src/vs/editor/browser/services/codeEditorServiceImpl.ts
View File

@@ -1,662 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as dom from 'vs/base/browser/dom';
import { IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
import * as strings from 'vs/base/common/strings';
import { URI } from 'vs/base/common/uri';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { AbstractCodeEditorService } from 'vs/editor/browser/services/abstractCodeEditorService';
import { IContentDecorationRenderOptions, IDecorationRenderOptions, IThemeDecorationRenderOptions, isThemeColor } from 'vs/editor/common/editorCommon';
import { IModelDecorationOptions, IModelDecorationOverviewRulerOptions, InjectedTextOptions, OverviewRulerLane, TrackedRangeStickiness } from 'vs/editor/common/model';
import { IColorTheme, IThemeService, ThemeColor } from 'vs/platform/theme/common/themeService';
export class RefCountedStyleSheet {
private readonly _parent: CodeEditorServiceImpl;
private readonly _editorId: string;
private readonly _styleSheet: HTMLStyleElement;
private _refCount: number;
public get sheet() {
return this._styleSheet.sheet as CSSStyleSheet;
}
constructor(parent: CodeEditorServiceImpl, editorId: string, styleSheet: HTMLStyleElement) {
this._parent = parent;
this._editorId = editorId;
this._styleSheet = styleSheet;
this._refCount = 0;
}
public ref(): void {
this._refCount++;
}
public unref(): void {
this._refCount--;
if (this._refCount === 0) {
this._styleSheet.parentNode?.removeChild(this._styleSheet);
this._parent._removeEditorStyleSheets(this._editorId);
}
}
public insertRule(rule: string, index?: number): void {
const sheet = <CSSStyleSheet>this._styleSheet.sheet;
sheet.insertRule(rule, index);
}
public removeRulesContainingSelector(ruleName: string): void {
dom.removeCSSRulesContainingSelector(ruleName, this._styleSheet);
}
}
export class GlobalStyleSheet {
private readonly _styleSheet: HTMLStyleElement;
public get sheet() {
return this._styleSheet.sheet as CSSStyleSheet;
}
constructor(styleSheet: HTMLStyleElement) {
this._styleSheet = styleSheet;
}
public ref(): void {
}
public unref(): void {
}
public insertRule(rule: string, index?: number): void {
const sheet = <CSSStyleSheet>this._styleSheet.sheet;
sheet.insertRule(rule, index);
}
public removeRulesContainingSelector(ruleName: string): void {
dom.removeCSSRulesContainingSelector(ruleName, this._styleSheet);
}
}
export abstract class CodeEditorServiceImpl extends AbstractCodeEditorService {
private _globalStyleSheet: GlobalStyleSheet | null;
private readonly _decorationOptionProviders = new Map<string, IModelDecorationOptionsProvider>();
private readonly _editorStyleSheets = new Map<string, RefCountedStyleSheet>();
private readonly _themeService: IThemeService;
constructor(
styleSheet: GlobalStyleSheet | null,
@IThemeService themeService: IThemeService,
) {
super();
this._globalStyleSheet = styleSheet ? styleSheet : null;
this._themeService = themeService;
}
private _getOrCreateGlobalStyleSheet(): GlobalStyleSheet {
if (!this._globalStyleSheet) {
this._globalStyleSheet = new GlobalStyleSheet(dom.createStyleSheet());
}
return this._globalStyleSheet;
}
private _getOrCreateStyleSheet(editor: ICodeEditor | undefined): GlobalStyleSheet | RefCountedStyleSheet {
if (!editor) {
return this._getOrCreateGlobalStyleSheet();
}
const domNode = editor.getContainerDomNode();
if (!dom.isInShadowDOM(domNode)) {
return this._getOrCreateGlobalStyleSheet();
}
const editorId = editor.getId();
if (!this._editorStyleSheets.has(editorId)) {
const refCountedStyleSheet = new RefCountedStyleSheet(this, editorId, dom.createStyleSheet(domNode));
this._editorStyleSheets.set(editorId, refCountedStyleSheet);
}
return this._editorStyleSheets.get(editorId)!;
}
_removeEditorStyleSheets(editorId: string): void {
this._editorStyleSheets.delete(editorId);
}
public registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): void {
let provider = this._decorationOptionProviders.get(key);
if (!provider) {
const styleSheet = this._getOrCreateStyleSheet(editor);
const providerArgs: ProviderArguments = {
styleSheet: styleSheet,
key: key,
parentTypeKey: parentTypeKey,
options: options || Object.create(null)
};
if (!parentTypeKey) {
provider = new DecorationTypeOptionsProvider(description, this._themeService, styleSheet, providerArgs);
} else {
provider = new DecorationSubTypeOptionsProvider(this._themeService, styleSheet, providerArgs);
}
this._decorationOptionProviders.set(key, provider);
this._onDecorationTypeRegistered.fire(key);
}
provider.refCount++;
}
public removeDecorationType(key: string): void {
const provider = this._decorationOptionProviders.get(key);
if (provider) {
provider.refCount--;
if (provider.refCount <= 0) {
this._decorationOptionProviders.delete(key);
provider.dispose();
this.listCodeEditors().forEach((ed) => ed.removeDecorations(key));
}
}
}
public resolveDecorationOptions(decorationTypeKey: string, writable: boolean): IModelDecorationOptions {
const provider = this._decorationOptionProviders.get(decorationTypeKey);
if (!provider) {
throw new Error('Unknown decoration type key: ' + decorationTypeKey);
}
return provider.getOptions(this, writable);
}
public resolveDecorationCSSRules(decorationTypeKey: string) {
const provider = this._decorationOptionProviders.get(decorationTypeKey);
if (!provider) {
return null;
}
return provider.resolveDecorationCSSRules();
}
}
interface IModelDecorationOptionsProvider extends IDisposable {
refCount: number;
getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions;
resolveDecorationCSSRules(): CSSRuleList;
}
export class DecorationSubTypeOptionsProvider implements IModelDecorationOptionsProvider {
private readonly _styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
public refCount: number;
private readonly _parentTypeKey: string | undefined;
private _beforeContentRules: DecorationCSSRules | null;
private _afterContentRules: DecorationCSSRules | null;
constructor(themeService: IThemeService, styleSheet: GlobalStyleSheet | RefCountedStyleSheet, providerArgs: ProviderArguments) {
this._styleSheet = styleSheet;
this._styleSheet.ref();
this._parentTypeKey = providerArgs.parentTypeKey;
this.refCount = 0;
this._beforeContentRules = new DecorationCSSRules(ModelDecorationCSSRuleType.BeforeContentClassName, providerArgs, themeService);
this._afterContentRules = new DecorationCSSRules(ModelDecorationCSSRuleType.AfterContentClassName, providerArgs, themeService);
}
public getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions {
const options = codeEditorService.resolveDecorationOptions(this._parentTypeKey, true);
if (this._beforeContentRules) {
options.beforeContentClassName = this._beforeContentRules.className;
}
if (this._afterContentRules) {
options.afterContentClassName = this._afterContentRules.className;
}
return options;
}
public resolveDecorationCSSRules(): CSSRuleList {
return this._styleSheet.sheet.cssRules;
}
public dispose(): void {
if (this._beforeContentRules) {
this._beforeContentRules.dispose();
this._beforeContentRules = null;
}
if (this._afterContentRules) {
this._afterContentRules.dispose();
this._afterContentRules = null;
}
this._styleSheet.unref();
}
}
interface ProviderArguments {
styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
key: string;
parentTypeKey?: string;
options: IDecorationRenderOptions;
}
export class DecorationTypeOptionsProvider implements IModelDecorationOptionsProvider {
private readonly _disposables = new DisposableStore();
private readonly _styleSheet: GlobalStyleSheet | RefCountedStyleSheet;
public refCount: number;
public description: string;
public className: string | undefined;
public inlineClassName: string | undefined;
public inlineClassNameAffectsLetterSpacing: boolean | undefined;
public beforeContentClassName: string | undefined;
public afterContentClassName: string | undefined;
public glyphMarginClassName: string | undefined;
public isWholeLine: boolean;
public overviewRuler: IModelDecorationOverviewRulerOptions | undefined;
public stickiness: TrackedRangeStickiness | undefined;
public beforeInjectedText: InjectedTextOptions | undefined;
public afterInjectedText: InjectedTextOptions | undefined;
constructor(description: string, themeService: IThemeService, styleSheet: GlobalStyleSheet | RefCountedStyleSheet, providerArgs: ProviderArguments) {
this.description = description;
this._styleSheet = styleSheet;
this._styleSheet.ref();
this.refCount = 0;
const createCSSRules = (type: ModelDecorationCSSRuleType) => {
const rules = new DecorationCSSRules(type, providerArgs, themeService);
this._disposables.add(rules);
if (rules.hasContent) {
return rules.className;
}
return undefined;
};
const createInlineCSSRules = (type: ModelDecorationCSSRuleType) => {
const rules = new DecorationCSSRules(type, providerArgs, themeService);
this._disposables.add(rules);
if (rules.hasContent) {
return { className: rules.className, hasLetterSpacing: rules.hasLetterSpacing };
}
return null;
};
this.className = createCSSRules(ModelDecorationCSSRuleType.ClassName);
const inlineData = createInlineCSSRules(ModelDecorationCSSRuleType.InlineClassName);
if (inlineData) {
this.inlineClassName = inlineData.className;
this.inlineClassNameAffectsLetterSpacing = inlineData.hasLetterSpacing;
}
this.beforeContentClassName = createCSSRules(ModelDecorationCSSRuleType.BeforeContentClassName);
this.afterContentClassName = createCSSRules(ModelDecorationCSSRuleType.AfterContentClassName);
if (providerArgs.options.beforeInjectedText && providerArgs.options.beforeInjectedText.contentText) {
const beforeInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.BeforeInjectedTextClassName);
this.beforeInjectedText = {
content: providerArgs.options.beforeInjectedText.contentText,
inlineClassName: beforeInlineData?.className,
inlineClassNameAffectsLetterSpacing: beforeInlineData?.hasLetterSpacing || providerArgs.options.beforeInjectedText.affectsLetterSpacing
};
}
if (providerArgs.options.afterInjectedText && providerArgs.options.afterInjectedText.contentText) {
const afterInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.AfterInjectedTextClassName);
this.afterInjectedText = {
content: providerArgs.options.afterInjectedText.contentText,
inlineClassName: afterInlineData?.className,
inlineClassNameAffectsLetterSpacing: afterInlineData?.hasLetterSpacing || providerArgs.options.afterInjectedText.affectsLetterSpacing
};
}
this.glyphMarginClassName = createCSSRules(ModelDecorationCSSRuleType.GlyphMarginClassName);
const options = providerArgs.options;
this.isWholeLine = Boolean(options.isWholeLine);
this.stickiness = options.rangeBehavior;
const lightOverviewRulerColor = options.light && options.light.overviewRulerColor || options.overviewRulerColor;
const darkOverviewRulerColor = options.dark && options.dark.overviewRulerColor || options.overviewRulerColor;
if (
typeof lightOverviewRulerColor !== 'undefined'
|| typeof darkOverviewRulerColor !== 'undefined'
) {
this.overviewRuler = {
color: lightOverviewRulerColor || darkOverviewRulerColor,
darkColor: darkOverviewRulerColor || lightOverviewRulerColor,
position: options.overviewRulerLane || OverviewRulerLane.Center
};
}
}
public getOptions(codeEditorService: AbstractCodeEditorService, writable: boolean): IModelDecorationOptions {
if (!writable) {
return this;
}
return {
description: this.description,
inlineClassName: this.inlineClassName,
beforeContentClassName: this.beforeContentClassName,
afterContentClassName: this.afterContentClassName,
className: this.className,
glyphMarginClassName: this.glyphMarginClassName,
isWholeLine: this.isWholeLine,
overviewRuler: this.overviewRuler,
stickiness: this.stickiness,
before: this.beforeInjectedText,
after: this.afterInjectedText
};
}
public resolveDecorationCSSRules(): CSSRuleList {
return this._styleSheet.sheet.rules;
}
public dispose(): void {
this._disposables.dispose();
this._styleSheet.unref();
}
}
export const _CSS_MAP: { [prop: string]: string; } = {
color: 'color:{0} !important;',
opacity: 'opacity:{0};',
backgroundColor: 'background-color:{0};',
outline: 'outline:{0};',
outlineColor: 'outline-color:{0};',
outlineStyle: 'outline-style:{0};',
outlineWidth: 'outline-width:{0};',
border: 'border:{0};',
borderColor: 'border-color:{0};',
borderRadius: 'border-radius:{0};',
borderSpacing: 'border-spacing:{0};',
borderStyle: 'border-style:{0};',
borderWidth: 'border-width:{0};',
fontStyle: 'font-style:{0};',
fontWeight: 'font-weight:{0};',
fontSize: 'font-size:{0};',
fontFamily: 'font-family:{0};',
textDecoration: 'text-decoration:{0};',
cursor: 'cursor:{0};',
letterSpacing: 'letter-spacing:{0};',
gutterIconPath: 'background:{0} center center no-repeat;',
gutterIconSize: 'background-size:{0};',
contentText: 'content:\'{0}\';',
contentIconPath: 'content:{0};',
margin: 'margin:{0};',
padding: 'padding:{0};',
width: 'width:{0};',
height: 'height:{0};',
verticalAlign: 'vertical-align:{0};',
};
class DecorationCSSRules {
private _theme: IColorTheme;
private readonly _className: string;
private readonly _unThemedSelector: string;
private _hasContent: boolean;
private _hasLetterSpacing: boolean;
private readonly _ruleType: ModelDecorationCSSRuleType;
private _themeListener: IDisposable | null;
private readonly _providerArgs: ProviderArguments;
private _usesThemeColors: boolean;
constructor(ruleType: ModelDecorationCSSRuleType, providerArgs: ProviderArguments, themeService: IThemeService) {
this._theme = themeService.getColorTheme();
this._ruleType = ruleType;
this._providerArgs = providerArgs;
this._usesThemeColors = false;
this._hasContent = false;
this._hasLetterSpacing = false;
let className = CSSNameHelper.getClassName(this._providerArgs.key, ruleType);
if (this._providerArgs.parentTypeKey) {
className = className + ' ' + CSSNameHelper.getClassName(this._providerArgs.parentTypeKey, ruleType);
}
this._className = className;
this._unThemedSelector = CSSNameHelper.getSelector(this._providerArgs.key, this._providerArgs.parentTypeKey, ruleType);
this._buildCSS();
if (this._usesThemeColors) {
this._themeListener = themeService.onDidColorThemeChange(theme => {
this._theme = themeService.getColorTheme();
this._removeCSS();
this._buildCSS();
});
} else {
this._themeListener = null;
}
}
public dispose() {
if (this._hasContent) {
this._removeCSS();
this._hasContent = false;
}
if (this._themeListener) {
this._themeListener.dispose();
this._themeListener = null;
}
}
public get hasContent(): boolean {
return this._hasContent;
}
public get hasLetterSpacing(): boolean {
return this._hasLetterSpacing;
}
public get className(): string {
return this._className;
}
private _buildCSS(): void {
const options = this._providerArgs.options;
let unthemedCSS: string, lightCSS: string, darkCSS: string;
switch (this._ruleType) {
case ModelDecorationCSSRuleType.ClassName:
unthemedCSS = this.getCSSTextForModelDecorationClassName(options);
lightCSS = this.getCSSTextForModelDecorationClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationClassName(options.dark);
break;
case ModelDecorationCSSRuleType.InlineClassName:
unthemedCSS = this.getCSSTextForModelDecorationInlineClassName(options);
lightCSS = this.getCSSTextForModelDecorationInlineClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationInlineClassName(options.dark);
break;
case ModelDecorationCSSRuleType.GlyphMarginClassName:
unthemedCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options);
lightCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.light);
darkCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.dark);
break;
case ModelDecorationCSSRuleType.BeforeContentClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.before);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.before);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.before);
break;
case ModelDecorationCSSRuleType.AfterContentClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.after);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.after);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.after);
break;
case ModelDecorationCSSRuleType.BeforeInjectedTextClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.beforeInjectedText);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.beforeInjectedText);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.beforeInjectedText);
break;
case ModelDecorationCSSRuleType.AfterInjectedTextClassName:
unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.afterInjectedText);
lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.afterInjectedText);
darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.afterInjectedText);
break;
default:
throw new Error('Unknown rule type: ' + this._ruleType);
}
const sheet = this._providerArgs.styleSheet;
let hasContent = false;
if (unthemedCSS.length > 0) {
sheet.insertRule(`${this._unThemedSelector} {${unthemedCSS}}`, 0);
hasContent = true;
}
if (lightCSS.length > 0) {
sheet.insertRule(`.vs${this._unThemedSelector} {${lightCSS}}`, 0);
hasContent = true;
}
if (darkCSS.length > 0) {
sheet.insertRule(`.vs-dark${this._unThemedSelector}, .hc-black${this._unThemedSelector} {${darkCSS}}`, 0);
hasContent = true;
}
this._hasContent = hasContent;
}
private _removeCSS(): void {
this._providerArgs.styleSheet.removeRulesContainingSelector(this._unThemedSelector);
}
/**
* Build the CSS for decorations styled via `className`.
*/
private getCSSTextForModelDecorationClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
this.collectCSSText(opts, ['backgroundColor'], cssTextArr);
this.collectCSSText(opts, ['outline', 'outlineColor', 'outlineStyle', 'outlineWidth'], cssTextArr);
this.collectBorderSettingsCSSText(opts, cssTextArr);
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled via `inlineClassName`.
*/
private getCSSTextForModelDecorationInlineClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
this.collectCSSText(opts, ['fontStyle', 'fontWeight', 'textDecoration', 'cursor', 'color', 'opacity', 'letterSpacing'], cssTextArr);
if (opts.letterSpacing) {
this._hasLetterSpacing = true;
}
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled before or after content.
*/
private getCSSTextForModelDecorationContentClassName(opts: IContentDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
if (typeof opts !== 'undefined') {
this.collectBorderSettingsCSSText(opts, cssTextArr);
if (typeof opts.contentIconPath !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.contentIconPath, dom.asCSSUrl(URI.revive(opts.contentIconPath))));
}
if (typeof opts.contentText === 'string') {
const truncated = opts.contentText.match(/^.*$/m)![0]; // only take first line
const escaped = truncated.replace(/['\\]/g, '\\$&');
cssTextArr.push(strings.format(_CSS_MAP.contentText, escaped));
}
this.collectCSSText(opts, ['verticalAlign', 'fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'textDecoration', 'color', 'opacity', 'backgroundColor', 'margin', 'padding'], cssTextArr);
if (this.collectCSSText(opts, ['width', 'height'], cssTextArr)) {
cssTextArr.push('display:inline-block;');
}
}
return cssTextArr.join('');
}
/**
* Build the CSS for decorations styled via `glpyhMarginClassName`.
*/
private getCSSTextForModelDecorationGlyphMarginClassName(opts: IThemeDecorationRenderOptions | undefined): string {
if (!opts) {
return '';
}
const cssTextArr: string[] = [];
if (typeof opts.gutterIconPath !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconPath, dom.asCSSUrl(URI.revive(opts.gutterIconPath))));
if (typeof opts.gutterIconSize !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconSize, opts.gutterIconSize));
}
}
return cssTextArr.join('');
}
private collectBorderSettingsCSSText(opts: any, cssTextArr: string[]): boolean {
if (this.collectCSSText(opts, ['border', 'borderColor', 'borderRadius', 'borderSpacing', 'borderStyle', 'borderWidth'], cssTextArr)) {
cssTextArr.push(strings.format('box-sizing: border-box;'));
return true;
}
return false;
}
private collectCSSText(opts: any, properties: string[], cssTextArr: string[]): boolean {
const lenBefore = cssTextArr.length;
for (let property of properties) {
const value = this.resolveValue(opts[property]);
if (typeof value === 'string') {
cssTextArr.push(strings.format(_CSS_MAP[property], value));
}
}
return cssTextArr.length !== lenBefore;
}
private resolveValue(value: string | ThemeColor): string {
if (isThemeColor(value)) {
this._usesThemeColors = true;
const color = this._theme.getColor(value.id);
if (color) {
return color.toString();
}
return 'transparent';
}
return value;
}
}
const enum ModelDecorationCSSRuleType {
ClassName = 0,
InlineClassName = 1,
GlyphMarginClassName = 2,
BeforeContentClassName = 3,
AfterContentClassName = 4,
BeforeInjectedTextClassName = 5,
AfterInjectedTextClassName = 6,
}
class CSSNameHelper {
public static getClassName(key: string, type: ModelDecorationCSSRuleType): string {
return 'ced-' + key + '-' + type;
}
public static getSelector(key: string, parentKey: string | undefined, ruleType: ModelDecorationCSSRuleType): string {
let selector = '.monaco-editor .' + this.getClassName(key, ruleType);
if (parentKey) {
selector = selector + '.' + this.getClassName(parentKey, ruleType);
}
if (ruleType === ModelDecorationCSSRuleType.BeforeContentClassName) {
selector += '::before';
} else if (ruleType === ModelDecorationCSSRuleType.AfterContentClassName) {
selector += '::after';
}
return selector;
}
}

129
src/vs/editor/common/services/editorWorkerServiceImpl.ts → src/vs/editor/browser/services/editorWorkerService.ts
View File

@@ -7,22 +7,25 @@ import { IntervalTimer, timeout } from 'vs/base/common/async';
import { Disposable, IDisposable, dispose, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
import { URI } from 'vs/base/common/uri';
import { SimpleWorkerClient, logOnceWebWorkerWarning, IWorkerClient } from 'vs/base/common/worker/simpleWorker';
import { DefaultWorkerFactory } from 'vs/base/worker/defaultWorkerFactory';
import { DefaultWorkerFactory } from 'vs/base/browser/defaultWorkerFactory';
import { Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import { IChange } from 'vs/editor/common/editorCommon';
import { IChange, IDiffComputationResult } from 'vs/editor/common/diff/diffComputer';
import { ITextModel } from 'vs/editor/common/model';
import * as modes from 'vs/editor/common/modes';
import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
import * as languages from 'vs/editor/common/languages';
import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
import { EditorSimpleWorker } from 'vs/editor/common/services/editorSimpleWorker';
import { IDiffComputationResult, IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
import { IModelService } from 'vs/editor/common/services/modelService';
import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfigurationService';
import { IEditorWorkerService, IUnicodeHighlightsResult } from 'vs/editor/common/services/editorWorker';
import { IModelService } from 'vs/editor/common/services/model';
import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration';
import { regExpFlags } from 'vs/base/common/strings';
import { isNonEmptyArray } from 'vs/base/common/arrays';
import { ILogService } from 'vs/platform/log/common/log';
import { StopWatch } from 'vs/base/common/stopwatch';
import { canceled } from 'vs/base/common/errors';
import { UnicodeHighlighterOptions } from 'vs/editor/common/services/unicodeTextModelHighlighter';
import { IEditorWorkerHost } from 'vs/editor/common/services/editorWorkerHost';
import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
/**
* Stop syncing a model to the worker if it was not needed for 1 min.
@@ -35,7 +38,7 @@ const STOP_SYNC_MODEL_DELTA_TIME_MS = 60 * 1000;
const STOP_WORKER_DELTA_TIME_MS = 5 * 60 * 1000;
function canSyncModel(modelService: IModelService, resource: URI): boolean {
let model = modelService.getModel(resource);
const model = modelService.getModel(resource);
if (!model) {
return false;
}
@@ -45,7 +48,7 @@ function canSyncModel(modelService: IModelService, resource: URI): boolean {
return true;
}
export class EditorWorkerServiceImpl extends Disposable implements IEditorWorkerService {
export class EditorWorkerService extends Disposable implements IEditorWorkerService {
declare readonly _serviceBrand: undefined;
@@ -56,15 +59,17 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
constructor(
@IModelService modelService: IModelService,
@ITextResourceConfigurationService configurationService: ITextResourceConfigurationService,
@ILogService logService: ILogService
@ILogService logService: ILogService,
@ILanguageConfigurationService languageConfigurationService: ILanguageConfigurationService,
@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
) {
super();
this._modelService = modelService;
this._workerManager = this._register(new WorkerManager(this._modelService));
this._workerManager = this._register(new WorkerManager(this._modelService, languageConfigurationService));
this._logService = logService;
// register default link-provider and default completions-provider
this._register(modes.LinkProviderRegistry.register({ language: '*', hasAccessToAllModels: true }, {
this._register(languageFeaturesService.linkProvider.register({ language: '*', hasAccessToAllModels: true }, {
provideLinks: (model, token) => {
if (!canSyncModel(this._modelService, model.uri)) {
return Promise.resolve({ links: [] }); // File too large
@@ -74,13 +79,21 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
});
}
}));
this._register(modes.CompletionProviderRegistry.register('*', new WordBasedCompletionItemProvider(this._workerManager, configurationService, this._modelService)));
this._register(languageFeaturesService.completionProvider.register('*', new WordBasedCompletionItemProvider(this._workerManager, configurationService, this._modelService, languageConfigurationService)));
}
public override dispose(): void {
super.dispose();
}
public canComputeUnicodeHighlights(uri: URI): boolean {
return canSyncModel(this._modelService, uri);
}
public computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult> {
return this._workerManager.withWorker().then(client => client.computedUnicodeHighlights(uri, options, range));
}
public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean, maxComputationTime: number): Promise<IDiffComputationResult | null> {
return this._workerManager.withWorker().then(client => client.computeDiff(original, modified, ignoreTrimWhitespace, maxComputationTime));
}
@@ -93,7 +106,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
return this._workerManager.withWorker().then(client => client.computeDirtyDiff(original, modified, ignoreTrimWhitespace));
}
public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[] | null | undefined): Promise<modes.TextEdit[] | undefined> {
public computeMoreMinimalEdits(resource: URI, edits: languages.TextEdit[] | null | undefined): Promise<languages.TextEdit[] | undefined> {
if (isNonEmptyArray(edits)) {
if (!canSyncModel(this._modelService, resource)) {
return Promise.resolve(edits); // File too large
@@ -112,7 +125,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
return (canSyncModel(this._modelService, resource));
}
public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<modes.IInplaceReplaceSupportResult | null> {
public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<languages.IInplaceReplaceSupportResult | null> {
return this._workerManager.withWorker().then(client => client.navigateValueSet(resource, range, up));
}
@@ -125,7 +138,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
}
}
class WordBasedCompletionItemProvider implements modes.CompletionItemProvider {
class WordBasedCompletionItemProvider implements languages.CompletionItemProvider {
private readonly _workerManager: WorkerManager;
private readonly _configurationService: ITextResourceConfigurationService;
@@ -136,17 +149,18 @@ class WordBasedCompletionItemProvider implements modes.CompletionItemProvider {
constructor(
workerManager: WorkerManager,
configurationService: ITextResourceConfigurationService,
modelService: IModelService
modelService: IModelService,
private readonly languageConfigurationService: ILanguageConfigurationService
) {
this._workerManager = workerManager;
this._configurationService = configurationService;
this._modelService = modelService;
}
async provideCompletionItems(model: ITextModel, position: Position): Promise<modes.CompletionList | undefined> {
async provideCompletionItems(model: ITextModel, position: Position): Promise<languages.CompletionList | undefined> {
type WordBasedSuggestionsConfig = {
wordBasedSuggestions?: boolean,
wordBasedSuggestionsMode?: 'currentDocument' | 'matchingDocuments' | 'allDocuments'
wordBasedSuggestions?: boolean;
wordBasedSuggestionsMode?: 'currentDocument' | 'matchingDocuments' | 'allDocuments';
};
const config = this._configurationService.getValue<WordBasedSuggestionsConfig>(model.uri, position, 'editor');
if (!config.wordBasedSuggestions) {
@@ -178,7 +192,7 @@ class WordBasedCompletionItemProvider implements modes.CompletionItemProvider {
return undefined; // File too large, no other files
}
const wordDefRegExp = LanguageConfigurationRegistry.getWordDefinition(model.getLanguageId());
const wordDefRegExp = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
const word = model.getWordAtPosition(position);
const replace = !word ? Range.fromPositions(position) : new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
const insert = replace.setEndPosition(position.lineNumber, position.column);
@@ -191,9 +205,9 @@ class WordBasedCompletionItemProvider implements modes.CompletionItemProvider {
return {
duration: data.duration,
suggestions: data.words.map((word): modes.CompletionItem => {
suggestions: data.words.map((word): languages.CompletionItem => {
return {
kind: modes.CompletionItemKind.Text,
kind: languages.CompletionItemKind.Text,
label: word,
insertText: word,
range: { insert, replace }
@@ -209,13 +223,13 @@ class WorkerManager extends Disposable {
private _editorWorkerClient: EditorWorkerClient | null;
private _lastWorkerUsedTime: number;
constructor(modelService: IModelService) {
constructor(modelService: IModelService, private readonly languageConfigurationService: ILanguageConfigurationService) {
super();
this._modelService = modelService;
this._editorWorkerClient = null;
this._lastWorkerUsedTime = (new Date()).getTime();
let stopWorkerInterval = this._register(new IntervalTimer());
const stopWorkerInterval = this._register(new IntervalTimer());
stopWorkerInterval.cancelAndSet(() => this._checkStopIdleWorker(), Math.round(STOP_WORKER_DELTA_TIME_MS / 2));
this._register(this._modelService.onModelRemoved(_ => this._checkStopEmptyWorker()));
@@ -237,7 +251,7 @@ class WorkerManager extends Disposable {
return;
}
let models = this._modelService.getModels();
const models = this._modelService.getModels();
if (models.length === 0) {
// There are no more models => nothing possible for me to do
this._editorWorkerClient.dispose();
@@ -253,7 +267,7 @@ class WorkerManager extends Disposable {
return;
}
let timeSinceLastWorkerUsedTime = (new Date()).getTime() - this._lastWorkerUsedTime;
const timeSinceLastWorkerUsedTime = (new Date()).getTime() - this._lastWorkerUsedTime;
if (timeSinceLastWorkerUsedTime > STOP_WORKER_DELTA_TIME_MS) {
this._editorWorkerClient.dispose();
this._editorWorkerClient = null;
@@ -263,7 +277,7 @@ class WorkerManager extends Disposable {
public withWorker(): Promise<EditorWorkerClient> {
this._lastWorkerUsedTime = (new Date()).getTime();
if (!this._editorWorkerClient) {
this._editorWorkerClient = new EditorWorkerClient(this._modelService, false, 'editorWorkerService');
this._editorWorkerClient = new EditorWorkerClient(this._modelService, false, 'editorWorkerService', this.languageConfigurationService);
}
return Promise.resolve(this._editorWorkerClient);
}
@@ -273,8 +287,8 @@ class EditorModelManager extends Disposable {
private readonly _proxy: EditorSimpleWorker;
private readonly _modelService: IModelService;
private _syncedModels: { [modelUrl: string]: IDisposable; } = Object.create(null);
private _syncedModelsLastUsedTime: { [modelUrl: string]: number; } = Object.create(null);
private _syncedModels: { [modelUrl: string]: IDisposable } = Object.create(null);
private _syncedModelsLastUsedTime: { [modelUrl: string]: number } = Object.create(null);
constructor(proxy: EditorSimpleWorker, modelService: IModelService, keepIdleModels: boolean) {
super();
@@ -282,7 +296,7 @@ class EditorModelManager extends Disposable {
this._modelService = modelService;
if (!keepIdleModels) {
let timer = new IntervalTimer();
const timer = new IntervalTimer();
timer.cancelAndSet(() => this._checkStopModelSync(), Math.round(STOP_SYNC_MODEL_DELTA_TIME_MS / 2));
this._register(timer);
}
@@ -299,7 +313,7 @@ class EditorModelManager extends Disposable {
public ensureSyncedResources(resources: URI[], forceLargeModels: boolean): void {
for (const resource of resources) {
let resourceStr = resource.toString();
const resourceStr = resource.toString();
if (!this._syncedModels[resourceStr]) {
this._beginModelSync(resource, forceLargeModels);
@@ -311,11 +325,11 @@ class EditorModelManager extends Disposable {
}
private _checkStopModelSync(): void {
let currentTime = (new Date()).getTime();
const currentTime = (new Date()).getTime();
let toRemove: string[] = [];
const toRemove: string[] = [];
for (let modelUrl in this._syncedModelsLastUsedTime) {
let elapsedTime = currentTime - this._syncedModelsLastUsedTime[modelUrl];
const elapsedTime = currentTime - this._syncedModelsLastUsedTime[modelUrl];
if (elapsedTime > STOP_SYNC_MODEL_DELTA_TIME_MS) {
toRemove.push(modelUrl);
}
@@ -327,7 +341,7 @@ class EditorModelManager extends Disposable {
}
private _beginModelSync(resource: URI, forceLargeModels: boolean): void {
let model = this._modelService.getModel(resource);
const model = this._modelService.getModel(resource);
if (!model) {
return;
}
@@ -335,7 +349,7 @@ class EditorModelManager extends Disposable {
return;
}
let modelUrl = resource.toString();
const modelUrl = resource.toString();
this._proxy.acceptNewModel({
url: model.uri.toString(),
@@ -359,7 +373,7 @@ class EditorModelManager extends Disposable {
}
private _stopModelSync(modelUrl: string): void {
let toDispose = this._syncedModels[modelUrl];
const toDispose = this._syncedModels[modelUrl];
delete this._syncedModels[modelUrl];
delete this._syncedModelsLastUsedTime[modelUrl];
dispose(toDispose);
@@ -388,7 +402,7 @@ export interface IEditorWorkerClient {
fhr(method: string, args: any[]): Promise<any>;
}
export class EditorWorkerHost {
export class EditorWorkerHost implements IEditorWorkerHost {
private readonly _workerClient: IEditorWorkerClient;
@@ -411,7 +425,12 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
private _modelManager: EditorModelManager | null;
private _disposed = false;
constructor(modelService: IModelService, keepIdleModels: boolean, label: string | undefined) {
constructor(
modelService: IModelService,
keepIdleModels: boolean,
label: string | undefined,
private readonly languageConfigurationService: ILanguageConfigurationService
) {
super();
this._modelService = modelService;
this._keepIdleModels = keepIdleModels;
@@ -466,6 +485,12 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
});
}
public computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult> {
return this._withSyncedResources([uri]).then(proxy => {
return proxy.computeUnicodeHighlights(uri.toString(), options, range);
});
}
public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean, maxComputationTime: number): Promise<IDiffComputationResult | null> {
return this._withSyncedResources([original, modified], /* forceLargeModels */true).then(proxy => {
return proxy.computeDiff(original.toString(), modified.toString(), ignoreTrimWhitespace, maxComputationTime);
@@ -478,19 +503,19 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
});
}
public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[]): Promise<modes.TextEdit[]> {
public computeMoreMinimalEdits(resource: URI, edits: languages.TextEdit[]): Promise<languages.TextEdit[]> {
return this._withSyncedResources([resource]).then(proxy => {
return proxy.computeMoreMinimalEdits(resource.toString(), edits);
});
}
public computeLinks(resource: URI): Promise<modes.ILink[] | null> {
public computeLinks(resource: URI): Promise<languages.ILink[] | null> {
return this._withSyncedResources([resource]).then(proxy => {
return proxy.computeLinks(resource.toString());
});
}
public async textualSuggest(resources: URI[], leadingWord: string | undefined, wordDefRegExp: RegExp): Promise<{ words: string[], duration: number } | null> {
public async textualSuggest(resources: URI[], leadingWord: string | undefined, wordDefRegExp: RegExp): Promise<{ words: string[]; duration: number } | null> {
const proxy = await this._withSyncedResources(resources);
const wordDef = wordDefRegExp.source;
const wordDefFlags = regExpFlags(wordDefRegExp);
@@ -499,26 +524,26 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
computeWordRanges(resource: URI, range: IRange): Promise<{ [word: string]: IRange[] } | null> {
return this._withSyncedResources([resource]).then(proxy => {
let model = this._modelService.getModel(resource);
const model = this._modelService.getModel(resource);
if (!model) {
return Promise.resolve(null);
}
let wordDefRegExp = LanguageConfigurationRegistry.getWordDefinition(model.getLanguageId());
let wordDef = wordDefRegExp.source;
let wordDefFlags = regExpFlags(wordDefRegExp);
const wordDefRegExp = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
const wordDef = wordDefRegExp.source;
const wordDefFlags = regExpFlags(wordDefRegExp);
return proxy.computeWordRanges(resource.toString(), range, wordDef, wordDefFlags);
});
}
public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<modes.IInplaceReplaceSupportResult | null> {
public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<languages.IInplaceReplaceSupportResult | null> {
return this._withSyncedResources([resource]).then(proxy => {
let model = this._modelService.getModel(resource);
const model = this._modelService.getModel(resource);
if (!model) {
return null;
}
let wordDefRegExp = LanguageConfigurationRegistry.getWordDefinition(model.getLanguageId());
let wordDef = wordDefRegExp.source;
let wordDefFlags = regExpFlags(wordDefRegExp);
const wordDefRegExp = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
const wordDef = wordDefRegExp.source;
const wordDefFlags = regExpFlags(wordDefRegExp);
return proxy.navigateValueSet(resource.toString(), range, up, wordDef, wordDefFlags);
});
}

2
src/vs/editor/browser/services/markerDecorations.ts
View File

@@ -3,7 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IMarkerDecorationsService } from 'vs/editor/common/services/markersDecorationService';
import { IMarkerDecorationsService } from 'vs/editor/common/services/markerDecorations';
import { registerEditorContribution } from 'vs/editor/browser/editorExtensions';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { IEditorContribution } from 'vs/editor/common/editorCommon';

24
src/vs/editor/browser/services/openerService.ts
View File

@@ -14,8 +14,8 @@ import { normalizePath } from 'vs/base/common/resources';
import { URI } from 'vs/base/common/uri';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { ICommandService } from 'vs/platform/commands/common/commands';
import { EditorOpenContext } from 'vs/platform/editor/common/editor';
import { IExternalOpener, IExternalUriResolver, IOpener, IOpenerService, IResolvedExternalUri, IValidator, matchesScheme, OpenOptions, ResolveExternalUriOptions } from 'vs/platform/opener/common/opener';
import { EditorOpenSource } from 'vs/platform/editor/common/editor';
import { extractSelection, IExternalOpener, IExternalUriResolver, IOpener, IOpenerService, IResolvedExternalUri, IValidator, matchesScheme, matchesSomeScheme, OpenOptions, ResolveExternalUriOptions } from 'vs/platform/opener/common/opener';
class CommandOpener implements IOpener {
@@ -62,18 +62,8 @@ class EditorOpener implements IOpener {
if (typeof target === 'string') {
target = URI.parse(target);
}
let selection: { startLineNumber: number; startColumn: number; } | undefined = undefined;
const match = /^L?(\d+)(?:,(\d+))?/.exec(target.fragment);
if (match) {
// support file:///some/file.js#73,84
// support file:///some/file.js#L73
selection = {
startLineNumber: parseInt(match[1]),
startColumn: match[2] ? parseInt(match[2]) : 1
};
// remove fragment
target = target.with({ fragment: '' });
}
const { selection, uri } = extractSelection(target);
target = uri;
if (target.scheme === Schemas.file) {
target = normalizePath(target); // workaround for non-normalized paths (https://github.com/microsoft/vscode/issues/12954)
@@ -84,7 +74,7 @@ class EditorOpener implements IOpener {
resource: target as URI, // {{SQL CARBON EDIT}} Cast to URI to fix strict compiler error
options: {
selection,
context: options?.fromUserGesture ? EditorOpenContext.USER : EditorOpenContext.API,
source: options?.fromUserGesture ? EditorOpenSource.USER : EditorOpenSource.API,
...options?.editorOptions
}
},
@@ -119,7 +109,7 @@ export class OpenerService implements IOpenerService {
// to not trigger a navigation. Any other link is
// safe to be set as HREF to prevent a blank window
// from opening.
if (matchesScheme(href, Schemas.http) || matchesScheme(href, Schemas.https)) {
if (matchesSomeScheme(href, Schemas.http, Schemas.https)) {
dom.windowOpenNoOpener(href);
} else {
window.location.href = href;
@@ -131,7 +121,7 @@ export class OpenerService implements IOpenerService {
// Default opener: any external, maito, http(s), command, and catch-all-editors
this._openers.push({
open: async (target: URI | string, options?: OpenOptions) => {
if (options?.openExternal || matchesScheme(target, Schemas.mailto) || matchesScheme(target, Schemas.http) || matchesScheme(target, Schemas.https)) {
if (options?.openExternal || matchesSomeScheme(target, Schemas.mailto, Schemas.http, Schemas.https, Schemas.vsls)) {
// open externally
await this._doOpenExternal(target, options);
return true;

17
src/vs/editor/common/services/webWorker.ts → src/vs/editor/browser/services/webWorker.ts
View File

@@ -4,16 +4,17 @@
*--------------------------------------------------------------------------------------------*/
import { URI } from 'vs/base/common/uri';
import { EditorWorkerClient } from 'vs/editor/common/services/editorWorkerServiceImpl';
import { IModelService } from 'vs/editor/common/services/modelService';
import { EditorWorkerClient } from 'vs/editor/browser/services/editorWorkerService';
import { IModelService } from 'vs/editor/common/services/model';
import * as types from 'vs/base/common/types';
import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
/**
* Create a new web worker that has model syncing capabilities built in.
* Specify an AMD module to load that will `create` an object that will be proxied.
*/
export function createWebWorker<T>(modelService: IModelService, opts: IWebWorkerOptions): MonacoWebWorker<T> {
return new MonacoWebWorkerImpl<T>(modelService, opts);
export function createWebWorker<T extends object>(modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions): MonacoWebWorker<T> {
return new MonacoWebWorkerImpl<T>(modelService, languageConfigurationService, opts);
}
/**
@@ -60,15 +61,15 @@ export interface IWebWorkerOptions {
keepIdleModels?: boolean;
}
class MonacoWebWorkerImpl<T> extends EditorWorkerClient implements MonacoWebWorker<T> {
class MonacoWebWorkerImpl<T extends object> extends EditorWorkerClient implements MonacoWebWorker<T> {
private readonly _foreignModuleId: string;
private readonly _foreignModuleHost: { [method: string]: Function } | null;
private _foreignModuleCreateData: any | null;
private _foreignProxy: Promise<T> | null;
constructor(modelService: IModelService, opts: IWebWorkerOptions) {
super(modelService, opts.keepIdleModels || false, opts.label);
constructor(modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions) {
super(modelService, opts.keepIdleModels || false, opts.label, languageConfigurationService);
this._foreignModuleId = opts.moduleId;
this._foreignModuleCreateData = opts.createData || null;
this._foreignModuleHost = opts.host || null;
@@ -106,7 +107,7 @@ class MonacoWebWorkerImpl<T> extends EditorWorkerClient implements MonacoWebWork
};
};
let foreignProxy = {} as T;
const foreignProxy = {} as T;
for (const foreignMethod of foreignMethods) {
(<any>foreignProxy)[foreignMethod] = createProxyMethod(foreignMethod, proxyMethodRequest);
}

49
src/vs/editor/browser/stableEditorScroll.ts Normal file
View File

@@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { Position } from 'vs/editor/common/core/position';
export class StableEditorScrollState {
public static capture(editor: ICodeEditor): StableEditorScrollState {
let visiblePosition: Position | null = null;
let visiblePositionScrollDelta = 0;
if (editor.getScrollTop() !== 0) {
const visibleRanges = editor.getVisibleRanges();
if (visibleRanges.length > 0) {
visiblePosition = visibleRanges[0].getStartPosition();
const visiblePositionScrollTop = editor.getTopForPosition(visiblePosition.lineNumber, visiblePosition.column);
visiblePositionScrollDelta = editor.getScrollTop() - visiblePositionScrollTop;
}
}
return new StableEditorScrollState(visiblePosition, visiblePositionScrollDelta, editor.getPosition());
}
constructor(
private readonly _visiblePosition: Position | null,
private readonly _visiblePositionScrollDelta: number,
private readonly _cursorPosition: Position | null
) {
}
public restore(editor: ICodeEditor): void {
if (this._visiblePosition) {
const visiblePositionScrollTop = editor.getTopForPosition(this._visiblePosition.lineNumber, this._visiblePosition.column);
editor.setScrollTop(visiblePositionScrollTop + this._visiblePositionScrollDelta);
}
}
public restoreRelativeVerticalPositionOfCursor(editor: ICodeEditor): void {
const currentCursorPosition = editor.getPosition();
if (!this._cursorPosition || !currentCursorPosition) {
return;
}
const offset = editor.getTopForLineNumber(currentCursorPosition.lineNumber) - editor.getTopForLineNumber(this._cursorPosition.lineNumber);
editor.setScrollTop(editor.getScrollTop() + offset);
}
}

75
src/vs/editor/browser/view/viewImpl.ts → src/vs/editor/browser/view.ts
View File

@@ -4,15 +4,13 @@
*--------------------------------------------------------------------------------------------*/
import * as dom from 'vs/base/browser/dom';
import * as browser from 'vs/base/browser/browser';
import { Selection } from 'vs/editor/common/core/selection';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IMouseEvent } from 'vs/base/browser/mouseEvent';
import { onUnexpectedError } from 'vs/base/common/errors';
import { IDisposable } from 'vs/base/common/lifecycle';
import { IPointerHandlerHelper } from 'vs/editor/browser/controller/mouseHandler';
import { PointerHandler } from 'vs/editor/browser/controller/pointerHandler';
import { ITextAreaHandlerHelper, TextAreaHandler } from 'vs/editor/browser/controller/textAreaHandler';
import { IVisibleRangeProvider, TextAreaHandler } from 'vs/editor/browser/controller/textAreaHandler';
import { IContentWidget, IContentWidgetPosition, IOverlayWidget, IOverlayWidgetPosition, IMouseTarget, IViewZoneChangeAccessor, IEditorAriaOptions } from 'vs/editor/browser/editorBrowser';
import { ICommandDelegate, ViewController } from 'vs/editor/browser/view/viewController';
import { ViewUserInputEvents } from 'vs/editor/browser/view/viewUserInputEvents';
@@ -40,14 +38,15 @@ import { ViewCursors } from 'vs/editor/browser/viewParts/viewCursors/viewCursors
import { ViewZones } from 'vs/editor/browser/viewParts/viewZones/viewZones';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { IConfiguration, ScrollType } from 'vs/editor/common/editorCommon';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ScrollType } from 'vs/editor/common/editorCommon';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { IThemeService, getThemeTypeSelector } from 'vs/platform/theme/common/themeService';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
import { IViewModel } from 'vs/editor/common/viewModel';
import { getThemeTypeSelector, IColorTheme } from 'vs/platform/theme/common/themeService';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { PointerHandlerLastRenderData } from 'vs/editor/browser/controller/mouseTarget';
@@ -66,7 +65,6 @@ export class View extends ViewEventHandler {
private readonly _scrollbar: EditorScrollbar;
private readonly _context: ViewContext;
private _configPixelRatio: number;
private _selections: Selection[];
// The view lines
@@ -92,8 +90,8 @@ export class View extends ViewEventHandler {
constructor(
commandDelegate: ICommandDelegate,
configuration: IConfiguration,
themeService: IThemeService,
configuration: IEditorConfiguration,
colorTheme: IColorTheme,
model: IViewModel,
userInputEvents: ViewUserInputEvents,
overflowWidgetsDomNode: HTMLElement | undefined
@@ -105,18 +103,11 @@ export class View extends ViewEventHandler {
const viewController = new ViewController(configuration, model, userInputEvents, commandDelegate);
// The view context is passed on to most classes (basically to reduce param. counts in ctors)
this._context = new ViewContext(configuration, themeService.getColorTheme(), model);
this._configPixelRatio = this._context.configuration.options.get(EditorOption.pixelRatio);
this._context = new ViewContext(configuration, colorTheme, model);
// Ensure the view is the first event handler in order to update the layout
this._context.addEventHandler(this);
this._register(themeService.onDidColorThemeChange(theme => {
this._context.theme.update(theme);
this._context.model.onDidColorThemeChange();
this.render(true, false);
}));
this._viewParts = [];
// Keyboard handler
@@ -234,6 +225,7 @@ export class View extends ViewEventHandler {
return {
viewDomNode: this.domNode.domNode,
linesContentDomNode: this._linesContent.domNode,
viewLinesDomNode: this._viewLines.getDomNode().domNode,
focusTextArea: () => {
this.focus();
@@ -271,11 +263,11 @@ export class View extends ViewEventHandler {
};
}
private _createTextAreaHandlerHelper(): ITextAreaHandlerHelper {
private _createTextAreaHandlerHelper(): IVisibleRangeProvider {
return {
visibleRangeForPositionRelativeToEditor: (lineNumber: number, column: number) => {
visibleRangeForPosition: (position: Position) => {
this._flushAccumulatedAndRenderNow();
return this._viewLines.visibleRangeForPosition(new Position(lineNumber, column));
return this._viewLines.visibleRangeForPosition(position);
}
};
}
@@ -305,7 +297,6 @@ export class View extends ViewEventHandler {
this._scheduleRender();
}
public override onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean {
this._configPixelRatio = this._context.configuration.options.get(EditorOption.pixelRatio);
this.domNode.setClassName(this._getEditorClassName());
this._applyLayout();
return false;
@@ -319,6 +310,7 @@ export class View extends ViewEventHandler {
return false;
}
public override onThemeChanged(e: viewEvents.ViewThemeChangedEvent): boolean {
this._context.theme.update(e.theme);
this.domNode.setClassName(this._getEditorClassName());
return false;
}
@@ -361,7 +353,8 @@ export class View extends ViewEventHandler {
}
private _getViewPartsToRender(): ViewPart[] {
let result: ViewPart[] = [], resultLen = 0;
const result: ViewPart[] = [];
let resultLen = 0;
for (const viewPart of this._viewParts) {
if (viewPart.shouldRender()) {
result[resultLen++] = viewPart;
@@ -383,13 +376,13 @@ export class View extends ViewEventHandler {
}
const partialViewportData = this._context.viewLayout.getLinesViewportData();
this._context.model.setViewport(partialViewportData.startLineNumber, partialViewportData.endLineNumber, partialViewportData.centeredLineNumber);
this._context.viewModel.setViewport(partialViewportData.startLineNumber, partialViewportData.endLineNumber, partialViewportData.centeredLineNumber);
const viewportData = new ViewportData(
this._selections,
partialViewportData,
this._context.viewLayout.getWhitespaceViewportData(),
this._context.model
this._context.viewModel
);
if (this._contentWidgets.shouldRender()) {
@@ -416,34 +409,28 @@ export class View extends ViewEventHandler {
viewPart.render(renderingContext);
viewPart.onDidRender();
}
// Try to detect browser zooming and paint again if necessary
if (Math.abs(browser.getPixelRatio() - this._configPixelRatio) > 0.001) {
// looks like the pixel ratio has changed
this._context.configuration.updatePixelRatio();
}
}
// --- BEGIN CodeEditor helpers
public delegateVerticalScrollbarMouseDown(browserEvent: IMouseEvent): void {
this._scrollbar.delegateVerticalScrollbarMouseDown(browserEvent);
public delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void {
this._scrollbar.delegateVerticalScrollbarPointerDown(browserEvent);
}
public restoreState(scrollPosition: { scrollLeft: number; scrollTop: number; }): void {
this._context.model.setScrollPosition({ scrollTop: scrollPosition.scrollTop }, ScrollType.Immediate);
this._context.model.tokenizeViewport();
public restoreState(scrollPosition: { scrollLeft: number; scrollTop: number }): void {
this._context.viewModel.viewLayout.setScrollPosition({ scrollTop: scrollPosition.scrollTop }, ScrollType.Immediate);
this._context.viewModel.tokenizeViewport();
this._renderNow();
this._viewLines.updateLineWidths();
this._context.model.setScrollPosition({ scrollLeft: scrollPosition.scrollLeft }, ScrollType.Immediate);
this._context.viewModel.viewLayout.setScrollPosition({ scrollLeft: scrollPosition.scrollLeft }, ScrollType.Immediate);
}
public getOffsetForColumn(modelLineNumber: number, modelColumn: number): number {
const modelPosition = this._context.model.validateModelPosition({
const modelPosition = this._context.viewModel.model.validatePosition({
lineNumber: modelLineNumber,
column: modelColumn
});
const viewPosition = this._context.model.coordinatesConverter.convertModelPositionToViewPosition(modelPosition);
const viewPosition = this._context.viewModel.coordinatesConverter.convertModelPositionToViewPosition(modelPosition);
this._flushAccumulatedAndRenderNow();
const visibleRange = this._viewLines.visibleRangeForPosition(new Position(viewPosition.lineNumber, viewPosition.column));
if (!visibleRange) {
@@ -457,7 +444,7 @@ export class View extends ViewEventHandler {
if (!mouseTarget) {
return null;
}
return ViewUserInputEvents.convertViewToModelMouseTarget(mouseTarget, this._context.model.coordinatesConverter);
return ViewUserInputEvents.convertViewToModelMouseTarget(mouseTarget, this._context.viewModel.coordinatesConverter);
}
public createOverviewRuler(cssClassName: string): OverviewRuler {
@@ -515,7 +502,7 @@ export class View extends ViewEventHandler {
}
}
const newPreference = widgetData.position ? widgetData.position.preference : null;
this._contentWidgets.setWidgetPosition(widgetData.widget, newRange, newPreference);
this._contentWidgets.setWidgetPosition(widgetData.widget, newRange, newPreference, widgetData.position?.positionAffinity ?? null);
this._scheduleRender();
}

38
src/vs/editor/browser/view/domLineBreaksComputer.ts
View File

@@ -3,16 +3,15 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ILineBreaksComputerFactory } from 'vs/editor/common/viewModel/splitLinesCollection';
import { WrappingIndent } from 'vs/editor/common/config/editorOptions';
import { FontInfo } from 'vs/editor/common/config/fontInfo';
import { createStringBuilder, IStringBuilder } from 'vs/editor/common/core/stringBuilder';
import { CharCode } from 'vs/base/common/charCode';
import * as strings from 'vs/base/common/strings';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { ILineBreaksComputer, LineBreakData } from 'vs/editor/common/viewModel/viewModel';
import { LineInjectedText } from 'vs/editor/common/model/textModelEvents';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { LineInjectedText } from 'vs/editor/common/textModelEvents';
import { InjectedTextOptions } from 'vs/editor/common/model';
import { ILineBreaksComputer, ILineBreaksComputerFactory, ModelLineProjectionData } from 'vs/editor/common/modelLineProjectionData';
const ttPolicy = window.trustedTypes?.createPolicy('domLineBreaksComputer', { createHTML: value => value });
@@ -26,13 +25,10 @@ export class DOMLineBreaksComputerFactory implements ILineBreaksComputerFactory
}
public createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent): ILineBreaksComputer {
tabSize = tabSize | 0; //@perf
wrappingColumn = +wrappingColumn; //@perf
let requests: string[] = [];
let injectedTexts: (LineInjectedText[] | null)[] = [];
const requests: string[] = [];
const injectedTexts: (LineInjectedText[] | null)[] = [];
return {
addRequest: (lineText: string, injectedText: LineInjectedText[] | null, previousLineBreakData: LineBreakData | null) => {
addRequest: (lineText: string, injectedText: LineInjectedText[] | null, previousLineBreakData: ModelLineProjectionData | null) => {
requests.push(lineText);
injectedTexts.push(injectedText);
},
@@ -43,8 +39,8 @@ export class DOMLineBreaksComputerFactory implements ILineBreaksComputerFactory
}
}
function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: number, firstLineBreakColumn: number, wrappingIndent: WrappingIndent, injectedTextsPerLine: (LineInjectedText[] | null)[]): (LineBreakData | null)[] {
function createEmptyLineBreakWithPossiblyInjectedText(requestIdx: number): LineBreakData | null {
function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: number, firstLineBreakColumn: number, wrappingIndent: WrappingIndent, injectedTextsPerLine: (LineInjectedText[] | null)[]): (ModelLineProjectionData | null)[] {
function createEmptyLineBreakWithPossiblyInjectedText(requestIdx: number): ModelLineProjectionData | null {
const injectedTexts = injectedTextsPerLine[requestIdx];
if (injectedTexts) {
const lineText = LineInjectedText.applyInjectedText(requests[requestIdx], injectedTexts);
@@ -54,14 +50,14 @@ function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: numbe
// creating a `LineBreakData` with an invalid `breakOffsetsVisibleColumn` is OK
// because `breakOffsetsVisibleColumn` will never be used because it contains injected text
return new LineBreakData([lineText.length], [], 0, injectionOffsets, injectionOptions);
return new ModelLineProjectionData(injectionOffsets, injectionOptions, [lineText.length], [], 0);
} else {
return null;
}
}
if (firstLineBreakColumn === -1) {
const result: (LineBreakData | null)[] = [];
const result: (ModelLineProjectionData | null)[] = [];
for (let i = 0, len = requests.length; i < len; i++) {
result[i] = createEmptyLineBreakWithPossiblyInjectedText(i);
}
@@ -74,7 +70,7 @@ function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: numbe
const additionalIndentLength = Math.ceil(fontInfo.spaceWidth * additionalIndentSize);
const containerDomNode = document.createElement('div');
Configuration.applyFontInfoSlow(containerDomNode, fontInfo);
applyFontInfo(containerDomNode, fontInfo);
const sb = createStringBuilder(10000);
const firstNonWhitespaceIndices: number[] = [];
@@ -136,10 +132,10 @@ function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: numbe
containerDomNode.style.wordWrap = 'break-word';
document.body.appendChild(containerDomNode);
let range = document.createRange();
const range = document.createRange();
const lineDomNodes = Array.prototype.slice.call(containerDomNode.children, 0);
let result: (LineBreakData | null)[] = [];
const result: (ModelLineProjectionData | null)[] = [];
for (let i = 0; i < requests.length; i++) {
const lineDomNode = lineDomNodes[i];
const breakOffsets: number[] | null = readLineBreaks(range, lineDomNode, renderLineContents[i], allCharOffsets[i]);
@@ -175,7 +171,7 @@ function createLineBreaks(requests: string[], fontInfo: FontInfo, tabSize: numbe
injectionOffsets = null;
}
result[i] = new LineBreakData(breakOffsets, breakOffsetsVisibleColumn, wrappedTextIndentLength, injectionOffsets, injectionOptions);
result[i] = new ModelLineProjectionData(injectionOffsets, injectionOptions, breakOffsets, breakOffsetsVisibleColumn, wrappedTextIndentLength);
}
document.body.removeChild(containerDomNode);
@@ -189,7 +185,7 @@ const enum Constants {
function renderLine(lineContent: string, initialVisibleColumn: number, tabSize: number, width: number, sb: IStringBuilder, wrappingIndentLength: number): [number[], number[]] {
if (wrappingIndentLength !== 0) {
let hangingOffset = String(wrappingIndentLength);
const hangingOffset = String(wrappingIndentLength);
sb.appendASCIIString('<div style="text-indent: -');
sb.appendASCIIString(hangingOffset);
sb.appendASCIIString('px; padding-left: ');
@@ -207,8 +203,8 @@ function renderLine(lineContent: string, initialVisibleColumn: number, tabSize:
const len = lineContent.length;
let visibleColumn = initialVisibleColumn;
let charOffset = 0;
let charOffsets: number[] = [];
let visibleColumns: number[] = [];
const charOffsets: number[] = [];
const visibleColumns: number[] = [];
let nextCharCode = (0 < len ? lineContent.charCodeAt(0) : CharCode.Null);
sb.appendASCIIString('<span>');

4
src/vs/editor/browser/view/dynamicViewOverlay.ts
View File

@@ -3,8 +3,8 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
export abstract class DynamicViewOverlay extends ViewEventHandler {

2
src/vs/editor/common/view/renderingContext.ts → src/vs/editor/browser/view/renderingContext.ts
View File

@@ -6,7 +6,7 @@
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { IViewLayout, ViewModelDecoration } from 'vs/editor/common/viewModel/viewModel';
import { IViewLayout, ViewModelDecoration } from 'vs/editor/common/viewModel';
export interface IViewLines {
linesVisibleRangesForRange(range: Range, includeNewLines: boolean): LineVisibleRanges[] | null;

25
src/vs/editor/browser/view/viewController.ts
View File

@@ -4,13 +4,13 @@
*--------------------------------------------------------------------------------------------*/
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { CoreNavigationCommands } from 'vs/editor/browser/controller/coreCommands';
import { CoreNavigationCommands } from 'vs/editor/browser/coreCommands';
import { IEditorMouseEvent, IPartialEditorMouseEvent } from 'vs/editor/browser/editorBrowser';
import { ViewUserInputEvents } from 'vs/editor/browser/view/viewUserInputEvents';
import { Position } from 'vs/editor/common/core/position';
import { Selection } from 'vs/editor/common/core/selection';
import { IConfiguration } from 'vs/editor/common/editorCommon';
import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { IViewModel } from 'vs/editor/common/viewModel';
import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import * as platform from 'vs/base/common/platform';
@@ -32,6 +32,7 @@ export interface IMouseDispatchData {
leftButton: boolean;
middleButton: boolean;
onInjectedText: boolean;
}
export interface ICommandDelegate {
@@ -45,13 +46,13 @@ export interface ICommandDelegate {
export class ViewController {
private readonly configuration: IConfiguration;
private readonly configuration: IEditorConfiguration;
private readonly viewModel: IViewModel;
private readonly userInputEvents: ViewUserInputEvents;
private readonly commandDelegate: ICommandDelegate;
constructor(
configuration: IConfiguration,
configuration: IEditorConfiguration,
viewModel: IViewModel,
userInputEvents: ViewUserInputEvents,
commandDelegate: ICommandDelegate
@@ -165,13 +166,15 @@ export class ViewController {
}
}
} else if (data.mouseDownCount === 2) {
if (this._hasMulticursorModifier(data)) {
this._lastCursorWordSelect(data.position);
} else {
if (data.inSelectionMode) {
this._wordSelectDrag(data.position);
if (!data.onInjectedText) {
if (this._hasMulticursorModifier(data)) {
this._lastCursorWordSelect(data.position);
} else {
this._wordSelect(data.position);
if (data.inSelectionMode) {
this._wordSelectDrag(data.position);
} else {
this._wordSelect(data.position);
}
}
}
} else {

11
src/vs/editor/browser/view/viewLayer.ts
View File

@@ -5,7 +5,7 @@
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IStringBuilder, createStringBuilder } from 'vs/editor/common/core/stringBuilder';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
@@ -52,7 +52,7 @@ export class RenderedLinesCollection<T extends ILine> {
this._rendLineNumberStart = rendLineNumberStart;
}
_get(): { rendLineNumberStart: number; lines: T[]; } {
_get(): { rendLineNumberStart: number; lines: T[] } {
return {
rendLineNumberStart: this._rendLineNumberStart,
lines: this._lines
@@ -146,7 +146,8 @@ export class RenderedLinesCollection<T extends ILine> {
return deleted;
}
public onLinesChanged(changeFromLineNumber: number, changeToLineNumber: number): boolean {
public onLinesChanged(changeFromLineNumber: number, changeCount: number): boolean {
const changeToLineNumber = changeFromLineNumber + changeCount - 1;
if (this.getCount() === 0) {
// no lines
return false;
@@ -210,7 +211,7 @@ export class RenderedLinesCollection<T extends ILine> {
return deletedLines;
}
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number; }[]): boolean {
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number }[]): boolean {
if (this.getCount() === 0) {
// no lines
return false;
@@ -283,7 +284,7 @@ export class VisibleLinesCollection<T extends IVisibleLine> {
}
public onLinesChanged(e: viewEvents.ViewLinesChangedEvent): boolean {
return this._linesCollection.onLinesChanged(e.fromLineNumber, e.toLineNumber);
return this._linesCollection.onLinesChanged(e.fromLineNumber, e.count);
}
public onLinesDeleted(e: viewEvents.ViewLinesDeletedEvent): boolean {

19
src/vs/editor/browser/view/viewOverlays.ts
View File

@@ -4,19 +4,18 @@
*--------------------------------------------------------------------------------------------*/
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { IVisibleLine, IVisibleLinesHost, VisibleLinesCollection } from 'vs/editor/browser/view/viewLayer';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { IStringBuilder } from 'vs/editor/common/core/stringBuilder';
import { IConfiguration } from 'vs/editor/common/editorCommon';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
export class ViewOverlays extends ViewPart implements IVisibleLinesHost<ViewOverlayLine> {
private readonly _visibleLines: VisibleLinesCollection<ViewOverlayLine>;
@@ -141,13 +140,13 @@ export class ViewOverlays extends ViewPart implements IVisibleLinesHost<ViewOver
export class ViewOverlayLine implements IVisibleLine {
private readonly _configuration: IConfiguration;
private readonly _configuration: IEditorConfiguration;
private readonly _dynamicOverlays: DynamicViewOverlay[];
private _domNode: FastDomNode<HTMLElement> | null;
private _renderedContent: string | null;
private _lineHeight: number;
constructor(configuration: IConfiguration, dynamicOverlays: DynamicViewOverlay[]) {
constructor(configuration: IEditorConfiguration, dynamicOverlays: DynamicViewOverlay[]) {
this._configuration = configuration;
this._lineHeight = this._configuration.options.get(EditorOption.lineHeight);
this._dynamicOverlays = dynamicOverlays;
@@ -257,12 +256,12 @@ export class MarginViewOverlays extends ViewOverlays {
this.domNode.setClassName('margin-view-overlays');
this.domNode.setWidth(1);
Configuration.applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
}
public override onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean {
const options = this._context.configuration.options;
Configuration.applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
const layoutInfo = options.get(EditorOption.layoutInfo);
this._contentLeft = layoutInfo.contentLeft;
return super.onConfigurationChanged(e) || true;

15
src/vs/editor/browser/view/viewPart.ts
View File

@@ -4,9 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import { FastDomNode } from 'vs/base/browser/fastDomNode';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
export abstract class ViewPart extends ViewEventHandler {
@@ -42,11 +42,7 @@ export const enum PartFingerprint {
export class PartFingerprints {
public static write(target: Element | FastDomNode<HTMLElement>, partId: PartFingerprint) {
if (target instanceof FastDomNode) {
target.setAttribute('data-mprt', String(partId));
} else {
target.setAttribute('data-mprt', String(partId));
}
target.setAttribute('data-mprt', String(partId));
}
public static read(target: Element): PartFingerprint {
@@ -58,7 +54,8 @@ export class PartFingerprints {
}
public static collect(child: Element | null, stopAt: Element): Uint8Array {
let result: PartFingerprint[] = [], resultLen = 0;
const result: PartFingerprint[] = [];
let resultLen = 0;
while (child && child !== document.body) {
if (child === stopAt) {

46
src/vs/editor/browser/view/viewUserInputEvents.ts
View File

@@ -4,11 +4,8 @@
*--------------------------------------------------------------------------------------------*/
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { MouseTarget } from 'vs/editor/browser/controller/mouseTarget';
import { IEditorMouseEvent, IMouseTarget, IPartialEditorMouseEvent, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { ICoordinatesConverter } from 'vs/editor/common/viewModel/viewModel';
import { IEditorMouseEvent, IMouseTarget, IPartialEditorMouseEvent } from 'vs/editor/browser/editorBrowser';
import { ICoordinatesConverter } from 'vs/editor/common/viewModel';
import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
export interface EventCallback<T> {
@@ -118,36 +115,13 @@ export class ViewUserInputEvents {
}
public static convertViewToModelMouseTarget(target: IMouseTarget, coordinatesConverter: ICoordinatesConverter): IMouseTarget {
return new ExternalMouseTarget(
target.element,
target.type,
target.mouseColumn,
target.position ? coordinatesConverter.convertViewPositionToModelPosition(target.position) : null,
target.range ? coordinatesConverter.convertViewRangeToModelRange(target.range) : null,
target.detail
);
}
}
class ExternalMouseTarget implements IMouseTarget {
public readonly element: Element | null;
public readonly type: MouseTargetType;
public readonly mouseColumn: number;
public readonly position: Position | null;
public readonly range: Range | null;
public readonly detail: any;
constructor(element: Element | null, type: MouseTargetType, mouseColumn: number, position: Position | null, range: Range | null, detail: any) {
this.element = element;
this.type = type;
this.mouseColumn = mouseColumn;
this.position = position;
this.range = range;
this.detail = detail;
}
public toString(): string {
return MouseTarget.toString(this);
const result = { ...target };
if (result.position) {
result.position = coordinatesConverter.convertViewPositionToModelPosition(result.position);
}
if (result.range) {
result.range = coordinatesConverter.convertViewRangeToModelRange(result.range);
}
return result;
}
}

128
src/vs/editor/browser/viewParts/contentWidgets/contentWidgets.ts
View File

@@ -9,12 +9,13 @@ import { ContentWidgetPositionPreference, IContentWidget } from 'vs/editor/brows
import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/view/viewPart';
import { IRange, Range } from 'vs/editor/common/core/range';
import { Constants } from 'vs/base/common/uint';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { IDimension } from 'vs/editor/common/editorCommon';
import { IDimension } from 'vs/editor/common/core/dimension';
import { PositionAffinity } from 'vs/editor/common/model';
class Coordinate {
@@ -32,7 +33,7 @@ class Coordinate {
export class ViewContentWidgets extends ViewPart {
private readonly _viewDomNode: FastDomNode<HTMLElement>;
private _widgets: { [key: string]: Widget; };
private _widgets: { [key: string]: Widget };
public domNode: FastDomNode<HTMLElement>;
public overflowingContentWidgetsDomNode: FastDomNode<HTMLElement>;
@@ -112,9 +113,9 @@ export class ViewContentWidgets extends ViewPart {
this.setShouldRender();
}
public setWidgetPosition(widget: IContentWidget, range: IRange | null, preference: ContentWidgetPositionPreference[] | null): void {
public setWidgetPosition(widget: IContentWidget, range: IRange | null, preference: ContentWidgetPositionPreference[] | null, affinity: PositionAffinity | null): void {
const myWidget = this._widgets[widget.getId()];
myWidget.setPosition(range, preference);
myWidget.setPosition(range, preference, affinity);
this.setShouldRender();
}
@@ -173,8 +174,8 @@ interface IBoxLayoutResult {
}
interface IRenderData {
coordinate: Coordinate,
position: ContentWidgetPositionPreference
coordinate: Coordinate;
position: ContentWidgetPositionPreference;
}
class Widget {
@@ -193,10 +194,11 @@ class Widget {
private _lineHeight: number;
private _range: IRange | null;
private _affinity: PositionAffinity | null;
private _viewRange: Range | null;
private _preference: ContentWidgetPositionPreference[] | null;
private _cachedDomNodeClientWidth: number;
private _cachedDomNodeClientHeight: number;
private _cachedDomNodeOffsetWidth: number;
private _cachedDomNodeOffsetHeight: number;
private _maxWidth: number;
private _isVisible: boolean;
@@ -222,14 +224,16 @@ class Widget {
this._range = null;
this._viewRange = null;
this._affinity = null;
this._preference = [];
this._cachedDomNodeClientWidth = -1;
this._cachedDomNodeClientHeight = -1;
this._cachedDomNodeOffsetWidth = -1;
this._cachedDomNodeOffsetHeight = -1;
this._maxWidth = this._getMaxWidth();
this._isVisible = false;
this._renderData = null;
this.domNode.setPosition((this._fixedOverflowWidgets && this.allowEditorOverflow) ? 'fixed' : 'absolute');
this.domNode.setDisplay('none');
this.domNode.setVisibility('hidden');
this.domNode.setAttribute('widgetId', this.id);
this.domNode.setMaxWidth(this._maxWidth);
@@ -247,18 +251,19 @@ class Widget {
}
public onLineMappingChanged(e: viewEvents.ViewLineMappingChangedEvent): void {
this._setPosition(this._range);
this._setPosition(this._range, this._affinity);
}
private _setPosition(range: IRange | null): void {
private _setPosition(range: IRange | null, affinity: PositionAffinity | null): void {
this._range = range;
this._viewRange = null;
this._affinity = affinity;
if (this._range) {
// Do not trust that widgets give a valid position
const validModelRange = this._context.model.validateModelRange(this._range);
if (this._context.model.coordinatesConverter.modelPositionIsVisible(validModelRange.getStartPosition()) || this._context.model.coordinatesConverter.modelPositionIsVisible(validModelRange.getEndPosition())) {
this._viewRange = this._context.model.coordinatesConverter.convertModelRangeToViewRange(validModelRange);
const validModelRange = this._context.viewModel.model.validateRange(this._range);
if (this._context.viewModel.coordinatesConverter.modelPositionIsVisible(validModelRange.getStartPosition()) || this._context.viewModel.coordinatesConverter.modelPositionIsVisible(validModelRange.getEndPosition())) {
this._viewRange = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(validModelRange, this._affinity ?? undefined);
}
}
}
@@ -266,16 +271,25 @@ class Widget {
private _getMaxWidth(): number {
return (
this.allowEditorOverflow
? window.innerWidth || document.documentElement!.clientWidth || document.body.clientWidth
? window.innerWidth || document.documentElement!.offsetWidth || document.body.offsetWidth
: this._contentWidth
);
}
public setPosition(range: IRange | null, preference: ContentWidgetPositionPreference[] | null): void {
this._setPosition(range);
public setPosition(range: IRange | null, preference: ContentWidgetPositionPreference[] | null, affinity: PositionAffinity | null): void {
this._setPosition(range, affinity);
this._preference = preference;
this._cachedDomNodeClientWidth = -1;
this._cachedDomNodeClientHeight = -1;
if (this._viewRange && this._preference && this._preference.length > 0) {
// this content widget would like to be visible if possible
// we change it from `display:none` to `display:block` even if it
// might be outside the viewport such that we can measure its size
// in `prepareRender`
this.domNode.setDisplay('block');
} else {
this.domNode.setDisplay('none');
}
this._cachedDomNodeOffsetWidth = -1;
this._cachedDomNodeOffsetHeight = -1;
}
private _layoutBoxInViewport(topLeft: Coordinate, bottomLeft: Coordinate, width: number, height: number, ctx: RenderingContext): IBoxLayoutResult {
@@ -435,65 +449,69 @@ class Widget {
}
private _prepareRenderWidget(ctx: RenderingContext): IRenderData | null {
if (!this._preference || this._preference.length === 0) {
return null;
}
const [topLeft, bottomLeft] = this._getTopAndBottomLeft(ctx);
if (!topLeft || !bottomLeft) {
return null;
}
if (this._cachedDomNodeClientWidth === -1 || this._cachedDomNodeClientHeight === -1) {
if (this._cachedDomNodeOffsetWidth === -1 || this._cachedDomNodeOffsetHeight === -1) {
let preferredDimensions: IDimension | null = null;
if (typeof this._actual.beforeRender === 'function') {
preferredDimensions = safeInvoke(this._actual.beforeRender, this._actual);
}
if (preferredDimensions) {
this._cachedDomNodeClientWidth = preferredDimensions.width;
this._cachedDomNodeClientHeight = preferredDimensions.height;
this._cachedDomNodeOffsetWidth = preferredDimensions.width;
this._cachedDomNodeOffsetHeight = preferredDimensions.height;
} else {
const domNode = this.domNode.domNode;
this._cachedDomNodeClientWidth = domNode.clientWidth;
this._cachedDomNodeClientHeight = domNode.clientHeight;
const clientRect = domNode.getBoundingClientRect();
this._cachedDomNodeOffsetWidth = Math.round(clientRect.width);
this._cachedDomNodeOffsetHeight = Math.round(clientRect.height);
}
}
let placement: IBoxLayoutResult | null;
if (this.allowEditorOverflow) {
placement = this._layoutBoxInPage(topLeft, bottomLeft, this._cachedDomNodeClientWidth, this._cachedDomNodeClientHeight, ctx);
placement = this._layoutBoxInPage(topLeft, bottomLeft, this._cachedDomNodeOffsetWidth, this._cachedDomNodeOffsetHeight, ctx);
} else {
placement = this._layoutBoxInViewport(topLeft, bottomLeft, this._cachedDomNodeClientWidth, this._cachedDomNodeClientHeight, ctx);
placement = this._layoutBoxInViewport(topLeft, bottomLeft, this._cachedDomNodeOffsetWidth, this._cachedDomNodeOffsetHeight, ctx);
}
// Do two passes, first for perfect fit, second picks first option
if (this._preference) {
for (let pass = 1; pass <= 2; pass++) {
for (const pref of this._preference) {
// placement
if (pref === ContentWidgetPositionPreference.ABOVE) {
if (!placement) {
// Widget outside of viewport
return null;
}
if (pass === 2 || placement.fitsAbove) {
return { coordinate: new Coordinate(placement.aboveTop, placement.aboveLeft), position: ContentWidgetPositionPreference.ABOVE };
}
} else if (pref === ContentWidgetPositionPreference.BELOW) {
if (!placement) {
// Widget outside of viewport
return null;
}
if (pass === 2 || placement.fitsBelow) {
return { coordinate: new Coordinate(placement.belowTop, placement.belowLeft), position: ContentWidgetPositionPreference.BELOW };
}
for (let pass = 1; pass <= 2; pass++) {
for (const pref of this._preference) {
// placement
if (pref === ContentWidgetPositionPreference.ABOVE) {
if (!placement) {
// Widget outside of viewport
return null;
}
if (pass === 2 || placement.fitsAbove) {
return { coordinate: new Coordinate(placement.aboveTop, placement.aboveLeft), position: ContentWidgetPositionPreference.ABOVE };
}
} else if (pref === ContentWidgetPositionPreference.BELOW) {
if (!placement) {
// Widget outside of viewport
return null;
}
if (pass === 2 || placement.fitsBelow) {
return { coordinate: new Coordinate(placement.belowTop, placement.belowLeft), position: ContentWidgetPositionPreference.BELOW };
}
} else {
if (this.allowEditorOverflow) {
return { coordinate: this._prepareRenderWidgetAtExactPositionOverflowing(topLeft), position: ContentWidgetPositionPreference.EXACT };
} else {
if (this.allowEditorOverflow) {
return { coordinate: this._prepareRenderWidgetAtExactPositionOverflowing(topLeft), position: ContentWidgetPositionPreference.EXACT };
} else {
return { coordinate: topLeft, position: ContentWidgetPositionPreference.EXACT };
}
return { coordinate: topLeft, position: ContentWidgetPositionPreference.EXACT };
}
}
}
}
return null;
}

62
src/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.ts
View File

@@ -5,16 +5,15 @@
import 'vs/css!./currentLineHighlight';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { editorLineHighlight, editorLineHighlightBorder } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { editorLineHighlight, editorLineHighlightBorder } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import * as arrays from 'vs/base/common/arrays';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { Selection } from 'vs/editor/common/core/selection';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
let isRenderedUsingBorder = true;
import { isHighContrast } from 'vs/platform/theme/common/theme';
export abstract class AbstractLineHighlightOverlay extends DynamicViewOverlay {
private readonly _context: ViewContext;
@@ -57,17 +56,14 @@ export abstract class AbstractLineHighlightOverlay extends DynamicViewOverlay {
private _readFromSelections(): boolean {
let hasChanged = false;
// Only render the first selection when using border
const renderSelections = isRenderedUsingBorder ? this._selections.slice(0, 1) : this._selections;
const cursorsLineNumbers = renderSelections.map(s => s.positionLineNumber);
const cursorsLineNumbers = this._selections.map(s => s.positionLineNumber);
cursorsLineNumbers.sort((a, b) => a - b);
if (!arrays.equals(this._cursorLineNumbers, cursorsLineNumbers)) {
this._cursorLineNumbers = cursorsLineNumbers;
hasChanged = true;
}
const selectionIsEmpty = renderSelections.every(s => s.isEmpty());
const selectionIsEmpty = this._selections.every(s => s.isEmpty());
if (this._selectionIsEmpty !== selectionIsEmpty) {
this._selectionIsEmpty = selectionIsEmpty;
hasChanged = true;
@@ -155,6 +151,21 @@ export abstract class AbstractLineHighlightOverlay extends DynamicViewOverlay {
return this._renderData[lineIndex];
}
protected _shouldRenderInMargin(): boolean {
return (
(this._renderLineHighlight === 'gutter' || this._renderLineHighlight === 'all')
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
}
protected _shouldRenderInContent(): boolean {
return (
(this._renderLineHighlight === 'line' || this._renderLineHighlight === 'all')
&& this._selectionIsEmpty
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
}
protected abstract _shouldRenderThis(): boolean;
protected abstract _shouldRenderOther(): boolean;
protected abstract _renderOne(ctx: RenderingContext): string;
@@ -167,45 +178,27 @@ export class CurrentLineHighlightOverlay extends AbstractLineHighlightOverlay {
return `<div class="${className}" style="width:${Math.max(ctx.scrollWidth, this._contentWidth)}px; height:${this._lineHeight}px;"></div>`;
}
protected _shouldRenderThis(): boolean {
return (
(this._renderLineHighlight === 'line' || this._renderLineHighlight === 'all')
&& this._selectionIsEmpty
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
return this._shouldRenderInContent();
}
protected _shouldRenderOther(): boolean {
return (
(this._renderLineHighlight === 'gutter' || this._renderLineHighlight === 'all')
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
return this._shouldRenderInMargin();
}
}
export class CurrentLineMarginHighlightOverlay extends AbstractLineHighlightOverlay {
protected _renderOne(ctx: RenderingContext): string {
const className = 'current-line' + (this._shouldRenderMargin() ? ' current-line-margin' : '') + (this._shouldRenderOther() ? ' current-line-margin-both' : '');
const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-margin' : '') + (this._shouldRenderOther() ? ' current-line-margin-both' : '');
return `<div class="${className}" style="width:${this._contentLeft}px; height:${this._lineHeight}px;"></div>`;
}
protected _shouldRenderMargin(): boolean {
return (
(this._renderLineHighlight === 'gutter' || this._renderLineHighlight === 'all')
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
}
protected _shouldRenderThis(): boolean {
return true;
}
protected _shouldRenderOther(): boolean {
return (
(this._renderLineHighlight === 'line' || this._renderLineHighlight === 'all')
&& this._selectionIsEmpty
&& (!this._renderLineHighlightOnlyWhenFocus || this._focused)
);
return this._shouldRenderInContent();
}
}
registerThemingParticipant((theme, collector) => {
isRenderedUsingBorder = false;
const lineHighlight = theme.getColor(editorLineHighlight);
if (lineHighlight) {
collector.addRule(`.monaco-editor .view-overlays .current-line { background-color: ${lineHighlight}; }`);
@@ -214,10 +207,9 @@ registerThemingParticipant((theme, collector) => {
if (!lineHighlight || lineHighlight.isTransparent() || theme.defines(editorLineHighlightBorder)) {
const lineHighlightBorder = theme.getColor(editorLineHighlightBorder);
if (lineHighlightBorder) {
isRenderedUsingBorder = true;
collector.addRule(`.monaco-editor .view-overlays .current-line { border: 2px solid ${lineHighlightBorder}; }`);
collector.addRule(`.monaco-editor .margin-view-overlays .current-line-margin { border: 2px solid ${lineHighlightBorder}; }`);
if (theme.type === 'hc') {
if (isHighContrast(theme.type)) {
collector.addRule(`.monaco-editor .view-overlays .current-line { border-width: 1px; }`);
collector.addRule(`.monaco-editor .margin-view-overlays .current-line-margin { border-width: 1px; }`);
}

22
src/vs/editor/browser/viewParts/decorations/decorations.ts
View File

@@ -6,10 +6,10 @@
import 'vs/css!./decorations';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { Range } from 'vs/editor/common/core/range';
import { HorizontalRange, RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ViewModelDecoration } from 'vs/editor/common/viewModel/viewModel';
import { HorizontalRange, RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewModelDecoration } from 'vs/editor/common/viewModel';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
export class DecorationsOverlay extends DynamicViewOverlay {
@@ -71,7 +71,8 @@ export class DecorationsOverlay extends DynamicViewOverlay {
const _decorations = ctx.getDecorationsInViewport();
// Keep only decorations with `className`
let decorations: ViewModelDecoration[] = [], decorationsLen = 0;
let decorations: ViewModelDecoration[] = [];
let decorationsLen = 0;
for (let i = 0, len = _decorations.length; i < len; i++) {
const d = _decorations[i];
if (d.options.className) {
@@ -163,7 +164,7 @@ export class DecorationsOverlay extends DynamicViewOverlay {
let range = d.range;
if (showIfCollapsed && range.endColumn === 1 && range.endLineNumber !== range.startLineNumber) {
range = new Range(range.startLineNumber, range.startColumn, range.endLineNumber - 1, this._context.model.getLineMaxColumn(range.endLineNumber - 1));
range = new Range(range.startLineNumber, range.startColumn, range.endLineNumber - 1, this._context.viewModel.getLineMaxColumn(range.endLineNumber - 1));
}
if (prevClassName === className && prevShowIfCollapsed === showIfCollapsed && Range.areIntersectingOrTouching(prevRange!, range)) {
@@ -202,9 +203,12 @@ export class DecorationsOverlay extends DynamicViewOverlay {
if (showIfCollapsed && lineVisibleRanges.ranges.length === 1) {
const singleVisibleRange = lineVisibleRanges.ranges[0];
if (singleVisibleRange.width === 0) {
// collapsed range case => make the decoration visible by faking its width
lineVisibleRanges.ranges[0] = new HorizontalRange(singleVisibleRange.left, this._typicalHalfwidthCharacterWidth);
if (singleVisibleRange.width < this._typicalHalfwidthCharacterWidth) {
// collapsed/very small range case => make the decoration visible by expanding its width
// expand its size on both sides (both to the left and to the right, keeping it centered)
const center = Math.round(singleVisibleRange.left + singleVisibleRange.width / 2);
const left = Math.max(0, Math.round(center - this._typicalHalfwidthCharacterWidth / 2));
lineVisibleRanges.ranges[0] = new HorizontalRange(left, this._typicalHalfwidthCharacterWidth);
}
}

64
src/vs/editor/browser/viewParts/editorScrollbar/editorScrollbar.ts
View File

@@ -5,16 +5,16 @@
import * as dom from 'vs/base/browser/dom';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IMouseEvent } from 'vs/base/browser/mouseEvent';
import { IOverviewRulerLayoutInfo, SmoothScrollableElement } from 'vs/base/browser/ui/scrollbar/scrollableElement';
import { ScrollableElementChangeOptions, ScrollableElementCreationOptions } from 'vs/base/browser/ui/scrollbar/scrollableElementOptions';
import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/view/viewPart';
import { INewScrollPosition, ScrollType } from 'vs/editor/common/editorCommon';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { getThemeTypeSelector } from 'vs/platform/theme/common/themeService';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { registerThemingParticipant, getThemeTypeSelector } from 'vs/platform/theme/common/themeService';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { scrollbarShadow, scrollbarSliderActiveBackground, scrollbarSliderBackground, scrollbarSliderHoverBackground } from 'vs/platform/theme/common/colorRegistry';
export class EditorScrollbar extends ViewPart {
@@ -89,7 +89,7 @@ export class EditorScrollbar extends ViewPart {
}
}
this._context.model.setScrollPosition(newScrollPosition, ScrollType.Immediate);
this._context.viewModel.viewLayout.setScrollPosition(newScrollPosition, ScrollType.Immediate);
};
// I've seen this happen both on the view dom node & on the lines content dom node.
@@ -127,8 +127,8 @@ export class EditorScrollbar extends ViewPart {
return this.scrollbarDomNode;
}
public delegateVerticalScrollbarMouseDown(browserEvent: IMouseEvent): void {
this.scrollbar.delegateVerticalScrollbarMouseDown(browserEvent);
public delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void {
this.scrollbar.delegateVerticalScrollbarPointerDown(browserEvent);
}
// --- begin event handlers
@@ -180,3 +180,51 @@ export class EditorScrollbar extends ViewPart {
this.scrollbar.renderNow();
}
}
registerThemingParticipant((theme, collector) => {
// Scrollbars
const scrollbarShadowColor = theme.getColor(scrollbarShadow);
if (scrollbarShadowColor) {
collector.addRule(`
.monaco-scrollable-element > .shadow.top {
box-shadow: ${scrollbarShadowColor} 0 6px 6px -6px inset;
}
.monaco-scrollable-element > .shadow.left {
box-shadow: ${scrollbarShadowColor} 6px 0 6px -6px inset;
}
.monaco-scrollable-element > .shadow.top.left {
box-shadow: ${scrollbarShadowColor} 6px 6px 6px -6px inset;
}
`);
}
const scrollbarSliderBackgroundColor = theme.getColor(scrollbarSliderBackground);
if (scrollbarSliderBackgroundColor) {
collector.addRule(`
.monaco-scrollable-element > .scrollbar > .slider {
background: ${scrollbarSliderBackgroundColor};
}
`);
}
const scrollbarSliderHoverBackgroundColor = theme.getColor(scrollbarSliderHoverBackground);
if (scrollbarSliderHoverBackgroundColor) {
collector.addRule(`
.monaco-scrollable-element > .scrollbar > .slider:hover {
background: ${scrollbarSliderHoverBackgroundColor};
}
`);
}
const scrollbarSliderActiveBackgroundColor = theme.getColor(scrollbarSliderActiveBackground);
if (scrollbarSliderActiveBackgroundColor) {
collector.addRule(`
.monaco-scrollable-element > .scrollbar > .slider.active {
background: ${scrollbarSliderActiveBackgroundColor};
}
`);
}
});

9
src/vs/editor/browser/viewParts/glyphMargin/glyphMargin.ts
View File

@@ -5,9 +5,9 @@
import 'vs/css!./glyphMargin';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
@@ -142,7 +142,8 @@ export class GlyphMarginOverlay extends DedupOverlay {
protected _getDecorations(ctx: RenderingContext): DecorationToRender[] {
const decorations = ctx.getDecorationsInViewport();
let r: DecorationToRender[] = [], rLen = 0;
const r: DecorationToRender[] = [];
let rLen = 0;
for (let i = 0, len = decorations.length; i < len; i++) {
const d = decorations[i];
const glyphMarginClassName = d.options.glyphMarginClassName;

39
src/vs/editor/browser/viewParts/indentGuides/indentGuides.ts
View File

@@ -5,18 +5,18 @@
import 'vs/css!./indentGuides';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { editorActiveIndentGuides, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketPairGuideActiveBackground1, editorBracketPairGuideActiveBackground2, editorBracketPairGuideActiveBackground3, editorBracketPairGuideActiveBackground4, editorBracketPairGuideActiveBackground5, editorBracketPairGuideActiveBackground6, editorBracketPairGuideBackground1, editorBracketPairGuideBackground2, editorBracketPairGuideBackground3, editorBracketPairGuideBackground4, editorBracketPairGuideBackground5, editorBracketPairGuideBackground6, editorIndentGuides } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { editorActiveIndentGuides, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketPairGuideActiveBackground1, editorBracketPairGuideActiveBackground2, editorBracketPairGuideActiveBackground3, editorBracketPairGuideActiveBackground4, editorBracketPairGuideActiveBackground5, editorBracketPairGuideActiveBackground6, editorBracketPairGuideBackground1, editorBracketPairGuideBackground2, editorBracketPairGuideBackground3, editorBracketPairGuideBackground4, editorBracketPairGuideBackground5, editorBracketPairGuideBackground6, editorIndentGuides } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { EditorOption, InternalGuidesOptions } from 'vs/editor/common/config/editorOptions';
import { Position } from 'vs/editor/common/core/position';
import { HorizontalGuidesState, IndentGuide } from 'vs/editor/common/model';
import { ArrayQueue } from 'vs/base/common/arrays';
import { BracketPairGuidesClassNames } from 'vs/editor/common/model/textModel';
import { Color } from 'vs/base/common/color';
import { isDefined } from 'vs/base/common/types';
import { BracketPairGuidesClassNames } from 'vs/editor/common/model/guidesTextModelPart';
import { IndentGuide, HorizontalGuidesState } from 'vs/editor/common/textModelGuides';
export class IndentGuidesOverlay extends DynamicViewOverlay {
@@ -131,7 +131,13 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
let result = '';
const leftOffset = ctx.visibleRangeForPosition(new Position(lineNumber, 1))?.left ?? 0;
for (const guide of indent) {
const left = leftOffset + (guide.visibleColumn - 1) * this._spaceWidth;
const left =
guide.column === -1
? leftOffset + (guide.visibleColumn - 1) * this._spaceWidth
: ctx.visibleRangeForPosition(
new Position(lineNumber, guide.column)
)!.left;
if (left > scrollWidth || (this._maxIndentLeft > 0 && left > this._maxIndentLeft)) {
break;
}
@@ -157,7 +163,7 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
activeCursorPosition: Position | null
): IndentGuide[][] {
const bracketGuides = this._bracketPairGuideOptions.bracketPairs !== false
? this._context.model.getBracketGuidesInRangeByLine(
? this._context.viewModel.getBracketGuidesInRangeByLine(
visibleStartLineNumber,
visibleEndLineNumber,
activeCursorPosition,
@@ -174,7 +180,7 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
: null;
const indentGuides = this._bracketPairGuideOptions.indentation
? this._context.model.getLinesIndentGuides(
? this._context.viewModel.getLinesIndentGuides(
visibleStartLineNumber,
visibleEndLineNumber
)
@@ -184,14 +190,14 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
let activeIndentEndLineNumber = 0;
let activeIndentLevel = 0;
if (this._bracketPairGuideOptions.highlightActiveIndentation && activeCursorPosition) {
const activeIndentInfo = this._context.model.getActiveIndentGuide(activeCursorPosition.lineNumber, visibleStartLineNumber, visibleEndLineNumber);
if (this._bracketPairGuideOptions.highlightActiveIndentation !== false && activeCursorPosition) {
const activeIndentInfo = this._context.viewModel.getActiveIndentGuide(activeCursorPosition.lineNumber, visibleStartLineNumber, visibleEndLineNumber);
activeIndentStartLineNumber = activeIndentInfo.startLineNumber;
activeIndentEndLineNumber = activeIndentInfo.endLineNumber;
activeIndentLevel = activeIndentInfo.indent;
}
const { indentSize } = this._context.model.getTextModelOptions();
const { indentSize } = this._context.viewModel.model.getOptions();
const result: IndentGuide[][] = [];
for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
@@ -207,7 +213,7 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
const indentGuide = (indentLvl - 1) * indentSize + 1;
const isActive =
// Disable active indent guide if there are bracket guides.
bracketGuidesInLine.length === 0 &&
(this._bracketPairGuideOptions.highlightActiveIndentation === 'always' || bracketGuidesInLine.length === 0) &&
activeIndentStartLineNumber <= lineNumber &&
lineNumber <= activeIndentEndLineNumber &&
indentLvl === activeIndentLevel;
@@ -217,8 +223,11 @@ export class IndentGuidesOverlay extends DynamicViewOverlay {
lineGuides.push(
new IndentGuide(
indentGuide,
-1,
isActive ? 'core-guide-indent-active' : 'core-guide-indent',
null
null,
-1,
-1,
)
);
}
@@ -270,7 +279,7 @@ registerThemingParticipant((theme, collector) => {
const colorProvider = new BracketPairGuidesClassNames();
let colorValues = colors
const colorValues = colors
.map(c => {
const bracketColor = theme.getColor(c.bracketColor);
const guideColor = theme.getColor(c.guideColor);

16
src/vs/editor/browser/viewParts/lineNumbers/lineNumbers.ts
View File

@@ -8,10 +8,10 @@ import * as platform from 'vs/base/common/platform';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { RenderLineNumbersType, EditorOption } from 'vs/editor/common/config/editorOptions';
import { Position } from 'vs/editor/common/core/position';
import { editorActiveLineNumber, editorLineNumbers } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { editorActiveLineNumber, editorLineNumbers } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
export class LineNumbersOverlay extends DynamicViewOverlay {
@@ -68,7 +68,7 @@ export class LineNumbersOverlay extends DynamicViewOverlay {
}
public override onCursorStateChanged(e: viewEvents.ViewCursorStateChangedEvent): boolean {
const primaryViewPosition = e.selections[0].getPosition();
this._lastCursorModelPosition = this._context.model.coordinatesConverter.convertViewPositionToModelPosition(primaryViewPosition);
this._lastCursorModelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(primaryViewPosition);
let shouldRender = false;
if (this._activeLineNumber !== primaryViewPosition.lineNumber) {
@@ -102,7 +102,7 @@ export class LineNumbersOverlay extends DynamicViewOverlay {
// --- end event handlers
private _getLineRenderLineNumber(viewLineNumber: number): string {
const modelPosition = this._context.model.coordinatesConverter.convertViewPositionToModelPosition(new Position(viewLineNumber, 1));
const modelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(new Position(viewLineNumber, 1));
if (modelPosition.column !== 1) {
return '';
}
@@ -144,13 +144,13 @@ export class LineNumbersOverlay extends DynamicViewOverlay {
const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
const common = '<div class="' + LineNumbersOverlay.CLASS_NAME + lineHeightClassName + '" style="left:' + this._lineNumbersLeft + 'px;width:' + this._lineNumbersWidth + 'px;">';
const lineCount = this._context.model.getLineCount();
const lineCount = this._context.viewModel.getLineCount();
const output: string[] = [];
for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
const lineIndex = lineNumber - visibleStartLineNumber;
if (!this._renderFinalNewline) {
if (lineNumber === lineCount && this._context.model.getLineLength(lineNumber) === 0) {
if (lineNumber === lineCount && this._context.viewModel.getLineLength(lineNumber) === 0) {
// Do not render last (empty) line
output[lineIndex] = '';
continue;

15
src/vs/editor/browser/viewParts/lines/rangeUtil.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { Constants } from 'vs/base/common/uint';
import { FloatHorizontalRange } from 'vs/editor/common/view/renderingContext';
import { FloatHorizontalRange } from 'vs/editor/browser/view/renderingContext';
export class RangeUtil {
@@ -51,7 +51,8 @@ export class RangeUtil {
ranges.sort(FloatHorizontalRange.compare);
let result: FloatHorizontalRange[] = [], resultLen = 0;
const result: FloatHorizontalRange[] = [];
let resultLen = 0;
let prev = ranges[0];
for (let i = 1, len = ranges.length; i < len; i++) {
@@ -69,7 +70,7 @@ export class RangeUtil {
return result;
}
private static _createHorizontalRangesFromClientRects(clientRects: DOMRectList | null, clientRectDeltaLeft: number): FloatHorizontalRange[] | null {
private static _createHorizontalRangesFromClientRects(clientRects: DOMRectList | null, clientRectDeltaLeft: number, clientRectScale: number): FloatHorizontalRange[] | null {
if (!clientRects || clientRects.length === 0) {
return null;
}
@@ -80,13 +81,13 @@ export class RangeUtil {
const result: FloatHorizontalRange[] = [];
for (let i = 0, len = clientRects.length; i < len; i++) {
const clientRect = clientRects[i];
result[i] = new FloatHorizontalRange(Math.max(0, clientRect.left - clientRectDeltaLeft), clientRect.width);
result[i] = new FloatHorizontalRange(Math.max(0, (clientRect.left - clientRectDeltaLeft) / clientRectScale), clientRect.width / clientRectScale);
}
return this._mergeAdjacentRanges(result);
}
public static readHorizontalRanges(domNode: HTMLElement, startChildIndex: number, startOffset: number, endChildIndex: number, endOffset: number, clientRectDeltaLeft: number, endNode: HTMLElement): FloatHorizontalRange[] | null {
public static readHorizontalRanges(domNode: HTMLElement, startChildIndex: number, startOffset: number, endChildIndex: number, endOffset: number, clientRectDeltaLeft: number, clientRectScale: number, endNode: HTMLElement): FloatHorizontalRange[] | null {
// Panic check
const min = 0;
const max = domNode.children.length - 1;
@@ -100,7 +101,7 @@ export class RangeUtil {
// We must find the position at the beginning of a <span>
// To cover cases of empty <span>s, avoid using a range and use the <span>'s bounding box
const clientRects = domNode.children[startChildIndex].getClientRects();
return this._createHorizontalRangesFromClientRects(clientRects, clientRectDeltaLeft);
return this._createHorizontalRangesFromClientRects(clientRects, clientRectDeltaLeft, clientRectScale);
}
// If crossing over to a span only to select offset 0, then use the previous span's maximum offset
@@ -135,6 +136,6 @@ export class RangeUtil {
endOffset = Math.min(endElement.textContent!.length, Math.max(0, endOffset));
const clientRects = this._readClientRects(startElement, startOffset, endElement, endOffset, endNode);
return this._createHorizontalRangesFromClientRects(clientRects, clientRectDeltaLeft);
return this._createHorizontalRangesFromClientRects(clientRects, clientRectDeltaLeft, clientRectScale);
}
}

54
src/vs/editor/browser/viewParts/lines/viewLine.ts
View File

@@ -9,13 +9,13 @@ import * as platform from 'vs/base/common/platform';
import { IVisibleLine } from 'vs/editor/browser/view/viewLayer';
import { RangeUtil } from 'vs/editor/browser/viewParts/lines/rangeUtil';
import { IStringBuilder } from 'vs/editor/common/core/stringBuilder';
import { IConfiguration } from 'vs/editor/common/editorCommon';
import { FloatHorizontalRange, VisibleRanges } from 'vs/editor/common/view/renderingContext';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { FloatHorizontalRange, VisibleRanges } from 'vs/editor/browser/view/renderingContext';
import { LineDecoration } from 'vs/editor/common/viewLayout/lineDecorations';
import { CharacterMapping, ForeignElementType, RenderLineInput, renderViewLine, LineRange, DomPosition } from 'vs/editor/common/viewLayout/viewLineRenderer';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { InlineDecorationType } from 'vs/editor/common/viewModel/viewModel';
import { ColorScheme } from 'vs/platform/theme/common/theme';
import { InlineDecorationType } from 'vs/editor/common/viewModel';
import { ColorScheme, isHighContrast } from 'vs/platform/theme/common/theme';
import { EditorOption, EditorFontLigatures } from 'vs/editor/common/config/editorOptions';
const canUseFastRenderedViewLine = (function () {
@@ -48,21 +48,39 @@ export class DomReadingContext {
private readonly _domNode: HTMLElement;
private _clientRectDeltaLeft: number;
private _clientRectDeltaLeftRead: boolean;
private _clientRectScale: number;
private _clientRectRead: boolean;
private readClientRect(): void {
if (!this._clientRectRead) {
this._clientRectRead = true;
const rect = this._domNode.getBoundingClientRect();
this._clientRectDeltaLeft = rect.left;
this._clientRectScale = rect.width / this._domNode.offsetWidth;
}
}
public get clientRectDeltaLeft(): number {
if (!this._clientRectDeltaLeftRead) {
this._clientRectDeltaLeftRead = true;
this._clientRectDeltaLeft = this._domNode.getBoundingClientRect().left;
if (!this._clientRectRead) {
this.readClientRect();
}
return this._clientRectDeltaLeft;
}
public get clientRectScale(): number {
if (!this._clientRectRead) {
this.readClientRect();
}
return this._clientRectScale;
}
public readonly endNode: HTMLElement;
constructor(domNode: HTMLElement, endNode: HTMLElement) {
this._domNode = domNode;
this._clientRectDeltaLeft = 0;
this._clientRectDeltaLeftRead = false;
this._clientRectScale = 1;
this._clientRectRead = false;
this.endNode = endNode;
}
@@ -81,7 +99,7 @@ export class ViewLineOptions {
public readonly stopRenderingLineAfter: number;
public readonly fontLigatures: string;
constructor(config: IConfiguration, themeType: ColorScheme) {
constructor(config: IEditorConfiguration, themeType: ColorScheme) {
this.themeType = themeType;
const options = config.options;
const fontInfo = options.get(EditorOption.fontInfo);
@@ -161,7 +179,7 @@ export class ViewLine implements IVisibleLine {
this._options = newOptions;
}
public onSelectionChanged(): boolean {
if (this._options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
if (isHighContrast(this._options.themeType) || this._options.renderWhitespace === 'selection') {
this._isMaybeInvalid = true;
return true;
}
@@ -182,7 +200,7 @@ export class ViewLine implements IVisibleLine {
// Only send selection information when needed for rendering whitespace
let selectionsOnLine: LineRange[] | null = null;
if (options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
if (isHighContrast(options.themeType) || this._options.renderWhitespace === 'selection') {
const selections = viewportData.selections;
for (const selection of selections) {
@@ -195,7 +213,7 @@ export class ViewLine implements IVisibleLine {
const endColumn = (selection.endLineNumber === lineNumber ? selection.endColumn : lineData.maxColumn);
if (startColumn < endColumn) {
if (options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace !== 'selection') {
if (isHighContrast(options.themeType) || this._options.renderWhitespace !== 'selection') {
actualInlineDecorations.push(new LineDecoration(startColumn, endColumn, 'inline-selected-text', InlineDecorationType.Regular));
} else {
if (!selectionsOnLine) {
@@ -331,13 +349,11 @@ export class ViewLine implements IVisibleLine {
if (!this._renderedViewLine) {
return null;
}
startColumn = startColumn | 0; // @perf
endColumn = endColumn | 0; // @perf
startColumn = Math.min(this._renderedViewLine.input.lineContent.length + 1, Math.max(1, startColumn));
endColumn = Math.min(this._renderedViewLine.input.lineContent.length + 1, Math.max(1, endColumn));
const stopRenderingLineAfter = this._renderedViewLine.input.stopRenderingLineAfter | 0; // @perf
const stopRenderingLineAfter = this._renderedViewLine.input.stopRenderingLineAfter;
let outsideRenderedLine = false;
if (stopRenderingLineAfter !== -1 && startColumn > stopRenderingLineAfter + 1 && endColumn > stopRenderingLineAfter + 1) {
@@ -589,7 +605,7 @@ class RenderedViewLine implements IRenderedViewLine {
private _actualReadPixelOffset(domNode: FastDomNode<HTMLElement>, lineNumber: number, column: number, context: DomReadingContext): number {
if (this._characterMapping.length === 0) {
// This line has no content
const r = RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), 0, 0, 0, 0, context.clientRectDeltaLeft, context.endNode);
const r = RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), 0, 0, 0, 0, context.clientRectDeltaLeft, context.clientRectScale, context.endNode);
if (!r || r.length === 0) {
return -1;
}
@@ -603,7 +619,7 @@ class RenderedViewLine implements IRenderedViewLine {
const domPosition = this._characterMapping.getDomPosition(column);
const r = RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), domPosition.partIndex, domPosition.charIndex, domPosition.partIndex, domPosition.charIndex, context.clientRectDeltaLeft, context.endNode);
const r = RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), domPosition.partIndex, domPosition.charIndex, domPosition.partIndex, domPosition.charIndex, context.clientRectDeltaLeft, context.clientRectScale, context.endNode);
if (!r || r.length === 0) {
return -1;
}
@@ -629,7 +645,7 @@ class RenderedViewLine implements IRenderedViewLine {
const startDomPosition = this._characterMapping.getDomPosition(startColumn);
const endDomPosition = this._characterMapping.getDomPosition(endColumn);
return RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), startDomPosition.partIndex, startDomPosition.charIndex, endDomPosition.partIndex, endDomPosition.charIndex, context.clientRectDeltaLeft, context.endNode);
return RangeUtil.readHorizontalRanges(this._getReadingTarget(domNode), startDomPosition.partIndex, startDomPosition.charIndex, endDomPosition.partIndex, endDomPosition.charIndex, context.clientRectDeltaLeft, context.clientRectScale, context.endNode);
}
/**

11
src/vs/editor/browser/viewParts/lines/viewLines.css
View File

@@ -14,6 +14,11 @@
100% { background-color: none }
}*/
.mtkcontrol {
color: rgb(255, 255, 255) !important;
background: rgb(150, 0, 0) !important;
}
.monaco-editor.no-user-select .lines-content,
.monaco-editor.no-user-select .view-line,
.monaco-editor.no-user-select .view-lines {
@@ -22,6 +27,12 @@
-ms-user-select: none;
}
.monaco-editor.enable-user-select {
user-select: initial;
-webkit-user-select: initial;
-ms-user-select: initial;
}
.monaco-editor .view-lines {
white-space: nowrap;
}

69
src/vs/editor/browser/viewParts/lines/viewLines.ts
View File

@@ -7,7 +7,7 @@ import 'vs/css!./viewLines';
import * as platform from 'vs/base/common/platform';
import { FastDomNode } from 'vs/base/browser/fastDomNode';
import { RunOnceScheduler } from 'vs/base/common/async';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { IVisibleLinesHost, VisibleLinesCollection } from 'vs/editor/browser/view/viewLayer';
import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/view/viewPart';
import { DomReadingContext, ViewLine, ViewLineOptions } from 'vs/editor/browser/viewParts/lines/viewLine';
@@ -15,11 +15,11 @@ import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import { ScrollType } from 'vs/editor/common/editorCommon';
import { IViewLines, LineVisibleRanges, VisibleRanges, HorizontalPosition, HorizontalRange } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { IViewLines, LineVisibleRanges, VisibleRanges, HorizontalPosition, HorizontalRange } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { Viewport } from 'vs/editor/common/viewModel/viewModel';
import { Viewport } from 'vs/editor/common/viewModel';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { Constants } from 'vs/base/common/uint';
import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'vs/base/browser/ui/mouseCursor/mouseCursor';
@@ -47,6 +47,7 @@ class HorizontalRevealRangeRequest {
public readonly maxLineNumber: number;
constructor(
public readonly minimalReveal: boolean,
public readonly lineNumber: number,
public readonly startColumn: number,
public readonly endColumn: number,
@@ -65,6 +66,7 @@ class HorizontalRevealSelectionsRequest {
public readonly maxLineNumber: number;
constructor(
public readonly minimalReveal: boolean,
public readonly selections: Selection[],
public readonly startScrollTop: number,
public readonly stopScrollTop: number,
@@ -100,6 +102,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
private _typicalHalfwidthCharacterWidth: number;
private _isViewportWrapping: boolean;
private _revealHorizontalRightPadding: number;
private _horizontalScrollbarHeight: number;
private _cursorSurroundingLines: number;
private _cursorSurroundingLinesStyle: 'default' | 'all';
private _canUseLayerHinting: boolean;
@@ -124,11 +127,13 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const options = this._context.configuration.options;
const fontInfo = options.get(EditorOption.fontInfo);
const wrappingInfo = options.get(EditorOption.wrappingInfo);
const layoutInfo = options.get(EditorOption.layoutInfo);
this._lineHeight = options.get(EditorOption.lineHeight);
this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
this._isViewportWrapping = wrappingInfo.isViewportWrapping;
this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
@@ -136,7 +141,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
PartFingerprints.write(this.domNode, PartFingerprint.ViewLines);
this.domNode.setClassName(`view-lines ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`);
Configuration.applyFontInfo(this.domNode, fontInfo);
applyFontInfo(this.domNode, fontInfo);
// --- width & height
this._maxLineWidth = 0;
@@ -181,15 +186,17 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const options = this._context.configuration.options;
const fontInfo = options.get(EditorOption.fontInfo);
const wrappingInfo = options.get(EditorOption.wrappingInfo);
const layoutInfo = options.get(EditorOption.layoutInfo);
this._lineHeight = options.get(EditorOption.lineHeight);
this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
this._isViewportWrapping = wrappingInfo.isViewportWrapping;
this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
Configuration.applyFontInfo(this.domNode, fontInfo);
applyFontInfo(this.domNode, fontInfo);
this._onOptionsMaybeChanged();
@@ -253,7 +260,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
public override onRevealRangeRequest(e: viewEvents.ViewRevealRangeRequestEvent): boolean {
// Using the future viewport here in order to handle multiple
// incoming reveal range requests that might all desire to be animated
const desiredScrollTop = this._computeScrollTopToRevealRange(this._context.viewLayout.getFutureViewport(), e.source, e.range, e.selections, e.verticalType);
const desiredScrollTop = this._computeScrollTopToRevealRange(this._context.viewLayout.getFutureViewport(), e.source, e.minimalReveal, e.range, e.selections, e.verticalType);
if (desiredScrollTop === -1) {
// marker to abort the reveal range request
@@ -272,9 +279,9 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
};
} else if (e.range) {
// We don't necessarily know the horizontal offset of this range since the line might not be in the view...
this._horizontalRevealRequest = new HorizontalRevealRangeRequest(e.range.startLineNumber, e.range.startColumn, e.range.endColumn, this._context.viewLayout.getCurrentScrollTop(), newScrollPosition.scrollTop, e.scrollType);
this._horizontalRevealRequest = new HorizontalRevealRangeRequest(e.minimalReveal, e.range.startLineNumber, e.range.startColumn, e.range.endColumn, this._context.viewLayout.getCurrentScrollTop(), newScrollPosition.scrollTop, e.scrollType);
} else if (e.selections && e.selections.length > 0) {
this._horizontalRevealRequest = new HorizontalRevealSelectionsRequest(e.selections, this._context.viewLayout.getCurrentScrollTop(), newScrollPosition.scrollTop, e.scrollType);
this._horizontalRevealRequest = new HorizontalRevealSelectionsRequest(e.minimalReveal, e.selections, this._context.viewLayout.getCurrentScrollTop(), newScrollPosition.scrollTop, e.scrollType);
}
} else {
this._horizontalRevealRequest = null;
@@ -282,7 +289,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const scrollTopDelta = Math.abs(this._context.viewLayout.getCurrentScrollTop() - newScrollPosition.scrollTop);
const scrollType = (scrollTopDelta <= this._lineHeight ? ScrollType.Immediate : e.scrollType);
this._context.model.setScrollPosition(newScrollPosition, scrollType);
this._context.viewModel.viewLayout.setScrollPosition(newScrollPosition, scrollType);
return true;
}
@@ -307,7 +314,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
return this._visibleLines.onTokensChanged(e);
}
public override onZonesChanged(e: viewEvents.ViewZonesChangedEvent): boolean {
this._context.model.setMaxLineWidth(this._maxLineWidth);
this._context.viewModel.viewLayout.setMaxLineWidth(this._maxLineWidth);
return this._visibleLines.onZonesChanged(e);
}
public override onThemeChanged(e: viewEvents.ViewThemeChangedEvent): boolean {
@@ -331,12 +338,12 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
return null;
}
if (lineNumber < 1 || lineNumber > this._context.model.getLineCount()) {
if (lineNumber < 1 || lineNumber > this._context.viewModel.getLineCount()) {
// lineNumber is outside range
return null;
}
if (this._context.model.getLineMaxColumn(lineNumber) === 1) {
if (this._context.viewModel.getLineMaxColumn(lineNumber) === 1) {
// Line is empty
return new Position(lineNumber, 1);
}
@@ -349,7 +356,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
}
let column = this._visibleLines.getVisibleLine(lineNumber).getColumnOfNodeOffset(lineNumber, spanNode, offset);
const minColumn = this._context.model.getLineMinColumn(lineNumber);
const minColumn = this._context.viewModel.getLineMinColumn(lineNumber);
if (column < minColumn) {
column = minColumn;
}
@@ -410,7 +417,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
let nextLineModelLineNumber: number = 0;
if (includeNewLines) {
nextLineModelLineNumber = this._context.model.coordinatesConverter.convertViewPositionToModelPosition(new Position(range.startLineNumber, 1)).lineNumber;
nextLineModelLineNumber = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(new Position(range.startLineNumber, 1)).lineNumber;
}
const rendStartLineNumber = this._visibleLines.getStartLineNumber();
@@ -422,7 +429,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
}
const startColumn = lineNumber === range.startLineNumber ? range.startColumn : 1;
const endColumn = lineNumber === range.endLineNumber ? range.endColumn : this._context.model.getLineMaxColumn(lineNumber);
const endColumn = lineNumber === range.endLineNumber ? range.endColumn : this._context.viewModel.getLineMaxColumn(lineNumber);
const visibleRangesForLine = this._visibleLines.getVisibleLine(lineNumber).getVisibleRangesForRange(lineNumber, startColumn, endColumn, domReadingContext);
if (!visibleRangesForLine) {
@@ -431,7 +438,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
if (includeNewLines && lineNumber < originalEndLineNumber) {
const currentLineModelLineNumber = nextLineModelLineNumber;
nextLineModelLineNumber = this._context.model.coordinatesConverter.convertViewPositionToModelPosition(new Position(lineNumber + 1, 1)).lineNumber;
nextLineModelLineNumber = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(new Position(lineNumber + 1, 1)).lineNumber;
if (currentLineModelLineNumber !== nextLineModelLineNumber) {
visibleRangesForLine.ranges[visibleRangesForLine.ranges.length - 1].width += this._typicalHalfwidthCharacterWidth;
@@ -507,7 +514,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
localMaxLineWidth = Math.max(localMaxLineWidth, visibleLine.getWidth());
}
if (allWidthsComputed && rendStartLineNumber === 1 && rendEndLineNumber === this._context.model.getLineCount()) {
if (allWidthsComputed && rendStartLineNumber === 1 && rendEndLineNumber === this._context.viewModel.getLineCount()) {
// we know the max line width for all the lines
this._maxLineWidth = 0;
}
@@ -587,7 +594,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
this._ensureMaxLineWidth(newScrollLeft.maxHorizontalOffset);
}
// set `scrollLeft`
this._context.model.setScrollPosition({
this._context.viewModel.viewLayout.setScrollPosition({
scrollLeft: newScrollLeft.scrollLeft
}, horizontalRevealRequest.scrollType);
}
@@ -626,11 +633,11 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const iLineWidth = Math.ceil(lineWidth);
if (this._maxLineWidth < iLineWidth) {
this._maxLineWidth = iLineWidth;
this._context.model.setMaxLineWidth(this._maxLineWidth);
this._context.viewModel.viewLayout.setMaxLineWidth(this._maxLineWidth);
}
}
private _computeScrollTopToRevealRange(viewport: Viewport, source: string | null | undefined, range: Range | null, selections: Selection[] | null, verticalType: viewEvents.VerticalRevealType): number {
private _computeScrollTopToRevealRange(viewport: Viewport, source: string | null | undefined, minimalReveal: boolean, range: Range | null, selections: Selection[] | null, verticalType: viewEvents.VerticalRevealType): number {
const viewportStartY = viewport.top;
const viewportHeight = viewport.height;
const viewportEndY = viewportStartY + viewportHeight;
@@ -638,7 +645,6 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
let boxStartY: number;
let boxEndY: number;
// Have a box that includes one extra line height (for the horizontal scrollbar)
if (selections && selections.length > 0) {
let minLineNumber = selections[0].startLineNumber;
let maxLineNumber = selections[0].endLineNumber;
@@ -658,17 +664,22 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
return -1;
}
const shouldIgnoreScrollOff = source === 'mouse' && this._cursorSurroundingLinesStyle === 'default';
const shouldIgnoreScrollOff = (source === 'mouse' || minimalReveal) && this._cursorSurroundingLinesStyle === 'default';
if (!shouldIgnoreScrollOff) {
const context = Math.min((viewportHeight / this._lineHeight) / 2, this._cursorSurroundingLines);
boxStartY -= context * this._lineHeight;
boxEndY += Math.max(0, (context - 1)) * this._lineHeight;
} else {
if (!minimalReveal) {
// Reveal one more line above (this case is hit when dragging)
boxStartY -= this._lineHeight;
}
}
if (verticalType === viewEvents.VerticalRevealType.Simple || verticalType === viewEvents.VerticalRevealType.Bottom) {
// Reveal one line more when the last line would be covered by the scrollbar - arrow down case or revealing a line explicitly at bottom
boxEndY += this._lineHeight;
boxEndY += (minimalReveal ? this._horizontalScrollbarHeight : this._lineHeight);
}
let newScrollTop: number;
@@ -709,7 +720,7 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
return newScrollTop;
}
private _computeScrollLeftToReveal(horizontalRevealRequest: HorizontalRevealRequest): { scrollLeft: number; maxHorizontalOffset: number; } | null {
private _computeScrollLeftToReveal(horizontalRevealRequest: HorizontalRevealRequest): { scrollLeft: number; maxHorizontalOffset: number } | null {
const viewport = this._context.viewLayout.getCurrentViewport();
const viewportStartX = viewport.left;
@@ -742,8 +753,10 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
}
}
boxStartX = Math.max(0, boxStartX - ViewLines.HORIZONTAL_EXTRA_PX);
boxEndX += this._revealHorizontalRightPadding;
if (!horizontalRevealRequest.minimalReveal) {
boxStartX = Math.max(0, boxStartX - ViewLines.HORIZONTAL_EXTRA_PX);
boxEndX += this._revealHorizontalRightPadding;
}
if (horizontalRevealRequest.type === 'selections' && boxEndX - boxStartX > viewport.width) {
return null;

9
src/vs/editor/browser/viewParts/linesDecorations/linesDecorations.ts
View File

@@ -5,9 +5,9 @@
import 'vs/css!./linesDecorations';
import { DecorationToRender, DedupOverlay } from 'vs/editor/browser/viewParts/glyphMargin/glyphMargin';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
@@ -71,7 +71,8 @@ export class LinesDecorationsOverlay extends DedupOverlay {
protected _getDecorations(ctx: RenderingContext): DecorationToRender[] {
const decorations = ctx.getDecorationsInViewport();
let r: DecorationToRender[] = [], rLen = 0;
const r: DecorationToRender[] = [];
let rLen = 0;
for (let i = 0, len = decorations.length; i < len; i++) {
const d = decorations[i];
const linesDecorationsClassName = d.options.linesDecorationsClassName;

6
src/vs/editor/browser/viewParts/margin/margin.ts
View File

@@ -5,9 +5,9 @@
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { EditorOption } from 'vs/editor/common/config/editorOptions';

9
src/vs/editor/browser/viewParts/marginDecorations/marginDecorations.ts
View File

@@ -5,9 +5,9 @@
import 'vs/css!./marginDecorations';
import { DecorationToRender, DedupOverlay } from 'vs/editor/browser/viewParts/glyphMargin/glyphMargin';
import { RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
export class MarginViewLineDecorationsOverlay extends DedupOverlay {
private readonly _context: ViewContext;
@@ -57,7 +57,8 @@ export class MarginViewLineDecorationsOverlay extends DedupOverlay {
protected _getDecorations(ctx: RenderingContext): DecorationToRender[] {
const decorations = ctx.getDecorationsInViewport();
let r: DecorationToRender[] = [], rLen = 0;
const r: DecorationToRender[] = [];
let rLen = 0;
for (let i = 0, len = decorations.length; i < len; i++) {
const d = decorations[i];
const marginClassName = d.options.marginClassName;

156
src/vs/editor/browser/viewParts/minimap/minimap.ts
View File

@@ -6,7 +6,7 @@
import 'vs/css!./minimap';
import * as dom from 'vs/base/browser/dom';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { GlobalMouseMoveMonitor, IStandardMouseMoveEventData, standardMouseMoveMerger } from 'vs/base/browser/globalMouseMoveMonitor';
import { GlobalPointerMoveMonitor, standardPointerMoveMerger } from 'vs/base/browser/globalPointerMoveMonitor';
import { CharCode } from 'vs/base/common/charCode';
import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
import * as platform from 'vs/base/common/platform';
@@ -16,15 +16,17 @@ import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/v
import { RenderMinimap, EditorOption, MINIMAP_GUTTER_WIDTH, EditorLayoutInfoComputer } from 'vs/editor/common/config/editorOptions';
import { Range } from 'vs/editor/common/core/range';
import { RGBA8 } from 'vs/editor/common/core/rgba';
import { IConfiguration, ScrollType } from 'vs/editor/common/editorCommon';
import { ColorId } from 'vs/editor/common/modes';
import { ScrollType } from 'vs/editor/common/editorCommon';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { ColorId } from 'vs/editor/common/languages';
import { MinimapCharRenderer } from 'vs/editor/browser/viewParts/minimap/minimapCharRenderer';
import { Constants } from 'vs/editor/browser/viewParts/minimap/minimapCharSheet';
import { MinimapTokensColorTracker } from 'vs/editor/common/viewModel/minimapTokensColorTracker';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext, EditorTheme } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ViewLineData, ViewModelDecoration } from 'vs/editor/common/viewModel/viewModel';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { EditorTheme } from 'vs/editor/common/editorTheme';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewLineData, ViewModelDecoration } from 'vs/editor/common/viewModel';
import { minimapSelection, scrollbarShadow, minimapBackground, minimapSliderBackground, minimapSliderHoverBackground, minimapSliderActiveBackground, minimapForegroundOpacity } from 'vs/platform/theme/common/colorRegistry';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { ModelDecorationMinimapOptions } from 'vs/editor/common/model/textModel';
@@ -38,7 +40,7 @@ import { once } from 'vs/base/common/functional';
/**
* The orthogonal distance to the slider at which dragging "resets". This implements "snapping"
*/
const MOUSE_DRAG_RESET_DISTANCE = 140;
const POINTER_DRAG_RESET_DISTANCE = 140;
const GUTTER_DECORATION_WIDTH = 2;
@@ -105,7 +107,7 @@ class MinimapOptions {
*/
public readonly foregroundAlpha: number;
constructor(configuration: IConfiguration, theme: EditorTheme, tokensColorTracker: MinimapTokensColorTracker) {
constructor(configuration: IEditorConfiguration, theme: EditorTheme, tokensColorTracker: MinimapTokensColorTracker) {
const options = configuration.options;
const pixelRatio = options.get(EditorOption.pixelRatio);
const layoutInfo = options.get(EditorOption.layoutInfo);
@@ -425,7 +427,7 @@ class RenderData {
&& this.renderedLayout.endLineNumber === layout.endLineNumber;
}
_get(): { imageData: ImageData; rendLineNumberStart: number; lines: MinimapLine[]; } {
_get(): { imageData: ImageData; rendLineNumberStart: number; lines: MinimapLine[] } {
const tmp = this._renderedLines._get();
return {
imageData: this._imageData,
@@ -434,8 +436,8 @@ class RenderData {
};
}
public onLinesChanged(changeFromLineNumber: number, changeToLineNumber: number): boolean {
return this._renderedLines.onLinesChanged(changeFromLineNumber, changeToLineNumber);
public onLinesChanged(changeFromLineNumber: number, changeCount: number): boolean {
return this._renderedLines.onLinesChanged(changeFromLineNumber, changeCount);
}
public onLinesDeleted(deleteFromLineNumber: number, deleteToLineNumber: number): void {
this._renderedLines.onLinesDeleted(deleteFromLineNumber, deleteToLineNumber);
@@ -443,7 +445,7 @@ class RenderData {
public onLinesInserted(insertFromLineNumber: number, insertToLineNumber: number): void {
this._renderedLines.onLinesInserted(insertFromLineNumber, insertToLineNumber);
}
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number; }[]): boolean {
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number }[]): boolean {
return this._renderedLines.onTokensChanged(ranges);
}
}
@@ -578,7 +580,7 @@ class MinimapSamplingState {
const halfRatio = ratio / 2;
if (!oldSamplingState || oldSamplingState.minimapLines.length === 0) {
let result: number[] = [];
const result: number[] = [];
result[0] = 1;
if (minimapLineCount > 1) {
for (let i = 0, lastIndex = minimapLineCount - 1; i < lastIndex; i++) {
@@ -591,7 +593,7 @@ class MinimapSamplingState {
const oldMinimapLines = oldSamplingState.minimapLines;
const oldLength = oldMinimapLines.length;
let result: number[] = [];
const result: number[] = [];
let oldIndex = 0;
let oldDeltaLineCount = 0;
let minViewLineNumber = 1;
@@ -771,7 +773,7 @@ export class Minimap extends ViewPart implements IMinimapModel {
this._minimapSelections = null;
this.options = new MinimapOptions(this._context.configuration, this._context.theme, this.tokensColorTracker);
const [samplingState,] = MinimapSamplingState.compute(this.options, this._context.model.getLineCount(), null);
const [samplingState,] = MinimapSamplingState.compute(this.options, this._context.viewModel.getLineCount(), null);
this._samplingState = samplingState;
this._shouldCheckSampling = false;
@@ -822,21 +824,21 @@ export class Minimap extends ViewPart implements IMinimapModel {
}
public override onLinesChanged(e: viewEvents.ViewLinesChangedEvent): boolean {
if (this._samplingState) {
const minimapLineRange = this._samplingState.modelLineRangeToMinimapLineRange(e.fromLineNumber, e.toLineNumber);
const minimapLineRange = this._samplingState.modelLineRangeToMinimapLineRange(e.fromLineNumber, e.fromLineNumber + e.count - 1);
if (minimapLineRange) {
return this._actual.onLinesChanged(minimapLineRange[0], minimapLineRange[1]);
return this._actual.onLinesChanged(minimapLineRange[0], minimapLineRange[1] - minimapLineRange[0] + 1);
} else {
return false;
}
} else {
return this._actual.onLinesChanged(e.fromLineNumber, e.toLineNumber);
return this._actual.onLinesChanged(e.fromLineNumber, e.count);
}
}
public override onLinesDeleted(e: viewEvents.ViewLinesDeletedEvent): boolean {
if (this._samplingState) {
const [changeStartIndex, changeEndIndex] = this._samplingState.onLinesDeleted(e);
if (changeStartIndex <= changeEndIndex) {
this._actual.onLinesChanged(changeStartIndex + 1, changeEndIndex + 1);
this._actual.onLinesChanged(changeStartIndex + 1, changeEndIndex - changeStartIndex + 1);
}
this._shouldCheckSampling = true;
return true;
@@ -857,14 +859,13 @@ export class Minimap extends ViewPart implements IMinimapModel {
return this._actual.onScrollChanged();
}
public override onThemeChanged(e: viewEvents.ViewThemeChangedEvent): boolean {
this._context.model.invalidateMinimapColorCache();
this._actual.onThemeChanged();
this._onOptionsMaybeChanged();
return true;
}
public override onTokensChanged(e: viewEvents.ViewTokensChangedEvent): boolean {
if (this._samplingState) {
let ranges: { fromLineNumber: number; toLineNumber: number; }[] = [];
const ranges: { fromLineNumber: number; toLineNumber: number }[] = [];
for (const range of e.ranges) {
const minimapLineRange = this._samplingState.modelLineRangeToMinimapLineRange(range.fromLineNumber, range.toLineNumber);
if (minimapLineRange) {
@@ -931,7 +932,7 @@ export class Minimap extends ViewPart implements IMinimapModel {
this._minimapSelections = null;
const wasSampling = Boolean(this._samplingState);
const [samplingState, events] = MinimapSamplingState.compute(this.options, this._context.model.getLineCount(), this._samplingState);
const [samplingState, events] = MinimapSamplingState.compute(this.options, this._context.viewModel.getLineCount(), this._samplingState);
this._samplingState = samplingState;
if (wasSampling && this._samplingState) {
@@ -956,40 +957,40 @@ export class Minimap extends ViewPart implements IMinimapModel {
if (this._samplingState) {
return this._samplingState.minimapLines.length;
}
return this._context.model.getLineCount();
return this._context.viewModel.getLineCount();
}
public getRealLineCount(): number {
return this._context.model.getLineCount();
return this._context.viewModel.getLineCount();
}
public getLineContent(lineNumber: number): string {
if (this._samplingState) {
return this._context.model.getLineContent(this._samplingState.minimapLines[lineNumber - 1]);
return this._context.viewModel.getLineContent(this._samplingState.minimapLines[lineNumber - 1]);
}
return this._context.model.getLineContent(lineNumber);
return this._context.viewModel.getLineContent(lineNumber);
}
public getLineMaxColumn(lineNumber: number): number {
if (this._samplingState) {
return this._context.model.getLineMaxColumn(this._samplingState.minimapLines[lineNumber - 1]);
return this._context.viewModel.getLineMaxColumn(this._samplingState.minimapLines[lineNumber - 1]);
}
return this._context.model.getLineMaxColumn(lineNumber);
return this._context.viewModel.getLineMaxColumn(lineNumber);
}
public getMinimapLinesRenderingData(startLineNumber: number, endLineNumber: number, needed: boolean[]): (ViewLineData | null)[] {
if (this._samplingState) {
let result: (ViewLineData | null)[] = [];
const result: (ViewLineData | null)[] = [];
for (let lineIndex = 0, lineCount = endLineNumber - startLineNumber + 1; lineIndex < lineCount; lineIndex++) {
if (needed[lineIndex]) {
result[lineIndex] = this._context.model.getViewLineData(this._samplingState.minimapLines[startLineNumber + lineIndex - 1]);
result[lineIndex] = this._context.viewModel.getViewLineData(this._samplingState.minimapLines[startLineNumber + lineIndex - 1]);
} else {
result[lineIndex] = null;
}
}
return result;
}
return this._context.model.getMinimapLinesRenderingData(startLineNumber, endLineNumber, needed).data;
return this._context.viewModel.getMinimapLinesRenderingData(startLineNumber, endLineNumber, needed).data;
}
public getSelections(): Selection[] {
@@ -1012,14 +1013,14 @@ export class Minimap extends ViewPart implements IMinimapModel {
if (this._samplingState) {
const modelStartLineNumber = this._samplingState.minimapLines[startLineNumber - 1];
const modelEndLineNumber = this._samplingState.minimapLines[endLineNumber - 1];
visibleRange = new Range(modelStartLineNumber, 1, modelEndLineNumber, this._context.model.getLineMaxColumn(modelEndLineNumber));
visibleRange = new Range(modelStartLineNumber, 1, modelEndLineNumber, this._context.viewModel.getLineMaxColumn(modelEndLineNumber));
} else {
visibleRange = new Range(startLineNumber, 1, endLineNumber, this._context.model.getLineMaxColumn(endLineNumber));
visibleRange = new Range(startLineNumber, 1, endLineNumber, this._context.viewModel.getLineMaxColumn(endLineNumber));
}
const decorations = this._context.model.getDecorationsInViewport(visibleRange);
const decorations = this._context.viewModel.getDecorationsInViewport(visibleRange);
if (this._samplingState) {
let result: ViewModelDecoration[] = [];
const result: ViewModelDecoration[] = [];
for (const decoration of decorations) {
if (!decoration.options.minimap) {
continue;
@@ -1035,14 +1036,14 @@ export class Minimap extends ViewPart implements IMinimapModel {
}
public getOptions(): TextModelResolvedOptions {
return this._context.model.getTextModelOptions();
return this._context.viewModel.model.getOptions();
}
public revealLineNumber(lineNumber: number): void {
if (this._samplingState) {
lineNumber = this._samplingState.minimapLines[lineNumber - 1];
}
this._context.model.revealRange(
this._context.viewModel.revealRange(
'mouse',
false,
new Range(lineNumber, 1, lineNumber, 1),
@@ -1052,7 +1053,7 @@ export class Minimap extends ViewPart implements IMinimapModel {
}
public setScrollTop(scrollTop: number): void {
this._context.model.setScrollPosition({
this._context.viewModel.viewLayout.setScrollPosition({
scrollTop: scrollTop
}, ScrollType.Immediate);
}
@@ -1071,9 +1072,9 @@ class InnerMinimap extends Disposable {
private readonly _decorationsCanvas: FastDomNode<HTMLCanvasElement>;
private readonly _slider: FastDomNode<HTMLElement>;
private readonly _sliderHorizontal: FastDomNode<HTMLElement>;
private readonly _mouseDownListener: IDisposable;
private readonly _sliderMouseMoveMonitor: GlobalMouseMoveMonitor<IStandardMouseMoveEventData>;
private readonly _sliderMouseDownListener: IDisposable;
private readonly _pointerDownListener: IDisposable;
private readonly _sliderPointerMoveMonitor: GlobalPointerMoveMonitor;
private readonly _sliderPointerDownListener: IDisposable;
private readonly _gestureDisposable: IDisposable;
private readonly _sliderTouchStartListener: IDisposable;
private readonly _sliderTouchMoveListener: IDisposable;
@@ -1134,7 +1135,7 @@ class InnerMinimap extends Disposable {
this._applyLayout();
this._mouseDownListener = dom.addStandardDisposableListener(this._domNode.domNode, 'mousedown', (e) => {
this._pointerDownListener = dom.addStandardDisposableListener(this._domNode.domNode, dom.EventType.POINTER_DOWN, (e) => {
e.preventDefault();
const renderMinimap = this._model.options.renderMinimap;
@@ -1145,16 +1146,16 @@ class InnerMinimap extends Disposable {
return;
}
if (this._model.options.size !== 'proportional') {
if (e.leftButton && this._lastRenderData) {
if (e.button === 0 && this._lastRenderData) {
// pretend the click occurred in the center of the slider
const position = dom.getDomNodePagePosition(this._slider.domNode);
const initialPosY = position.top + position.height / 2;
this._startSliderDragging(e.buttons, e.posx, initialPosY, e.posy, this._lastRenderData.renderedLayout);
this._startSliderDragging(e, initialPosY, this._lastRenderData.renderedLayout);
}
return;
}
const minimapLineHeight = this._model.options.minimapLineHeight;
const internalOffsetY = (this._model.options.canvasInnerHeight / this._model.options.canvasOuterHeight) * e.browserEvent.offsetY;
const internalOffsetY = (this._model.options.canvasInnerHeight / this._model.options.canvasOuterHeight) * e.offsetY;
const lineIndex = Math.floor(internalOffsetY / minimapLineHeight);
let lineNumber = lineIndex + this._lastRenderData.renderedLayout.startLineNumber;
@@ -1163,13 +1164,13 @@ class InnerMinimap extends Disposable {
this._model.revealLineNumber(lineNumber);
});
this._sliderMouseMoveMonitor = new GlobalMouseMoveMonitor<IStandardMouseMoveEventData>();
this._sliderPointerMoveMonitor = new GlobalPointerMoveMonitor();
this._sliderMouseDownListener = dom.addStandardDisposableListener(this._slider.domNode, 'mousedown', (e) => {
this._sliderPointerDownListener = dom.addStandardDisposableListener(this._slider.domNode, dom.EventType.POINTER_DOWN, (e) => {
e.preventDefault();
e.stopPropagation();
if (e.leftButton && this._lastRenderData) {
this._startSliderDragging(e.buttons, e.posx, e.posy, e.posy, this._lastRenderData.renderedLayout);
if (e.button === 0 && this._lastRenderData) {
this._startSliderDragging(e, e.pageY, this._lastRenderData.renderedLayout);
}
});
@@ -1200,31 +1201,37 @@ class InnerMinimap extends Disposable {
});
}
private _startSliderDragging(initialButtons: number, initialPosX: number, initialPosY: number, posy: number, initialSliderState: MinimapLayout): void {
private _startSliderDragging(e: PointerEvent, initialPosY: number, initialSliderState: MinimapLayout): void {
if (!e.target || !(e.target instanceof Element)) {
return;
}
const initialPosX = e.pageX;
this._slider.toggleClassName('active', true);
const handleMouseMove = (posy: number, posx: number) => {
const mouseOrthogonalDelta = Math.abs(posx - initialPosX);
const handlePointerMove = (posy: number, posx: number) => {
const pointerOrthogonalDelta = Math.abs(posx - initialPosX);
if (platform.isWindows && mouseOrthogonalDelta > MOUSE_DRAG_RESET_DISTANCE) {
// The mouse has wondered away from the scrollbar => reset dragging
if (platform.isWindows && pointerOrthogonalDelta > POINTER_DRAG_RESET_DISTANCE) {
// The pointer has wondered away from the scrollbar => reset dragging
this._model.setScrollTop(initialSliderState.scrollTop);
return;
}
const mouseDelta = posy - initialPosY;
this._model.setScrollTop(initialSliderState.getDesiredScrollTopFromDelta(mouseDelta));
const pointerDelta = posy - initialPosY;
this._model.setScrollTop(initialSliderState.getDesiredScrollTopFromDelta(pointerDelta));
};
if (posy !== initialPosY) {
handleMouseMove(posy, initialPosX);
if (e.pageY !== initialPosY) {
handlePointerMove(e.pageY, initialPosX);
}
this._sliderMouseMoveMonitor.startMonitoring(
this._slider.domNode,
initialButtons,
standardMouseMoveMerger,
(mouseMoveData: IStandardMouseMoveEventData) => handleMouseMove(mouseMoveData.posy, mouseMoveData.posx),
this._sliderPointerMoveMonitor.startMonitoring(
e.target,
e.pointerId,
e.buttons,
standardPointerMoveMerger,
pointerMoveData => handlePointerMove(pointerMoveData.pageY, pointerMoveData.pageX),
() => {
this._slider.toggleClassName('active', false);
}
@@ -1238,9 +1245,9 @@ class InnerMinimap extends Disposable {
}
public override dispose(): void {
this._mouseDownListener.dispose();
this._sliderMouseMoveMonitor.dispose();
this._sliderMouseDownListener.dispose();
this._pointerDownListener.dispose();
this._sliderPointerMoveMonitor.dispose();
this._sliderPointerDownListener.dispose();
this._gestureDisposable.dispose();
this._sliderTouchStartListener.dispose();
this._sliderTouchMoveListener.dispose();
@@ -1312,9 +1319,9 @@ class InnerMinimap extends Disposable {
this._lastRenderData = null;
return true;
}
public onLinesChanged(changeFromLineNumber: number, changeToLineNumber: number): boolean {
public onLinesChanged(changeFromLineNumber: number, changeCount: number): boolean {
if (this._lastRenderData) {
return this._lastRenderData.onLinesChanged(changeFromLineNumber, changeToLineNumber);
return this._lastRenderData.onLinesChanged(changeFromLineNumber, changeCount);
}
return false;
}
@@ -1339,7 +1346,7 @@ class InnerMinimap extends Disposable {
this._renderDecorations = true;
return true;
}
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number; }[]): boolean {
public onTokensChanged(ranges: { fromLineNumber: number; toLineNumber: number }[]): boolean {
if (this._lastRenderData) {
return this._lastRenderData.onTokensChanged(ranges);
}
@@ -1506,7 +1513,7 @@ class InnerMinimap extends Disposable {
continue;
}
const decorationColor = minimapOptions.getColor(this._theme);
const decorationColor = minimapOptions.getColor(this._theme.value);
if (!decorationColor || decorationColor.isTransparent()) {
continue;
}
@@ -1581,7 +1588,7 @@ class InnerMinimap extends Disposable {
continue;
}
const decorationColor = minimapOptions.getColor(this._theme);
const decorationColor = minimapOptions.getColor(this._theme.value);
if (!decorationColor || decorationColor.isTransparent()) {
continue;
}
@@ -1593,11 +1600,12 @@ class InnerMinimap extends Disposable {
this.renderDecorationOnLine(canvasContext, lineOffsetMap, decoration.range, decorationColor, layout, line, lineHeight, lineHeight, tabSize, characterWidth, canvasInnerWidth);
continue;
case MinimapPosition.Gutter:
case MinimapPosition.Gutter: {
const y = (line - layout.startLineNumber) * lineHeight;
const x = 2;
this.renderDecoration(canvasContext, decorationColor, x, y, GUTTER_DECORATION_WIDTH, lineHeight);
continue;
}
}
}
}
@@ -1713,7 +1721,7 @@ class InnerMinimap extends Disposable {
}
// Render untouched lines by using last rendered data.
let [_dirtyY1, _dirtyY2, needed] = InnerMinimap._renderUntouchedLines(
const [_dirtyY1, _dirtyY2, needed] = InnerMinimap._renderUntouchedLines(
imageData,
startLineNumber,
endLineNumber,

2
src/vs/editor/browser/viewParts/minimap/minimapCharRenderer.ts
View File

@@ -19,7 +19,7 @@ export class MinimapCharRenderer {
}
private static soften(input: Uint8ClampedArray, ratio: number): Uint8ClampedArray {
let result = new Uint8ClampedArray(input.length);
const result = new Uint8ClampedArray(input.length);
for (let i = 0, len = input.length; i < len; i++) {
result[i] = toUint8(input[i] * ratio);
}

2
src/vs/editor/browser/viewParts/minimap/minimapCharRendererFactory.ts
View File

@@ -80,7 +80,7 @@ export class MinimapCharRendererFactory {
throw new Error('Unexpected source in MinimapCharRenderer');
}
let charData = MinimapCharRendererFactory._downsample(source, scale);
const charData = MinimapCharRendererFactory._downsample(source, scale);
return new MinimapCharRenderer(charData, scale);
}

8
src/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.ts
View File

@@ -7,9 +7,9 @@ import 'vs/css!./overlayWidgets';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IOverlayWidget, OverlayWidgetPositionPreference } from 'vs/editor/browser/editorBrowser';
import { PartFingerprint, PartFingerprints, ViewPart } from 'vs/editor/browser/view/viewPart';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
@@ -122,7 +122,7 @@ export class ViewOverlayWidgets extends ViewPart {
const domNode = widgetData.domNode;
if (widgetData.preference === null) {
domNode.unsetTop();
domNode.setTop('');
return;
}

25
src/vs/editor/browser/viewParts/overviewRuler/decorationsOverviewRuler.ts
View File

@@ -8,14 +8,15 @@ import { Color } from 'vs/base/common/color';
import { IDisposable } from 'vs/base/common/lifecycle';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { Position } from 'vs/editor/common/core/position';
import { IConfiguration } from 'vs/editor/common/editorCommon';
import { TokenizationRegistry } from 'vs/editor/common/modes';
import { editorCursorForeground, editorOverviewRulerBorder, editorOverviewRulerBackground } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext, EditorTheme } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { TokenizationRegistry } from 'vs/editor/common/languages';
import { editorCursorForeground, editorOverviewRulerBorder, editorOverviewRulerBackground } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { EditorTheme } from 'vs/editor/common/editorTheme';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { OverviewRulerDecorationsGroup } from 'vs/editor/common/viewModel/viewModel';
import { OverviewRulerDecorationsGroup } from 'vs/editor/common/viewModel';
class Settings {
@@ -29,7 +30,7 @@ class Settings {
public readonly hideCursor: boolean;
public readonly cursorColor: string | null;
public readonly themeType: 'light' | 'dark' | 'hc';
public readonly themeType: 'light' | 'dark' | 'hcLight' | 'hcDark';
public readonly backgroundColor: string | null;
public readonly top: number;
@@ -42,7 +43,7 @@ class Settings {
public readonly x: number[];
public readonly w: number[];
constructor(config: IConfiguration, theme: EditorTheme) {
constructor(config: IEditorConfiguration, theme: EditorTheme) {
const options = config.options;
this.lineHeight = options.get(EditorOption.lineHeight);
this.pixelRatio = options.get(EditorOption.pixelRatio);
@@ -295,8 +296,6 @@ export class DecorationsOverviewRuler extends ViewPart {
return true;
}
public override onThemeChanged(e: viewEvents.ViewThemeChangedEvent): boolean {
// invalidate color cache
this._context.model.invalidateOverviewRulerColorCache();
return this._updateSettings(false);
}
@@ -318,15 +317,17 @@ export class DecorationsOverviewRuler extends ViewPart {
if (this._settings.overviewRulerLanes === 0) {
// overview ruler is off
this._domNode.setBackgroundColor(this._settings.backgroundColor ? this._settings.backgroundColor : '');
this._domNode.setDisplay('none');
return;
}
this._domNode.setDisplay('block');
const canvasWidth = this._settings.canvasWidth;
const canvasHeight = this._settings.canvasHeight;
const lineHeight = this._settings.lineHeight;
const viewLayout = this._context.viewLayout;
const outerHeight = this._context.viewLayout.getScrollHeight();
const heightRatio = canvasHeight / outerHeight;
const decorations = this._context.model.getAllOverviewRulerDecorations(this._context.theme);
const decorations = this._context.viewModel.getAllOverviewRulerDecorations(this._context.theme);
const minDecorationHeight = (Constants.MIN_DECORATION_HEIGHT * this._settings.pixelRatio) | 0;
const halfMinDecorationHeight = (minDecorationHeight / 2) | 0;

8
src/vs/editor/browser/viewParts/overviewRuler/overviewRuler.ts
View File

@@ -6,10 +6,10 @@
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { IOverviewRuler } from 'vs/editor/browser/editorBrowser';
import { OverviewRulerPosition, EditorOption } from 'vs/editor/common/config/editorOptions';
import { ColorZone, OverviewRulerZone, OverviewZoneManager } from 'vs/editor/common/view/overviewZoneManager';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
import { ColorZone, OverviewRulerZone, OverviewZoneManager } from 'vs/editor/common/viewModel/overviewZoneManager';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
export class OverviewRuler extends ViewEventHandler implements IOverviewRuler {

10
src/vs/editor/browser/viewParts/rulers/rulers.ts
View File

@@ -6,10 +6,10 @@
import 'vs/css!./rulers';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { editorRuler } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { editorRuler } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { EditorOption, IRulerOption } from 'vs/editor/common/config/editorOptions';
@@ -64,7 +64,7 @@ export class Rulers extends ViewPart {
}
if (currentCount < desiredCount) {
const { tabSize } = this._context.model.getTextModelOptions();
const { tabSize } = this._context.viewModel.model.getOptions();
const rulerWidth = tabSize;
let addCount = desiredCount - currentCount;
while (addCount > 0) {

6
src/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.ts
View File

@@ -6,9 +6,9 @@
import 'vs/css!./scrollDecoration';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { scrollbarShadow } from 'vs/platform/theme/common/colorRegistry';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { EditorOption } from 'vs/editor/common/config/editorOptions';

5
src/vs/editor/browser/viewParts/selections/selections.css
View File

@@ -20,3 +20,8 @@
.monaco-editor.hc-black .bottom-left-radius { border-bottom-left-radius: 0; }
.monaco-editor.hc-black .top-right-radius { border-top-right-radius: 0; }
.monaco-editor.hc-black .bottom-right-radius { border-bottom-right-radius: 0; }
.monaco-editor.hc-light .top-left-radius { border-top-left-radius: 0; }
.monaco-editor.hc-light .bottom-left-radius { border-bottom-left-radius: 0; }
.monaco-editor.hc-light .top-right-radius { border-top-right-radius: 0; }
.monaco-editor.hc-light .bottom-right-radius { border-bottom-right-radius: 0; }

6
src/vs/editor/browser/viewParts/selections/selections.ts
View File

@@ -6,9 +6,9 @@
import 'vs/css!./selections';
import { DynamicViewOverlay } from 'vs/editor/browser/view/dynamicViewOverlay';
import { Range } from 'vs/editor/common/core/range';
import { HorizontalRange, LineVisibleRanges, RenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { HorizontalRange, LineVisibleRanges, RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { editorInactiveSelection, editorSelectionBackground, editorSelectionForeground } from 'vs/platform/theme/common/colorRegistry';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { EditorOption } from 'vs/editor/common/config/editorOptions';

44
src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts
View File

@@ -6,13 +6,13 @@
import * as dom from 'vs/base/browser/dom';
import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
import * as strings from 'vs/base/common/strings';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { TextEditorCursorStyle, EditorOption } from 'vs/editor/common/config/editorOptions';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'vs/base/browser/ui/mouseCursor/mouseCursor';
export interface IViewCursorRenderData {
@@ -68,7 +68,7 @@ export class ViewCursor {
this._domNode.setHeight(this._lineHeight);
this._domNode.setTop(0);
this._domNode.setLeft(0);
Configuration.applyFontInfo(this._domNode, fontInfo);
applyFontInfo(this._domNode, fontInfo);
this._domNode.setDisplay('none');
this._position = new Position(1, 1);
@@ -107,7 +107,7 @@ export class ViewCursor {
this._lineHeight = options.get(EditorOption.lineHeight);
this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
this._lineCursorWidth = Math.min(options.get(EditorOption.cursorWidth), this._typicalHalfwidthCharacterWidth);
Configuration.applyFontInfo(this._domNode, fontInfo);
applyFontInfo(this._domNode, fontInfo);
return true;
}
@@ -117,11 +117,23 @@ export class ViewCursor {
return true;
}
/**
* If `this._position` is inside a grapheme, returns the position where the grapheme starts.
* Also returns the next grapheme.
*/
private _getGraphemeAwarePosition(): [Position, string] {
const { lineNumber, column } = this._position;
const lineContent = this._context.viewModel.getLineContent(lineNumber);
const [startOffset, endOffset] = strings.getCharContainingOffset(lineContent, column - 1);
return [new Position(lineNumber, startOffset + 1), lineContent.substring(startOffset, endOffset)];
}
private _prepareRender(ctx: RenderingContext): ViewCursorRenderData | null {
let textContent = '';
const [position, nextGrapheme] = this._getGraphemeAwarePosition();
if (this._cursorStyle === TextEditorCursorStyle.Line || this._cursorStyle === TextEditorCursorStyle.LineThin) {
const visibleRange = ctx.visibleRangeForPosition(this._position);
const visibleRange = ctx.visibleRangeForPosition(position);
if (!visibleRange || visibleRange.outsideRenderedLine) {
// Outside viewport
return null;
@@ -131,9 +143,7 @@ export class ViewCursor {
if (this._cursorStyle === TextEditorCursorStyle.Line) {
width = dom.computeScreenAwareSize(this._lineCursorWidth > 0 ? this._lineCursorWidth : 2);
if (width > 2) {
const lineContent = this._context.model.getLineContent(this._position.lineNumber);
const nextCharLength = strings.nextCharLength(lineContent, this._position.column - 1);
textContent = lineContent.substr(this._position.column - 1, nextCharLength);
textContent = nextGrapheme;
}
} else {
width = dom.computeScreenAwareSize(1);
@@ -145,13 +155,11 @@ export class ViewCursor {
left -= 1;
}
const top = ctx.getVerticalOffsetForLineNumber(this._position.lineNumber) - ctx.bigNumbersDelta;
const top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
return new ViewCursorRenderData(top, left, width, this._lineHeight, textContent, '');
}
const lineContent = this._context.model.getLineContent(this._position.lineNumber);
const nextCharLength = strings.nextCharLength(lineContent, this._position.column - 1);
const visibleRangeForCharacter = ctx.linesVisibleRangesForRange(new Range(this._position.lineNumber, this._position.column, this._position.lineNumber, this._position.column + nextCharLength), false);
const visibleRangeForCharacter = ctx.linesVisibleRangesForRange(new Range(position.lineNumber, position.column, position.lineNumber, position.column + nextGrapheme.length), false);
if (!visibleRangeForCharacter || visibleRangeForCharacter.length === 0) {
// Outside viewport
return null;
@@ -168,13 +176,13 @@ export class ViewCursor {
let textContentClassName = '';
if (this._cursorStyle === TextEditorCursorStyle.Block) {
const lineData = this._context.model.getViewLineData(this._position.lineNumber);
textContent = lineContent.substr(this._position.column - 1, nextCharLength);
const tokenIndex = lineData.tokens.findTokenIndexAtOffset(this._position.column - 1);
const lineData = this._context.viewModel.getViewLineData(position.lineNumber);
textContent = nextGrapheme;
const tokenIndex = lineData.tokens.findTokenIndexAtOffset(position.column - 1);
textContentClassName = lineData.tokens.getClassName(tokenIndex);
}
let top = ctx.getVerticalOffsetForLineNumber(this._position.lineNumber) - ctx.bigNumbersDelta;
let top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
let height = this._lineHeight;
// Underline might interfere with clicking

15
src/vs/editor/browser/viewParts/viewCursors/viewCursors.ts
View File

@@ -10,11 +10,12 @@ import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { IViewCursorRenderData, ViewCursor } from 'vs/editor/browser/viewParts/viewCursors/viewCursor';
import { TextEditorCursorBlinkingStyle, TextEditorCursorStyle, EditorOption } from 'vs/editor/common/config/editorOptions';
import { Position } from 'vs/editor/common/core/position';
import { editorCursorBackground, editorCursorForeground } from 'vs/editor/common/view/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { editorCursorBackground, editorCursorForeground } from 'vs/editor/common/core/editorColorRegistry';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { isHighContrast } from 'vs/platform/theme/common/theme';
export class ViewCursors extends ViewPart {
@@ -344,7 +345,8 @@ export class ViewCursors extends ViewPart {
}
public render(ctx: RestrictedRenderingContext): void {
let renderData: IViewCursorRenderData[] = [], renderDataLen = 0;
const renderData: IViewCursorRenderData[] = [];
let renderDataLen = 0;
const primaryRenderData = this._primaryCursor.render(ctx);
if (primaryRenderData) {
@@ -373,8 +375,9 @@ registerThemingParticipant((theme, collector) => {
if (!caretBackground) {
caretBackground = caret.opposite();
}
collector.addRule(`.monaco-editor .inputarea.ime-input { caret-color: ${caret}; }`);
collector.addRule(`.monaco-editor .cursors-layer .cursor { background-color: ${caret}; border-color: ${caret}; color: ${caretBackground}; }`);
if (theme.type === 'hc') {
if (isHighContrast(theme.type)) {
collector.addRule(`.monaco-editor .cursors-layer.has-selection .cursor { border-left: 1px solid ${caretBackground}; border-right: 1px solid ${caretBackground}; }`);
}
}

33
src/vs/editor/browser/viewParts/viewZones/viewZones.ts
View File

@@ -8,12 +8,11 @@ import { onUnexpectedError } from 'vs/base/common/errors';
import { IViewZone, IViewZoneChangeAccessor } from 'vs/editor/browser/editorBrowser';
import { ViewPart } from 'vs/editor/browser/view/viewPart';
import { Position } from 'vs/editor/common/core/position';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
import { ViewContext } from 'vs/editor/common/view/viewContext';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { IViewWhitespaceViewportData } from 'vs/editor/common/viewModel/viewModel';
import { RenderingContext, RestrictedRenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { IEditorWhitespace, IViewWhitespaceViewportData, IWhitespaceChangeAccessor } from 'vs/editor/common/viewModel';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { IWhitespaceChangeAccessor, IEditorWhitespace } from 'vs/editor/common/viewLayout/linesLayout';
export interface IMyViewZone {
whitespaceId: string;
@@ -35,7 +34,7 @@ const invalidFunc = () => { throw new Error(`Invalid change accessor`); };
export class ViewZones extends ViewPart {
private _zones: { [id: string]: IMyViewZone; };
private _zones: { [id: string]: IMyViewZone };
private _lineHeight: number;
private _contentWidth: number;
private _contentLeft: number;
@@ -82,7 +81,7 @@ export class ViewZones extends ViewPart {
oldWhitespaces.set(whitespace.id, whitespace);
}
let hadAChange = false;
this._context.model.changeWhitespace((whitespaceAccessor: IWhitespaceChangeAccessor) => {
this._context.viewModel.changeWhitespace((whitespaceAccessor: IWhitespaceChangeAccessor) => {
const keys = Object.keys(this._zones);
for (let i = 0, len = keys.length; i < len; i++) {
const id = keys[i];
@@ -158,37 +157,37 @@ export class ViewZones extends ViewPart {
let zoneAfterModelPosition: Position;
if (typeof zone.afterColumn !== 'undefined') {
zoneAfterModelPosition = this._context.model.validateModelPosition({
zoneAfterModelPosition = this._context.viewModel.model.validatePosition({
lineNumber: zone.afterLineNumber,
column: zone.afterColumn
});
} else {
const validAfterLineNumber = this._context.model.validateModelPosition({
const validAfterLineNumber = this._context.viewModel.model.validatePosition({
lineNumber: zone.afterLineNumber,
column: 1
}).lineNumber;
zoneAfterModelPosition = new Position(
validAfterLineNumber,
this._context.model.getModelLineMaxColumn(validAfterLineNumber)
this._context.viewModel.model.getLineMaxColumn(validAfterLineNumber)
);
}
let zoneBeforeModelPosition: Position;
if (zoneAfterModelPosition.column === this._context.model.getModelLineMaxColumn(zoneAfterModelPosition.lineNumber)) {
zoneBeforeModelPosition = this._context.model.validateModelPosition({
if (zoneAfterModelPosition.column === this._context.viewModel.model.getLineMaxColumn(zoneAfterModelPosition.lineNumber)) {
zoneBeforeModelPosition = this._context.viewModel.model.validatePosition({
lineNumber: zoneAfterModelPosition.lineNumber + 1,
column: 1
});
} else {
zoneBeforeModelPosition = this._context.model.validateModelPosition({
zoneBeforeModelPosition = this._context.viewModel.model.validatePosition({
lineNumber: zoneAfterModelPosition.lineNumber,
column: zoneAfterModelPosition.column + 1
});
}
const viewPosition = this._context.model.coordinatesConverter.convertModelPositionToViewPosition(zoneAfterModelPosition);
const isVisible = this._context.model.coordinatesConverter.modelPositionIsVisible(zoneBeforeModelPosition);
const viewPosition = this._context.viewModel.coordinatesConverter.convertModelPositionToViewPosition(zoneAfterModelPosition, zone.afterColumnAffinity);
const isVisible = this._context.viewModel.coordinatesConverter.modelPositionIsVisible(zoneBeforeModelPosition);
return {
isInHiddenArea: !isVisible,
afterViewLineNumber: viewPosition.lineNumber,
@@ -200,7 +199,7 @@ export class ViewZones extends ViewPart {
public changeViewZones(callback: (changeAccessor: IViewZoneChangeAccessor) => any): boolean {
let zonesHaveChanged = false;
this._context.model.changeWhitespace((whitespaceAccessor: IWhitespaceChangeAccessor) => {
this._context.viewModel.changeWhitespace((whitespaceAccessor: IWhitespaceChangeAccessor) => {
const changeAccessor: IViewZoneChangeAccessor = {
addZone: (zone: IViewZone): string => {
@@ -360,7 +359,7 @@ export class ViewZones extends ViewPart {
public render(ctx: RestrictedRenderingContext): void {
const visibleWhitespaces = ctx.viewportData.whitespaceViewportData;
const visibleZones: { [id: string]: IViewWhitespaceViewportData; } = {};
const visibleZones: { [id: string]: IViewWhitespaceViewportData } = {};
let hasVisibleZone = false;
for (const visibleWhitespace of visibleWhitespaces) {

387
src/vs/editor/browser/widget/codeEditorWidget.ts
View File

@@ -9,39 +9,38 @@ import 'vs/css!./media/editor';
import * as nls from 'vs/nls';
import * as dom from 'vs/base/browser/dom';
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { IMouseEvent, IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
import { Color } from 'vs/base/common/color';
import { onUnexpectedError } from 'vs/base/common/errors';
import { Emitter, Event } from 'vs/base/common/event';
import { Emitter, EmitterOptions, Event, EventDeliveryQueue } from 'vs/base/common/event';
import { hash } from 'vs/base/common/hash';
import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
import { Schemas } from 'vs/base/common/network';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { EditorConfiguration, IEditorConstructionOptions } from 'vs/editor/browser/config/editorConfiguration';
import * as editorBrowser from 'vs/editor/browser/editorBrowser';
import { EditorExtensionsRegistry, IEditorContributionDescription } from 'vs/editor/browser/editorExtensions';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { ICommandDelegate } from 'vs/editor/browser/view/viewController';
import { IContentWidgetData, IOverlayWidgetData, View } from 'vs/editor/browser/view/viewImpl';
import { IContentWidgetData, IOverlayWidgetData, View } from 'vs/editor/browser/view';
import { ViewUserInputEvents } from 'vs/editor/browser/view/viewUserInputEvents';
import { ConfigurationChangedEvent, EditorLayoutInfo, IEditorOptions, EditorOption, IComputedEditorOptions, FindComputedEditorOptionValueById, filterValidationDecorations } from 'vs/editor/common/config/editorOptions';
import { CursorsController } from 'vs/editor/common/controller/cursor';
import { CursorColumns } from 'vs/editor/common/controller/cursorCommon';
import { CursorChangeReason, ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
import { CursorsController } from 'vs/editor/common/cursor/cursor';
import { CursorColumns } from 'vs/editor/common/core/cursorColumns';
import { CursorChangeReason, ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/cursorEvents';
import { IPosition, Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import { ISelection, Selection } from 'vs/editor/common/core/selection';
import { InternalEditorAction } from 'vs/editor/common/editorAction';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
import { EndOfLinePreference, IIdentifiedSingleEditOperation, IModelDecoration, IModelDecorationOptions, IModelDecorationsChangeAccessor, IModelDeltaDecoration, ITextModel, ICursorStateComputer, IWordAtPosition } from 'vs/editor/common/model';
import { EndOfLinePreference, IIdentifiedSingleEditOperation, IModelDecoration, IModelDecorationOptions, IModelDecorationsChangeAccessor, IModelDeltaDecoration, ITextModel, ICursorStateComputer } from 'vs/editor/common/model';
import { IWordAtPosition } from 'vs/editor/common/core/wordHelper';
import { ClassName } from 'vs/editor/common/model/intervalTree';
import { ModelDecorationOptions } from 'vs/editor/common/model/textModel';
import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent } from 'vs/editor/common/model/textModelEvents';
import * as modes from 'vs/editor/common/modes';
import { editorUnnecessaryCodeBorder, editorUnnecessaryCodeOpacity } from 'vs/editor/common/view/editorColorRegistry';
import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent } from 'vs/editor/common/textModelEvents';
import { editorUnnecessaryCodeBorder, editorUnnecessaryCodeOpacity } from 'vs/editor/common/core/editorColorRegistry';
import { editorErrorBorder, editorErrorForeground, editorHintBorder, editorHintForeground, editorInfoBorder, editorInfoForeground, editorWarningBorder, editorWarningForeground, editorForeground, editorErrorBackground, editorInfoBackground, editorWarningBackground } from 'vs/platform/theme/common/colorRegistry';
import { VerticalRevealType } from 'vs/editor/common/view/viewEvents';
import { IEditorWhitespace } from 'vs/editor/common/viewLayout/linesLayout';
import { VerticalRevealType } from 'vs/editor/common/viewEvents';
import { ViewModel } from 'vs/editor/common/viewModel/viewModelImpl';
import { ICommandService } from 'vs/platform/commands/common/commands';
import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
@@ -53,15 +52,20 @@ import { IAccessibilityService } from 'vs/platform/accessibility/common/accessib
import { withNullAsUndefined } from 'vs/base/common/types';
import { MonospaceLineBreaksComputerFactory } from 'vs/editor/common/viewModel/monospaceLineBreaksComputer';
import { DOMLineBreaksComputerFactory } from 'vs/editor/browser/view/domLineBreaksComputer';
import { WordOperations } from 'vs/editor/common/controller/cursorWordOperations';
import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
import { OutgoingViewModelEventKind } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
import { WordOperations } from 'vs/editor/common/cursor/cursorWordOperations';
import { IEditorWhitespace, IViewModel } from 'vs/editor/common/viewModel';
import { OutgoingViewModelEventKind } from 'vs/editor/common/viewModelEventDispatcher';
import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { IEditorConfiguration } from 'vs/editor/common/config/editorConfiguration';
import { IDimension } from 'vs/editor/common/core/dimension';
import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
let EDITOR_ID = 0;
export interface ICodeEditorWidgetOptions {
/**
* Is this a simple widget (not a real code editor) ?
* Is this a simple widget (not a real code editor)?
* Defaults to false.
*/
isSimpleWidget?: boolean;
@@ -106,122 +110,139 @@ class ModelData {
export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeEditor {
private static readonly dropIntoEditorDecorationOptions = ModelDecorationOptions.register({
description: 'workbench-dnd-target',
className: 'dnd-target'
});
//#region Eventing
private readonly _deliveryQueue = new EventDeliveryQueue();
private readonly _onDidDispose: Emitter<void> = this._register(new Emitter<void>());
public readonly onDidDispose: Event<void> = this._onDidDispose.event;
private readonly _onDidChangeModelContent: Emitter<IModelContentChangedEvent> = this._register(new Emitter<IModelContentChangedEvent>());
private readonly _onDidChangeModelContent: Emitter<IModelContentChangedEvent> = this._register(new Emitter<IModelContentChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelContent: Event<IModelContentChangedEvent> = this._onDidChangeModelContent.event;
private readonly _onDidChangeModelLanguage: Emitter<IModelLanguageChangedEvent> = this._register(new Emitter<IModelLanguageChangedEvent>());
private readonly _onDidChangeModelLanguage: Emitter<IModelLanguageChangedEvent> = this._register(new Emitter<IModelLanguageChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelLanguage: Event<IModelLanguageChangedEvent> = this._onDidChangeModelLanguage.event;
private readonly _onDidChangeModelLanguageConfiguration: Emitter<IModelLanguageConfigurationChangedEvent> = this._register(new Emitter<IModelLanguageConfigurationChangedEvent>());
private readonly _onDidChangeModelLanguageConfiguration: Emitter<IModelLanguageConfigurationChangedEvent> = this._register(new Emitter<IModelLanguageConfigurationChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelLanguageConfiguration: Event<IModelLanguageConfigurationChangedEvent> = this._onDidChangeModelLanguageConfiguration.event;
private readonly _onDidChangeModelOptions: Emitter<IModelOptionsChangedEvent> = this._register(new Emitter<IModelOptionsChangedEvent>());
private readonly _onDidChangeModelOptions: Emitter<IModelOptionsChangedEvent> = this._register(new Emitter<IModelOptionsChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelOptions: Event<IModelOptionsChangedEvent> = this._onDidChangeModelOptions.event;
private readonly _onDidChangeModelDecorations: Emitter<IModelDecorationsChangedEvent> = this._register(new Emitter<IModelDecorationsChangedEvent>());
private readonly _onDidChangeModelDecorations: Emitter<IModelDecorationsChangedEvent> = this._register(new Emitter<IModelDecorationsChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelDecorations: Event<IModelDecorationsChangedEvent> = this._onDidChangeModelDecorations.event;
private readonly _onDidChangeConfiguration: Emitter<ConfigurationChangedEvent> = this._register(new Emitter<ConfigurationChangedEvent>());
private readonly _onDidChangeModelTokens: Emitter<IModelTokensChangedEvent> = this._register(new Emitter<IModelTokensChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModelTokens: Event<IModelTokensChangedEvent> = this._onDidChangeModelTokens.event;
private readonly _onDidChangeConfiguration: Emitter<ConfigurationChangedEvent> = this._register(new Emitter<ConfigurationChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeConfiguration: Event<ConfigurationChangedEvent> = this._onDidChangeConfiguration.event;
protected readonly _onDidChangeModel: Emitter<editorCommon.IModelChangedEvent> = this._register(new Emitter<editorCommon.IModelChangedEvent>());
protected readonly _onDidChangeModel: Emitter<editorCommon.IModelChangedEvent> = this._register(new Emitter<editorCommon.IModelChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeModel: Event<editorCommon.IModelChangedEvent> = this._onDidChangeModel.event;
private readonly _onDidChangeCursorPosition: Emitter<ICursorPositionChangedEvent> = this._register(new Emitter<ICursorPositionChangedEvent>());
private readonly _onDidChangeCursorPosition: Emitter<ICursorPositionChangedEvent> = this._register(new Emitter<ICursorPositionChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeCursorPosition: Event<ICursorPositionChangedEvent> = this._onDidChangeCursorPosition.event;
private readonly _onDidChangeCursorSelection: Emitter<ICursorSelectionChangedEvent> = this._register(new Emitter<ICursorSelectionChangedEvent>());
private readonly _onDidChangeCursorSelection: Emitter<ICursorSelectionChangedEvent> = this._register(new Emitter<ICursorSelectionChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeCursorSelection: Event<ICursorSelectionChangedEvent> = this._onDidChangeCursorSelection.event;
private readonly _onDidAttemptReadOnlyEdit: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidAttemptReadOnlyEdit: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidAttemptReadOnlyEdit: Event<void> = this._onDidAttemptReadOnlyEdit.event;
private readonly _onDidLayoutChange: Emitter<EditorLayoutInfo> = this._register(new Emitter<EditorLayoutInfo>());
private readonly _onDidLayoutChange: Emitter<EditorLayoutInfo> = this._register(new Emitter<EditorLayoutInfo>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidLayoutChange: Event<EditorLayoutInfo> = this._onDidLayoutChange.event;
private readonly _editorTextFocus: BooleanEventEmitter = this._register(new BooleanEventEmitter());
private readonly _editorTextFocus: BooleanEventEmitter = this._register(new BooleanEventEmitter({ deliveryQueue: this._deliveryQueue }));
public readonly onDidFocusEditorText: Event<void> = this._editorTextFocus.onDidChangeToTrue;
public readonly onDidBlurEditorText: Event<void> = this._editorTextFocus.onDidChangeToFalse;
private readonly _editorWidgetFocus: BooleanEventEmitter = this._register(new BooleanEventEmitter());
private readonly _editorWidgetFocus: BooleanEventEmitter = this._register(new BooleanEventEmitter({ deliveryQueue: this._deliveryQueue }));
public readonly onDidFocusEditorWidget: Event<void> = this._editorWidgetFocus.onDidChangeToTrue;
public readonly onDidBlurEditorWidget: Event<void> = this._editorWidgetFocus.onDidChangeToFalse;
private readonly _onWillType: Emitter<string> = this._register(new Emitter<string>());
private readonly _onWillType: Emitter<string> = this._register(new Emitter<string>({ deliveryQueue: this._deliveryQueue }));
public readonly onWillType = this._onWillType.event;
private readonly _onDidType: Emitter<string> = this._register(new Emitter<string>());
private readonly _onDidType: Emitter<string> = this._register(new Emitter<string>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidType = this._onDidType.event;
private readonly _onDidCompositionStart: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidCompositionStart: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidCompositionStart = this._onDidCompositionStart.event;
private readonly _onDidCompositionEnd: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidCompositionEnd: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidCompositionEnd = this._onDidCompositionEnd.event;
private readonly _onDidPaste: Emitter<editorBrowser.IPasteEvent> = this._register(new Emitter<editorBrowser.IPasteEvent>());
private readonly _onDidPaste: Emitter<editorBrowser.IPasteEvent> = this._register(new Emitter<editorBrowser.IPasteEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidPaste = this._onDidPaste.event;
private readonly _onMouseUp: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>());
private readonly _onMouseUp: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseUp: Event<editorBrowser.IEditorMouseEvent> = this._onMouseUp.event;
private readonly _onMouseDown: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>());
private readonly _onMouseDown: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseDown: Event<editorBrowser.IEditorMouseEvent> = this._onMouseDown.event;
private readonly _onMouseDrag: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>());
private readonly _onMouseDrag: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseDrag: Event<editorBrowser.IEditorMouseEvent> = this._onMouseDrag.event;
private readonly _onMouseDrop: Emitter<editorBrowser.IPartialEditorMouseEvent> = this._register(new Emitter<editorBrowser.IPartialEditorMouseEvent>());
private readonly _onMouseDrop: Emitter<editorBrowser.IPartialEditorMouseEvent> = this._register(new Emitter<editorBrowser.IPartialEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseDrop: Event<editorBrowser.IPartialEditorMouseEvent> = this._onMouseDrop.event;
private readonly _onMouseDropCanceled: Emitter<void> = this._register(new Emitter<void>());
private readonly _onMouseDropCanceled: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseDropCanceled: Event<void> = this._onMouseDropCanceled.event;
private readonly _onContextMenu: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>());
private readonly _onDropIntoEditor = this._register(new Emitter<{ readonly position: IPosition; readonly event: DragEvent }>({ deliveryQueue: this._deliveryQueue }));
public readonly onDropIntoEditor = this._onDropIntoEditor.event;
private readonly _onContextMenu: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onContextMenu: Event<editorBrowser.IEditorMouseEvent> = this._onContextMenu.event;
private readonly _onMouseMove: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>());
private readonly _onMouseMove: Emitter<editorBrowser.IEditorMouseEvent> = this._register(new Emitter<editorBrowser.IEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseMove: Event<editorBrowser.IEditorMouseEvent> = this._onMouseMove.event;
private readonly _onMouseLeave: Emitter<editorBrowser.IPartialEditorMouseEvent> = this._register(new Emitter<editorBrowser.IPartialEditorMouseEvent>());
private readonly _onMouseLeave: Emitter<editorBrowser.IPartialEditorMouseEvent> = this._register(new Emitter<editorBrowser.IPartialEditorMouseEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseLeave: Event<editorBrowser.IPartialEditorMouseEvent> = this._onMouseLeave.event;
private readonly _onMouseWheel: Emitter<IMouseWheelEvent> = this._register(new Emitter<IMouseWheelEvent>());
private readonly _onMouseWheel: Emitter<IMouseWheelEvent> = this._register(new Emitter<IMouseWheelEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onMouseWheel: Event<IMouseWheelEvent> = this._onMouseWheel.event;
private readonly _onKeyUp: Emitter<IKeyboardEvent> = this._register(new Emitter<IKeyboardEvent>());
private readonly _onKeyUp: Emitter<IKeyboardEvent> = this._register(new Emitter<IKeyboardEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onKeyUp: Event<IKeyboardEvent> = this._onKeyUp.event;
private readonly _onKeyDown: Emitter<IKeyboardEvent> = this._register(new Emitter<IKeyboardEvent>());
private readonly _onKeyDown: Emitter<IKeyboardEvent> = this._register(new Emitter<IKeyboardEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onKeyDown: Event<IKeyboardEvent> = this._onKeyDown.event;
private readonly _onDidContentSizeChange: Emitter<editorCommon.IContentSizeChangedEvent> = this._register(new Emitter<editorCommon.IContentSizeChangedEvent>());
private readonly _onDidContentSizeChange: Emitter<editorCommon.IContentSizeChangedEvent> = this._register(new Emitter<editorCommon.IContentSizeChangedEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidContentSizeChange: Event<editorCommon.IContentSizeChangedEvent> = this._onDidContentSizeChange.event;
private readonly _onDidScrollChange: Emitter<editorCommon.IScrollEvent> = this._register(new Emitter<editorCommon.IScrollEvent>());
private readonly _onDidScrollChange: Emitter<editorCommon.IScrollEvent> = this._register(new Emitter<editorCommon.IScrollEvent>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidScrollChange: Event<editorCommon.IScrollEvent> = this._onDidScrollChange.event;
private readonly _onDidChangeViewZones: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidChangeViewZones: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeViewZones: Event<void> = this._onDidChangeViewZones.event;
private readonly _onDidChangeHiddenAreas: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidChangeHiddenAreas: Emitter<void> = this._register(new Emitter<void>({ deliveryQueue: this._deliveryQueue }));
public readonly onDidChangeHiddenAreas: Event<void> = this._onDidChangeHiddenAreas.event;
//#endregion
public readonly isSimpleWidget: boolean;
public get isSimpleWidget(): boolean {
return this._configuration.isSimpleWidget;
}
private readonly _telemetryData?: object;
private readonly _domElement: HTMLElement;
private readonly _overflowWidgetsDomNode: HTMLElement | undefined;
private readonly _id: number;
private readonly _configuration: editorCommon.IConfiguration;
private readonly _configuration: IEditorConfiguration;
protected _contributions: { [key: string]: editorCommon.IEditorContribution; };
protected _actions: { [key: string]: editorCommon.IEditorAction; };
protected _contributions: { [key: string]: editorCommon.IEditorContribution };
protected _actions: { [key: string]: editorCommon.IEditorAction };
// --- Members logically associated to a model
protected _modelData: ModelData | null;
@@ -235,8 +256,8 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
private readonly _focusTracker: CodeEditorWidgetFocusTracker;
private _contentWidgets: { [key: string]: IContentWidgetData; };
private _overlayWidgets: { [key: string]: IOverlayWidgetData; };
private _contentWidgets: { [key: string]: IContentWidgetData };
private _overlayWidgets: { [key: string]: IOverlayWidgetData };
/**
* map from "parent" decoration type to live decoration ids.
@@ -244,9 +265,13 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
private _decorationTypeKeysToIds: { [decorationTypeKey: string]: string[] };
private _decorationTypeSubtypes: { [decorationTypeKey: string]: { [subtype: string]: boolean } };
private _bannerDomNode: HTMLElement | null = null;
private _dropIntoEditorDecorationIds: string[] = [];
constructor(
domElement: HTMLElement,
_options: Readonly<editorBrowser.IEditorConstructionOptions>,
_options: Readonly<IEditorConstructionOptions>,
codeEditorWidgetOptions: ICodeEditorWidgetOptions,
@IInstantiationService instantiationService: IInstantiationService,
@ICodeEditorService codeEditorService: ICodeEditorService,
@@ -254,7 +279,9 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
@IContextKeyService contextKeyService: IContextKeyService,
@IThemeService themeService: IThemeService,
@INotificationService notificationService: INotificationService,
@IAccessibilityService accessibilityService: IAccessibilityService
@IAccessibilityService accessibilityService: IAccessibilityService,
@ILanguageConfigurationService private readonly languageConfigurationService: ILanguageConfigurationService,
@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
) {
super();
@@ -266,10 +293,9 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
this._id = (++EDITOR_ID);
this._decorationTypeKeysToIds = {};
this._decorationTypeSubtypes = {};
this.isSimpleWidget = codeEditorWidgetOptions.isSimpleWidget || false;
this._telemetryData = codeEditorWidgetOptions.telemetryData;
this._configuration = this._register(this._createConfiguration(options, accessibilityService));
this._configuration = this._register(this._createConfiguration(codeEditorWidgetOptions.isSimpleWidget || false, options, accessibilityService));
this._register(this._configuration.onDidChange((e) => {
this._onDidChangeConfiguration.fire(e);
@@ -286,7 +312,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
this._commandService = commandService;
this._themeService = themeService;
this._register(new EditorContextKeysManager(this, this._contextKeyService));
this._register(new EditorModeContext(this, this._contextKeyService));
this._register(new EditorModeContext(this, this._contextKeyService, languageFeaturesService));
this._instantiationService = instantiationService.createChild(new ServiceCollection([IContextKeyService, this._contextKeyService]));
@@ -342,11 +368,41 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
this._actions[internalAction.id] = internalAction;
});
if (_options.enableDropIntoEditor) {
this._register(new dom.DragAndDropObserver(this._domElement, {
onDragEnter: () => undefined,
onDragOver: e => {
const target = this.getTargetAtClientPoint(e.clientX, e.clientY);
if (target?.position) {
this.showDropIndicatorAt(target.position);
}
},
onDrop: async e => {
this.removeDropIndicator();
if (!e.dataTransfer) {
return;
}
const target = this.getTargetAtClientPoint(e.clientX, e.clientY);
if (target?.position) {
this._onDropIntoEditor.fire({ position: target.position, event: e });
}
},
onDragLeave: () => {
this.removeDropIndicator();
},
onDragEnd: () => {
this.removeDropIndicator();
},
}));
}
this._codeEditorService.addCodeEditor(this);
}
protected _createConfiguration(options: Readonly<editorBrowser.IEditorConstructionOptions>, accessibilityService: IAccessibilityService): editorCommon.IConfiguration {
return new Configuration(this.isSimpleWidget, options, this._domElement, accessibilityService);
protected _createConfiguration(isSimpleWidget: boolean, options: Readonly<IEditorConstructionOptions>, accessibilityService: IAccessibilityService): EditorConfiguration {
return new EditorConfiguration(isSimpleWidget, options, this._domElement, accessibilityService);
}
public getId(): string {
@@ -384,8 +440,8 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._instantiationService.invokeFunction(fn);
}
public updateOptions(newOptions: Readonly<IEditorOptions>): void {
this._configuration.updateOptions(newOptions);
public updateOptions(newOptions: Readonly<IEditorOptions> | undefined): void {
this._configuration.updateOptions(newOptions || {});
}
public getOptions(): IComputedEditorOptions {
@@ -411,7 +467,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return WordOperations.getWordAtPosition(this._modelData.model, this._configuration.options.get(EditorOption.wordSeparators), position);
}
public getValue(options: { preserveBOM: boolean; lineEnding: string; } | null = null): string {
public getValue(options: { preserveBOM: boolean; lineEnding: string } | null = null): string {
if (!this._modelData) {
return '';
}
@@ -559,14 +615,14 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._modelData.viewModel.getPosition();
}
public setPosition(position: IPosition): void {
public setPosition(position: IPosition, source: string = 'api'): void {
if (!this._modelData) {
return;
}
if (!Position.isIPosition(position)) {
throw new Error('Invalid arguments');
}
this._modelData.viewModel.setSelections('api', [{
this._modelData.viewModel.setSelections(source, [{
selectionStartLineNumber: position.lineNumber,
selectionStartColumn: position.column,
positionLineNumber: position.lineNumber,
@@ -679,11 +735,11 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._modelData.viewModel.getSelections();
}
public setSelection(range: IRange): void;
public setSelection(editorRange: Range): void;
public setSelection(selection: ISelection): void;
public setSelection(editorSelection: Selection): void;
public setSelection(something: any): void {
public setSelection(range: IRange, source?: string): void;
public setSelection(editorRange: Range, source?: string): void;
public setSelection(selection: ISelection, source?: string): void;
public setSelection(editorSelection: Selection, source?: string): void;
public setSelection(something: any, source: string = 'api'): void {
const isSelection = Selection.isISelection(something);
const isRange = Range.isIRange(something);
@@ -692,7 +748,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
}
if (isSelection) {
this._setSelectionImpl(<ISelection>something);
this._setSelectionImpl(<ISelection>something, source);
} else if (isRange) {
// act as if it was an IRange
const selection: ISelection = {
@@ -701,16 +757,16 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
positionLineNumber: something.endLineNumber,
positionColumn: something.endColumn
};
this._setSelectionImpl(selection);
this._setSelectionImpl(selection, source);
}
}
private _setSelectionImpl(sel: ISelection): void {
private _setSelectionImpl(sel: ISelection, source: string): void {
if (!this._modelData) {
return;
}
const selection = new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);
this._modelData.viewModel.setSelections('api', [selection]);
this._modelData.viewModel.setSelections(source, [selection]);
}
public revealLines(startLineNumber: number, endLineNumber: number, scrollType: editorCommon.ScrollType = editorCommon.ScrollType.Smooth): void {
@@ -891,7 +947,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
if (typeof newScrollLeft !== 'number') {
throw new Error('Invalid arguments');
}
this._modelData.viewModel.setScrollPosition({
this._modelData.viewModel.viewLayout.setScrollPosition({
scrollLeft: newScrollLeft
}, scrollType);
}
@@ -902,7 +958,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
if (typeof newScrollTop !== 'number') {
throw new Error('Invalid arguments');
}
this._modelData.viewModel.setScrollPosition({
this._modelData.viewModel.viewLayout.setScrollPosition({
scrollTop: newScrollTop
}, scrollType);
}
@@ -910,7 +966,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
if (!this._modelData) {
return;
}
this._modelData.viewModel.setScrollPosition(position, scrollType);
this._modelData.viewModel.viewLayout.setScrollPosition(position, scrollType);
}
public saveViewState(): editorCommon.ICodeEditorViewState | null {
@@ -944,7 +1000,9 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
if (codeEditorState && codeEditorState.cursorState && codeEditorState.viewState) {
const cursorState = <any>codeEditorState.cursorState;
if (Array.isArray(cursorState)) {
this._modelData.viewModel.restoreCursorState(<editorCommon.ICursorState[]>cursorState);
if (cursorState.length > 0) {
this._modelData.viewModel.restoreCursorState(<editorCommon.ICursorState[]>cursorState);
}
} else {
// Backwards compatibility
this._modelData.viewModel.restoreCursorState([<editorCommon.ICursorState>cursorState]);
@@ -974,7 +1032,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
this._focusTracker.refreshState();
}
public getContribution<T extends editorCommon.IEditorContribution>(id: string): T {
public getContribution<T extends editorCommon.IEditorContribution>(id: string): T | null {
return <T>(this._contributions[id] || null);
}
@@ -1212,6 +1270,13 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._modelData.model.getLineDecorations(lineNumber, this._id, filterValidationDecorations(this._configuration.options));
}
public getDecorationsInRange(range: Range): IModelDecoration[] | null {
if (!this._modelData) {
return null;
}
return this._modelData.model.getDecorationsInRange(range, this._id, filterValidationDecorations(this._configuration.options));
}
public deltaDecorations(oldDecorations: string[], newDecorations: IModelDeltaDecoration[]): string[] {
if (!this._modelData) {
return [];
@@ -1324,15 +1389,15 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._modelData.view.domNode.domNode;
}
public delegateVerticalScrollbarMouseDown(browserEvent: IMouseEvent): void {
public delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void {
if (!this._modelData || !this._modelData.hasRealView) {
return;
}
this._modelData.view.delegateVerticalScrollbarMouseDown(browserEvent);
this._modelData.view.delegateVerticalScrollbarPointerDown(browserEvent);
}
public layout(dimension?: editorCommon.IDimension): void {
this._configuration.observeReferenceElement(dimension);
public layout(dimension?: IDimension): void {
this._configuration.observeContainer(dimension);
this.render();
}
@@ -1446,7 +1511,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._modelData.view.getTargetAtClientPoint(clientX, clientY);
}
public getScrolledVisiblePosition(rawPosition: IPosition): { top: number; left: number; height: number; } | null {
public getScrolledVisiblePosition(rawPosition: IPosition): { top: number; left: number; height: number } | null {
if (!this._modelData || !this._modelData.hasRealView) {
return null;
}
@@ -1487,7 +1552,20 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
}
public applyFontInfo(target: HTMLElement): void {
Configuration.applyFontInfoSlow(target, this._configuration.options.get(EditorOption.fontInfo));
applyFontInfo(target, this._configuration.options.get(EditorOption.fontInfo));
}
public setBanner(domNode: HTMLElement | null, domNodeHeight: number): void {
if (this._bannerDomNode && this._domElement.contains(this._bannerDomNode)) {
this._domElement.removeChild(this._bannerDomNode);
}
this._bannerDomNode = domNode;
this._configuration.setReservedHeight(domNode ? domNodeHeight : 0);
if (this._bannerDomNode) {
this._domElement.prepend(this._bannerDomNode);
}
}
protected _attachModel(model: ITextModel | null): void {
@@ -1500,7 +1578,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
this._domElement.setAttribute('data-mode-id', model.getLanguageId());
this._configuration.setIsDominatedByLongLines(model.isDominatedByLongLines());
this._configuration.setMaxLineNumber(model.getLineCount());
this._configuration.setModelLineCount(model.getLineCount());
model.onBeforeAttached();
@@ -1510,17 +1588,11 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
model,
DOMLineBreaksComputerFactory.create(),
MonospaceLineBreaksComputerFactory.create(this._configuration.options),
(callback) => dom.scheduleAtNextAnimationFrame(callback)
(callback) => dom.scheduleAtNextAnimationFrame(callback),
this.languageConfigurationService,
this._themeService
);
listenersToRemove.push(model.onDidChangeDecorations((e) => this._onDidChangeModelDecorations.fire(e)));
listenersToRemove.push(model.onDidChangeLanguage((e) => {
this._domElement.setAttribute('data-mode-id', model.getLanguageId());
this._onDidChangeModelLanguage.fire(e);
}));
listenersToRemove.push(model.onDidChangeLanguageConfiguration((e) => this._onDidChangeModelLanguageConfiguration.fire(e)));
listenersToRemove.push(model.onDidChangeContent((e) => this._onDidChangeModelContent.fire(e)));
listenersToRemove.push(model.onDidChangeOptions((e) => this._onDidChangeModelOptions.fire(e)));
// Someone might destroy the model from under the editor, so prevent any exceptions by setting a null model
listenersToRemove.push(model.onWillDispose(() => this.setModel(null)));
@@ -1575,6 +1647,25 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
break;
}
case OutgoingViewModelEventKind.ModelDecorationsChanged:
this._onDidChangeModelDecorations.fire(e.event);
break;
case OutgoingViewModelEventKind.ModelLanguageChanged:
this._domElement.setAttribute('data-mode-id', model.getLanguageId());
this._onDidChangeModelLanguage.fire(e.event);
break;
case OutgoingViewModelEventKind.ModelLanguageConfigurationChanged:
this._onDidChangeModelLanguageConfiguration.fire(e.event);
break;
case OutgoingViewModelEventKind.ModelContentChanged:
this._onDidChangeModelContent.fire(e.event);
break;
case OutgoingViewModelEventKind.ModelOptionsChanged:
this._onDidChangeModelOptions.fire(e.event);
break;
case OutgoingViewModelEventKind.ModelTokensChanged:
this._onDidChangeModelTokens.fire(e.event);
break;
}
}));
@@ -1674,7 +1765,7 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
const view = new View(
commandDelegate,
this._configuration,
this._themeService,
this._themeService.getColorTheme(),
viewModel,
viewUserInputEvents,
this._overflowWidgetsDomNode
@@ -1703,6 +1794,9 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
if (removeDomNode && this._domElement.contains(removeDomNode)) {
this._domElement.removeChild(removeDomNode);
}
if (this._bannerDomNode && this._domElement.contains(this._bannerDomNode)) {
this._domElement.removeChild(this._bannerDomNode);
}
return model;
}
@@ -1719,13 +1813,27 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
return this._codeEditorService.resolveDecorationOptions(typeKey, writable);
}
public getTelemetryData(): { [key: string]: any; } | undefined {
public getTelemetryData(): { [key: string]: any } | undefined {
return this._telemetryData;
}
public hasModel(): this is editorBrowser.IActiveCodeEditor {
return (this._modelData !== null);
}
private showDropIndicatorAt(position: Position): void {
let newDecorations: IModelDeltaDecoration[] = [{
range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),
options: CodeEditorWidget.dropIntoEditorDecorationOptions
}];
this._dropIntoEditorDecorationIds = this.deltaDecorations(this._dropIntoEditorDecorationIds, newDecorations);
this.revealPosition(position, editorCommon.ScrollType.Immediate);
}
private removeDropIndicator(): void {
this._dropIntoEditorDecorationIds = this.deltaDecorations(this._dropIntoEditorDecorationIds, []);
}
}
const enum BooleanEventValue {
@@ -1735,15 +1843,17 @@ const enum BooleanEventValue {
}
export class BooleanEventEmitter extends Disposable {
private readonly _onDidChangeToTrue: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidChangeToTrue: Emitter<void> = this._register(new Emitter<void>(this._emitterOptions));
public readonly onDidChangeToTrue: Event<void> = this._onDidChangeToTrue.event;
private readonly _onDidChangeToFalse: Emitter<void> = this._register(new Emitter<void>());
private readonly _onDidChangeToFalse: Emitter<void> = this._register(new Emitter<void>(this._emitterOptions));
public readonly onDidChangeToFalse: Event<void> = this._onDidChangeToFalse.event;
private _value: BooleanEventValue;
constructor() {
constructor(
private readonly _emitterOptions: EmitterOptions
) {
super();
this._value = BooleanEventValue.NotSet;
}
@@ -1876,7 +1986,8 @@ export class EditorModeContext extends Disposable {
constructor(
private readonly _editor: CodeEditorWidget,
private readonly _contextKeyService: IContextKeyService
private readonly _contextKeyService: IContextKeyService,
private readonly _languageFeaturesService: ILanguageFeaturesService,
) {
super();
@@ -1908,22 +2019,22 @@ export class EditorModeContext extends Disposable {
this._register(_editor.onDidChangeModelLanguage(update));
// update when registries change
this._register(modes.CompletionProviderRegistry.onDidChange(update));
this._register(modes.CodeActionProviderRegistry.onDidChange(update));
this._register(modes.CodeLensProviderRegistry.onDidChange(update));
this._register(modes.DefinitionProviderRegistry.onDidChange(update));
this._register(modes.DeclarationProviderRegistry.onDidChange(update));
this._register(modes.ImplementationProviderRegistry.onDidChange(update));
this._register(modes.TypeDefinitionProviderRegistry.onDidChange(update));
this._register(modes.HoverProviderRegistry.onDidChange(update));
this._register(modes.DocumentHighlightProviderRegistry.onDidChange(update));
this._register(modes.DocumentSymbolProviderRegistry.onDidChange(update));
this._register(modes.ReferenceProviderRegistry.onDidChange(update));
this._register(modes.RenameProviderRegistry.onDidChange(update));
this._register(modes.DocumentFormattingEditProviderRegistry.onDidChange(update));
this._register(modes.DocumentRangeFormattingEditProviderRegistry.onDidChange(update));
this._register(modes.SignatureHelpProviderRegistry.onDidChange(update));
this._register(modes.InlayHintsProviderRegistry.onDidChange(update));
this._register(_languageFeaturesService.completionProvider.onDidChange(update));
this._register(_languageFeaturesService.codeActionProvider.onDidChange(update));
this._register(_languageFeaturesService.codeLensProvider.onDidChange(update));
this._register(_languageFeaturesService.definitionProvider.onDidChange(update));
this._register(_languageFeaturesService.declarationProvider.onDidChange(update));
this._register(_languageFeaturesService.implementationProvider.onDidChange(update));
this._register(_languageFeaturesService.typeDefinitionProvider.onDidChange(update));
this._register(_languageFeaturesService.hoverProvider.onDidChange(update));
this._register(_languageFeaturesService.documentHighlightProvider.onDidChange(update));
this._register(_languageFeaturesService.documentSymbolProvider.onDidChange(update));
this._register(_languageFeaturesService.referenceProvider.onDidChange(update));
this._register(_languageFeaturesService.renameProvider.onDidChange(update));
this._register(_languageFeaturesService.documentFormattingEditProvider.onDidChange(update));
this._register(_languageFeaturesService.documentRangeFormattingEditProvider.onDidChange(update));
this._register(_languageFeaturesService.signatureHelpProvider.onDidChange(update));
this._register(_languageFeaturesService.inlayHintsProvider.onDidChange(update));
update();
}
@@ -1962,24 +2073,24 @@ export class EditorModeContext extends Disposable {
}
this._contextKeyService.bufferChangeEvents(() => {
this._langId.set(model.getLanguageId());
this._hasCompletionItemProvider.set(modes.CompletionProviderRegistry.has(model));
this._hasCodeActionsProvider.set(modes.CodeActionProviderRegistry.has(model));
this._hasCodeLensProvider.set(modes.CodeLensProviderRegistry.has(model));
this._hasDefinitionProvider.set(modes.DefinitionProviderRegistry.has(model));
this._hasDeclarationProvider.set(modes.DeclarationProviderRegistry.has(model));
this._hasImplementationProvider.set(modes.ImplementationProviderRegistry.has(model));
this._hasTypeDefinitionProvider.set(modes.TypeDefinitionProviderRegistry.has(model));
this._hasHoverProvider.set(modes.HoverProviderRegistry.has(model));
this._hasDocumentHighlightProvider.set(modes.DocumentHighlightProviderRegistry.has(model));
this._hasDocumentSymbolProvider.set(modes.DocumentSymbolProviderRegistry.has(model));
this._hasReferenceProvider.set(modes.ReferenceProviderRegistry.has(model));
this._hasRenameProvider.set(modes.RenameProviderRegistry.has(model));
this._hasSignatureHelpProvider.set(modes.SignatureHelpProviderRegistry.has(model));
this._hasInlayHintsProvider.set(modes.InlayHintsProviderRegistry.has(model));
this._hasDocumentFormattingProvider.set(modes.DocumentFormattingEditProviderRegistry.has(model) || modes.DocumentRangeFormattingEditProviderRegistry.has(model));
this._hasDocumentSelectionFormattingProvider.set(modes.DocumentRangeFormattingEditProviderRegistry.has(model));
this._hasMultipleDocumentFormattingProvider.set(modes.DocumentFormattingEditProviderRegistry.all(model).length + modes.DocumentRangeFormattingEditProviderRegistry.all(model).length > 1);
this._hasMultipleDocumentSelectionFormattingProvider.set(modes.DocumentRangeFormattingEditProviderRegistry.all(model).length > 1);
this._hasCompletionItemProvider.set(this._languageFeaturesService.completionProvider.has(model));
this._hasCodeActionsProvider.set(this._languageFeaturesService.codeActionProvider.has(model));
this._hasCodeLensProvider.set(this._languageFeaturesService.codeLensProvider.has(model));
this._hasDefinitionProvider.set(this._languageFeaturesService.definitionProvider.has(model));
this._hasDeclarationProvider.set(this._languageFeaturesService.declarationProvider.has(model));
this._hasImplementationProvider.set(this._languageFeaturesService.implementationProvider.has(model));
this._hasTypeDefinitionProvider.set(this._languageFeaturesService.typeDefinitionProvider.has(model));
this._hasHoverProvider.set(this._languageFeaturesService.hoverProvider.has(model));
this._hasDocumentHighlightProvider.set(this._languageFeaturesService.documentHighlightProvider.has(model));
this._hasDocumentSymbolProvider.set(this._languageFeaturesService.documentSymbolProvider.has(model));
this._hasReferenceProvider.set(this._languageFeaturesService.referenceProvider.has(model));
this._hasRenameProvider.set(this._languageFeaturesService.renameProvider.has(model));
this._hasSignatureHelpProvider.set(this._languageFeaturesService.signatureHelpProvider.has(model));
this._hasInlayHintsProvider.set(this._languageFeaturesService.inlayHintsProvider.has(model));
this._hasDocumentFormattingProvider.set(this._languageFeaturesService.documentFormattingEditProvider.has(model) || this._languageFeaturesService.documentRangeFormattingEditProvider.has(model));
this._hasDocumentSelectionFormattingProvider.set(this._languageFeaturesService.documentRangeFormattingEditProvider.has(model));
this._hasMultipleDocumentFormattingProvider.set(this._languageFeaturesService.documentFormattingEditProvider.all(model).length + this._languageFeaturesService.documentRangeFormattingEditProvider.all(model).length > 1);
this._hasMultipleDocumentSelectionFormattingProvider.set(this._languageFeaturesService.documentRangeFormattingEditProvider.all(model).length > 1);
this._isInWalkThrough.set(model.uri.scheme === Schemas.walkThroughSnippet);
});
}

214
src/vs/editor/browser/widget/diffEditorWidget.ts
View File

@@ -13,8 +13,8 @@ import { Color } from 'vs/base/common/color';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import { URI } from 'vs/base/common/uri';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { StableEditorScrollState } from 'vs/editor/browser/core/editorState';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { StableEditorScrollState } from 'vs/editor/browser/stableEditorScroll';
import * as editorBrowser from 'vs/editor/browser/editorBrowser';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { CodeEditorWidget, ICodeEditorWidgetOptions } from 'vs/editor/browser/widget/codeEditorWidget';
@@ -27,17 +27,16 @@ import { IStringBuilder, createStringBuilder } from 'vs/editor/common/core/strin
import * as editorCommon from 'vs/editor/common/editorCommon';
import { IModelDecorationsChangeAccessor, IModelDeltaDecoration, ITextModel } from 'vs/editor/common/model';
import { ModelDecorationOptions } from 'vs/editor/common/model/textModel';
import { IDiffComputationResult, IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
import { OverviewRulerZone } from 'vs/editor/common/view/overviewZoneManager';
import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker';
import { OverviewRulerZone } from 'vs/editor/common/viewModel/overviewZoneManager';
import { LineDecoration } from 'vs/editor/common/viewLayout/lineDecorations';
import { RenderLineInput, renderViewLine } from 'vs/editor/common/viewLayout/viewLineRenderer';
import { IEditorWhitespace } from 'vs/editor/common/viewLayout/linesLayout';
import { ILineBreaksComputer, InlineDecoration, InlineDecorationType, IViewModel, ViewLineRenderingData } from 'vs/editor/common/viewModel/viewModel';
import { IEditorWhitespace, InlineDecoration, InlineDecorationType, IViewModel, ViewLineRenderingData } from 'vs/editor/common/viewModel';
import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
import { INotificationService } from 'vs/platform/notification/common/notification';
import { defaultInsertColor, defaultRemoveColor, diffBorder, diffInserted, diffInsertedOutline, diffRemoved, diffRemovedOutline, scrollbarShadow, scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground, diffDiagonalFill } from 'vs/platform/theme/common/colorRegistry';
import { defaultInsertColor, defaultRemoveColor, diffBorder, diffInserted, diffInsertedOutline, diffRemoved, diffRemovedOutline, scrollbarShadow, scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground, diffDiagonalFill, diffInsertedLineGutter, diffRemovedLineGutter, diffInsertedLine, diffRemovedLine, diffOverviewRulerInserted, diffOverviewRulerRemoved } from 'vs/platform/theme/common/colorRegistry';
import { IColorTheme, IThemeService, getThemeTypeSelector, registerThemingParticipant, ThemeIcon } from 'vs/platform/theme/common/themeService';
import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
import { IDiffLinesChange, InlineDiffMargin } from 'vs/editor/browser/widget/inlineDiffMargin';
@@ -50,9 +49,14 @@ import { ElementSizeObserver } from 'vs/editor/browser/config/elementSizeObserve
import { reverseLineChanges } from 'sql/editor/browser/diffEditorHelper'; // {{SQL CARBON EDIT}}
import { Codicon } from 'vs/base/common/codicons';
import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'vs/base/browser/ui/mouseCursor/mouseCursor';
import { IViewLineTokens } from 'vs/editor/common/core/lineTokens';
import { IViewLineTokens } from 'vs/editor/common/tokens/lineTokens';
import { FontInfo } from 'vs/editor/common/config/fontInfo';
import { registerIcon } from 'vs/platform/theme/common/iconRegistry';
import { ILineBreaksComputer } from 'vs/editor/common/modelLineProjectionData';
import { IChange, IDiffComputationResult, ILineChange } from 'vs/editor/common/diff/diffComputer';
import { IEditorConstructionOptions } from 'vs/editor/browser/config/editorConfiguration';
import { IDimension } from 'vs/editor/common/core/dimension';
import { isHighContrast } from 'vs/platform/theme/common/theme';
export interface IDiffCodeEditorWidgetOptions {
originalEditor?: ICodeEditorWidgetOptions;
@@ -81,7 +85,7 @@ interface IEditorsZones {
class VisualEditorState {
private _zones: string[];
private _inlineDiffMargins: InlineDiffMargin[];
private _zonesMap: { [zoneId: string]: boolean; };
private _zonesMap: { [zoneId: string]: boolean };
private _decorations: string[];
constructor(
@@ -295,8 +299,8 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
this._overviewDomElement.appendChild(this._overviewViewportDomElement.domNode);
this._register(dom.addStandardDisposableListener(this._overviewDomElement, 'mousedown', (e) => {
this._modifiedEditor.delegateVerticalScrollbarMouseDown(e);
this._register(dom.addStandardDisposableListener(this._overviewDomElement, dom.EventType.POINTER_DOWN, (e) => {
this._modifiedEditor.delegateVerticalScrollbarPointerDown(e);
}));
if (this._options.renderOverviewRuler) {
this._containerDomElement.appendChild(this._overviewDomElement);
@@ -326,7 +330,8 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
this._isVisible = true;
this._isHandlingScrollEvent = false;
this._elementSizeObserver = this._register(new ElementSizeObserver(this._containerDomElement, options.dimension, () => this._onDidContainerSizeChanged()));
this._elementSizeObserver = this._register(new ElementSizeObserver(this._containerDomElement, options.dimension));
this._register(this._elementSizeObserver.onDidChange(() => this._onDidContainerSizeChanged()));
if (options.automaticLayout) {
this._elementSizeObserver.startObserving();
}
@@ -377,6 +382,10 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return this._options.maxComputationTime;
}
public get renderSideBySide(): boolean {
return this._options.renderSideBySide;
}
public getContentHeight(): number {
return this._modifiedEditor.getContentHeight();
}
@@ -588,8 +597,8 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return editor;
}
protected _createInnerEditor(instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<editorBrowser.IEditorConstructionOptions>, editorWidgetOptions: ICodeEditorWidgetOptions): CodeEditorWidget {
return instantiationService.createInstance(CodeEditorWidget, container, options, editorWidgetOptions);
protected _createInnerEditor(instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<IEditorConstructionOptions>, editorWidgetOptions: ICodeEditorWidgetOptions): CodeEditorWidget {
return instantiationService.createInstance(CodeEditorWidget, container, { enableDropIntoEditor: true, ...options }, editorWidgetOptions);
}
public override dispose(): void {
@@ -645,7 +654,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return editorCommon.EditorType.IDiffEditor;
}
public getLineChanges(): editorCommon.ILineChange[] | null {
public getLineChanges(): ILineChange[] | null {
if (!this._diffComputationResult) {
return null;
}
@@ -748,7 +757,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
this._layoutOverviewViewport();
}
public getDomNode(): HTMLElement {
public getContainerDomNode(): HTMLElement {
return this._domElement;
}
@@ -764,8 +773,8 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return this._modifiedEditor.getPosition();
}
public setPosition(position: IPosition): void {
this._modifiedEditor.setPosition(position);
public setPosition(position: IPosition, source: string = 'api'): void {
this._modifiedEditor.setPosition(position, source);
}
public revealLine(lineNumber: number, scrollType: editorCommon.ScrollType = editorCommon.ScrollType.Smooth): void {
@@ -808,16 +817,16 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return this._modifiedEditor.getSelections();
}
public setSelection(range: IRange): void;
public setSelection(editorRange: Range): void;
public setSelection(selection: ISelection): void;
public setSelection(editorSelection: Selection): void;
public setSelection(something: any): void {
this._modifiedEditor.setSelection(something);
public setSelection(range: IRange, source?: string): void;
public setSelection(editorRange: Range, source?: string): void;
public setSelection(selection: ISelection, source?: string): void;
public setSelection(editorSelection: Selection, source?: string): void;
public setSelection(something: any, source: string = 'api'): void {
this._modifiedEditor.setSelection(something, source);
}
public setSelections(ranges: readonly ISelection[]): void {
this._modifiedEditor.setSelections(ranges);
public setSelections(ranges: readonly ISelection[], source: string = 'api'): void {
this._modifiedEditor.setSelections(ranges, source);
}
public revealLines(startLineNumber: number, endLineNumber: number, scrollType: editorCommon.ScrollType = editorCommon.ScrollType.Smooth): void {
@@ -881,7 +890,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
}
}
public layout(dimension?: editorCommon.IDimension): void {
public layout(dimension?: IDimension): void {
this._elementSizeObserver.observe(dimension);
}
@@ -1073,7 +1082,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
}
}
private _adjustOptionsForSubEditor(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): editorBrowser.IEditorConstructionOptions {
private _adjustOptionsForSubEditor(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): IEditorConstructionOptions {
const clonedOptions = { ...options };
clonedOptions.inDiffEditor = true;
clonedOptions.automaticLayout = false;
@@ -1090,11 +1099,12 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
return clonedOptions;
}
private _adjustOptionsForLeftHandSide(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): editorBrowser.IEditorConstructionOptions {
private _adjustOptionsForLeftHandSide(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): IEditorConstructionOptions {
const result = this._adjustOptionsForSubEditor(options);
if (!this._options.renderSideBySide) {
// never wrap hidden editor
result.wordWrapOverride1 = 'off';
result.wordWrapOverride2 = 'off';
} else {
result.wordWrapOverride1 = this._options.diffWordWrap;
}
@@ -1112,7 +1122,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
};
}
private _adjustOptionsForRightHandSide(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): editorBrowser.IEditorConstructionOptions {
private _adjustOptionsForRightHandSide(options: Readonly<editorBrowser.IDiffEditorConstructionOptions>): IEditorConstructionOptions {
const result = this._adjustOptionsForSubEditor(options);
if (options.modifiedAriaLabel) {
result.ariaLabel = options.modifiedAriaLabel;
@@ -1179,7 +1189,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
}
}
private _computeOverviewViewport(): { height: number; top: number; } | null {
private _computeOverviewViewport(): { height: number; top: number } | null {
const layoutInfo = this._modifiedEditor.getLayoutInfo();
if (!layoutInfo) {
return null;
@@ -1251,7 +1261,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
this._doLayout();
}
private _getLineChangeAtOrBeforeLineNumber(lineNumber: number, startLineNumberExtractor: (lineChange: editorCommon.ILineChange) => number): editorCommon.ILineChange | null {
private _getLineChangeAtOrBeforeLineNumber(lineNumber: number, startLineNumberExtractor: (lineChange: ILineChange) => number): ILineChange | null {
const lineChanges = (this._diffComputationResult ? this._diffComputationResult.changes : []);
if (lineChanges.length === 0 || lineNumber < startLineNumberExtractor(lineChanges[0])) {
// There are no changes or `lineNumber` is before the first change
@@ -1346,7 +1356,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
interface IDataSource {
getWidth(): number;
getHeight(): number;
getOptions(): { renderOverviewRuler: boolean; };
getOptions(): { renderOverviewRuler: boolean };
getContainerDomNode(): HTMLElement;
relayoutEditors(): void;
@@ -1368,8 +1378,8 @@ abstract class DiffEditorWidgetStyle extends Disposable {
}
public applyColors(theme: IColorTheme): boolean {
const newInsertColor = (theme.getColor(diffInserted) || defaultInsertColor).transparent(2);
const newRemoveColor = (theme.getColor(diffRemoved) || defaultRemoveColor).transparent(2);
const newInsertColor = theme.getColor(diffOverviewRulerInserted) || (theme.getColor(diffInserted) || defaultInsertColor).transparent(2);
const newRemoveColor = theme.getColor(diffOverviewRulerRemoved) || (theme.getColor(diffRemoved) || defaultRemoveColor).transparent(2);
const hasChanges = !newInsertColor.equals(this._insertColor) || !newRemoveColor.equals(this._removeColor);
this._insertColor = newInsertColor;
this._removeColor = newRemoveColor;
@@ -1377,7 +1387,7 @@ abstract class DiffEditorWidgetStyle extends Disposable {
}
// {{SQL CARBON EDIT}} - add reverse parameter
public getEditorsDiffDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean, originalWhitespaces: IEditorWhitespace[], modifiedWhitespaces: IEditorWhitespace[], originalEditor: editorBrowser.ICodeEditor, modifiedEditor: editorBrowser.ICodeEditor, reverse?: boolean): IEditorsDiffDecorationsWithZones {
public getEditorsDiffDecorations(lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean, originalWhitespaces: IEditorWhitespace[], modifiedWhitespaces: IEditorWhitespace[], originalEditor: editorBrowser.ICodeEditor, modifiedEditor: editorBrowser.ICodeEditor, reverse?: boolean): IEditorsDiffDecorationsWithZones {
// Get view zones
modifiedWhitespaces = modifiedWhitespaces.sort((a, b) => {
return a.afterLineNumber - b.afterLineNumber;
@@ -1395,8 +1405,8 @@ abstract class DiffEditorWidgetStyle extends Disposable {
// {{SQL CARBON EDIT}}
// Get decorations & overview ruler zones
let originalDecorations = this._getOriginalEditorDecorations(lineChanges, ignoreTrimWhitespace, renderIndicators);
let modifiedDecorations = this._getModifiedEditorDecorations(lineChanges, ignoreTrimWhitespace, renderIndicators);
let originalDecorations = this._getOriginalEditorDecorations(zones, lineChanges, ignoreTrimWhitespace, renderIndicators);
let modifiedDecorations = this._getModifiedEditorDecorations(zones, lineChanges, ignoreTrimWhitespace, renderIndicators);
// {{SQL CARBON EDIT}}
if (reverse) {
[originalDecorations, modifiedDecorations] = [modifiedDecorations, originalDecorations];
@@ -1416,9 +1426,9 @@ abstract class DiffEditorWidgetStyle extends Disposable {
};
}
protected abstract _getViewZones(lineChanges: editorCommon.ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[], renderIndicators: boolean): IEditorsZones;
protected abstract _getOriginalEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations;
protected abstract _getModifiedEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations;
protected abstract _getViewZones(lineChanges: ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[], renderIndicators: boolean): IEditorsZones;
protected abstract _getOriginalEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations;
protected abstract _getModifiedEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations;
public abstract setEnableSplitViewResizing(enableSplitViewResizing: boolean): void;
public abstract layout(): number;
@@ -1461,7 +1471,7 @@ class ForeignViewZonesIterator {
abstract class ViewZonesComputer {
constructor(
private readonly _lineChanges: editorCommon.ILineChange[],
private readonly _lineChanges: ILineChange[],
private readonly _originalForeignVZ: IEditorWhitespace[],
private readonly _modifiedForeignVZ: IEditorWhitespace[],
protected readonly _originalEditor: CodeEditorWidget,
@@ -1490,7 +1500,7 @@ abstract class ViewZonesComputer {
const originalCoordinatesConverter = this._originalEditor._getViewModel()!.coordinatesConverter;
const modifiedCoordinatesConverter = this._modifiedEditor._getViewModel()!.coordinatesConverter;
const result: { original: IMyViewZone[]; modified: IMyViewZone[]; } = {
const result: { original: IMyViewZone[]; modified: IMyViewZone[] } = {
original: [],
modified: []
};
@@ -1558,7 +1568,8 @@ abstract class ViewZonesComputer {
count = lineChange.modifiedStartLineNumber - lastModifiedLineNumber;
}
} else {
count = originalModel.getLineCount() - lastOriginalLineNumber;
// `lastOriginalLineNumber` has not been looked at yet
count = originalModel.getLineCount() - lastOriginalLineNumber + 1;
}
for (let i = 0; i < count; i++) {
@@ -1719,9 +1730,9 @@ abstract class ViewZonesComputer {
protected abstract _createOriginalMarginDomNodeForModifiedForeignViewZoneInAddedRegion(): HTMLDivElement | null;
protected abstract _produceOriginalFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null;
protected abstract _produceOriginalFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null;
protected abstract _produceModifiedFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null;
protected abstract _produceModifiedFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null;
}
function createDecoration(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, options: ModelDecorationOptions) {
@@ -1756,34 +1767,34 @@ const DECORATIONS = {
lineInsert: ModelDecorationOptions.register({
description: 'diff-editor-line-insert',
className: 'line-insert',
marginClassName: 'line-insert',
marginClassName: 'gutter-insert',
isWholeLine: true
}),
lineInsertWithSign: ModelDecorationOptions.register({
description: 'diff-editor-line-insert-with-sign',
className: 'line-insert',
linesDecorationsClassName: 'insert-sign ' + ThemeIcon.asClassName(diffInsertIcon),
marginClassName: 'line-insert',
marginClassName: 'gutter-insert',
isWholeLine: true
}),
lineDelete: ModelDecorationOptions.register({
description: 'diff-editor-line-delete',
className: 'line-delete',
marginClassName: 'line-delete',
marginClassName: 'gutter-delete',
isWholeLine: true
}),
lineDeleteWithSign: ModelDecorationOptions.register({
description: 'diff-editor-line-delete-with-sign',
className: 'line-delete',
linesDecorationsClassName: 'delete-sign ' + ThemeIcon.asClassName(diffRemoveIcon),
marginClassName: 'line-delete',
marginClassName: 'gutter-delete',
isWholeLine: true
}),
lineDeleteMargin: ModelDecorationOptions.register({
description: 'diff-editor-line-delete-margin',
marginClassName: 'line-delete',
marginClassName: 'gutter-delete',
})
};
@@ -1848,8 +1859,8 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
if (this._sashPosition !== sashPosition) {
this._sashPosition = sashPosition;
this._sash.layout();
}
this._sash.layout();
return this._sashPosition;
}
@@ -1890,14 +1901,14 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
return this._dataSource.getHeight();
}
protected _getViewZones(lineChanges: editorCommon.ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[]): IEditorsZones {
protected _getViewZones(lineChanges: ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[]): IEditorsZones {
const originalEditor = this._dataSource.getOriginalEditor();
const modifiedEditor = this._dataSource.getModifiedEditor();
const c = new SideBySideViewZonesComputer(lineChanges, originalForeignVZ, modifiedForeignVZ, originalEditor, modifiedEditor);
return c.getViewZones();
}
protected _getOriginalEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
protected _getOriginalEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
const originalEditor = this._dataSource.getOriginalEditor();
const overviewZoneColor = String(this._removeColor);
@@ -1921,7 +1932,7 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
}
const viewRange = getViewRange(originalModel, originalViewModel, lineChange.originalStartLineNumber, lineChange.originalEndLineNumber);
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, overviewZoneColor));
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, /*use endLineNumber*/0, overviewZoneColor));
if (lineChange.charChanges) {
for (const charChange of lineChange.charChanges) {
@@ -1954,7 +1965,7 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
return result;
}
protected _getModifiedEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
protected _getModifiedEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
const modifiedEditor = this._dataSource.getModifiedEditor();
const overviewZoneColor = String(this._insertColor);
@@ -1979,7 +1990,7 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
}
const viewRange = getViewRange(modifiedModel, modifiedViewModel, lineChange.modifiedStartLineNumber, lineChange.modifiedEndLineNumber);
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, overviewZoneColor));
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber,/*use endLineNumber*/0, overviewZoneColor));
if (lineChange.charChanges) {
for (const charChange of lineChange.charChanges) {
@@ -2016,7 +2027,7 @@ class DiffEditorWidgetSideBySide extends DiffEditorWidgetStyle implements IVerti
class SideBySideViewZonesComputer extends ViewZonesComputer {
constructor(
lineChanges: editorCommon.ILineChange[],
lineChanges: ILineChange[],
originalForeignVZ: IEditorWhitespace[],
modifiedForeignVZ: IEditorWhitespace[],
originalEditor: CodeEditorWidget,
@@ -2029,7 +2040,7 @@ class SideBySideViewZonesComputer extends ViewZonesComputer {
return null;
}
protected _produceOriginalFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
protected _produceOriginalFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
if (lineChangeModifiedLength > lineChangeOriginalLength) {
return {
afterLineNumber: Math.max(lineChange.originalStartLineNumber, lineChange.originalEndLineNumber),
@@ -2040,7 +2051,7 @@ class SideBySideViewZonesComputer extends ViewZonesComputer {
return null;
}
protected _produceModifiedFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
protected _produceModifiedFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
if (lineChangeOriginalLength > lineChangeModifiedLength) {
return {
afterLineNumber: Math.max(lineChange.modifiedStartLineNumber, lineChange.modifiedEndLineNumber),
@@ -2073,14 +2084,14 @@ class DiffEditorWidgetInline extends DiffEditorWidgetStyle {
// Nothing to do..
}
protected _getViewZones(lineChanges: editorCommon.ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[], renderIndicators: boolean): IEditorsZones {
protected _getViewZones(lineChanges: ILineChange[], originalForeignVZ: IEditorWhitespace[], modifiedForeignVZ: IEditorWhitespace[], renderIndicators: boolean): IEditorsZones {
const originalEditor = this._dataSource.getOriginalEditor();
const modifiedEditor = this._dataSource.getModifiedEditor();
const computer = new InlineViewZonesComputer(lineChanges, originalForeignVZ, modifiedForeignVZ, originalEditor, modifiedEditor, renderIndicators);
return computer.getViewZones();
}
protected _getOriginalEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
protected _getOriginalEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
const overviewZoneColor = String(this._removeColor);
const result: IEditorDiffDecorations = {
@@ -2091,6 +2102,7 @@ class DiffEditorWidgetInline extends DiffEditorWidgetStyle {
const originalEditor = this._dataSource.getOriginalEditor();
const originalModel = originalEditor.getModel()!;
const originalViewModel = originalEditor._getViewModel()!;
let zoneIndex = 0;
for (const lineChange of lineChanges) {
@@ -2101,15 +2113,37 @@ class DiffEditorWidgetInline extends DiffEditorWidgetStyle {
options: DECORATIONS.lineDeleteMargin
});
while (zoneIndex < zones.modified.length) {
const zone = zones.modified[zoneIndex];
if (zone.diff && zone.diff.originalStartLineNumber >= lineChange.originalStartLineNumber) {
break;
}
zoneIndex++;
}
let zoneHeightInLines = 0;
if (zoneIndex < zones.modified.length) {
const zone = zones.modified[zoneIndex];
if (
zone.diff
&& zone.diff.originalStartLineNumber === lineChange.originalStartLineNumber
&& zone.diff.originalEndLineNumber === lineChange.originalEndLineNumber
&& zone.diff.modifiedStartLineNumber === lineChange.modifiedStartLineNumber
&& zone.diff.modifiedEndLineNumber === lineChange.modifiedEndLineNumber
) {
zoneHeightInLines = zone.heightInLines;
}
}
const viewRange = getViewRange(originalModel, originalViewModel, lineChange.originalStartLineNumber, lineChange.originalEndLineNumber);
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, overviewZoneColor));
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, zoneHeightInLines, overviewZoneColor));
}
}
return result;
}
protected _getModifiedEditorDecorations(lineChanges: editorCommon.ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
protected _getModifiedEditorDecorations(zones: IEditorsZones, lineChanges: ILineChange[], ignoreTrimWhitespace: boolean, renderIndicators: boolean): IEditorDiffDecorations {
const modifiedEditor = this._dataSource.getModifiedEditor();
const overviewZoneColor = String(this._insertColor);
@@ -2131,7 +2165,7 @@ class DiffEditorWidgetInline extends DiffEditorWidgetStyle {
});
const viewRange = getViewRange(modifiedModel, modifiedViewModel, lineChange.modifiedStartLineNumber, lineChange.modifiedEndLineNumber);
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, overviewZoneColor));
result.overviewZones.push(new OverviewRulerZone(viewRange.startLineNumber, viewRange.endLineNumber, /*use endLineNumber*/0, overviewZoneColor));
if (lineChange.charChanges) {
for (const charChange of lineChange.charChanges) {
@@ -2187,12 +2221,12 @@ class InlineViewZonesComputer extends ViewZonesComputer {
private readonly _originalModel: ITextModel;
private readonly _renderIndicators: boolean;
private readonly _pendingLineChange: editorCommon.ILineChange[];
private readonly _pendingLineChange: ILineChange[];
private readonly _pendingViewZones: InlineModifiedViewZone[];
private readonly _lineBreaksComputer: ILineBreaksComputer;
constructor(
lineChanges: editorCommon.ILineChange[],
lineChanges: ILineChange[],
originalForeignVZ: IEditorWhitespace[],
modifiedForeignVZ: IEditorWhitespace[],
originalEditor: CodeEditorWidget,
@@ -2219,7 +2253,7 @@ class InlineViewZonesComputer extends ViewZonesComputer {
return result;
}
protected _produceOriginalFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
protected _produceOriginalFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
const marginDomNode = document.createElement('div');
marginDomNode.className = 'inline-added-margin-view-zone';
@@ -2231,7 +2265,7 @@ class InlineViewZonesComputer extends ViewZonesComputer {
};
}
protected _produceModifiedFromDiff(lineChange: editorCommon.ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
protected _produceModifiedFromDiff(lineChange: ILineChange, lineChangeOriginalLength: number, lineChangeModifiedLength: number): IMyViewZone | null {
const domNode = document.createElement('div');
domNode.className = `view-lines line-delete ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`;
@@ -2289,10 +2323,10 @@ class InlineViewZonesComputer extends ViewZonesComputer {
const lineChange = this._pendingLineChange[i];
const viewZone = this._pendingViewZones[i];
const domNode = viewZone.domNode;
Configuration.applyFontInfoSlow(domNode, fontInfo);
applyFontInfo(domNode, fontInfo);
const marginDomNode = viewZone.marginDomNode;
Configuration.applyFontInfoSlow(marginDomNode, fontInfo);
applyFontInfo(marginDomNode, fontInfo);
const decorations: InlineDecoration[] = [];
if (lineChange.charChanges) {
@@ -2314,7 +2348,7 @@ class InlineViewZonesComputer extends ViewZonesComputer {
let viewLineCounts: number[] | null = null;
for (let lineNumber = lineChange.originalStartLineNumber; lineNumber <= lineChange.originalEndLineNumber; lineNumber++) {
const lineIndex = lineNumber - lineChange.originalStartLineNumber;
const lineTokens = this._originalModel.getLineTokens(lineNumber);
const lineTokens = this._originalModel.tokenization.getLineTokens(lineNumber);
const lineContent = lineTokens.getLineContent();
const lineBreakData = lineBreaks[lineBreakIndex++];
const actualDecorations = LineDecoration.filter(decorations, lineNumber, 1, lineContent.length + 1);
@@ -2356,7 +2390,7 @@ class InlineViewZonesComputer extends ViewZonesComputer {
viewLineCounts[lineIndex] = lineBreakData.breakOffsets.length;
viewZone.heightInLines += (lineBreakData.breakOffsets.length - 1);
const marginDomNode2 = document.createElement('div');
marginDomNode2.className = 'line-delete';
marginDomNode2.className = 'gutter-delete';
result.original.push({
afterLineNumber: lineNumber,
afterColumn: 0,
@@ -2480,11 +2514,11 @@ function validateDiffWordWrap(value: 'off' | 'on' | 'inherit' | undefined, defau
return validateStringSetOption<'off' | 'on' | 'inherit'>(value, defaultValue, ['off', 'on', 'inherit']);
}
function isChangeOrInsert(lineChange: editorCommon.IChange): boolean {
function isChangeOrInsert(lineChange: IChange): boolean {
return lineChange.modifiedEndLineNumber > 0;
}
function isChangeOrDelete(lineChange: editorCommon.IChange): boolean {
function isChangeOrDelete(lineChange: IChange): boolean {
return lineChange.originalEndLineNumber > 0;
}
@@ -2539,26 +2573,40 @@ function changedDiffEditorOptions(a: ValidDiffEditorBaseOptions, b: ValidDiffEdi
registerThemingParticipant((theme, collector) => {
const added = theme.getColor(diffInserted);
if (added) {
collector.addRule(`.monaco-editor .line-insert, .monaco-editor .char-insert { background-color: ${added}; }`);
collector.addRule(`.monaco-diff-editor .line-insert, .monaco-diff-editor .char-insert { background-color: ${added}; }`);
collector.addRule(`.monaco-editor .inline-added-margin-view-zone { background-color: ${added}; }`);
collector.addRule(`.monaco-editor .char-insert, .monaco-diff-editor .char-insert { background-color: ${added}; }`);
}
const lineAdded = theme.getColor(diffInsertedLine) || added;
if (lineAdded) {
collector.addRule(`.monaco-editor .line-insert, .monaco-diff-editor .line-insert { background-color: ${lineAdded}; }`);
}
const gutterAdded = theme.getColor(diffInsertedLineGutter) || lineAdded;
if (gutterAdded) {
collector.addRule(`.monaco-editor .inline-added-margin-view-zone { background-color: ${gutterAdded}; }`);
collector.addRule(`.monaco-editor .gutter-insert, .monaco-diff-editor .gutter-insert { background-color: ${gutterAdded}; }`);
}
const removed = theme.getColor(diffRemoved);
if (removed) {
collector.addRule(`.monaco-editor .line-delete, .monaco-editor .char-delete { background-color: ${removed}; }`);
collector.addRule(`.monaco-diff-editor .line-delete, .monaco-diff-editor .char-delete { background-color: ${removed}; }`);
collector.addRule(`.monaco-editor .inline-deleted-margin-view-zone { background-color: ${removed}; }`);
collector.addRule(`.monaco-editor .char-delete, .monaco-diff-editor .char-delete { background-color: ${removed}; }`);
}
const lineRemoved = theme.getColor(diffRemovedLine) || removed;
if (lineRemoved) {
collector.addRule(`.monaco-editor .line-delete, .monaco-diff-editor .line-delete { background-color: ${lineRemoved}; }`);
}
const gutterRemoved = theme.getColor(diffRemovedLineGutter) || lineRemoved;
if (gutterRemoved) {
collector.addRule(`.monaco-editor .inline-deleted-margin-view-zone { background-color: ${gutterRemoved}; }`);
collector.addRule(`.monaco-editor .gutter-delete, .monaco-diff-editor .gutter-delete { background-color: ${gutterRemoved}; }`);
}
const addedOutline = theme.getColor(diffInsertedOutline);
if (addedOutline) {
collector.addRule(`.monaco-editor .line-insert, .monaco-editor .char-insert { border: 1px ${theme.type === 'hc' ? 'dashed' : 'solid'} ${addedOutline}; }`);
collector.addRule(`.monaco-editor .line-insert, .monaco-editor .char-insert { border: 1px ${isHighContrast(theme.type) ? 'dashed' : 'solid'} ${addedOutline}; }`);
}
const removedOutline = theme.getColor(diffRemovedOutline);
if (removedOutline) {
collector.addRule(`.monaco-editor .line-delete, .monaco-editor .char-delete { border: 1px ${theme.type === 'hc' ? 'dashed' : 'solid'} ${removedOutline}; }`);
collector.addRule(`.monaco-editor .line-delete, .monaco-editor .char-delete { border: 1px ${isHighContrast(theme.type) ? 'dashed' : 'solid'} ${removedOutline}; }`);
}
const shadow = theme.getColor(scrollbarShadow);

15
src/vs/editor/browser/widget/diffNavigator.ts
View File

@@ -8,9 +8,10 @@ import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import * as objects from 'vs/base/common/objects';
import { IDiffEditor } from 'vs/editor/browser/editorBrowser';
import { ICursorPositionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
import { ICursorPositionChangedEvent } from 'vs/editor/common/cursorEvents';
import { Range } from 'vs/editor/common/core/range';
import { ILineChange, ScrollType } from 'vs/editor/common/editorCommon';
import { ILineChange } from 'vs/editor/common/diff/diffComputer';
import { ScrollType } from 'vs/editor/common/editorCommon';
interface IDiffRange {
@@ -89,7 +90,7 @@ export class DiffNavigator extends Disposable implements IDiffNavigator {
}
private _init(): void {
let changes = this._editor.getLineChanges();
const changes = this._editor.getLineChanges();
if (!changes) {
return;
}
@@ -156,13 +157,13 @@ export class DiffNavigator extends Disposable implements IDiffNavigator {
private _initIdx(fwd: boolean): void {
let found = false;
let position = this._editor.getPosition();
const position = this._editor.getPosition();
if (!position) {
this.nextIdx = 0;
return;
}
for (let i = 0, len = this.ranges.length; i < len && !found; i++) {
let range = this.ranges[i].range;
const range = this.ranges[i].range;
if (position.isBeforeOrEqual(range.getStartPosition())) {
this.nextIdx = i + (fwd ? 0 : -1);
found = true;
@@ -199,10 +200,10 @@ export class DiffNavigator extends Disposable implements IDiffNavigator {
}
}
let info = this.ranges[this.nextIdx];
const info = this.ranges[this.nextIdx];
this.ignoreSelectionChange = true;
try {
let pos = info.range.getStartPosition();
const pos = info.range.getStartPosition();
this._editor.setPosition(pos);
this._editor.revealRangeInCenter(info.range, scrollType);
} finally {

52
src/vs/editor/browser/widget/diffReview.ts
View File

@@ -12,19 +12,19 @@ import { DomScrollableElement } from 'vs/base/browser/ui/scrollbar/scrollableEle
import { Action } from 'vs/base/common/actions';
import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
import { Disposable } from 'vs/base/common/lifecycle';
import { Configuration } from 'vs/editor/browser/config/configuration';
import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { EditorAction, ServicesAccessor, registerEditorAction } from 'vs/editor/browser/editorExtensions';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { DiffEditorWidget } from 'vs/editor/browser/widget/diffEditorWidget';
import { IComputedEditorOptions, EditorOption, EditorFontLigatures } from 'vs/editor/common/config/editorOptions';
import { LineTokens } from 'vs/editor/common/core/lineTokens';
import { LineTokens } from 'vs/editor/common/tokens/lineTokens';
import { Position } from 'vs/editor/common/core/position';
import { ILineChange, ScrollType } from 'vs/editor/common/editorCommon';
import { ScrollType } from 'vs/editor/common/editorCommon';
import { ITextModel, TextModelResolvedOptions } from 'vs/editor/common/model';
import { editorLineNumbers } from 'vs/editor/common/view/editorColorRegistry';
import { editorLineNumbers } from 'vs/editor/common/core/editorColorRegistry';
import { RenderLineInput, renderViewLine2 as renderViewLine } from 'vs/editor/common/viewLayout/viewLineRenderer';
import { ViewLineRenderingData } from 'vs/editor/common/viewModel/viewModel';
import { ViewLineRenderingData } from 'vs/editor/common/viewModel';
import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
import { scrollbarShadow } from 'vs/platform/theme/common/colorRegistry';
@@ -32,8 +32,9 @@ import { registerThemingParticipant, ThemeIcon } from 'vs/platform/theme/common/
import { Constants } from 'vs/base/common/uint';
import { Codicon } from 'vs/base/common/codicons';
import { registerIcon } from 'vs/platform/theme/common/iconRegistry';
import { ILanguageIdCodec } from 'vs/editor/common/modes';
import { IModeService } from 'vs/editor/common/services/modeService';
import { ILanguageIdCodec } from 'vs/editor/common/languages';
import { ILanguageService } from 'vs/editor/common/languages/language';
import { ILineChange } from 'vs/editor/common/diff/diffComputer';
const DIFF_LINES_PADDING = 3;
@@ -96,7 +97,7 @@ export class DiffReview extends Disposable {
constructor(
diffEditor: DiffEditorWidget,
@IModeService private readonly _modeService: IModeService
@ILanguageService private readonly _languageService: ILanguageService
) {
super();
this._diffEditor = diffEditor;
@@ -138,7 +139,7 @@ export class DiffReview extends Disposable {
this._register(dom.addStandardDisposableListener(this.domNode.domNode, 'click', (e) => {
e.preventDefault();
let row = dom.findParentWithClass(e.target, 'diff-review-row');
const row = dom.findParentWithClass(e.target, 'diff-review-row');
if (row) {
this._goToRow(row);
}
@@ -256,9 +257,9 @@ export class DiffReview extends Disposable {
private accept(): void {
let jumpToLineNumber = -1;
let current = this._getCurrentFocusedRow();
const current = this._getCurrentFocusedRow();
if (current) {
let lineNumber = parseInt(current.getAttribute('data-line')!, 10);
const lineNumber = parseInt(current.getAttribute('data-line')!, 10);
if (!isNaN(lineNumber)) {
jumpToLineNumber = lineNumber;
}
@@ -280,7 +281,7 @@ export class DiffReview extends Disposable {
}
private _getPrevRow(): HTMLElement {
let current = this._getCurrentFocusedRow();
const current = this._getCurrentFocusedRow();
if (!current) {
return this._getFirstRow();
}
@@ -291,7 +292,7 @@ export class DiffReview extends Disposable {
}
private _getNextRow(): HTMLElement {
let current = this._getCurrentFocusedRow();
const current = this._getCurrentFocusedRow();
if (!current) {
return this._getFirstRow();
}
@@ -306,7 +307,7 @@ export class DiffReview extends Disposable {
}
private _getCurrentFocusedRow(): HTMLElement | null {
let result = <HTMLElement>document.activeElement;
const result = <HTMLElement>document.activeElement;
if (result && /diff-review-row/.test(result.className)) {
return result;
}
@@ -314,7 +315,7 @@ export class DiffReview extends Disposable {
}
private _goToRow(row: HTMLElement): void {
let prev = this._getCurrentFocusedRow();
const prev = this._getCurrentFocusedRow();
row.tabIndex = 0;
row.focus();
if (prev && prev !== row) {
@@ -369,7 +370,8 @@ export class DiffReview extends Disposable {
return [];
}
let diffs: Diff[] = [], diffsLength = 0;
const diffs: Diff[] = [];
let diffsLength = 0;
for (let i = 0, len = lineChanges.length; i < len; i++) {
const lineChange = lineChanges[i];
@@ -379,7 +381,8 @@ export class DiffReview extends Disposable {
const modifiedStart = lineChange.modifiedStartLineNumber;
const modifiedEnd = lineChange.modifiedEndLineNumber;
let r: DiffEntry[] = [], rLength = 0;
const r: DiffEntry[] = [];
let rLength = 0;
// Emit before anchors
{
@@ -487,7 +490,8 @@ export class DiffReview extends Disposable {
// Merge adjacent diffs
let curr: DiffEntry[] = diffs[0].entries;
let r: Diff[] = [], rLength = 0;
const r: Diff[] = [];
let rLength = 0;
for (let i = 1, len = diffs.length; i < len; i++) {
const thisDiff = diffs[i].entries;
@@ -555,11 +559,11 @@ export class DiffReview extends Disposable {
this._currentDiff = this._diffs[diffIndex];
const diffs = this._diffs[diffIndex].entries;
let container = document.createElement('div');
const container = document.createElement('div');
container.className = 'diff-review-table';
container.setAttribute('role', 'list');
container.setAttribute('aria-label', 'Difference review. Use "Stage | Unstage | Revert Selected Ranges" commands');
Configuration.applyFontInfoSlow(container, modifiedOptions.get(EditorOption.fontInfo));
applyFontInfo(container, modifiedOptions.get(EditorOption.fontInfo));
let minOriginalLine = 0;
let maxOriginalLine = 0;
@@ -586,10 +590,10 @@ export class DiffReview extends Disposable {
}
}
let header = document.createElement('div');
const header = document.createElement('div');
header.className = 'diff-review-row';
let cell = document.createElement('div');
const cell = document.createElement('div');
cell.className = 'diff-review-cell diff-review-summary';
const originalChangedLinesCnt = maxOriginalLine - minOriginalLine + 1;
const modifiedChangedLinesCnt = maxModifiedLine - minModifiedLine + 1;
@@ -629,7 +633,7 @@ export class DiffReview extends Disposable {
let modLine = minModifiedLine;
for (let i = 0, len = diffs.length; i < len; i++) {
const diffEntry = diffs[i];
DiffReview._renderSection(container, diffEntry, modLine, lineHeight, this._width, originalOptions, originalModel, originalModelOpts, modifiedOptions, modifiedModel, modifiedModelOpts, this._modeService.languageIdCodec);
DiffReview._renderSection(container, diffEntry, modLine, lineHeight, this._width, originalOptions, originalModel, originalModelOpts, modifiedOptions, modifiedModel, modifiedModelOpts, this._languageService.languageIdCodec);
if (diffEntry.modifiedLineStart !== 0) {
modLine = diffEntry.modifiedLineEnd;
}
@@ -695,7 +699,7 @@ export class DiffReview extends Disposable {
}
row.setAttribute('data-line', String(modLine));
let cell = document.createElement('div');
const cell = document.createElement('div');
cell.className = 'diff-review-cell';
cell.style.height = `${lineHeight}px`;
row.appendChild(cell);

10
src/vs/editor/browser/widget/embeddedCodeEditorWidget.ts
View File

@@ -9,7 +9,7 @@ import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService
import { CodeEditorWidget } from 'vs/editor/browser/widget/codeEditorWidget';
import { DiffEditorWidget } from 'vs/editor/browser/widget/diffEditorWidget';
import { ConfigurationChangedEvent, IDiffEditorOptions, IEditorOptions } from 'vs/editor/common/config/editorOptions';
import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker';
import { ICommandService } from 'vs/platform/commands/common/commands';
import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -19,6 +19,8 @@ import { IAccessibilityService } from 'vs/platform/accessibility/common/accessib
import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
import { IEditorProgressService } from 'vs/platform/progress/common/progress';
import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
export class EmbeddedCodeEditorWidget extends CodeEditorWidget {
@@ -35,9 +37,11 @@ export class EmbeddedCodeEditorWidget extends CodeEditorWidget {
@IContextKeyService contextKeyService: IContextKeyService,
@IThemeService themeService: IThemeService,
@INotificationService notificationService: INotificationService,
@IAccessibilityService accessibilityService: IAccessibilityService
@IAccessibilityService accessibilityService: IAccessibilityService,
@ILanguageConfigurationService languageConfigurationService: ILanguageConfigurationService,
@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
) {
super(domElement, { ...parentEditor.getRawOptions(), overflowWidgetsDomNode: parentEditor.getOverflowWidgetsDomNode() }, {}, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService);
super(domElement, { ...parentEditor.getRawOptions(), overflowWidgetsDomNode: parentEditor.getOverflowWidgetsDomNode() }, {}, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
this._parentEditor = parentEditor;
this._overwriteOptions = options;

2
src/vs/editor/browser/widget/inlineDiffMargin.ts
View File

@@ -167,7 +167,7 @@ export class InlineDiffMargin extends Disposable {
this._register(dom.addStandardDisposableListener(this._diffActions, 'mousedown', e => {
const { top, height } = dom.getDomNodePagePosition(this._diffActions);
let pad = Math.floor(lineHeight / 3);
const pad = Math.floor(lineHeight / 3);
e.preventDefault();
showContextMenu(e.posx, top + height + pad);

8
src/vs/editor/browser/widget/media/diffEditor.css
View File

@@ -19,12 +19,14 @@
.monaco-scrollable-element.modified-in-monaco-diff-editor.vs .scrollbar { background: rgba(0,0,0,0); }
.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark .scrollbar { background: rgba(0,0,0,0); }
.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black .scrollbar { background: none; }
.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light .scrollbar { background: none; }
.monaco-scrollable-element.modified-in-monaco-diff-editor .slider {
z-index: 10;
}
.modified-in-monaco-diff-editor .slider.active { background: rgba(171, 171, 171, .4); }
.modified-in-monaco-diff-editor.hc-black .slider.active { background: none; }
.modified-in-monaco-diff-editor.hc-light .slider.active { background: none; }
/* ---------- Diff ---------- */
@@ -40,7 +42,11 @@
.monaco-editor.hc-black .insert-sign,
.monaco-diff-editor.hc-black .insert-sign,
.monaco-editor.hc-black .delete-sign,
.monaco-diff-editor.hc-black .delete-sign {
.monaco-diff-editor.hc-black .delete-sign,
.monaco-editor.hc-light .insert-sign,
.monaco-diff-editor.hc-light .insert-sign,
.monaco-editor.hc-light .delete-sign,
.monaco-diff-editor.hc-light .delete-sign {
opacity: 1;
}

12
src/vs/editor/common/commands/replaceCommand.ts
View File

@@ -25,8 +25,8 @@ export class ReplaceCommand implements ICommand {
}
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
let inverseEditOperations = helper.getInverseEditOperations();
let srcRange = inverseEditOperations[0].range;
const inverseEditOperations = helper.getInverseEditOperations();
const srcRange = inverseEditOperations[0].range;
return Selection.fromPositions(srcRange.getEndPosition());
}
}
@@ -69,8 +69,8 @@ export class ReplaceCommandWithoutChangingPosition implements ICommand {
}
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
let inverseEditOperations = helper.getInverseEditOperations();
let srcRange = inverseEditOperations[0].range;
const inverseEditOperations = helper.getInverseEditOperations();
const srcRange = inverseEditOperations[0].range;
return Selection.fromPositions(srcRange.getStartPosition());
}
}
@@ -96,8 +96,8 @@ export class ReplaceCommandWithOffsetCursorState implements ICommand {
}
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
let inverseEditOperations = helper.getInverseEditOperations();
let srcRange = inverseEditOperations[0].range;
const inverseEditOperations = helper.getInverseEditOperations();
const srcRange = inverseEditOperations[0].range;
return Selection.fromPositions(srcRange.getEndPosition().delta(this._lineNumberDeltaOffset, this._columnDeltaOffset));
}
}

27
src/vs/editor/common/commands/shiftCommand.ts
View File

@@ -5,13 +5,14 @@
import { CharCode } from 'vs/base/common/charCode';
import * as strings from 'vs/base/common/strings';
import { CursorColumns } from 'vs/editor/common/controller/cursorCommon';
import { CursorColumns } from 'vs/editor/common/core/cursorColumns';
import { Range } from 'vs/editor/common/core/range';
import { Selection, SelectionDirection } from 'vs/editor/common/core/selection';
import { ICommand, ICursorStateComputerData, IEditOperationBuilder } from 'vs/editor/common/editorCommon';
import { ITextModel } from 'vs/editor/common/model';
import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
import { EditorAutoIndentStrategy } from 'vs/editor/common/config/editorOptions';
import { getEnterAction } from 'vs/editor/common/languages/enterAction';
import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
export interface IShiftCommandOpts {
isUnshift: boolean;
@@ -22,7 +23,7 @@ export interface IShiftCommandOpts {
autoIndent: EditorAutoIndentStrategy;
}
const repeatCache: { [str: string]: string[]; } = Object.create(null);
const repeatCache: { [str: string]: string[] } = Object.create(null);
export function cachedStringRepeat(str: string, count: number): string {
if (count <= 0) {
return '';
@@ -79,7 +80,11 @@ export class ShiftCommand implements ICommand {
private _useLastEditRangeForCursorEndPosition: boolean;
private _selectionStartColumnStaysPut: boolean;
constructor(range: Selection, opts: IShiftCommandOpts) {
constructor(
range: Selection,
opts: IShiftCommandOpts,
@ILanguageConfigurationService private readonly _languageConfigurationService: ILanguageConfigurationService
) {
this._opts = opts;
this._selection = range;
this._selectionId = null;
@@ -118,7 +123,7 @@ export class ShiftCommand implements ICommand {
let previousLineExtraSpaces = 0, extraSpaces = 0;
for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++, previousLineExtraSpaces = extraSpaces) {
extraSpaces = 0;
let lineText = model.getLineContent(lineNumber);
const lineText = model.getLineContent(lineNumber);
let indentationEndIndex = strings.firstNonWhitespaceIndex(lineText);
if (this._opts.isUnshift && (lineText.length === 0 || indentationEndIndex === 0)) {
@@ -137,12 +142,12 @@ export class ShiftCommand implements ICommand {
}
if (lineNumber > 1) {
let contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(lineText, indentationEndIndex + 1, tabSize);
const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(lineText, indentationEndIndex + 1, tabSize);
if (contentStartVisibleColumn % indentSize !== 0) {
// The current line is "miss-aligned", so let's see if this is expected...
// This can only happen when it has trailing commas in the indent
if (model.isCheapToTokenize(lineNumber - 1)) {
let enterAction = LanguageConfigurationRegistry.getEnterAction(this._opts.autoIndent, model, new Range(lineNumber - 1, model.getLineMaxColumn(lineNumber - 1), lineNumber - 1, model.getLineMaxColumn(lineNumber - 1)));
if (model.tokenization.isCheapToTokenize(lineNumber - 1)) {
const enterAction = getEnterAction(this._opts.autoIndent, model, new Range(lineNumber - 1, model.getLineMaxColumn(lineNumber - 1), lineNumber - 1, model.getLineMaxColumn(lineNumber - 1)), this._languageConfigurationService);
if (enterAction) {
extraSpaces = previousLineExtraSpaces;
if (enterAction.appendText) {
@@ -249,15 +254,15 @@ export class ShiftCommand implements ICommand {
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
if (this._useLastEditRangeForCursorEndPosition) {
let lastOp = helper.getInverseEditOperations()[0];
const lastOp = helper.getInverseEditOperations()[0];
return new Selection(lastOp.range.endLineNumber, lastOp.range.endColumn, lastOp.range.endLineNumber, lastOp.range.endColumn);
}
const result = helper.getTrackedSelection(this._selectionId!);
if (this._selectionStartColumnStaysPut) {
// The selection start should not move
let initialStartColumn = this._selection.startColumn;
let resultStartColumn = result.startColumn;
const initialStartColumn = this._selection.startColumn;
const resultStartColumn = result.startColumn;
if (resultStartColumn <= initialStartColumn) {
return result;
}

40
src/vs/editor/common/commands/surroundSelectionCommand.ts
View File

@@ -4,6 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { Range } from 'vs/editor/common/core/range';
import { Position } from 'vs/editor/common/core/position';
import { Selection } from 'vs/editor/common/core/selection';
import { ICommand, ICursorStateComputerData, IEditOperationBuilder } from 'vs/editor/common/editorCommon';
import { ITextModel } from 'vs/editor/common/model';
@@ -36,9 +37,9 @@ export class SurroundSelectionCommand implements ICommand {
}
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
let inverseEditOperations = helper.getInverseEditOperations();
let firstOperationRange = inverseEditOperations[0].range;
let secondOperationRange = inverseEditOperations[1].range;
const inverseEditOperations = helper.getInverseEditOperations();
const firstOperationRange = inverseEditOperations[0].range;
const secondOperationRange = inverseEditOperations[1].range;
return new Selection(
firstOperationRange.endLineNumber,
@@ -48,3 +49,36 @@ export class SurroundSelectionCommand implements ICommand {
);
}
}
/**
* A surround selection command that runs after composition finished.
*/
export class CompositionSurroundSelectionCommand implements ICommand {
constructor(
private readonly _position: Position,
private readonly _text: string,
private readonly _charAfter: string
) { }
public getEditOperations(model: ITextModel, builder: IEditOperationBuilder): void {
builder.addTrackedEditOperation(new Range(
this._position.lineNumber,
this._position.column,
this._position.lineNumber,
this._position.column
), this._text + this._charAfter);
}
public computeCursorState(model: ITextModel, helper: ICursorStateComputerData): Selection {
const inverseEditOperations = helper.getInverseEditOperations();
const opRange = inverseEditOperations[0].range;
return new Selection(
opRange.endLineNumber,
opRange.startColumn,
opRange.endLineNumber,
opRange.endColumn - this._charAfter.length
);
}
}

20
src/vs/editor/common/commands/trimTrailingWhitespaceCommand.ts
View File

@@ -4,12 +4,12 @@
*--------------------------------------------------------------------------------------------*/
import * as strings from 'vs/base/common/strings';
import { EditOperation } from 'vs/editor/common/core/editOperation';
import { EditOperation, ISingleEditOperation } from 'vs/editor/common/core/editOperation';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import { ICommand, ICursorStateComputerData, IEditOperationBuilder } from 'vs/editor/common/editorCommon';
import { IIdentifiedSingleEditOperation, ITextModel } from 'vs/editor/common/model';
import { ITextModel } from 'vs/editor/common/model';
export class TrimTrailingWhitespaceCommand implements ICommand {
@@ -24,9 +24,9 @@ export class TrimTrailingWhitespaceCommand implements ICommand {
}
public getEditOperations(model: ITextModel, builder: IEditOperationBuilder): void {
let ops = trimTrailingWhitespace(model, this._cursors);
const ops = trimTrailingWhitespace(model, this._cursors);
for (let i = 0, len = ops.length; i < len; i++) {
let op = ops[i];
const op = ops[i];
builder.addEditOperation(op.range, op.text);
}
@@ -42,7 +42,7 @@ export class TrimTrailingWhitespaceCommand implements ICommand {
/**
* Generate commands for trimming trailing whitespace on a model and ignore lines on which cursors are sitting.
*/
export function trimTrailingWhitespace(model: ITextModel, cursors: Position[]): IIdentifiedSingleEditOperation[] {
export function trimTrailingWhitespace(model: ITextModel, cursors: Position[]): ISingleEditOperation[] {
// Sort cursors ascending
cursors.sort((a, b) => {
if (a.lineNumber === b.lineNumber) {
@@ -59,14 +59,14 @@ export function trimTrailingWhitespace(model: ITextModel, cursors: Position[]):
}
}
let r: IIdentifiedSingleEditOperation[] = [];
const r: ISingleEditOperation[] = [];
let rLen = 0;
let cursorIndex = 0;
let cursorLen = cursors.length;
const cursorLen = cursors.length;
for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
let lineContent = model.getLineContent(lineNumber);
let maxLineColumn = lineContent.length + 1;
const lineContent = model.getLineContent(lineNumber);
const maxLineColumn = lineContent.length + 1;
let minEditColumn = 0;
if (cursorIndex < cursorLen && cursors[cursorIndex].lineNumber === lineNumber) {
@@ -82,7 +82,7 @@ export function trimTrailingWhitespace(model: ITextModel, cursors: Position[]):
continue;
}
let lastNonWhitespaceIndex = strings.lastNonWhitespaceIndex(lineContent);
const lastNonWhitespaceIndex = strings.lastNonWhitespaceIndex(lineContent);
let fromColumn = 0;
if (lastNonWhitespaceIndex === -1) {

670
src/vs/editor/common/config/commonEditorConfig.ts
View File

@@ -1,670 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from 'vs/nls';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import * as objects from 'vs/base/common/objects';
import * as arrays from 'vs/base/common/arrays';
import { IEditorOptions, editorOptionsRegistry, ValidatedEditorOptions, IEnvironmentalOptions, IComputedEditorOptions, ConfigurationChangedEvent, EDITOR_MODEL_DEFAULTS, EditorOption, FindComputedEditorOptionValueById, ComputeOptionsMemory } from 'vs/editor/common/config/editorOptions';
import { EditorZoom } from 'vs/editor/common/config/editorZoom';
import { BareFontInfo, FontInfo } from 'vs/editor/common/config/fontInfo';
import { IConfiguration, IDimension } from 'vs/editor/common/editorCommon';
import { ConfigurationScope, Extensions, IConfigurationNode, IConfigurationRegistry, IConfigurationPropertySchema } from 'vs/platform/configuration/common/configurationRegistry';
import { Registry } from 'vs/platform/registry/common/platform';
import { AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
import { forEach } from 'vs/base/common/collections';
/**
* Control what pressing Tab does.
* If it is false, pressing Tab or Shift-Tab will be handled by the editor.
* If it is true, pressing Tab or Shift-Tab will move the browser focus.
* Defaults to false.
*/
export interface ITabFocus {
onDidChangeTabFocus: Event<boolean>;
getTabFocusMode(): boolean;
setTabFocusMode(tabFocusMode: boolean): void;
}
export const TabFocus: ITabFocus = new class implements ITabFocus {
private _tabFocus: boolean = false;
private readonly _onDidChangeTabFocus = new Emitter<boolean>();
public readonly onDidChangeTabFocus: Event<boolean> = this._onDidChangeTabFocus.event;
public getTabFocusMode(): boolean {
return this._tabFocus;
}
public setTabFocusMode(tabFocusMode: boolean): void {
if (this._tabFocus === tabFocusMode) {
return;
}
this._tabFocus = tabFocusMode;
this._onDidChangeTabFocus.fire(this._tabFocus);
}
};
export interface IEnvConfiguration {
extraEditorClassName: string;
outerWidth: number;
outerHeight: number;
emptySelectionClipboard: boolean;
pixelRatio: number;
zoomLevel: number;
accessibilitySupport: AccessibilitySupport;
}
const hasOwnProperty = Object.hasOwnProperty;
export class ComputedEditorOptions implements IComputedEditorOptions {
private readonly _values: any[] = [];
public _read<T>(id: EditorOption): T {
return this._values[id];
}
public get<T extends EditorOption>(id: T): FindComputedEditorOptionValueById<T> {
return this._values[id];
}
public _write<T>(id: EditorOption, value: T): void {
this._values[id] = value;
}
}
class RawEditorOptions {
private readonly _values: any[] = [];
public _read<T>(id: EditorOption): T | undefined {
return this._values[id];
}
public _write<T>(id: EditorOption, value: T | undefined): void {
this._values[id] = value;
}
}
class EditorConfiguration2 {
public static readOptions(_options: IEditorOptions): RawEditorOptions {
const options: { [key: string]: any; } = _options;
const result = new RawEditorOptions();
for (const editorOption of editorOptionsRegistry) {
const value = (editorOption.name === '_never_' ? undefined : options[editorOption.name]);
result._write(editorOption.id, value);
}
return result;
}
public static validateOptions(options: RawEditorOptions): ValidatedEditorOptions {
const result = new ValidatedEditorOptions();
for (const editorOption of editorOptionsRegistry) {
result._write(editorOption.id, editorOption.validate(options._read(editorOption.id)));
}
return result;
}
public static computeOptions(options: ValidatedEditorOptions, env: IEnvironmentalOptions): ComputedEditorOptions {
const result = new ComputedEditorOptions();
for (const editorOption of editorOptionsRegistry) {
result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
}
return result;
}
private static _deepEquals<T>(a: T, b: T): boolean {
if (typeof a !== 'object' || typeof b !== 'object') {
return (a === b);
}
if (Array.isArray(a) || Array.isArray(b)) {
return (Array.isArray(a) && Array.isArray(b) ? arrays.equals(a, b) : false);
}
for (let key in a) {
if (!EditorConfiguration2._deepEquals(a[key], b[key])) {
return false;
}
}
return true;
}
public static checkEquals(a: ComputedEditorOptions, b: ComputedEditorOptions): ConfigurationChangedEvent | null {
const result: boolean[] = [];
let somethingChanged = false;
for (const editorOption of editorOptionsRegistry) {
const changed = !EditorConfiguration2._deepEquals(a._read(editorOption.id), b._read(editorOption.id));
result[editorOption.id] = changed;
if (changed) {
somethingChanged = true;
}
}
return (somethingChanged ? new ConfigurationChangedEvent(result) : null);
}
}
/**
* Compatibility with old options
*/
function migrateOptions(options: IEditorOptions): void {
const wordWrap = options.wordWrap;
if (<any>wordWrap === true) {
options.wordWrap = 'on';
} else if (<any>wordWrap === false) {
options.wordWrap = 'off';
}
const lineNumbers = options.lineNumbers;
if (<any>lineNumbers === true) {
options.lineNumbers = 'on';
} else if (<any>lineNumbers === false) {
options.lineNumbers = 'off';
}
const autoClosingBrackets = options.autoClosingBrackets;
if (<any>autoClosingBrackets === false) {
options.autoClosingBrackets = 'never';
options.autoClosingQuotes = 'never';
options.autoSurround = 'never';
}
const cursorBlinking = options.cursorBlinking;
if (<any>cursorBlinking === 'visible') {
options.cursorBlinking = 'solid';
}
const renderWhitespace = options.renderWhitespace;
if (<any>renderWhitespace === true) {
options.renderWhitespace = 'boundary';
} else if (<any>renderWhitespace === false) {
options.renderWhitespace = 'none';
}
const renderLineHighlight = options.renderLineHighlight;
if (<any>renderLineHighlight === true) {
options.renderLineHighlight = 'line';
} else if (<any>renderLineHighlight === false) {
options.renderLineHighlight = 'none';
}
const acceptSuggestionOnEnter = options.acceptSuggestionOnEnter;
if (<any>acceptSuggestionOnEnter === true) {
options.acceptSuggestionOnEnter = 'on';
} else if (<any>acceptSuggestionOnEnter === false) {
options.acceptSuggestionOnEnter = 'off';
}
const tabCompletion = options.tabCompletion;
if (<any>tabCompletion === false) {
options.tabCompletion = 'off';
} else if (<any>tabCompletion === true) {
options.tabCompletion = 'onlySnippets';
}
const suggest = options.suggest;
if (suggest && typeof (<any>suggest).filteredTypes === 'object' && (<any>suggest).filteredTypes) {
const mapping: Record<string, string> = {};
mapping['method'] = 'showMethods';
mapping['function'] = 'showFunctions';
mapping['constructor'] = 'showConstructors';
mapping['deprecated'] = 'showDeprecated';
mapping['field'] = 'showFields';
mapping['variable'] = 'showVariables';
mapping['class'] = 'showClasses';
mapping['struct'] = 'showStructs';
mapping['interface'] = 'showInterfaces';
mapping['module'] = 'showModules';
mapping['property'] = 'showProperties';
mapping['event'] = 'showEvents';
mapping['operator'] = 'showOperators';
mapping['unit'] = 'showUnits';
mapping['value'] = 'showValues';
mapping['constant'] = 'showConstants';
mapping['enum'] = 'showEnums';
mapping['enumMember'] = 'showEnumMembers';
mapping['keyword'] = 'showKeywords';
mapping['text'] = 'showWords';
mapping['color'] = 'showColors';
mapping['file'] = 'showFiles';
mapping['reference'] = 'showReferences';
mapping['folder'] = 'showFolders';
mapping['typeParameter'] = 'showTypeParameters';
mapping['snippet'] = 'showSnippets';
forEach(mapping, entry => {
const value = (<any>suggest).filteredTypes[entry.key];
if (value === false) {
(<any>suggest)[entry.value] = value;
}
});
// delete (<any>suggest).filteredTypes;
}
const hover = options.hover;
if (<any>hover === true) {
options.hover = {
enabled: true
};
} else if (<any>hover === false) {
options.hover = {
enabled: false
};
}
const parameterHints = options.parameterHints;
if (<any>parameterHints === true) {
options.parameterHints = {
enabled: true
};
} else if (<any>parameterHints === false) {
options.parameterHints = {
enabled: false
};
}
const autoIndent = options.autoIndent;
if (<any>autoIndent === true) {
options.autoIndent = 'full';
} else if (<any>autoIndent === false) {
options.autoIndent = 'advanced';
}
const matchBrackets = options.matchBrackets;
if (<any>matchBrackets === true) {
options.matchBrackets = 'always';
} else if (<any>matchBrackets === false) {
options.matchBrackets = 'never';
}
const { renderIndentGuides, highlightActiveIndentGuide } = options as any as {
renderIndentGuides: boolean;
highlightActiveIndentGuide: boolean;
};
if (!options.guides) {
options.guides = {};
}
if (renderIndentGuides !== undefined) {
options.guides.indentation = !!renderIndentGuides;
}
if (highlightActiveIndentGuide !== undefined) {
options.guides.highlightActiveIndentation = !!highlightActiveIndentGuide;
}
}
function deepCloneAndMigrateOptions(_options: Readonly<IEditorOptions>): IEditorOptions {
const options = objects.deepClone(_options);
migrateOptions(options);
return options;
}
export abstract class CommonEditorConfiguration extends Disposable implements IConfiguration {
private _onDidChange = this._register(new Emitter<ConfigurationChangedEvent>());
public readonly onDidChange: Event<ConfigurationChangedEvent> = this._onDidChange.event;
private _onDidChangeFast = this._register(new Emitter<ConfigurationChangedEvent>());
public readonly onDidChangeFast: Event<ConfigurationChangedEvent> = this._onDidChangeFast.event;
public readonly isSimpleWidget: boolean;
private _computeOptionsMemory: ComputeOptionsMemory;
public options!: ComputedEditorOptions;
private _isDominatedByLongLines: boolean;
private _viewLineCount: number;
private _lineNumbersDigitCount: number;
private _rawOptions: IEditorOptions;
private _readOptions: RawEditorOptions;
protected _validatedOptions: ValidatedEditorOptions;
constructor(isSimpleWidget: boolean, _options: Readonly<IEditorOptions>) {
super();
this.isSimpleWidget = isSimpleWidget;
this._isDominatedByLongLines = false;
this._computeOptionsMemory = new ComputeOptionsMemory();
this._viewLineCount = 1;
this._lineNumbersDigitCount = 1;
this._rawOptions = deepCloneAndMigrateOptions(_options);
this._readOptions = EditorConfiguration2.readOptions(this._rawOptions);
this._validatedOptions = EditorConfiguration2.validateOptions(this._readOptions);
this._register(EditorZoom.onDidChangeZoomLevel(_ => this._recomputeOptions()));
this._register(TabFocus.onDidChangeTabFocus(_ => this._recomputeOptions()));
}
public observeReferenceElement(dimension?: IDimension): void {
}
public updatePixelRatio(): void {
}
protected _recomputeOptions(): void {
const oldOptions = this.options;
const newOptions = this._computeInternalOptions();
if (!oldOptions) {
this.options = newOptions;
} else {
const changeEvent = EditorConfiguration2.checkEquals(oldOptions, newOptions);
if (changeEvent === null) {
// nothing changed!
return;
}
this.options = newOptions;
this._onDidChangeFast.fire(changeEvent);
this._onDidChange.fire(changeEvent);
}
}
public getRawOptions(): IEditorOptions {
return this._rawOptions;
}
private _computeInternalOptions(): ComputedEditorOptions {
const partialEnv = this._getEnvConfiguration();
const bareFontInfo = BareFontInfo.createFromValidatedSettings(this._validatedOptions, partialEnv.zoomLevel, partialEnv.pixelRatio, this.isSimpleWidget);
const env: IEnvironmentalOptions = {
memory: this._computeOptionsMemory,
outerWidth: partialEnv.outerWidth,
outerHeight: partialEnv.outerHeight,
fontInfo: this.readConfiguration(bareFontInfo),
extraEditorClassName: partialEnv.extraEditorClassName,
isDominatedByLongLines: this._isDominatedByLongLines,
viewLineCount: this._viewLineCount,
lineNumbersDigitCount: this._lineNumbersDigitCount,
emptySelectionClipboard: partialEnv.emptySelectionClipboard,
pixelRatio: partialEnv.pixelRatio,
tabFocusMode: TabFocus.getTabFocusMode(),
accessibilitySupport: partialEnv.accessibilitySupport
};
return EditorConfiguration2.computeOptions(this._validatedOptions, env);
}
private static _subsetEquals(base: { [key: string]: any }, subset: { [key: string]: any }): boolean {
for (const key in subset) {
if (hasOwnProperty.call(subset, key)) {
const subsetValue = subset[key];
const baseValue = base[key];
if (baseValue === subsetValue) {
continue;
}
if (Array.isArray(baseValue) && Array.isArray(subsetValue)) {
if (!arrays.equals(baseValue, subsetValue)) {
return false;
}
continue;
}
if (baseValue && typeof baseValue === 'object' && subsetValue && typeof subsetValue === 'object') {
if (!this._subsetEquals(baseValue, subsetValue)) {
return false;
}
continue;
}
return false;
}
}
return true;
}
public updateOptions(_newOptions: Readonly<IEditorOptions>): void {
if (typeof _newOptions === 'undefined') {
return;
}
const newOptions = deepCloneAndMigrateOptions(_newOptions);
if (CommonEditorConfiguration._subsetEquals(this._rawOptions, newOptions)) {
return;
}
this._rawOptions = objects.mixin(this._rawOptions, newOptions || {});
this._readOptions = EditorConfiguration2.readOptions(this._rawOptions);
this._validatedOptions = EditorConfiguration2.validateOptions(this._readOptions);
this._recomputeOptions();
}
public setIsDominatedByLongLines(isDominatedByLongLines: boolean): void {
this._isDominatedByLongLines = isDominatedByLongLines;
this._recomputeOptions();
}
public setMaxLineNumber(maxLineNumber: number): void {
const lineNumbersDigitCount = CommonEditorConfiguration._digitCount(maxLineNumber);
if (this._lineNumbersDigitCount === lineNumbersDigitCount) {
return;
}
this._lineNumbersDigitCount = lineNumbersDigitCount;
this._recomputeOptions();
}
public setViewLineCount(viewLineCount: number): void {
if (this._viewLineCount === viewLineCount) {
return;
}
this._viewLineCount = viewLineCount;
this._recomputeOptions();
}
private static _digitCount(n: number): number {
let r = 0;
while (n) {
n = Math.floor(n / 10);
r++;
}
return r ? r : 1;
}
protected abstract _getEnvConfiguration(): IEnvConfiguration;
protected abstract readConfiguration(styling: BareFontInfo): FontInfo;
}
export const editorConfigurationBaseNode = Object.freeze<IConfigurationNode>({
id: 'editor',
order: 5,
type: 'object',
title: nls.localize('editorConfigurationTitle', "Editor"),
scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
});
const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
const editorConfiguration: IConfigurationNode = {
...editorConfigurationBaseNode,
properties: {
'editor.tabSize': {
type: 'number',
default: EDITOR_MODEL_DEFAULTS.tabSize,
minimum: 1,
markdownDescription: nls.localize('tabSize', "The number of spaces a tab is equal to. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
},
// 'editor.indentSize': {
// 'anyOf': [
// {
// type: 'string',
// enum: ['tabSize']
// },
// {
// type: 'number',
// minimum: 1
// }
// ],
// default: 'tabSize',
// markdownDescription: nls.localize('indentSize', "The number of spaces used for indentation or 'tabSize' to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
// },
'editor.insertSpaces': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.insertSpaces,
markdownDescription: nls.localize('insertSpaces', "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
},
'editor.detectIndentation': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.detectIndentation,
markdownDescription: nls.localize('detectIndentation', "Controls whether `#editor.tabSize#` and `#editor.insertSpaces#` will be automatically detected when a file is opened based on the file contents.")
},
'editor.trimAutoWhitespace': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
description: nls.localize('trimAutoWhitespace', "Remove trailing auto inserted whitespace.")
},
'editor.largeFileOptimizations': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
description: nls.localize('largeFileOptimizations', "Special handling for large files to disable certain memory intensive features.")
},
'editor.wordBasedSuggestions': {
type: 'boolean',
default: true,
description: nls.localize('wordBasedSuggestions', "Controls whether completions should be computed based on words in the document.")
},
'editor.wordBasedSuggestionsMode': {
enum: ['currentDocument', 'matchingDocuments', 'allDocuments'],
default: 'matchingDocuments',
enumDescriptions: [
nls.localize('wordBasedSuggestionsMode.currentDocument', 'Only suggest words from the active document.'),
nls.localize('wordBasedSuggestionsMode.matchingDocuments', 'Suggest words from all open documents of the same language.'),
nls.localize('wordBasedSuggestionsMode.allDocuments', 'Suggest words from all open documents.')
],
description: nls.localize('wordBasedSuggestionsMode', "Controls from which documents word based completions are computed.")
},
'editor.semanticHighlighting.enabled': {
enum: [true, false, 'configuredByTheme'],
enumDescriptions: [
nls.localize('semanticHighlighting.true', 'Semantic highlighting enabled for all color themes.'),
nls.localize('semanticHighlighting.false', 'Semantic highlighting disabled for all color themes.'),
nls.localize('semanticHighlighting.configuredByTheme', 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
],
default: 'configuredByTheme',
description: nls.localize('semanticHighlighting.enabled', "Controls whether the semanticHighlighting is shown for the languages that support it.")
},
'editor.stablePeek': {
type: 'boolean',
default: false,
markdownDescription: nls.localize('stablePeek', "Keep peek editors open even when double clicking their content or when hitting `Escape`.")
},
'editor.maxTokenizationLineLength': {
type: 'integer',
default: 20_000,
description: nls.localize('maxTokenizationLineLength', "Lines above this length will not be tokenized for performance reasons")
},
'editor.language.brackets': {
type: 'array',
default: false, // We want to distinguish the empty array from not configured.
description: nls.localize('schema.brackets', 'Defines the bracket symbols that increase or decrease the indentation.'),
items: {
type: 'array',
items: [
{
type: 'string',
description: nls.localize('schema.openBracket', 'The opening bracket character or string sequence.')
},
{
type: 'string',
description: nls.localize('schema.closeBracket', 'The closing bracket character or string sequence.')
}
]
}
},
'editor.language.colorizedBracketPairs': {
type: 'array',
default: false, // We want to distinguish the empty array from not configured.
description: nls.localize('schema.colorizedBracketPairs', 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
items: {
type: 'array',
items: [
{
type: 'string',
description: nls.localize('schema.openBracket', 'The opening bracket character or string sequence.')
},
{
type: 'string',
description: nls.localize('schema.closeBracket', 'The closing bracket character or string sequence.')
}
]
}
},
'diffEditor.maxComputationTime': {
type: 'number',
default: 5000,
description: nls.localize('maxComputationTime', "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
},
'diffEditor.maxFileSize': {
type: 'number',
default: 50,
description: nls.localize('maxFileSize', "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
},
'diffEditor.renderSideBySide': {
type: 'boolean',
default: true,
description: nls.localize('sideBySide', "Controls whether the diff editor shows the diff side by side or inline.")
},
'diffEditor.ignoreTrimWhitespace': {
type: 'boolean',
default: true,
description: nls.localize('ignoreTrimWhitespace', "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
},
'diffEditor.renderIndicators': {
type: 'boolean',
default: true,
description: nls.localize('renderIndicators', "Controls whether the diff editor shows +/- indicators for added/removed changes.")
},
'diffEditor.codeLens': {
type: 'boolean',
default: false,
description: nls.localize('codeLens', "Controls whether the editor shows CodeLens.")
},
'diffEditor.wordWrap': {
type: 'string',
enum: ['off', 'on', 'inherit'],
default: 'inherit',
markdownEnumDescriptions: [
nls.localize('wordWrap.off', "Lines will never wrap."),
nls.localize('wordWrap.on', "Lines will wrap at the viewport width."),
nls.localize('wordWrap.inherit', "Lines will wrap according to the `#editor.wordWrap#` setting."),
]
}
}
};
function isConfigurationPropertySchema(x: IConfigurationPropertySchema | { [path: string]: IConfigurationPropertySchema; }): x is IConfigurationPropertySchema {
return (typeof x.type !== 'undefined' || typeof x.anyOf !== 'undefined');
}
// Add properties from the Editor Option Registry
for (const editorOption of editorOptionsRegistry) {
const schema = editorOption.schema;
if (typeof schema !== 'undefined') {
if (isConfigurationPropertySchema(schema)) {
// This is a single schema contribution
editorConfiguration.properties![`editor.${editorOption.name}`] = schema;
} else {
for (let key in schema) {
if (hasOwnProperty.call(schema, key)) {
editorConfiguration.properties![key] = schema[key];
}
}
}
}
}
let cachedEditorConfigurationKeys: { [key: string]: boolean; } | null = null;
function getEditorConfigurationKeys(): { [key: string]: boolean; } {
if (cachedEditorConfigurationKeys === null) {
cachedEditorConfigurationKeys = <{ [key: string]: boolean; }>Object.create(null);
Object.keys(editorConfiguration.properties!).forEach((prop) => {
cachedEditorConfigurationKeys![prop] = true;
});
}
return cachedEditorConfigurationKeys;
}
export function isEditorConfigurationKey(key: string): boolean {
const editorConfigurationKeys = getEditorConfigurationKeys();
return (editorConfigurationKeys[`editor.${key}`] || false);
}
export function isDiffEditorConfigurationKey(key: string): boolean {
const editorConfigurationKeys = getEditorConfigurationKeys();
return (editorConfigurationKeys[`diffEditor.${key}`] || false);
}
configurationRegistry.registerConfiguration(editorConfiguration);

58
src/vs/editor/common/config/editorConfiguration.ts Normal file
View File

@@ -0,0 +1,58 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Event } from 'vs/base/common/event';
import { IDisposable } from 'vs/base/common/lifecycle';
import { ConfigurationChangedEvent, IComputedEditorOptions, IEditorOptions } from 'vs/editor/common/config/editorOptions';
import { IDimension } from 'vs/editor/common/core/dimension';
export interface IEditorConfiguration extends IDisposable {
/**
* Is this a simple widget (not a real code editor)?
*/
readonly isSimpleWidget: boolean;
/**
* Computed editor options.
*/
readonly options: IComputedEditorOptions;
/**
* The `options` have changed (quick event)
*/
onDidChangeFast: Event<ConfigurationChangedEvent>;
/**
* The `options` have changed (slow event)
*/
onDidChange: Event<ConfigurationChangedEvent>;
/**
* Get the raw options as they were passed in to the editor
* and merged with all calls to `updateOptions`.
*/
getRawOptions(): IEditorOptions;
/**
* Update the options with new partial options. All previous
* options will be kept and only present keys will be overwritten.
*/
updateOptions(newOptions: Readonly<IEditorOptions>): void;
/**
* Recompute options with new reference element dimensions.
*/
observeContainer(dimension?: IDimension): void;
/**
* Set if the current model is dominated by long lines.
*/
setIsDominatedByLongLines(isDominatedByLongLines: boolean): void;
/**
* Set the current model line count.
*/
setModelLineCount(modelLineCount: number): void;
/**
* Set the current view model line count.
*/
setViewLineCount(viewLineCount: number): void;
/**
* Set reserved height above.
*/
setReservedHeight(reservedHeight: number): void;
}

220
src/vs/editor/common/config/editorConfigurationSchema.ts Normal file
View File

@@ -0,0 +1,220 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { editorOptionsRegistry } from 'vs/editor/common/config/editorOptions';
import { EDITOR_MODEL_DEFAULTS } from 'vs/editor/common/core/textModelDefaults';
import * as nls from 'vs/nls';
import { ConfigurationScope, Extensions, IConfigurationNode, IConfigurationPropertySchema, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
import { Registry } from 'vs/platform/registry/common/platform';
export const editorConfigurationBaseNode = Object.freeze<IConfigurationNode>({
id: 'editor',
order: 5,
type: 'object',
title: nls.localize('editorConfigurationTitle', "Editor"),
scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
});
const editorConfiguration: IConfigurationNode = {
...editorConfigurationBaseNode,
properties: {
'editor.tabSize': {
type: 'number',
default: EDITOR_MODEL_DEFAULTS.tabSize,
minimum: 1,
markdownDescription: nls.localize('tabSize', "The number of spaces a tab is equal to. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
},
// 'editor.indentSize': {
// 'anyOf': [
// {
// type: 'string',
// enum: ['tabSize']
// },
// {
// type: 'number',
// minimum: 1
// }
// ],
// default: 'tabSize',
// markdownDescription: nls.localize('indentSize', "The number of spaces used for indentation or 'tabSize' to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
// },
'editor.insertSpaces': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.insertSpaces,
markdownDescription: nls.localize('insertSpaces', "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
},
'editor.detectIndentation': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.detectIndentation,
markdownDescription: nls.localize('detectIndentation', "Controls whether `#editor.tabSize#` and `#editor.insertSpaces#` will be automatically detected when a file is opened based on the file contents.")
},
'editor.trimAutoWhitespace': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
description: nls.localize('trimAutoWhitespace', "Remove trailing auto inserted whitespace.")
},
'editor.largeFileOptimizations': {
type: 'boolean',
default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
description: nls.localize('largeFileOptimizations', "Special handling for large files to disable certain memory intensive features.")
},
'editor.wordBasedSuggestions': {
type: 'boolean',
default: true,
description: nls.localize('wordBasedSuggestions', "Controls whether completions should be computed based on words in the document.")
},
'editor.wordBasedSuggestionsMode': {
enum: ['currentDocument', 'matchingDocuments', 'allDocuments'],
default: 'matchingDocuments',
enumDescriptions: [
nls.localize('wordBasedSuggestionsMode.currentDocument', 'Only suggest words from the active document.'),
nls.localize('wordBasedSuggestionsMode.matchingDocuments', 'Suggest words from all open documents of the same language.'),
nls.localize('wordBasedSuggestionsMode.allDocuments', 'Suggest words from all open documents.')
],
description: nls.localize('wordBasedSuggestionsMode', "Controls from which documents word based completions are computed.")
},
'editor.semanticHighlighting.enabled': {
enum: [true, false, 'configuredByTheme'],
enumDescriptions: [
nls.localize('semanticHighlighting.true', 'Semantic highlighting enabled for all color themes.'),
nls.localize('semanticHighlighting.false', 'Semantic highlighting disabled for all color themes.'),
nls.localize('semanticHighlighting.configuredByTheme', 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
],
default: 'configuredByTheme',
description: nls.localize('semanticHighlighting.enabled', "Controls whether the semanticHighlighting is shown for the languages that support it.")
},
'editor.stablePeek': {
type: 'boolean',
default: false,
markdownDescription: nls.localize('stablePeek', "Keep peek editors open even when double clicking their content or when hitting `Escape`.")
},
'editor.maxTokenizationLineLength': {
type: 'integer',
default: 20_000,
description: nls.localize('maxTokenizationLineLength', "Lines above this length will not be tokenized for performance reasons")
},
'editor.language.brackets': {
type: ['array', 'null'],
default: null, // We want to distinguish the empty array from not configured.
description: nls.localize('schema.brackets', 'Defines the bracket symbols that increase or decrease the indentation.'),
items: {
type: 'array',
items: [
{
type: 'string',
description: nls.localize('schema.openBracket', 'The opening bracket character or string sequence.')
},
{
type: 'string',
description: nls.localize('schema.closeBracket', 'The closing bracket character or string sequence.')
}
]
}
},
'editor.language.colorizedBracketPairs': {
type: ['array', 'null'],
default: null, // We want to distinguish the empty array from not configured.
description: nls.localize('schema.colorizedBracketPairs', 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
items: {
type: 'array',
items: [
{
type: 'string',
description: nls.localize('schema.openBracket', 'The opening bracket character or string sequence.')
},
{
type: 'string',
description: nls.localize('schema.closeBracket', 'The closing bracket character or string sequence.')
}
]
}
},
'diffEditor.maxComputationTime': {
type: 'number',
default: 5000,
description: nls.localize('maxComputationTime', "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
},
'diffEditor.maxFileSize': {
type: 'number',
default: 50,
description: nls.localize('maxFileSize', "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
},
'diffEditor.renderSideBySide': {
type: 'boolean',
default: true,
description: nls.localize('sideBySide', "Controls whether the diff editor shows the diff side by side or inline.")
},
'diffEditor.ignoreTrimWhitespace': {
type: 'boolean',
default: true,
description: nls.localize('ignoreTrimWhitespace', "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
},
'diffEditor.renderIndicators': {
type: 'boolean',
default: true,
description: nls.localize('renderIndicators', "Controls whether the diff editor shows +/- indicators for added/removed changes.")
},
'diffEditor.codeLens': {
type: 'boolean',
default: false,
description: nls.localize('codeLens', "Controls whether the editor shows CodeLens.")
},
'diffEditor.wordWrap': {
type: 'string',
enum: ['off', 'on', 'inherit'],
default: 'inherit',
markdownEnumDescriptions: [
nls.localize('wordWrap.off', "Lines will never wrap."),
nls.localize('wordWrap.on', "Lines will wrap at the viewport width."),
nls.localize('wordWrap.inherit', "Lines will wrap according to the `#editor.wordWrap#` setting."),
]
}
}
};
function isConfigurationPropertySchema(x: IConfigurationPropertySchema | { [path: string]: IConfigurationPropertySchema }): x is IConfigurationPropertySchema {
return (typeof x.type !== 'undefined' || typeof x.anyOf !== 'undefined');
}
// Add properties from the Editor Option Registry
for (const editorOption of editorOptionsRegistry) {
const schema = editorOption.schema;
if (typeof schema !== 'undefined') {
if (isConfigurationPropertySchema(schema)) {
// This is a single schema contribution
editorConfiguration.properties![`editor.${editorOption.name}`] = schema;
} else {
for (const key in schema) {
if (Object.hasOwnProperty.call(schema, key)) {
editorConfiguration.properties![key] = schema[key];
}
}
}
}
}
let cachedEditorConfigurationKeys: { [key: string]: boolean } | null = null;
function getEditorConfigurationKeys(): { [key: string]: boolean } {
if (cachedEditorConfigurationKeys === null) {
cachedEditorConfigurationKeys = <{ [key: string]: boolean }>Object.create(null);
Object.keys(editorConfiguration.properties!).forEach((prop) => {
cachedEditorConfigurationKeys![prop] = true;
});
}
return cachedEditorConfigurationKeys;
}
export function isEditorConfigurationKey(key: string): boolean {
const editorConfigurationKeys = getEditorConfigurationKeys();
return (editorConfigurationKeys[`editor.${key}`] || false);
}
export function isDiffEditorConfigurationKey(key: string): boolean {
const editorConfigurationKeys = getEditorConfigurationKeys();
return (editorConfigurationKeys[`diffEditor.${key}`] || false);
}
const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
configurationRegistry.registerConfiguration(editorConfiguration);

654
src/vs/editor/common/config/editorOptions.ts
View File

File diff suppressed because it is too large Load Diff

28
src/vs/editor/common/config/fontInfo.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as platform from 'vs/base/common/platform';
import { EditorOptions, ValidatedEditorOptions, EditorOption } from 'vs/editor/common/config/editorOptions';
import { EditorOptions, EditorOption, FindComputedEditorOptionValueById } from 'vs/editor/common/config/editorOptions';
import { EditorZoom } from 'vs/editor/common/config/editorZoom';
/**
@@ -18,43 +18,50 @@ const GOLDEN_LINE_HEIGHT_RATIO = platform.isMacintosh ? 1.5 : 1.35;
*/
const MINIMUM_LINE_HEIGHT = 8;
/**
* @internal
*/
export interface IValidatedEditorOptions {
get<T extends EditorOption>(id: T): FindComputedEditorOptionValueById<T>;
}
export class BareFontInfo {
readonly _bareFontInfoBrand: void = undefined;
/**
* @internal
*/
public static createFromValidatedSettings(options: ValidatedEditorOptions, zoomLevel: number, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo {
public static createFromValidatedSettings(options: IValidatedEditorOptions, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo {
const fontFamily = options.get(EditorOption.fontFamily);
const fontWeight = options.get(EditorOption.fontWeight);
const fontSize = options.get(EditorOption.fontSize);
const fontFeatureSettings = options.get(EditorOption.fontLigatures);
const lineHeight = options.get(EditorOption.lineHeight);
const letterSpacing = options.get(EditorOption.letterSpacing);
return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, lineHeight, letterSpacing, zoomLevel, pixelRatio, ignoreEditorZoom);
return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
}
/**
* @internal
*/
public static createFromRawSettings(opts: { fontFamily?: string; fontWeight?: string; fontSize?: number; fontLigatures?: boolean | string; lineHeight?: number; letterSpacing?: number; }, zoomLevel: number, pixelRatio: number, ignoreEditorZoom: boolean = false): BareFontInfo {
public static createFromRawSettings(opts: { fontFamily?: string; fontWeight?: string; fontSize?: number; fontLigatures?: boolean | string; lineHeight?: number; letterSpacing?: number }, pixelRatio: number, ignoreEditorZoom: boolean = false): BareFontInfo {
const fontFamily = EditorOptions.fontFamily.validate(opts.fontFamily);
const fontWeight = EditorOptions.fontWeight.validate(opts.fontWeight);
const fontSize = EditorOptions.fontSize.validate(opts.fontSize);
const fontFeatureSettings = EditorOptions.fontLigatures2.validate(opts.fontLigatures);
const lineHeight = EditorOptions.lineHeight.validate(opts.lineHeight);
const letterSpacing = EditorOptions.letterSpacing.validate(opts.letterSpacing);
return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, lineHeight, letterSpacing, zoomLevel, pixelRatio, ignoreEditorZoom);
return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
}
/**
* @internal
*/
private static _create(fontFamily: string, fontWeight: string, fontSize: number, fontFeatureSettings: string, lineHeight: number, letterSpacing: number, zoomLevel: number, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo {
private static _create(fontFamily: string, fontWeight: string, fontSize: number, fontFeatureSettings: string, lineHeight: number, letterSpacing: number, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo {
if (lineHeight === 0) {
lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
} else if (lineHeight < MINIMUM_LINE_HEIGHT) {
// Values too small to be line heights in pixels are probably in ems. Accept them gracefully.
// Values too small to be line heights in pixels are in ems.
lineHeight = lineHeight * fontSize;
}
@@ -69,7 +76,6 @@ export class BareFontInfo {
lineHeight *= editorZoomLevelMultiplier;
return new BareFontInfo({
zoomLevel: zoomLevel,
pixelRatio: pixelRatio,
fontFamily: fontFamily,
fontWeight: fontWeight,
@@ -80,7 +86,6 @@ export class BareFontInfo {
});
}
readonly zoomLevel: number;
readonly pixelRatio: number;
readonly fontFamily: string;
readonly fontWeight: string;
@@ -93,7 +98,6 @@ export class BareFontInfo {
* @internal
*/
protected constructor(opts: {
zoomLevel: number;
pixelRatio: number;
fontFamily: string;
fontWeight: string;
@@ -102,7 +106,6 @@ export class BareFontInfo {
lineHeight: number;
letterSpacing: number;
}) {
this.zoomLevel = opts.zoomLevel;
this.pixelRatio = opts.pixelRatio;
this.fontFamily = String(opts.fontFamily);
this.fontWeight = String(opts.fontWeight);
@@ -116,7 +119,7 @@ export class BareFontInfo {
* @internal
*/
public getId(): string {
return this.zoomLevel + '-' + this.pixelRatio + '-' + this.fontFamily + '-' + this.fontWeight + '-' + this.fontSize + '-' + this.fontFeatureSettings + '-' + this.lineHeight + '-' + this.letterSpacing;
return `${this.pixelRatio}-${this.fontFamily}-${this.fontWeight}-${this.fontSize}-${this.fontFeatureSettings}-${this.lineHeight}-${this.letterSpacing}`;
}
/**
@@ -164,7 +167,6 @@ export class FontInfo extends BareFontInfo {
* @internal
*/
constructor(opts: {
zoomLevel: number;
pixelRatio: number;
fontFamily: string;
fontWeight: string;

219
src/vs/editor/common/controller/cursorColumns.ts
View File

@@ -1,219 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CharCode } from 'vs/base/common/charCode';
import * as strings from 'vs/base/common/strings';
import { Constants } from 'vs/base/common/uint';
import { CursorConfiguration, ICursorSimpleModel } from 'vs/editor/common/controller/cursorCommon';
import { Position } from 'vs/editor/common/core/position';
/**
* Common operations that work and make sense both on the model and on the view model.
*/
export class CursorColumns {
public static visibleColumnFromColumn(lineContent: string, column: number, tabSize: number): number {
const lineContentLength = lineContent.length;
const endOffset = column - 1 < lineContentLength ? column - 1 : lineContentLength;
let result = 0;
let i = 0;
while (i < endOffset) {
const codePoint = strings.getNextCodePoint(lineContent, endOffset, i);
i += (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
if (codePoint === CharCode.Tab) {
result = CursorColumns.nextRenderTabStop(result, tabSize);
} else {
let graphemeBreakType = strings.getGraphemeBreakType(codePoint);
while (i < endOffset) {
const nextCodePoint = strings.getNextCodePoint(lineContent, endOffset, i);
const nextGraphemeBreakType = strings.getGraphemeBreakType(nextCodePoint);
if (strings.breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {
break;
}
i += (nextCodePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
graphemeBreakType = nextGraphemeBreakType;
}
if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {
result = result + 2;
} else {
result = result + 1;
}
}
}
return result;
}
/**
* Returns an array that maps one based columns to one based visible columns. The entry at position 0 is -1.
*/
public static visibleColumnsByColumns(lineContent: string, tabSize: number): number[] {
const endOffset = lineContent.length;
let result = new Array<number>();
result.push(-1);
let pos = 0;
let i = 0;
while (i < endOffset) {
const codePoint = strings.getNextCodePoint(lineContent, endOffset, i);
i += (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
result.push(pos);
if (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN) {
result.push(pos);
}
if (codePoint === CharCode.Tab) {
pos = CursorColumns.nextRenderTabStop(pos, tabSize);
} else {
let graphemeBreakType = strings.getGraphemeBreakType(codePoint);
while (i < endOffset) {
const nextCodePoint = strings.getNextCodePoint(lineContent, endOffset, i);
const nextGraphemeBreakType = strings.getGraphemeBreakType(nextCodePoint);
if (strings.breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {
break;
}
i += (nextCodePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
result.push(pos);
if (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN) {
result.push(pos);
}
graphemeBreakType = nextGraphemeBreakType;
}
if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {
pos = pos + 2;
} else {
pos = pos + 1;
}
}
}
result.push(pos);
return result;
}
public static toStatusbarColumn(lineContent: string, column: number, tabSize: number): number {
const lineContentLength = lineContent.length;
const endOffset = column - 1 < lineContentLength ? column - 1 : lineContentLength;
let result = 0;
let i = 0;
while (i < endOffset) {
const codePoint = strings.getNextCodePoint(lineContent, endOffset, i);
i += (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
if (codePoint === CharCode.Tab) {
result = CursorColumns.nextRenderTabStop(result, tabSize);
} else {
result = result + 1;
}
}
return result + 1;
}
public static visibleColumnFromColumn2(config: CursorConfiguration, model: ICursorSimpleModel, position: Position): number {
return this.visibleColumnFromColumn(model.getLineContent(position.lineNumber), position.column, config.tabSize);
}
public static columnFromVisibleColumn(lineContent: string, visibleColumn: number, tabSize: number): number {
if (visibleColumn <= 0) {
return 1;
}
const lineLength = lineContent.length;
let beforeVisibleColumn = 0;
let beforeColumn = 1;
let i = 0;
while (i < lineLength) {
const codePoint = strings.getNextCodePoint(lineContent, lineLength, i);
i += (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
let afterVisibleColumn: number;
if (codePoint === CharCode.Tab) {
afterVisibleColumn = CursorColumns.nextRenderTabStop(beforeVisibleColumn, tabSize);
} else {
let graphemeBreakType = strings.getGraphemeBreakType(codePoint);
while (i < lineLength) {
const nextCodePoint = strings.getNextCodePoint(lineContent, lineLength, i);
const nextGraphemeBreakType = strings.getGraphemeBreakType(nextCodePoint);
if (strings.breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {
break;
}
i += (nextCodePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
graphemeBreakType = nextGraphemeBreakType;
}
if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {
afterVisibleColumn = beforeVisibleColumn + 2;
} else {
afterVisibleColumn = beforeVisibleColumn + 1;
}
}
const afterColumn = i + 1;
if (afterVisibleColumn >= visibleColumn) {
const beforeDelta = visibleColumn - beforeVisibleColumn;
const afterDelta = afterVisibleColumn - visibleColumn;
if (afterDelta < beforeDelta) {
return afterColumn;
} else {
return beforeColumn;
}
}
beforeVisibleColumn = afterVisibleColumn;
beforeColumn = afterColumn;
}
// walked the entire string
return lineLength + 1;
}
public static columnFromVisibleColumn2(config: CursorConfiguration, model: ICursorSimpleModel, lineNumber: number, visibleColumn: number): number {
let result = this.columnFromVisibleColumn(model.getLineContent(lineNumber), visibleColumn, config.tabSize);
let minColumn = model.getLineMinColumn(lineNumber);
if (result < minColumn) {
return minColumn;
}
let maxColumn = model.getLineMaxColumn(lineNumber);
if (result > maxColumn) {
return maxColumn;
}
return result;
}
/**
* ATTENTION: This works with 0-based columns (as oposed to the regular 1-based columns)
*/
public static nextRenderTabStop(visibleColumn: number, tabSize: number): number {
return visibleColumn + tabSize - visibleColumn % tabSize;
}
/**
* ATTENTION: This works with 0-based columns (as oposed to the regular 1-based columns)
*/
public static nextIndentTabStop(visibleColumn: number, indentSize: number): number {
return visibleColumn + indentSize - visibleColumn % indentSize;
}
/**
* ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
*/
public static prevRenderTabStop(column: number, tabSize: number): number {
return Math.max(0, column - 1 - (column - 1) % tabSize);
}
/**
* ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
*/
public static prevIndentTabStop(column: number, indentSize: number): number {
return Math.max(0, column - 1 - (column - 1) % indentSize);
}
}

6
src/vs/editor/common/core/characterClassifier.ts
View File

@@ -22,7 +22,7 @@ export class CharacterClassifier<T extends number> {
protected _defaultValue: number;
constructor(_defaultValue: T) {
let defaultValue = toUint8(_defaultValue);
const defaultValue = toUint8(_defaultValue);
this._defaultValue = defaultValue;
this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
@@ -30,7 +30,7 @@ export class CharacterClassifier<T extends number> {
}
private static _createAsciiMap(defaultValue: number): Uint8Array {
let asciiMap: Uint8Array = new Uint8Array(256);
const asciiMap: Uint8Array = new Uint8Array(256);
for (let i = 0; i < 256; i++) {
asciiMap[i] = defaultValue;
}
@@ -38,7 +38,7 @@ export class CharacterClassifier<T extends number> {
}
public set(charCode: number, _value: T): void {
let value = toUint8(_value);
const value = toUint8(_value);
if (charCode >= 0 && charCode < 256) {
this._asciiMap[charCode] = value;

149
src/vs/editor/common/core/cursorColumns.ts Normal file
View File

@@ -0,0 +1,149 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CharCode } from 'vs/base/common/charCode';
import * as strings from 'vs/base/common/strings';
/**
* A column in a position is the gap between two adjacent characters. The methods here
* work with a concept called "visible column". A visible column is a very rough approximation
* of the horizontal screen position of a column. For example, using a tab size of 4:
* ```txt
* |<TAB>|<TAB>|T|ext
* | | | \---- column = 4, visible column = 9
* | | \------ column = 3, visible column = 8
* | \------------ column = 2, visible column = 4
* \------------------ column = 1, visible column = 0
* ```
*
* **NOTE**: Visual columns do not work well for RTL text or variable-width fonts or characters.
*
* **NOTE**: These methods work and make sense both on the model and on the view model.
*/
export class CursorColumns {
private static _nextVisibleColumn(codePoint: number, visibleColumn: number, tabSize: number): number {
if (codePoint === CharCode.Tab) {
return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
}
if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {
return visibleColumn + 2;
}
return visibleColumn + 1;
}
/**
* Returns a visible column from a column.
* @see {@link CursorColumns}
*/
public static visibleColumnFromColumn(lineContent: string, column: number, tabSize: number): number {
const textLen = Math.min(column - 1, lineContent.length);
const text = lineContent.substring(0, textLen);
const iterator = new strings.GraphemeIterator(text);
let result = 0;
while (!iterator.eol()) {
const codePoint = strings.getNextCodePoint(text, textLen, iterator.offset);
iterator.nextGraphemeLength();
result = this._nextVisibleColumn(codePoint, result, tabSize);
}
return result;
}
/**
* Returns the value to display as "Col" in the status bar.
* @see {@link CursorColumns}
*/
public static toStatusbarColumn(lineContent: string, column: number, tabSize: number): number {
const text = lineContent.substring(0, Math.min(column - 1, lineContent.length));
const iterator = new strings.CodePointIterator(text);
let result = 0;
while (!iterator.eol()) {
const codePoint = iterator.nextCodePoint();
if (codePoint === CharCode.Tab) {
result = CursorColumns.nextRenderTabStop(result, tabSize);
} else {
result = result + 1;
}
}
return result + 1;
}
/**
* Returns a column from a visible column.
* @see {@link CursorColumns}
*/
public static columnFromVisibleColumn(lineContent: string, visibleColumn: number, tabSize: number): number {
if (visibleColumn <= 0) {
return 1;
}
const lineContentLength = lineContent.length;
const iterator = new strings.GraphemeIterator(lineContent);
let beforeVisibleColumn = 0;
let beforeColumn = 1;
while (!iterator.eol()) {
const codePoint = strings.getNextCodePoint(lineContent, lineContentLength, iterator.offset);
iterator.nextGraphemeLength();
const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);
const afterColumn = iterator.offset + 1;
if (afterVisibleColumn >= visibleColumn) {
const beforeDelta = visibleColumn - beforeVisibleColumn;
const afterDelta = afterVisibleColumn - visibleColumn;
if (afterDelta < beforeDelta) {
return afterColumn;
} else {
return beforeColumn;
}
}
beforeVisibleColumn = afterVisibleColumn;
beforeColumn = afterColumn;
}
// walked the entire string
return lineContentLength + 1;
}
/**
* ATTENTION: This works with 0-based columns (as oposed to the regular 1-based columns)
* @see {@link CursorColumns}
*/
public static nextRenderTabStop(visibleColumn: number, tabSize: number): number {
return visibleColumn + tabSize - visibleColumn % tabSize;
}
/**
* ATTENTION: This works with 0-based columns (as oposed to the regular 1-based columns)
* @see {@link CursorColumns}
*/
public static nextIndentTabStop(visibleColumn: number, indentSize: number): number {
return visibleColumn + indentSize - visibleColumn % indentSize;
}
/**
* ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
* @see {@link CursorColumns}
*/
public static prevRenderTabStop(column: number, tabSize: number): number {
return Math.max(0, column - 1 - (column - 1) % tabSize);
}
/**
* ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
* @see {@link CursorColumns}
*/
public static prevIndentTabStop(column: number, indentSize: number): number {
return Math.max(0, column - 1 - (column - 1) % indentSize);
}
}

5
src/vs/editor/test/common/model/benchmark/bootstrap.js → src/vs/editor/common/core/dimension.ts
View File

@@ -3,4 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
require('../../../../../../bootstrap-amd').load('vs/editor/test/common/model/benchmark/entry');
export interface IDimension {
width: number;
height: number;
}

31
src/vs/editor/common/core/editOperation.ts
View File

@@ -4,12 +4,31 @@
*--------------------------------------------------------------------------------------------*/
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { IIdentifiedSingleEditOperation } from 'vs/editor/common/model';
import { IRange, Range } from 'vs/editor/common/core/range';
/**
* A single edit operation, that acts as a simple replace.
* i.e. Replace text at `range` with `text` in model.
*/
export interface ISingleEditOperation {
/**
* The range to replace. This can be empty to emulate a simple insert.
*/
range: IRange;
/**
* The text to replace with. This can be null to emulate a simple delete.
*/
text: string | null;
/**
* This indicates that this operation has "insert" semantics.
* i.e. forceMoveMarkers = true => if `range` is collapsed, all markers at the position will be moved.
*/
forceMoveMarkers?: boolean;
}
export class EditOperation {
public static insert(position: Position, text: string): IIdentifiedSingleEditOperation {
public static insert(position: Position, text: string): ISingleEditOperation {
return {
range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),
text: text,
@@ -17,21 +36,21 @@ export class EditOperation {
};
}
public static delete(range: Range): IIdentifiedSingleEditOperation {
public static delete(range: Range): ISingleEditOperation {
return {
range: range,
text: null
};
}
public static replace(range: Range, text: string | null): IIdentifiedSingleEditOperation {
public static replace(range: Range, text: string | null): ISingleEditOperation {
return {
range: range,
text: text
};
}
public static replaceMove(range: Range, text: string | null): IIdentifiedSingleEditOperation {
public static replaceMove(range: Range, text: string | null): ISingleEditOperation {
return {
range: range,
text: text,

132
src/vs/editor/common/core/editorColorRegistry.ts Normal file
View File

@@ -0,0 +1,132 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from 'vs/nls';
import { Color, RGBA } from 'vs/base/common/color';
import { activeContrastBorder, editorBackground, editorForeground, registerColor, editorWarningForeground, editorInfoForeground, editorWarningBorder, editorInfoBorder, contrastBorder, editorFindMatchHighlight } from 'vs/platform/theme/common/colorRegistry';
import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
import { isHighContrast } from 'vs/platform/theme/common/theme';
/**
* Definition of the editor colors
*/
export const editorLineHighlight = registerColor('editor.lineHighlightBackground', { dark: null, light: null, hcDark: null, hcLight: null }, nls.localize('lineHighlight', 'Background color for the highlight of line at the cursor position.'));
export const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, nls.localize('lineHighlightBorderBox', 'Background color for the border around the line at the cursor position.'));
export const editorRangeHighlight = registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, nls.localize('rangeHighlight', 'Background color of highlighted ranges, like by quick open and find features. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorRangeHighlightBorder = registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('rangeHighlightBorder', 'Background color of the border around highlighted ranges.'), true);
export const editorSymbolHighlight = registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, nls.localize('symbolHighlight', 'Background color of highlighted symbol, like for go to definition or go next/previous symbol. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorSymbolHighlightBorder = registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('symbolHighlightBorder', 'Background color of the border around highlighted symbols.'), true);
export const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, nls.localize('caret', 'Color of the editor cursor.'));
export const editorCursorBackground = registerColor('editorCursor.background', null, nls.localize('editorCursorBackground', 'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.'));
export const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, nls.localize('editorWhitespaces', 'Color of whitespace characters in the editor.'));
export const editorIndentGuides = registerColor('editorIndentGuide.background', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, nls.localize('editorIndentGuides', 'Color of the editor indentation guides.'));
export const editorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, nls.localize('editorActiveIndentGuide', 'Color of the active editor indentation guides.'));
export const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorLineNumbers', 'Color of editor line numbers.'));
const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('editorActiveLineNumber', 'Color of editor active line number'), false, nls.localize('deprecatedEditorActiveLineNumber', 'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'));
export const editorActiveLineNumber = registerColor('editorLineNumber.activeForeground', { dark: deprecatedEditorActiveLineNumber, light: deprecatedEditorActiveLineNumber, hcDark: deprecatedEditorActiveLineNumber, hcLight: deprecatedEditorActiveLineNumber }, nls.localize('editorActiveLineNumber', 'Color of editor active line number'));
export const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorRuler', 'Color of the editor rulers.'));
export const editorCodeLensForeground = registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, nls.localize('editorCodeLensForeground', 'Foreground color of editor CodeLens'));
export const editorBracketMatchBackground = registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, nls.localize('editorBracketMatchBackground', 'Background color behind matching brackets'));
export const editorBracketMatchBorder = registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize('editorBracketMatchBorder', 'Color for matching brackets boxes'));
export const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, nls.localize('editorOverviewRulerBorder', 'Color of the overview ruler border.'));
export const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, nls.localize('editorOverviewRulerBackground', 'Background color of the editor overview ruler. Only used when the minimap is enabled and placed on the right side of the editor.'));
export const editorGutter = registerColor('editorGutter.background', { dark: editorBackground, light: editorBackground, hcDark: editorBackground, hcLight: editorBackground }, nls.localize('editorGutter', 'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'));
export const editorUnnecessaryCodeBorder = registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: contrastBorder }, nls.localize('unnecessaryCodeBorder', 'Border color of unnecessary (unused) source code in the editor.'));
export const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: Color.fromHex('#000a'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, nls.localize('unnecessaryCodeOpacity', 'Opacity of unnecessary (unused) source code in the editor. For example, "#000000c0" will render the code with 75% opacity. For high contrast themes, use the \'editorUnnecessaryCode.border\' theme color to underline unnecessary code instead of fading it out.'));
export const ghostTextBorder = registerColor('editorGhostText.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: Color.fromHex('#292929').transparent(0.8) }, nls.localize('editorGhostTextBorder', 'Border color of ghost text in the editor.'));
export const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: Color.fromHex('#ffffff56'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, nls.localize('editorGhostTextForeground', 'Foreground color of the ghost text in the editor.'));
export const ghostTextBackground = registerColor('editorGhostText.background', { dark: null, light: null, hcDark: null, hcLight: null }, nls.localize('editorGhostTextBackground', 'Background color of the ghost text in the editor.'));
const rulerRangeDefault = new Color(new RGBA(0, 122, 204, 0.6));
export const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', { dark: rulerRangeDefault, light: rulerRangeDefault, hcDark: rulerRangeDefault, hcLight: rulerRangeDefault }, nls.localize('overviewRulerRangeHighlight', 'Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
export const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: new Color(new RGBA(255, 18, 18, 0.7)), light: new Color(new RGBA(255, 18, 18, 0.7)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '#B5200D' }, nls.localize('overviewRuleError', 'Overview ruler marker color for errors.'));
export const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, nls.localize('overviewRuleWarning', 'Overview ruler marker color for warnings.'));
export const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, nls.localize('overviewRuleInfo', 'Overview ruler marker color for infos.'));
export const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, nls.localize('editorBracketHighlightForeground1', 'Foreground color of brackets (1). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, nls.localize('editorBracketHighlightForeground2', 'Foreground color of brackets (2). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, nls.localize('editorBracketHighlightForeground3', 'Foreground color of brackets (3). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground4', 'Foreground color of brackets (4). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground5', 'Foreground color of brackets (5). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground6', 'Foreground color of brackets (6). Requires enabling bracket pair colorization.'));
export const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: new Color(new RGBA(255, 18, 18, 0.8)), light: new Color(new RGBA(255, 18, 18, 0.8)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '' }, nls.localize('editorBracketHighlightUnexpectedBracketForeground', 'Foreground color of unexpected brackets.'));
export const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background1', 'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background2', 'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background3', 'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background4', 'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background5', 'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background6', 'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground1', 'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground2', 'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground3', 'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground4', 'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground5', 'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'));
export const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground6', 'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'));
export const editorUnicodeHighlightBorder = registerColor('editorUnicodeHighlight.border', { dark: '#BD9B03', light: '#CEA33D', hcDark: '#ff0000', hcLight: '' }, nls.localize('editorUnicodeHighlight.border', 'Border color used to highlight unicode characters.'));
export const editorUnicodeHighlightBackground = registerColor('editorUnicodeHighlight.background', { dark: '#bd9b0326', light: '#cea33d14', hcDark: '#00000000', hcLight: '' }, nls.localize('editorUnicodeHighlight.background', 'Background color used to highlight unicode characters.'));
// contains all color rules that used to defined in editor/browser/widget/editor.css
registerThemingParticipant((theme, collector) => {
const background = theme.getColor(editorBackground);
if (background) {
collector.addRule(`.monaco-editor, .monaco-editor-background { background-color: ${background}; }`);
}
const lineHighlight = theme.getColor(editorLineHighlight);
const imeBackground = (lineHighlight && !lineHighlight.isTransparent() ? lineHighlight : background);
if (imeBackground) {
collector.addRule(`.monaco-editor .inputarea.ime-input { background-color: ${imeBackground}; }`);
}
const foreground = theme.getColor(editorForeground);
if (foreground) {
collector.addRule(`.monaco-editor, .monaco-editor .inputarea.ime-input { color: ${foreground}; }`);
}
const gutter = theme.getColor(editorGutter);
if (gutter) {
collector.addRule(`.monaco-editor .margin { background-color: ${gutter}; }`);
}
const rangeHighlight = theme.getColor(editorRangeHighlight);
if (rangeHighlight) {
collector.addRule(`.monaco-editor .rangeHighlight { background-color: ${rangeHighlight}; }`);
}
const rangeHighlightBorder = theme.getColor(editorRangeHighlightBorder);
if (rangeHighlightBorder) {
collector.addRule(`.monaco-editor .rangeHighlight { border: 1px ${isHighContrast(theme.type) ? 'dotted' : 'solid'} ${rangeHighlightBorder}; }`);
}
const symbolHighlight = theme.getColor(editorSymbolHighlight);
if (symbolHighlight) {
collector.addRule(`.monaco-editor .symbolHighlight { background-color: ${symbolHighlight}; }`);
}
const symbolHighlightBorder = theme.getColor(editorSymbolHighlightBorder);
if (symbolHighlightBorder) {
collector.addRule(`.monaco-editor .symbolHighlight { border: 1px ${isHighContrast(theme.type) ? 'dotted' : 'solid'} ${symbolHighlightBorder}; }`);
}
const invisibles = theme.getColor(editorWhitespaces);
if (invisibles) {
collector.addRule(`.monaco-editor .mtkw { color: ${invisibles} !important; }`);
collector.addRule(`.monaco-editor .mtkz { color: ${invisibles} !important; }`);
}
});

51
src/vs/editor/common/core/eolCounter.ts Normal file
View File

@@ -0,0 +1,51 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CharCode } from 'vs/base/common/charCode';
export const enum StringEOL {
Unknown = 0,
Invalid = 3,
LF = 1,
CRLF = 2
}
export function countEOL(text: string): [number, number, number, StringEOL] {
let eolCount = 0;
let firstLineLength = 0;
let lastLineStart = 0;
let eol: StringEOL = StringEOL.Unknown;
for (let i = 0, len = text.length; i < len; i++) {
const chr = text.charCodeAt(i);
if (chr === CharCode.CarriageReturn) {
if (eolCount === 0) {
firstLineLength = i;
}
eolCount++;
if (i + 1 < len && text.charCodeAt(i + 1) === CharCode.LineFeed) {
// \r\n... case
eol |= StringEOL.CRLF;
i++; // skip \n
} else {
// \r... case
eol |= StringEOL.Invalid;
}
lastLineStart = i + 1;
} else if (chr === CharCode.LineFeed) {
// \n... case
eol |= StringEOL.LF;
if (eolCount === 0) {
firstLineLength = i;
}
eolCount++;
lastLineStart = i + 1;
}
}
if (eolCount === 0) {
firstLineLength = text.length;
}
return [eolCount, firstLineLength, text.length - lastLineStart, eol];
}

40
src/vs/editor/common/core/indentation.ts Normal file
View File

@@ -0,0 +1,40 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as strings from 'vs/base/common/strings';
function _normalizeIndentationFromWhitespace(str: string, indentSize: number, insertSpaces: boolean): string {
let spacesCnt = 0;
for (let i = 0; i < str.length; i++) {
if (str.charAt(i) === '\t') {
spacesCnt += indentSize;
} else {
spacesCnt++;
}
}
let result = '';
if (!insertSpaces) {
const tabsCnt = Math.floor(spacesCnt / indentSize);
spacesCnt = spacesCnt % indentSize;
for (let i = 0; i < tabsCnt; i++) {
result += '\t';
}
}
for (let i = 0; i < spacesCnt; i++) {
result += ' ';
}
return result;
}
export function normalizeIndentation(str: string, indentSize: number, insertSpaces: boolean): string {
let firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(str);
if (firstNonWhitespaceIndex === -1) {
firstNonWhitespaceIndex = str.length;
}
return _normalizeIndentationFromWhitespace(str.substring(0, firstNonWhitespaceIndex), indentSize, insertSpaces) + str.substring(firstNonWhitespaceIndex);
}

8
src/vs/editor/common/core/position.ts
View File

@@ -129,12 +129,12 @@ export class Position {
* A function that compares positions, useful for sorting
*/
public static compare(a: IPosition, b: IPosition): number {
let aLineNumber = a.lineNumber | 0;
let bLineNumber = b.lineNumber | 0;
const aLineNumber = a.lineNumber | 0;
const bLineNumber = b.lineNumber | 0;
if (aLineNumber === bLineNumber) {
let aColumn = a.column | 0;
let bColumn = b.column | 0;
const aColumn = a.column | 0;
const bColumn = b.column | 0;
return aColumn - bColumn;
}

22
src/vs/editor/common/core/range.ts
View File

@@ -100,6 +100,23 @@ export class Range {
return true;
}
/**
* Test if `position` is in `range`. If the position is at the edges, will return false.
* @internal
*/
public static strictContainsPosition(range: IRange, position: IPosition): boolean {
if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
return false;
}
if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {
return false;
}
if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {
return false;
}
return true;
}
/**
* Test if range is in this range. If the range is equal to this range, will return true.
*/
@@ -334,6 +351,7 @@ export class Range {
*/
public static lift(range: undefined | null): null;
public static lift(range: IRange): Range;
public static lift(range: IRange | undefined | null): Range | null;
public static lift(range: IRange | undefined | null): Range | null {
if (!range) {
return null;
@@ -446,4 +464,8 @@ export class Range {
public static spansMultipleLines(range: IRange): boolean {
return range.endLineNumber > range.startLineNumber;
}
public toJSON(): IRange {
return this;
}
}

2
src/vs/editor/common/core/stringBuilder.ts
View File

@@ -72,7 +72,7 @@ function standardDecodeUTF16LE(source: Uint8Array, offset: number, len: number):
}
function compatDecodeUTF16LE(source: Uint8Array, offset: number, len: number): string {
let result: string[] = [];
const result: string[] = [];
let resultLen = 0;
for (let i = 0; i < len; i++) {
const charCode = buffer.readUInt16LE(source, offset); offset += 2;

6
src/vs/editor/common/model/textChange.ts → src/vs/editor/common/core/textChange.ts
View File

@@ -299,7 +299,8 @@ class TextChangeCompressor {
return edits;
}
let result: TextChange[] = [], resultLen = 0;
const result: TextChange[] = [];
let resultLen = 0;
let prev = edits[0];
for (let i = 1; i < edits.length; i++) {
@@ -328,7 +329,8 @@ class TextChangeCompressor {
return edits;
}
let result: TextChange[] = [], resultLen = 0;
const result: TextChange[] = [];
let resultLen = 0;
for (let i = 0; i < edits.length; i++) {
const edit = edits[i];

17
src/vs/editor/common/core/textModelDefaults.ts Normal file
View File

@@ -0,0 +1,17 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
export const EDITOR_MODEL_DEFAULTS = {
tabSize: 4,
indentSize: 4,
insertSpaces: true,
detectIndentation: true,
trimAutoWhitespace: true,
largeFileOptimizations: true,
bracketPairColorizationOptions: {
enabled: true,
independentColorPoolPerBracketType: false,
},
};

54
src/vs/editor/common/core/token.ts
View File

@@ -1,54 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IState } from 'vs/editor/common/modes';
export class Token {
_tokenBrand: void = undefined;
public readonly offset: number;
public readonly type: string;
public readonly language: string;
constructor(offset: number, type: string, language: string) {
this.offset = offset | 0;// @perf
this.type = type;
this.language = language;
}
public toString(): string {
return '(' + this.offset + ', ' + this.type + ')';
}
}
export class TokenizationResult {
_tokenizationResultBrand: void = undefined;
public readonly tokens: Token[];
public readonly endState: IState;
constructor(tokens: Token[], endState: IState) {
this.tokens = tokens;
this.endState = endState;
}
}
export class TokenizationResult2 {
_tokenizationResult2Brand: void = undefined;
/**
* The tokens in binary format. Each token occupies two array indices. For token i:
* - at offset 2*i => startIndex
* - at offset 2*i + 1 => metadata
*
*/
public readonly tokens: Uint32Array;
public readonly endState: IState;
constructor(tokens: Uint32Array, endState: IState) {
this.tokens = tokens;
this.endState = endState;
}
}

2
src/vs/editor/common/controller/wordCharacterClassifier.ts → src/vs/editor/common/core/wordCharacterClassifier.ts
View File

@@ -28,7 +28,7 @@ export class WordCharacterClassifier extends CharacterClassifier<WordCharacterCl
}
function once<R>(computeFn: (input: string) => R): (input: string) => R {
let cache: { [key: string]: R; } = {}; // TODO@Alex unbounded cache
const cache: { [key: string]: R } = {}; // TODO@Alex unbounded cache
return (input: string): R => {
if (!cache.hasOwnProperty(input)) {
cache[input] = computeFn(input);

22
src/vs/editor/common/model/wordHelper.ts → src/vs/editor/common/core/wordHelper.ts
View File

@@ -3,11 +3,27 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IWordAtPosition } from 'vs/editor/common/model';
// {{SQL CARBON EDIT}}
export const USUAL_WORD_SEPARATORS = '`~!#$%^&*()-=+[{]}\\|;:\'",.<>/?';
/**
* Word inside a model.
*/
export interface IWordAtPosition {
/**
* The word.
*/
readonly word: string;
/**
* The column where the word starts.
*/
readonly startColumn: number;
/**
* The column where the word ends.
*/
readonly endColumn: number;
}
/**
* Create a word definition regular expression based on default word separators.
* Optionally provide allowed separators that should be included in words.
@@ -110,7 +126,7 @@ export function getWordAtText(column: number, wordDefinition: RegExp, text: stri
}
if (match) {
let result = {
const result = {
word: match[0],
startColumn: textOffset + 1 + match.index!,
endColumn: textOffset + 1 + match.index! + match[0].length

393
src/vs/editor/common/controller/cursor.ts → src/vs/editor/common/cursor/cursor.ts
View File

@@ -5,119 +5,22 @@
import { onUnexpectedError } from 'vs/base/common/errors';
import * as strings from 'vs/base/common/strings';
import { CursorCollection } from 'vs/editor/common/controller/cursorCollection';
import { CursorColumns, CursorConfiguration, CursorContext, CursorState, EditOperationResult, EditOperationType, IColumnSelectData, PartialCursorState, ICursorSimpleModel } from 'vs/editor/common/controller/cursorCommon';
import { DeleteOperations } from 'vs/editor/common/controller/cursorDeleteOperations';
import { CursorChangeReason } from 'vs/editor/common/controller/cursorEvents';
import { TypeOperations, TypeWithAutoClosingCommand } from 'vs/editor/common/controller/cursorTypeOperations';
import { CursorCollection } from 'vs/editor/common/cursor/cursorCollection';
import { CursorConfiguration, CursorState, EditOperationResult, EditOperationType, IColumnSelectData, PartialCursorState, ICursorSimpleModel } from 'vs/editor/common/cursorCommon';
import { CursorContext } from 'vs/editor/common/cursor/cursorContext';
import { DeleteOperations } from 'vs/editor/common/cursor/cursorDeleteOperations';
import { CursorChangeReason } from 'vs/editor/common/cursorEvents';
import { CompositionOutcome, TypeOperations, TypeWithAutoClosingCommand } from 'vs/editor/common/cursor/cursorTypeOperations';
import { Position } from 'vs/editor/common/core/position';
import { Range, IRange } from 'vs/editor/common/core/range';
import { ISelection, Selection, SelectionDirection } from 'vs/editor/common/core/selection';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { ITextModel, TrackedRangeStickiness, IModelDeltaDecoration, ICursorStateComputer, IIdentifiedSingleEditOperation, IValidEditOperation } from 'vs/editor/common/model';
import { RawContentChangedType, ModelRawContentChangedEvent, ModelInjectedTextChangedEvent } from 'vs/editor/common/model/textModelEvents';
import { VerticalRevealType, ViewCursorStateChangedEvent, ViewRevealRangeRequestEvent } from 'vs/editor/common/view/viewEvents';
import { RawContentChangedType, ModelInjectedTextChangedEvent, InternalModelContentChangeEvent } from 'vs/editor/common/textModelEvents';
import { VerticalRevealType, ViewCursorStateChangedEvent, ViewRevealRangeRequestEvent } from 'vs/editor/common/viewEvents';
import { dispose, Disposable } from 'vs/base/common/lifecycle';
import { ICoordinatesConverter } from 'vs/editor/common/viewModel/viewModel';
import { CursorStateChangedEvent, ViewModelEventsCollector } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
/**
* A snapshot of the cursor and the model state
*/
export class CursorModelState {
public readonly modelVersionId: number;
public readonly cursorState: CursorState[];
constructor(model: ITextModel, cursor: CursorsController) {
this.modelVersionId = model.getVersionId();
this.cursorState = cursor.getCursorStates();
}
public equals(other: CursorModelState | null): boolean {
if (!other) {
return false;
}
if (this.modelVersionId !== other.modelVersionId) {
return false;
}
if (this.cursorState.length !== other.cursorState.length) {
return false;
}
for (let i = 0, len = this.cursorState.length; i < len; i++) {
if (!this.cursorState[i].equals(other.cursorState[i])) {
return false;
}
}
return true;
}
}
class AutoClosedAction {
public static getAllAutoClosedCharacters(autoClosedActions: AutoClosedAction[]): Range[] {
let autoClosedCharacters: Range[] = [];
for (const autoClosedAction of autoClosedActions) {
autoClosedCharacters = autoClosedCharacters.concat(autoClosedAction.getAutoClosedCharactersRanges());
}
return autoClosedCharacters;
}
private readonly _model: ITextModel;
private _autoClosedCharactersDecorations: string[];
private _autoClosedEnclosingDecorations: string[];
constructor(model: ITextModel, autoClosedCharactersDecorations: string[], autoClosedEnclosingDecorations: string[]) {
this._model = model;
this._autoClosedCharactersDecorations = autoClosedCharactersDecorations;
this._autoClosedEnclosingDecorations = autoClosedEnclosingDecorations;
}
public dispose(): void {
this._autoClosedCharactersDecorations = this._model.deltaDecorations(this._autoClosedCharactersDecorations, []);
this._autoClosedEnclosingDecorations = this._model.deltaDecorations(this._autoClosedEnclosingDecorations, []);
}
public getAutoClosedCharactersRanges(): Range[] {
let result: Range[] = [];
for (let i = 0; i < this._autoClosedCharactersDecorations.length; i++) {
const decorationRange = this._model.getDecorationRange(this._autoClosedCharactersDecorations[i]);
if (decorationRange) {
result.push(decorationRange);
}
}
return result;
}
public isValid(selections: Range[]): boolean {
let enclosingRanges: Range[] = [];
for (let i = 0; i < this._autoClosedEnclosingDecorations.length; i++) {
const decorationRange = this._model.getDecorationRange(this._autoClosedEnclosingDecorations[i]);
if (decorationRange) {
enclosingRanges.push(decorationRange);
if (decorationRange.startLineNumber !== decorationRange.endLineNumber) {
// Stop tracking if the range becomes multiline...
return false;
}
}
}
enclosingRanges.sort(Range.compareRangesUsingStarts);
selections.sort(Range.compareRangesUsingStarts);
for (let i = 0; i < selections.length; i++) {
if (i >= enclosingRanges.length) {
return false;
}
if (!enclosingRanges[i].strictContainsRange(selections[i])) {
return false;
}
}
return true;
}
}
import { ICoordinatesConverter } from 'vs/editor/common/viewModel';
import { CursorStateChangedEvent, ViewModelEventsCollector } from 'vs/editor/common/viewModelEventDispatcher';
export class CursorsController extends Disposable {
@@ -132,8 +35,7 @@ export class CursorsController extends Disposable {
private _hasFocus: boolean;
private _isHandling: boolean;
private _isDoingComposition: boolean;
private _selectionsWhenCompositionStarted: Selection[] | null;
private _compositionState: CompositionState | null;
private _columnSelectData: IColumnSelectData | null;
private _autoClosedActions: AutoClosedAction[];
private _prevEditOperationType: EditOperationType;
@@ -149,8 +51,7 @@ export class CursorsController extends Disposable {
this._hasFocus = false;
this._isHandling = false;
this._isDoingComposition = false;
this._selectionsWhenCompositionStarted = null;
this._compositionState = null;
this._columnSelectData = null;
this._autoClosedActions = [];
this._prevEditOperationType = EditOperationType.Other;
@@ -188,7 +89,7 @@ export class CursorsController extends Disposable {
private _validateAutoClosedActions(): void {
if (this._autoClosedActions.length > 0) {
let selections: Range[] = this._cursors.getSelections();
const selections: Range[] = this._cursors.getSelections();
for (let i = 0; i < this._autoClosedActions.length; i++) {
const autoClosedAction = this._autoClosedActions[i];
if (!autoClosedAction.isValid(selections)) {
@@ -221,7 +122,7 @@ export class CursorsController extends Disposable {
reachedMaxCursorCount = true;
}
const oldState = new CursorModelState(this._model, this);
const oldState = CursorModelState.from(this._model, this);
this._cursors.setStates(states);
this._cursors.normalize();
@@ -236,36 +137,23 @@ export class CursorsController extends Disposable {
this._columnSelectData = columnSelectData;
}
public revealPrimary(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, revealHorizontal: boolean, scrollType: editorCommon.ScrollType): void {
public revealPrimary(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, minimalReveal: boolean, verticalType: VerticalRevealType, revealHorizontal: boolean, scrollType: editorCommon.ScrollType): void {
const viewPositions = this._cursors.getViewPositions();
if (viewPositions.length > 1) {
this._emitCursorRevealRange(eventsCollector, source, null, this._cursors.getViewSelections(), VerticalRevealType.Simple, revealHorizontal, scrollType);
return;
} else {
const viewPosition = viewPositions[0];
const viewRange = new Range(viewPosition.lineNumber, viewPosition.column, viewPosition.lineNumber, viewPosition.column);
this._emitCursorRevealRange(eventsCollector, source, viewRange, null, VerticalRevealType.Simple, revealHorizontal, scrollType);
}
}
private _revealPrimaryCursor(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, verticalType: VerticalRevealType, revealHorizontal: boolean, scrollType: editorCommon.ScrollType): void {
const viewPositions = this._cursors.getViewPositions();
let revealViewRange: Range | null = null;
let revealViewSelections: Selection[] | null = null;
if (viewPositions.length > 1) {
this._emitCursorRevealRange(eventsCollector, source, null, this._cursors.getViewSelections(), verticalType, revealHorizontal, scrollType);
revealViewSelections = this._cursors.getViewSelections();
} else {
const viewPosition = viewPositions[0];
const viewRange = new Range(viewPosition.lineNumber, viewPosition.column, viewPosition.lineNumber, viewPosition.column);
this._emitCursorRevealRange(eventsCollector, source, viewRange, null, verticalType, revealHorizontal, scrollType);
revealViewRange = Range.fromPositions(viewPositions[0], viewPositions[0]);
}
}
private _emitCursorRevealRange(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, viewRange: Range | null, viewSelections: Selection[] | null, verticalType: VerticalRevealType, revealHorizontal: boolean, scrollType: editorCommon.ScrollType) {
eventsCollector.emitViewEvent(new ViewRevealRangeRequestEvent(source, viewRange, viewSelections, verticalType, revealHorizontal, scrollType));
eventsCollector.emitViewEvent(new ViewRevealRangeRequestEvent(source, minimalReveal, revealViewRange, revealViewSelections, verticalType, revealHorizontal, scrollType));
}
public saveState(): editorCommon.ICursorState[] {
let result: editorCommon.ICursorState[] = [];
const result: editorCommon.ICursorState[] = [];
const selections = this._cursors.getSelections();
for (let i = 0, len = selections.length; i < len; i++) {
@@ -289,7 +177,7 @@ export class CursorsController extends Disposable {
public restoreState(eventsCollector: ViewModelEventsCollector, states: editorCommon.ICursorState[]): void {
let desiredSelections: ISelection[] = [];
const desiredSelections: ISelection[] = [];
for (let i = 0, len = states.length; i < len; i++) {
const state = states[i];
@@ -325,11 +213,11 @@ export class CursorsController extends Disposable {
}
this.setStates(eventsCollector, 'restoreState', CursorChangeReason.NotSet, CursorState.fromModelSelections(desiredSelections));
this.revealPrimary(eventsCollector, 'restoreState', true, editorCommon.ScrollType.Immediate);
this.revealPrimary(eventsCollector, 'restoreState', false, VerticalRevealType.Simple, true, editorCommon.ScrollType.Immediate);
}
public onModelContentChanged(eventsCollector: ViewModelEventsCollector, e: ModelRawContentChangedEvent | ModelInjectedTextChangedEvent): void {
if (e instanceof ModelInjectedTextChangedEvent) {
public onModelContentChanged(eventsCollector: ViewModelEventsCollector, event: InternalModelContentChangeEvent | ModelInjectedTextChangedEvent): void {
if (event instanceof ModelInjectedTextChangedEvent) {
// If injected texts change, the view positions of all cursors need to be updated.
if (this._isHandling) {
// The view positions will be updated when handling finishes
@@ -346,6 +234,7 @@ export class CursorsController extends Disposable {
this._isHandling = false;
}
} else {
const e = event.rawContentChangedEvent;
this._knownModelVersionId = e.versionId;
if (this._isHandling) {
return;
@@ -364,7 +253,7 @@ export class CursorsController extends Disposable {
if (this._hasFocus && e.resultingSelection && e.resultingSelection.length > 0) {
const cursorState = CursorState.fromModelSelections(e.resultingSelection);
if (this.setStates(eventsCollector, 'modelChange', e.isUndoing ? CursorChangeReason.Undo : e.isRedoing ? CursorChangeReason.Redo : CursorChangeReason.RecoverFromMarkers, cursorState)) {
this._revealPrimaryCursor(eventsCollector, 'modelChange', VerticalRevealType.Simple, true, editorCommon.ScrollType.Smooth);
this.revealPrimary(eventsCollector, 'modelChange', false, VerticalRevealType.Simple, true, editorCommon.ScrollType.Smooth);
}
} else {
const selectionsFromMarkers = this._cursors.readSelectionFromMarkers();
@@ -396,9 +285,9 @@ export class CursorsController extends Disposable {
return {
isReal: false,
fromViewLineNumber: viewSelectionStart.lineNumber,
fromViewVisualColumn: CursorColumns.visibleColumnFromColumn2(this.context.cursorConfig, this._viewModel, viewSelectionStart),
fromViewVisualColumn: this.context.cursorConfig.visibleColumnFromColumn(this._viewModel, viewSelectionStart),
toViewLineNumber: viewPosition.lineNumber,
toViewVisualColumn: CursorColumns.visibleColumnFromColumn2(this.context.cursorConfig, this._viewModel, viewPosition),
toViewVisualColumn: this.context.cursorConfig.visibleColumnFromColumn(this._viewModel, viewPosition),
};
}
@@ -425,8 +314,8 @@ export class CursorsController extends Disposable {
// ------ auxiliary handling logic
private _pushAutoClosedAction(autoClosedCharactersRanges: Range[], autoClosedEnclosingRanges: Range[]): void {
let autoClosedCharactersDeltaDecorations: IModelDeltaDecoration[] = [];
let autoClosedEnclosingDeltaDecorations: IModelDeltaDecoration[] = [];
const autoClosedCharactersDeltaDecorations: IModelDeltaDecoration[] = [];
const autoClosedEnclosingDeltaDecorations: IModelDeltaDecoration[] = [];
for (let i = 0, len = autoClosedCharactersRanges.length; i < len; i++) {
autoClosedCharactersDeltaDecorations.push({
@@ -468,8 +357,8 @@ export class CursorsController extends Disposable {
this._interpretCommandResult(result);
// Check for auto-closing closed characters
let autoClosedCharactersRanges: Range[] = [];
let autoClosedEnclosingRanges: Range[] = [];
const autoClosedCharactersRanges: Range[] = [];
const autoClosedEnclosingRanges: Range[] = [];
for (let i = 0; i < opResult.commands.length; i++) {
const command = opResult.commands[i];
@@ -505,7 +394,7 @@ export class CursorsController extends Disposable {
// ----- emitting events
private _emitStateChangedIfNecessary(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, reason: CursorChangeReason, oldState: CursorModelState | null, reachedMaxCursorCount: boolean): boolean {
const newState = new CursorModelState(this._model, this);
const newState = CursorModelState.from(this._model, this);
if (newState.equals(oldState)) {
return false;
}
@@ -537,7 +426,7 @@ export class CursorsController extends Disposable {
return null;
}
let indices: [number, number][] = [];
const indices: [number, number][] = [];
for (let i = 0, len = edits.length; i < len; i++) {
const edit = edits[i];
if (!edit.text || edit.text.indexOf('\n') >= 0) {
@@ -577,8 +466,8 @@ export class CursorsController extends Disposable {
if (autoClosingIndices) {
edits[0]._isTracked = true;
}
let autoClosedCharactersRanges: Range[] = [];
let autoClosedEnclosingRanges: Range[] = [];
const autoClosedCharactersRanges: Range[] = [];
const autoClosedEnclosingRanges: Range[] = [];
const selections = this._model.pushEditOperations(this.getSelections(), edits, (undoEdits) => {
if (autoClosingIndices) {
for (let i = 0, len = autoClosingIndices.length; i < len; i++) {
@@ -616,7 +505,7 @@ export class CursorsController extends Disposable {
return;
}
const oldState = new CursorModelState(this._model, this);
const oldState = CursorModelState.from(this._model, this);
this._cursors.stopTrackingSelections();
this._isHandling = true;
@@ -631,28 +520,26 @@ export class CursorsController extends Disposable {
this._cursors.startTrackingSelections();
this._validateAutoClosedActions();
if (this._emitStateChangedIfNecessary(eventsCollector, source, cursorChangeReason, oldState, false)) {
this._revealPrimaryCursor(eventsCollector, source, VerticalRevealType.Simple, true, editorCommon.ScrollType.Smooth);
this.revealPrimary(eventsCollector, source, false, VerticalRevealType.Simple, true, editorCommon.ScrollType.Smooth);
}
}
public setIsDoingComposition(isDoingComposition: boolean): void {
this._isDoingComposition = isDoingComposition;
}
public getAutoClosedCharacters(): Range[] {
return AutoClosedAction.getAllAutoClosedCharacters(this._autoClosedActions);
}
public startComposition(eventsCollector: ViewModelEventsCollector): void {
this._selectionsWhenCompositionStarted = this.getSelections().slice(0);
this._compositionState = new CompositionState(this._model, this.getSelections());
}
public endComposition(eventsCollector: ViewModelEventsCollector, source?: string | null | undefined): void {
const compositionOutcome = this._compositionState ? this._compositionState.deduceOutcome(this._model, this.getSelections()) : null;
this._compositionState = null;
this._executeEdit(() => {
if (source === 'keyboard') {
// composition finishes, let's check if we need to auto complete if necessary.
this._executeEditOperation(TypeOperations.compositionEndWithInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, this._selectionsWhenCompositionStarted, this.getSelections(), this.getAutoClosedCharacters()));
this._selectionsWhenCompositionStarted = null;
this._executeEditOperation(TypeOperations.compositionEndWithInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, compositionOutcome, this.getSelections(), this.getAutoClosedCharacters()));
}
}, eventsCollector, source);
}
@@ -669,7 +556,7 @@ export class CursorsController extends Disposable {
const chr = text.substr(offset, charLength);
// Here we must interpret each typed character individually
this._executeEditOperation(TypeOperations.typeWithInterceptors(this._isDoingComposition, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), this.getAutoClosedCharacters(), chr));
this._executeEditOperation(TypeOperations.typeWithInterceptors(!!this._compositionState, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), this.getAutoClosedCharacters(), chr));
offset += charLength;
}
@@ -731,6 +618,105 @@ export class CursorsController extends Disposable {
}
}
/**
* A snapshot of the cursor and the model state
*/
class CursorModelState {
public static from(model: ITextModel, cursor: CursorsController): CursorModelState {
return new CursorModelState(model.getVersionId(), cursor.getCursorStates());
}
constructor(
public readonly modelVersionId: number,
public readonly cursorState: CursorState[],
) {
}
public equals(other: CursorModelState | null): boolean {
if (!other) {
return false;
}
if (this.modelVersionId !== other.modelVersionId) {
return false;
}
if (this.cursorState.length !== other.cursorState.length) {
return false;
}
for (let i = 0, len = this.cursorState.length; i < len; i++) {
if (!this.cursorState[i].equals(other.cursorState[i])) {
return false;
}
}
return true;
}
}
class AutoClosedAction {
public static getAllAutoClosedCharacters(autoClosedActions: AutoClosedAction[]): Range[] {
let autoClosedCharacters: Range[] = [];
for (const autoClosedAction of autoClosedActions) {
autoClosedCharacters = autoClosedCharacters.concat(autoClosedAction.getAutoClosedCharactersRanges());
}
return autoClosedCharacters;
}
private readonly _model: ITextModel;
private _autoClosedCharactersDecorations: string[];
private _autoClosedEnclosingDecorations: string[];
constructor(model: ITextModel, autoClosedCharactersDecorations: string[], autoClosedEnclosingDecorations: string[]) {
this._model = model;
this._autoClosedCharactersDecorations = autoClosedCharactersDecorations;
this._autoClosedEnclosingDecorations = autoClosedEnclosingDecorations;
}
public dispose(): void {
this._autoClosedCharactersDecorations = this._model.deltaDecorations(this._autoClosedCharactersDecorations, []);
this._autoClosedEnclosingDecorations = this._model.deltaDecorations(this._autoClosedEnclosingDecorations, []);
}
public getAutoClosedCharactersRanges(): Range[] {
const result: Range[] = [];
for (let i = 0; i < this._autoClosedCharactersDecorations.length; i++) {
const decorationRange = this._model.getDecorationRange(this._autoClosedCharactersDecorations[i]);
if (decorationRange) {
result.push(decorationRange);
}
}
return result;
}
public isValid(selections: Range[]): boolean {
const enclosingRanges: Range[] = [];
for (let i = 0; i < this._autoClosedEnclosingDecorations.length; i++) {
const decorationRange = this._model.getDecorationRange(this._autoClosedEnclosingDecorations[i]);
if (decorationRange) {
enclosingRanges.push(decorationRange);
if (decorationRange.startLineNumber !== decorationRange.endLineNumber) {
// Stop tracking if the range becomes multiline...
return false;
}
}
}
enclosingRanges.sort(Range.compareRangesUsingStarts);
selections.sort(Range.compareRangesUsingStarts);
for (let i = 0; i < selections.length; i++) {
if (i >= enclosingRanges.length) {
return false;
}
if (!enclosingRanges[i].strictContainsRange(selections[i])) {
return false;
}
}
return true;
}
}
interface IExecContext {
readonly model: ITextModel;
readonly selectionsBefore: Selection[];
@@ -789,7 +775,7 @@ class CommandExecutor {
}
// Remove operations belonging to losing cursors
let filteredOperations: IIdentifiedSingleEditOperation[] = [];
const filteredOperations: IIdentifiedSingleEditOperation[] = [];
for (let i = 0, len = rawOperations.length; i < len; i++) {
if (!loserCursorsMap.hasOwnProperty(rawOperations[i].identifier!.major.toString())) {
filteredOperations.push(rawOperations[i]);
@@ -802,7 +788,7 @@ class CommandExecutor {
filteredOperations[0]._isTracked = true;
}
let selectionsAfter = ctx.model.pushEditOperations(ctx.selectionsBefore, filteredOperations, (inverseEditOperations: IValidEditOperation[]): Selection[] => {
let groupedInverseEditOperations: IValidEditOperation[][] = [];
const groupedInverseEditOperations: IValidEditOperation[][] = [];
for (let i = 0; i < ctx.selectionsBefore.length; i++) {
groupedInverseEditOperations[i] = [];
}
@@ -816,7 +802,7 @@ class CommandExecutor {
const minorBasedSorter = (a: IValidEditOperation, b: IValidEditOperation) => {
return a.identifier!.minor - b.identifier!.minor;
};
let cursorSelections: Selection[] = [];
const cursorSelections: Selection[] = [];
for (let i = 0; i < ctx.selectionsBefore.length; i++) {
if (groupedInverseEditOperations[i].length > 0) {
groupedInverseEditOperations[i].sort(minorBasedSorter);
@@ -845,7 +831,7 @@ class CommandExecutor {
}
// Extract losing cursors
let losingCursors: number[] = [];
const losingCursors: number[] = [];
for (let losingCursorIndex in loserCursorsMap) {
if (loserCursorsMap.hasOwnProperty(losingCursorIndex)) {
losingCursors.push(parseInt(losingCursorIndex, 10));
@@ -895,7 +881,7 @@ class CommandExecutor {
private static _getEditOperationsFromCommand(ctx: IExecContext, majorIdentifier: number, command: editorCommon.ICommand): ICommandData {
// This method acts as a transaction, if the command fails
// everything it has done is ignored
let operations: IIdentifiedSingleEditOperation[] = [];
const operations: IIdentifiedSingleEditOperation[] = [];
let operationMinor = 0;
const addEditOperation = (range: IRange, text: string | null, forceMoveMarkers: boolean = false) => {
@@ -975,7 +961,7 @@ class CommandExecutor {
};
}
private static _getLoserCursorMap(operations: IIdentifiedSingleEditOperation[]): { [index: string]: boolean; } {
private static _getLoserCursorMap(operations: IIdentifiedSingleEditOperation[]): { [index: string]: boolean } {
// This is destructive on the array
operations = operations.slice(0);
@@ -986,7 +972,7 @@ class CommandExecutor {
});
// Operations can not overlap!
let loserCursorsMap: { [index: string]: boolean; } = {};
const loserCursorsMap: { [index: string]: boolean } = {};
for (let i = 1; i < operations.length; i++) {
const previousOp = operations[i - 1];
@@ -1024,3 +1010,80 @@ class CommandExecutor {
return loserCursorsMap;
}
}
class CompositionLineState {
constructor(
public readonly text: string,
public readonly startSelection: number,
public readonly endSelection: number
) { }
}
class CompositionState {
private readonly _original: CompositionLineState[] | null;
private static _capture(textModel: ITextModel, selections: Selection[]): CompositionLineState[] | null {
const result: CompositionLineState[] = [];
for (const selection of selections) {
if (selection.startLineNumber !== selection.endLineNumber) {
return null;
}
result.push(new CompositionLineState(
textModel.getLineContent(selection.startLineNumber),
selection.startColumn - 1,
selection.endColumn - 1
));
}
return result;
}
constructor(textModel: ITextModel, selections: Selection[]) {
this._original = CompositionState._capture(textModel, selections);
}
/**
* Returns the inserted text during this composition.
* If the composition resulted in existing text being changed (i.e. not a pure insertion) it returns null.
*/
deduceOutcome(textModel: ITextModel, selections: Selection[]): CompositionOutcome[] | null {
if (!this._original) {
return null;
}
const current = CompositionState._capture(textModel, selections);
if (!current) {
return null;
}
if (this._original.length !== current.length) {
return null;
}
const result: CompositionOutcome[] = [];
for (let i = 0, len = this._original.length; i < len; i++) {
result.push(CompositionState._deduceOutcome(this._original[i], current[i]));
}
return result;
}
private static _deduceOutcome(original: CompositionLineState, current: CompositionLineState): CompositionOutcome {
const commonPrefix = Math.min(
original.startSelection,
current.startSelection,
strings.commonPrefixLength(original.text, current.text)
);
const commonSuffix = Math.min(
original.text.length - original.endSelection,
current.text.length - current.endSelection,
strings.commonSuffixLength(original.text, current.text)
);
const deletedText = original.text.substring(commonPrefix, original.text.length - commonSuffix);
const insertedText = current.text.substring(commonPrefix, current.text.length - commonSuffix);
return new CompositionOutcome(
deletedText,
original.startSelection - commonPrefix,
original.endSelection - commonPrefix,
insertedText,
current.startSelection - commonPrefix,
current.endSelection - commonPrefix
);
}
}

2
src/vs/editor/common/controller/cursorAtomicMoveOperations.ts → src/vs/editor/common/cursor/cursorAtomicMoveOperations.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { CharCode } from 'vs/base/common/charCode';
import { CursorColumns } from 'vs/editor/common/controller/cursorCommon';
import { CursorColumns } from 'vs/editor/common/core/cursorColumns';
export const enum Direction {
Left,

144
src/vs/editor/common/controller/cursorCollection.ts → src/vs/editor/common/cursor/cursorCollection.ts
View File

@@ -3,44 +3,49 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CursorContext, CursorState, PartialCursorState } from 'vs/editor/common/controller/cursorCommon';
import { Cursor } from 'vs/editor/common/controller/oneCursor';
import { compareBy, findLastMaxBy, findMinBy } from 'vs/base/common/arrays';
import { CursorState, PartialCursorState } from 'vs/editor/common/cursorCommon';
import { CursorContext } from 'vs/editor/common/cursor/cursorContext';
import { Cursor } from 'vs/editor/common/cursor/oneCursor';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { ISelection, Selection } from 'vs/editor/common/core/selection';
export class CursorCollection {
private context: CursorContext;
private primaryCursor: Cursor;
private secondaryCursors: Cursor[];
/**
* `cursors[0]` is the primary cursor, thus `cursors.length >= 1` is always true.
* `cursors.slice(1)` are secondary cursors.
*/
private cursors: Cursor[];
// An index which identifies the last cursor that was added / moved (think Ctrl+drag)
// This index refers to `cursors.slice(1)`, i.e. after removing the primary cursor.
private lastAddedCursorIndex: number;
constructor(context: CursorContext) {
this.context = context;
this.primaryCursor = new Cursor(context);
this.secondaryCursors = [];
this.cursors = [new Cursor(context)];
this.lastAddedCursorIndex = 0;
}
public dispose(): void {
this.primaryCursor.dispose(this.context);
this.killSecondaryCursors();
for (const cursor of this.cursors) {
cursor.dispose(this.context);
}
}
public startTrackingSelections(): void {
this.primaryCursor.startTrackingSelection(this.context);
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
this.secondaryCursors[i].startTrackingSelection(this.context);
for (const cursor of this.cursors) {
cursor.startTrackingSelection(this.context);
}
}
public stopTrackingSelections(): void {
this.primaryCursor.stopTrackingSelection(this.context);
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
this.secondaryCursors[i].stopTrackingSelection(this.context);
for (const cursor of this.cursors) {
cursor.stopTrackingSelection(this.context);
}
}
@@ -49,77 +54,43 @@ export class CursorCollection {
}
public ensureValidState(): void {
this.primaryCursor.ensureValidState(this.context);
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
this.secondaryCursors[i].ensureValidState(this.context);
for (const cursor of this.cursors) {
cursor.ensureValidState(this.context);
}
}
public readSelectionFromMarkers(): Selection[] {
let result: Selection[] = [];
result[0] = this.primaryCursor.readSelectionFromMarkers(this.context);
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i].readSelectionFromMarkers(this.context);
}
return result;
return this.cursors.map(c => c.readSelectionFromMarkers(this.context));
}
public getAll(): CursorState[] {
let result: CursorState[] = [];
result[0] = this.primaryCursor.asCursorState();
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i].asCursorState();
}
return result;
return this.cursors.map(c => c.asCursorState());
}
public getViewPositions(): Position[] {
let result: Position[] = [];
result[0] = this.primaryCursor.viewState.position;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i].viewState.position;
}
return result;
return this.cursors.map(c => c.viewState.position);
}
public getTopMostViewPosition(): Position {
let result = this.primaryCursor.viewState.position;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
const viewPosition = this.secondaryCursors[i].viewState.position;
if (viewPosition.isBefore(result)) {
result = viewPosition;
}
}
return result;
return findMinBy(
this.cursors,
compareBy(c => c.viewState.position, Position.compare)
)!.viewState.position;
}
public getBottomMostViewPosition(): Position {
let result = this.primaryCursor.viewState.position;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
const viewPosition = this.secondaryCursors[i].viewState.position;
if (result.isBeforeOrEqual(viewPosition)) {
result = viewPosition;
}
}
return result;
return findLastMaxBy(
this.cursors,
compareBy(c => c.viewState.position, Position.compare)
)!.viewState.position;
}
public getSelections(): Selection[] {
let result: Selection[] = [];
result[0] = this.primaryCursor.modelState.selection;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i].modelState.selection;
}
return result;
return this.cursors.map(c => c.modelState.selection);
}
public getViewSelections(): Selection[] {
let result: Selection[] = [];
result[0] = this.primaryCursor.viewState.selection;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i].viewState.selection;
}
return result;
return this.cursors.map(c => c.viewState.selection);
}
public setSelections(selections: ISelection[]): void {
@@ -127,14 +98,14 @@ export class CursorCollection {
}
public getPrimaryCursor(): CursorState {
return this.primaryCursor.asCursorState();
return this.cursors[0].asCursorState();
}
public setStates(states: PartialCursorState[] | null): void {
if (states === null) {
return;
}
this.primaryCursor.setState(this.context, states[0].modelState, states[0].viewState);
this.cursors[0].setState(this.context, states[0].modelState, states[0].viewState);
this._setSecondaryStates(states.slice(1));
}
@@ -142,23 +113,23 @@ export class CursorCollection {
* Creates or disposes secondary cursors as necessary to match the number of `secondarySelections`.
*/
private _setSecondaryStates(secondaryStates: PartialCursorState[]): void {
const secondaryCursorsLength = this.secondaryCursors.length;
const secondaryCursorsLength = this.cursors.length - 1;
const secondaryStatesLength = secondaryStates.length;
if (secondaryCursorsLength < secondaryStatesLength) {
let createCnt = secondaryStatesLength - secondaryCursorsLength;
const createCnt = secondaryStatesLength - secondaryCursorsLength;
for (let i = 0; i < createCnt; i++) {
this._addSecondaryCursor();
}
} else if (secondaryCursorsLength > secondaryStatesLength) {
let removeCnt = secondaryCursorsLength - secondaryStatesLength;
const removeCnt = secondaryCursorsLength - secondaryStatesLength;
for (let i = 0; i < removeCnt; i++) {
this._removeSecondaryCursor(this.secondaryCursors.length - 1);
this._removeSecondaryCursor(this.cursors.length - 2);
}
}
for (let i = 0; i < secondaryStatesLength; i++) {
this.secondaryCursors[i].setState(this.context, secondaryStates[i].modelState, secondaryStates[i].viewState);
this.cursors[i + 1].setState(this.context, secondaryStates[i].modelState, secondaryStates[i].viewState);
}
}
@@ -167,12 +138,12 @@ export class CursorCollection {
}
private _addSecondaryCursor(): void {
this.secondaryCursors.push(new Cursor(this.context));
this.lastAddedCursorIndex = this.secondaryCursors.length;
this.cursors.push(new Cursor(this.context));
this.lastAddedCursorIndex = this.cursors.length - 1;
}
public getLastAddedCursorIndex(): number {
if (this.secondaryCursors.length === 0 || this.lastAddedCursorIndex === 0) {
if (this.cursors.length === 1 || this.lastAddedCursorIndex === 0) {
return 0;
}
return this.lastAddedCursorIndex;
@@ -182,42 +153,29 @@ export class CursorCollection {
if (this.lastAddedCursorIndex >= removeIndex + 1) {
this.lastAddedCursorIndex--;
}
this.secondaryCursors[removeIndex].dispose(this.context);
this.secondaryCursors.splice(removeIndex, 1);
}
private _getAll(): Cursor[] {
let result: Cursor[] = [];
result[0] = this.primaryCursor;
for (let i = 0, len = this.secondaryCursors.length; i < len; i++) {
result[i + 1] = this.secondaryCursors[i];
}
return result;
this.cursors[removeIndex + 1].dispose(this.context);
this.cursors.splice(removeIndex + 1, 1);
}
public normalize(): void {
if (this.secondaryCursors.length === 0) {
if (this.cursors.length === 1) {
return;
}
let cursors = this._getAll();
const cursors = this.cursors.slice(0);
interface SortedCursor {
index: number;
selection: Selection;
}
let sortedCursors: SortedCursor[] = [];
const sortedCursors: SortedCursor[] = [];
for (let i = 0, len = cursors.length; i < len; i++) {
sortedCursors.push({
index: i,
selection: cursors[i].modelState.selection,
});
}
sortedCursors.sort((a, b) => {
if (a.selection.startLineNumber === b.selection.startLineNumber) {
return a.selection.startColumn - b.selection.startColumn;
}
return a.selection.startLineNumber - b.selection.startLineNumber;
});
sortedCursors.sort(compareBy(s => s.selection, Range.compareRangesUsingStarts));
for (let sortedCursorIndex = 0; sortedCursorIndex < sortedCursors.length - 1; sortedCursorIndex++) {
const current = sortedCursors[sortedCursorIndex];

42
src/vs/editor/common/controller/cursorColumnSelection.ts → src/vs/editor/common/cursor/cursorColumnSelection.ts
View File

@@ -3,38 +3,29 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CursorColumns, CursorConfiguration, ICursorSimpleModel, SingleCursorState, IColumnSelectData } from 'vs/editor/common/controller/cursorCommon';
import { CursorConfiguration, ICursorSimpleModel, SingleCursorState, IColumnSelectData } from 'vs/editor/common/cursorCommon';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
export interface IColumnSelectResult {
viewStates: SingleCursorState[];
reversed: boolean;
fromLineNumber: number;
fromVisualColumn: number;
toLineNumber: number;
toVisualColumn: number;
}
export class ColumnSelection {
public static columnSelect(config: CursorConfiguration, model: ICursorSimpleModel, fromLineNumber: number, fromVisibleColumn: number, toLineNumber: number, toVisibleColumn: number): IColumnSelectResult {
let lineCount = Math.abs(toLineNumber - fromLineNumber) + 1;
let reversed = (fromLineNumber > toLineNumber);
let isRTL = (fromVisibleColumn > toVisibleColumn);
let isLTR = (fromVisibleColumn < toVisibleColumn);
const lineCount = Math.abs(toLineNumber - fromLineNumber) + 1;
const reversed = (fromLineNumber > toLineNumber);
const isRTL = (fromVisibleColumn > toVisibleColumn);
const isLTR = (fromVisibleColumn < toVisibleColumn);
let result: SingleCursorState[] = [];
const result: SingleCursorState[] = [];
// console.log(`fromVisibleColumn: ${fromVisibleColumn}, toVisibleColumn: ${toVisibleColumn}`);
for (let i = 0; i < lineCount; i++) {
let lineNumber = fromLineNumber + (reversed ? -i : i);
const lineNumber = fromLineNumber + (reversed ? -i : i);
let startColumn = CursorColumns.columnFromVisibleColumn2(config, model, lineNumber, fromVisibleColumn);
let endColumn = CursorColumns.columnFromVisibleColumn2(config, model, lineNumber, toVisibleColumn);
let visibleStartColumn = CursorColumns.visibleColumnFromColumn2(config, model, new Position(lineNumber, startColumn));
let visibleEndColumn = CursorColumns.visibleColumnFromColumn2(config, model, new Position(lineNumber, endColumn));
const startColumn = config.columnFromVisibleColumn(model, lineNumber, fromVisibleColumn);
const endColumn = config.columnFromVisibleColumn(model, lineNumber, toVisibleColumn);
const visibleStartColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, startColumn));
const visibleEndColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, endColumn));
// console.log(`lineNumber: ${lineNumber}: visibleStartColumn: ${visibleStartColumn}, visibleEndColumn: ${visibleEndColumn}`);
@@ -100,7 +91,7 @@ export class ColumnSelection {
const maxViewLineNumber = Math.max(prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.toViewLineNumber);
for (let lineNumber = minViewLineNumber; lineNumber <= maxViewLineNumber; lineNumber++) {
const lineMaxViewColumn = model.getLineMaxColumn(lineNumber);
const lineMaxVisualViewColumn = CursorColumns.visibleColumnFromColumn2(config, model, new Position(lineNumber, lineMaxViewColumn));
const lineMaxVisualViewColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, lineMaxViewColumn));
maxVisualViewColumn = Math.max(maxVisualViewColumn, lineMaxVisualViewColumn);
}
@@ -124,3 +115,12 @@ export class ColumnSelection {
return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, toViewLineNumber, prevColumnSelectData.toViewVisualColumn);
}
}
export interface IColumnSelectResult {
viewStates: SingleCursorState[];
reversed: boolean;
fromLineNumber: number;
fromVisualColumn: number;
toLineNumber: number;
toVisualColumn: number;
}

24
src/vs/editor/common/cursor/cursorContext.ts Normal file
View File

@@ -0,0 +1,24 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ITextModel } from 'vs/editor/common/model';
import { ICoordinatesConverter } from 'vs/editor/common/viewModel';
import { CursorConfiguration, ICursorSimpleModel } from 'vs/editor/common/cursorCommon';
export class CursorContext {
_cursorContextBrand: void = undefined;
public readonly model: ITextModel;
public readonly viewModel: ICursorSimpleModel;
public readonly coordinatesConverter: ICoordinatesConverter;
public readonly cursorConfig: CursorConfiguration;
constructor(model: ITextModel, viewModel: ICursorSimpleModel, coordinatesConverter: ICoordinatesConverter, cursorConfig: CursorConfiguration) {
this.model = model;
this.viewModel = viewModel;
this.coordinatesConverter = coordinatesConverter;
this.cursorConfig = cursorConfig;
}
}

27
src/vs/editor/common/controller/cursorDeleteOperations.ts → src/vs/editor/common/cursor/cursorDeleteOperations.ts
View File

@@ -6,18 +6,19 @@
import * as strings from 'vs/base/common/strings';
import { ReplaceCommand } from 'vs/editor/common/commands/replaceCommand';
import { EditorAutoClosingEditStrategy, EditorAutoClosingStrategy } from 'vs/editor/common/config/editorOptions';
import { CursorColumns, CursorConfiguration, EditOperationResult, EditOperationType, ICursorSimpleModel, isQuote } from 'vs/editor/common/controller/cursorCommon';
import { MoveOperations } from 'vs/editor/common/controller/cursorMoveOperations';
import { CursorConfiguration, EditOperationResult, EditOperationType, ICursorSimpleModel, isQuote } from 'vs/editor/common/cursorCommon';
import { CursorColumns } from 'vs/editor/common/core/cursorColumns';
import { MoveOperations } from 'vs/editor/common/cursor/cursorMoveOperations';
import { Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import { ICommand } from 'vs/editor/common/editorCommon';
import { StandardAutoClosingPairConditional } from 'vs/editor/common/modes/languageConfiguration';
import { StandardAutoClosingPairConditional } from 'vs/editor/common/languages/languageConfiguration';
import { Position } from 'vs/editor/common/core/position';
export class DeleteOperations {
public static deleteRight(prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[]): [boolean, Array<ICommand | null>] {
let commands: Array<ICommand | null> = [];
const commands: Array<ICommand | null> = [];
let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingRight);
for (let i = 0, len = selections.length; i < len; i++) {
const selection = selections[i];
@@ -25,8 +26,8 @@ export class DeleteOperations {
let deleteSelection: Range = selection;
if (deleteSelection.isEmpty()) {
let position = selection.getPosition();
let rightOfPosition = MoveOperations.right(config, model, position);
const position = selection.getPosition();
const rightOfPosition = MoveOperations.right(config, model, position);
deleteSelection = new Range(
rightOfPosition.lineNumber,
rightOfPosition.column,
@@ -127,7 +128,7 @@ export class DeleteOperations {
}
private static _runAutoClosingPairDelete(config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[]): [boolean, ICommand[]] {
let commands: ICommand[] = [];
const commands: ICommand[] = [];
for (let i = 0, len = selections.length; i < len; i++) {
const position = selections[i].getPosition();
const deleteSelection = new Range(
@@ -149,7 +150,7 @@ export class DeleteOperations {
const commands: Array<ICommand | null> = [];
let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingLeft);
for (let i = 0, len = selections.length; i < len; i++) {
let deleteRange = DeleteOperations.getDeleteRange(selections[i], model, config);
const deleteRange = DeleteOperations.getDeleteRange(selections[i], model, config);
// Ignore empty delete ranges, as they have no effect
// They happen if the cursor is at the beginning of the file.
@@ -187,9 +188,9 @@ export class DeleteOperations {
);
if (position.column <= lastIndentationColumn) {
const fromVisibleColumn = CursorColumns.visibleColumnFromColumn2(config, model, position);
const fromVisibleColumn = config.visibleColumnFromColumn(model, position);
const toVisibleColumn = CursorColumns.prevIndentTabStop(fromVisibleColumn, config.indentSize);
const toColumn = CursorColumns.columnFromVisibleColumn2(config, model, position.lineNumber, toVisibleColumn);
const toColumn = config.columnFromVisibleColumn(model, position.lineNumber, toVisibleColumn);
return new Range(position.lineNumber, toColumn, position.lineNumber, position.column);
}
}
@@ -211,7 +212,7 @@ export class DeleteOperations {
}
public static cut(config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[]): EditOperationResult {
let commands: Array<ICommand | null> = [];
const commands: Array<ICommand | null> = [];
let lastCutRange: Range | null = null;
selections.sort((a, b) => Position.compare(a.getStartPosition(), b.getEndPosition()));
for (let i = 0, len = selections.length; i < len; i++) {
@@ -221,7 +222,7 @@ export class DeleteOperations {
if (config.emptySelectionClipboard) {
// This is a full line cut
let position = selection.getPosition();
const position = selection.getPosition();
let startLineNumber: number,
startColumn: number,
@@ -248,7 +249,7 @@ export class DeleteOperations {
endColumn = model.getLineMaxColumn(position.lineNumber);
}
let deleteSelection = new Range(
const deleteSelection = new Range(
startLineNumber,
startColumn,
endLineNumber,

Some files were not shown because too many files have changed in this diff Show More