TypeScript idGenerator.IdGenerator类代码示例

	protected _addMarkers(newMarkers:INewMarker[]): string[] {
		let addMarkersPerLine: {
			[lineNumber:number]: LineMarker[];
		} = Object.create(null);

		let result:string[] = [];
		for (let i = 0, len = newMarkers.length; i < len; i++) {
			let newMarker = newMarkers[i];

			let marker = new LineMarker(this._markerIdGenerator.nextId(), newMarker.column, newMarker.stickToPreviousCharacter);
			this._markerIdToMarker[marker.id] = marker;

			if (!addMarkersPerLine[newMarker.lineNumber]) {
				addMarkersPerLine[newMarker.lineNumber] = [];
			}
			addMarkersPerLine[newMarker.lineNumber].push(marker);

			result.push(marker.id);
		}

		let lineNumbers = Object.keys(addMarkersPerLine);
		for (let i = 0, len = lineNumbers.length; i < len; i++) {
			let lineNumber = parseInt(lineNumbers[i], 10);
			this._lines[lineNumber - 1].addMarkers(addMarkersPerLine[lineNumbers[i]]);
		}

		return result;
	}

	_addMarker(lineNumber:number, column:number, stickToPreviousCharacter:boolean): string {
		var pos = this.validatePosition(new Position(lineNumber, column));

		var marker = new LineMarker(this._markerIdGenerator.nextId(), pos.column, stickToPreviousCharacter);
		this._markerIdToMarker[marker.id] = marker;

		this._lines[pos.lineNumber - 1].addMarker(marker);

		return marker.id;
	}

	private _addDecorationImpl(eventBuilder:DeferredEventsBuilder, ownerId:number, range:Range, options:ModelDecorationOptions): string {
		var rangeId = this.addTrackedRange(range, options.stickiness);

		var decoration = new ModelInternalDecoration(this._decorationIdGenerator.nextId(), ownerId, rangeId, options);

		this.decorations[decoration.id] = decoration;
		this.rangeIdToDecorationId[rangeId] = decoration.id;

		eventBuilder.addNewDecoration(decoration.id);

		return decoration.id;
	}

	public addTrackedRange(textRange:editorCommon.IRange, stickiness:editorCommon.TrackedRangeStickiness): string {
		textRange = this.validateRange(textRange);

		var startMarkerSticksToPreviousCharacter = this._shouldStartMarkerSticksToPreviousCharacter(stickiness);
		var endMarkerSticksToPreviousCharacter = this._shouldEndMarkerSticksToPreviousCharacter(stickiness);

		var startMarkerId = this._addMarker(textRange.startLineNumber, textRange.startColumn, startMarkerSticksToPreviousCharacter);
		var endMarkerId = this._addMarker(textRange.endLineNumber, textRange.endColumn, endMarkerSticksToPreviousCharacter);

		var range = new TrackedRange(this._rangeIdGenerator.nextId(), startMarkerId, endMarkerId);
		this._ranges[range.id] = range;
		this._markerIdToRangeId[startMarkerId] = range.id;
		this._markerIdToRangeId[endMarkerId] = range.id;

		this._setRangeIsMultiLine(range.id, (textRange.startLineNumber !== textRange.endLineNumber));

		return range.id;
	}

