export function getOutOfWorkspaceEditorResources(editorGroupService: IEditorGroupService, contextService: IWorkspaceContextService): URI[] {
const resources: URI[] = [];
editorGroupService.getStacksModel().groups.forEach(group => {
const editors = group.getEditors();
editors.forEach(editor => {
const resource = toResource(editor, { supportSideBySide: true });
if (resource && !contextService.isInsideWorkspace(resource)) {
resources.push(resource);
}
});
});
return resources;
}
function save(resource: URI, isSaveAs: boolean, editorService: IWorkbenchEditorService, fileService: IFileService, untitledEditorService: IUntitledEditorService,
textFileService: ITextFileService, editorGroupService: IEditorGroupService): TPromise<any> {
if (resource && (fileService.canHandleResource(resource) || resource.scheme === Schemas.untitled)) {
// Save As (or Save untitled with associated path)
if (isSaveAs || resource.scheme === Schemas.untitled) {
let encodingOfSource: string;
if (resource.scheme === Schemas.untitled) {
encodingOfSource = untitledEditorService.getEncoding(resource);
} else if (fileService.canHandleResource(resource)) {
const textModel = textFileService.models.get(resource);
encodingOfSource = textModel && textModel.getEncoding(); // text model can be null e.g. if this is a binary file!
}
let viewStateOfSource: IEditorViewState;
const activeEditor = editorService.getActiveEditor();
const editor = getCodeEditor(activeEditor);
if (editor) {
const activeResource = toResource(activeEditor.input, { supportSideBySide: true });
if (activeResource && (fileService.canHandleResource(activeResource) || resource.scheme === Schemas.untitled) && activeResource.toString() === resource.toString()) {
viewStateOfSource = editor.saveViewState();
}
}
// Special case: an untitled file with associated path gets saved directly unless "saveAs" is true
let savePromise: TPromise<URI>;
if (!isSaveAs && resource.scheme === Schemas.untitled && untitledEditorService.hasAssociatedFilePath(resource)) {
savePromise = textFileService.save(resource).then((result) => {
if (result) {
return URI.file(resource.fsPath);
}
return null;
});
}
// Otherwise, really "Save As..."
else {
savePromise = textFileService.saveAs(resource);
}
return savePromise.then((target) => {
if (!target || target.toString() === resource.toString()) {
return void 0; // save canceled or same resource used
}
const replaceWith: IResourceInput = {
resource: target,
encoding: encodingOfSource,
options: {
pinned: true,
viewState: viewStateOfSource
}
};
return editorService.replaceEditors([{
toReplace: { resource: resource },
replaceWith
}]).then(() => true);
});
}
// Pin the active editor if we are saving it
const editor = editorService.getActiveEditor();
const activeEditorResource = editor && editor.input && editor.input.getResource();
if (activeEditorResource && activeEditorResource.toString() === resource.toString()) {
editorGroupService.pinEditor(editor.position, editor.input);
}
// Just save
return textFileService.save(resource, { force: true /* force a change to the file to trigger external watchers if any */ });
}
return TPromise.as(false);
}
function saveAll(saveAllArguments: any, editorService: IWorkbenchEditorService, untitledEditorService: IUntitledEditorService,
textFileService: ITextFileService, editorGroupService: IEditorGroupService): TPromise<any> {
const stacks = editorGroupService.getStacksModel();
// Store some properties per untitled file to restore later after save is completed
const mapUntitledToProperties: { [resource: string]: { encoding: string; indexInGroups: number[]; activeInGroups: boolean[] } } = Object.create(null);
untitledEditorService.getDirty().forEach(resource => {
const activeInGroups: boolean[] = [];
const indexInGroups: number[] = [];
const encoding = untitledEditorService.getEncoding(resource);
// For each group
stacks.groups.forEach((group, groupIndex) => {
// Find out if editor is active in group
const activeEditor = group.activeEditor;
const activeResource = toResource(activeEditor, { supportSideBySide: true });
activeInGroups[groupIndex] = (activeResource && activeResource.toString() === resource.toString());
// Find index of editor in group
indexInGroups[groupIndex] = -1;
group.getEditors().forEach((editor, editorIndex) => {
const editorResource = toResource(editor, { supportSideBySide: true });
if (editorResource && editorResource.toString() === resource.toString()) {
indexInGroups[groupIndex] = editorIndex;
return;
}
});
});
mapUntitledToProperties[resource.toString()] = { encoding, indexInGroups, activeInGroups };
});
// Save all
return textFileService.saveAll(saveAllArguments).then(results => {
// Reopen saved untitled editors
const untitledToReopen: { input: IResourceInput, position: Position }[] = [];
results.results.forEach(result => {
if (!result.success || result.source.scheme !== Schemas.untitled) {
return;
}
const untitledProps = mapUntitledToProperties[result.source.toString()];
if (!untitledProps) {
return;
}
// For each position where the untitled file was opened
untitledProps.indexInGroups.forEach((indexInGroup, index) => {
if (indexInGroup >= 0) {
untitledToReopen.push({
input: {
resource: result.target,
encoding: untitledProps.encoding,
options: {
pinned: true,
index: indexInGroup,
preserveFocus: true,
inactive: !untitledProps.activeInGroups[index]
}
},
position: index
});
}
});
});
if (untitledToReopen.length) {
return editorService.openEditors(untitledToReopen).then(() => true);
}
return void 0;
});
}