Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "_cmdDownloadFile", "(", "downloadId", ",", "url", ",", "proxy", ",", "callback", ",", "pCallback", ")", "{", "// Backwards compatibility check, added in 0.37", "if", "(", "typeof", "proxy", "===", "\"function\"", ")", "{", "callback", "=", "proxy", ";", "proxy", "=", "undefined", ";", "}", "if", "(", "pendingDownloads", "[", "downloadId", "]", ")", "{", "callback", "(", "Errors", ".", "DOWNLOAD_ID_IN_USE", ",", "null", ")", ";", "return", ";", "}", "var", "req", "=", "request", ".", "get", "(", "{", "url", ":", "url", ",", "encoding", ":", "null", ",", "proxy", ":", "proxy", "}", ",", "// Note: we could use the traditional \"response\"/\"data\"/\"end\" events too if we wanted to stream data", "// incrementally, limit download size, etc. - but the simple callback is good enough for our needs.", "function", "(", "error", ",", "response", ",", "body", ")", "{", "if", "(", "error", ")", "{", "// Usually means we never got a response - server is down, no DNS entry, etc.", "_endDownload", "(", "downloadId", ",", "Errors", ".", "NO_SERVER_RESPONSE", ")", ";", "return", ";", "}", "if", "(", "response", ".", "statusCode", "!==", "200", ")", "{", "_endDownload", "(", "downloadId", ",", "[", "Errors", ".", "BAD_HTTP_STATUS", ",", "response", ".", "statusCode", "]", ")", ";", "return", ";", "}", "var", "stream", "=", "temp", ".", "createWriteStream", "(", "\"brackets\"", ")", ";", "if", "(", "!", "stream", ")", "{", "_endDownload", "(", "downloadId", ",", "Errors", ".", "CANNOT_WRITE_TEMP", ")", ";", "return", ";", "}", "pendingDownloads", "[", "downloadId", "]", ".", "localPath", "=", "stream", ".", "path", ";", "pendingDownloads", "[", "downloadId", "]", ".", "outStream", "=", "stream", ";", "stream", ".", "write", "(", "body", ")", ";", "_endDownload", "(", "downloadId", ")", ";", "}", ")", ";", "pendingDownloads", "[", "downloadId", "]", "=", "{", "request", ":", "req", ",", "callback", ":", "callback", "}", ";", "}" ]

[ "Implements", "downloadFile", "command", "asynchronously", "." ]

[ "function", "_cmdAbortDownload", "(", "downloadId", ")", "{", "if", "(", "!", "pendingDownloads", "[", "downloadId", "]", ")", "{", "// This may mean the download already completed", "return", "false", ";", "}", "else", "{", "_endDownload", "(", "downloadId", ",", "Errors", ".", "CANCELED", ")", ";", "return", "true", ";", "}", "}" ]

[ "Implements", "abortDownload", "command", "synchronously", "." ]

