Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-05-08 17:19:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Simplify EditorLayoutInfoComputer

Browse Source
This commit is contained in:
Alex Dima
2019-09-06 14:29:53 +02:00
parent 959c017811
commit 744eb296ef
3 changed files with 124 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/vs/editor/common/config/commonEditorConfig.ts
+1 -1
View File
@@ -61,7 +61,7 @@ export interface IEnvConfiguration {
const hasOwnProperty = Object.hasOwnProperty;
class ComputedEditorOptions implements IComputedEditorOptions {
export class ComputedEditorOptions implements IComputedEditorOptions {
private readonly _values: any[] = [];
public _read<T>(id: EditorOption): T {
return this._values[id];
src/vs/editor/common/config/editorOptions.ts
+50 -90
View File
@@ -853,45 +853,6 @@ function _float(value: any, defaultValue: number): number {
return (isNaN(r) ? defaultValue : r);
}
/**
* @internal
*/
export interface IEditorLayoutProviderOpts {
readonly outerWidth: number;
readonly outerHeight: number;
readonly showGlyphMargin: boolean;
readonly lineHeight: number;
readonly showLineNumbers: boolean;
readonly lineNumbersMinChars: number;
readonly lineNumbersDigitCount: number;
readonly lineDecorationsWidth: number;
readonly typicalHalfwidthCharacterWidth: number;
readonly maxDigitWidth: number;
readonly verticalScrollbarWidth: number;
readonly verticalScrollbarHasArrows: boolean;
readonly scrollbarArrowSize: number;
readonly horizontalScrollbarHeight: number;
readonly minimap: boolean;
readonly minimapSide: string;
readonly minimapRenderCharacters: boolean;
readonly minimapMaxColumn: number;
readonly pixelRatio: number;
}
/**
* @internal
*/
export interface IRawEditorOptionsBag extends IEditorOptions {
[key: string]: any;
}
/**
* @internal
*/
@@ -1494,23 +1455,66 @@ export interface EditorLayoutInfo {
readonly overviewRuler: OverviewRulerPosition;
}
/**
* @internal
*/
export interface EditorLayoutInfoComputerEnv {
outerWidth: number;
outerHeight: number;
lineHeight: number;
lineNumbersDigitCount: number;
typicalHalfwidthCharacterWidth: number;
maxDigitWidth: number;
pixelRatio: number;
}
/**
* @internal
*/
export class EditorLayoutInfoComputer<K1 extends EditorOption> extends ComputedEditorOption<K1, EditorLayoutInfo> {
public compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, _: EditorLayoutInfo): EditorLayoutInfo {
const glyphMargin = options.get(EditorOption.glyphMargin);
const lineNumbersMinChars = options.get(EditorOption.lineNumbersMinChars);
return EditorLayoutInfoComputer.computeLayout(options, {
outerWidth: env.outerWidth,
outerHeight: env.outerHeight,
lineHeight: env.fontInfo.lineHeight,
lineNumbersDigitCount: env.lineNumbersDigitCount,
typicalHalfwidthCharacterWidth: env.fontInfo.typicalHalfwidthCharacterWidth,
maxDigitWidth: env.fontInfo.maxDigitWidth,
pixelRatio: env.pixelRatio
});
}
public static computeLayout(options: IComputedEditorOptions, env: EditorLayoutInfoComputerEnv): EditorLayoutInfo {
const outerWidth = env.outerWidth | 0;
const outerHeight = env.outerHeight | 0;
const lineHeight = env.lineHeight | 0;
const lineNumbersDigitCount = env.lineNumbersDigitCount | 0;
const typicalHalfwidthCharacterWidth = env.typicalHalfwidthCharacterWidth;
const maxDigitWidth = env.maxDigitWidth;
const pixelRatio = env.pixelRatio;
const showGlyphMargin = options.get(EditorOption.glyphMargin);
const showLineNumbers = (options.get(EditorOption.lineNumbers).renderType !== RenderLineNumbersType.Off);
const lineNumbersMinChars = options.get(EditorOption.lineNumbersMinChars) | 0;
const minimap = options.get(EditorOption.minimap);
const minimapEnabled = minimap.enabled;
const minimapSide = minimap.side;
const minimapRenderCharacters = minimap.renderCharacters;
const minimapMaxColumn = minimap.maxColumn | 0;
const scrollbar = options.get(EditorOption.scrollbar);
const verticalScrollbarWidth = scrollbar.verticalScrollbarSize | 0;
const verticalScrollbarHasArrows = scrollbar.verticalHasArrows;
const scrollbarArrowSize = scrollbar.arrowSize | 0;
const horizontalScrollbarHeight = scrollbar.horizontalScrollbarSize | 0;
const rawLineDecorationsWidth = options.get(EditorOption.lineDecorationsWidth);
const folding = options.get(EditorOption.folding);
const minimap = options.get(EditorOption.minimap);
const scrollbar = options.get(EditorOption.scrollbar);
const lineNumbers = options.get(EditorOption.lineNumbers);
let lineDecorationsWidth: number;
if (typeof rawLineDecorationsWidth === 'string' && /^\d+(\.\d+)?ch$/.test(rawLineDecorationsWidth)) {
const multiple = parseFloat(rawLineDecorationsWidth.substr(0, rawLineDecorationsWidth.length - 2));
lineDecorationsWidth = multiple * env.fontInfo.typicalHalfwidthCharacterWidth;
lineDecorationsWidth = _clampedInt(multiple * typicalHalfwidthCharacterWidth, 0, 0, 1000);
} else {
lineDecorationsWidth = _clampedInt(rawLineDecorationsWidth, 0, 0, 1000);
}
@@ -1518,50 +1522,6 @@ export class EditorLayoutInfoComputer<K1 extends EditorOption> extends ComputedE
lineDecorationsWidth += 16;
}
return EditorLayoutInfoComputer.compute({
outerWidth: env.outerWidth,
outerHeight: env.outerHeight,
showGlyphMargin: glyphMargin,
lineHeight: env.fontInfo.lineHeight,
showLineNumbers: (lineNumbers.renderType !== RenderLineNumbersType.Off),
lineNumbersMinChars: lineNumbersMinChars,
lineNumbersDigitCount: env.lineNumbersDigitCount,
lineDecorationsWidth: lineDecorationsWidth,
typicalHalfwidthCharacterWidth: env.fontInfo.typicalHalfwidthCharacterWidth,
maxDigitWidth: env.fontInfo.maxDigitWidth,
verticalScrollbarWidth: scrollbar.verticalScrollbarSize,
horizontalScrollbarHeight: scrollbar.horizontalScrollbarSize,
scrollbarArrowSize: scrollbar.arrowSize,
verticalScrollbarHasArrows: scrollbar.verticalHasArrows,
minimap: minimap.enabled,
minimapSide: minimap.side,
minimapRenderCharacters: minimap.renderCharacters,
minimapMaxColumn: minimap.maxColumn,
pixelRatio: env.pixelRatio
});
}
public static compute(_opts: IEditorLayoutProviderOpts): EditorLayoutInfo {
const outerWidth = _opts.outerWidth | 0;
const outerHeight = _opts.outerHeight | 0;
const showGlyphMargin = _opts.showGlyphMargin;
const lineHeight = _opts.lineHeight | 0;
const showLineNumbers = _opts.showLineNumbers;
const lineNumbersMinChars = _opts.lineNumbersMinChars | 0;
const lineNumbersDigitCount = _opts.lineNumbersDigitCount | 0;
const lineDecorationsWidth = _opts.lineDecorationsWidth | 0;
const typicalHalfwidthCharacterWidth = _opts.typicalHalfwidthCharacterWidth;
const maxDigitWidth = _opts.maxDigitWidth;
const verticalScrollbarWidth = _opts.verticalScrollbarWidth | 0;
const verticalScrollbarHasArrows = _opts.verticalScrollbarHasArrows;
const scrollbarArrowSize = _opts.scrollbarArrowSize | 0;
const horizontalScrollbarHeight = _opts.horizontalScrollbarHeight | 0;
const minimap = _opts.minimap;
const minimapSide = _opts.minimapSide;
const minimapRenderCharacters = _opts.minimapRenderCharacters;
const minimapMaxColumn = _opts.minimapMaxColumn | 0;
const pixelRatio = _opts.pixelRatio;
let lineNumbersWidth = 0;
if (showLineNumbers) {
const digitCount = Math.max(lineNumbersDigitCount, lineNumbersMinChars);
@@ -1584,7 +1544,7 @@ export class EditorLayoutInfoComputer<K1 extends EditorOption> extends ComputedE
let minimapLeft: number;
let minimapWidth: number;
let contentWidth: number;
if (!minimap) {
if (!minimapEnabled) {
minimapLeft = 0;
minimapWidth = 0;
renderMinimap = RenderMinimap.None;
src/vs/editor/test/common/viewLayout/editorLayoutProvider.test.ts
+73 -3
View File
@@ -4,16 +4,86 @@
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { EditorLayoutInfo, EditorLayoutInfoComputer, IEditorLayoutProviderOpts, RenderMinimap } from 'vs/editor/common/config/editorOptions';
import { EditorLayoutInfo, EditorLayoutInfoComputer, RenderMinimap, EditorOption, InternalEditorMinimapOptions, InternalEditorScrollbarOptions, EditorOptions, RenderLineNumbersType, InternalEditorRenderLineNumbersOptions } from 'vs/editor/common/config/editorOptions';
import { ComputedEditorOptions } from 'vs/editor/common/config/commonEditorConfig';
interface IEditorLayoutProviderOpts {
readonly outerWidth: number;
readonly outerHeight: number;
readonly showGlyphMargin: boolean;
readonly lineHeight: number;
readonly showLineNumbers: boolean;
readonly lineNumbersMinChars: number;
readonly lineNumbersDigitCount: number;
readonly lineDecorationsWidth: number;
readonly typicalHalfwidthCharacterWidth: number;
readonly maxDigitWidth: number;
readonly verticalScrollbarWidth: number;
readonly verticalScrollbarHasArrows: boolean;
readonly scrollbarArrowSize: number;
readonly horizontalScrollbarHeight: number;
readonly minimap: boolean;
readonly minimapSide: 'left' | 'right';
readonly minimapRenderCharacters: boolean;
readonly minimapMaxColumn: number;
readonly pixelRatio: number;
}
suite('Editor ViewLayout - EditorLayoutProvider', () => {
function doTest(input: IEditorLayoutProviderOpts, expected: EditorLayoutInfo): void {
let actual = EditorLayoutInfoComputer.compute(input);
const options = new ComputedEditorOptions();
options._write(EditorOption.glyphMargin, input.showGlyphMargin);
options._write(EditorOption.lineNumbersMinChars, input.lineNumbersMinChars);
options._write(EditorOption.lineDecorationsWidth, input.lineDecorationsWidth);
options._write(EditorOption.folding, false);
const minimapOptions: InternalEditorMinimapOptions = {
enabled: input.minimap,
side: input.minimapSide,
renderCharacters: input.minimapRenderCharacters,
maxColumn: input.minimapMaxColumn,
showSlider: 'mouseover'
};
options._write(EditorOption.minimap, minimapOptions);
const scrollbarOptions: InternalEditorScrollbarOptions = {
arrowSize: input.scrollbarArrowSize,
vertical: EditorOptions.scrollbar.defaultValue.vertical,
horizontal: EditorOptions.scrollbar.defaultValue.horizontal,
useShadows: EditorOptions.scrollbar.defaultValue.useShadows,
verticalHasArrows: input.verticalScrollbarHasArrows,
horizontalHasArrows: false,
handleMouseWheel: EditorOptions.scrollbar.defaultValue.handleMouseWheel,
horizontalScrollbarSize: input.horizontalScrollbarHeight,
horizontalSliderSize: EditorOptions.scrollbar.defaultValue.horizontalSliderSize,
verticalScrollbarSize: input.verticalScrollbarWidth,
verticalSliderSize: EditorOptions.scrollbar.defaultValue.verticalSliderSize,
};
options._write(EditorOption.scrollbar, scrollbarOptions);
const lineNumbersOptions: InternalEditorRenderLineNumbersOptions = {
renderType: input.showLineNumbers ? RenderLineNumbersType.On : RenderLineNumbersType.Off,
renderFn: null
};
options._write(EditorOption.lineNumbers, lineNumbersOptions);
const actual = EditorLayoutInfoComputer.computeLayout(options, {
outerWidth: input.outerWidth,
outerHeight: input.outerHeight,
lineHeight: input.lineHeight,
lineNumbersDigitCount: input.lineNumbersDigitCount,
typicalHalfwidthCharacterWidth: input.typicalHalfwidthCharacterWidth,
maxDigitWidth: input.maxDigitWidth,
pixelRatio: input.pixelRatio,
});
assert.deepEqual(actual, expected);
}
test('EditorLayoutProvider 1', () => {
test.only('EditorLayoutProvider 1', () => {
doTest({
outerWidth: 1000,
outerHeight: 800,