TypeScript CommonEditorRegistry.registerEditorAction方法代码示例

function registerClipboardAction(desc: IClipboardCommand, alias: string, weight: number) {
	if (!browser.supportsExecCommand(desc.execCommand)) {
		return;
	}

	CommonEditorRegistry.registerEditorAction(new EditorActionDescriptor(desc.ctor, desc.id, desc.label, {
		handler: execCommandToHandler.bind(null, desc.id, desc.execCommand),
		context: ContextKey.None,
		primary: desc.primary,
		secondary: desc.secondary,
		win: desc.win,
		linux: desc.linux,
		mac: desc.mac,
		kbExpr: KbExpr.has(editorCommon.KEYBINDING_CONTEXT_EDITOR_TEXT_FOCUS)
	}, alias));

	MenuRegistry.appendMenuItem(MenuId.EditorContext, {
		command: {
			id: desc.id,
			title: desc.label
		},
		group: `9_cutcopypaste`,
		order: weight,
		when: desc.kbExpr
	});
}

function registerClipboardAction(desc:IClipboardCommand, alias:string) {
	if (!browser.supportsExecCommand(desc.execCommand)) {
		return;
	}

	CommonEditorRegistry.registerEditorAction(new EditorActionDescriptor(desc.ctor, desc.id, desc.label, {
		handler: execCommandToHandler.bind(null, desc.id, desc.execCommand),
		context: ContextKey.None,
		primary: desc.primary,
		secondary: desc.secondary,
		win: desc.win,
		linux: desc.linux,
		mac: desc.mac
	}, alias));
}

		editor.executeCommands(this.id, commands);
	}
}

class MoveCarretLeftAction extends MoveCarretAction {

	constructor() {
		super(
			'editor.action.moveCarretLeftAction',
			nls.localize('carret.moveLeft', "Move Carret Left"),
			'Move Carret Left',
			true
		);
	}
}

class MoveCarretRightAction extends MoveCarretAction {

	constructor() {
		super(
			'editor.action.moveCarretRightAction',
			nls.localize('carret.moveRight', "Move Carret Right"),
			'Move Carret Right',
			false
		);
	}
}

CommonEditorRegistry.registerEditorAction(new MoveCarretLeftAction());
CommonEditorRegistry.registerEditorAction(new MoveCarretRightAction());

/*---------------------------------------------------------------------------------------------
 *  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 {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';
import {GotoLineAction} from './gotoLine';

// Contribute Ctrl+G to "Go to line" using quick open
CommonEditorRegistry.registerEditorAction(new GotoLineAction());

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

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

class PreviousEditPointAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.previousEditPoint',
			nls.localize('previousEditPoint', "Emmet: Previous Edit Point"),
			'Emmet: Previous Edit Point',
			'prev_edit_point'
		);
	}
}

class NextEditPointAction extends BasicEmmetEditorAction {
	constructor() {
		super(
			'editor.emmet.action.nextEditPoint',
			nls.localize('nextEditPoint', "Emmet: Next Edit Point"),
			'Emmet: Next Edit Point',
			'next_edit_point'
		);
	}
}

CommonEditorRegistry.registerEditorAction(new PreviousEditPointAction());
CommonEditorRegistry.registerEditorAction(new NextEditPointAction());

	constructor() {
		super({
			id: 'editor.emmet.action.updateTag',
			label: nls.localize('updateTag', "Emmet: Update Tag"),
			alias: 'Emmet: Update Tag',
			precondition: EditorContextKeys.Writable
		});
	}

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

		let options: IInputOptions = {
			prompt: nls.localize('enterTag', 'Enter Tag'),
			placeHolder: nls.localize('tag', 'Tag')
		};

		quickOpenService.input(options).then(tag => {
			this.wrapAbbreviation(ctx, tag);
		});
	}

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

CommonEditorRegistry.registerEditorAction(new UpdateTagAction());

/*---------------------------------------------------------------------------------------------
 *  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.registerEditorAction(new MergeLinesAction());

			true
		);
	}

	public run(accessor:ServicesAccessor, editor:ICommonCodeEditor): TPromise<void> {
		const quickOpenService = accessor.get(IQuickOpenService);

		if (!editor.getModel()) {
			return;
		}

		const picks: ISnippetPick[] = [];
		Registry.as<ISnippetsRegistry>(Extensions.Snippets).visitSnippets(editor.getModel().getModeId(), snippet => {
			picks.push({
				label: snippet.prefix,
				detail: snippet.description,
				snippet
			});
			return true;
		});

		return quickOpenService.pick(picks).then(pick => {
			if (pick) {
				getSnippetController(editor).run(new CodeSnippet(pick.snippet.codeSnippet), 0, 0);
			}
		});
	}
}

CommonEditorRegistry.registerEditorAction(new ShowSnippetsActions());

/*---------------------------------------------------------------------------------------------
 *  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.registerEditorAction(new ReflectCSSValueAction());

/*---------------------------------------------------------------------------------------------
 *  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 * as nls from 'vs/nls';
import {KeyCode, KeyMod} from 'vs/base/common/keyCodes';
import * as browser from 'vs/base/browser/browser';
import {KbExpr} from 'vs/platform/keybinding/common/keybinding';
import {KEYBINDING_CONTEXT_EDITOR_FOCUS} from 'vs/editor/common/editorCommon';
import {CommonEditorRegistry, ContextKey} from 'vs/editor/common/editorCommonExtensions';
import {QuickCommandAction} from './quickCommand';

// Contribute "Quick Command" to context menu
CommonEditorRegistry.registerEditorAction({
	ctor: QuickCommandAction,
	id: QuickCommandAction.ID,
	label: nls.localize('label', "Command Palette"),
	alias: 'Command Palette',
	kbOpts: {
		context: ContextKey.EditorFocus,
		primary: (browser.isIE11orEarlier ? KeyMod.Alt | KeyCode.F1 : KeyCode.F1)
	},
	menuOpts: {
		kbExpr: KbExpr.has(KEYBINDING_CONTEXT_EDITOR_FOCUS)
	}
});