[ "function", "_cmdRemove", "(", "extensionDir", ",", "callback", ",", "pCallback", ")", "{", "fs", ".", "remove", "(", "extensionDir", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "callback", "(", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Implements", "the", "remove", "extension", "command", "." ]

[ "function", "registerProtocolAdapter", "(", "protocol", ",", "adapter", ")", "{", "var", "adapters", ";", "if", "(", "protocol", ")", "{", "adapters", "=", "_fileProtocolPlugins", "[", "protocol", "]", "||", "[", "]", ";", "adapters", ".", "push", "(", "adapter", ")", ";", "// We will keep a sorted adapter list on 'priority'", "// If priority is not provided a default of '0' is assumed", "adapters", ".", "sort", "(", "function", "(", "a", ",", "b", ")", "{", "return", "(", "b", ".", "priority", "||", "0", ")", "-", "(", "a", ".", "priority", "||", "0", ")", ";", "}", ")", ";", "_fileProtocolPlugins", "[", "protocol", "]", "=", "adapters", ";", "}", "}" ]

[ "Typical", "signature", "of", "a", "file", "protocol", "adapter", "." ]

[ "function", "downloadRegistry", "(", ")", "{", "if", "(", "pendingDownloadRegistry", ")", "{", "return", "pendingDownloadRegistry", ".", "promise", "(", ")", ";", "}", "pendingDownloadRegistry", "=", "new", "$", ".", "Deferred", "(", ")", ";", "$", ".", "ajax", "(", "{", "url", ":", "brackets", ".", "config", ".", "extension_registry", ",", "dataType", ":", "\"json\"", ",", "cache", ":", "false", "}", ")", ".", "done", "(", "function", "(", "data", ")", "{", "exports", ".", "hasDownloadedRegistry", "=", "true", ";", "Object", ".", "keys", "(", "data", ")", ".", "forEach", "(", "function", "(", "id", ")", "{", "if", "(", "!", "extensions", "[", "id", "]", ")", "{", "extensions", "[", "id", "]", "=", "{", "}", ";", "}", "extensions", "[", "id", "]", ".", "registryInfo", "=", "data", "[", "id", "]", ";", "synchronizeEntry", "(", "id", ")", ";", "}", ")", ";", "exports", ".", "trigger", "(", "\"registryDownload\"", ")", ";", "pendingDownloadRegistry", ".", "resolve", "(", ")", ";", "}", ")", ".", "fail", "(", "function", "(", ")", "{", "pendingDownloadRegistry", ".", "reject", "(", ")", ";", "}", ")", ".", "always", "(", "function", "(", ")", "{", "// Make sure to clean up the pending registry so that new requests can be made.", "pendingDownloadRegistry", "=", "null", ";", "}", ")", ";", "return", "pendingDownloadRegistry", ".", "promise", "(", ")", ";", "}" ]

[ "Downloads", "the", "registry", "of", "Brackets", "extensions", "and", "stores", "the", "information", "in", "our", "extension", "info", "." ]

[ "function", "getCompatibilityInfo", "(", "entry", ",", "apiVersion", ")", "{", "if", "(", "!", "entry", ".", "versions", ")", "{", "var", "fallback", "=", "getCompatibilityInfoForVersion", "(", "entry", ".", "metadata", ",", "apiVersion", ")", ";", "if", "(", "fallback", ".", "isCompatible", ")", "{", "fallback", ".", "isLatestVersion", "=", "true", ";", "}", "return", "fallback", ";", "}", "var", "i", "=", "entry", ".", "versions", ".", "length", "-", "1", ",", "latestInfo", "=", "getCompatibilityInfoForVersion", "(", "entry", ".", "versions", "[", "i", "]", ",", "apiVersion", ")", ";", "if", "(", "latestInfo", ".", "isCompatible", ")", "{", "latestInfo", ".", "isLatestVersion", "=", "true", ";", "return", "latestInfo", ";", "}", "else", "{", "// Look at earlier versions (skipping very latest version since we already checked it)", "for", "(", "i", "--", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "var", "compatInfo", "=", "getCompatibilityInfoForVersion", "(", "entry", ".", "versions", "[", "i", "]", ",", "apiVersion", ")", ";", "if", "(", "compatInfo", ".", "isCompatible", ")", "{", "compatInfo", ".", "isLatestVersion", "=", "false", ";", "compatInfo", ".", "requiresNewer", "=", "latestInfo", ".", "requiresNewer", ";", "return", "compatInfo", ";", "}", "}", "// No version is compatible, so just return info for the latest version", "return", "latestInfo", ";", "}", "}" ]

[ "Finds", "the", "newest", "version", "of", "the", "entry", "that", "is", "compatible", "with", "the", "given", "Brackets", "API", "version", "if", "any", "." ]

[ "function", "getExtensionURL", "(", "id", ",", "version", ")", "{", "return", "StringUtils", ".", "format", "(", "brackets", ".", "config", ".", "extension_url", ",", "id", ",", "version", ")", ";", "}" ]

[ "Given", "an", "extension", "id", "and", "version", "number", "returns", "the", "URL", "for", "downloading", "that", "extension", "from", "the", "repository", ".", "Does", "not", "guarantee", "that", "the", "extension", "exists", "at", "that", "URL", "." ]

[ "function", "remove", "(", "id", ")", "{", "var", "result", "=", "new", "$", ".", "Deferred", "(", ")", ";", "if", "(", "extensions", "[", "id", "]", "&&", "extensions", "[", "id", "]", ".", "installInfo", ")", "{", "Package", ".", "remove", "(", "extensions", "[", "id", "]", ".", "installInfo", ".", "path", ")", ".", "done", "(", "function", "(", ")", "{", "extensions", "[", "id", "]", ".", "installInfo", "=", "null", ";", "result", ".", "resolve", "(", ")", ";", "exports", ".", "trigger", "(", "\"statusChange\"", ",", "id", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "err", ")", "{", "result", ".", "reject", "(", "err", ")", ";", "}", ")", ";", "}", "else", "{", "result", ".", "reject", "(", "StringUtils", ".", "format", "(", "Strings", ".", "EXTENSION_NOT_INSTALLED", ",", "id", ")", ")", ";", "}", "return", "result", ".", "promise", "(", ")", ";", "}" ]

[ "Removes", "the", "installed", "extension", "with", "the", "given", "id", "." ]

[ "function", "update", "(", "id", ",", "packagePath", ",", "keepFile", ")", "{", "return", "Package", ".", "installUpdate", "(", "packagePath", ",", "id", ")", ".", "done", "(", "function", "(", ")", "{", "if", "(", "!", "keepFile", ")", "{", "FileSystem", ".", "getFileForPath", "(", "packagePath", ")", ".", "unlink", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Updates", "an", "installed", "extension", "with", "the", "given", "package", "file", "." ]

[ "function", "cleanupUpdates", "(", ")", "{", "Object", ".", "keys", "(", "_idsToUpdate", ")", ".", "forEach", "(", "function", "(", "id", ")", "{", "var", "installResult", "=", "_idsToUpdate", "[", "id", "]", ",", "keepFile", "=", "installResult", ".", "keepFile", ",", "filename", "=", "installResult", ".", "localPath", ";", "if", "(", "filename", "&&", "!", "keepFile", ")", "{", "FileSystem", ".", "getFileForPath", "(", "filename", ")", ".", "unlink", "(", ")", ";", "}", "}", ")", ";", "_idsToUpdate", "=", "{", "}", ";", "}" ]

[ "Deletes", "any", "temporary", "files", "left", "behind", "by", "extensions", "that", "were", "marked", "for", "update", "." ]

[ "function", "markForRemoval", "(", "id", ",", "mark", ")", "{", "if", "(", "mark", ")", "{", "_idsToRemove", "[", "id", "]", "=", "true", ";", "}", "else", "{", "delete", "_idsToRemove", "[", "id", "]", ";", "}", "exports", ".", "trigger", "(", "\"statusChange\"", ",", "id", ")", ";", "}" ]

[ "Marks", "an", "extension", "for", "later", "removal", "or", "unmarks", "an", "extension", "previously", "marked", "." ]

[ "function", "markForDisabling", "(", "id", ",", "mark", ")", "{", "if", "(", "mark", ")", "{", "_idsToDisable", "[", "id", "]", "=", "true", ";", "}", "else", "{", "delete", "_idsToDisable", "[", "id", "]", ";", "}", "exports", ".", "trigger", "(", "\"statusChange\"", ",", "id", ")", ";", "}" ]

[ "Marks", "an", "extension", "for", "disabling", "later", "or", "unmarks", "an", "extension", "previously", "marked", "." ]

[ "function", "updateFromDownload", "(", "installationResult", ")", "{", "if", "(", "installationResult", ".", "keepFile", "===", "undefined", ")", "{", "installationResult", ".", "keepFile", "=", "false", ";", "}", "var", "installationStatus", "=", "installationResult", ".", "installationStatus", ";", "if", "(", "installationStatus", "===", "Package", ".", "InstallationStatuses", ".", "ALREADY_INSTALLED", "||", "installationStatus", "===", "Package", ".", "InstallationStatuses", ".", "NEEDS_UPDATE", "||", "installationStatus", "===", "Package", ".", "InstallationStatuses", ".", "SAME_VERSION", "||", "installationStatus", "===", "Package", ".", "InstallationStatuses", ".", "OLDER_VERSION", ")", "{", "var", "id", "=", "installationResult", ".", "name", ";", "delete", "_idsToRemove", "[", "id", "]", ";", "_idsToUpdate", "[", "id", "]", "=", "installationResult", ";", "exports", ".", "trigger", "(", "\"statusChange\"", ",", "id", ")", ";", "}", "}" ]

[ "If", "a", "downloaded", "package", "appears", "to", "be", "an", "update", "mark", "the", "extension", "for", "update", ".", "If", "an", "extension", "was", "previously", "marked", "for", "removal", "marking", "for", "update", "will", "turn", "off", "the", "removal", "mark", "." ]

[ "function", "removeUpdate", "(", "id", ")", "{", "var", "installationResult", "=", "_idsToUpdate", "[", "id", "]", ";", "if", "(", "!", "installationResult", ")", "{", "return", ";", "}", "if", "(", "installationResult", ".", "localPath", "&&", "!", "installationResult", ".", "keepFile", ")", "{", "FileSystem", ".", "getFileForPath", "(", "installationResult", ".", "localPath", ")", ".", "unlink", "(", ")", ";", "}", "delete", "_idsToUpdate", "[", "id", "]", ";", "exports", ".", "trigger", "(", "\"statusChange\"", ",", "id", ")", ";", "}" ]

[ "Removes", "the", "mark", "for", "an", "extension", "to", "be", "updated", "on", "restart", ".", "Also", "deletes", "the", "downloaded", "package", "file", "." ]

[ "function", "updateExtensions", "(", ")", "{", "return", "Async", ".", "doInParallel_aggregateErrors", "(", "Object", ".", "keys", "(", "_idsToUpdate", ")", ",", "function", "(", "id", ")", "{", "var", "installationResult", "=", "_idsToUpdate", "[", "id", "]", ";", "return", "update", "(", "installationResult", ".", "name", ",", "installationResult", ".", "localPath", ",", "installationResult", ".", "keepFile", ")", ";", "}", ")", ";", "}" ]

[ "Updates", "extensions", "previously", "marked", "for", "update", "." ]

[ "function", "getAvailableUpdates", "(", ")", "{", "var", "result", "=", "[", "]", ";", "Object", ".", "keys", "(", "extensions", ")", ".", "forEach", "(", "function", "(", "extensionId", ")", "{", "var", "extensionInfo", "=", "extensions", "[", "extensionId", "]", ";", "// skip extensions that are not installed or are not in the registry", "if", "(", "!", "extensionInfo", ".", "installInfo", "||", "!", "extensionInfo", ".", "registryInfo", ")", "{", "return", ";", "}", "if", "(", "extensionInfo", ".", "registryInfo", ".", "updateCompatible", ")", "{", "result", ".", "push", "(", "{", "id", ":", "extensionId", ",", "installVersion", ":", "extensionInfo", ".", "installInfo", ".", "metadata", ".", "version", ",", "registryVersion", ":", "extensionInfo", ".", "registryInfo", ".", "lastCompatibleVersion", "}", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Gets", "an", "array", "of", "extensions", "that", "are", "currently", "installed", "and", "can", "be", "updated", "to", "a", "new", "version" ]

[ "function", "extract", "(", "scopes", ",", "parentStatement", ",", "expns", ",", "text", ",", "insertPosition", ")", "{", "var", "varType", "=", "\"var\"", ",", "varName", "=", "RefactoringUtils", ".", "getUniqueIdentifierName", "(", "scopes", ",", "\"extracted\"", ")", ",", "varDeclaration", "=", "varType", "+", "\" \"", "+", "varName", "+", "\" = \"", "+", "text", "+", "\";\\n\"", ",", "parentStatementStartPos", "=", "session", ".", "editor", ".", "posFromIndex", "(", "parentStatement", ".", "start", ")", ",", "insertStartPos", "=", "insertPosition", "||", "parentStatementStartPos", ",", "selections", "=", "[", "]", ",", "doc", "=", "session", ".", "editor", ".", "document", ",", "replaceExpnIndex", "=", "0", ",", "posToIndent", ",", "edits", "=", "[", "]", ";", "// If parent statement is expression statement, then just append var declaration", "// Ex: \"add(1, 2)\" will become \"var extracted = add(1, 2)\"", "if", "(", "parentStatement", ".", "type", "===", "\"ExpressionStatement\"", "&&", "RefactoringUtils", ".", "isEqual", "(", "parentStatement", ".", "expression", ",", "expns", "[", "0", "]", ")", "&&", "insertStartPos", ".", "line", "===", "parentStatementStartPos", ".", "line", "&&", "insertStartPos", ".", "ch", "===", "parentStatementStartPos", ".", "ch", ")", "{", "varDeclaration", "=", "varType", "+", "\" \"", "+", "varName", "+", "\" = \"", ";", "replaceExpnIndex", "=", "1", ";", "}", "posToIndent", "=", "doc", ".", "adjustPosForChange", "(", "insertStartPos", ",", "varDeclaration", ".", "split", "(", "\"\\n\"", ")", ",", "insertStartPos", ",", "insertStartPos", ")", ";", "// adjust pos for change", "for", "(", "var", "i", "=", "replaceExpnIndex", ";", "i", "<", "expns", ".", "length", ";", "++", "i", ")", "{", "expns", "[", "i", "]", ".", "start", "=", "session", ".", "editor", ".", "posFromIndex", "(", "expns", "[", "i", "]", ".", "start", ")", ";", "expns", "[", "i", "]", ".", "end", "=", "session", ".", "editor", ".", "posFromIndex", "(", "expns", "[", "i", "]", ".", "end", ")", ";", "expns", "[", "i", "]", ".", "start", "=", "doc", ".", "adjustPosForChange", "(", "expns", "[", "i", "]", ".", "start", ",", "varDeclaration", ".", "split", "(", "\"\\n\"", ")", ",", "insertStartPos", ",", "insertStartPos", ")", ";", "expns", "[", "i", "]", ".", "end", "=", "doc", ".", "adjustPosForChange", "(", "expns", "[", "i", "]", ".", "end", ",", "varDeclaration", ".", "split", "(", "\"\\n\"", ")", ",", "insertStartPos", ",", "insertStartPos", ")", ";", "edits", ".", "push", "(", "{", "edit", ":", "{", "text", ":", "varName", ",", "start", ":", "expns", "[", "i", "]", ".", "start", ",", "end", ":", "expns", "[", "i", "]", ".", "end", "}", ",", "selection", ":", "{", "start", ":", "expns", "[", "i", "]", ".", "start", ",", "end", ":", "{", "line", ":", "expns", "[", "i", "]", ".", "start", ".", "line", ",", "ch", ":", "expns", "[", "i", "]", ".", "start", ".", "ch", "+", "varName", ".", "length", "}", "}", "}", ")", ";", "}", "// Replace and multi-select", "doc", ".", "batchOperation", "(", "function", "(", ")", "{", "doc", ".", "replaceRange", "(", "varDeclaration", ",", "insertStartPos", ")", ";", "selections", "=", "doc", ".", "doMultipleEdits", "(", "edits", ")", ";", "selections", ".", "push", "(", "{", "start", ":", "{", "line", ":", "insertStartPos", ".", "line", ",", "ch", ":", "insertStartPos", ".", "ch", "+", "varType", ".", "length", "+", "1", "}", ",", "end", ":", "{", "line", ":", "insertStartPos", ".", "line", ",", "ch", ":", "insertStartPos", ".", "ch", "+", "varType", ".", "length", "+", "varName", ".", "length", "+", "1", "}", ",", "primary", ":", "true", "}", ")", ";", "session", ".", "editor", ".", "setSelections", "(", "selections", ")", ";", "session", ".", "editor", ".", "_codeMirror", ".", "indentLine", "(", "posToIndent", ".", "line", ",", "\"smart\"", ")", ";", "}", ")", ";", "}" ]

[ "Does", "the", "actual", "extraction", ".", "i", ".", "e", "Replacing", "the", "text", "Creating", "a", "variable", "and", "multi", "select", "variable", "names" ]

[ "function", "findAllExpressions", "(", "parentBlockStatement", ",", "expn", ",", "text", ")", "{", "var", "doc", "=", "session", ".", "editor", ".", "document", ",", "obj", "=", "{", "}", ",", "expns", "=", "[", "]", ";", "// find all references of the expression", "obj", "[", "expn", ".", "type", "]", "=", "function", "(", "node", ")", "{", "if", "(", "text", "===", "doc", ".", "getText", "(", ")", ".", "substr", "(", "node", ".", "start", ",", "node", ".", "end", "-", "node", ".", "start", ")", ")", "{", "expns", ".", "push", "(", "node", ")", ";", "}", "}", ";", "ASTWalker", ".", "simple", "(", "parentBlockStatement", ",", "obj", ")", ";", "return", "expns", ";", "}" ]

[ "Find", "all", "expressions", "in", "the", "parentBlockStatement", "that", "are", "same", "as", "expn" ]

[ "function", "getExpressions", "(", "ast", ",", "start", ",", "end", ")", "{", "var", "expns", "=", "[", "]", ",", "s", "=", "start", ",", "e", "=", "end", ",", "expn", ";", "while", "(", "true", ")", "{", "expn", "=", "RefactoringUtils", ".", "findSurroundExpression", "(", "ast", ",", "{", "start", ":", "s", ",", "end", ":", "e", "}", ")", ";", "if", "(", "!", "expn", ")", "{", "break", ";", "}", "expns", ".", "push", "(", "expn", ")", ";", "s", "=", "expn", ".", "start", "-", "1", ";", "}", "s", "=", "start", ";", "e", "=", "end", ";", "function", "checkExpnEquality", "(", "e", ")", "{", "return", "e", ".", "start", "===", "expn", ".", "start", "&&", "e", ".", "end", "===", "expn", ".", "end", ";", "}", "while", "(", "true", ")", "{", "expn", "=", "RefactoringUtils", ".", "findSurroundExpression", "(", "ast", ",", "{", "start", ":", "s", ",", "end", ":", "e", "}", ")", ";", "if", "(", "!", "expn", ")", "{", "break", ";", "}", "e", "=", "expn", ".", "end", "+", "1", ";", "// if expn already added, continue", "if", "(", "expns", ".", "find", "(", "checkExpnEquality", ")", ")", "{", "continue", ";", "}", "expns", ".", "push", "(", "expn", ")", ";", "}", "return", "expns", ";", "}" ]

[ "Gets", "the", "surrounding", "expressions", "of", "start", "and", "end", "offset" ]

[ "function", "removeMenuItemEventListeners", "(", "menuItem", ")", "{", "menuItem", ".", "_command", ".", "off", "(", "\"enabledStateChange\"", ",", "menuItem", ".", "_enabledChanged", ")", ".", "off", "(", "\"checkedStateChange\"", ",", "menuItem", ".", "_checkedChanged", ")", ".", "off", "(", "\"nameChange\"", ",", "menuItem", ".", "_nameChanged", ")", ".", "off", "(", "\"keyBindingAdded\"", ",", "menuItem", ".", "_keyBindingAdded", ")", ".", "off", "(", "\"keyBindingRemoved\"", ",", "menuItem", ".", "_keyBindingRemoved", ")", ";", "}" ]

[ "Removes", "the", "attached", "event", "listeners", "from", "the", "corresponding", "object", "." ]

[ "function", "_insertInList", "(", "$list", ",", "$element", ",", "position", ",", "$relativeElement", ")", "{", "// Determine where to insert. Default is LAST.", "var", "inserted", "=", "false", ";", "if", "(", "position", ")", "{", "// Adjust relative position for menu section positions since $relativeElement", "// has already been resolved by _getRelativeMenuItem() to a menuItem", "if", "(", "position", "===", "FIRST_IN_SECTION", ")", "{", "position", "=", "BEFORE", ";", "}", "else", "if", "(", "position", "===", "LAST_IN_SECTION", ")", "{", "position", "=", "AFTER", ";", "}", "if", "(", "position", "===", "FIRST", ")", "{", "$list", ".", "prepend", "(", "$element", ")", ";", "inserted", "=", "true", ";", "}", "else", "if", "(", "$relativeElement", "&&", "$relativeElement", ".", "length", ">", "0", ")", "{", "if", "(", "position", "===", "AFTER", ")", "{", "$relativeElement", ".", "after", "(", "$element", ")", ";", "inserted", "=", "true", ";", "}", "else", "if", "(", "position", "===", "BEFORE", ")", "{", "$relativeElement", ".", "before", "(", "$element", ")", ";", "inserted", "=", "true", ";", "}", "}", "}", "// Default to LAST", "if", "(", "!", "inserted", ")", "{", "$list", ".", "append", "(", "$element", ")", ";", "}", "}" ]

[ "Help", "function", "for", "inserting", "elements", "into", "a", "list" ]

[ "function", "MenuItem", "(", "id", ",", "command", ")", "{", "this", ".", "id", "=", "id", ";", "this", ".", "isDivider", "=", "(", "command", "===", "DIVIDER", ")", ";", "this", ".", "isNative", "=", "false", ";", "if", "(", "!", "this", ".", "isDivider", "&&", "command", "!==", "SUBMENU", ")", "{", "// Bind event handlers", "this", ".", "_enabledChanged", "=", "this", ".", "_enabledChanged", ".", "bind", "(", "this", ")", ";", "this", ".", "_checkedChanged", "=", "this", ".", "_checkedChanged", ".", "bind", "(", "this", ")", ";", "this", ".", "_nameChanged", "=", "this", ".", "_nameChanged", ".", "bind", "(", "this", ")", ";", "this", ".", "_keyBindingAdded", "=", "this", ".", "_keyBindingAdded", ".", "bind", "(", "this", ")", ";", "this", ".", "_keyBindingRemoved", "=", "this", ".", "_keyBindingRemoved", ".", "bind", "(", "this", ")", ";", "this", ".", "_command", "=", "command", ";", "this", ".", "_command", ".", "on", "(", "\"enabledStateChange\"", ",", "this", ".", "_enabledChanged", ")", ".", "on", "(", "\"checkedStateChange\"", ",", "this", ".", "_checkedChanged", ")", ".", "on", "(", "\"nameChange\"", ",", "this", ".", "_nameChanged", ")", ".", "on", "(", "\"keyBindingAdded\"", ",", "this", ".", "_keyBindingAdded", ")", ".", "on", "(", "\"keyBindingRemoved\"", ",", "this", ".", "_keyBindingRemoved", ")", ";", "}", "}" ]

[ "MenuItem", "represents", "a", "single", "menu", "item", "that", "executes", "a", "Command", "or", "a", "menu", "divider", ".", "MenuItems", "may", "have", "a", "sub", "-", "menu", ".", "A", "MenuItem", "may", "correspond", "to", "an", "HTML", "-", "based", "menu", "item", "or", "a", "native", "menu", "item", "if", "Brackets", "is", "running", "in", "a", "native", "application", "shell" ]

[ "function", "addMenu", "(", "name", ",", "id", ",", "position", ",", "relativeID", ")", "{", "name", "=", "_", ".", "escape", "(", "name", ")", ";", "var", "$menubar", "=", "$", "(", "\"#titlebar .nav\"", ")", ",", "menu", ";", "if", "(", "!", "name", "||", "!", "id", ")", "{", "console", ".", "error", "(", "\"call to addMenu() is missing required parameters\"", ")", ";", "return", "null", ";", "}", "// Guard against duplicate menu ids", "if", "(", "menuMap", "[", "id", "]", ")", "{", "console", ".", "log", "(", "\"Menu added with same name and id of existing Menu: \"", "+", "id", ")", ";", "return", "null", ";", "}", "menu", "=", "new", "Menu", "(", "id", ")", ";", "menuMap", "[", "id", "]", "=", "menu", ";", "if", "(", "!", "_isHTMLMenu", "(", "id", ")", ")", "{", "brackets", ".", "app", ".", "addMenu", "(", "name", ",", "id", ",", "position", ",", "relativeID", ",", "function", "(", "err", ")", "{", "switch", "(", "err", ")", "{", "case", "NO_ERROR", ":", "// Make sure name is up to date", "brackets", ".", "app", ".", "setMenuTitle", "(", "id", ",", "name", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "console", ".", "error", "(", "\"setMenuTitle() -- error: \"", "+", "err", ")", ";", "}", "}", ")", ";", "break", ";", "case", "ERR_UNKNOWN", ":", "console", ".", "error", "(", "\"addMenu(): Unknown Error when adding the menu \"", "+", "id", ")", ";", "break", ";", "case", "ERR_INVALID_PARAMS", ":", "console", ".", "error", "(", "\"addMenu(): Invalid Parameters when adding the menu \"", "+", "id", ")", ";", "break", ";", "case", "ERR_NOT_FOUND", ":", "console", ".", "error", "(", "\"addMenu(): Menu with command \"", "+", "relativeID", "+", "\" could not be found when adding the menu \"", "+", "id", ")", ";", "break", ";", "default", ":", "console", ".", "error", "(", "\"addMenu(): Unknown Error (\"", "+", "err", "+", "\") when adding the menu \"", "+", "id", ")", ";", "}", "}", ")", ";", "return", "menu", ";", "}", "var", "$toggle", "=", "$", "(", "\"<a href='#' class='dropdown-toggle' data-toggle='dropdown'>\"", "+", "name", "+", "\"</a>\"", ")", ",", "$popUp", "=", "$", "(", "\"<ul class='dropdown-menu'></ul>\"", ")", ",", "$newMenu", "=", "$", "(", "\"<li class='dropdown' id='\"", "+", "id", "+", "\"'></li>\"", ")", ".", "append", "(", "$toggle", ")", ".", "append", "(", "$popUp", ")", ";", "// Insert menu", "var", "$relativeElement", "=", "relativeID", "&&", "$", "(", "_getHTMLMenu", "(", "relativeID", ")", ")", ";", "_insertInList", "(", "$menubar", ",", "$newMenu", ",", "position", ",", "$relativeElement", ")", ";", "// Install ESC key handling", "PopUpManager", ".", "addPopUp", "(", "$popUp", ",", "closeAll", ",", "false", ")", ";", "// todo error handling", "return", "menu", ";", "}" ]

[ "Adds", "a", "top", "-", "level", "menu", "to", "the", "application", "menu", "bar", "which", "may", "be", "native", "or", "HTML", "-", "based", "." ]

[ "function", "removeMenu", "(", "id", ")", "{", "var", "menu", ",", "commandID", "=", "\"\"", ";", "if", "(", "!", "id", ")", "{", "console", ".", "error", "(", "\"removeMenu(): missing required parameter: id\"", ")", ";", "return", ";", "}", "if", "(", "!", "menuMap", "[", "id", "]", ")", "{", "console", ".", "error", "(", "\"removeMenu(): menu id not found: %s\"", ",", "id", ")", ";", "return", ";", "}", "// Remove all of the menu items in the menu", "menu", "=", "getMenu", "(", "id", ")", ";", "_", ".", "forEach", "(", "menuItemMap", ",", "function", "(", "value", ",", "key", ")", "{", "if", "(", "_", ".", "startsWith", "(", "key", ",", "id", ")", ")", "{", "if", "(", "value", ".", "isDivider", ")", "{", "menu", ".", "removeMenuDivider", "(", "key", ")", ";", "}", "else", "{", "commandID", "=", "value", ".", "getCommand", "(", ")", ";", "menu", ".", "removeMenuItem", "(", "commandID", ")", ";", "}", "}", "}", ")", ";", "if", "(", "_isHTMLMenu", "(", "id", ")", ")", "{", "$", "(", "_getHTMLMenu", "(", "id", ")", ")", ".", "remove", "(", ")", ";", "}", "else", "{", "brackets", ".", "app", ".", "removeMenu", "(", "id", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "console", ".", "error", "(", "\"removeMenu() -- id not found: \"", "+", "id", "+", "\" (error: \"", "+", "err", "+", "\")\"", ")", ";", "}", "}", ")", ";", "}", "delete", "menuMap", "[", "id", "]", ";", "}" ]

[ "Removes", "a", "top", "-", "level", "menu", "from", "the", "application", "menu", "bar", "which", "may", "be", "native", "or", "HTML", "-", "based", "." ]

[ "function", "ContextMenu", "(", "id", ")", "{", "Menu", ".", "apply", "(", "this", ",", "arguments", ")", ";", "var", "$newMenu", "=", "$", "(", "\"<li class='dropdown context-menu' id='\"", "+", "StringUtils", ".", "jQueryIdEscape", "(", "id", ")", "+", "\"'></li>\"", ")", ",", "$popUp", "=", "$", "(", "\"<ul class='dropdown-menu'></ul>\"", ")", ",", "$toggle", "=", "$", "(", "\"<a href='#' class='dropdown-toggle' data-toggle='dropdown'></a>\"", ")", ".", "hide", "(", ")", ";", "// assemble the menu fragments", "$newMenu", ".", "append", "(", "$toggle", ")", ".", "append", "(", "$popUp", ")", ";", "// insert into DOM", "$", "(", "\"#context-menu-bar > ul\"", ")", ".", "append", "(", "$newMenu", ")", ";", "var", "self", "=", "this", ";", "PopUpManager", ".", "addPopUp", "(", "$popUp", ",", "function", "(", ")", "{", "self", ".", "close", "(", ")", ";", "}", ",", "false", ")", ";", "// Listen to ContextMenu's beforeContextMenuOpen event to first close other popups", "PopUpManager", ".", "listenToContextMenu", "(", "this", ")", ";", "}" ]

[ "Represents", "a", "context", "menu", "that", "can", "open", "at", "a", "specific", "location", "in", "the", "UI", "." ]

[ "function", "registerContextMenu", "(", "id", ")", "{", "if", "(", "!", "id", ")", "{", "console", ".", "error", "(", "\"call to registerContextMenu() is missing required parameters\"", ")", ";", "return", "null", ";", "}", "// Guard against duplicate menu ids", "if", "(", "contextMenuMap", "[", "id", "]", ")", "{", "console", ".", "log", "(", "\"Context Menu added with same name and id of existing Context Menu: \"", "+", "id", ")", ";", "return", "null", ";", "}", "var", "cmenu", "=", "new", "ContextMenu", "(", "id", ")", ";", "contextMenuMap", "[", "id", "]", "=", "cmenu", ";", "return", "cmenu", ";", "}" ]

[ "Registers", "new", "context", "menu", "with", "Brackets", "." ]

[ "function", "getServer", "(", "localPath", ")", "{", "var", "provider", ",", "server", ",", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "_serverProviders", ".", "length", ";", "i", "++", ")", "{", "provider", "=", "_serverProviders", "[", "i", "]", ";", "server", "=", "provider", ".", "create", "(", ")", ";", "if", "(", "server", ".", "canServe", "(", "localPath", ")", ")", "{", "return", "server", ";", "}", "}", "return", "null", ";", "}" ]

[ "Determines", "which", "provider", "can", "serve", "a", "file", "with", "a", "local", "path", "." ]

[ "function", "registerServer", "(", "provider", ",", "priority", ")", "{", "if", "(", "!", "provider", ".", "create", ")", "{", "console", ".", "error", "(", "\"Incompatible live development server provider\"", ")", ";", "return", ";", "}", "var", "providerObj", "=", "{", "}", ";", "providerObj", ".", "create", "=", "provider", ".", "create", ";", "providerObj", ".", "priority", "=", "priority", "||", "0", ";", "_serverProviders", ".", "push", "(", "providerObj", ")", ";", "_serverProviders", ".", "sort", "(", "_providerSort", ")", ";", "return", "providerObj", ";", "}" ]

[ "The", "method", "by", "which", "a", "server", "registers", "itself", ".", "It", "returns", "an", "object", "handler", "that", "can", "be", "used", "to", "remove", "that", "server", "from", "the", "list", "." ]

[ "function", "removeServer", "(", "provider", ")", "{", "var", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "_serverProviders", ".", "length", ";", "i", "++", ")", "{", "if", "(", "provider", "===", "_serverProviders", "[", "i", "]", ")", "{", "_serverProviders", ".", "splice", "(", "i", ",", "1", ")", ";", "}", "}", "}" ]

[ "Remove", "a", "server", "from", "the", "list", "of", "the", "registered", "providers", "." ]

[ "function", "settingsToRegExp", "(", "settings", ",", "baseRegExp", ",", "defaultRegExp", ")", "{", "var", "regExpString", "=", "\"\"", ";", "if", "(", "settings", "instanceof", "Array", "&&", "settings", ".", "length", ">", "0", ")", "{", "// Append base settings to user settings. The base", "// settings are builtin and cannot be overridden.", "if", "(", "baseRegExp", ")", "{", "settings", ".", "push", "(", "\"/\"", "+", "baseRegExp", ".", "source", "+", "\"/\"", ")", ";", "}", "// convert each string, with optional wildcards to an equivalent", "// string in a regular expression.", "settings", ".", "forEach", "(", "function", "(", "value", ",", "index", ")", "{", "if", "(", "typeof", "value", "===", "\"string\"", ")", "{", "var", "isRegExp", "=", "value", "[", "0", "]", "===", "'/'", "&&", "value", "[", "value", ".", "length", "-", "1", "]", "===", "'/'", ";", "if", "(", "isRegExp", ")", "{", "value", "=", "value", ".", "substring", "(", "1", ",", "value", ".", "length", "-", "1", ")", ";", "}", "else", "{", "value", "=", "StringUtils", ".", "regexEscape", "(", "value", ")", ";", "// convert user input wildcard, \"*\" or \"?\", to a regular", "// expression. We can just replace the escaped \"*\" or \"?\"", "// since we know it is a wildcard.", "value", "=", "value", ".", "replace", "(", "\"\\\\?\"", ",", "\".?\"", ")", ";", "value", "=", "value", ".", "replace", "(", "\"\\\\*\"", ",", "\".*\"", ")", ";", "// Add \"^\" and \"$\" to prevent matching in the middle of strings.", "value", "=", "\"^\"", "+", "value", "+", "\"$\"", ";", "}", "if", "(", "index", ">", "0", ")", "{", "regExpString", "+=", "\"|\"", ";", "}", "regExpString", "=", "regExpString", ".", "concat", "(", "value", ")", ";", "}", "}", ")", ";", "}", "if", "(", "!", "regExpString", ")", "{", "var", "defaultParts", "=", "[", "]", ";", "if", "(", "baseRegExp", ")", "{", "defaultParts", ".", "push", "(", "baseRegExp", ".", "source", ")", ";", "}", "if", "(", "defaultRegExp", ")", "{", "defaultParts", ".", "push", "(", "defaultRegExp", ".", "source", ")", ";", "}", "if", "(", "defaultParts", ".", "length", ">", "0", ")", "{", "regExpString", "=", "defaultParts", ".", "join", "(", "\"|\"", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}", "return", "new", "RegExp", "(", "regExpString", ")", ";", "}" ]

[ "Convert", "an", "array", "of", "strings", "with", "optional", "wildcards", "to", "an", "equivalent", "regular", "expression", "." ]

[ "function", "Preferences", "(", "prefs", ")", "{", "var", "BASE_EXCLUDED_DIRECTORIES", "=", "null", ",", "/* if the user has settings, we don't exclude anything by default */", "// exclude node_modules for performance reasons and because we don't do full hinting for those anyhow.", "DEFAULT_EXCLUDED_DIRECTORIES", "=", "/", "node_modules", "/", ",", "// exclude require and jquery since we have special knowledge of those", "BASE_EXCLUDED_FILES", "=", "/", "^require.*\\.js$|^jquery.*\\.js$", "/", ",", "DEFAULT_MAX_FILE_COUNT", "=", "100", ",", "DEFAULT_MAX_FILE_SIZE", "=", "512", "*", "1024", ";", "if", "(", "prefs", ")", "{", "this", ".", "_excludedDirectories", "=", "settingsToRegExp", "(", "prefs", "[", "\"excluded-directories\"", "]", ",", "BASE_EXCLUDED_DIRECTORIES", ",", "DEFAULT_EXCLUDED_DIRECTORIES", ")", ";", "this", ".", "_excludedFiles", "=", "settingsToRegExp", "(", "prefs", "[", "\"excluded-files\"", "]", ",", "BASE_EXCLUDED_FILES", ")", ";", "this", ".", "_maxFileCount", "=", "prefs", "[", "\"max-file-count\"", "]", ";", "this", ".", "_maxFileSize", "=", "prefs", "[", "\"max-file-size\"", "]", ";", "// sanity check values", "if", "(", "!", "this", ".", "_maxFileCount", "||", "this", ".", "_maxFileCount", "<", "0", ")", "{", "this", ".", "_maxFileCount", "=", "DEFAULT_MAX_FILE_COUNT", ";", "}", "if", "(", "!", "this", ".", "_maxFileSize", "||", "this", ".", "_maxFileSize", "<", "0", ")", "{", "this", ".", "_maxFileSize", "=", "DEFAULT_MAX_FILE_SIZE", ";", "}", "}", "else", "{", "this", ".", "_excludedDirectories", "=", "DEFAULT_EXCLUDED_DIRECTORIES", ";", "this", ".", "_excludedFiles", "=", "BASE_EXCLUDED_FILES", ";", "this", ".", "_maxFileCount", "=", "DEFAULT_MAX_FILE_COUNT", ";", "this", ".", "_maxFileSize", "=", "DEFAULT_MAX_FILE_SIZE", ";", "}", "}" ]

[ "Constructor", "to", "create", "a", "default", "preference", "object", "." ]

[ "function", "InlineMenu", "(", "editor", ",", "menuText", ")", "{", "/**\n * The list of items to display\n *\n * @type {Array.<{id: number, name: string>}\n */", "this", ".", "items", "=", "[", "]", ";", "/**\n * The selected position in the list; otherwise -1.\n *\n * @type {number}\n */", "this", ".", "selectedIndex", "=", "-", "1", ";", "/**\n * Is the list currently open?\n *\n * @type {boolean}\n */", "this", ".", "opened", "=", "false", ";", "/**\n * The editor context\n *\n * @type {Editor}\n */", "this", ".", "editor", "=", "editor", ";", "/**\n * The menu selection callback function\n *\n * @type {Function}\n */", "this", ".", "handleSelect", "=", "null", ";", "/**\n * The menu closure callback function\n *\n * @type {Function}\n */", "this", ".", "handleClose", "=", "null", ";", "/**\n * The menu object\n *\n * @type {jQuery.Object}\n */", "this", ".", "$menu", "=", "$", "(", "\"<li class='dropdown inlinemenu-menu'></li>\"", ")", ".", "append", "(", "$", "(", "\"<a href='#' class='dropdown-toggle' data-toggle='dropdown'></a>\"", ")", ".", "hide", "(", ")", ")", ".", "append", "(", "\"<ul class='dropdown-menu'>\"", "+", "\"<li class='inlinemenu-header'>\"", "+", "\"<a>\"", "+", "menuText", "+", "\"</a>\"", "+", "\"</li>\"", "+", "\"</ul>\"", ")", ";", "this", ".", "_keydownHook", "=", "this", ".", "_keydownHook", ".", "bind", "(", "this", ")", ";", "}" ]

[ "Displays", "a", "popup", "list", "of", "items", "for", "a", "given", "editor", "context" ]

[ "function", "_findFileInMRUList", "(", "paneId", ",", "file", ")", "{", "return", "_", ".", "findIndex", "(", "_mruList", ",", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", ".", "fullPath", "===", "file", ".", "fullPath", "&&", "record", ".", "paneId", "===", "paneId", ")", ";", "}", ")", ";", "}" ]