ExtensionsRegistry.registerExtensionPoint<schema.IUserFriendlyCommand | schema.IUserFriendlyCommand[]>('commands', [], schema.commandsContribution).setHandler(extensions => {

	const ids = new IdGenerator('contrib-cmd-icon-');

	function handleCommand(userFriendlyCommand: schema.IUserFriendlyCommand, extension: IExtensionPointUser<any>) {

		if (!schema.isValidCommand(userFriendlyCommand, extension.collector)) {
			return;
		}

		let { icon, category, title, command } = userFriendlyCommand;
		let iconClass: string;
		let iconPath: string;
		if (icon) {
			iconClass = ids.nextId();
			if (typeof icon === 'string') {
				iconPath = join(extension.description.extensionFolderPath, icon);
				createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(iconPath).toString()}")`);
			} else {
				const light = join(extension.description.extensionFolderPath, icon.light);
				const dark = join(extension.description.extensionFolderPath, icon.dark);
				createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(light).toString()}")`);
				createCSSRule(`.vs-dark .icon.${iconClass}, .hc-black .icon.${iconClass}`, `background-image: url("${URI.file(dark).toString()}")`);

				iconPath = join(extension.description.extensionFolderPath, icon.dark);
			}
		}

		if (MenuRegistry.addCommand({ id: command, title, category, iconClass, iconPath })) {
			extension.collector.info(localize('dup', "Command `{0}` appears multiple times in the `commands` section.", userFriendlyCommand.command));
		}
	}

	for (let extension of extensions) {
		const { value } = extension;
		if (Array.isArray<schema.IUserFriendlyCommand>(value)) {
			for (let command of value) {
				handleCommand(command, extension);
			}
		} else {
			handleCommand(value, extension);
		}
	}
});

	private _addDecorationsImpl(eventBuilder:DeferredEventsBuilder, ownerId:number, newDecorations: ModelDeltaDecoration[]): string[] {
		var rangeIds = this._addTrackedRanges(newDecorations.map(d => d.range), newDecorations.map(d => d.options.stickiness));
		var result: string[] = [];

		for (let i = 0, len = newDecorations.length; i < len; i++) {
			let rangeId = rangeIds[i];

			var decoration = new ModelInternalDecoration(this._decorationIdGenerator.nextId(), ownerId, rangeId, newDecorations[i].options);

			this.decorations[decoration.id] = decoration;
			this.rangeIdToDecorationId[rangeId] = decoration.id;

			eventBuilder.addNewDecoration(decoration.id);

			result.push(decoration.id);
		}

		return result;
	}

	protected _addMarkers(newMarkers: INewMarker[]): LineMarker[] {
		if (newMarkers.length === 0) {
			return [];
		}

		let markers: LineMarker[] = [];
		for (let i = 0, len = newMarkers.length; i < len; i++) {
			let newMarker = newMarkers[i];

			let marker = new LineMarker(this._markerIdGenerator.nextId(), newMarker.internalDecorationId, newMarker.position, newMarker.stickToPreviousCharacter);
			this._markerIdToMarker[marker.id] = marker;

			markers[i] = marker;
		}

		let sortedMarkers = markers.slice(0);
		sortedMarkers.sort((a, b) => {
			return a.position.lineNumber - b.position.lineNumber;
		});

		let currentLineNumber = 0;
		let currentMarkers: LineMarker[] = [], currentMarkersLen = 0;
		for (let i = 0, len = sortedMarkers.length; i < len; i++) {
			let marker = sortedMarkers[i];

			if (marker.position.lineNumber !== currentLineNumber) {
				if (currentLineNumber !== 0) {
					this._lines[currentLineNumber - 1].addMarkers(currentMarkers);
				}
				currentLineNumber = marker.position.lineNumber;
				currentMarkers.length = 0;
				currentMarkersLen = 0;
			}

			currentMarkers[currentMarkersLen++] = marker;
		}
		this._lines[currentLineNumber - 1].addMarkers(currentMarkers);

		return markers;
	}

	function handleCommand(userFriendlyCommand: schema.IUserFriendlyCommand , extension: IExtensionPointUser<any>) {

		if (!schema.isValidCommand(userFriendlyCommand, extension.collector)) {
			return;
		}

		let {icon, category, title, command} = userFriendlyCommand;
		let iconClass: string;
		if (icon) {
			iconClass = ids.nextId();
			if (typeof icon === 'string') {
				const path = join(extension.description.extensionFolderPath, icon);
				createCSSRule(`.icon.${iconClass}`, `background-image: url("${path}")`);
			} else {
				const light = join(extension.description.extensionFolderPath, icon.light);
				const dark = join(extension.description.extensionFolderPath, icon.dark);
				createCSSRule(`.icon.${iconClass}`, `background-image: url("${light}")`);
				createCSSRule(`.vs-dark .icon.${iconClass}, hc-black .icon.${iconClass}`, `background-image: url("${dark}")`);
			}
		}

		if (MenuRegistry.addCommand({ id: command, title, category, iconClass })) {
			extension.collector.info(localize('dup', "Command `{0}` appears multiple times in the `commands` section.", userFriendlyCommand.command));
		}
	}

export function getIconClass(iconPath: { dark: URI; light?: URI; }) {
	let iconClass: string;

	const key = iconPath.dark.toString();
	if (iconPathToClass[key]) {
		iconClass = iconPathToClass[key];
	} else {
		iconClass = iconClassGenerator.nextId();
		dom.createCSSRule(`.${iconClass}`, `background-image: url("${(iconPath.light || iconPath.dark).toString()}")`);
		dom.createCSSRule(`.vs-dark .${iconClass}, .hc-black .${iconClass}`, `background-image: url("${iconPath.dark.toString()}")`);
		iconPathToClass[key] = iconClass;
	}

	return iconClass;
}

function createCSSRuleForIcon(icon: IUserFriendlyIcon, extension: IExtensionPointUser<any>): string {
	let iconClass: string;
	if (icon) {
		iconClass = ids.nextId();
		if (typeof icon === 'string') {
			const path = join(extension.description.extensionLocation.fsPath, icon);
			createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(path).toString()}")`);
		} else {
			const light = join(extension.description.extensionLocation.fsPath, icon.light);
			const dark = join(extension.description.extensionLocation.fsPath, icon.dark);
			createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(light).toString()}")`);
			createCSSRule(`.vs-dark .icon.${iconClass}, .hc-black .icon.${iconClass}`, `background-image: url("${URI.file(dark).toString()}")`);
		}
	}
	return iconClass;
}