private _setIndentConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
if (newConfiguration.tabSize === 'auto' || newConfiguration.insertSpaces === 'auto') {
// one of the options was set to 'auto' => detect indentation
let creationOpts = this._modelService.getCreationOptions(this._model.getLanguageIdentifier().language, this._model.uri, this._model.isForSimpleWidget);
let insertSpaces = creationOpts.insertSpaces;
let tabSize = creationOpts.tabSize;
if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
insertSpaces = newConfiguration.insertSpaces;
}
if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
tabSize = newConfiguration.tabSize;
}
this._model.detectIndentation(insertSpaces, tabSize);
return;
}
let newOpts: ITextModelUpdateOptions = {};
if (typeof newConfiguration.insertSpaces !== 'undefined') {
newOpts.insertSpaces = newConfiguration.insertSpaces;
}
if (typeof newConfiguration.tabSize !== 'undefined') {
newOpts.tabSize = newConfiguration.tabSize;
}
this._model.updateOptions(newOpts);
}
export function getConfiguredLangId(modelService: IModelService, modeService: IModeService, resource: uri): string | null {
let configuredLangId: string | null = null;
if (resource) {
let modeId: string | null = null;
// Data URI: check for encoded metadata
if (resource.scheme === Schemas.data) {
const metadata = DataUri.parseMetaData(resource);
const mime = metadata.get(DataUri.META_DATA_MIME);
if (mime) {
modeId = modeService.getModeId(mime);
}
}
// Any other URI: check for model if existing
else {
const model = modelService.getModel(resource);
if (model) {
modeId = model.getLanguageIdentifier().language;
}
}
if (modeId && modeId !== PLAINTEXT_MODE_ID) {
configuredLangId = modeId; // only take if the mode is specific (aka no just plain text)
}
}
return configuredLangId;
}
constructor(problemMatchers: ProblemMatcher[], protected markerService: IMarkerService, private modelService: IModelService) {
this.matchers = Object.create(null);
this.bufferLength = 1;
problemMatchers.map(elem => createLineMatcher(elem)).forEach((matcher) => {
let length = matcher.matchLength;
if (length > this.bufferLength) {
this.bufferLength = length;
}
let value = this.matchers[length];
if (!value) {
value = [];
this.matchers[length] = value;
}
value.push(matcher);
});
this.buffer = [];
this.activeMatcher = null;
this._numberOfMatches = 0;
this._maxMarkerSeverity = undefined;
this.openModels = Object.create(null);
this.modelListeners = [];
this.applyToByOwner = new Map<string, ApplyToKind>();
for (let problemMatcher of problemMatchers) {
let current = this.applyToByOwner.get(problemMatcher.owner);
if (current === void 0) {
this.applyToByOwner.set(problemMatcher.owner, problemMatcher.applyTo);
} else {
this.applyToByOwner.set(problemMatcher.owner, this.mergeApplyTo(current, problemMatcher.applyTo));
}
}
this.resourcesToClean = new Map<string, Map<string, URI>>();
this.markers = new Map<string, Map<string, Map<string, IMarkerData>>>();
this.deliveredMarkers = new Map<string, Map<string, number>>();
this.modelService.onModelAdded((model) => {
this.openModels[model.uri.toString()] = true;
}, this, this.modelListeners);
this.modelService.onModelRemoved((model) => {
delete this.openModels[model.uri.toString()];
}, this, this.modelListeners);
this.modelService.getModels().forEach(model => this.openModels[model.uri.toString()] = true);
this._onDidStateChange = new Emitter();
}
export function getConfiguredLangId(modelService: IModelService, resource: uri): string | null {
let configuredLangId: string | null = null;
if (resource) {
const model = modelService.getModel(resource);
if (model) {
const modeId = model.getLanguageIdentifier().language;
if (modeId && modeId !== PLAINTEXT_MODE_ID) {
configuredLangId = modeId; // only take if the mode is specific (aka no just plain text)
}
}
}
return configuredLangId;
}
export function detectModeId(modelService: IModelService, modeService: IModeService, resource: uri): string | null {
if (!resource) {
return null; // we need a resource at least
}
let modeId: string | null = null;
// Data URI: check for encoded metadata
if (resource.scheme === Schemas.data) {
const metadata = DataUri.parseMetaData(resource);
const mime = metadata.get(DataUri.META_DATA_MIME);
if (mime) {
modeId = modeService.getModeId(mime);
}
}
// Any other URI: check for model if existing
else {
const model = modelService.getModel(resource);
if (model) {
modeId = model.getModeId();
}
}
// only take if the mode is specific (aka no just plain text)
if (modeId && modeId !== PLAINTEXT_MODE_ID) {
return modeId;
}
// otherwise fallback to path based detection
let path: string | undefined;
if (resource.scheme === Schemas.data) {
const metadata = DataUri.parseMetaData(resource);
path = metadata.get(DataUri.META_DATA_LABEL);
} else {
path = resource.path.toLowerCase();
}
if (path) {
return modeService.getModeIdByFilepathOrFirstLine(path);
}
return null; // finally - we do not know the mode id
}
return editorWorkerService.textualSuggest(resource, position).then((textualSuggestions) => {
let model = modelService.getModel(resource);
let result = _addSuggestionsAtPosition(model, position, predefined, textualSuggestions);
return result;
});
suggest: (resource, position) => {
let model = modelService.getModel(resource);
let result = _addSuggestionsAtPosition(model, position, predefined, null);
return TPromise.as(result);
}