[ "Locates", "the", "first", "MRU", "entry", "of", "a", "file", "for", "the", "requested", "pane" ]

[ "function", "isExclusiveToPane", "(", "file", ",", "paneId", ")", "{", "paneId", "=", "paneId", "===", "ACTIVE_PANE", "&&", "_activePaneId", "?", "_activePaneId", ":", "paneId", ";", "var", "index", "=", "_", ".", "findIndex", "(", "_mruList", ",", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", ".", "fullPath", "===", "file", ".", "fullPath", "&&", "record", ".", "paneId", "!==", "paneId", ")", ";", "}", ")", ";", "return", "index", "===", "-", "1", ";", "}" ]

[ "Checks", "whether", "a", "file", "is", "listed", "exclusively", "in", "the", "provided", "pane" ]

[ "function", "_getPane", "(", "paneId", ")", "{", "paneId", "=", "_resolvePaneId", "(", "paneId", ")", ";", "if", "(", "_panes", "[", "paneId", "]", ")", "{", "return", "_panes", "[", "paneId", "]", ";", "}", "return", "null", ";", "}" ]

[ "Retrieves", "the", "Pane", "object", "for", "the", "given", "paneId" ]

[ "function", "_makeFileMostRecent", "(", "paneId", ",", "file", ")", "{", "var", "index", ",", "entry", ",", "pane", "=", "_getPane", "(", "paneId", ")", ";", "if", "(", "!", "_traversingFileList", ")", "{", "pane", ".", "makeViewMostRecent", "(", "file", ")", ";", "index", "=", "_findFileInMRUList", "(", "pane", ".", "id", ",", "file", ")", ";", "entry", "=", "_makeMRUListEntry", "(", "file", ",", "pane", ".", "id", ")", ";", "if", "(", "index", "!==", "-", "1", ")", "{", "_mruList", ".", "splice", "(", "index", ",", "1", ")", ";", "}", "if", "(", "_findFileInMRUList", "(", "pane", ".", "id", ",", "file", ")", "!==", "-", "1", ")", "{", "console", ".", "log", "(", "file", ".", "fullPath", "+", "\" duplicated in mru list\"", ")", ";", "}", "// add it to the front of the list", "_mruList", ".", "unshift", "(", "entry", ")", ";", "}", "}" ]

