TypeScript IModeService.getOrCreateMode方法代碼示例

	public static colorize(modeService: IModeService, text: string, mimeType: string, options: IColorizerOptions): TPromise<string> {
		if (strings.startsWithUTF8BOM(text)) {
			text = text.substr(1);
		}
		let lines = text.split(/\r\n|\r|\n/);
		let language = modeService.getModeId(mimeType);

		options = options || {};
		if (typeof options.tabSize === 'undefined') {
			options.tabSize = 4;
		}

		// Send out the event to create the mode
		modeService.getOrCreateMode(language);

		let tokenizationSupport = TokenizationRegistry.get(language);
		if (tokenizationSupport) {
			return TPromise.as(_colorize(lines, options.tabSize, tokenizationSupport));
		}

		// wait 500ms for mode to load, then give up
		return TPromise.any([this._tokenizationSupportChangedPromise(language), timeout(500)]).then(_ => {
			let tokenizationSupport = TokenizationRegistry.get(language);
			if (tokenizationSupport) {
				return _colorize(lines, options.tabSize, tokenizationSupport);
			}
			return _fakeColorize(lines, options.tabSize);
		});
	}

	public static colorize(modeService:IModeService, text:string, mimeType:string, options:IColorizerOptions): TPromise<string> {
		options = options || {};
		if (typeof options.tabSize === 'undefined') {
			options.tabSize = 4;
		}

		let lines = text.split('\n');
		let c: (v:string)=>void;
		let e: (err:any)=>void;
		let p: (v:string)=>void;
		let isCanceled = false;
		let mode: IMode;

		let result = new TPromise<string>((_c, _e, _p) => {
			c = _c;
			e = _e;
			p = _p;
		}, () => {
			isCanceled = true;
		});

		let colorize = new RunOnceScheduler(() => {
			if (isCanceled) {
				return;
			}
			let r = actualColorize(lines, mode, options.tabSize);
			if (r.retokenize.length > 0) {
				// There are retokenization requests
				r.retokenize.forEach((p) => p.then(scheduleColorize));
				p(r.result);
			} else {
				// There are no (more) retokenization requests
				c(r.result);
			}
		}, 0);
		let scheduleColorize = () => colorize.schedule();

		modeService.getOrCreateMode(mimeType).then((_mode) => {
			if (!_mode) {
				e('Mode not found: "' + mimeType + '".');
				return;
			}
			if (!_mode.tokenizationSupport) {
				// wait 500ms for mode to load, then give up
				TPromise.any([this._tokenizationSupportChangedPromise(_mode), TPromise.timeout(500)]).then(_ => {
					if (!_mode.tokenizationSupport) {
						e('Mode found ("' + _mode.getId() + '"), but does not support tokenization.');
						return;
					}
					mode = _mode;
					scheduleColorize();
				});
				return;
			}
			mode = _mode;
			scheduleColorize();
		});

		return result;
	}

	public static colorize(modeService: IModeService, text: string, mimeType: string, options: IColorizerOptions | null | undefined): Promise<string> {
		let tabSize = 4;
		if (options && typeof options.tabSize === 'number') {
			tabSize = options.tabSize;
		}

		if (strings.startsWithUTF8BOM(text)) {
			text = text.substr(1);
		}
		let lines = text.split(/\r\n|\r|\n/);
		let language = modeService.getModeId(mimeType);
		if (!language) {
			return Promise.resolve(_fakeColorize(lines, tabSize));
		}

		// Send out the event to create the mode
		modeService.getOrCreateMode(language);

		let tokenizationSupport = TokenizationRegistry.get(language);
		if (tokenizationSupport) {
			return Promise.resolve(_colorize(lines, tabSize, tokenizationSupport));
		}

		return new Promise<string>((resolve, reject) => {
			let listener: IDisposable | null = null;
			let timeout: TimeoutTimer | null = null;

			const execute = () => {
				if (listener) {
					listener.dispose();
					listener = null;
				}
				if (timeout) {
					timeout.dispose();
					timeout = null;
				}
				const tokenizationSupport = TokenizationRegistry.get(language!);
				if (tokenizationSupport) {
					return resolve(_colorize(lines, tabSize, tokenizationSupport));
				}
				return resolve(_fakeColorize(lines, tabSize));
			};

			// wait 500ms for mode to load, then give up
			timeout = new TimeoutTimer();
			timeout.cancelAndSet(execute, 500);
			listener = TokenizationRegistry.onDidChange((e) => {
				if (e.changedLanguages.indexOf(language!) >= 0) {
					execute();
				}
			});
		});
	}

export function colorize(modeService:IModeService, text:string, mimeType:string, options:IColorizerOptions): TPromise<string> {
	options = options || {};
	if (typeof options.tabSize === 'undefined') {
		options.tabSize = 4;
	}

	var lines = text.split('\n'),
		c: (v:string)=>void,
		e: (err:any)=>void,
		p: (v:string)=>void,
		isCancelled = false,
		mode: Modes.IMode;

	var result = new TPromise<string>((_c, _e, _p) => {
		c = _c;
		e = _e;
		p = _p;
	}, () => {
		isCancelled = true;
	});

	var colorize = new Schedulers.RunOnceScheduler(() => {
		if (isCancelled) {
			return;
		}
		var r = actualColorize(lines, mode, options.tabSize);
		if (r.retokenize.length > 0) {
			// There are retokenization requests
			r.retokenize.forEach((p) => p.then(scheduleColorize));
			p(r.result);
		} else {
			// There are no (more) retokenization requests
			c(r.result);
		}
	}, 0);
	var scheduleColorize = () => colorize.schedule();

	modeService.getOrCreateMode(mimeType).then((_mode) => {
		if (!_mode) {
			e('Mode not found: "' + mimeType + '".');
			return;
		}
		if (!_mode.tokenizationSupport) {
			e('Mode found ("' + _mode.getId() + '"), but does not support tokenization.');
			return;
		}
		mode = _mode;
		scheduleColorize();
	});

	return result;
}