var id;

// Need to walk all open documents and check for matching path. We can't

// use getFileForPath(fullPath).id since the file it returns won't match

// an Untitled document's InMemoryFile.

for (id in _openDocuments) {

if (_openDocuments.hasOwnProperty(id)) {

if (_openDocuments[id].file.fullPath === fullPath) {

return _openDocuments[id];

}

}

}

return null;

var file = MainViewManager.getCurrentlyViewedFile(MainViewManager.ACTIVE_PANE);

if (file) {

return getOpenDocumentForPath(file.fullPath);

}

return null;

DeprecationWarning.deprecationWarning("Use MainViewManager.getWorkingSet() instead of DocumentManager.getWorkingSet()", true);

return MainViewManager.getWorkingSet(MainViewManager.ALL_PANES)

.filter(function (file) {

// Legacy didn't allow for files with custom viewers

return !MainViewFactory.findSuitableFactoryForPath(file.fullPath);

});

var result = [];

var id;

for (id in _openDocuments) {

if (_openDocuments.hasOwnProperty(id)) {

result.push(_openDocuments[id]);

}

}

return result;

DeprecationWarning.deprecationWarning("Use MainViewManager.traverseToNextViewByMRU() instead of DocumentManager.getNextPrevFile()", true);

var result = MainViewManager.traverseToNextViewByMRU(inc);

if (result) {

return result.file;

}

return null;

getAllOpenDocuments().forEach(function (doc) {

// Is the only ref to this document its own master Editor?

if (doc._refCount === 1 && doc._masterEditor) {

// Destroy the Editor if it's not being kept alive by the UI

MainViewManager._destroyEditorIfNotNeeded(doc);

}

});

var doc = getOpenDocumentForPath(fullPath);

if (doc) {

// use existing document

return new $.Deferred().resolve(doc).promise();

} else {

var result = new $.Deferred(),

promise = result.promise();

// return null in case of untitled documents

if (fullPath.indexOf(_untitledDocumentPath) === 0) {

result.resolve(null);

return promise;

}

var file = fileObj || FileSystem.getFileForPath(fullPath),

pendingPromise = getDocumentForPath._pendingDocumentPromises[file.id];

if (pendingPromise) {

// wait for the result of a previous request

return pendingPromise;

} else {

// log this document's Promise as pending

getDocumentForPath._pendingDocumentPromises[file.id] = promise;

// create a new document

var perfTimerName = PerfUtils.markStart("getDocumentForPath:\t" + fullPath);

result.done(function () {

PerfUtils.addMeasurement(perfTimerName);

}).fail(function () {

PerfUtils.finalizeMeasurement(perfTimerName);

});

FileUtils.readAsText(file)

.always(function () {

// document is no longer pending

delete getDocumentForPath._pendingDocumentPromises[file.id];

})

.done(function (rawText, readTimestamp) {

doc = new DocumentModule.Document(file, readTimestamp, rawText);

// This is a good point to clean up any old dangling Documents

_gcDocuments();

result.resolve(doc);

})

.fail(function (fileError) {

result.reject(fileError);

});

return promise;

}

}

var result = new $.Deferred(),

doc = getOpenDocumentForPath(file.fullPath);

if (doc) {

result.resolve(doc.getText(), doc.diskTimestamp, checkLineEndings ? doc._lineEndings : null);

} else {

file.read(function (err, contents, encoding, stat) {

if (err) {

result.reject(err);

} else {

// Normalize line endings the same way Document would, but don't actually

// new up a Document (which entails a bunch of object churn).

var originalLineEndings = checkLineEndings ? FileUtils.sniffLineEndings(contents) : null;

contents = DocumentModule.Document.normalizeText(contents);

result.resolve(contents, stat.mtime, originalLineEndings);

}

});

}

return result.promise();

var filename = Strings.UNTITLED + "-" + counter + fileExt,

fullPath = _untitledDocumentPath + "/" + filename,

now = new Date(),

file = new InMemoryFile(fullPath, FileSystem);

FileSystem.addEntryForPathIfRequired(file, fullPath);

return new DocumentModule.Document(file, now, "");

// Notify all editors to close as well

exports.trigger("pathDeleted", file.fullPath);

var doc = getOpenDocumentForPath(file.fullPath);

if (doc) {

doc.trigger("deleted");

}

// At this point, all those other views SHOULD have released the Doc

if (doc && doc._refCount > 0) {

console.warn("Deleted " + file.fullPath + " Document still has " + doc._refCount + " references. Did someone addRef() without listening for 'deleted'?");

}

// FileSyncManager.syncOpenDocuments() does all the work prompting

// the user to save any unsaved changes and then calls us back

// via notifyFileDeleted

FileSyncManager.syncOpenDocuments(Strings.FILE_DELETED_TITLE);

var projectRoot = ProjectManager.getProjectRoot(),

context = {

location : {

scope: "user",

layer: "project",

layerID: projectRoot.fullPath

}

};

var encoding = PreferencesManager.getViewState("encoding", context);

delete encoding[fullPath];

PreferencesManager.setViewState("encoding", encoding, context);

if (!getOpenDocumentForPath(fullPath) &&

!MainViewManager.findInAllWorkingSets(fullPath).length) {

// For images not open in the workingset,

// FileSyncManager.syncOpenDocuments() will

// not tell us to close those views

exports.trigger("pathDeleted", fullPath);

}

// Notify all open documents

_.forEach(_openDocuments, function (doc) {

// TODO: Only notify affected documents? For now _notifyFilePathChange

// just updates the language if the extension changed, so it's fine

// to call for all open docs.

doc._notifyFilePathChanged();

});

// Send a "fileNameChange" event. This will trigger the views to update.

exports.trigger("fileNameChange", oldName, newName);

_.forEach(_openDocuments, function (doc) {

// No need to look at the new language if this document has one already

if (doc.getLanguage().isFallbackLanguage()) {

doc._updateLanguage();

}

});

_.forEach(_openDocuments, function (doc) {

var docLanguage = doc.getLanguage();

// A modified language can affect a document

// - if its language was modified

// - if the document doesn't have a language yet and its file extension was added to the modified language

if (docLanguage === language || docLanguage.isFallbackLanguage()) {

doc._updateLanguage();

}

});

DeprecationWarning.deprecateEvent(exports,

MainViewManager,

eventName,

eventName,

"DocumentManager." + eventName,

"MainViewManager." + eventName);