[ "Makes", "the", "file", "the", "most", "recent", "for", "the", "pane", "and", "the", "global", "mru", "lists" ]

[ "function", "_makePaneMostRecent", "(", "paneId", ")", "{", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "if", "(", "pane", ".", "getCurrentlyViewedFile", "(", ")", ")", "{", "_makeFileMostRecent", "(", "paneId", ",", "pane", ".", "getCurrentlyViewedFile", "(", ")", ")", ";", "}", "}" ]

[ "Makes", "the", "Pane", "s", "current", "file", "the", "most", "recent" ]

[ "function", "_activeEditorChange", "(", "e", ",", "current", ")", "{", "if", "(", "current", ")", "{", "var", "$container", "=", "current", ".", "$el", ".", "parent", "(", ")", ".", "parent", "(", ")", ",", "pane", "=", "_getPaneFromElement", "(", "$container", ")", ";", "if", "(", "pane", ")", "{", "// Editor is a full editor", "if", "(", "pane", ".", "id", "!==", "_activePaneId", ")", "{", "// we just need to set the active pane in this case", "// it will dispatch the currentFileChange message as well", "// as dispatching other events when the active pane changes", "setActivePaneId", "(", "pane", ".", "id", ")", ";", "}", "}", "else", "{", "// Editor is an inline editor, find the parent pane", "var", "parents", "=", "$container", ".", "parents", "(", "\".view-pane\"", ")", ";", "if", "(", "parents", ".", "length", "===", "1", ")", "{", "$container", "=", "$", "(", "parents", "[", "0", "]", ")", ";", "pane", "=", "_getPaneFromElement", "(", "$container", ")", ";", "if", "(", "pane", ")", "{", "if", "(", "pane", ".", "id", "!==", "_activePaneId", ")", "{", "// activate the pane which will put focus in the pane's doc", "setActivePaneId", "(", "pane", ".", "id", ")", ";", "// reset the focus to the inline editor", "current", ".", "focus", "(", ")", ";", "}", "}", "}", "}", "}", "}" ]

[ "EditorManager", ".", "activeEditorChange", "handler", "This", "event", "is", "triggered", "when", "an", "visible", "editor", "gains", "focus", "Therefore", "we", "need", "to", "Activate", "the", "pane", "that", "the", "active", "editor", "belongs", "to" ]

[ "function", "_forEachPaneOrPanes", "(", "paneId", ",", "callback", ")", "{", "if", "(", "paneId", "===", "ALL_PANES", ")", "{", "_", ".", "forEach", "(", "_panes", ",", "callback", ")", ";", "}", "else", "{", "callback", "(", "_getPane", "(", "paneId", ")", ")", ";", "}", "}" ]

[ "Iterates", "over", "the", "pane", "or", "ALL_PANES", "and", "calls", "the", "callback", "function", "for", "each", "." ]

[ "function", "cacheScrollState", "(", "paneId", ")", "{", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "_paneScrollStates", "[", "pane", ".", "id", "]", "=", "pane", ".", "getScrollState", "(", ")", ";", "}", ")", ";", "}" ]

[ "Caches", "the", "specified", "pane", "s", "current", "scroll", "state", "If", "there", "was", "already", "cached", "state", "for", "the", "specified", "pane", "it", "is", "discarded", "and", "overwritten" ]

[ "function", "restoreAdjustedScrollState", "(", "paneId", ",", "heightDelta", ")", "{", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "pane", ".", "restoreAndAdjustScrollState", "(", "_paneScrollStates", "[", "pane", ".", "id", "]", ",", "heightDelta", ")", ";", "delete", "_paneScrollStates", "[", "pane", ".", "id", "]", ";", "}", ")", ";", "}" ]

[ "Restores", "the", "scroll", "state", "from", "cache", "and", "applies", "the", "heightDelta", "The", "view", "implementation", "is", "responsible", "for", "applying", "or", "ignoring", "the", "heightDelta", ".", "This", "is", "used", "primarily", "when", "a", "modal", "bar", "opens", "to", "keep", "the", "editor", "from", "scrolling", "the", "current", "page", "out", "of", "view", "in", "order", "to", "maintain", "the", "appearance", ".", "The", "state", "is", "removed", "from", "the", "cache", "after", "calling", "this", "function", "." ]

[ "function", "getWorkingSet", "(", "paneId", ")", "{", "var", "result", "=", "[", "]", ";", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "var", "viewList", "=", "pane", ".", "getViewList", "(", ")", ";", "result", "=", "_", ".", "union", "(", "result", ",", "viewList", ")", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Retrieves", "the", "WorkingSet", "for", "the", "given", "paneId", "not", "including", "temporary", "views" ]

[ "function", "getAllOpenFiles", "(", ")", "{", "var", "result", "=", "getWorkingSet", "(", "ALL_PANES", ")", ";", "_", ".", "forEach", "(", "_panes", ",", "function", "(", "pane", ")", "{", "var", "file", "=", "pane", ".", "getCurrentlyViewedFile", "(", ")", ";", "if", "(", "file", ")", "{", "result", "=", "_", ".", "union", "(", "result", ",", "[", "file", "]", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Retrieves", "the", "list", "of", "all", "open", "files", "including", "temporary", "views" ]

[ "function", "getWorkingSetSize", "(", "paneId", ")", "{", "var", "result", "=", "0", ";", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "result", "+=", "pane", ".", "getViewListSize", "(", ")", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Retrieves", "the", "size", "of", "the", "selected", "pane", "s", "view", "list" ]

[ "function", "findInAllWorkingSets", "(", "fullPath", ")", "{", "var", "index", ",", "result", "=", "[", "]", ";", "_", ".", "forEach", "(", "_panes", ",", "function", "(", "pane", ")", "{", "index", "=", "pane", ".", "findInViewList", "(", "fullPath", ")", ";", "if", "(", "index", ">=", "0", ")", "{", "result", ".", "push", "(", "{", "paneId", ":", "pane", ".", "id", ",", "index", ":", "index", "}", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Finds", "all", "instances", "of", "the", "specified", "file", "in", "all", "working", "sets", ".", "If", "there", "is", "a", "temporary", "view", "of", "the", "file", "it", "is", "not", "part", "of", "the", "result", "set" ]

[ "function", "addToWorkingSet", "(", "paneId", ",", "file", ",", "index", ",", "force", ")", "{", "// look for the file to have already been added to another pane", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "if", "(", "!", "pane", ")", "{", "throw", "new", "Error", "(", "\"invalid pane id: \"", "+", "paneId", ")", ";", "}", "var", "result", "=", "pane", ".", "reorderItem", "(", "file", ",", "index", ",", "force", ")", ",", "entry", "=", "_makeMRUListEntry", "(", "file", ",", "pane", ".", "id", ")", ";", "// handles the case of save as so that the file remains in the", "// the same location in the working set as the file that was renamed", "if", "(", "result", "===", "pane", ".", "ITEM_FOUND_NEEDS_SORT", ")", "{", "console", ".", "warn", "(", "\"pane.reorderItem returned pane.ITEM_FOUND_NEEDS_SORT which shouldn't happen \"", "+", "file", ")", ";", "exports", ".", "trigger", "(", "\"workingSetSort\"", ",", "pane", ".", "id", ")", ";", "}", "else", "if", "(", "result", "===", "pane", ".", "ITEM_NOT_FOUND", ")", "{", "index", "=", "pane", ".", "addToViewList", "(", "file", ",", "index", ")", ";", "if", "(", "_findFileInMRUList", "(", "pane", ".", "id", ",", "file", ")", "===", "-", "1", ")", "{", "// Add to or update the position in MRU", "if", "(", "pane", ".", "getCurrentlyViewedFile", "(", ")", "===", "file", ")", "{", "_mruList", ".", "unshift", "(", "entry", ")", ";", "}", "else", "{", "_mruList", ".", "push", "(", "entry", ")", ";", "}", "}", "exports", ".", "trigger", "(", "\"workingSetAdd\"", ",", "file", ",", "index", ",", "pane", ".", "id", ")", ";", "}", "}" ]

[ "Adds", "the", "given", "file", "to", "the", "end", "of", "the", "workingset", "if", "it", "is", "not", "already", "there", ".", "This", "API", "does", "not", "create", "a", "view", "of", "the", "file", "it", "just", "adds", "it", "to", "the", "working", "set", "Views", "of", "files", "in", "the", "working", "set", "are", "persisted", "and", "are", "not", "destroyed", "until", "the", "user", "closes", "the", "file", "using", "FILE_CLOSE", ";", "Views", "are", "created", "using", "FILE_OPEN", "and", "when", "opened", "are", "made", "the", "current", "view", ".", "If", "a", "File", "is", "already", "opened", "then", "the", "file", "is", "just", "made", "current", "and", "its", "view", "is", "shown", "." ]

[ "function", "addListToWorkingSet", "(", "paneId", ",", "fileList", ")", "{", "var", "uniqueFileList", ",", "pane", "=", "_getPane", "(", "paneId", ")", ";", "uniqueFileList", "=", "pane", ".", "addListToViewList", "(", "fileList", ")", ";", "uniqueFileList", ".", "forEach", "(", "function", "(", "file", ")", "{", "if", "(", "_findFileInMRUList", "(", "pane", ".", "id", ",", "file", ")", "!==", "-", "1", ")", "{", "console", ".", "log", "(", "file", ".", "fullPath", "+", "\" duplicated in mru list\"", ")", ";", "}", "_mruList", ".", "push", "(", "_makeMRUListEntry", "(", "file", ",", "pane", ".", "id", ")", ")", ";", "}", ")", ";", "exports", ".", "trigger", "(", "\"workingSetAddList\"", ",", "uniqueFileList", ",", "pane", ".", "id", ")", ";", "// find all of the files that could be added but were not", "var", "unsolvedList", "=", "fileList", ".", "filter", "(", "function", "(", "item", ")", "{", "// if the file open in another pane, then add it to the list of unsolvedList", "return", "(", "pane", ".", "findInViewList", "(", "item", ".", "fullPath", ")", "===", "-", "1", "&&", "_getPaneIdForPath", "(", "item", ".", "fullPath", ")", ")", ";", "}", ")", ";", "// Use the pane id of the first one in the list for pane id and recurse", "// if we add more panes, then this will recurse until all items in the list are satisified", "if", "(", "unsolvedList", ".", "length", ")", "{", "addListToWorkingSet", "(", "_getPaneIdForPath", "(", "unsolvedList", "[", "0", "]", ".", "fullPath", ")", ",", "unsolvedList", ")", ";", "}", "}" ]

[ "Adds", "the", "given", "file", "list", "to", "the", "end", "of", "the", "workingset", "." ]

[ "function", "_removeFileFromMRU", "(", "paneId", ",", "file", ")", "{", "var", "index", ",", "compare", "=", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", "===", "file", "&&", "record", ".", "paneId", "===", "paneId", ")", ";", "}", ";", "// find and remove all instances", "do", "{", "index", "=", "_", ".", "findIndex", "(", "_mruList", ",", "compare", ")", ";", "if", "(", "index", "!==", "-", "1", ")", "{", "_mruList", ".", "splice", "(", "index", ",", "1", ")", ";", "}", "}", "while", "(", "index", "!==", "-", "1", ")", ";", "}" ]

[ "Removes", "a", "file", "from", "the", "global", "MRU", "list", ".", "Future", "versions", "of", "this", "implementation", "may", "support", "the", "ALL_PANES", "constant", "but", "FOCUS_PANE", "is", "not", "allowed" ]

[ "function", "_removeView", "(", "paneId", ",", "file", ",", "suppressRedraw", ")", "{", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "if", "(", "pane", ".", "removeView", "(", "file", ")", ")", "{", "_removeFileFromMRU", "(", "pane", ".", "id", ",", "file", ")", ";", "exports", ".", "trigger", "(", "\"workingSetRemove\"", ",", "file", ",", "suppressRedraw", ",", "pane", ".", "id", ")", ";", "}", "}" ]

[ "Removes", "a", "file", "the", "specified", "pane" ]

[ "function", "_moveView", "(", "sourcePaneId", ",", "destinationPaneId", ",", "file", ",", "destinationIndex", ")", "{", "var", "result", "=", "new", "$", ".", "Deferred", "(", ")", ",", "sourcePane", "=", "_getPane", "(", "sourcePaneId", ")", ",", "destinationPane", "=", "_getPane", "(", "destinationPaneId", ")", ";", "sourcePane", ".", "moveView", "(", "file", ",", "destinationPane", ",", "destinationIndex", ")", ".", "done", "(", "function", "(", ")", "{", "// remove existing entry from mrulist for the same document if present ", "_removeFileFromMRU", "(", "destinationPane", ".", "id", ",", "file", ")", ";", "// update the mru list", "_mruList", ".", "every", "(", "function", "(", "record", ")", "{", "if", "(", "record", ".", "file", "===", "file", "&&", "record", ".", "paneId", "===", "sourcePane", ".", "id", ")", "{", "record", ".", "paneId", "=", "destinationPane", ".", "id", ";", "return", "false", ";", "}", "return", "true", ";", "}", ")", ";", "exports", ".", "trigger", "(", "\"workingSetMove\"", ",", "file", ",", "sourcePane", ".", "id", ",", "destinationPane", ".", "id", ")", ";", "result", ".", "resolve", "(", ")", ";", "}", ")", ";", "return", "result", ".", "promise", "(", ")", ";", "}" ]

[ "moves", "a", "view", "from", "one", "pane", "to", "another" ]

[ "function", "_removeDeletedFileFromMRU", "(", "e", ",", "fullPath", ")", "{", "var", "index", ",", "compare", "=", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", ".", "fullPath", "===", "fullPath", ")", ";", "}", ";", "// find and remove all instances", "do", "{", "index", "=", "_", ".", "findIndex", "(", "_mruList", ",", "compare", ")", ";", "if", "(", "index", "!==", "-", "1", ")", "{", "_mruList", ".", "splice", "(", "index", ",", "1", ")", ";", "}", "}", "while", "(", "index", "!==", "-", "1", ")", ";", "}" ]

[ "DocumentManager", ".", "pathDeleted", "Event", "handler", "to", "remove", "a", "file", "from", "the", "MRU", "list" ]

[ "function", "_sortWorkingSet", "(", "paneId", ",", "compareFn", ")", "{", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "pane", ".", "sortViewList", "(", "compareFn", ")", ";", "exports", ".", "trigger", "(", "\"workingSetSort\"", ",", "pane", ".", "id", ")", ";", "}", ")", ";", "}" ]

[ "sorts", "the", "pane", "s", "view", "list" ]

[ "function", "_moveWorkingSetItem", "(", "paneId", ",", "fromIndex", ",", "toIndex", ")", "{", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "pane", ".", "moveWorkingSetItem", "(", "fromIndex", ",", "toIndex", ")", ";", "exports", ".", "trigger", "(", "\"workingSetSort\"", ",", "pane", ".", "id", ")", ";", "exports", ".", "trigger", "(", "\"_workingSetDisableAutoSort\"", ",", "pane", ".", "id", ")", ";", "}" ]

[ "moves", "a", "working", "set", "item", "from", "one", "index", "to", "another", "shifting", "the", "items", "after", "in", "the", "working", "set", "up", "and", "reinserting", "it", "at", "the", "desired", "location" ]

[ "function", "_swapWorkingSetListIndexes", "(", "paneId", ",", "index1", ",", "index2", ")", "{", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "pane", ".", "swapViewListIndexes", "(", "index1", ",", "index2", ")", ";", "exports", ".", "trigger", "(", "\"workingSetSort\"", ",", "pane", ".", "id", ")", ";", "exports", ".", "trigger", "(", "\"_workingSetDisableAutoSort\"", ",", "pane", ".", "id", ")", ";", "}" ]

[ "Mutually", "exchanges", "the", "files", "at", "the", "indexes", "passed", "by", "parameters", "." ]

[ "function", "traverseToNextViewByMRU", "(", "direction", ")", "{", "var", "file", "=", "getCurrentlyViewedFile", "(", ")", ",", "paneId", "=", "getActivePaneId", "(", ")", ",", "index", "=", "_", ".", "findIndex", "(", "_mruList", ",", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", "===", "file", "&&", "record", ".", "paneId", "===", "paneId", ")", ";", "}", ")", ";", "return", "ViewUtils", ".", "traverseViewArray", "(", "_mruList", ",", "index", ",", "direction", ")", ";", "}" ]

[ "Get", "the", "next", "or", "previous", "file", "in", "the", "MRU", "list", "." ]

[ "function", "traverseToNextViewInListOrder", "(", "direction", ")", "{", "var", "file", "=", "getCurrentlyViewedFile", "(", ")", ",", "curPaneId", "=", "getActivePaneId", "(", ")", ",", "allFiles", "=", "[", "]", ",", "index", ";", "getPaneIdList", "(", ")", ".", "forEach", "(", "function", "(", "paneId", ")", "{", "var", "paneFiles", "=", "getWorkingSet", "(", "paneId", ")", ".", "map", "(", "function", "(", "file", ")", "{", "return", "{", "file", ":", "file", ",", "pane", ":", "paneId", "}", ";", "}", ")", ";", "allFiles", "=", "allFiles", ".", "concat", "(", "paneFiles", ")", ";", "}", ")", ";", "index", "=", "_", ".", "findIndex", "(", "allFiles", ",", "function", "(", "record", ")", "{", "return", "(", "record", ".", "file", "===", "file", "&&", "record", ".", "pane", "===", "curPaneId", ")", ";", "}", ")", ";", "return", "ViewUtils", ".", "traverseViewArray", "(", "allFiles", ",", "index", ",", "direction", ")", ";", "}" ]

[ "Get", "the", "next", "or", "previous", "file", "in", "list", "order", "." ]

[ "function", "_synchronizePaneSize", "(", "pane", ",", "forceRefresh", ")", "{", "var", "available", ";", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "available", "=", "_$el", ".", "innerWidth", "(", ")", ";", "}", "else", "{", "available", "=", "_$el", ".", "innerHeight", "(", ")", ";", "}", "// Update the pane's sizer element if it has one and update the max size", "Resizer", ".", "resyncSizer", "(", "pane", ".", "$el", ")", ";", "pane", ".", "$el", ".", "data", "(", "\"maxsize\"", ",", "available", "-", "MIN_PANE_SIZE", ")", ";", "pane", ".", "updateLayout", "(", "forceRefresh", ")", ";", "}" ]

[ "Synchronizes", "the", "pane", "s", "sizer", "element", "updates", "the", "pane", "s", "resizer", "maxsize", "value", "and", "tells", "the", "pane", "to", "update", "its", "layout" ]

[ "function", "_updateLayout", "(", "event", ",", "viewAreaHeight", ",", "forceRefresh", ")", "{", "var", "available", ";", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "available", "=", "_$el", ".", "innerWidth", "(", ")", ";", "}", "else", "{", "available", "=", "_$el", ".", "innerHeight", "(", ")", ";", "}", "_", ".", "forEach", "(", "_panes", ",", "function", "(", "pane", ")", "{", "// For VERTICAL orientation, we set the second pane to be width: auto", "// so that it resizes to fill the available space in the containing div", "// unfortunately, that doesn't work in the HORIZONTAL orientation so we", "// must update the height and convert it into a percentage", "if", "(", "pane", ".", "id", "===", "SECOND_PANE", "&&", "_orientation", "===", "HORIZONTAL", ")", "{", "var", "percentage", "=", "(", "(", "_panes", "[", "FIRST_PANE", "]", ".", "$el", ".", "height", "(", ")", "+", "1", ")", "/", "available", ")", ";", "pane", ".", "$el", ".", "css", "(", "\"height\"", ",", "100", "-", "(", "percentage", "*", "100", ")", "+", "\"%\"", ")", ";", "}", "_synchronizePaneSize", "(", "pane", ",", "forceRefresh", ")", ";", "}", ")", ";", "}" ]

[ "Event", "handler", "for", "workspaceUpdateLayout", "to", "update", "the", "layout" ]

[ "function", "_initialLayout", "(", "forceRefresh", ")", "{", "var", "panes", "=", "Object", ".", "keys", "(", "_panes", ")", ",", "size", "=", "100", "/", "panes", ".", "length", ";", "_", ".", "forEach", "(", "_panes", ",", "function", "(", "pane", ")", "{", "if", "(", "pane", ".", "id", "===", "FIRST_PANE", ")", "{", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "pane", ".", "$el", ".", "css", "(", "{", "height", ":", "\"100%\"", ",", "width", ":", "size", "+", "\"%\"", ",", "float", ":", "\"left\"", "}", ")", ";", "}", "else", "{", "pane", ".", "$el", ".", "css", "(", "{", "height", ":", "size", "+", "\"%\"", ",", "width", ":", "\"100%\"", "}", ")", ";", "}", "}", "else", "{", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "pane", ".", "$el", ".", "css", "(", "{", "height", ":", "\"100%\"", ",", "width", ":", "\"auto\"", ",", "float", ":", "\"none\"", "}", ")", ";", "}", "else", "{", "pane", ".", "$el", ".", "css", "(", "{", "width", ":", "\"100%\"", ",", "height", ":", "\"50%\"", "}", ")", ";", "}", "}", "_synchronizePaneSize", "(", "pane", ",", "forceRefresh", ")", ";", "}", ")", ";", "}" ]

[ "Sets", "up", "the", "initial", "layout", "so", "panes", "are", "evenly", "distributed", "This", "also", "sets", "css", "properties", "that", "aid", "in", "the", "layout", "when", "_updateLayout", "is", "called" ]

[ "function", "_createPaneIfNecessary", "(", "paneId", ")", "{", "var", "newPane", ";", "if", "(", "!", "_panes", ".", "hasOwnProperty", "(", "paneId", ")", ")", "{", "newPane", "=", "new", "Pane", "(", "paneId", ",", "_$el", ")", ";", "_panes", "[", "paneId", "]", "=", "newPane", ";", "exports", ".", "trigger", "(", "\"paneCreate\"", ",", "newPane", ".", "id", ")", ";", "newPane", ".", "$el", ".", "on", "(", "\"click.mainview dragover.mainview\"", ",", "function", "(", ")", "{", "setActivePaneId", "(", "newPane", ".", "id", ")", ";", "}", ")", ";", "newPane", ".", "on", "(", "\"viewListChange.mainview\"", ",", "function", "(", ")", "{", "_updatePaneHeaders", "(", ")", ";", "exports", ".", "trigger", "(", "\"workingSetUpdate\"", ",", "newPane", ".", "id", ")", ";", "}", ")", ";", "newPane", ".", "on", "(", "\"currentViewChange.mainview\"", ",", "function", "(", "e", ",", "newView", ",", "oldView", ")", "{", "_updatePaneHeaders", "(", ")", ";", "if", "(", "_activePaneId", "===", "newPane", ".", "id", ")", "{", "exports", ".", "trigger", "(", "\"currentFileChange\"", ",", "newView", "&&", "newView", ".", "getFile", "(", ")", ",", "newPane", ".", "id", ",", "oldView", "&&", "oldView", ".", "getFile", "(", ")", ",", "newPane", ".", "id", ")", ";", "}", "}", ")", ";", "newPane", ".", "on", "(", "\"viewDestroy.mainView\"", ",", "function", "(", "e", ",", "view", ")", "{", "_removeFileFromMRU", "(", "newPane", ".", "id", ",", "view", ".", "getFile", "(", ")", ")", ";", "}", ")", ";", "}", "return", "newPane", ";", "}" ]

[ "Creates", "a", "pane", "for", "paneId", "if", "one", "doesn", "t", "already", "exist" ]

[ "function", "_makeFirstPaneResizable", "(", ")", "{", "var", "firstPane", "=", "_panes", "[", "FIRST_PANE", "]", ";", "Resizer", ".", "makeResizable", "(", "firstPane", ".", "$el", ",", "_orientation", "===", "HORIZONTAL", "?", "Resizer", ".", "DIRECTION_VERTICAL", ":", "Resizer", ".", "DIRECTION_HORIZONTAL", ",", "_orientation", "===", "HORIZONTAL", "?", "Resizer", ".", "POSITION_BOTTOM", ":", "Resizer", ".", "POSITION_RIGHT", ",", "MIN_PANE_SIZE", ",", "false", ",", "false", ",", "false", ",", "true", ",", "true", ")", ";", "firstPane", ".", "$el", ".", "on", "(", "\"panelResizeUpdate\"", ",", "function", "(", ")", "{", "_updateLayout", "(", ")", ";", "}", ")", ";", "}" ]

[ "Makes", "the", "first", "pane", "resizable" ]

[ "function", "_doSplit", "(", "orientation", ")", "{", "var", "firstPane", ",", "newPane", ";", "if", "(", "orientation", "===", "_orientation", ")", "{", "return", ";", "}", "firstPane", "=", "_panes", "[", "FIRST_PANE", "]", ";", "Resizer", ".", "removeSizable", "(", "firstPane", ".", "$el", ")", ";", "if", "(", "_orientation", ")", "{", "_$el", ".", "removeClass", "(", "\"split-\"", "+", "_orientation", ".", "toLowerCase", "(", ")", ")", ";", "}", "_$el", ".", "addClass", "(", "\"split-\"", "+", "orientation", ".", "toLowerCase", "(", ")", ")", ";", "_orientation", "=", "orientation", ";", "newPane", "=", "_createPaneIfNecessary", "(", "SECOND_PANE", ")", ";", "_makeFirstPaneResizable", "(", ")", ";", "// reset the layout to 50/50 split", "// if we changed orientation then", "// the percentages are reset as well", "_initialLayout", "(", ")", ";", "exports", ".", "trigger", "(", "\"paneLayoutChange\"", ",", "_orientation", ")", ";", "// if new pane was created, and original pane is not empty, make new pane the active pane", "if", "(", "newPane", "&&", "getCurrentlyViewedFile", "(", "firstPane", ".", "id", ")", ")", "{", "setActivePaneId", "(", "newPane", ".", "id", ")", ";", "}", "}" ]

