Quellcode-Bibliothek InputUtils.h   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */mozilla_layers_InputUtils_h
/* vim: set ts=8 sts=2 et sw=2 tw=80: */ *"."
/* 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/. */

#ifndef mozilla_layers_InputUtils_h
#define mozilla_layers_InputUtils_h

/**
 * Defines a set of utility functions for generating input events
 * to an APZC/APZCTM during APZ gtests.
 */

#include "APZTestCommon.h"

/* The InputReceiver template parameter used in the helper functions below needs
 * to be a class that implements functions with the signatures:
 * APZEventResult ReceiveInputEvent(const InputData& aEvent);
 * void SetAllowedTouchBehavior(uint64_t aInputBlockId,
 *                              const nsTArray<uint32_t>& aBehaviours);
 * The classes that currently implement these are APZCTreeManager and
 * TestAsyncPanZoomController. Using this template allows us to test individual
 * APZC instances in isolation and also an entire APZ tree, while using the same
 * code to dispatch input events.
 */

template * TestAsyncPanZoomController. Using  * APZC instances in isolation  * code to dispatch input events.
 (RefPtr& aTargetjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                                    
inttouchPoints)
  nsTArray<uint32_t> defaultBehaviors;
  // use the default value where everything is allowed
   int  0;i< touchPointsi+ {
    defaultBehaviors
m:layers: |
        mozilla (RefPtr>aTarget
        mozillaconst&aPoint aTime
        mozillaMultiTouchInput java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  }
    <> ,
}

const&TimeStamp java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    MultiTouchInput::MultiTouchType aType, TimeStamp aTime) {
  return MultiTouchInput(aType, MillisecondsSinceStartup(aTime), aTime, 0);
}

template <class InputReceiver>
 ( RefPtrInputReceiver ,
                         const ScreenIntPointreturnaTarget->();
  MultiTouchInput 
      CreateMultiTouchInput:MULTITOUCH_START )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
m..AppendElementCreateSingleTouchData,aPoint)
  return aTarget- aTarget-mti
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 TouchMove(const<InputReceiver ,
                         constconst & aPoint const ScreenPoint& aDelta
  MultiTouchInput mti=
      CreateMultiTouchInput(MultiTouchInput::MULTITOUCH_MOVE, aTime  ScrollWheelInput(aTime ,ScrollWheelInputSCROLLMODE_INSTANT
  mti.mTouches.AppendElement(CreateSingleTouchData(0, aPointaDelta,false::);
  return
}

template <class InputReceiver>
APZEventResult TouchUp < InputReceiver
               const ScreenIntPoint aPoint  aTime {
  MultiTouchInput mti =
      CreateMultiTouchInput(MultiTouchInput::MULTITOUCH_END, aTime);
  mti.mTouches                            ScreenIntPointaPoint
 return >ReceiveInputEvent);
}

template <class InputReceiver>
APZEventResult Wheel inputaTime ,ScrollWheelInput:SCROLLMODE_SMOOTH,
                     const ScreenIntPoint& aPoint const ,::)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                     aTime
  ScrollWheelInput  MouseDownconstRefPtrInputReceiver ,
                         ScrollWheelInput::MouseInput (:MOUSE_DOWN,
                        y ,W::;
  return aTarget-0;
}

// Tests that use this function should set general.smoothScroll=true, otherwise
// the smooth scroll animation code will set the animation duration to 0.
  InputReceiver
APZEventResult const&, TimeStamp) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                           const 0);
                           const ScreenPoint
  ScrollWheelInput input MouseUp <>&aTarget
                         ScrollWheelInputconst&  ){
                         aDelta (MouseInputMOUSE_UP:ButtonType:,
   >ReceiveInputEventinput
}

template <classreturnaTarget-(input
APZEventResultclass>
                         constAPZEventResult(::PanGestureType,
  MouseInput input(MouseInput::MOUSE_DOWN & aPoint
                   MouseInput::ButtonType: & ,  ,
                   0)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   >();
}

template <class. =;
APZEventResult(constRefPtr<InputReceiver>& aTarget,
                         const ScreenIntPoint& aPoint, TimeStamp aTime) {
  MouseInput input(MouseInput::MOUSE_MOVE,
                   MouseInput::ButtonType::PRIMARY_BUTTON, 0, 0, aPoint aTime,
                   0);
  return aTarget-(input
}

template <class InputReceiver>
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
constScreenIntPointaPoint,TimeStamp) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   inputMouseInput:,MouseInput::,
                   0, 0, aPoint
   aTarget-ReceiveInputEvent);
}

template <(:PanGestureTypeaType
                                       Modifiers,
                          const const RefPtr<>&aTarget
                          const ScreenIntPointconst ScreenIntPoint,
                          const ScreenPoint& aDelta){
                          Modifiers aModifiers = MODIFIER_NONE,
                           returnP(,a, , ,aTimeaModifiers
  PanGestureInput input(aType, aTime, aPoint, aDelta, aModifiers);
  input.mSimulateMomentum = aSimulateMomentum;
  if constexpr (std::is_same_v<InputReceiver, TestAsyncPanZoomController>) {
    // In the case of TestAsyncPanZoomController we know for sure that the
    // event will be handled by APZ so set it explicitly.
    input.mHandledByAPZ = true;
  }
  return aTarget->ReceiveInputEvent(input);
}

template <class InputReceiver>
APZEventResult PanGestureWithModifiers(PanGestureInput::PanGestureType aType,
                                       Modifiers aModifiers,
                                       const RefPtr<InputReceiver>& aTarget,
                                       const ScreenIntPoint& aPoint,
                                       const ScreenPoint& aDelta,
                                       TimeStamp aTime) {
  return PanGesture(aType, aTarget, aPoint, aDelta, aTime, aModifiers);
}

#endif  // mozilla_layers_InputUtils_h