TypeScript CommonEditorRegistry.registerEditorAction2方法代码示例

}

class DecrementNumberByOneAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.decrementNumberByOne',
			nls.localize('decrementNumberByOne', "Emmet: Decrement by 1"),
			'Emmet: Decrement by 1',
			'decrement_number_by_1'
		);
	}
}

class DecrementNumberByTenAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.decrementNumberByTen',
			nls.localize('decrementNumberByTen', "Emmet: Decrement by 10"),
			'Emmet: Decrement by 10',
			'decrement_number_by_10'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new IncrementNumberByOneTenthAction());
CommonEditorRegistry.registerEditorAction2(new IncrementNumberByOneAction());
CommonEditorRegistry.registerEditorAction2(new IncrementNumberByTenAction());
CommonEditorRegistry.registerEditorAction2(new DecrementNumberByOneTenthAction());
CommonEditorRegistry.registerEditorAction2(new DecrementNumberByOneAction());
CommonEditorRegistry.registerEditorAction2(new DecrementNumberByTenAction());

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class SelectPreviousItemAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.selectPreviousItem',
			nls.localize('selectPreviousItem', "Emmet: Select Previous Item"),
			'Emmet: Select Previous Item',
			'select_previous_item'
		);
	}
}

class SelectNextItemAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.selectNextItem',
			nls.localize('selectNextItem', "Emmet: Select Next Item"),
			'Emmet: Select Next Item',
			'select_next_item'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new SelectPreviousItemAction());
CommonEditorRegistry.registerEditorAction2(new SelectNextItemAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class ToggleCommentAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.toggleComment',
			nls.localize('toggleComment', "Emmet: Toggle Comment"),
			'Emmet: Toggle Comment',
			'toggle_comment'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new ToggleCommentAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class GoToMatchingPairAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.matchingPair',
			nls.localize('matchingPair', "Emmet: Go to Matching Pair"),
			'Emmet: Go to Matching Pair',
			'matching_pair'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new GoToMatchingPairAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class RemoveTagAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.removeTag',
			nls.localize('removeTag', "Emmet: Remove Tag"),
			'Emmet: Remove Tag',
			'remove_tag'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new RemoveTagAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class UpdateImageSizeAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.updateImageSize',
			nls.localize('updateImageSize', "Emmet: Update Image Size"),
			'Emmet: Update Image Size',
			'update_image_size'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new UpdateImageSizeAction());

class WrapWithAbbreviationAction extends EmmetEditorAction {

	constructor() {
		super(
			'editor.emmet.action.wrapWithAbbreviation',
			nls.localize('wrapWithAbbreviationAction', "Emmet: Wrap with Abbreviation"),
			'Emmet: Wrap with Abbreviation'
		);
	}

	public runEmmetAction(accessor:ServicesAccessor, ctx: EmmetActionContext) {
		const quickOpenService = accessor.get(IQuickOpenService);

		let options: IInputOptions = {
			prompt: nls.localize('enterAbbreviation', "Enter Abbreviation"),
			placeHolder: nls.localize('abbreviation', "Abbreviation")
		};
		quickOpenService.input(options).then(abbreviation => {
			this.wrapAbbreviation(ctx, abbreviation);
		});
	}

	private wrapAbbreviation(ctx: EmmetActionContext, abbreviation:string) {
		if (abbreviation && !ctx.emmet.run('wrap_with_abbreviation', ctx.editorAccessor, abbreviation)) {
			this.noExpansionOccurred(ctx.editor);
		}
	}
}

CommonEditorRegistry.registerEditorAction2(new WrapWithAbbreviationAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class MergeLinesAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.mergeLines',
			nls.localize('mergeLines', "Emmet: Merge Lines"),
			'Emmet: Merge Lines',
			'merge_lines'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new MergeLinesAction());

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

import nls = require('vs/nls');
import {BasicEmmetEditorAction} from 'vs/workbench/parts/emmet/node/emmetActions';

import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';

class ReflectCSSValueAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.reflectCSSValue',
			nls.localize('reflectCSSValue', "Emmet: Reflect CSS Value"),
			'Emmet: Reflect CSS Value',
			'reflect_css_value'
		);
	}
}

CommonEditorRegistry.registerEditorAction2(new ReflectCSSValueAction());

class ExpandAbbreviationAction extends BasicEmmetEditorAction {

	constructor() {
		super(
			'editor.emmet.action.expandAbbreviation',
			nls.localize('expandAbbreviationAction', "Emmet: Expand Abbreviation"),
			'Emmet: Expand Abbreviation',
			'expand_abbreviation'
		);

		this.kbOpts = {
			primary: KeyCode.Tab,
			kbExpr: KbExpr.and(
				EditorKbExpr.TextFocus,
				EditorKbExpr.HasOnlyEmptySelection,
				EditorKbExpr.HasSingleSelection,
				EditorKbExpr.TabDoesNotMoveFocus,
				KbExpr.has('config.emmet.triggerExpansionOnTab')
			)
		};
	}

	protected noExpansionOccurred(editor:ICommonCodeEditor): void {
		// forward the tab key back to the editor
		editor.trigger('emmet', Handler.Tab, {});
	}
}

CommonEditorRegistry.registerEditorAction2(new ExpandAbbreviationAction());