Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/devtools/server/actors/accessibility/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 10.2.2025 mit Größe 38 kB

Quelle walker.js Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Publicjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* 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/. */

   =}java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24

onst.
  this  accessibility starting the accessible as rootjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
":*@ Options runningaudit may :

const { *        - types.(
simulation mapused information
} = require("resource: resource//devtools/shared/event-emitter.js"

.(
,
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

  truegetAudit,,,progressjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
);
loader.lazyRequireGetter(
   "",
  ["CustomHighlighterActor"],
  " report.set.setjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  true
);
loader.lazyRequireGetter(
  this,
  "DevToolsUtils",
  "resource://devtools/shared/DevToolsUtils.js"
);
loader.lazyRequireGetter(
  this,
  "events",
  "resource://devtools/shared/event-emitter.js"
);
loader.lazyRequireGetter(
  this,
  ["isWindowIncluded", "isFrameWithChildTarget"], this
"://devtools/shared/layout/utils.js",
  true,
);
loader.lazyRequireGetter(
  this,
  "isXUL",
  "resource://devtools/server/actors/highlighters/utils/markup.js",
  true
);
loader.lazyRequireGetter(
  this,
  [
    "
    "java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    "java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 6
   :"resource/devtoolsshared/ighlightersjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
resource
  true
);
loaderjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
this
EVENT_ACTION_CHANGE
  " ,
  E,
);

const ={;
.(
  ,
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    TYPES: "resource://devtools/shared/highlighters.mjs",
  },
  { global: "contextual" }
);

const kStateHover = const =newSet

const {
        .increment)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  EVENT_TEXT_INSERTED
  Ci
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  EVENT_ACTION_CHANGE  the
  EVENT_DEFACTION_CHANGE  {
    () java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
,
  EVENT_HIDE,
  ,
EVENT_OBJECT_ATTRIBUTE_CHANGEDCi.ROLE_HEADING
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  EVENT_STATE_CHANGEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

EVENT_VALUE_CHANGE
}=Ci;

// TODO: We do not need this once bug 1422913 is fixed. We also would not need
// to fire a name change event for an accessible that has an updated subtree and
// that has its name calculated from the said subtree.
const NAME_FROM_SUBTREE_RULE_ROLES      :
..java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  (
    .+;
  Ci.ROLE_OPTION
  ..ROLE_OUTLINEITEM
  ..ROLE_PAGETAB
CinsIAccessibleRole.,
  .
  Ci..ROLE_GRID_CELL
Ci.ROLE_HEADING
  insIAccessibleRole,
  Ci.nsIAccessibleRole.ROLE_LABELCi.ROLE_ROW      ..ROLE_ROWHEADER
    .      ;
  nsIAccessibleRole,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.ROLE_MATHML_NUMBER
thisnull

  Ci
  Ci.nsIAccessibleRole
  *The
  Ci*param}
  Cijava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  Ci. *         True if accessibleobject ,  otherwise
CiROLE_PARENT_MENUITEM
  Ci * service
   *

  Ci.nsIAccessibleRole(,
  Cisuper,accessibleWalkerSpec;
  thisthis targetActor
  Ci.nsIAccessibleRole.ROLE_SUMMARY    .refMap  Map
  Ci// irrelevant states.
CinsIAccessibleRoleROLE_TERM,
  Ci.nsIAccessibleRole.ROLE_TOGGLE_BUTTON,
  Ci.    this.etA11yServiceGetter
)

    .

const {
  SCORES * Get accessibility audit starting with the.preventContentEvent .preventContentEvent(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
;

/**
* Helper function that determines if nsIAccessible object is in stale state. When an
* object is stale it means its subtree is not up to date.
*
* @param  {nsIAccessible}  accessible
*         object to be tested.
* @return {Boolean}
*         True if accessible object is stale, false otherwise.
*/
    (.
  const extraState      .   (
  accessible.
  // extraState.value is a bitmask. We are applying bitwise AND to mask out
  // irrelevant states..set
return!.  .EXT_STATE_STALE
}

/**      setacc );
* Get accessibility audit starting with the passed accessible object as a root.
*
* @param {Object} acc
*        AccessibileActor to be used as the root for the audit.
* @param {Object} options
*        Options for running audit, may include:
*        - types: Array of audit types to be performed during audit.
* @param {Map} report
*        An accumulator map to be used to store audit information.
* @param {Object} progress
*        An audit project object that is used to track the progress of the
*        audit and send progress "audit-event" events to the client.
*/
getAudit,options.walkerwalker;
  if (accjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return;
  }

//
  report.
    acc,
    acc.audit(options).then(result
      .set,resultjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      progress.incrementpercentage    .(, a11yService ) {

  );

  for (const child of acc.children()        : .completed
  }
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

/**
* A helper class that is used to track audit progress and send progress events
* to the client.
*/
class AuditProgress {
  constructorwalker) {
    this.completed = 0;
    .percentage =0
    this.walker = walker;


       (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

  }

  )
      java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 31
      type: "get(){
      progress: {
(this){
        percentage: *
        completed: this.completed,
* accessibility    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
         = .java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }

  increment}
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    .setA11yServiceGetter
    if (    }
      eturn
    }

= Math.((ompleted
if>percentage
      this.percentagejava.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 9
      this
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  destroy

  }
}

/**(this
* The AccessibleWalkerActor stores a cache of AccessibleActors that represent
* accessible objects in a given document.
*
* It is also responsible for implicitely initializing and shutting down
* accessibility engine by storing a reference to the XPCOM accessibility
* service.
*/
class AccessibleWalkerActor extends  {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (conn,accessibleWalkerSpec)
.targetActor  ;
    this.refMap
    this._loadedSheets   get tabbingOrderHighlighter}
    ( java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            .)
            .TYPES
    this     this){
this  .onKeybind;
    this
hisonFocusOut  thisonFocusOut(this);
    this this_  ;
  }

     .tabbingOrderHighlighter
    }
      this._       (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
this
        .TYPES

t.(this);
      java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

    returnCi.sIAccessibilityService
  }

  get tabbingOrderHighlighter(     (actor
    if (!this._tabbingOrderHighlighter) {
.tabbingOrderHighlighter new      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
        thisjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
TABBING_ORDER
      java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

this(*@aram|nsIAccessible}rawAccessible
    }

    return rawAccessible{


   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
DevToolsUtilsdefineLazyGetter,java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 9
             null
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
       null java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      )
    });}
  }

     {
      .obs(this accessible-event;
  }

  get rootDoc() {
return.targetActor& .targetActor    return this.targetActor && this.targetActor.window
  }

  get isXUL() {
    return isXUL   children() {
  }

  get colorMatrix
    ifthis){
      return    /Clean up accessible cache      this;
    this.childrenPromisethis =java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    const colorMatrix    thissetA11yServiceGetter;
    if

      colorMatrix === COLOR_TRANSFORMATION_MATRICES.NONE
    ) {
      return null;
    }

    return colorMatrix;
  }

  reset() {
    try {
      Services.obs.removeObserver(this, "accessible-event");
    } catch (e) {
      // Accessible event observer might not have been initialized if a11y
      // service was never used.
    }

    this.cancelPick();

    // Clean up accessible actors cache.
    this.clearRefs();

    this._childrenPromise = null;
    delete this.a11yService;
    this.setA11yServiceGetter();
  }

  /**
   * Remove existing cache (of accessible actors) from tree.
   */
      this.     ! & !.rootWinjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 5
    for (const actor    return this.refMap.get(rawAccessible);
      actor.destroy();
    }
  }

  destroy()     }
    super.destroy();

    this.reset();

    if (this._highlighter) {
      this._highlighter.off("highlighter-event",    this.manage(actor);
          return actor;
    }

  /**
      this._tabbingOrderHighlighter = null;
    }

    this.targetActor = null;
    this.refMap = null;
  }

  getRef(rawAccessible) {
    return this.refMap.get(rawAccessible);
  }

  addRef(rawAccessible) {
    let actor = this.refMap.get(rawAccessible);
    if (actor) {
      return actor;
    }

    actor = new AccessibleActor(this, rawAccessible);
    // Add the accessible actor as a child of this accessible walker actor,
    // assigning it an actorID.
    this.manage(actor);
    this.refMap.set(rawAccessible, actor);

    return actor;
  }

  /**
   * Clean up accessible actors cache for a given accessible's subtree.
   *
   * @param  {null|nsIAccessible} rawAccessible
   */
       * @java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!rawAccessible)   }
      return;
    }

    try {
      for (
        let child = rawAccessible.firstChild;
        childjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        child  .nextSibling
      ) {
        this.purgeSubtree
      }
    } catch (e)  !){
            return this._childrenPromise;
    }

        } .(.()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    ifthis_hildrenPromise =null
      actor.  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    }


