mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/accessible/jsat/Utils.jsm

956 строки
28 KiB
JavaScript
Исходник Ответственный История

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
/* exported Utils, Logger, PivotContext, PrefCache */
"use strict";
ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
ChromeUtils.defineModuleGetter(this, "Services", // jshint ignore:line
"resource://gre/modules/Services.jsm");
ChromeUtils.defineModuleGetter(this, "Rect", // jshint ignore:line
"resource://gre/modules/Geometry.jsm");
ChromeUtils.defineModuleGetter(this, "Roles", // jshint ignore:line
"resource://gre/modules/accessibility/Constants.jsm");
ChromeUtils.defineModuleGetter(this, "Events", // jshint ignore:line
"resource://gre/modules/accessibility/Constants.jsm");
ChromeUtils.defineModuleGetter(this, "Relations", // jshint ignore:line
"resource://gre/modules/accessibility/Constants.jsm");
ChromeUtils.defineModuleGetter(this, "States", // jshint ignore:line
"resource://gre/modules/accessibility/Constants.jsm");
ChromeUtils.defineModuleGetter(this, "PluralForm", // jshint ignore:line
"resource://gre/modules/PluralForm.jsm");
var EXPORTED_SYMBOLS = ["Utils", "Logger", "PivotContext", "PrefCache"]; // jshint ignore:line
var Utils = { // jshint ignore:line
_buildAppMap: {
"{3c2e2abc-06d4-11e1-ac3b-374f68613e61}": "b2g",
"{d1bfe7d9-c01e-4237-998b-7b5f960a4314}": "graphene",
"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "browser",
"{aa3c5121-dab2-40e2-81ca-7ea25febc110}": "mobile/android"
},
get AccService() {
if (!this._AccService) {
this._AccService = Cc["@mozilla.org/accessibilityService;1"].
getService(Ci.nsIAccessibilityService);
}
return this._AccService;
},
set MozBuildApp(value) {
this._buildApp = value;
},
get MozBuildApp() {
if (!this._buildApp) {
this._buildApp = this._buildAppMap[Services.appinfo.ID];
}
return this._buildApp;
},
get ScriptName() {
if (!this._ScriptName) {
this._ScriptName =
(Services.appinfo.processType == 2) ? "AccessFuContent" : "AccessFu";
}
return this._ScriptName;
},
get AndroidSdkVersion() {
if (!this._AndroidSdkVersion) {
if (Services.appinfo.OS == "Android") {
this._AndroidSdkVersion = Services.sysinfo.getPropertyAsInt32(
"version");
} else {
// Most useful in desktop debugging.
this._AndroidSdkVersion = 16;
}
}
return this._AndroidSdkVersion;
},
set AndroidSdkVersion(value) {
// When we want to mimic another version.
this._AndroidSdkVersion = value;
},
getCurrentBrowser: function getCurrentBrowser(aWindow) {
let win = aWindow ||
Services.wm.getMostRecentWindow("navigator:browser") ||
Services.wm.getMostRecentWindow("navigator:geckoview");
return win.document.querySelector("browser[type=content][primary=true]");
},
getAllMessageManagers: function getAllMessageManagers(aWindow) {
let messageManagers = new Set();
function collectLeafMessageManagers(mm) {
for (let i = 0; i < mm.childCount; i++) {
let childMM = mm.getChildAt(i);
if ("sendAsyncMessage" in childMM) {
messageManagers.add(childMM);
} else {
collectLeafMessageManagers(childMM);
}
}
}
collectLeafMessageManagers(aWindow.messageManager);
let browser = this.getCurrentBrowser(aWindow);
let document = browser ? browser.contentDocument : null;
if (document) {
let remoteframes = document.querySelectorAll("iframe");
for (let i = 0; i < remoteframes.length; ++i) {
let mm = this.getMessageManager(remoteframes[i]);
if (mm) {
messageManagers.add(mm);
}
}
}
return messageManagers;
},
get isContentProcess() {
delete this.isContentProcess;
this.isContentProcess =
Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT;
return this.isContentProcess;
},
localize: function localize(aOutput) {
let outputArray = Array.isArray(aOutput) ? aOutput : [aOutput];
let localized =
outputArray.map(details => this.stringBundle.get(details));
// Clean up the white space.
return localized.filter(word => word).map(word => word.trim()).
filter(trimmed => trimmed);
},
get stringBundle() {
delete this.stringBundle;
let bundle = Services.strings.createBundle(
"chrome://global/locale/AccessFu.properties");
this.stringBundle = {
get: function stringBundle_get(aDetails = {}) {
if (!aDetails || typeof aDetails === "string") {
return aDetails;
}
let str = "";
let string = aDetails.string;
if (!string) {
return str;
}
try {
let args = aDetails.args;
let count = aDetails.count;
if (args) {
str = bundle.formatStringFromName(string, args, args.length);
} else {
str = bundle.GetStringFromName(string);
}
if (count) {
str = PluralForm.get(count, str);
str = str.replace("#1", count);
}
} catch (e) {
Logger.debug("Failed to get a string from a bundle for", string);
} finally {
return str;
}
}
};
return this.stringBundle;
},
getMessageManager: function getMessageManager(aBrowser) {
let browser = aBrowser || this.getCurrentBrowser();
try {
return browser.frameLoader.messageManager;
} catch (x) {
return null;
}
},
getState: function getState(aAccessibleOrEvent) {
if (aAccessibleOrEvent instanceof Ci.nsIAccessibleStateChangeEvent) {
return new State(
aAccessibleOrEvent.isExtraState ? 0 : aAccessibleOrEvent.state,
aAccessibleOrEvent.isExtraState ? aAccessibleOrEvent.state : 0);
}
let state = {};
let extState = {};
aAccessibleOrEvent.getState(state, extState);
return new State(state.value, extState.value);
},
getAttributes: function getAttributes(aAccessible) {
let attributes = {};
if (aAccessible && aAccessible.attributes) {
let attributesEnum = aAccessible.attributes.enumerate();
// Populate |attributes| object with |aAccessible|'s attribute key-value
// pairs.
while (attributesEnum.hasMoreElements()) {
let attribute = attributesEnum.getNext().QueryInterface(
Ci.nsIPropertyElement);
attributes[attribute.key] = attribute.value;
}
}
return attributes;
},
getVirtualCursor: function getVirtualCursor(aDocument) {
let doc = (aDocument instanceof Ci.nsIAccessible) ? aDocument :
this.AccService.getAccessibleFor(aDocument);
return doc.QueryInterface(Ci.nsIAccessibleDocument).virtualCursor;
},
getContentResolution: function _getContentResolution(aAccessible) {
let res = { value: 1 };
aAccessible.document.window.QueryInterface(
Ci.nsIInterfaceRequestor).getInterface(
Ci.nsIDOMWindowUtils).getResolution(res);
return res.value;
},
getBounds: function getBounds(aAccessible) {
let objX = {}, objY = {}, objW = {}, objH = {};
aAccessible.getBounds(objX, objY, objW, objH);
return new Rect(objX.value, objY.value, objW.value, objH.value);
},
getTextBounds: function getTextBounds(aAccessible, aStart, aEnd,
aPreserveContentScale) {
let accText = aAccessible.QueryInterface(Ci.nsIAccessibleText);
let objX = {}, objY = {}, objW = {}, objH = {};
accText.getRangeExtents(aStart, aEnd, objX, objY, objW, objH,
Ci.nsIAccessibleCoordinateType.COORDTYPE_SCREEN_RELATIVE);
return new Rect(objX.value, objY.value, objW.value, objH.value);
},
isInSubtree: function isInSubtree(aAccessible, aSubTreeRoot) {
let acc = aAccessible;
// If aSubTreeRoot is an accessible document, we will only walk up the
// ancestry of documents and skip everything else.
if (aSubTreeRoot instanceof Ci.nsIAccessibleDocument) {
while (acc) {
let parentDoc = acc instanceof Ci.nsIAccessibleDocument ?
acc.parentDocument : acc.document;
if (parentDoc === aSubTreeRoot) {
return true;
}
acc = parentDoc;
}
return false;
}
while (acc) {
if (acc == aSubTreeRoot) {
return true;
}
try {
acc = acc.parent;
} catch (x) {
Logger.debug("Failed to get parent:", x);
acc = null;
}
}
return false;
},
isHidden: function isHidden(aAccessible) {
// Need to account for aria-hidden, so can't just check for INVISIBLE
// state.
let hidden = Utils.getAttributes(aAccessible).hidden;
return hidden && hidden === "true";
},
visibleChildCount: function visibleChildCount(aAccessible) {
let count = 0;
for (let child = aAccessible.firstChild; child; child = child.nextSibling) {
if (!this.isHidden(child)) {
++count;
}
}
return count;
},
inHiddenSubtree: function inHiddenSubtree(aAccessible) {
for (let acc = aAccessible; acc; acc = acc.parent) {
if (this.isHidden(acc)) {
return true;
}
}
return false;
},
isAliveAndVisible: function isAliveAndVisible(aAccessible, aIsOnScreen) {
if (!aAccessible) {
return false;
}
try {
let state = this.getState(aAccessible);
if (state.contains(States.DEFUNCT) || state.contains(States.INVISIBLE) ||
(aIsOnScreen && state.contains(States.OFFSCREEN)) ||
Utils.inHiddenSubtree(aAccessible)) {
return false;
}
} catch (x) {
return false;
}
return true;
},
matchAttributeValue: function matchAttributeValue(aAttributeValue, values) {
let attrSet = new Set(aAttributeValue.split(" "));
for (let value of values) {
if (attrSet.has(value)) {
return value;
}
}
},
getLandmarkName: function getLandmarkName(aAccessible) {
return this.matchRoles(aAccessible, [
"banner",
"complementary",
"contentinfo",
"main",
"navigation",
"search"
]);
},
getMathRole: function getMathRole(aAccessible) {
return this.matchRoles(aAccessible, [
"base",
"close-fence",
"denominator",
"numerator",
"open-fence",
"overscript",
"presubscript",
"presuperscript",
"root-index",
"subscript",
"superscript",
"underscript"
]);
},
matchRoles: function matchRoles(aAccessible, aRoles) {
let roles = this.getAttributes(aAccessible)["xml-roles"];
if (!roles) {
return;
}
// Looking up a role that would match any in the provided roles.
return this.matchAttributeValue(roles, aRoles);
},
getEmbeddedControl: function getEmbeddedControl(aLabel) {
if (aLabel) {
let relation = aLabel.getRelationByType(Relations.LABEL_FOR);
for (let i = 0; i < relation.targetsCount; i++) {
let target = relation.getTarget(i);
if (target.parent === aLabel) {
return target;
}
}
}
return null;
},
isListItemDecorator: function isListItemDecorator(aStaticText,
aExcludeOrdered) {
let parent = aStaticText.parent;
if (aExcludeOrdered && parent.parent.DOMNode.nodeName === "OL") {
return false;
}
return parent.role === Roles.LISTITEM && parent.childCount > 1 &&
aStaticText.indexInParent === 0;
},
isActivatableOnFingerUp: function isActivatableOnFingerUp(aAccessible) {
if (aAccessible.role === Roles.KEY) {
return true;
}
let quick_activate = this.getAttributes(aAccessible)["moz-quick-activate"];
return quick_activate && JSON.parse(quick_activate);
}
};
/**
* State object used internally to process accessible's states.
* @param {Number} aBase Base state.
* @param {Number} aExtended Extended state.
*/
function State(aBase, aExtended) {
this.base = aBase;
this.extended = aExtended;
}
State.prototype = {
contains: function State_contains(other) {
return !!(this.base & other.base || this.extended & other.extended);
},
toString: function State_toString() {
let stateStrings = Utils.AccService.
getStringStates(this.base, this.extended);
let statesArray = new Array(stateStrings.length);
for (let i = 0; i < statesArray.length; i++) {
statesArray[i] = stateStrings.item(i);
}
return "[" + statesArray.join(", ") + "]";
}
};
var Logger = { // jshint ignore:line
GESTURE: -1,
DEBUG: 0,
INFO: 1,
WARNING: 2,
ERROR: 3,
_LEVEL_NAMES: ["GESTURE", "DEBUG", "INFO", "WARNING", "ERROR"],
logLevel: 1, // INFO;
test: false,
log: function log(aLogLevel) {
if (aLogLevel < this.logLevel) {
return;
}
let args = Array.prototype.slice.call(arguments, 1);
let message = (typeof(args[0]) === "function" ? args[0]() : args).join(" ");
message = "[" + Utils.ScriptName + "] " + this._LEVEL_NAMES[aLogLevel + 1] +
" " + message + "\n";
dump(message);
// Note: used for testing purposes. If |this.test| is true, also log to
// the console service.
if (this.test) {
try {
Services.console.logStringMessage(message);
} catch (ex) {
// There was an exception logging to the console service.
}
}
},
info: function info() {
this.log.apply(
this, [this.INFO].concat(Array.prototype.slice.call(arguments)));
},
gesture: function gesture() {
this.log.apply(
this, [this.GESTURE].concat(Array.prototype.slice.call(arguments)));
},
debug: function debug() {
this.log.apply(
this, [this.DEBUG].concat(Array.prototype.slice.call(arguments)));
},
warning: function warning() {
this.log.apply(
this, [this.WARNING].concat(Array.prototype.slice.call(arguments)));
},
error: function error() {
this.log.apply(
this, [this.ERROR].concat(Array.prototype.slice.call(arguments)));
},
logException: function logException(
aException, aErrorMessage = "An exception has occured") {
try {
let stackMessage = "";
if (aException.stack) {
stackMessage = " " + aException.stack.replace(/\n/g, "\n ");
} else if (aException.location) {
let frame = aException.location;
let stackLines = [];
while (frame && frame.lineNumber) {
stackLines.push(
" " + frame.name + "@" + frame.filename + ":" + frame.lineNumber);
frame = frame.caller;
}
stackMessage = stackLines.join("\n");
} else {
stackMessage =
"(" + aException.fileName + ":" + aException.lineNumber + ")";
}
this.error(aErrorMessage + ":\n " +
aException.message + "\n" +
stackMessage);
} catch (x) {
this.error(x);
}
},
accessibleToString: function accessibleToString(aAccessible) {
if (!aAccessible) {
return "[ null ]";
}
try {
return "[ " + Utils.AccService.getStringRole(aAccessible.role) +
" | " + aAccessible.name + " ]";
} catch (x) {
return "[ defunct ]";
}
},
eventToString: function eventToString(aEvent) {
let str = Utils.AccService.getStringEventType(aEvent.eventType);
if (aEvent.eventType == Events.STATE_CHANGE) {
let event = aEvent.QueryInterface(Ci.nsIAccessibleStateChangeEvent);
let stateStrings = event.isExtraState ?
Utils.AccService.getStringStates(0, event.state) :
Utils.AccService.getStringStates(event.state, 0);
str += " (" + stateStrings.item(0) + ")";
}
if (aEvent.eventType == Events.VIRTUALCURSOR_CHANGED) {
let event = aEvent.QueryInterface(
Ci.nsIAccessibleVirtualCursorChangeEvent);
let pivot = aEvent.accessible.QueryInterface(
Ci.nsIAccessibleDocument).virtualCursor;
str += " (" + this.accessibleToString(event.oldAccessible) + " -> " +
this.accessibleToString(pivot.position) + ")";
}
return str;
},
statesToString: function statesToString(aAccessible) {
return Utils.getState(aAccessible).toString();
},
dumpTree: function dumpTree(aLogLevel, aRootAccessible) {
if (aLogLevel < this.logLevel) {
return;
}
this._dumpTreeInternal(aLogLevel, aRootAccessible, 0);
},
_dumpTreeInternal:
function _dumpTreeInternal(aLogLevel, aAccessible, aIndent) {
let indentStr = "";
for (let i = 0; i < aIndent; i++) {
indentStr += " ";
}
this.log(aLogLevel, indentStr,
this.accessibleToString(aAccessible),
"(" + this.statesToString(aAccessible) + ")");
for (let i = 0; i < aAccessible.childCount; i++) {
this._dumpTreeInternal(aLogLevel, aAccessible.getChildAt(i),
aIndent + 1);
}
}
};
/**
* PivotContext: An object that generates and caches context information
* for a given accessible and its relationship with another accessible.
*
* If the given accessible is a label for a nested control, then this
* context will represent the nested control instead of the label.
* With the exception of bounds calculation, which will use the containing
* label. In this case the |accessible| field would be the embedded control,
* and the |accessibleForBounds| field would be the label.
*/
function PivotContext(aAccessible, aOldAccessible, // jshint ignore:line
aStartOffset, aEndOffset, aIgnoreAncestry = false,
aIncludeInvisible = false) {
this._accessible = aAccessible;
this._nestedControl = Utils.getEmbeddedControl(aAccessible);
this._oldAccessible =
this._isDefunct(aOldAccessible) ? null : aOldAccessible;
this.startOffset = aStartOffset;
this.endOffset = aEndOffset;
this._ignoreAncestry = aIgnoreAncestry;
this._includeInvisible = aIncludeInvisible;
}
PivotContext.prototype = {
get accessible() {
// If the current pivot accessible has a nested control,
// make this context use it publicly.
return this._nestedControl || this._accessible;
},
get oldAccessible() {
return this._oldAccessible;
},
get isNestedControl() {
return !!this._nestedControl;
},
get accessibleForBounds() {
return this._accessible;
},
get textAndAdjustedOffsets() {
if (this.startOffset === -1 && this.endOffset === -1) {
return null;
}
if (!this._textAndAdjustedOffsets) {
let result = {startOffset: this.startOffset,
endOffset: this.endOffset,
text: this._accessible.QueryInterface(Ci.nsIAccessibleText).
getText(0,
Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT)};
let hypertextAcc = this._accessible.QueryInterface(
Ci.nsIAccessibleHyperText);
// Iterate through the links in backwards order so text replacements don't
// affect the offsets of links yet to be processed.
for (let i = hypertextAcc.linkCount - 1; i >= 0; i--) {
let link = hypertextAcc.getLinkAt(i);
let linkText = "";
if (link instanceof Ci.nsIAccessibleText) {
linkText = link.QueryInterface(Ci.nsIAccessibleText).
getText(0,
Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT);
}
let start = link.startIndex;
let end = link.endIndex;
for (let offset of ["startOffset", "endOffset"]) {
if (this[offset] >= end) {
result[offset] += linkText.length - (end - start);
}
}
result.text = result.text.substring(0, start) + linkText +
result.text.substring(end);
}
this._textAndAdjustedOffsets = result;
}
return this._textAndAdjustedOffsets;
},
/**
* Get a list of |aAccessible|'s ancestry up to the root.
* @param {nsIAccessible} aAccessible.
* @return {Array} Ancestry list.
*/
_getAncestry: function _getAncestry(aAccessible) {
let ancestry = [];
let parent = aAccessible;
try {
while (parent && (parent = parent.parent)) {
ancestry.push(parent);
}
} catch (x) {
// A defunct accessible will raise an exception geting parent.
Logger.debug("Failed to get parent:", x);
}
return ancestry.reverse();
},
/**
* A list of the old accessible's ancestry.
*/
get oldAncestry() {
if (!this._oldAncestry) {
if (!this._oldAccessible || this._ignoreAncestry) {
this._oldAncestry = [];
} else {
this._oldAncestry = this._getAncestry(this._oldAccessible);
this._oldAncestry.push(this._oldAccessible);
}
}
return this._oldAncestry;
},
/**
* A list of the current accessible's ancestry.
*/
get currentAncestry() {
if (!this._currentAncestry) {
this._currentAncestry = this._ignoreAncestry ? [] :
this._getAncestry(this.accessible);
}
return this._currentAncestry;
},
/*
* This is a list of the accessible's ancestry up to the common ancestor
* of the accessible and the old accessible. It is useful for giving the
* user context as to where they are in the heirarchy.
*/
get newAncestry() {
if (!this._newAncestry) {
this._newAncestry = this._ignoreAncestry ? [] :
this.currentAncestry.filter(
(currentAncestor, i) => currentAncestor !== this.oldAncestry[i]);
}
return this._newAncestry;
},
/*
* Traverse the accessible's subtree in pre or post order.
* It only includes the accessible's visible chidren.
* Note: needSubtree is a function argument that can be used to determine
* whether aAccessible's subtree is required.
*/
_traverse: function* _traverse(aAccessible, aPreorder, aStop) {
if (aStop && aStop(aAccessible)) {
return;
}
let child = aAccessible.firstChild;
while (child) {
let include;
if (this._includeInvisible) {
include = true;
} else {
include = !Utils.isHidden(child);
}
if (include) {
if (aPreorder) {
yield child;
for (let node of this._traverse(child, aPreorder, aStop)) {
yield node;
}
} else {
for (let node of this._traverse(child, aPreorder, aStop)) {
yield node;
}
yield child;
}
}
child = child.nextSibling;
}
},
/**
* Get interaction hints for the context ancestry.
* @return {Array} Array of interaction hints.
*/
get interactionHints() {
let hints = [];
this.newAncestry.concat(this.accessible).reverse().forEach(aAccessible => {
let hint = Utils.getAttributes(aAccessible)["moz-hint"];
if (hint) {
hints.push(hint);
} else if (aAccessible.actionCount > 0) {
hints.push({
string: Utils.AccService.getStringRole(
aAccessible.role).replace(/\s/g, "") + "-hint"
});
}
});
return hints;
},
/*
* A subtree generator function, used to generate a flattened
* list of the accessible's subtree in pre or post order.
* It only includes the accessible's visible chidren.
* @param {boolean} aPreorder A flag for traversal order. If true, traverse
* in preorder; if false, traverse in postorder.
* @param {function} aStop An optional function, indicating whether subtree
* traversal should stop.
*/
subtreeGenerator: function subtreeGenerator(aPreorder, aStop) {
return this._traverse(this.accessible, aPreorder, aStop);
},
getCellInfo: function getCellInfo(aAccessible) {
if (!this._cells) {
this._cells = new WeakMap();
}
let domNode = aAccessible.DOMNode;
if (this._cells.has(domNode)) {
return this._cells.get(domNode);
}
let cellInfo = {};
let getAccessibleCell = function getAccessibleCell(aAccessible) {
if (!aAccessible) {
return null;
}
if (![
Roles.CELL,
Roles.COLUMNHEADER,
Roles.ROWHEADER,
Roles.MATHML_CELL
].includes(aAccessible.role)) {
return null;
}
try {
return aAccessible.QueryInterface(Ci.nsIAccessibleTableCell);
} catch (x) {
Logger.logException(x);
return null;
}
};
let getHeaders = function* getHeaders(aHeaderCells) {
let enumerator = aHeaderCells.enumerate();
while (enumerator.hasMoreElements()) {
yield enumerator.getNext().QueryInterface(Ci.nsIAccessible).name;
}
};
cellInfo.current = getAccessibleCell(aAccessible);
if (!cellInfo.current) {
Logger.warning(aAccessible,
"does not support nsIAccessibleTableCell interface.");
this._cells.set(domNode, null);
return null;
}
let table = cellInfo.current.table;
if (table.isProbablyForLayout()) {
this._cells.set(domNode, null);
return null;
}
cellInfo.previous = null;
let oldAncestry = this.oldAncestry.reverse();
let ancestor = oldAncestry.shift();
while (!cellInfo.previous && ancestor) {
let cell = getAccessibleCell(ancestor);
if (cell && cell.table === table) {
cellInfo.previous = cell;
}
ancestor = oldAncestry.shift();
}
if (cellInfo.previous) {
cellInfo.rowChanged = cellInfo.current.rowIndex !==
cellInfo.previous.rowIndex;
cellInfo.columnChanged = cellInfo.current.columnIndex !==
cellInfo.previous.columnIndex;
} else {
cellInfo.rowChanged = true;
cellInfo.columnChanged = true;
}
cellInfo.rowExtent = cellInfo.current.rowExtent;
cellInfo.columnExtent = cellInfo.current.columnExtent;
cellInfo.columnIndex = cellInfo.current.columnIndex;
cellInfo.rowIndex = cellInfo.current.rowIndex;
cellInfo.columnHeaders = [];
if (cellInfo.columnChanged && cellInfo.current.role !==
Roles.COLUMNHEADER) {
cellInfo.columnHeaders = [...getHeaders(cellInfo.current.columnHeaderCells)];
}
cellInfo.rowHeaders = [];
if (cellInfo.rowChanged &&
(cellInfo.current.role === Roles.CELL ||
cellInfo.current.role === Roles.MATHML_CELL)) {
cellInfo.rowHeaders = [...getHeaders(cellInfo.current.rowHeaderCells)];
}
this._cells.set(domNode, cellInfo);
return cellInfo;
},
get bounds() {
if (!this._bounds) {
this._bounds = Utils.getBounds(this.accessibleForBounds);
}
return this._bounds.clone();
},
_isDefunct: function _isDefunct(aAccessible) {
try {
return Utils.getState(aAccessible).contains(States.DEFUNCT);
} catch (x) {
return true;
}
}
};
function PrefCache(aName, aCallback, aRunCallbackNow) { // jshint ignore:line
this.name = aName;
this.callback = aCallback;
let branch = Services.prefs;
this.value = this._getValue(branch);
if (this.callback && aRunCallbackNow) {
try {
this.callback(this.name, this.value, true);
} catch (x) {
Logger.logException(x);
}
}
branch.addObserver(aName, this, true);
}
PrefCache.prototype = {
_getValue: function _getValue(aBranch) {
try {
if (!this.type) {
this.type = aBranch.getPrefType(this.name);
}
switch (this.type) {
case Ci.nsIPrefBranch.PREF_STRING:
return aBranch.getCharPref(this.name);
case Ci.nsIPrefBranch.PREF_INT:
return aBranch.getIntPref(this.name);
case Ci.nsIPrefBranch.PREF_BOOL:
return aBranch.getBoolPref(this.name);
default:
return null;
}
} catch (x) {
// Pref does not exist.
return null;
}
},
observe: function observe(aSubject) {
this.value = this._getValue(aSubject.QueryInterface(Ci.nsIPrefBranch));
Logger.info("pref changed", this.name, this.value);
if (this.callback) {
try {
this.callback(this.name, this.value, false);
} catch (x) {
Logger.logException(x);
}
}
},
QueryInterface: ChromeUtils.generateQI([Ci.nsIObserver,
Ci.nsISupportsWeakReference])
};
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку