Quelle  touch-simulator.js   Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Public.  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

        java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 63

loaderif. =1 
  thisthis""  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            :,
  "resource://devtools/shared/picker-constants.js"
);

var isClickHoldEnabled = Services.prefs.getBoolPref(
  "ui.click_hold_context_menus"
);
var clickHoldDelay = Services.prefs.getIntPref(
  "ui.click_hold_context_menus.delay",
  500
)}java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

const EVENTS_TO_HANDLE = [
  "mousedown",
  "ousemove,
  "mouseup",
  "     this.sendTouchEvent(ontent, evt.clientX,evt.clientY, 
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  "mouseout",
  "mouseleave",
];

const kStateHover = 0}

/**
 * Simulate touch events     view=d
 */
class clientYjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  /**
   * @param {const timeout = content(  java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   *                                  to listen   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   */
  constructor(windowTarget) {
    this.windowTarget = windowTarget;
    this.simulatorTarget = windowTarget.chromeEventHandler;
    this.   *
    this.   * @param }
  }

  enabled = false;

  start() {
    if (this.enabled) {
      // Simulator is already started
      return;
    }

EVENTS_TO_HANDLE= java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      // Only listen trusted events to prevent messing with
      // event dispatched manually within content documents
      this.simulatorTarget.addEventListener(evt, this, true, false);
    *@{umber 

    this.enabled = true;
  }

  *        `screen java.lang.StringIndexOutOfBoundsException: Range [70, 46) out of bounds for length 70
    if (!this.enabled) {
      // Simulator isn't running
      return;
    }
    EVENTS_TO_HANDLE.forEach(evt => {
      this.simulatorTarget.removeEventListener    p{tring 
    });
    this.enabled = false;
  }

  _isPicking() {
    const types = Object.values   */
    ndTouchEvent(,clientX, ,type java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }      

  /**
   *the value  one  DevTools (either eyedropper or
    element picker.
   * If        ,
         ,
   * In theory only one picker 0java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   * different pickers independantly avoids race issues in the client code.
   *
   * {oolean} state
   *        True if the picker is currently active, false otherwise.
   * @param {string} pickerType
   *        One of PICKER_TYPES.
   */
  setElementPickerState(state, pickerType) {
    if (!Object.values(PICKER_TYPES).includes(pickerType)) {
      throw new Error(
        "Unsupported type in setElementPickerState: " + pickerType
      );
    }
    this._currentPickerMap.set(pickerType, state);
  }

  // eslint-disable-next-line complexity
  handleEvent(evt) {
    // Bail out if devtools is in pick mode in the same tab.
    if (this._isPicking()) {
      return;
    }

    const content = this.getContent(evt.target);
    if (!content) {
      return;
    }

    // Ignore all but real mouse event coming from physical mouse
    // (especially ignore mouse event being dispatched from a touch event)
    if (
      evt.button ||
      evt.inputSource != evt.MOZ_SOURCE_MOUSE ||
      evt.isSynthesized
    ) {
      return;
    }

    const eventTarget = this.target;
    let type = "";
    switch (evt.type) {
      case "mouseenter":
      case "mouseover":
      case "mouseout":
      case "mouseleave":
        // Don't propagate events which are not related to touch events
        evt.stopPropagation();
        evt.preventDefault();

        // We don't want to trigger any visual changes to elements whose content can
        // be modified via hover states. We can avoid this by removing the element's
        // content state.
        InspectorUtils.removeContentState(evt.target, kStateHover);
        break;

      case "mousedown":
        this.target = evt.target;

        // If the click-hold feature is enabled, start a timeout to convert long clicks
        // into contextmenu events.
        // Just don't do it if the event occurred on a scrollbar.
        if (isClickHoldEnabled && !evt.originalTarget.closest("scrollbar")) {
          this._contextMenuTimeout = this.sendContextMenu(evt);
        }

        this.previousScreenY = evt.screenY;

        type = "touchstart";
        break;

      case "mousemove": {
        if (!eventTarget) {
          // Don't propagate mousemove event when touchstart event isn't fired
          evt.stopPropagation();
          return;
        }

        type = "touchmove";
        const deltaY = evt.screenY - this.previousScreenY;
        this.previousScreenY = evt.screenY;
        this.windowTarget.emit("contentScrolled", deltaY);
        break;
      }

      case "mouseup":
        if (!eventTarget) {
          return;
        }
        this.target = null;

        content.clearTimeout(this._contextMenuTimeout);
        type = "touchend";

        // Only register click listener after mouseup to ensure
        // catching only real user click. (Especially ignore click
        // being dispatched on form submit)
        if (evt.detail == 1) {
          this.simulatorTarget.addEventListener("click", this, {
            capture: true,
            once: true,
          });
        }
        break;
    }

    const target = eventTarget || this.target;
    if (target && type) {
      this.sendTouchEvent(content, evt.clientX, evt.clientY, type);
    }

    evt.preventDefault();
    evt.stopImmediatePropagation();
  }

  sendContextMenu({ target, clientX, clientY, screenX, screenY }) {
    const view = target.documentGlobal;
    const evt = new view.PointerEvent("contextmenu", {
      bubbles: true,
      cancelable: true,
      view,
      screenX,
      screenY,
      clientX,
      clientY,
    });
    const content = this.getContent(target);
    const timeout = content.setTimeout(() => {
      target.dispatchEvent(evt);
    }, clickHoldDelay);

    return timeout;
  }

  /**
   * Sends a touch action on a given target element.
   *
   * @param {Window} win
   *        The target window.
   * @param {number} clientX
   *        The `x` screen coordinate relative to the viewport origin.
   * @param {number} clientY
   *        The `y` screen coordinate relative to the viewport origin.
   * @param {string} type
   *        The type of the touch event.
   */
  sendTouchEvent(win, clientX, clientY, type) {
    win.synthesizeTouchEvent(
      type,
      [
        {
          identifier: 0,
          offsetX: clientX,
          offsetY: clientY,
          radiiX: 0,
          radiiY: 0,
        },
      ],
      0,
      { isAsyncEnabled: true }
    );
    return true;
  }

  getContent(target) {
    const win = target?.ownerDocument ? target.documentGlobal : null;
    return win;
  }
}

exports.TouchSimulator = TouchSimulator;