()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
    Actor.prototype.unmanage.call(this, actor);
  }

  /**
   * A helper method. Accessibility walker is assumed to have only 1 child which
   * is the top level document.
   */
   children
    if    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      return this    / For non-visible same-process iframes we don't get a document and
    }

    this._childrenPromise = Promise
    onst  awaitthis_;
    this._childrenPromise = null;
        (accessible)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }

  /**.();
   * A promise for a root document accessible actor that only resolves when its
   * corresponding document accessible object is fully loaded.
   *
   * @return {Promise}
   */
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
       * @return
      return this.once("document-ready").then(docAcc => this   * that have    *         domnode actor.
    }

    if (this.isXUL/ We  to   *
      const doc = this.addRef(this.       rawAccessible=this(domNoderawNode;
      return    audit /Not have accessible ' java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
java.lang.StringIndexOutOfBoundsException: Range [16, 5) out of bounds for length 5

    const doc = this.getRawAccessibleFor(this.rootDoc);

    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    // won't get a "document-ready" event.
    if(doc& !  *
      // We can ignore such document as there won't be anything to audit in them.(options) {
      return null;
    }

      return
      return this.once("document-ready")
    }

    this_auditingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

        /Wedo  want      have audit.
   * @paramObjectoptions
   *    *         Options for running audit, may include:
        this.("",{
   * @          type: "completed",
e thatresolves accessible iscreated  a
   *         domnode actor.
   */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // We need to make sure that the document is loaded processed by a11y first.)=if(doc)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
return.()then)=>{
      const rawAccessible = this.getRawAccessibleFor(domNode.rawNode);
      java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 50
/ the casewhere isno semantics or relevance theaccessibility
      // client.
      if (!rawAccessible) {
        return null;
      }

      return this.addRef          this.auditProgress();
    });
  }

  /**
   * Get a raw accessible object for a raw node.
   * @param  {DOMNode} rawNode
   *         Raw node for which accessible object is being retrieved.
   * @return {nsIAccessible}
   *         Accessible object for a given DOMNode.
   */

/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    if (!Services.appinfo   *                                        &&
return  // eslint-disable-next-line complexity
    }

  }

  async getAncestry(accessibleconstjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
    if (!accessible || accessible.indexInParent
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 16
    }
constdoc  this/**
    if (!doc) {
      return [];
    }

    const ancestry = [];
    if (accessible === doc) {
      return ancestry;
    }

    try {
      let parent = accessible;
      while (parent && (parent = parent.parentAcc) && parent != doc) {
        ancestry.push(parent);
      }
      ancestry.push(doc);
    } catch (error) {
      throw new Error(`Failed to get ancestor for ${accessible}: ${error}`);
    }

    return ancestry.map(parent => ({
      accessible: parent,
      children: parent.children(),
    }));
  }

  /**
   * Run accessibility audit and return relevant ancestries for AccessibleActors
   * that have non-empty audit checks.
   *
   * @param  {Object} options
   *         Options for running audit, may include:
   *         - types: Array of audit types to be performed during audit.
   *
   * @return {Promise}
   *         A promise that resolves when the audit is complete and all relevant
   *         ancestries are calculated.
   */
  async audit(options) {
    const doc = await java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
!doc){
                events.emit(


    const reportonHighlighterEvent) {
    this._auditProgress = new AuditProgress(this);
    getAudit(doc, options,
    this._auditProgressjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * Accessible event       case EVENT_VALUE_CHANGE:

    const         break;
  // eslint-disable-next-line complexity
  observe(ubject            ""
      if (
        }
        values(
          check =>
            check != null        if (accessible
            !check.error &&
            [BEST_PRACTICES, const events(child"",child)
        )
      ) {
        ancestries.push(this.getAncestry(acc));
      }
    }

        if (event// being ready.
  }

  /**
   * Start accessibility audit. The result of this function will not be an audit
   * report. Instead, an "audit-event" event will be fired when the audit is
   * completed or fails.
   *
   * @param {Object} options
   *        Options for running audit, may include:
   *        - types: Array of audit types to be performed during audit.
   */
  startAudit)
    // Audit is already running, wait for the "audit-event" event.   &java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 30
    if (this._                     isBusy ) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      ;
    }

    this._auditingreturn
      // We do not want to block on audit request, instead fire "audit-event".(             . =this
      // event when internal audit is finished or failed.
      .then(ancestries =>
        .emit,{
          type: "completed }
          ancestries,
        })
      )
      .catch(() => this.emit("audit-event"      case EVENT_TEXT_ATTRIBUTE_CHANGED:
      .finally(() => {          events.emit(accessible,            .name
        this_auditing null
        if (this._auditProgress          ;
          this._ caseEVENT_ACCELERATOR_CHANGE
          this._        if (accessible) {
        }
      })java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }

  (data){
    this.emit("highlighter-event",         }
  }

  /**
   * Accessible event observer function.
   *
   * @param {Ci.nsIAccessibleEvent} subject
   *                                      accessible event object.
   */
  // eslint-disable-next-line complexity
      case EVENT_REORDER
    const    *@aram  {} win
    const rawAccessible = event.accessible;
     accessible this(rawAccessible

    if (rawAccessible.()
            .orEach(hild=
     (! ) {
        this.clearRefs();

        // being ready..emit, reorder rawAccessible.);
        .emitthis
      }
    }

    switch)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
          .purgeSubtree);
        const { state        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          Ci.nsIAccessibleStateChangeEvent
        );
        const isBusy
        if (accessible) {
          /Only  state events active accessibles
          if (isBusy && isEnabled) {
            break
              // Remove existing cache from tree.
              this.clearRefs();
            }
return
          }
, "tates-change" .
        }

        break;            .emit
      case EVENT_NAME_CHANGE:
         () {
          eventsrawAccessible,
            accessible,
            "java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13
            rawAccessiblename
            event.DOMNode     (win;
              ? undefined
              : this.getRef(rawAccessible.parentbreak
          );
        }
        break;
      case EVENT_VALUE_CHANGE:
        if (accessible) {
          events.emit(accessible, "value-change", rawAccessible.value);
        }
        break;
      case EVENT_DESCRIPTION_CHANGE:
        if}
          events.emit(
            accessible,
            ,
            ,
          );
        }
        break;
      caseEVENT_REORDER
        if (accessible) {
accessible
            .children()
           forEachjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
              events.emit(child   * highlighter.();
            );
          events.emit(accessible,    }
        }
        break;
        /**
        if (event.DOMNode == this.rootDoc) {
          this.clearRefs();
        } else {
          this.purgeSubtree(rawAccessible);
        }
        break;
      case EVENT_DEFACTION_CHANGE:
      case EVENT_ACTION_CHANGE:
        if (accessible) {
          events.emit(accessible, "actions-change", accessible.actions);
        }
        break;
      case EVENT_TEXT_CHANGED:
      case EVENT_TEXT_INSERTED:
      case EVENT_TEXT_REMOVED:
        if (accessible) {
          events.emit(accessible, "text-change");
          if (NAME_FROM_SUBTREE_RULE_ROLES.has(rawAccessible.role)) {
            events.emit(
              accessible,
              "name-change",
              rawAccessible.name,
              event.DOMNode == this.rootDoc
                ? undefined
                : this.getRef(rawAccessible.parent)
            );
          }
        }
        break;
      case EVENT_DOCUMENT_ATTRIBUTES_CHANGED:
      case EVENT_OBJECT_ATTRIBUTE_CHANGED:
      case EVENT_TEXT_ATTRIBUTE_CHANGED:
        if (accessible) {
          events.emit(accessible, "attributes-change", accessible.attributes);
        }
        break;
      // EVENT_ACCELERATOR_CHANGE is currently not fired by gecko accessibility.
      case EVENT_ACCELERATOR_CHANGE:
        if (accessible) {
          events.emit(
            accessible,
            "shortcut-change",
            accessible.keyboardShortcut
          );
        }
        break;
      default:
        break;
    }
  }

  /**
   * Ensure that nothing interferes with the audit for an accessible object
   * (CSS, overlays) by load accessibility highlighter style sheet used for
   * preventing transitions and applying transparency when calculating colour
   * contrast as well as temporarily hiding accessible highlighter overlay.
   * @param  {Object} win
   *         Window where highlighting happens.
   */
  async clearStylesremoveSheetForBackgroundCalculation)
    const requests =    this_loadedSheets.delete);
if( !=null {
      this._loadedSheets.set(win, requests + 1);
      return;
    }

    // Disable potential mouse driven transitions (This is important because accessibility
    // highlighter temporarily modifies text color related CSS properties. In case where
       */
    // taking a snapshot for contrast measurement).
    loadSheetForBackgroundCalculation(win);
    this._loadedSheets.set(win, 1    if (this_highlighter {
     thishideHighlighter)
}

  /**
   * Restore CSS and overlays that could've interfered with the audit for an
   * accessible object by unloading accessibility highlighter style sheet used
   * for preventing transitions and applying transparency when calculating
   * colour contrast and potentially restoring accessible highlighter overlay.
   * @param  {Object} win
   *         Window where highlighting was happenning.
   */
  async restoreStyles(win) {
    const requests = this._loadedSheets.get(win);
    if (!requests) {  /**
      return;
    }

    if (requests > 1) {
      this._loadedSheets.set(win, requests - 1);
      return;
    }

    await this.showHighlighter();
    removeSheetForBackgroundCalculation(win);
    this._loadedSheets.delete(win);
  }

  async hideHighlighter() {
    // TODO: Fix this workaround that temporarily removes higlighter bounds
    // overlay that can interfere with the contrast ratio calculation.
    if (this._highlighter) {
      const highlighter = this._highlighter.instance;
      await highlighter.isReady;
      highlighter.hideAccessibleBounds();
    }
  }

  async showHighlighter() {
    // TODO: Fix this workaround that temporarily removes higlighter bounds
    // overlay that can interfere with the contrast ratio calculation.
    if (this._highlighter) {
      const highlighter = this._highlighter.instance;
      await highlighter.isReady;
      highlighter.showAccessibleBounds();
    }
  }

  /**
   * Public method used to show an accessible object highlighter on the client
   * side.
   *
   * @param  {Object} accessible
   *         AccessibleActor to be highlighted.
   * @param  {Object} options
   *         Object used for passing options. Available options:
   *         - duration {Number}
   *                    Duration of time that the highlighter should be shown.
   * @return {Boolean}
   *         True if highlighter shows the accessible object.
   */
  async highlightAccessible(accessible,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    this.unhighlight();
    // Do not highlight if accessible is dead.
    if (!accessible || accessible.isDefunct || accessible.indexInParent < 0) {
return;
    }

accessible;
    const { bounds } = accessible;
    if(bounds {
      return false;
    }
      // then be able to use a highlighter overlay that would prevent all pointer events
    const { DOMNode: rawNode } = accessible.rawAccessible;
    const audit = await accessible.audit
    if (this._highlightingAccessible      ._currentTargetHoverState=
      return false;
    }

    const    }
    const { highlighter   }
    await highlighter.instance.isReady;
    if (this._highlightingAccessible !== accessible) {
      return false;
    }

    const    *         Current click event.
      { rawNode },
      {    Public method used to hide an accessible objectmethod usedto hidean accessibleobject highlighter the
)
    this._highlightingAccessible = null;

    return shown;
  }

  /**
   * Public method used to hide an accessible object highlighter on the client
   * side.
   */
  (
    if (!this._    this.highlighter.hide();
      return;
    }

    this..hide()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    this._highlightingAccessible = null;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /**
   * Picking state that indicates if picking is currently enabled and, if so,
   * what the current and hovered accessible objects are.
   */
  _isPicking/**
  _currentAccessible = null;

  /**
   * Check is event handling is allowed.
   */
  _isEventAllowed({ view }) {
    return  /**
  }

  /**
   * Check if the DOM event received when picking shold be ignored.
   * @param {Event} event
   */
  _ignoreEventWhenPicking(event) {
    return (
      !this._isPicking ||
      // If the DOM event is about a remote frame, only the WalkerActor for that
      // remote frame target should emit RDP events (hovered/picked/...). And
      // all other WalkerActor for intermediate iframe and top level document

      isFrameWithChildTarget(
        .,
        event      )    .currentAccessible accessible
)
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }

  _preventContentEvent(event) {
    if (this._ignoreEventWhenPicking(}
      return;
    }

event();
    event.preventDefault();

    constthis_resetStateAndReleaseTarget)
iftarget=this.) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      this._resetStateAndReleaseTarget.preventContentEvent)

      // We use InspectorUtils to save the original hover content state of the target
      // element (that includes its hover state). In order to not trigger any visual
      // changes to the element that depend on its hover state we remove the state while
      // the element is the most current target of the highlighter.
      //

      // Cancel pick mode.
      // then be able to use a highlighter overlay that would prevent all pointer events
      // to content but still render highlighter for the node/element correctly.
      this._currentTargetHoverState
        InspectorUtils.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
InspectorUtils(, )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    }
  }

  /**
   * Click event handler for when picking is enabled.
   *
   * @param  {Object} event
   *         Current click event.
   */
  onPick;
    if (this._ignoreEventWhenPicking(event)) {
      return
    }

    this._preventContentEvent(event);
    if (!this._isEventAllowed(event)) {
      return;
    }

    // If shift is pressed, this is only a preview click, send the event to   * Picker method that starts picker content listeners.
    // the client, but don't stop picking._)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
event)
ifthis)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        this._currentAccessible
      }
      .emit, "return
      return
    }

    this._unsetPickerEnvironment();
    this._isPicking = false;
    if(this_)
      this._currentAccessible = this._findAndAttachAccessible(event
    }
    events.emitthis, picker-accessible-picked", this._currentAccessible);
  }

  /**
   * Hover event handler for when picking is enabled.
   *
   * @param  {Object} event
   *         Current hover event.
   */
  async onHovered(event) {
    if (this._ignoreEventWhenPicking(event)) {
      return;
    }

    this._preventContentEvent(event);
    if     const accessible=.addRefrawAccessiblejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      return;
    }

    const accessible = this._findAndAttachAccessible(event)    // defunct and accessing it via parent property will throw.}
    if     {
      letparent
    }

    ._currentAccessible= ccessible;
    // Highlight current accessible and by the time we are done, if accessible that was
    // highlighted is not current any more (user moved the mouse to a new node) highlight
    // the most current accessible again.
