mirror of
https://github.com/microsoft/vscode.git
synced 2026-04-27 20:13:32 +01:00
462 lines
14 KiB
TypeScript
462 lines
14 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
import { URI, UriComponents } from 'vs/base/common/uri';
|
|
import { Event, Emitter } from 'vs/base/common/event';
|
|
import { IDisposable, DisposableStore, combinedDisposable } from 'vs/base/common/lifecycle';
|
|
import { ISCMService, ISCMRepository, ISCMProvider, ISCMResource, ISCMResourceGroup, ISCMResourceDecorations, IInputValidation, ISCMViewService, InputValidationType } from 'vs/workbench/contrib/scm/common/scm';
|
|
import { ExtHostContext, MainThreadSCMShape, ExtHostSCMShape, SCMProviderFeatures, SCMRawResourceSplices, SCMGroupFeatures, MainContext, IExtHostContext } from '../common/extHost.protocol';
|
|
import { Command } from 'vs/editor/common/modes';
|
|
import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
|
|
import { ISplice, Sequence } from 'vs/base/common/sequence';
|
|
import { CancellationToken } from 'vs/base/common/cancellation';
|
|
|
|
class MainThreadSCMResourceGroup implements ISCMResourceGroup {
|
|
|
|
readonly elements: ISCMResource[] = [];
|
|
|
|
private readonly _onDidSplice = new Emitter<ISplice<ISCMResource>>();
|
|
readonly onDidSplice = this._onDidSplice.event;
|
|
|
|
get hideWhenEmpty(): boolean { return !!this.features.hideWhenEmpty; }
|
|
|
|
private readonly _onDidChange = new Emitter<void>();
|
|
readonly onDidChange: Event<void> = this._onDidChange.event;
|
|
|
|
constructor(
|
|
private readonly sourceControlHandle: number,
|
|
private readonly handle: number,
|
|
public provider: ISCMProvider,
|
|
public features: SCMGroupFeatures,
|
|
public label: string,
|
|
public id: string
|
|
) { }
|
|
|
|
toJSON(): any {
|
|
return {
|
|
$mid: 4,
|
|
sourceControlHandle: this.sourceControlHandle,
|
|
groupHandle: this.handle
|
|
};
|
|
}
|
|
|
|
splice(start: number, deleteCount: number, toInsert: ISCMResource[]) {
|
|
this.elements.splice(start, deleteCount, ...toInsert);
|
|
this._onDidSplice.fire({ start, deleteCount, toInsert });
|
|
}
|
|
|
|
$updateGroup(features: SCMGroupFeatures): void {
|
|
this.features = { ...this.features, ...features };
|
|
this._onDidChange.fire();
|
|
}
|
|
|
|
$updateGroupLabel(label: string): void {
|
|
this.label = label;
|
|
this._onDidChange.fire();
|
|
}
|
|
}
|
|
|
|
class MainThreadSCMResource implements ISCMResource {
|
|
|
|
constructor(
|
|
private readonly proxy: ExtHostSCMShape,
|
|
private readonly sourceControlHandle: number,
|
|
private readonly groupHandle: number,
|
|
private readonly handle: number,
|
|
readonly sourceUri: URI,
|
|
readonly resourceGroup: ISCMResourceGroup,
|
|
readonly decorations: ISCMResourceDecorations,
|
|
readonly contextValue: string | undefined,
|
|
readonly command: Command | undefined
|
|
) { }
|
|
|
|
open(preserveFocus: boolean): Promise<void> {
|
|
return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle, preserveFocus);
|
|
}
|
|
|
|
toJSON(): any {
|
|
return {
|
|
$mid: 3,
|
|
sourceControlHandle: this.sourceControlHandle,
|
|
groupHandle: this.groupHandle,
|
|
handle: this.handle
|
|
};
|
|
}
|
|
}
|
|
|
|
class MainThreadSCMProvider implements ISCMProvider {
|
|
|
|
private static ID_HANDLE = 0;
|
|
private _id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
|
|
get id(): string { return this._id; }
|
|
|
|
readonly groups = new Sequence<MainThreadSCMResourceGroup>();
|
|
private readonly _groupsByHandle: { [handle: number]: MainThreadSCMResourceGroup; } = Object.create(null);
|
|
|
|
// get groups(): ISequence<ISCMResourceGroup> {
|
|
// return {
|
|
// elements: this._groups,
|
|
// onDidSplice: this._onDidSplice.event
|
|
// };
|
|
|
|
// // return this._groups
|
|
// // .filter(g => g.resources.elements.length > 0 || !g.features.hideWhenEmpty);
|
|
// }
|
|
|
|
private readonly _onDidChangeResources = new Emitter<void>();
|
|
readonly onDidChangeResources: Event<void> = this._onDidChangeResources.event;
|
|
|
|
private features: SCMProviderFeatures = {};
|
|
|
|
get handle(): number { return this._handle; }
|
|
get label(): string { return this._label; }
|
|
get rootUri(): URI | undefined { return this._rootUri; }
|
|
get contextValue(): string { return this._contextValue; }
|
|
|
|
get commitTemplate(): string { return this.features.commitTemplate || ''; }
|
|
get acceptInputCommand(): Command | undefined { return this.features.acceptInputCommand; }
|
|
get statusBarCommands(): Command[] | undefined { return this.features.statusBarCommands; }
|
|
get count(): number | undefined { return this.features.count; }
|
|
|
|
private readonly _onDidChangeCommitTemplate = new Emitter<string>();
|
|
readonly onDidChangeCommitTemplate: Event<string> = this._onDidChangeCommitTemplate.event;
|
|
|
|
private readonly _onDidChangeStatusBarCommands = new Emitter<Command[]>();
|
|
get onDidChangeStatusBarCommands(): Event<Command[]> { return this._onDidChangeStatusBarCommands.event; }
|
|
|
|
private readonly _onDidChange = new Emitter<void>();
|
|
readonly onDidChange: Event<void> = this._onDidChange.event;
|
|
|
|
constructor(
|
|
private readonly proxy: ExtHostSCMShape,
|
|
private readonly _handle: number,
|
|
private readonly _contextValue: string,
|
|
private readonly _label: string,
|
|
private readonly _rootUri: URI | undefined
|
|
) { }
|
|
|
|
$updateSourceControl(features: SCMProviderFeatures): void {
|
|
this.features = { ...this.features, ...features };
|
|
this._onDidChange.fire();
|
|
|
|
if (typeof features.commitTemplate !== 'undefined') {
|
|
this._onDidChangeCommitTemplate.fire(this.commitTemplate!);
|
|
}
|
|
|
|
if (typeof features.statusBarCommands !== 'undefined') {
|
|
this._onDidChangeStatusBarCommands.fire(this.statusBarCommands!);
|
|
}
|
|
}
|
|
|
|
$registerGroups(_groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures][]): void {
|
|
const groups = _groups.map(([handle, id, label, features]) => {
|
|
const group = new MainThreadSCMResourceGroup(
|
|
this.handle,
|
|
handle,
|
|
this,
|
|
features,
|
|
label,
|
|
id
|
|
);
|
|
|
|
this._groupsByHandle[handle] = group;
|
|
return group;
|
|
});
|
|
|
|
this.groups.splice(this.groups.elements.length, 0, groups);
|
|
}
|
|
|
|
$updateGroup(handle: number, features: SCMGroupFeatures): void {
|
|
const group = this._groupsByHandle[handle];
|
|
|
|
if (!group) {
|
|
return;
|
|
}
|
|
|
|
group.$updateGroup(features);
|
|
}
|
|
|
|
$updateGroupLabel(handle: number, label: string): void {
|
|
const group = this._groupsByHandle[handle];
|
|
|
|
if (!group) {
|
|
return;
|
|
}
|
|
|
|
group.$updateGroupLabel(label);
|
|
}
|
|
|
|
$spliceGroupResourceStates(splices: SCMRawResourceSplices[]): void {
|
|
for (const [groupHandle, groupSlices] of splices) {
|
|
const group = this._groupsByHandle[groupHandle];
|
|
|
|
if (!group) {
|
|
console.warn(`SCM group ${groupHandle} not found in provider ${this.label}`);
|
|
continue;
|
|
}
|
|
|
|
// reverse the splices sequence in order to apply them correctly
|
|
groupSlices.reverse();
|
|
|
|
for (const [start, deleteCount, rawResources] of groupSlices) {
|
|
const resources = rawResources.map(rawResource => {
|
|
const [handle, sourceUri, icons, tooltip, strikeThrough, faded, contextValue, command] = rawResource;
|
|
const icon = icons[0];
|
|
const iconDark = icons[1] || icon;
|
|
const decorations = {
|
|
icon: icon ? URI.revive(icon) : undefined,
|
|
iconDark: iconDark ? URI.revive(iconDark) : undefined,
|
|
tooltip,
|
|
strikeThrough,
|
|
faded
|
|
};
|
|
|
|
return new MainThreadSCMResource(
|
|
this.proxy,
|
|
this.handle,
|
|
groupHandle,
|
|
handle,
|
|
URI.revive(sourceUri),
|
|
group,
|
|
decorations,
|
|
contextValue || undefined,
|
|
command
|
|
);
|
|
});
|
|
|
|
group.splice(start, deleteCount, resources);
|
|
}
|
|
}
|
|
|
|
this._onDidChangeResources.fire();
|
|
}
|
|
|
|
$unregisterGroup(handle: number): void {
|
|
const group = this._groupsByHandle[handle];
|
|
|
|
if (!group) {
|
|
return;
|
|
}
|
|
|
|
delete this._groupsByHandle[handle];
|
|
this.groups.splice(this.groups.elements.indexOf(group), 1);
|
|
this._onDidChangeResources.fire();
|
|
}
|
|
|
|
async getOriginalResource(uri: URI): Promise<URI | null> {
|
|
if (!this.features.hasQuickDiffProvider) {
|
|
return null;
|
|
}
|
|
|
|
const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
|
|
return result && URI.revive(result);
|
|
}
|
|
|
|
toJSON(): any {
|
|
return {
|
|
$mid: 5,
|
|
handle: this.handle
|
|
};
|
|
}
|
|
|
|
dispose(): void {
|
|
|
|
}
|
|
}
|
|
|
|
@extHostNamedCustomer(MainContext.MainThreadSCM)
|
|
export class MainThreadSCM implements MainThreadSCMShape {
|
|
|
|
private readonly _proxy: ExtHostSCMShape;
|
|
private _repositories = new Map<number, ISCMRepository>();
|
|
private _repositoryDisposables = new Map<number, IDisposable>();
|
|
private readonly _disposables = new DisposableStore();
|
|
|
|
constructor(
|
|
extHostContext: IExtHostContext,
|
|
@ISCMService private readonly scmService: ISCMService,
|
|
@ISCMViewService private readonly scmViewService: ISCMViewService
|
|
) {
|
|
this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSCM);
|
|
}
|
|
|
|
dispose(): void {
|
|
this._repositories.forEach(r => r.dispose());
|
|
this._repositories.clear();
|
|
|
|
this._repositoryDisposables.forEach(d => d.dispose());
|
|
this._repositoryDisposables.clear();
|
|
|
|
this._disposables.dispose();
|
|
}
|
|
|
|
$registerSourceControl(handle: number, id: string, label: string, rootUri: UriComponents | undefined): void {
|
|
const provider = new MainThreadSCMProvider(this._proxy, handle, id, label, rootUri ? URI.revive(rootUri) : undefined);
|
|
const repository = this.scmService.registerSCMProvider(provider);
|
|
this._repositories.set(handle, repository);
|
|
|
|
const disposable = combinedDisposable(
|
|
Event.filter(this.scmViewService.onDidFocusRepository, r => r === repository)(_ => this._proxy.$setSelectedSourceControl(handle)),
|
|
repository.input.onDidChange(({ value }) => this._proxy.$onInputBoxValueChange(handle, value))
|
|
);
|
|
|
|
if (this.scmViewService.focusedRepository === repository) {
|
|
setTimeout(() => this._proxy.$setSelectedSourceControl(handle), 0);
|
|
}
|
|
|
|
if (repository.input.value) {
|
|
setTimeout(() => this._proxy.$onInputBoxValueChange(handle, repository.input.value), 0);
|
|
}
|
|
|
|
this._repositoryDisposables.set(handle, disposable);
|
|
}
|
|
|
|
$updateSourceControl(handle: number, features: SCMProviderFeatures): void {
|
|
const repository = this._repositories.get(handle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$updateSourceControl(features);
|
|
}
|
|
|
|
$unregisterSourceControl(handle: number): void {
|
|
const repository = this._repositories.get(handle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
this._repositoryDisposables.get(handle)!.dispose();
|
|
this._repositoryDisposables.delete(handle);
|
|
|
|
repository.dispose();
|
|
this._repositories.delete(handle);
|
|
}
|
|
|
|
$registerGroups(sourceControlHandle: number, groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures][], splices: SCMRawResourceSplices[]): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$registerGroups(groups);
|
|
provider.$spliceGroupResourceStates(splices);
|
|
}
|
|
|
|
$updateGroup(sourceControlHandle: number, groupHandle: number, features: SCMGroupFeatures): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$updateGroup(groupHandle, features);
|
|
}
|
|
|
|
$updateGroupLabel(sourceControlHandle: number, groupHandle: number, label: string): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$updateGroupLabel(groupHandle, label);
|
|
}
|
|
|
|
$spliceResourceStates(sourceControlHandle: number, splices: SCMRawResourceSplices[]): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$spliceGroupResourceStates(splices);
|
|
}
|
|
|
|
$unregisterGroup(sourceControlHandle: number, handle: number): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
const provider = repository.provider as MainThreadSCMProvider;
|
|
provider.$unregisterGroup(handle);
|
|
}
|
|
|
|
$setInputBoxValue(sourceControlHandle: number, value: string): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
repository.input.setValue(value, false);
|
|
}
|
|
|
|
$setInputBoxPlaceholder(sourceControlHandle: number, placeholder: string): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
repository.input.placeholder = placeholder;
|
|
}
|
|
|
|
$setInputBoxVisibility(sourceControlHandle: number, visible: boolean): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
repository.input.visible = visible;
|
|
}
|
|
|
|
$setInputBoxFocus(sourceControlHandle: number): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
repository.input.setFocus();
|
|
}
|
|
|
|
$showValidationMessage(sourceControlHandle: number, message: string, type: InputValidationType) {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
repository.input.showValidationMessage(message, type);
|
|
}
|
|
|
|
$setValidationProviderIsEnabled(sourceControlHandle: number, enabled: boolean): void {
|
|
const repository = this._repositories.get(sourceControlHandle);
|
|
|
|
if (!repository) {
|
|
return;
|
|
}
|
|
|
|
if (enabled) {
|
|
repository.input.validateInput = async (value, pos): Promise<IInputValidation | undefined> => {
|
|
const result = await this._proxy.$validateInput(sourceControlHandle, value, pos);
|
|
return result && { message: result[0], type: result[1] };
|
|
};
|
|
} else {
|
|
repository.input.validateInput = async () => undefined;
|
|
}
|
|
}
|
|
}
|