[ "Creates", "a", "split", "for", "the", "specified", "orientation" ]

[ "function", "_open", "(", "paneId", ",", "file", ",", "optionsIn", ")", "{", "var", "result", "=", "new", "$", ".", "Deferred", "(", ")", ",", "options", "=", "optionsIn", "||", "{", "}", ";", "function", "doPostOpenActivation", "(", ")", "{", "if", "(", "!", "options", ".", "noPaneActivate", ")", "{", "setActivePaneId", "(", "paneId", ")", ";", "}", "}", "if", "(", "!", "file", "||", "!", "_getPane", "(", "paneId", ")", ")", "{", "return", "result", ".", "reject", "(", "\"bad argument\"", ")", ".", "promise", "(", ")", ";", "}", "// See if there is already a view for the file", "var", "pane", "=", "_getPane", "(", "paneId", ")", ";", "// See if there is a factory to create a view for this file", "// we want to do this first because, we don't want our internal", "// editor to edit files for which there are suitable viewfactories", "var", "factory", "=", "MainViewFactory", ".", "findSuitableFactoryForPath", "(", "file", ".", "fullPath", ")", ";", "if", "(", "factory", ")", "{", "file", ".", "exists", "(", "function", "(", "fileError", ",", "fileExists", ")", "{", "if", "(", "fileExists", ")", "{", "// let the factory open the file and create a view for it", "factory", ".", "openFile", "(", "file", ",", "pane", ")", ".", "done", "(", "function", "(", ")", "{", "// if we opened a file that isn't in the project", "// then add the file to the working set", "if", "(", "!", "ProjectManager", ".", "isWithinProject", "(", "file", ".", "fullPath", ")", ")", "{", "addToWorkingSet", "(", "paneId", ",", "file", ")", ";", "}", "doPostOpenActivation", "(", ")", ";", "result", ".", "resolve", "(", "file", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "fileError", ")", "{", "result", ".", "reject", "(", "fileError", ")", ";", "}", ")", ";", "}", "else", "{", "result", ".", "reject", "(", "fileError", "||", "FileSystemError", ".", "NOT_FOUND", ")", ";", "}", "}", ")", ";", "}", "else", "{", "DocumentManager", ".", "getDocumentForPath", "(", "file", ".", "fullPath", ",", "file", ")", ".", "done", "(", "function", "(", "doc", ")", "{", "if", "(", "doc", ")", "{", "_edit", "(", "paneId", ",", "doc", ",", "$", ".", "extend", "(", "{", "}", ",", "options", ",", "{", "noPaneActivate", ":", "true", "}", ")", ")", ";", "doPostOpenActivation", "(", ")", ";", "result", ".", "resolve", "(", "doc", ".", "file", ")", ";", "}", "else", "{", "result", ".", "resolve", "(", "null", ")", ";", "}", "}", ")", ".", "fail", "(", "function", "(", "fileError", ")", "{", "result", ".", "reject", "(", "fileError", ")", ";", "}", ")", ";", "}", "result", ".", "done", "(", "function", "(", ")", "{", "_makeFileMostRecent", "(", "paneId", ",", "file", ")", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Opens", "a", "file", "in", "the", "specified", "pane", "this", "can", "be", "used", "to", "open", "a", "file", "with", "a", "custom", "viewer", "or", "a", "document", "for", "editing", ".", "If", "it", "s", "a", "document", "for", "editing", "edit", "is", "called", "on", "the", "document" ]

[ "function", "_mergePanes", "(", ")", "{", "if", "(", "_panes", ".", "hasOwnProperty", "(", "SECOND_PANE", ")", ")", "{", "var", "firstPane", "=", "_panes", "[", "FIRST_PANE", "]", ",", "secondPane", "=", "_panes", "[", "SECOND_PANE", "]", ",", "fileList", "=", "secondPane", ".", "getViewList", "(", ")", ",", "lastViewed", "=", "getCurrentlyViewedFile", "(", ")", ";", "Resizer", ".", "removeSizable", "(", "firstPane", ".", "$el", ")", ";", "firstPane", ".", "mergeFrom", "(", "secondPane", ")", ";", "exports", ".", "trigger", "(", "\"workingSetRemoveList\"", ",", "fileList", ",", "secondPane", ".", "id", ")", ";", "setActivePaneId", "(", "firstPane", ".", "id", ")", ";", "secondPane", ".", "$el", ".", "off", "(", "\".mainview\"", ")", ";", "secondPane", ".", "off", "(", "\".mainview\"", ")", ";", "secondPane", ".", "destroy", "(", ")", ";", "delete", "_panes", "[", "SECOND_PANE", "]", ";", "exports", ".", "trigger", "(", "\"paneDestroy\"", ",", "secondPane", ".", "id", ")", ";", "exports", ".", "trigger", "(", "\"workingSetAddList\"", ",", "fileList", ",", "firstPane", ".", "id", ")", ";", "_mruList", ".", "forEach", "(", "function", "(", "record", ")", "{", "if", "(", "record", ".", "paneId", "===", "secondPane", ".", "id", ")", "{", "record", ".", "paneId", "=", "firstPane", ".", "id", ";", "}", "}", ")", ";", "_$el", ".", "removeClass", "(", "\"split-\"", "+", "_orientation", ".", "toLowerCase", "(", ")", ")", ";", "_orientation", "=", "null", ";", "// this will set the remaining pane to 100%", "_initialLayout", "(", ")", ";", "exports", ".", "trigger", "(", "\"paneLayoutChange\"", ",", "_orientation", ")", ";", "// if the current view before the merger was in the pane", "// that went away then reopen it so that it's now the current view again", "if", "(", "lastViewed", "&&", "getCurrentlyViewedFile", "(", ")", "!==", "lastViewed", ")", "{", "exports", ".", "_open", "(", "firstPane", ".", "id", ",", "lastViewed", ")", ";", "}", "}", "}" ]

[ "Merges", "second", "pane", "into", "first", "pane", "and", "opens", "the", "current", "file" ]

[ "function", "_close", "(", "paneId", ",", "file", ",", "optionsIn", ")", "{", "var", "options", "=", "optionsIn", "||", "{", "}", ";", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "if", "(", "pane", ".", "removeView", "(", "file", ",", "options", ".", "noOpenNextFile", ")", "&&", "(", "paneId", "===", "ACTIVE_PANE", "||", "pane", ".", "id", "===", "paneId", ")", ")", "{", "_removeFileFromMRU", "(", "pane", ".", "id", ",", "file", ")", ";", "exports", ".", "trigger", "(", "\"workingSetRemove\"", ",", "file", ",", "false", ",", "pane", ".", "id", ")", ";", "return", "false", ";", "}", "}", ")", ";", "}" ]

[ "Closes", "a", "file", "in", "the", "specified", "pane", "or", "panes" ]

[ "function", "_closeList", "(", "paneId", ",", "fileList", ")", "{", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "var", "closedList", "=", "pane", ".", "removeViews", "(", "fileList", ")", ";", "closedList", ".", "forEach", "(", "function", "(", "file", ")", "{", "_removeFileFromMRU", "(", "pane", ".", "id", ",", "file", ")", ";", "}", ")", ";", "exports", ".", "trigger", "(", "\"workingSetRemoveList\"", ",", "closedList", ",", "pane", ".", "id", ")", ";", "}", ")", ";", "}" ]

[ "Closes", "a", "list", "of", "file", "in", "the", "specified", "pane", "or", "panes" ]

[ "function", "_closeAll", "(", "paneId", ")", "{", "_forEachPaneOrPanes", "(", "paneId", ",", "function", "(", "pane", ")", "{", "var", "closedList", "=", "pane", ".", "getViewList", "(", ")", ";", "closedList", ".", "forEach", "(", "function", "(", "file", ")", "{", "_removeFileFromMRU", "(", "pane", ".", "id", ",", "file", ")", ";", "}", ")", ";", "pane", ".", "_reset", "(", ")", ";", "exports", ".", "trigger", "(", "\"workingSetRemoveList\"", ",", "closedList", ",", "pane", ".", "id", ")", ";", "}", ")", ";", "}" ]

[ "Closes", "all", "files", "in", "the", "specified", "pane", "or", "panes" ]

[ "function", "_findPaneForDocument", "(", "document", ")", "{", "// First check for an editor view of the document", "var", "pane", "=", "_getPaneFromElement", "(", "$", "(", "document", ".", "_masterEditor", ".", "$el", ".", "parent", "(", ")", ".", "parent", "(", ")", ")", ")", ";", "if", "(", "!", "pane", ")", "{", "// No view of the document, it may be in a working set and not yet opened", "var", "info", "=", "findInAllWorkingSets", "(", "document", ".", "file", ".", "fullPath", ")", ".", "shift", "(", ")", ";", "if", "(", "info", ")", "{", "pane", "=", "_panes", "[", "info", ".", "paneId", "]", ";", "}", "}", "return", "pane", ";", "}" ]

[ "Finds", "which", "pane", "a", "document", "belongs", "to" ]

[ "function", "_destroyEditorIfNotNeeded", "(", "document", ")", "{", "if", "(", "!", "(", "document", "instanceof", "DocumentManager", ".", "Document", ")", ")", "{", "throw", "new", "Error", "(", "\"_destroyEditorIfUnneeded() should be passed a Document\"", ")", ";", "}", "if", "(", "document", ".", "_masterEditor", ")", "{", "// findPaneForDocument tries to locate the pane in which the document", "// is either opened or will be opened (in the event that the document is", "// in a working set but has yet to be opened) and then asks the pane", "// to destroy the view if it doesn't need it anymore", "var", "pane", "=", "_findPaneForDocument", "(", "document", ")", ";", "if", "(", "pane", ")", "{", "// let the pane deceide if it wants to destroy the view if it's no needed", "pane", ".", "destroyViewIfNotNeeded", "(", "document", ".", "_masterEditor", ")", ";", "}", "else", "{", "// in this case, the document isn't referenced at all so just destroy it", "document", ".", "_masterEditor", ".", "destroy", "(", ")", ";", "}", "}", "}" ]

[ "Destroys", "an", "editor", "object", "if", "a", "document", "is", "no", "longer", "referenced" ]

[ "function", "_saveViewState", "(", ")", "{", "function", "_computeSplitPercentage", "(", ")", "{", "var", "available", ",", "used", ";", "if", "(", "getPaneCount", "(", ")", "===", "1", ")", "{", "// just short-circuit here and", "// return 100% to avoid any rounding issues", "return", "1", ";", "}", "else", "{", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "available", "=", "_$el", ".", "innerWidth", "(", ")", ";", "used", "=", "_panes", "[", "FIRST_PANE", "]", ".", "$el", ".", "width", "(", ")", ";", "}", "else", "{", "available", "=", "_$el", ".", "innerHeight", "(", ")", ";", "used", "=", "_panes", "[", "FIRST_PANE", "]", ".", "$el", ".", "height", "(", ")", ";", "}", "return", "used", "/", "available", ";", "}", "}", "var", "projectRoot", "=", "ProjectManager", ".", "getProjectRoot", "(", ")", ",", "context", "=", "{", "location", ":", "{", "scope", ":", "\"user\"", ",", "layer", ":", "\"project\"", ",", "layerID", ":", "projectRoot", ".", "fullPath", "}", "}", ",", "state", "=", "{", "orientation", ":", "_orientation", ",", "activePaneId", ":", "getActivePaneId", "(", ")", ",", "splitPercentage", ":", "_computeSplitPercentage", "(", ")", ",", "panes", ":", "{", "}", "}", ";", "if", "(", "!", "projectRoot", ")", "{", "return", ";", "}", "_", ".", "forEach", "(", "_panes", ",", "function", "(", "pane", ")", "{", "state", ".", "panes", "[", "pane", ".", "id", "]", "=", "pane", ".", "saveState", "(", ")", ";", "}", ")", ";", "PreferencesManager", ".", "setViewState", "(", "PREFS_NAME", ",", "state", ",", "context", ")", ";", "}" ]

[ "Saves", "the", "workingset", "state" ]

[ "function", "_initialize", "(", "$container", ")", "{", "if", "(", "_activePaneId", ")", "{", "throw", "new", "Error", "(", "\"MainViewManager has already been initialized\"", ")", ";", "}", "_$el", "=", "$container", ";", "_createPaneIfNecessary", "(", "FIRST_PANE", ")", ";", "_activePaneId", "=", "FIRST_PANE", ";", "// One-time init so the pane has the \"active\" appearance", "_panes", "[", "FIRST_PANE", "]", ".", "_handleActivePaneChange", "(", "undefined", ",", "_activePaneId", ")", ";", "_initialLayout", "(", ")", ";", "// This ensures that unit tests that use this function", "// get an event handler for workspace events and we don't listen", "// to the event before we've been initialized", "WorkspaceManager", ".", "on", "(", "\"workspaceUpdateLayout\"", ",", "_updateLayout", ")", ";", "// Listen to key Alt-W to toggle between panes", "CommandManager", ".", "register", "(", "Strings", ".", "CMD_SWITCH_PANE_FOCUS", ",", "Commands", ".", "CMD_SWITCH_PANE_FOCUS", ",", "switchPaneFocus", ")", ";", "KeyBindingManager", ".", "addBinding", "(", "Commands", ".", "CMD_SWITCH_PANE_FOCUS", ",", "{", "key", ":", "'Alt-W'", "}", ")", ";", "}" ]

[ "Initializes", "the", "MainViewManager", "s", "view", "state" ]

[ "function", "setLayoutScheme", "(", "rows", ",", "columns", ")", "{", "if", "(", "(", "rows", "<", "1", ")", "||", "(", "rows", ">", "2", ")", "||", "(", "columns", "<", "1", ")", "||", "(", "columns", ">", "2", ")", "||", "(", "columns", "===", "2", "&&", "rows", "===", "2", ")", ")", "{", "console", ".", "error", "(", "\"setLayoutScheme unsupported layout \"", "+", "rows", "+", "\", \"", "+", "columns", ")", ";", "return", "false", ";", "}", "if", "(", "rows", "===", "columns", ")", "{", "_mergePanes", "(", ")", ";", "}", "else", "if", "(", "rows", ">", "columns", ")", "{", "_doSplit", "(", "HORIZONTAL", ")", ";", "}", "else", "{", "_doSplit", "(", "VERTICAL", ")", ";", "}", "return", "true", ";", "}" ]

[ "Changes", "the", "layout", "scheme" ]

[ "function", "getLayoutScheme", "(", ")", "{", "var", "result", "=", "{", "rows", ":", "1", ",", "columns", ":", "1", "}", ";", "if", "(", "_orientation", "===", "HORIZONTAL", ")", "{", "result", ".", "rows", "=", "2", ";", "}", "else", "if", "(", "_orientation", "===", "VERTICAL", ")", "{", "result", ".", "columns", "=", "2", ";", "}", "return", "result", ";", "}" ]

[ "Retrieves", "the", "current", "layout", "scheme" ]

[ "function", "InlineTimingFunctionEditor", "(", "timingFunction", ",", "startBookmark", ",", "endBookmark", ")", "{", "this", ".", "_timingFunction", "=", "timingFunction", ";", "this", ".", "_startBookmark", "=", "startBookmark", ";", "this", ".", "_endBookmark", "=", "endBookmark", ";", "this", ".", "_isOwnChange", "=", "false", ";", "this", ".", "_isHostChange", "=", "false", ";", "this", ".", "_origin", "=", "\"+InlineTimingFunctionEditor_\"", "+", "(", "lastOriginId", "++", ")", ";", "this", ".", "_handleTimingFunctionChange", "=", "this", ".", "_handleTimingFunctionChange", ".", "bind", "(", "this", ")", ";", "this", ".", "_handleHostDocumentChange", "=", "this", ".", "_handleHostDocumentChange", ".", "bind", "(", "this", ")", ";", "InlineWidget", ".", "call", "(", "this", ")", ";", "}" ]

[ "Constructor", "for", "inline", "widget", "containing", "a", "BezierCurveEditor", "control" ]

[ "function", "performNpmInstallIfRequired", "(", "npmOptions", ",", "validationResult", ",", "callback", ")", "{", "function", "finish", "(", ")", "{", "callback", "(", "null", ",", "validationResult", ")", ";", "}", "var", "installDirectory", "=", "path", ".", "join", "(", "validationResult", ".", "extractDir", ",", "validationResult", ".", "commonPrefix", ")", ";", "var", "packageJson", ";", "try", "{", "packageJson", "=", "fs", ".", "readJsonSync", "(", "path", ".", "join", "(", "installDirectory", ",", "\"package.json\"", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "packageJson", "=", "null", ";", "}", "if", "(", "!", "packageJson", "||", "!", "packageJson", ".", "dependencies", "||", "!", "Object", ".", "keys", "(", "packageJson", ".", "dependencies", ")", ".", "length", ")", "{", "return", "finish", "(", ")", ";", "}", "_performNpmInstall", "(", "installDirectory", ",", "npmOptions", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "validationResult", ".", "errors", ".", "push", "(", "[", "Errors", ".", "NPM_INSTALL_FAILED", ",", "err", ".", "toString", "(", ")", "]", ")", ";", "}", "finish", "(", ")", ";", "}", ")", ";", "}" ]

[ "Checks", "package", ".", "json", "of", "the", "extracted", "extension", "for", "npm", "dependencies", "and", "runs", "npm", "install", "when", "required", "." ]

[ "function", "showDialog", "(", ")", "{", "var", "currentSettings", "=", "getValues", "(", ")", ";", "var", "newSettings", "=", "{", "}", ";", "var", "themes", "=", "_", ".", "map", "(", "loadedThemes", ",", "function", "(", "theme", ")", "{", "return", "theme", ";", "}", ")", ";", "var", "template", "=", "$", "(", "\"<div>\"", ")", ".", "append", "(", "$settings", ")", ".", "html", "(", ")", ";", "var", "$template", "=", "$", "(", "Mustache", ".", "render", "(", "template", ",", "{", "\"settings\"", ":", "currentSettings", ",", "\"themes\"", ":", "themes", ",", "\"Strings\"", ":", "Strings", "}", ")", ")", ";", "// Select the correct theme.", "var", "$currentThemeOption", "=", "$template", ".", "find", "(", "\"[value='\"", "+", "currentSettings", ".", "theme", "+", "\"']\"", ")", ";", "if", "(", "$currentThemeOption", ".", "length", "===", "0", ")", "{", "$currentThemeOption", "=", "$template", ".", "find", "(", "\"[value='\"", "+", "defaults", ".", "theme", "+", "\"']\"", ")", ";", "}", "$currentThemeOption", ".", "attr", "(", "\"selected\"", ",", "\"selected\"", ")", ";", "$template", ".", "find", "(", "\"[data-toggle=tab].default\"", ")", ".", "tab", "(", "\"show\"", ")", ";", "$template", ".", "on", "(", "\"change\"", ",", "\"[data-target]:checkbox\"", ",", "function", "(", ")", "{", "var", "$target", "=", "$", "(", "this", ")", ";", "var", "attr", "=", "$target", ".", "attr", "(", "\"data-target\"", ")", ";", "newSettings", "[", "attr", "]", "=", "$target", ".", "is", "(", "\":checked\"", ")", ";", "}", ")", ".", "on", "(", "\"input\"", ",", "\"[data-target='fontSize']\"", ",", "function", "(", ")", "{", "var", "target", "=", "this", ";", "var", "targetValue", "=", "$", "(", "this", ")", ".", "val", "(", ")", ";", "var", "$btn", "=", "$", "(", "\"#theme-settings-done-btn\"", ")", "[", "0", "]", ";", "// Make sure that the font size is expressed in terms", "// we can handle (px or em). If not, 'done' button is", "// disabled until input has been corrected.", "if", "(", "target", ".", "checkValidity", "(", ")", "===", "true", ")", "{", "$btn", ".", "disabled", "=", "false", ";", "newSettings", "[", "\"fontSize\"", "]", "=", "targetValue", ";", "}", "else", "{", "$btn", ".", "disabled", "=", "true", ";", "}", "}", ")", ".", "on", "(", "\"input\"", ",", "\"[data-target='fontFamily']\"", ",", "function", "(", ")", "{", "var", "targetValue", "=", "$", "(", "this", ")", ".", "val", "(", ")", ";", "newSettings", "[", "\"fontFamily\"", "]", "=", "targetValue", ";", "}", ")", ".", "on", "(", "\"change\"", ",", "\"select\"", ",", "function", "(", ")", "{", "var", "$target", "=", "$", "(", "\":selected\"", ",", "this", ")", ";", "var", "attr", "=", "$target", ".", "attr", "(", "\"data-target\"", ")", ";", "if", "(", "attr", ")", "{", "prefs", ".", "set", "(", "attr", ",", "$target", ".", "val", "(", ")", ")", ";", "}", "}", ")", ";", "Dialogs", ".", "showModalDialogUsingTemplate", "(", "$template", ")", ".", "done", "(", "function", "(", "id", ")", "{", "var", "setterFn", ";", "if", "(", "id", "===", "\"save\"", ")", "{", "// Go through each new setting and apply it", "Object", ".", "keys", "(", "newSettings", ")", ".", "forEach", "(", "function", "(", "setting", ")", "{", "if", "(", "defaults", ".", "hasOwnProperty", "(", "setting", ")", ")", "{", "prefs", ".", "set", "(", "setting", ",", "newSettings", "[", "setting", "]", ")", ";", "}", "else", "{", "// Figure out if the setting is in the ViewCommandHandlers, which means it is", "// a font setting", "setterFn", "=", "\"set\"", "+", "setting", "[", "0", "]", ".", "toLocaleUpperCase", "(", ")", "+", "setting", ".", "substr", "(", "1", ")", ";", "if", "(", "typeof", "ViewCommandHandlers", "[", "setterFn", "]", "===", "\"function\"", ")", "{", "ViewCommandHandlers", "[", "setterFn", "]", "(", "newSettings", "[", "setting", "]", ")", ";", "}", "}", "}", ")", ";", "}", "else", "if", "(", "id", "===", "\"cancel\"", ")", "{", "// Make sure we revert any changes to theme selection", "prefs", ".", "set", "(", "\"theme\"", ",", "currentSettings", ".", "theme", ")", ";", "}", "}", ")", ";", "}" ]

[ "Opens", "the", "settings", "dialog" ]

[ "function", "getCurrentDocument", "(", ")", "{", "var", "file", "=", "MainViewManager", ".", "getCurrentlyViewedFile", "(", "MainViewManager", ".", "ACTIVE_PANE", ")", ";", "if", "(", "file", ")", "{", "return", "getOpenDocumentForPath", "(", "file", ".", "fullPath", ")", ";", "}", "return", "null", ";", "}" ]

[ "Returns", "the", "Document", "that", "is", "currently", "open", "in", "the", "editor", "UI", ".", "May", "be", "null", "." ]

[ "function", "getWorkingSet", "(", ")", "{", "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", ")", ";", "}", ")", ";", "}" ]

[ "Returns", "a", "list", "of", "items", "in", "the", "working", "set", "in", "UI", "list", "order", ".", "May", "be", "0", "-", "length", "but", "never", "null", "." ]

[ "function", "findInWorkingSet", "(", "fullPath", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use MainViewManager.findInWorkingSet() instead of DocumentManager.findInWorkingSet()\"", ",", "true", ")", ";", "return", "MainViewManager", ".", "findInWorkingSet", "(", "MainViewManager", ".", "ACTIVE_PANE", ",", "fullPath", ")", ";", "}" ]

[ "Returns", "the", "index", "of", "the", "file", "matching", "fullPath", "in", "the", "working", "set", "." ]

[ "function", "addToWorkingSet", "(", "file", ",", "index", ",", "forceRedraw", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use MainViewManager.addToWorkingSet() instead of DocumentManager.addToWorkingSet()\"", ",", "true", ")", ";", "MainViewManager", ".", "addToWorkingSet", "(", "MainViewManager", ".", "ACTIVE_PANE", ",", "file", ",", "index", ",", "forceRedraw", ")", ";", "}" ]

[ "Adds", "the", "given", "file", "to", "the", "end", "of", "the", "working", "set", "list", "." ]

[ "function", "removeListFromWorkingSet", "(", "list", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use CommandManager.execute(Commands.FILE_CLOSE_LIST, {PaneId: MainViewManager.ALL_PANES, fileList: list}) instead of DocumentManager.removeListFromWorkingSet()\"", ",", "true", ")", ";", "CommandManager", ".", "execute", "(", "Commands", ".", "FILE_CLOSE_LIST", ",", "{", "PaneId", ":", "MainViewManager", ".", "ALL_PANES", ",", "fileList", ":", "list", "}", ")", ";", "}" ]

[ "closes", "a", "list", "of", "files" ]

[ "function", "closeAll", "(", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use CommandManager.execute(Commands.FILE_CLOSE_ALL,{PaneId: MainViewManager.ALL_PANES}) instead of DocumentManager.closeAll()\"", ",", "true", ")", ";", "CommandManager", ".", "execute", "(", "Commands", ".", "FILE_CLOSE_ALL", ",", "{", "PaneId", ":", "MainViewManager", ".", "ALL_PANES", "}", ")", ";", "}" ]

[ "closes", "all", "open", "files" ]

[ "function", "closeFullEditor", "(", "file", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use CommandManager.execute(Commands.FILE_CLOSE, {File: file} instead of DocumentManager.closeFullEditor()\"", ",", "true", ")", ";", "CommandManager", ".", "execute", "(", "Commands", ".", "FILE_CLOSE", ",", "{", "File", ":", "file", "}", ")", ";", "}" ]

[ "closes", "the", "specified", "file", "file" ]

[ "function", "setCurrentDocument", "(", "doc", ")", "{", "DeprecationWarning", ".", "deprecationWarning", "(", "\"Use CommandManager.execute(Commands.CMD_OPEN) instead of DocumentManager.setCurrentDocument()\"", ",", "true", ")", ";", "CommandManager", ".", "execute", "(", "Commands", ".", "CMD_OPEN", ",", "{", "fullPath", ":", "doc", ".", "file", ".", "fullPath", "}", ")", ";", "}" ]

[ "opens", "the", "specified", "document", "for", "editing", "in", "the", "currently", "active", "pane" ]

[ "function", "notifyPathDeleted", "(", "fullPath", ")", "{", "// 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", ")", ";", "}", "}" ]

[ "Called", "after", "a", "file", "or", "folder", "has", "been", "deleted", ".", "This", "function", "is", "responsible", "for", "updating", "underlying", "model", "data", "and", "notifying", "all", "views", "of", "the", "change", "." ]

[ "function", "notifyPathNameChanged", "(", "oldName", ",", "newName", ")", "{", "// 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", ")", ";", "}" ]

[ "Called", "after", "a", "file", "or", "folder", "name", "has", "changed", ".", "This", "function", "is", "responsible", "for", "updating", "underlying", "model", "data", "and", "notifying", "all", "views", "of", "the", "change", "." ]

[ "function", "_proxyDeprecatedEvent", "(", "eventName", ")", "{", "DeprecationWarning", ".", "deprecateEvent", "(", "exports", ",", "MainViewManager", ",", "eventName", ",", "eventName", ",", "\"DocumentManager.\"", "+", "eventName", ",", "\"MainViewManager.\"", "+", "eventName", ")", ";", "}" ]

[ "Listens", "for", "the", "given", "event", "on", "MainViewManager", "and", "triggers", "a", "copy", "of", "the", "event", "on", "DocumentManager", "whenever", "it", "occurs" ]

[ "function", "marker", "(", "spec", ")", "{", "var", "elt", "=", "window", ".", "document", ".", "createElement", "(", "\"div\"", ")", ";", "elt", ".", "className", "=", "spec", ";", "return", "elt", ";", "}" ]

[ "Utility", "for", "creating", "fold", "markers", "in", "fold", "gutter" ]

[ "function", "updateFoldInfo", "(", "cm", ",", "from", ",", "to", ")", "{", "var", "minFoldSize", "=", "prefs", ".", "getSetting", "(", "\"minFoldSize\"", ")", "||", "2", ";", "var", "opts", "=", "cm", ".", "state", ".", "foldGutter", ".", "options", ";", "var", "fade", "=", "prefs", ".", "getSetting", "(", "\"hideUntilMouseover\"", ")", ";", "var", "$gutter", "=", "$", "(", "cm", ".", "getGutterElement", "(", ")", ")", ";", "var", "i", "=", "from", ";", "function", "clear", "(", "m", ")", "{", "return", "m", ".", "clear", "(", ")", ";", "}", "/**\n * @private\n * helper function to check if the given line is in a folded region in the editor.\n * @param {number} line the\n * @return {Object} the range that hides the specified line or undefine if the line is not hidden\n */", "function", "_isCurrentlyFolded", "(", "line", ")", "{", "var", "keys", "=", "Object", ".", "keys", "(", "cm", ".", "_lineFolds", ")", ",", "i", "=", "0", ",", "range", ";", "while", "(", "i", "<", "keys", ".", "length", ")", "{", "range", "=", "cm", ".", "_lineFolds", "[", "keys", "[", "i", "]", "]", ";", "if", "(", "range", ".", "from", ".", "line", "<", "line", "&&", "range", ".", "to", ".", "line", ">=", "line", ")", "{", "return", "range", ";", "}", "i", "++", ";", "}", "}", "/**\n This case is needed when unfolding a region that does not cause the viewport to change.\n For instance in a file with about 15 lines, if some code regions are folded and unfolded, the\n viewport change event isn't fired by CodeMirror. The setTimeout is a workaround to trigger the\n gutter update after the viewport has been drawn.\n */", "if", "(", "i", "===", "to", ")", "{", "window", ".", "setTimeout", "(", "function", "(", ")", "{", "var", "vp", "=", "cm", ".", "getViewport", "(", ")", ";", "updateFoldInfo", "(", "cm", ",", "vp", ".", "from", ",", "vp", ".", "to", ")", ";", "}", ",", "200", ")", ";", "}", "while", "(", "i", "<", "to", ")", "{", "var", "sr", "=", "_isCurrentlyFolded", "(", "i", ")", ",", "// surrounding range for the current line if one exists", "range", ";", "var", "mark", "=", "marker", "(", "\"CodeMirror-foldgutter-blank\"", ")", ";", "var", "pos", "=", "CodeMirror", ".", "Pos", "(", "i", ",", "0", ")", ",", "func", "=", "opts", ".", "rangeFinder", "||", "CodeMirror", ".", "fold", ".", "auto", ";", "// don't look inside collapsed ranges", "if", "(", "sr", ")", "{", "i", "=", "sr", ".", "to", ".", "line", "+", "1", ";", "}", "else", "{", "range", "=", "cm", ".", "_lineFolds", "[", "i", "]", "||", "(", "func", "&&", "func", "(", "cm", ",", "pos", ")", ")", ";", "if", "(", "!", "fade", "||", "(", "fade", "&&", "$gutter", ".", "is", "(", "\":hover\"", ")", ")", ")", "{", "if", "(", "cm", ".", "isFolded", "(", "i", ")", ")", "{", "// expand fold if invalid", "if", "(", "range", ")", "{", "mark", "=", "marker", "(", "opts", ".", "indicatorFolded", ")", ";", "}", "else", "{", "cm", ".", "findMarksAt", "(", "pos", ")", ".", "filter", "(", "isFold", ")", ".", "forEach", "(", "clear", ")", ";", "}", "}", "else", "{", "if", "(", "range", "&&", "range", ".", "to", ".", "line", "-", "range", ".", "from", ".", "line", ">=", "minFoldSize", ")", "{", "mark", "=", "marker", "(", "opts", ".", "indicatorOpen", ")", ";", "}", "}", "}", "cm", ".", "setGutterMarker", "(", "i", ",", "opts", ".", "gutter", ",", "mark", ")", ";", "i", "++", ";", "}", "}", "}" ]

[ "Updates", "the", "gutter", "markers", "for", "the", "specified", "range" ]

[ "function", "updateInViewport", "(", "cm", ",", "from", ",", "to", ")", "{", "var", "vp", "=", "cm", ".", "getViewport", "(", ")", ",", "state", "=", "cm", ".", "state", ".", "foldGutter", ";", "from", "=", "isNaN", "(", "from", ")", "?", "vp", ".", "from", ":", "from", ";", "to", "=", "isNaN", "(", "to", ")", "?", "vp", ".", "to", ":", "to", ";", "if", "(", "!", "state", ")", "{", "return", ";", "}", "cm", ".", "operation", "(", "function", "(", ")", "{", "updateFoldInfo", "(", "cm", ",", "from", ",", "to", ")", ";", "}", ")", ";", "state", ".", "from", "=", "from", ";", "state", ".", "to", "=", "to", ";", "}" ]

[ "Updates", "the", "fold", "information", "in", "the", "viewport", "for", "the", "specified", "range" ]

[ "function", "getFoldOnLine", "(", "cm", ",", "line", ")", "{", "var", "pos", "=", "CodeMirror", ".", "Pos", "(", "line", ",", "0", ")", ";", "var", "folds", "=", "cm", ".", "findMarksAt", "(", "pos", ")", "||", "[", "]", ";", "folds", "=", "folds", ".", "filter", "(", "isFold", ")", ";", "return", "folds", ".", "length", "?", "folds", "[", "0", "]", ":", "undefined", ";", "}" ]

[ "Helper", "function", "to", "return", "the", "fold", "text", "marker", "on", "a", "line", "in", "an", "editor" ]

[ "function", "syncDocToFoldsCache", "(", "cm", ",", "from", ",", "lineAdded", ")", "{", "var", "minFoldSize", "=", "prefs", ".", "getSetting", "(", "\"minFoldSize\"", ")", "||", "2", ";", "var", "i", ",", "fold", ",", "range", ";", "if", "(", "lineAdded", "<=", "0", ")", "{", "return", ";", "}", "for", "(", "i", "=", "from", ";", "i", "<=", "from", "+", "lineAdded", ";", "i", "=", "i", "+", "1", ")", "{", "fold", "=", "getFoldOnLine", "(", "cm", ",", "i", ")", ";", "if", "(", "fold", ")", "{", "range", "=", "fold", ".", "find", "(", ")", ";", "if", "(", "range", "&&", "range", ".", "to", ".", "line", "-", "range", ".", "from", ".", "line", ">=", "minFoldSize", ")", "{", "cm", ".", "_lineFolds", "[", "i", "]", "=", "range", ";", "i", "=", "range", ".", "to", ".", "line", ";", "}", "else", "{", "delete", "cm", ".", "_lineFolds", "[", "i", "]", ";", "}", "}", "}", "}" ]

[ "Synchronises", "the", "code", "folding", "states", "in", "the", "CM", "doc", "to", "cm", ".", "_lineFolds", "cache", ".", "When", "an", "undo", "operation", "is", "done", "if", "folded", "code", "fragments", "are", "restored", "then", "we", "need", "to", "update", "cm", ".", "_lineFolds", "with", "the", "fragments" ]

[ "function", "moveRange", "(", "range", ",", "numLines", ")", "{", "return", "{", "from", ":", "CodeMirror", ".", "Pos", "(", "range", ".", "from", ".", "line", "+", "numLines", ",", "range", ".", "from", ".", "ch", ")", ",", "to", ":", "CodeMirror", ".", "Pos", "(", "range", ".", "to", ".", "line", "+", "numLines", ",", "range", ".", "to", ".", "ch", ")", "}", ";", "}" ]

[ "Helper", "function", "to", "move", "a", "fold", "range", "object", "by", "the", "specified", "number", "of", "lines" ]

[ "function", "onCursorActivity", "(", "cm", ")", "{", "var", "state", "=", "cm", ".", "state", ".", "foldGutter", ";", "var", "vp", "=", "cm", ".", "getViewport", "(", ")", ";", "window", ".", "clearTimeout", "(", "state", ".", "changeUpdate", ")", ";", "state", ".", "changeUpdate", "=", "window", ".", "setTimeout", "(", "function", "(", ")", "{", "//need to render the entire visible viewport to remove fold marks rendered from previous selections if any", "updateInViewport", "(", "cm", ",", "vp", ".", "from", ",", "vp", ".", "to", ")", ";", "}", ",", "400", ")", ";", "}" ]

[ "Triggered", "when", "the", "cursor", "moves", "in", "the", "editor", "and", "used", "to", "detect", "text", "selection", "changes", "in", "the", "editor", "." ]

[ "function", "onFold", "(", "cm", ",", "from", ",", "to", ")", "{", "var", "state", "=", "cm", ".", "state", ".", "foldGutter", ";", "updateFoldInfo", "(", "cm", ",", "from", ".", "line", ",", "from", ".", "line", "+", "1", ")", ";", "}" ]

[ "Triggered", "when", "a", "code", "segment", "is", "folded", "." ]

[ "function", "onUnFold", "(", "cm", ",", "from", ",", "to", ")", "{", "var", "state", "=", "cm", ".", "state", ".", "foldGutter", ";", "var", "vp", "=", "cm", ".", "getViewport", "(", ")", ";", "delete", "cm", ".", "_lineFolds", "[", "from", ".", "line", "]", ";", "updateFoldInfo", "(", "cm", ",", "from", ".", "line", ",", "to", ".", "line", "||", "vp", ".", "to", ")", ";", "}" ]

[ "Triggered", "when", "a", "folded", "code", "segment", "is", "unfolded", "." ]

[ "function", "init", "(", ")", "{", "CodeMirror", ".", "defineOption", "(", "\"foldGutter\"", ",", "false", ",", "function", "(", "cm", ",", "val", ",", "old", ")", "{", "if", "(", "old", "&&", "old", "!==", "CodeMirror", ".", "Init", ")", "{", "cm", ".", "clearGutter", "(", "cm", ".", "state", ".", "foldGutter", ".", "options", ".", "gutter", ")", ";", "cm", ".", "state", ".", "foldGutter", "=", "null", ";", "cm", ".", "off", "(", "\"gutterClick\"", ",", "old", ".", "onGutterClick", ")", ";", "cm", ".", "off", "(", "\"change\"", ",", "onChange", ")", ";", "cm", ".", "off", "(", "\"viewportChange\"", ",", "onViewportChange", ")", ";", "cm", ".", "off", "(", "\"cursorActivity\"", ",", "onCursorActivity", ")", ";", "cm", ".", "off", "(", "\"fold\"", ",", "onFold", ")", ";", "cm", ".", "off", "(", "\"unfold\"", ",", "onUnFold", ")", ";", "cm", ".", "off", "(", "\"swapDoc\"", ",", "updateInViewport", ")", ";", "}", "if", "(", "val", ")", "{", "cm", ".", "state", ".", "foldGutter", "=", "new", "State", "(", "parseOptions", "(", "val", ")", ")", ";", "updateInViewport", "(", "cm", ")", ";", "cm", ".", "on", "(", "\"gutterClick\"", ",", "val", ".", "onGutterClick", ")", ";", "cm", ".", "on", "(", "\"change\"", ",", "onChange", ")", ";", "cm", ".", "on", "(", "\"viewportChange\"", ",", "onViewportChange", ")", ";", "cm", ".", "on", "(", "\"cursorActivity\"", ",", "onCursorActivity", ")", ";", "cm", ".", "on", "(", "\"fold\"", ",", "onFold", ")", ";", "cm", ".", "on", "(", "\"unfold\"", ",", "onUnFold", ")", ";", "cm", ".", "on", "(", "\"swapDoc\"", ",", "updateInViewport", ")", ";", "}", "}", ")", ";", "}" ]

[ "Initialises", "the", "fold", "gutter", "and", "registers", "event", "handlers", "for", "changes", "to", "document", "viewport", "and", "user", "interactions", "." ]

[ "function", "_getCondensedForm", "(", "filter", ")", "{", "if", "(", "!", "_", ".", "isArray", "(", "filter", ")", ")", "{", "return", "\"\"", ";", "}", "// Format filter in condensed form", "if", "(", "filter", ".", "length", ">", "2", ")", "{", "return", "filter", ".", "slice", "(", "0", ",", "2", ")", ".", "join", "(", "\", \"", ")", "+", "\" \"", "+", "StringUtils", ".", "format", "(", "Strings", ".", "FILE_FILTER_CLIPPED_SUFFIX", ",", "filter", ".", "length", "-", "2", ")", ";", "}", "return", "filter", ".", "join", "(", "\", \"", ")", ";", "}" ]

[ "Get", "the", "condensed", "form", "of", "the", "filter", "set", "by", "joining", "the", "first", "two", "in", "the", "set", "with", "a", "comma", "separator", "and", "appending", "a", "short", "message", "with", "the", "number", "of", "filters", "being", "clipped", "." ]

[ "function", "_doPopulate", "(", ")", "{", "var", "dropdownItems", "=", "[", "Strings", ".", "NEW_FILE_FILTER", ",", "Strings", ".", "CLEAR_FILE_FILTER", "]", ",", "filterSets", "=", "PreferencesManager", ".", "get", "(", "\"fileFilters\"", ")", "||", "[", "]", ";", "if", "(", "filterSets", ".", "length", ")", "{", "dropdownItems", ".", "push", "(", "\"---\"", ")", ";", "// Remove all the empty exclusion sets before concatenating to the dropdownItems.", "filterSets", "=", "filterSets", ".", "filter", "(", "function", "(", "filter", ")", "{", "return", "(", "_getCondensedForm", "(", "filter", ".", "patterns", ")", "!==", "\"\"", ")", ";", "}", ")", ";", "// FIRST_FILTER_INDEX needs to stay in sync with the number of static items (plus separator)", "// ie. the number of items populated so far before we concatenate with the actual filter sets.", "dropdownItems", "=", "dropdownItems", ".", "concat", "(", "filterSets", ")", ";", "}", "_picker", ".", "items", "=", "dropdownItems", ";", "}" ]

[ "Populate", "the", "list", "of", "dropdown", "menu", "with", "two", "filter", "commands", "and", "the", "list", "of", "saved", "filter", "sets", "." ]

[ "function", "_getFilterIndex", "(", "filterSets", ",", "filter", ")", "{", "var", "index", "=", "-", "1", ";", "if", "(", "!", "filter", "||", "!", "filterSets", ".", "length", ")", "{", "return", "index", ";", "}", "return", "_", ".", "findIndex", "(", "filterSets", ",", "_", ".", "partial", "(", "_", ".", "isEqual", ",", "filter", ")", ")", ";", "}" ]

[ "Find", "the", "index", "of", "a", "filter", "set", "in", "the", "list", "of", "saved", "filter", "sets", "." ]