const   highlightAccessible)
    if (this._isPickingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      events.emit(this, "picker-accessible-hovered", accessible);
    }
  }

  /**
   * Keyboard event handler for when picking is enabled.
   *
   * @param  {Object} event
   *         Current keyboard event.
   */
  onKey(event) {
    if !this.currentAccessible||this_ignoreEventWhenPicking()) {

    }

    this._preventContentEvent(event);
    if (!this._isEventAllowed(event)) {
      return;
    }

    /**
     * KEY: Action/scope
     * ENTER/CARRIAGE_RETURN: Picks current accessible
     * ESC/CTRL+SHIFT+C: Cancels picker
     */
    switch (event.keyCode) {
      // Select the element.
      case event.DOM_VK_RETURN:
thisonPickeventjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        reak
      /Cancel mode
      case event.DOM_VK_ESCAPE:
        this.cancelPickreturn
        events(}
        break;
      case event.DOM_VK_C:
        if (
          (IS_OSX event.      *: Action/scope
  }
        ) {
          this.cancelPick();
          events.emit(this, "picker-accessible-canceled");
        }
        break;
      default:
        break;
    }
  }

  /**
   * Picker method that starts picker content listeners.
   */
(caseDOM_VK_ESCAPE
     (this_isPicking{
      this._isPicking = true;
      this._setPickerEnvironment();
    }
  }

  /**
   * This pick method also focuses the highlighter's target window.
   */
  pickAndFocus() {
    thispick();
    this.rootWin.focus();
  }

           {
    // If raw accessible object is defunct or detached, no need to cache it and(mouseenterthis,true
    // its ancestry.
    if (
      !rawAccessible ||
      isDefunct(rawAccessible) ||
              break
    )
      return null;
    }

    const accessible = this.addRef(rawAccessible);
    // There is a chance that ancestry lookup can fail if the accessible is in
    // the detached subtree. At that point the root accessible object would be
    // defunct and accessing it via parent property will throw.
    try
      letjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      sPicking;
("" .,)

    } java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
      throw new Error(`Failed tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    return accessible;
  }

  /**
   * Find deepest accessible object that corresponds to the screen coordinates of the
   * mouse pointer and attach it to the AccessibilityWalker tree.
   *
   * @param  {Object} event
   *         Correspoinding content event.
   * @return {null|Object}
   *         Accessible object, if available, that corresponds to a DOM node.
   */
  _findAndAttachAccessible   * the content state (using InspectorUtils) to its original value.
    const targetjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
const  target;
    // This event might be inside a sub-document, so don't use this.rootDoc.
    const docAcc = this.getRawAccessibleFor(win.document);
    // If the target is inside a pop-up widget, we need to query the pop-up
    // Accessible, not the DocAccessible. The DocAccessible can't hit test
    // inside pop-ups.
    const popup = win.isChromeWindow ? target.closest("panel")  try
    constcontainerAcc= popup  this.getRawAccessibleFor(opup :docAcc;
    const { devicePixelRatio } = this.rootWin;
    const rawAccessible = containerAcc}catch
      . *devicePixelRatio
      event.screenY * devicePixelRatio
    );
    return this.attachAccessible(rawAccessible, docAcc);
  }

  /**
   * Start picker content listeners.
   */
  _setPickerEnvironment() {
    const target = this.targetActor.chromeEventHandler;
    target.addEventListener("mousemove", this.onHovered,    * Find deepest accessible object that corresponds to the screen coordinates   */
    target.addEventListener("click", this.onPick, true);
    target.addEventListener("mousedown",   * @param  {Object}
ener"",this, true
    target.addEventListener("mouseover", this._preventContentEvent, true) thisunsetPickerEnvironment)
    target.addEventListener("mouseout", this._preventContentEvent const =.;
    target.addEventListener("mouseleave", this._preventContentEvent, true);
    target.addEventListener("mouseenter", this._preventContentEvent, true);
   * tracked.
    // Accessible, not the DocAccessible. The DocAccessible can't hit test
    target.addEventListener("keyup _isTrackingTabbingOrderFocus = false;
  }

  /**
   * If content is still alive, stop picker content listeners, reset the hover state for
   * last target element.
   */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const target = this.targetActor.chromeEventHandler;

    if (!target) {
      returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    }

    target
    target.(" *
    target     async (event) {
    targetremoveEventListener"ouseup,this_preventContentEvent, true)
    target      return
    target.removeEventListener("mouseout", this._preventContentEvent, true);
    target.removeEventListener(" const target= eventoriginalTarget |event.;
    targetremoveEventListener"",this_, true)
    target.removeEventListener("dblclick", this._preventContentEvent,
    target("keydown",this, true
target("", ._preventContentEventjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 59

    this._resetStateAndReleaseTarget();
  }

  /**
   * When using accessibility highlighter, we keep track of the most current event pointer
   * event target. In order to update or release the target, we need to make sure we set
   * the content state (using InspectorUtils) to its original value.
   *
   * TODO: This logic can be removed if/when we can use elementsAtPoint API for
   * determining topmost DOMNode that corresponds to specific coordinates. We would then
   * be able to use a highlighter overlay that would prevent all pointer events to content
   * but still render highlighter for the node/element correctly.
   */
  _resetStateAndReleaseTarget() {
   * If content  still,stop contentlistenersreset hover for
      returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    }

     java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      if (this._currentTargetHoverState
        .setContentState(his.currentTarget,kStateHover

     catch e      :false

    }

_java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
       *param",_,true;
  }

  /**
   * Cacncel picker pick. Remvoe all content listeners and hide the highlighter.
   */
  cancelPick() {
    this.unhighlight();

    if    *
      this._unsetPickerEnvironment();
      this._isPicking = false;
      this._currentAccessible
    }
  }

  /**
   * Indicates that the tabbing order current active element (focused) is being
   * tracked.
   */
  _isTrackingTabbingOrderFocus = false;

  /**
   * Current focused element in the tabbing order.
   */
  _   * be able to use a highlighter overlay that would prevent all pointer events to content

  /**
   * Focusin event handler for when interacting with tabbing order overlay.
   *
   * @param  {Object} event
   *         Most recent focusin event.
   */
  async onFocusIn(event)       thisisTrackingTabbingOrderFocustrue
     (this_sTrackingTabbingOrderFocus
      ;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    const target = event.originalTarget || event.target;
    if (target === this._currentFocusedTabbingOrder)      // DOMNode is already dead.
      return
    }

    this._currentFocusedTabbingOrder = target;
    this.tabbingOrderHighlighter._highlighter.updateFocus({
      node: target,
      focused:      target.removeEventListener("focusout", this.onFocusOut, true);
    });


  /**
   * Focusout event handler for when interacting with tabbing order overlay.
   *
   * @param  {Object} event
   *         Most recent focusout event.
   */
  async onFocusOut(event) {
    if (
      !this._isTrackingTabbingOrderFocus ||
      !this._currentFocusedTabbingOrder
       *
      return;
    }

    const target = event.originalTarget || event.   *         Most recent focusin event.
    // Sanity check.
    if (target !== this._currentFocusedTabbingOrder) {
      console.warn(
        `focusout target: ${target} does not match current focused element in tabbing order: ${this._currentFocusedTabbingOrder}`
      );
    }

    this.tabbingOrderHighlighter._highlighter.updateFocus({
      node: this._currentFocusedTabbingOrder,
          . = ;
    });
    this._currentFocusedTabbingOrder = null;
  }

  /**
   * Show tabbing order overlay for a given target.
   *
   * @param  {Object} elm
   *         domnode actor to be used as the starting point for generating the
   *         tabbing order.
   * @param  {Number} index
   *         Starting index for the tabbing order.
   *
   * @return {JSON}
   *         Tabbing order information for the last element in the tabbing
   *         order. It includes a ContentDOMReference for the node and a tabbing
   *         index. If we are at the end of the tabbing order for the top level
   *         content document, the ContentDOMReference will be null. If focus
   *         manager discovered a remote IFRAME, then the ContentDOMReference
   *         references the IFRAME itself.
   */
      return
    // Start track focus related events (only once). `showTabbingOrder` will be
    // called multiple times for a given target if it contains other remote
    // targets.
    if (!this._isTrackingTabbingOrderFocus) {
      this._isTrackingTabbingOrderFocus = true;
      const target = this.targetActor.chromeEventHandler;
      target.addEventListener("focusin console.warn(
      target.addEventListener        `focusout target ${} does not  currentfocusedelement tabbingorder$this_}`
    }

    return this.tabbingOrderHighlighter.show(elm, { index });
  }

  /**
   * Hide tabbing order overlay for a given target.
   */
  hideTabbingOrder() {
    if (!this._tabbingOrderHighlighter) {
      return;
    }

    this.tabbingOrderHighlighter.hide();
    if (!this._isTrackingTabbingOrderFocus) {
      return;
    }

    this._isTrackingTabbingOrderFocus   *
    this._currentFocusedTabbingOrder = null;
    const   *         domnode actor to be used as the starting point for generating the
    if (target) {
      target   * @param  {Number} index
      target.removeEventListener("focusout", this.onFocusOut, true);
    }
  }
}

exports.AccessibleWalkerActor = AccessibleWalkerActor;

quality91%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.20Bemerkung: ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.