{-# LANGUAGE OverloadedStrings, RecordWildCards, TupleSections #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeFamilies #-}


{- |
= Input

-}


module CDP.Domains.Input (module CDP.Domains.Input) where

import           Control.Applicative  ((<$>))
import           Control.Monad
import           Control.Monad.Loops
import           Control.Monad.Trans  (liftIO)
import qualified Data.Map             as M
import           Data.Maybe          
import Data.Functor.Identity
import Data.String
import qualified Data.Text as T
import qualified Data.List as List
import qualified Data.Text.IO         as TI
import qualified Data.Vector          as V
import Data.Aeson.Types (Parser(..))
import           Data.Aeson           (FromJSON (..), ToJSON (..), (.:), (.:?), (.=), (.!=), (.:!))
import qualified Data.Aeson           as A
import qualified Network.HTTP.Simple as Http
import qualified Network.URI          as Uri
import qualified Network.WebSockets as WS
import Control.Concurrent
import qualified Data.ByteString.Lazy as BS
import qualified Data.Map as Map
import Data.Proxy
import System.Random
import GHC.Generics
import Data.Char
import Data.Default

import CDP.Internal.Utils




-- | Type 'Input.TouchPoint'.
data InputTouchPoint = InputTouchPoint
  {
    -- | X coordinate of the event relative to the main frame's viewport in CSS pixels.
    InputTouchPoint -> Double
inputTouchPointX :: Double,
    -- | Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
    --   the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    InputTouchPoint -> Double
inputTouchPointY :: Double,
    -- | X radius of the touch area (default: 1.0).
    InputTouchPoint -> Maybe Double
inputTouchPointRadiusX :: Maybe Double,
    -- | Y radius of the touch area (default: 1.0).
    InputTouchPoint -> Maybe Double
inputTouchPointRadiusY :: Maybe Double,
    -- | Rotation angle (default: 0.0).
    InputTouchPoint -> Maybe Double
inputTouchPointRotationAngle :: Maybe Double,
    -- | Force (default: 1.0).
    InputTouchPoint -> Maybe Double
inputTouchPointForce :: Maybe Double,
    -- | The normalized tangential pressure, which has a range of [-1,1] (default: 0).
    InputTouchPoint -> Maybe Double
inputTouchPointTangentialPressure :: Maybe Double,
    -- | The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)
    InputTouchPoint -> Maybe Int
inputTouchPointTiltX :: Maybe Int,
    -- | The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
    InputTouchPoint -> Maybe Int
inputTouchPointTiltY :: Maybe Int,
    -- | The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
    InputTouchPoint -> Maybe Int
inputTouchPointTwist :: Maybe Int,
    -- | Identifier used to track touch sources between events, must be unique within an event.
    InputTouchPoint -> Maybe Double
inputTouchPointId :: Maybe Double
  }
  deriving (InputTouchPoint -> InputTouchPoint -> Bool
(InputTouchPoint -> InputTouchPoint -> Bool)
-> (InputTouchPoint -> InputTouchPoint -> Bool)
-> Eq InputTouchPoint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputTouchPoint -> InputTouchPoint -> Bool
$c/= :: InputTouchPoint -> InputTouchPoint -> Bool
== :: InputTouchPoint -> InputTouchPoint -> Bool
$c== :: InputTouchPoint -> InputTouchPoint -> Bool
Eq, Int -> InputTouchPoint -> ShowS
[InputTouchPoint] -> ShowS
InputTouchPoint -> String
(Int -> InputTouchPoint -> ShowS)
-> (InputTouchPoint -> String)
-> ([InputTouchPoint] -> ShowS)
-> Show InputTouchPoint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputTouchPoint] -> ShowS
$cshowList :: [InputTouchPoint] -> ShowS
show :: InputTouchPoint -> String
$cshow :: InputTouchPoint -> String
showsPrec :: Int -> InputTouchPoint -> ShowS
$cshowsPrec :: Int -> InputTouchPoint -> ShowS
Show)
instance FromJSON InputTouchPoint where
  parseJSON :: Value -> Parser InputTouchPoint
parseJSON = String
-> (Object -> Parser InputTouchPoint)
-> Value
-> Parser InputTouchPoint
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"InputTouchPoint" ((Object -> Parser InputTouchPoint)
 -> Value -> Parser InputTouchPoint)
-> (Object -> Parser InputTouchPoint)
-> Value
-> Parser InputTouchPoint
forall a b. (a -> b) -> a -> b
$ \Object
o -> Double
-> Double
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Double
-> InputTouchPoint
InputTouchPoint
    (Double
 -> Double
 -> Maybe Double
 -> Maybe Double
 -> Maybe Double
 -> Maybe Double
 -> Maybe Double
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Double
 -> InputTouchPoint)
-> Parser Double
-> Parser
     (Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Double
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"x"
    Parser
  (Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser Double
-> Parser
     (Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Double
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"y"
    Parser
  (Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser (Maybe Double)
-> Parser
     (Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"radiusX"
    Parser
  (Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser (Maybe Double)
-> Parser
     (Maybe Double
      -> Maybe Double
      -> Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"radiusY"
    Parser
  (Maybe Double
   -> Maybe Double
   -> Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser (Maybe Double)
-> Parser
     (Maybe Double
      -> Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"rotationAngle"
    Parser
  (Maybe Double
   -> Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser (Maybe Double)
-> Parser
     (Maybe Double
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Double
      -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"force"
    Parser
  (Maybe Double
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Double
   -> InputTouchPoint)
-> Parser (Maybe Double)
-> Parser
     (Maybe Int
      -> Maybe Int -> Maybe Int -> Maybe Double -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"tangentialPressure"
    Parser
  (Maybe Int
   -> Maybe Int -> Maybe Int -> Maybe Double -> InputTouchPoint)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int -> Maybe Int -> Maybe Double -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"tiltX"
    Parser (Maybe Int -> Maybe Int -> Maybe Double -> InputTouchPoint)
-> Parser (Maybe Int)
-> Parser (Maybe Int -> Maybe Double -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"tiltY"
    Parser (Maybe Int -> Maybe Double -> InputTouchPoint)
-> Parser (Maybe Int) -> Parser (Maybe Double -> InputTouchPoint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"twist"
    Parser (Maybe Double -> InputTouchPoint)
-> Parser (Maybe Double) -> Parser InputTouchPoint
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"id"
instance ToJSON InputTouchPoint where
  toJSON :: InputTouchPoint -> Value
toJSON InputTouchPoint
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (InputTouchPoint -> Double
inputTouchPointX InputTouchPoint
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (InputTouchPoint -> Double
inputTouchPointY InputTouchPoint
p),
    (Text
"radiusX" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointRadiusX InputTouchPoint
p),
    (Text
"radiusY" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointRadiusY InputTouchPoint
p),
    (Text
"rotationAngle" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointRotationAngle InputTouchPoint
p),
    (Text
"force" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointForce InputTouchPoint
p),
    (Text
"tangentialPressure" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointTangentialPressure InputTouchPoint
p),
    (Text
"tiltX" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Int
inputTouchPointTiltX InputTouchPoint
p),
    (Text
"tiltY" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Int
inputTouchPointTiltY InputTouchPoint
p),
    (Text
"twist" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Int
inputTouchPointTwist InputTouchPoint
p),
    (Text
"id" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputTouchPoint -> Maybe Double
inputTouchPointId InputTouchPoint
p)
    ]

-- | Type 'Input.GestureSourceType'.
data InputGestureSourceType = InputGestureSourceTypeDefault | InputGestureSourceTypeTouch | InputGestureSourceTypeMouse
  deriving (Eq InputGestureSourceType
Eq InputGestureSourceType
-> (InputGestureSourceType -> InputGestureSourceType -> Ordering)
-> (InputGestureSourceType -> InputGestureSourceType -> Bool)
-> (InputGestureSourceType -> InputGestureSourceType -> Bool)
-> (InputGestureSourceType -> InputGestureSourceType -> Bool)
-> (InputGestureSourceType -> InputGestureSourceType -> Bool)
-> (InputGestureSourceType
    -> InputGestureSourceType -> InputGestureSourceType)
-> (InputGestureSourceType
    -> InputGestureSourceType -> InputGestureSourceType)
-> Ord InputGestureSourceType
InputGestureSourceType -> InputGestureSourceType -> Bool
InputGestureSourceType -> InputGestureSourceType -> Ordering
InputGestureSourceType
-> InputGestureSourceType -> InputGestureSourceType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: InputGestureSourceType
-> InputGestureSourceType -> InputGestureSourceType
$cmin :: InputGestureSourceType
-> InputGestureSourceType -> InputGestureSourceType
max :: InputGestureSourceType
-> InputGestureSourceType -> InputGestureSourceType
$cmax :: InputGestureSourceType
-> InputGestureSourceType -> InputGestureSourceType
>= :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c>= :: InputGestureSourceType -> InputGestureSourceType -> Bool
> :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c> :: InputGestureSourceType -> InputGestureSourceType -> Bool
<= :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c<= :: InputGestureSourceType -> InputGestureSourceType -> Bool
< :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c< :: InputGestureSourceType -> InputGestureSourceType -> Bool
compare :: InputGestureSourceType -> InputGestureSourceType -> Ordering
$ccompare :: InputGestureSourceType -> InputGestureSourceType -> Ordering
$cp1Ord :: Eq InputGestureSourceType
Ord, InputGestureSourceType -> InputGestureSourceType -> Bool
(InputGestureSourceType -> InputGestureSourceType -> Bool)
-> (InputGestureSourceType -> InputGestureSourceType -> Bool)
-> Eq InputGestureSourceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c/= :: InputGestureSourceType -> InputGestureSourceType -> Bool
== :: InputGestureSourceType -> InputGestureSourceType -> Bool
$c== :: InputGestureSourceType -> InputGestureSourceType -> Bool
Eq, Int -> InputGestureSourceType -> ShowS
[InputGestureSourceType] -> ShowS
InputGestureSourceType -> String
(Int -> InputGestureSourceType -> ShowS)
-> (InputGestureSourceType -> String)
-> ([InputGestureSourceType] -> ShowS)
-> Show InputGestureSourceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputGestureSourceType] -> ShowS
$cshowList :: [InputGestureSourceType] -> ShowS
show :: InputGestureSourceType -> String
$cshow :: InputGestureSourceType -> String
showsPrec :: Int -> InputGestureSourceType -> ShowS
$cshowsPrec :: Int -> InputGestureSourceType -> ShowS
Show, ReadPrec [InputGestureSourceType]
ReadPrec InputGestureSourceType
Int -> ReadS InputGestureSourceType
ReadS [InputGestureSourceType]
(Int -> ReadS InputGestureSourceType)
-> ReadS [InputGestureSourceType]
-> ReadPrec InputGestureSourceType
-> ReadPrec [InputGestureSourceType]
-> Read InputGestureSourceType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InputGestureSourceType]
$creadListPrec :: ReadPrec [InputGestureSourceType]
readPrec :: ReadPrec InputGestureSourceType
$creadPrec :: ReadPrec InputGestureSourceType
readList :: ReadS [InputGestureSourceType]
$creadList :: ReadS [InputGestureSourceType]
readsPrec :: Int -> ReadS InputGestureSourceType
$creadsPrec :: Int -> ReadS InputGestureSourceType
Read)
instance FromJSON InputGestureSourceType where
  parseJSON :: Value -> Parser InputGestureSourceType
parseJSON = String
-> (Text -> Parser InputGestureSourceType)
-> Value
-> Parser InputGestureSourceType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"InputGestureSourceType" ((Text -> Parser InputGestureSourceType)
 -> Value -> Parser InputGestureSourceType)
-> (Text -> Parser InputGestureSourceType)
-> Value
-> Parser InputGestureSourceType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"default" -> InputGestureSourceType -> Parser InputGestureSourceType
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputGestureSourceType
InputGestureSourceTypeDefault
    Text
"touch" -> InputGestureSourceType -> Parser InputGestureSourceType
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputGestureSourceType
InputGestureSourceTypeTouch
    Text
"mouse" -> InputGestureSourceType -> Parser InputGestureSourceType
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputGestureSourceType
InputGestureSourceTypeMouse
    Text
"_" -> String -> Parser InputGestureSourceType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse InputGestureSourceType"
instance ToJSON InputGestureSourceType where
  toJSON :: InputGestureSourceType -> Value
toJSON InputGestureSourceType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case InputGestureSourceType
v of
    InputGestureSourceType
InputGestureSourceTypeDefault -> Text
"default"
    InputGestureSourceType
InputGestureSourceTypeTouch -> Text
"touch"
    InputGestureSourceType
InputGestureSourceTypeMouse -> Text
"mouse"

-- | Type 'Input.MouseButton'.
data InputMouseButton = InputMouseButtonNone | InputMouseButtonLeft | InputMouseButtonMiddle | InputMouseButtonRight | InputMouseButtonBack | InputMouseButtonForward
  deriving (Eq InputMouseButton
Eq InputMouseButton
-> (InputMouseButton -> InputMouseButton -> Ordering)
-> (InputMouseButton -> InputMouseButton -> Bool)
-> (InputMouseButton -> InputMouseButton -> Bool)
-> (InputMouseButton -> InputMouseButton -> Bool)
-> (InputMouseButton -> InputMouseButton -> Bool)
-> (InputMouseButton -> InputMouseButton -> InputMouseButton)
-> (InputMouseButton -> InputMouseButton -> InputMouseButton)
-> Ord InputMouseButton
InputMouseButton -> InputMouseButton -> Bool
InputMouseButton -> InputMouseButton -> Ordering
InputMouseButton -> InputMouseButton -> InputMouseButton
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: InputMouseButton -> InputMouseButton -> InputMouseButton
$cmin :: InputMouseButton -> InputMouseButton -> InputMouseButton
max :: InputMouseButton -> InputMouseButton -> InputMouseButton
$cmax :: InputMouseButton -> InputMouseButton -> InputMouseButton
>= :: InputMouseButton -> InputMouseButton -> Bool
$c>= :: InputMouseButton -> InputMouseButton -> Bool
> :: InputMouseButton -> InputMouseButton -> Bool
$c> :: InputMouseButton -> InputMouseButton -> Bool
<= :: InputMouseButton -> InputMouseButton -> Bool
$c<= :: InputMouseButton -> InputMouseButton -> Bool
< :: InputMouseButton -> InputMouseButton -> Bool
$c< :: InputMouseButton -> InputMouseButton -> Bool
compare :: InputMouseButton -> InputMouseButton -> Ordering
$ccompare :: InputMouseButton -> InputMouseButton -> Ordering
$cp1Ord :: Eq InputMouseButton
Ord, InputMouseButton -> InputMouseButton -> Bool
(InputMouseButton -> InputMouseButton -> Bool)
-> (InputMouseButton -> InputMouseButton -> Bool)
-> Eq InputMouseButton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputMouseButton -> InputMouseButton -> Bool
$c/= :: InputMouseButton -> InputMouseButton -> Bool
== :: InputMouseButton -> InputMouseButton -> Bool
$c== :: InputMouseButton -> InputMouseButton -> Bool
Eq, Int -> InputMouseButton -> ShowS
[InputMouseButton] -> ShowS
InputMouseButton -> String
(Int -> InputMouseButton -> ShowS)
-> (InputMouseButton -> String)
-> ([InputMouseButton] -> ShowS)
-> Show InputMouseButton
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputMouseButton] -> ShowS
$cshowList :: [InputMouseButton] -> ShowS
show :: InputMouseButton -> String
$cshow :: InputMouseButton -> String
showsPrec :: Int -> InputMouseButton -> ShowS
$cshowsPrec :: Int -> InputMouseButton -> ShowS
Show, ReadPrec [InputMouseButton]
ReadPrec InputMouseButton
Int -> ReadS InputMouseButton
ReadS [InputMouseButton]
(Int -> ReadS InputMouseButton)
-> ReadS [InputMouseButton]
-> ReadPrec InputMouseButton
-> ReadPrec [InputMouseButton]
-> Read InputMouseButton
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InputMouseButton]
$creadListPrec :: ReadPrec [InputMouseButton]
readPrec :: ReadPrec InputMouseButton
$creadPrec :: ReadPrec InputMouseButton
readList :: ReadS [InputMouseButton]
$creadList :: ReadS [InputMouseButton]
readsPrec :: Int -> ReadS InputMouseButton
$creadsPrec :: Int -> ReadS InputMouseButton
Read)
instance FromJSON InputMouseButton where
  parseJSON :: Value -> Parser InputMouseButton
parseJSON = String
-> (Text -> Parser InputMouseButton)
-> Value
-> Parser InputMouseButton
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"InputMouseButton" ((Text -> Parser InputMouseButton)
 -> Value -> Parser InputMouseButton)
-> (Text -> Parser InputMouseButton)
-> Value
-> Parser InputMouseButton
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"none" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonNone
    Text
"left" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonLeft
    Text
"middle" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonMiddle
    Text
"right" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonRight
    Text
"back" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonBack
    Text
"forward" -> InputMouseButton -> Parser InputMouseButton
forall (f :: * -> *) a. Applicative f => a -> f a
pure InputMouseButton
InputMouseButtonForward
    Text
"_" -> String -> Parser InputMouseButton
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse InputMouseButton"
instance ToJSON InputMouseButton where
  toJSON :: InputMouseButton -> Value
toJSON InputMouseButton
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case InputMouseButton
v of
    InputMouseButton
InputMouseButtonNone -> Text
"none"
    InputMouseButton
InputMouseButtonLeft -> Text
"left"
    InputMouseButton
InputMouseButtonMiddle -> Text
"middle"
    InputMouseButton
InputMouseButtonRight -> Text
"right"
    InputMouseButton
InputMouseButtonBack -> Text
"back"
    InputMouseButton
InputMouseButtonForward -> Text
"forward"

-- | Type 'Input.TimeSinceEpoch'.
--   UTC time in seconds, counted from January 1, 1970.
type InputTimeSinceEpoch = Double

-- | Type 'Input.DragDataItem'.
data InputDragDataItem = InputDragDataItem
  {
    -- | Mime type of the dragged data.
    InputDragDataItem -> Text
inputDragDataItemMimeType :: T.Text,
    -- | Depending of the value of `mimeType`, it contains the dragged link,
    --   text, HTML markup or any other data.
    InputDragDataItem -> Text
inputDragDataItemData :: T.Text,
    -- | Title associated with a link. Only valid when `mimeType` == "text/uri-list".
    InputDragDataItem -> Maybe Text
inputDragDataItemTitle :: Maybe T.Text,
    -- | Stores the base URL for the contained markup. Only valid when `mimeType`
    --   == "text/html".
    InputDragDataItem -> Maybe Text
inputDragDataItemBaseURL :: Maybe T.Text
  }
  deriving (InputDragDataItem -> InputDragDataItem -> Bool
(InputDragDataItem -> InputDragDataItem -> Bool)
-> (InputDragDataItem -> InputDragDataItem -> Bool)
-> Eq InputDragDataItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputDragDataItem -> InputDragDataItem -> Bool
$c/= :: InputDragDataItem -> InputDragDataItem -> Bool
== :: InputDragDataItem -> InputDragDataItem -> Bool
$c== :: InputDragDataItem -> InputDragDataItem -> Bool
Eq, Int -> InputDragDataItem -> ShowS
[InputDragDataItem] -> ShowS
InputDragDataItem -> String
(Int -> InputDragDataItem -> ShowS)
-> (InputDragDataItem -> String)
-> ([InputDragDataItem] -> ShowS)
-> Show InputDragDataItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputDragDataItem] -> ShowS
$cshowList :: [InputDragDataItem] -> ShowS
show :: InputDragDataItem -> String
$cshow :: InputDragDataItem -> String
showsPrec :: Int -> InputDragDataItem -> ShowS
$cshowsPrec :: Int -> InputDragDataItem -> ShowS
Show)
instance FromJSON InputDragDataItem where
  parseJSON :: Value -> Parser InputDragDataItem
parseJSON = String
-> (Object -> Parser InputDragDataItem)
-> Value
-> Parser InputDragDataItem
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"InputDragDataItem" ((Object -> Parser InputDragDataItem)
 -> Value -> Parser InputDragDataItem)
-> (Object -> Parser InputDragDataItem)
-> Value
-> Parser InputDragDataItem
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> Maybe Text -> Maybe Text -> InputDragDataItem
InputDragDataItem
    (Text -> Text -> Maybe Text -> Maybe Text -> InputDragDataItem)
-> Parser Text
-> Parser (Text -> Maybe Text -> Maybe Text -> InputDragDataItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"mimeType"
    Parser (Text -> Maybe Text -> Maybe Text -> InputDragDataItem)
-> Parser Text
-> Parser (Maybe Text -> Maybe Text -> InputDragDataItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"data"
    Parser (Maybe Text -> Maybe Text -> InputDragDataItem)
-> Parser (Maybe Text) -> Parser (Maybe Text -> InputDragDataItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"title"
    Parser (Maybe Text -> InputDragDataItem)
-> Parser (Maybe Text) -> Parser InputDragDataItem
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"baseURL"
instance ToJSON InputDragDataItem where
  toJSON :: InputDragDataItem -> Value
toJSON InputDragDataItem
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"mimeType" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (InputDragDataItem -> Text
inputDragDataItemMimeType InputDragDataItem
p),
    (Text
"data" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (InputDragDataItem -> Text
inputDragDataItemData InputDragDataItem
p),
    (Text
"title" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputDragDataItem -> Maybe Text
inputDragDataItemTitle InputDragDataItem
p),
    (Text
"baseURL" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputDragDataItem -> Maybe Text
inputDragDataItemBaseURL InputDragDataItem
p)
    ]

-- | Type 'Input.DragData'.
data InputDragData = InputDragData
  {
    InputDragData -> [InputDragDataItem]
inputDragDataItems :: [InputDragDataItem],
    -- | List of filenames that should be included when dropping
    InputDragData -> Maybe [Text]
inputDragDataFiles :: Maybe [T.Text],
    -- | Bit field representing allowed drag operations. Copy = 1, Link = 2, Move = 16
    InputDragData -> Int
inputDragDataDragOperationsMask :: Int
  }
  deriving (InputDragData -> InputDragData -> Bool
(InputDragData -> InputDragData -> Bool)
-> (InputDragData -> InputDragData -> Bool) -> Eq InputDragData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputDragData -> InputDragData -> Bool
$c/= :: InputDragData -> InputDragData -> Bool
== :: InputDragData -> InputDragData -> Bool
$c== :: InputDragData -> InputDragData -> Bool
Eq, Int -> InputDragData -> ShowS
[InputDragData] -> ShowS
InputDragData -> String
(Int -> InputDragData -> ShowS)
-> (InputDragData -> String)
-> ([InputDragData] -> ShowS)
-> Show InputDragData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputDragData] -> ShowS
$cshowList :: [InputDragData] -> ShowS
show :: InputDragData -> String
$cshow :: InputDragData -> String
showsPrec :: Int -> InputDragData -> ShowS
$cshowsPrec :: Int -> InputDragData -> ShowS
Show)
instance FromJSON InputDragData where
  parseJSON :: Value -> Parser InputDragData
parseJSON = String
-> (Object -> Parser InputDragData)
-> Value
-> Parser InputDragData
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"InputDragData" ((Object -> Parser InputDragData) -> Value -> Parser InputDragData)
-> (Object -> Parser InputDragData)
-> Value
-> Parser InputDragData
forall a b. (a -> b) -> a -> b
$ \Object
o -> [InputDragDataItem] -> Maybe [Text] -> Int -> InputDragData
InputDragData
    ([InputDragDataItem] -> Maybe [Text] -> Int -> InputDragData)
-> Parser [InputDragDataItem]
-> Parser (Maybe [Text] -> Int -> InputDragData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser [InputDragDataItem]
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"items"
    Parser (Maybe [Text] -> Int -> InputDragData)
-> Parser (Maybe [Text]) -> Parser (Int -> InputDragData)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"files"
    Parser (Int -> InputDragData) -> Parser Int -> Parser InputDragData
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Int
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"dragOperationsMask"
instance ToJSON InputDragData where
  toJSON :: InputDragData -> Value
toJSON InputDragData
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"items" Text -> [InputDragDataItem] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) ([InputDragDataItem] -> Pair)
-> Maybe [InputDragDataItem] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [InputDragDataItem] -> Maybe [InputDragDataItem]
forall a. a -> Maybe a
Just (InputDragData -> [InputDragDataItem]
inputDragDataItems InputDragData
p),
    (Text
"files" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (InputDragData -> Maybe [Text]
inputDragDataFiles InputDragData
p),
    (Text
"dragOperationsMask" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (InputDragData -> Int
inputDragDataDragOperationsMask InputDragData
p)
    ]

-- | Type of the 'Input.dragIntercepted' event.
data InputDragIntercepted = InputDragIntercepted
  {
    InputDragIntercepted -> InputDragData
inputDragInterceptedData :: InputDragData
  }
  deriving (InputDragIntercepted -> InputDragIntercepted -> Bool
(InputDragIntercepted -> InputDragIntercepted -> Bool)
-> (InputDragIntercepted -> InputDragIntercepted -> Bool)
-> Eq InputDragIntercepted
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputDragIntercepted -> InputDragIntercepted -> Bool
$c/= :: InputDragIntercepted -> InputDragIntercepted -> Bool
== :: InputDragIntercepted -> InputDragIntercepted -> Bool
$c== :: InputDragIntercepted -> InputDragIntercepted -> Bool
Eq, Int -> InputDragIntercepted -> ShowS
[InputDragIntercepted] -> ShowS
InputDragIntercepted -> String
(Int -> InputDragIntercepted -> ShowS)
-> (InputDragIntercepted -> String)
-> ([InputDragIntercepted] -> ShowS)
-> Show InputDragIntercepted
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputDragIntercepted] -> ShowS
$cshowList :: [InputDragIntercepted] -> ShowS
show :: InputDragIntercepted -> String
$cshow :: InputDragIntercepted -> String
showsPrec :: Int -> InputDragIntercepted -> ShowS
$cshowsPrec :: Int -> InputDragIntercepted -> ShowS
Show)
instance FromJSON InputDragIntercepted where
  parseJSON :: Value -> Parser InputDragIntercepted
parseJSON = String
-> (Object -> Parser InputDragIntercepted)
-> Value
-> Parser InputDragIntercepted
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"InputDragIntercepted" ((Object -> Parser InputDragIntercepted)
 -> Value -> Parser InputDragIntercepted)
-> (Object -> Parser InputDragIntercepted)
-> Value
-> Parser InputDragIntercepted
forall a b. (a -> b) -> a -> b
$ \Object
o -> InputDragData -> InputDragIntercepted
InputDragIntercepted
    (InputDragData -> InputDragIntercepted)
-> Parser InputDragData -> Parser InputDragIntercepted
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser InputDragData
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"data"
instance Event InputDragIntercepted where
  eventName :: Proxy InputDragIntercepted -> String
eventName Proxy InputDragIntercepted
_ = String
"Input.dragIntercepted"

-- | Dispatches a drag event into the page.

-- | Parameters of the 'Input.dispatchDragEvent' command.
data PInputDispatchDragEventType = PInputDispatchDragEventTypeDragEnter | PInputDispatchDragEventTypeDragOver | PInputDispatchDragEventTypeDrop | PInputDispatchDragEventTypeDragCancel
  deriving (Eq PInputDispatchDragEventType
Eq PInputDispatchDragEventType
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Ordering)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Bool)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Bool)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Bool)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Bool)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> PInputDispatchDragEventType)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> PInputDispatchDragEventType)
-> Ord PInputDispatchDragEventType
PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
PInputDispatchDragEventType
-> PInputDispatchDragEventType -> Ordering
PInputDispatchDragEventType
-> PInputDispatchDragEventType -> PInputDispatchDragEventType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> PInputDispatchDragEventType
$cmin :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> PInputDispatchDragEventType
max :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> PInputDispatchDragEventType
$cmax :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> PInputDispatchDragEventType
>= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c>= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
> :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c> :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
<= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c<= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
< :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c< :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
compare :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> Ordering
$ccompare :: PInputDispatchDragEventType
-> PInputDispatchDragEventType -> Ordering
$cp1Ord :: Eq PInputDispatchDragEventType
Ord, PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
(PInputDispatchDragEventType
 -> PInputDispatchDragEventType -> Bool)
-> (PInputDispatchDragEventType
    -> PInputDispatchDragEventType -> Bool)
-> Eq PInputDispatchDragEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c/= :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
== :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
$c== :: PInputDispatchDragEventType -> PInputDispatchDragEventType -> Bool
Eq, Int -> PInputDispatchDragEventType -> ShowS
[PInputDispatchDragEventType] -> ShowS
PInputDispatchDragEventType -> String
(Int -> PInputDispatchDragEventType -> ShowS)
-> (PInputDispatchDragEventType -> String)
-> ([PInputDispatchDragEventType] -> ShowS)
-> Show PInputDispatchDragEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchDragEventType] -> ShowS
$cshowList :: [PInputDispatchDragEventType] -> ShowS
show :: PInputDispatchDragEventType -> String
$cshow :: PInputDispatchDragEventType -> String
showsPrec :: Int -> PInputDispatchDragEventType -> ShowS
$cshowsPrec :: Int -> PInputDispatchDragEventType -> ShowS
Show, ReadPrec [PInputDispatchDragEventType]
ReadPrec PInputDispatchDragEventType
Int -> ReadS PInputDispatchDragEventType
ReadS [PInputDispatchDragEventType]
(Int -> ReadS PInputDispatchDragEventType)
-> ReadS [PInputDispatchDragEventType]
-> ReadPrec PInputDispatchDragEventType
-> ReadPrec [PInputDispatchDragEventType]
-> Read PInputDispatchDragEventType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputDispatchDragEventType]
$creadListPrec :: ReadPrec [PInputDispatchDragEventType]
readPrec :: ReadPrec PInputDispatchDragEventType
$creadPrec :: ReadPrec PInputDispatchDragEventType
readList :: ReadS [PInputDispatchDragEventType]
$creadList :: ReadS [PInputDispatchDragEventType]
readsPrec :: Int -> ReadS PInputDispatchDragEventType
$creadsPrec :: Int -> ReadS PInputDispatchDragEventType
Read)
instance FromJSON PInputDispatchDragEventType where
  parseJSON :: Value -> Parser PInputDispatchDragEventType
parseJSON = String
-> (Text -> Parser PInputDispatchDragEventType)
-> Value
-> Parser PInputDispatchDragEventType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputDispatchDragEventType" ((Text -> Parser PInputDispatchDragEventType)
 -> Value -> Parser PInputDispatchDragEventType)
-> (Text -> Parser PInputDispatchDragEventType)
-> Value
-> Parser PInputDispatchDragEventType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"dragEnter" -> PInputDispatchDragEventType -> Parser PInputDispatchDragEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchDragEventType
PInputDispatchDragEventTypeDragEnter
    Text
"dragOver" -> PInputDispatchDragEventType -> Parser PInputDispatchDragEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchDragEventType
PInputDispatchDragEventTypeDragOver
    Text
"drop" -> PInputDispatchDragEventType -> Parser PInputDispatchDragEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchDragEventType
PInputDispatchDragEventTypeDrop
    Text
"dragCancel" -> PInputDispatchDragEventType -> Parser PInputDispatchDragEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchDragEventType
PInputDispatchDragEventTypeDragCancel
    Text
"_" -> String -> Parser PInputDispatchDragEventType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputDispatchDragEventType"
instance ToJSON PInputDispatchDragEventType where
  toJSON :: PInputDispatchDragEventType -> Value
toJSON PInputDispatchDragEventType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputDispatchDragEventType
v of
    PInputDispatchDragEventType
PInputDispatchDragEventTypeDragEnter -> Text
"dragEnter"
    PInputDispatchDragEventType
PInputDispatchDragEventTypeDragOver -> Text
"dragOver"
    PInputDispatchDragEventType
PInputDispatchDragEventTypeDrop -> Text
"drop"
    PInputDispatchDragEventType
PInputDispatchDragEventTypeDragCancel -> Text
"dragCancel"
data PInputDispatchDragEvent = PInputDispatchDragEvent
  {
    -- | Type of the drag event.
    PInputDispatchDragEvent -> PInputDispatchDragEventType
pInputDispatchDragEventType :: PInputDispatchDragEventType,
    -- | X coordinate of the event relative to the main frame's viewport in CSS pixels.
    PInputDispatchDragEvent -> Double
pInputDispatchDragEventX :: Double,
    -- | Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
    --   the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    PInputDispatchDragEvent -> Double
pInputDispatchDragEventY :: Double,
    PInputDispatchDragEvent -> InputDragData
pInputDispatchDragEventData :: InputDragData,
    -- | Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
    --   (default: 0).
    PInputDispatchDragEvent -> Maybe Int
pInputDispatchDragEventModifiers :: Maybe Int
  }
  deriving (PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool
(PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool)
-> (PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool)
-> Eq PInputDispatchDragEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool
$c/= :: PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool
== :: PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool
$c== :: PInputDispatchDragEvent -> PInputDispatchDragEvent -> Bool
Eq, Int -> PInputDispatchDragEvent -> ShowS
[PInputDispatchDragEvent] -> ShowS
PInputDispatchDragEvent -> String
(Int -> PInputDispatchDragEvent -> ShowS)
-> (PInputDispatchDragEvent -> String)
-> ([PInputDispatchDragEvent] -> ShowS)
-> Show PInputDispatchDragEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchDragEvent] -> ShowS
$cshowList :: [PInputDispatchDragEvent] -> ShowS
show :: PInputDispatchDragEvent -> String
$cshow :: PInputDispatchDragEvent -> String
showsPrec :: Int -> PInputDispatchDragEvent -> ShowS
$cshowsPrec :: Int -> PInputDispatchDragEvent -> ShowS
Show)
pInputDispatchDragEvent
  {-
  -- | Type of the drag event.
  -}
  :: PInputDispatchDragEventType
  {-
  -- | X coordinate of the event relative to the main frame's viewport in CSS pixels.
  -}
  -> Double
  {-
  -- | Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
  --   the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
  -}
  -> Double
  -> InputDragData
  -> PInputDispatchDragEvent
pInputDispatchDragEvent :: PInputDispatchDragEventType
-> Double -> Double -> InputDragData -> PInputDispatchDragEvent
pInputDispatchDragEvent
  PInputDispatchDragEventType
arg_pInputDispatchDragEventType
  Double
arg_pInputDispatchDragEventX
  Double
arg_pInputDispatchDragEventY
  InputDragData
arg_pInputDispatchDragEventData
  = PInputDispatchDragEventType
-> Double
-> Double
-> InputDragData
-> Maybe Int
-> PInputDispatchDragEvent
PInputDispatchDragEvent
    PInputDispatchDragEventType
arg_pInputDispatchDragEventType
    Double
arg_pInputDispatchDragEventX
    Double
arg_pInputDispatchDragEventY
    InputDragData
arg_pInputDispatchDragEventData
    Maybe Int
forall a. Maybe a
Nothing
instance ToJSON PInputDispatchDragEvent where
  toJSON :: PInputDispatchDragEvent -> Value
toJSON PInputDispatchDragEvent
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"type" Text -> PInputDispatchDragEventType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputDispatchDragEventType -> Pair)
-> Maybe PInputDispatchDragEventType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PInputDispatchDragEventType -> Maybe PInputDispatchDragEventType
forall a. a -> Maybe a
Just (PInputDispatchDragEvent -> PInputDispatchDragEventType
pInputDispatchDragEventType PInputDispatchDragEvent
p),
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputDispatchDragEvent -> Double
pInputDispatchDragEventX PInputDispatchDragEvent
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputDispatchDragEvent -> Double
pInputDispatchDragEventY PInputDispatchDragEvent
p),
    (Text
"data" Text -> InputDragData -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputDragData -> Pair) -> Maybe InputDragData -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InputDragData -> Maybe InputDragData
forall a. a -> Maybe a
Just (PInputDispatchDragEvent -> InputDragData
pInputDispatchDragEventData PInputDispatchDragEvent
p),
    (Text
"modifiers" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchDragEvent -> Maybe Int
pInputDispatchDragEventModifiers PInputDispatchDragEvent
p)
    ]
instance Command PInputDispatchDragEvent where
  type CommandResponse PInputDispatchDragEvent = ()
  commandName :: Proxy PInputDispatchDragEvent -> String
commandName Proxy PInputDispatchDragEvent
_ = String
"Input.dispatchDragEvent"
  fromJSON :: Proxy PInputDispatchDragEvent
-> Value -> Result (CommandResponse PInputDispatchDragEvent)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputDispatchDragEvent -> Result ())
-> Proxy PInputDispatchDragEvent
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputDispatchDragEvent -> ())
-> Proxy PInputDispatchDragEvent
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputDispatchDragEvent -> ()
forall a b. a -> b -> a
const ()

-- | Dispatches a key event to the page.

-- | Parameters of the 'Input.dispatchKeyEvent' command.
data PInputDispatchKeyEventType = PInputDispatchKeyEventTypeKeyDown | PInputDispatchKeyEventTypeKeyUp | PInputDispatchKeyEventTypeRawKeyDown | PInputDispatchKeyEventTypeChar
  deriving (Eq PInputDispatchKeyEventType
Eq PInputDispatchKeyEventType
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Ordering)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Bool)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Bool)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Bool)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Bool)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> PInputDispatchKeyEventType)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> PInputDispatchKeyEventType)
-> Ord PInputDispatchKeyEventType
PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> Ordering
PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> PInputDispatchKeyEventType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> PInputDispatchKeyEventType
$cmin :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> PInputDispatchKeyEventType
max :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> PInputDispatchKeyEventType
$cmax :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> PInputDispatchKeyEventType
>= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c>= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
> :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c> :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
<= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c<= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
< :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c< :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
compare :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> Ordering
$ccompare :: PInputDispatchKeyEventType
-> PInputDispatchKeyEventType -> Ordering
$cp1Ord :: Eq PInputDispatchKeyEventType
Ord, PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
(PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool)
-> (PInputDispatchKeyEventType
    -> PInputDispatchKeyEventType -> Bool)
-> Eq PInputDispatchKeyEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c/= :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
== :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
$c== :: PInputDispatchKeyEventType -> PInputDispatchKeyEventType -> Bool
Eq, Int -> PInputDispatchKeyEventType -> ShowS
[PInputDispatchKeyEventType] -> ShowS
PInputDispatchKeyEventType -> String
(Int -> PInputDispatchKeyEventType -> ShowS)
-> (PInputDispatchKeyEventType -> String)
-> ([PInputDispatchKeyEventType] -> ShowS)
-> Show PInputDispatchKeyEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchKeyEventType] -> ShowS
$cshowList :: [PInputDispatchKeyEventType] -> ShowS
show :: PInputDispatchKeyEventType -> String
$cshow :: PInputDispatchKeyEventType -> String
showsPrec :: Int -> PInputDispatchKeyEventType -> ShowS
$cshowsPrec :: Int -> PInputDispatchKeyEventType -> ShowS
Show, ReadPrec [PInputDispatchKeyEventType]
ReadPrec PInputDispatchKeyEventType
Int -> ReadS PInputDispatchKeyEventType
ReadS [PInputDispatchKeyEventType]
(Int -> ReadS PInputDispatchKeyEventType)
-> ReadS [PInputDispatchKeyEventType]
-> ReadPrec PInputDispatchKeyEventType
-> ReadPrec [PInputDispatchKeyEventType]
-> Read PInputDispatchKeyEventType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputDispatchKeyEventType]
$creadListPrec :: ReadPrec [PInputDispatchKeyEventType]
readPrec :: ReadPrec PInputDispatchKeyEventType
$creadPrec :: ReadPrec PInputDispatchKeyEventType
readList :: ReadS [PInputDispatchKeyEventType]
$creadList :: ReadS [PInputDispatchKeyEventType]
readsPrec :: Int -> ReadS PInputDispatchKeyEventType
$creadsPrec :: Int -> ReadS PInputDispatchKeyEventType
Read)
instance FromJSON PInputDispatchKeyEventType where
  parseJSON :: Value -> Parser PInputDispatchKeyEventType
parseJSON = String
-> (Text -> Parser PInputDispatchKeyEventType)
-> Value
-> Parser PInputDispatchKeyEventType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputDispatchKeyEventType" ((Text -> Parser PInputDispatchKeyEventType)
 -> Value -> Parser PInputDispatchKeyEventType)
-> (Text -> Parser PInputDispatchKeyEventType)
-> Value
-> Parser PInputDispatchKeyEventType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"keyDown" -> PInputDispatchKeyEventType -> Parser PInputDispatchKeyEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchKeyEventType
PInputDispatchKeyEventTypeKeyDown
    Text
"keyUp" -> PInputDispatchKeyEventType -> Parser PInputDispatchKeyEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchKeyEventType
PInputDispatchKeyEventTypeKeyUp
    Text
"rawKeyDown" -> PInputDispatchKeyEventType -> Parser PInputDispatchKeyEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchKeyEventType
PInputDispatchKeyEventTypeRawKeyDown
    Text
"char" -> PInputDispatchKeyEventType -> Parser PInputDispatchKeyEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchKeyEventType
PInputDispatchKeyEventTypeChar
    Text
"_" -> String -> Parser PInputDispatchKeyEventType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputDispatchKeyEventType"
instance ToJSON PInputDispatchKeyEventType where
  toJSON :: PInputDispatchKeyEventType -> Value
toJSON PInputDispatchKeyEventType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputDispatchKeyEventType
v of
    PInputDispatchKeyEventType
PInputDispatchKeyEventTypeKeyDown -> Text
"keyDown"
    PInputDispatchKeyEventType
PInputDispatchKeyEventTypeKeyUp -> Text
"keyUp"
    PInputDispatchKeyEventType
PInputDispatchKeyEventTypeRawKeyDown -> Text
"rawKeyDown"
    PInputDispatchKeyEventType
PInputDispatchKeyEventTypeChar -> Text
"char"
data PInputDispatchKeyEvent = PInputDispatchKeyEvent
  {
    -- | Type of the key event.
    PInputDispatchKeyEvent -> PInputDispatchKeyEventType
pInputDispatchKeyEventType :: PInputDispatchKeyEventType,
    -- | Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
    --   (default: 0).
    PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventModifiers :: Maybe Int,
    -- | Time at which the event occurred.
    PInputDispatchKeyEvent -> Maybe Double
pInputDispatchKeyEventTimestamp :: Maybe InputTimeSinceEpoch,
    -- | Text as generated by processing a virtual key code with a keyboard layout. Not needed for
    --   for `keyUp` and `rawKeyDown` events (default: "")
    PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventText :: Maybe T.Text,
    -- | Text that would have been generated by the keyboard if no modifiers were pressed (except for
    --   shift). Useful for shortcut (accelerator) key handling (default: "").
    PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventUnmodifiedText :: Maybe T.Text,
    -- | Unique key identifier (e.g., 'U+0041') (default: "").
    PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventKeyIdentifier :: Maybe T.Text,
    -- | Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").
    PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventCode :: Maybe T.Text,
    -- | Unique DOM defined string value describing the meaning of the key in the context of active
    --   modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").
    PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventKey :: Maybe T.Text,
    -- | Windows virtual key code (default: 0).
    PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventWindowsVirtualKeyCode :: Maybe Int,
    -- | Native virtual key code (default: 0).
    PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventNativeVirtualKeyCode :: Maybe Int,
    -- | Whether the event was generated from auto repeat (default: false).
    PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventAutoRepeat :: Maybe Bool,
    -- | Whether the event was generated from the keypad (default: false).
    PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventIsKeypad :: Maybe Bool,
    -- | Whether the event was a system key event (default: false).
    PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventIsSystemKey :: Maybe Bool,
    -- | Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default:
    --   0).
    PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventLocation :: Maybe Int,
    -- | Editing commands to send with the key event (e.g., 'selectAll') (default: []).
    --   These are related to but not equal the command names used in `document.execCommand` and NSStandardKeyBindingResponding.
    --   See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names.
    PInputDispatchKeyEvent -> Maybe [Text]
pInputDispatchKeyEventCommands :: Maybe [T.Text]
  }
  deriving (PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool
(PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool)
-> (PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool)
-> Eq PInputDispatchKeyEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool
$c/= :: PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool
== :: PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool
$c== :: PInputDispatchKeyEvent -> PInputDispatchKeyEvent -> Bool
Eq, Int -> PInputDispatchKeyEvent -> ShowS
[PInputDispatchKeyEvent] -> ShowS
PInputDispatchKeyEvent -> String
(Int -> PInputDispatchKeyEvent -> ShowS)
-> (PInputDispatchKeyEvent -> String)
-> ([PInputDispatchKeyEvent] -> ShowS)
-> Show PInputDispatchKeyEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchKeyEvent] -> ShowS
$cshowList :: [PInputDispatchKeyEvent] -> ShowS
show :: PInputDispatchKeyEvent -> String
$cshow :: PInputDispatchKeyEvent -> String
showsPrec :: Int -> PInputDispatchKeyEvent -> ShowS
$cshowsPrec :: Int -> PInputDispatchKeyEvent -> ShowS
Show)
pInputDispatchKeyEvent
  {-
  -- | Type of the key event.
  -}
  :: PInputDispatchKeyEventType
  -> PInputDispatchKeyEvent
pInputDispatchKeyEvent :: PInputDispatchKeyEventType -> PInputDispatchKeyEvent
pInputDispatchKeyEvent
  PInputDispatchKeyEventType
arg_pInputDispatchKeyEventType
  = PInputDispatchKeyEventType
-> Maybe Int
-> Maybe Double
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Int
-> Maybe [Text]
-> PInputDispatchKeyEvent
PInputDispatchKeyEvent
    PInputDispatchKeyEventType
arg_pInputDispatchKeyEventType
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Bool
forall a. Maybe a
Nothing
    Maybe Bool
forall a. Maybe a
Nothing
    Maybe Bool
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe [Text]
forall a. Maybe a
Nothing
instance ToJSON PInputDispatchKeyEvent where
  toJSON :: PInputDispatchKeyEvent -> Value
toJSON PInputDispatchKeyEvent
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"type" Text -> PInputDispatchKeyEventType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputDispatchKeyEventType -> Pair)
-> Maybe PInputDispatchKeyEventType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PInputDispatchKeyEventType -> Maybe PInputDispatchKeyEventType
forall a. a -> Maybe a
Just (PInputDispatchKeyEvent -> PInputDispatchKeyEventType
pInputDispatchKeyEventType PInputDispatchKeyEvent
p),
    (Text
"modifiers" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventModifiers PInputDispatchKeyEvent
p),
    (Text
"timestamp" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Double
pInputDispatchKeyEventTimestamp PInputDispatchKeyEvent
p),
    (Text
"text" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventText PInputDispatchKeyEvent
p),
    (Text
"unmodifiedText" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventUnmodifiedText PInputDispatchKeyEvent
p),
    (Text
"keyIdentifier" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventKeyIdentifier PInputDispatchKeyEvent
p),
    (Text
"code" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventCode PInputDispatchKeyEvent
p),
    (Text
"key" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Text
pInputDispatchKeyEventKey PInputDispatchKeyEvent
p),
    (Text
"windowsVirtualKeyCode" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventWindowsVirtualKeyCode PInputDispatchKeyEvent
p),
    (Text
"nativeVirtualKeyCode" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventNativeVirtualKeyCode PInputDispatchKeyEvent
p),
    (Text
"autoRepeat" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventAutoRepeat PInputDispatchKeyEvent
p),
    (Text
"isKeypad" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventIsKeypad PInputDispatchKeyEvent
p),
    (Text
"isSystemKey" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Bool
pInputDispatchKeyEventIsSystemKey PInputDispatchKeyEvent
p),
    (Text
"location" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe Int
pInputDispatchKeyEventLocation PInputDispatchKeyEvent
p),
    (Text
"commands" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchKeyEvent -> Maybe [Text]
pInputDispatchKeyEventCommands PInputDispatchKeyEvent
p)
    ]
instance Command PInputDispatchKeyEvent where
  type CommandResponse PInputDispatchKeyEvent = ()
  commandName :: Proxy PInputDispatchKeyEvent -> String
commandName Proxy PInputDispatchKeyEvent
_ = String
"Input.dispatchKeyEvent"
  fromJSON :: Proxy PInputDispatchKeyEvent
-> Value -> Result (CommandResponse PInputDispatchKeyEvent)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputDispatchKeyEvent -> Result ())
-> Proxy PInputDispatchKeyEvent
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputDispatchKeyEvent -> ())
-> Proxy PInputDispatchKeyEvent
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputDispatchKeyEvent -> ()
forall a b. a -> b -> a
const ()

-- | This method emulates inserting text that doesn't come from a key press,
--   for example an emoji keyboard or an IME.

-- | Parameters of the 'Input.insertText' command.
data PInputInsertText = PInputInsertText
  {
    -- | The text to insert.
    PInputInsertText -> Text
pInputInsertTextText :: T.Text
  }
  deriving (PInputInsertText -> PInputInsertText -> Bool
(PInputInsertText -> PInputInsertText -> Bool)
-> (PInputInsertText -> PInputInsertText -> Bool)
-> Eq PInputInsertText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputInsertText -> PInputInsertText -> Bool
$c/= :: PInputInsertText -> PInputInsertText -> Bool
== :: PInputInsertText -> PInputInsertText -> Bool
$c== :: PInputInsertText -> PInputInsertText -> Bool
Eq, Int -> PInputInsertText -> ShowS
[PInputInsertText] -> ShowS
PInputInsertText -> String
(Int -> PInputInsertText -> ShowS)
-> (PInputInsertText -> String)
-> ([PInputInsertText] -> ShowS)
-> Show PInputInsertText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputInsertText] -> ShowS
$cshowList :: [PInputInsertText] -> ShowS
show :: PInputInsertText -> String
$cshow :: PInputInsertText -> String
showsPrec :: Int -> PInputInsertText -> ShowS
$cshowsPrec :: Int -> PInputInsertText -> ShowS
Show)
pInputInsertText
  {-
  -- | The text to insert.
  -}
  :: T.Text
  -> PInputInsertText
pInputInsertText :: Text -> PInputInsertText
pInputInsertText
  Text
arg_pInputInsertTextText
  = Text -> PInputInsertText
PInputInsertText
    Text
arg_pInputInsertTextText
instance ToJSON PInputInsertText where
  toJSON :: PInputInsertText -> Value
toJSON PInputInsertText
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"text" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (PInputInsertText -> Text
pInputInsertTextText PInputInsertText
p)
    ]
instance Command PInputInsertText where
  type CommandResponse PInputInsertText = ()
  commandName :: Proxy PInputInsertText -> String
commandName Proxy PInputInsertText
_ = String
"Input.insertText"
  fromJSON :: Proxy PInputInsertText
-> Value -> Result (CommandResponse PInputInsertText)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputInsertText -> Result ())
-> Proxy PInputInsertText
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputInsertText -> ())
-> Proxy PInputInsertText
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputInsertText -> ()
forall a b. a -> b -> a
const ()

-- | This method sets the current candidate text for ime.
--   Use imeCommitComposition to commit the final text.
--   Use imeSetComposition with empty string as text to cancel composition.

-- | Parameters of the 'Input.imeSetComposition' command.
data PInputImeSetComposition = PInputImeSetComposition
  {
    -- | The text to insert
    PInputImeSetComposition -> Text
pInputImeSetCompositionText :: T.Text,
    -- | selection start
    PInputImeSetComposition -> Int
pInputImeSetCompositionSelectionStart :: Int,
    -- | selection end
    PInputImeSetComposition -> Int
pInputImeSetCompositionSelectionEnd :: Int,
    -- | replacement start
    PInputImeSetComposition -> Maybe Int
pInputImeSetCompositionReplacementStart :: Maybe Int,
    -- | replacement end
    PInputImeSetComposition -> Maybe Int
pInputImeSetCompositionReplacementEnd :: Maybe Int
  }
  deriving (PInputImeSetComposition -> PInputImeSetComposition -> Bool
(PInputImeSetComposition -> PInputImeSetComposition -> Bool)
-> (PInputImeSetComposition -> PInputImeSetComposition -> Bool)
-> Eq PInputImeSetComposition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputImeSetComposition -> PInputImeSetComposition -> Bool
$c/= :: PInputImeSetComposition -> PInputImeSetComposition -> Bool
== :: PInputImeSetComposition -> PInputImeSetComposition -> Bool
$c== :: PInputImeSetComposition -> PInputImeSetComposition -> Bool
Eq, Int -> PInputImeSetComposition -> ShowS
[PInputImeSetComposition] -> ShowS
PInputImeSetComposition -> String
(Int -> PInputImeSetComposition -> ShowS)
-> (PInputImeSetComposition -> String)
-> ([PInputImeSetComposition] -> ShowS)
-> Show PInputImeSetComposition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputImeSetComposition] -> ShowS
$cshowList :: [PInputImeSetComposition] -> ShowS
show :: PInputImeSetComposition -> String
$cshow :: PInputImeSetComposition -> String
showsPrec :: Int -> PInputImeSetComposition -> ShowS
$cshowsPrec :: Int -> PInputImeSetComposition -> ShowS
Show)
pInputImeSetComposition
  {-
  -- | The text to insert
  -}
  :: T.Text
  {-
  -- | selection start
  -}
  -> Int
  {-
  -- | selection end
  -}
  -> Int
  -> PInputImeSetComposition
pInputImeSetComposition :: Text -> Int -> Int -> PInputImeSetComposition
pInputImeSetComposition
  Text
arg_pInputImeSetCompositionText
  Int
arg_pInputImeSetCompositionSelectionStart
  Int
arg_pInputImeSetCompositionSelectionEnd
  = Text
-> Int -> Int -> Maybe Int -> Maybe Int -> PInputImeSetComposition
PInputImeSetComposition
    Text
arg_pInputImeSetCompositionText
    Int
arg_pInputImeSetCompositionSelectionStart
    Int
arg_pInputImeSetCompositionSelectionEnd
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
instance ToJSON PInputImeSetComposition where
  toJSON :: PInputImeSetComposition -> Value
toJSON PInputImeSetComposition
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"text" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (PInputImeSetComposition -> Text
pInputImeSetCompositionText PInputImeSetComposition
p),
    (Text
"selectionStart" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (PInputImeSetComposition -> Int
pInputImeSetCompositionSelectionStart PInputImeSetComposition
p),
    (Text
"selectionEnd" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (PInputImeSetComposition -> Int
pInputImeSetCompositionSelectionEnd PInputImeSetComposition
p),
    (Text
"replacementStart" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputImeSetComposition -> Maybe Int
pInputImeSetCompositionReplacementStart PInputImeSetComposition
p),
    (Text
"replacementEnd" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputImeSetComposition -> Maybe Int
pInputImeSetCompositionReplacementEnd PInputImeSetComposition
p)
    ]
instance Command PInputImeSetComposition where
  type CommandResponse PInputImeSetComposition = ()
  commandName :: Proxy PInputImeSetComposition -> String
commandName Proxy PInputImeSetComposition
_ = String
"Input.imeSetComposition"
  fromJSON :: Proxy PInputImeSetComposition
-> Value -> Result (CommandResponse PInputImeSetComposition)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputImeSetComposition -> Result ())
-> Proxy PInputImeSetComposition
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputImeSetComposition -> ())
-> Proxy PInputImeSetComposition
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputImeSetComposition -> ()
forall a b. a -> b -> a
const ()

-- | Dispatches a mouse event to the page.

-- | Parameters of the 'Input.dispatchMouseEvent' command.
data PInputDispatchMouseEventType = PInputDispatchMouseEventTypeMousePressed | PInputDispatchMouseEventTypeMouseReleased | PInputDispatchMouseEventTypeMouseMoved | PInputDispatchMouseEventTypeMouseWheel
  deriving (Eq PInputDispatchMouseEventType
Eq PInputDispatchMouseEventType
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Ordering)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Bool)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Bool)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Bool)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Bool)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> PInputDispatchMouseEventType)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> PInputDispatchMouseEventType)
-> Ord PInputDispatchMouseEventType
PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Ordering
PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> PInputDispatchMouseEventType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> PInputDispatchMouseEventType
$cmin :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> PInputDispatchMouseEventType
max :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> PInputDispatchMouseEventType
$cmax :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> PInputDispatchMouseEventType
>= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c>= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
> :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c> :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
<= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c<= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
< :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c< :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
compare :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Ordering
$ccompare :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Ordering
$cp1Ord :: Eq PInputDispatchMouseEventType
Ord, PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
(PInputDispatchMouseEventType
 -> PInputDispatchMouseEventType -> Bool)
-> (PInputDispatchMouseEventType
    -> PInputDispatchMouseEventType -> Bool)
-> Eq PInputDispatchMouseEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c/= :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
== :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
$c== :: PInputDispatchMouseEventType
-> PInputDispatchMouseEventType -> Bool
Eq, Int -> PInputDispatchMouseEventType -> ShowS
[PInputDispatchMouseEventType] -> ShowS
PInputDispatchMouseEventType -> String
(Int -> PInputDispatchMouseEventType -> ShowS)
-> (PInputDispatchMouseEventType -> String)
-> ([PInputDispatchMouseEventType] -> ShowS)
-> Show PInputDispatchMouseEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchMouseEventType] -> ShowS
$cshowList :: [PInputDispatchMouseEventType] -> ShowS
show :: PInputDispatchMouseEventType -> String
$cshow :: PInputDispatchMouseEventType -> String
showsPrec :: Int -> PInputDispatchMouseEventType -> ShowS
$cshowsPrec :: Int -> PInputDispatchMouseEventType -> ShowS
Show, ReadPrec [PInputDispatchMouseEventType]
ReadPrec PInputDispatchMouseEventType
Int -> ReadS PInputDispatchMouseEventType
ReadS [PInputDispatchMouseEventType]
(Int -> ReadS PInputDispatchMouseEventType)
-> ReadS [PInputDispatchMouseEventType]
-> ReadPrec PInputDispatchMouseEventType
-> ReadPrec [PInputDispatchMouseEventType]
-> Read PInputDispatchMouseEventType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputDispatchMouseEventType]
$creadListPrec :: ReadPrec [PInputDispatchMouseEventType]
readPrec :: ReadPrec PInputDispatchMouseEventType
$creadPrec :: ReadPrec PInputDispatchMouseEventType
readList :: ReadS [PInputDispatchMouseEventType]
$creadList :: ReadS [PInputDispatchMouseEventType]
readsPrec :: Int -> ReadS PInputDispatchMouseEventType
$creadsPrec :: Int -> ReadS PInputDispatchMouseEventType
Read)
instance FromJSON PInputDispatchMouseEventType where
  parseJSON :: Value -> Parser PInputDispatchMouseEventType
parseJSON = String
-> (Text -> Parser PInputDispatchMouseEventType)
-> Value
-> Parser PInputDispatchMouseEventType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputDispatchMouseEventType" ((Text -> Parser PInputDispatchMouseEventType)
 -> Value -> Parser PInputDispatchMouseEventType)
-> (Text -> Parser PInputDispatchMouseEventType)
-> Value
-> Parser PInputDispatchMouseEventType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"mousePressed" -> PInputDispatchMouseEventType -> Parser PInputDispatchMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMousePressed
    Text
"mouseReleased" -> PInputDispatchMouseEventType -> Parser PInputDispatchMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseReleased
    Text
"mouseMoved" -> PInputDispatchMouseEventType -> Parser PInputDispatchMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseMoved
    Text
"mouseWheel" -> PInputDispatchMouseEventType -> Parser PInputDispatchMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseWheel
    Text
"_" -> String -> Parser PInputDispatchMouseEventType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputDispatchMouseEventType"
instance ToJSON PInputDispatchMouseEventType where
  toJSON :: PInputDispatchMouseEventType -> Value
toJSON PInputDispatchMouseEventType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputDispatchMouseEventType
v of
    PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMousePressed -> Text
"mousePressed"
    PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseReleased -> Text
"mouseReleased"
    PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseMoved -> Text
"mouseMoved"
    PInputDispatchMouseEventType
PInputDispatchMouseEventTypeMouseWheel -> Text
"mouseWheel"
data PInputDispatchMouseEventPointerType = PInputDispatchMouseEventPointerTypeMouse | PInputDispatchMouseEventPointerTypePen
  deriving (Eq PInputDispatchMouseEventPointerType
Eq PInputDispatchMouseEventPointerType
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Ordering)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Bool)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Bool)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Bool)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Bool)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType)
-> Ord PInputDispatchMouseEventPointerType
PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Ordering
PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
$cmin :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
max :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
$cmax :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType
>= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c>= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
> :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c> :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
<= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c<= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
< :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c< :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
compare :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Ordering
$ccompare :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Ordering
$cp1Ord :: Eq PInputDispatchMouseEventPointerType
Ord, PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
(PInputDispatchMouseEventPointerType
 -> PInputDispatchMouseEventPointerType -> Bool)
-> (PInputDispatchMouseEventPointerType
    -> PInputDispatchMouseEventPointerType -> Bool)
-> Eq PInputDispatchMouseEventPointerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c/= :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
== :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
$c== :: PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEventPointerType -> Bool
Eq, Int -> PInputDispatchMouseEventPointerType -> ShowS
[PInputDispatchMouseEventPointerType] -> ShowS
PInputDispatchMouseEventPointerType -> String
(Int -> PInputDispatchMouseEventPointerType -> ShowS)
-> (PInputDispatchMouseEventPointerType -> String)
-> ([PInputDispatchMouseEventPointerType] -> ShowS)
-> Show PInputDispatchMouseEventPointerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchMouseEventPointerType] -> ShowS
$cshowList :: [PInputDispatchMouseEventPointerType] -> ShowS
show :: PInputDispatchMouseEventPointerType -> String
$cshow :: PInputDispatchMouseEventPointerType -> String
showsPrec :: Int -> PInputDispatchMouseEventPointerType -> ShowS
$cshowsPrec :: Int -> PInputDispatchMouseEventPointerType -> ShowS
Show, ReadPrec [PInputDispatchMouseEventPointerType]
ReadPrec PInputDispatchMouseEventPointerType
Int -> ReadS PInputDispatchMouseEventPointerType
ReadS [PInputDispatchMouseEventPointerType]
(Int -> ReadS PInputDispatchMouseEventPointerType)
-> ReadS [PInputDispatchMouseEventPointerType]
-> ReadPrec PInputDispatchMouseEventPointerType
-> ReadPrec [PInputDispatchMouseEventPointerType]
-> Read PInputDispatchMouseEventPointerType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputDispatchMouseEventPointerType]
$creadListPrec :: ReadPrec [PInputDispatchMouseEventPointerType]
readPrec :: ReadPrec PInputDispatchMouseEventPointerType
$creadPrec :: ReadPrec PInputDispatchMouseEventPointerType
readList :: ReadS [PInputDispatchMouseEventPointerType]
$creadList :: ReadS [PInputDispatchMouseEventPointerType]
readsPrec :: Int -> ReadS PInputDispatchMouseEventPointerType
$creadsPrec :: Int -> ReadS PInputDispatchMouseEventPointerType
Read)
instance FromJSON PInputDispatchMouseEventPointerType where
  parseJSON :: Value -> Parser PInputDispatchMouseEventPointerType
parseJSON = String
-> (Text -> Parser PInputDispatchMouseEventPointerType)
-> Value
-> Parser PInputDispatchMouseEventPointerType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputDispatchMouseEventPointerType" ((Text -> Parser PInputDispatchMouseEventPointerType)
 -> Value -> Parser PInputDispatchMouseEventPointerType)
-> (Text -> Parser PInputDispatchMouseEventPointerType)
-> Value
-> Parser PInputDispatchMouseEventPointerType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"mouse" -> PInputDispatchMouseEventPointerType
-> Parser PInputDispatchMouseEventPointerType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventPointerType
PInputDispatchMouseEventPointerTypeMouse
    Text
"pen" -> PInputDispatchMouseEventPointerType
-> Parser PInputDispatchMouseEventPointerType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchMouseEventPointerType
PInputDispatchMouseEventPointerTypePen
    Text
"_" -> String -> Parser PInputDispatchMouseEventPointerType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputDispatchMouseEventPointerType"
instance ToJSON PInputDispatchMouseEventPointerType where
  toJSON :: PInputDispatchMouseEventPointerType -> Value
toJSON PInputDispatchMouseEventPointerType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputDispatchMouseEventPointerType
v of
    PInputDispatchMouseEventPointerType
PInputDispatchMouseEventPointerTypeMouse -> Text
"mouse"
    PInputDispatchMouseEventPointerType
PInputDispatchMouseEventPointerTypePen -> Text
"pen"
data PInputDispatchMouseEvent = PInputDispatchMouseEvent
  {
    -- | Type of the mouse event.
    PInputDispatchMouseEvent -> PInputDispatchMouseEventType
pInputDispatchMouseEventType :: PInputDispatchMouseEventType,
    -- | X coordinate of the event relative to the main frame's viewport in CSS pixels.
    PInputDispatchMouseEvent -> Double
pInputDispatchMouseEventX :: Double,
    -- | Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
    --   the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    PInputDispatchMouseEvent -> Double
pInputDispatchMouseEventY :: Double,
    -- | Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
    --   (default: 0).
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventModifiers :: Maybe Int,
    -- | Time at which the event occurred.
    PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventTimestamp :: Maybe InputTimeSinceEpoch,
    -- | Mouse button (default: "none").
    PInputDispatchMouseEvent -> Maybe InputMouseButton
pInputDispatchMouseEventButton :: Maybe InputMouseButton,
    -- | A number indicating which buttons are pressed on the mouse when a mouse event is triggered.
    --   Left=1, Right=2, Middle=4, Back=8, Forward=16, None=0.
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventButtons :: Maybe Int,
    -- | Number of times the mouse button was clicked (default: 0).
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventClickCount :: Maybe Int,
    -- | The normalized pressure, which has a range of [0,1] (default: 0).
    PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventForce :: Maybe Double,
    -- | The normalized tangential pressure, which has a range of [-1,1] (default: 0).
    PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventTangentialPressure :: Maybe Double,
    -- | The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0).
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTiltX :: Maybe Int,
    -- | The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTiltY :: Maybe Int,
    -- | The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
    PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTwist :: Maybe Int,
    -- | X delta in CSS pixels for mouse wheel event (default: 0).
    PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventDeltaX :: Maybe Double,
    -- | Y delta in CSS pixels for mouse wheel event (default: 0).
    PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventDeltaY :: Maybe Double,
    -- | Pointer type (default: "mouse").
    PInputDispatchMouseEvent
-> Maybe PInputDispatchMouseEventPointerType
pInputDispatchMouseEventPointerType :: Maybe PInputDispatchMouseEventPointerType
  }
  deriving (PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool
(PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool)
-> (PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool)
-> Eq PInputDispatchMouseEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool
$c/= :: PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool
== :: PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool
$c== :: PInputDispatchMouseEvent -> PInputDispatchMouseEvent -> Bool
Eq, Int -> PInputDispatchMouseEvent -> ShowS
[PInputDispatchMouseEvent] -> ShowS
PInputDispatchMouseEvent -> String
(Int -> PInputDispatchMouseEvent -> ShowS)
-> (PInputDispatchMouseEvent -> String)
-> ([PInputDispatchMouseEvent] -> ShowS)
-> Show PInputDispatchMouseEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchMouseEvent] -> ShowS
$cshowList :: [PInputDispatchMouseEvent] -> ShowS
show :: PInputDispatchMouseEvent -> String
$cshow :: PInputDispatchMouseEvent -> String
showsPrec :: Int -> PInputDispatchMouseEvent -> ShowS
$cshowsPrec :: Int -> PInputDispatchMouseEvent -> ShowS
Show)
pInputDispatchMouseEvent
  {-
  -- | Type of the mouse event.
  -}
  :: PInputDispatchMouseEventType
  {-
  -- | X coordinate of the event relative to the main frame's viewport in CSS pixels.
  -}
  -> Double
  {-
  -- | Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
  --   the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
  -}
  -> Double
  -> PInputDispatchMouseEvent
pInputDispatchMouseEvent :: PInputDispatchMouseEventType
-> Double -> Double -> PInputDispatchMouseEvent
pInputDispatchMouseEvent
  PInputDispatchMouseEventType
arg_pInputDispatchMouseEventType
  Double
arg_pInputDispatchMouseEventX
  Double
arg_pInputDispatchMouseEventY
  = PInputDispatchMouseEventType
-> Double
-> Double
-> Maybe Int
-> Maybe Double
-> Maybe InputMouseButton
-> Maybe Int
-> Maybe Int
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Double
-> Maybe Double
-> Maybe PInputDispatchMouseEventPointerType
-> PInputDispatchMouseEvent
PInputDispatchMouseEvent
    PInputDispatchMouseEventType
arg_pInputDispatchMouseEventType
    Double
arg_pInputDispatchMouseEventX
    Double
arg_pInputDispatchMouseEventY
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe InputMouseButton
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe PInputDispatchMouseEventPointerType
forall a. Maybe a
Nothing
instance ToJSON PInputDispatchMouseEvent where
  toJSON :: PInputDispatchMouseEvent -> Value
toJSON PInputDispatchMouseEvent
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"type" Text -> PInputDispatchMouseEventType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputDispatchMouseEventType -> Pair)
-> Maybe PInputDispatchMouseEventType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PInputDispatchMouseEventType -> Maybe PInputDispatchMouseEventType
forall a. a -> Maybe a
Just (PInputDispatchMouseEvent -> PInputDispatchMouseEventType
pInputDispatchMouseEventType PInputDispatchMouseEvent
p),
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputDispatchMouseEvent -> Double
pInputDispatchMouseEventX PInputDispatchMouseEvent
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputDispatchMouseEvent -> Double
pInputDispatchMouseEventY PInputDispatchMouseEvent
p),
    (Text
"modifiers" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventModifiers PInputDispatchMouseEvent
p),
    (Text
"timestamp" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventTimestamp PInputDispatchMouseEvent
p),
    (Text
"button" Text -> InputMouseButton -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputMouseButton -> Pair) -> Maybe InputMouseButton -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe InputMouseButton
pInputDispatchMouseEventButton PInputDispatchMouseEvent
p),
    (Text
"buttons" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventButtons PInputDispatchMouseEvent
p),
    (Text
"clickCount" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventClickCount PInputDispatchMouseEvent
p),
    (Text
"force" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventForce PInputDispatchMouseEvent
p),
    (Text
"tangentialPressure" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventTangentialPressure PInputDispatchMouseEvent
p),
    (Text
"tiltX" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTiltX PInputDispatchMouseEvent
p),
    (Text
"tiltY" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTiltY PInputDispatchMouseEvent
p),
    (Text
"twist" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Int
pInputDispatchMouseEventTwist PInputDispatchMouseEvent
p),
    (Text
"deltaX" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventDeltaX PInputDispatchMouseEvent
p),
    (Text
"deltaY" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent -> Maybe Double
pInputDispatchMouseEventDeltaY PInputDispatchMouseEvent
p),
    (Text
"pointerType" Text -> PInputDispatchMouseEventPointerType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputDispatchMouseEventPointerType -> Pair)
-> Maybe PInputDispatchMouseEventPointerType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchMouseEvent
-> Maybe PInputDispatchMouseEventPointerType
pInputDispatchMouseEventPointerType PInputDispatchMouseEvent
p)
    ]
instance Command PInputDispatchMouseEvent where
  type CommandResponse PInputDispatchMouseEvent = ()
  commandName :: Proxy PInputDispatchMouseEvent -> String
commandName Proxy PInputDispatchMouseEvent
_ = String
"Input.dispatchMouseEvent"
  fromJSON :: Proxy PInputDispatchMouseEvent
-> Value -> Result (CommandResponse PInputDispatchMouseEvent)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputDispatchMouseEvent -> Result ())
-> Proxy PInputDispatchMouseEvent
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputDispatchMouseEvent -> ())
-> Proxy PInputDispatchMouseEvent
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputDispatchMouseEvent -> ()
forall a b. a -> b -> a
const ()

-- | Dispatches a touch event to the page.

-- | Parameters of the 'Input.dispatchTouchEvent' command.
data PInputDispatchTouchEventType = PInputDispatchTouchEventTypeTouchStart | PInputDispatchTouchEventTypeTouchEnd | PInputDispatchTouchEventTypeTouchMove | PInputDispatchTouchEventTypeTouchCancel
  deriving (Eq PInputDispatchTouchEventType
Eq PInputDispatchTouchEventType
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Ordering)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Bool)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Bool)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Bool)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Bool)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> PInputDispatchTouchEventType)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> PInputDispatchTouchEventType)
-> Ord PInputDispatchTouchEventType
PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Ordering
PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> PInputDispatchTouchEventType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> PInputDispatchTouchEventType
$cmin :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> PInputDispatchTouchEventType
max :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> PInputDispatchTouchEventType
$cmax :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> PInputDispatchTouchEventType
>= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c>= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
> :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c> :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
<= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c<= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
< :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c< :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
compare :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Ordering
$ccompare :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Ordering
$cp1Ord :: Eq PInputDispatchTouchEventType
Ord, PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
(PInputDispatchTouchEventType
 -> PInputDispatchTouchEventType -> Bool)
-> (PInputDispatchTouchEventType
    -> PInputDispatchTouchEventType -> Bool)
-> Eq PInputDispatchTouchEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c/= :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
== :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
$c== :: PInputDispatchTouchEventType
-> PInputDispatchTouchEventType -> Bool
Eq, Int -> PInputDispatchTouchEventType -> ShowS
[PInputDispatchTouchEventType] -> ShowS
PInputDispatchTouchEventType -> String
(Int -> PInputDispatchTouchEventType -> ShowS)
-> (PInputDispatchTouchEventType -> String)
-> ([PInputDispatchTouchEventType] -> ShowS)
-> Show PInputDispatchTouchEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchTouchEventType] -> ShowS
$cshowList :: [PInputDispatchTouchEventType] -> ShowS
show :: PInputDispatchTouchEventType -> String
$cshow :: PInputDispatchTouchEventType -> String
showsPrec :: Int -> PInputDispatchTouchEventType -> ShowS
$cshowsPrec :: Int -> PInputDispatchTouchEventType -> ShowS
Show, ReadPrec [PInputDispatchTouchEventType]
ReadPrec PInputDispatchTouchEventType
Int -> ReadS PInputDispatchTouchEventType
ReadS [PInputDispatchTouchEventType]
(Int -> ReadS PInputDispatchTouchEventType)
-> ReadS [PInputDispatchTouchEventType]
-> ReadPrec PInputDispatchTouchEventType
-> ReadPrec [PInputDispatchTouchEventType]
-> Read PInputDispatchTouchEventType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputDispatchTouchEventType]
$creadListPrec :: ReadPrec [PInputDispatchTouchEventType]
readPrec :: ReadPrec PInputDispatchTouchEventType
$creadPrec :: ReadPrec PInputDispatchTouchEventType
readList :: ReadS [PInputDispatchTouchEventType]
$creadList :: ReadS [PInputDispatchTouchEventType]
readsPrec :: Int -> ReadS PInputDispatchTouchEventType
$creadsPrec :: Int -> ReadS PInputDispatchTouchEventType
Read)
instance FromJSON PInputDispatchTouchEventType where
  parseJSON :: Value -> Parser PInputDispatchTouchEventType
parseJSON = String
-> (Text -> Parser PInputDispatchTouchEventType)
-> Value
-> Parser PInputDispatchTouchEventType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputDispatchTouchEventType" ((Text -> Parser PInputDispatchTouchEventType)
 -> Value -> Parser PInputDispatchTouchEventType)
-> (Text -> Parser PInputDispatchTouchEventType)
-> Value
-> Parser PInputDispatchTouchEventType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"touchStart" -> PInputDispatchTouchEventType -> Parser PInputDispatchTouchEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchStart
    Text
"touchEnd" -> PInputDispatchTouchEventType -> Parser PInputDispatchTouchEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchEnd
    Text
"touchMove" -> PInputDispatchTouchEventType -> Parser PInputDispatchTouchEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchMove
    Text
"touchCancel" -> PInputDispatchTouchEventType -> Parser PInputDispatchTouchEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchCancel
    Text
"_" -> String -> Parser PInputDispatchTouchEventType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputDispatchTouchEventType"
instance ToJSON PInputDispatchTouchEventType where
  toJSON :: PInputDispatchTouchEventType -> Value
toJSON PInputDispatchTouchEventType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputDispatchTouchEventType
v of
    PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchStart -> Text
"touchStart"
    PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchEnd -> Text
"touchEnd"
    PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchMove -> Text
"touchMove"
    PInputDispatchTouchEventType
PInputDispatchTouchEventTypeTouchCancel -> Text
"touchCancel"
data PInputDispatchTouchEvent = PInputDispatchTouchEvent
  {
    -- | Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while
    --   TouchStart and TouchMove must contains at least one.
    PInputDispatchTouchEvent -> PInputDispatchTouchEventType
pInputDispatchTouchEventType :: PInputDispatchTouchEventType,
    -- | Active touch points on the touch device. One event per any changed point (compared to
    --   previous touch event in a sequence) is generated, emulating pressing/moving/releasing points
    --   one by one.
    PInputDispatchTouchEvent -> [InputTouchPoint]
pInputDispatchTouchEventTouchPoints :: [InputTouchPoint],
    -- | Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
    --   (default: 0).
    PInputDispatchTouchEvent -> Maybe Int
pInputDispatchTouchEventModifiers :: Maybe Int,
    -- | Time at which the event occurred.
    PInputDispatchTouchEvent -> Maybe Double
pInputDispatchTouchEventTimestamp :: Maybe InputTimeSinceEpoch
  }
  deriving (PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool
(PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool)
-> (PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool)
-> Eq PInputDispatchTouchEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool
$c/= :: PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool
== :: PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool
$c== :: PInputDispatchTouchEvent -> PInputDispatchTouchEvent -> Bool
Eq, Int -> PInputDispatchTouchEvent -> ShowS
[PInputDispatchTouchEvent] -> ShowS
PInputDispatchTouchEvent -> String
(Int -> PInputDispatchTouchEvent -> ShowS)
-> (PInputDispatchTouchEvent -> String)
-> ([PInputDispatchTouchEvent] -> ShowS)
-> Show PInputDispatchTouchEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputDispatchTouchEvent] -> ShowS
$cshowList :: [PInputDispatchTouchEvent] -> ShowS
show :: PInputDispatchTouchEvent -> String
$cshow :: PInputDispatchTouchEvent -> String
showsPrec :: Int -> PInputDispatchTouchEvent -> ShowS
$cshowsPrec :: Int -> PInputDispatchTouchEvent -> ShowS
Show)
pInputDispatchTouchEvent
  {-
  -- | Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while
  --   TouchStart and TouchMove must contains at least one.
  -}
  :: PInputDispatchTouchEventType
  {-
  -- | Active touch points on the touch device. One event per any changed point (compared to
  --   previous touch event in a sequence) is generated, emulating pressing/moving/releasing points
  --   one by one.
  -}
  -> [InputTouchPoint]
  -> PInputDispatchTouchEvent
pInputDispatchTouchEvent :: PInputDispatchTouchEventType
-> [InputTouchPoint] -> PInputDispatchTouchEvent
pInputDispatchTouchEvent
  PInputDispatchTouchEventType
arg_pInputDispatchTouchEventType
  [InputTouchPoint]
arg_pInputDispatchTouchEventTouchPoints
  = PInputDispatchTouchEventType
-> [InputTouchPoint]
-> Maybe Int
-> Maybe Double
-> PInputDispatchTouchEvent
PInputDispatchTouchEvent
    PInputDispatchTouchEventType
arg_pInputDispatchTouchEventType
    [InputTouchPoint]
arg_pInputDispatchTouchEventTouchPoints
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
instance ToJSON PInputDispatchTouchEvent where
  toJSON :: PInputDispatchTouchEvent -> Value
toJSON PInputDispatchTouchEvent
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"type" Text -> PInputDispatchTouchEventType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputDispatchTouchEventType -> Pair)
-> Maybe PInputDispatchTouchEventType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PInputDispatchTouchEventType -> Maybe PInputDispatchTouchEventType
forall a. a -> Maybe a
Just (PInputDispatchTouchEvent -> PInputDispatchTouchEventType
pInputDispatchTouchEventType PInputDispatchTouchEvent
p),
    (Text
"touchPoints" Text -> [InputTouchPoint] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) ([InputTouchPoint] -> Pair)
-> Maybe [InputTouchPoint] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [InputTouchPoint] -> Maybe [InputTouchPoint]
forall a. a -> Maybe a
Just (PInputDispatchTouchEvent -> [InputTouchPoint]
pInputDispatchTouchEventTouchPoints PInputDispatchTouchEvent
p),
    (Text
"modifiers" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchTouchEvent -> Maybe Int
pInputDispatchTouchEventModifiers PInputDispatchTouchEvent
p),
    (Text
"timestamp" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputDispatchTouchEvent -> Maybe Double
pInputDispatchTouchEventTimestamp PInputDispatchTouchEvent
p)
    ]
instance Command PInputDispatchTouchEvent where
  type CommandResponse PInputDispatchTouchEvent = ()
  commandName :: Proxy PInputDispatchTouchEvent -> String
commandName Proxy PInputDispatchTouchEvent
_ = String
"Input.dispatchTouchEvent"
  fromJSON :: Proxy PInputDispatchTouchEvent
-> Value -> Result (CommandResponse PInputDispatchTouchEvent)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputDispatchTouchEvent -> Result ())
-> Proxy PInputDispatchTouchEvent
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputDispatchTouchEvent -> ())
-> Proxy PInputDispatchTouchEvent
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputDispatchTouchEvent -> ()
forall a b. a -> b -> a
const ()

-- | Emulates touch event from the mouse event parameters.

-- | Parameters of the 'Input.emulateTouchFromMouseEvent' command.
data PInputEmulateTouchFromMouseEventType = PInputEmulateTouchFromMouseEventTypeMousePressed | PInputEmulateTouchFromMouseEventTypeMouseReleased | PInputEmulateTouchFromMouseEventTypeMouseMoved | PInputEmulateTouchFromMouseEventTypeMouseWheel
  deriving (Eq PInputEmulateTouchFromMouseEventType
Eq PInputEmulateTouchFromMouseEventType
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Ordering)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Bool)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Bool)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Bool)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Bool)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType)
-> Ord PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Ordering
PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
$cmin :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
max :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
$cmax :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType
>= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c>= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
> :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c> :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
<= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c<= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
< :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c< :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
compare :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Ordering
$ccompare :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Ordering
$cp1Ord :: Eq PInputEmulateTouchFromMouseEventType
Ord, PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
(PInputEmulateTouchFromMouseEventType
 -> PInputEmulateTouchFromMouseEventType -> Bool)
-> (PInputEmulateTouchFromMouseEventType
    -> PInputEmulateTouchFromMouseEventType -> Bool)
-> Eq PInputEmulateTouchFromMouseEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c/= :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
== :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
$c== :: PInputEmulateTouchFromMouseEventType
-> PInputEmulateTouchFromMouseEventType -> Bool
Eq, Int -> PInputEmulateTouchFromMouseEventType -> ShowS
[PInputEmulateTouchFromMouseEventType] -> ShowS
PInputEmulateTouchFromMouseEventType -> String
(Int -> PInputEmulateTouchFromMouseEventType -> ShowS)
-> (PInputEmulateTouchFromMouseEventType -> String)
-> ([PInputEmulateTouchFromMouseEventType] -> ShowS)
-> Show PInputEmulateTouchFromMouseEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputEmulateTouchFromMouseEventType] -> ShowS
$cshowList :: [PInputEmulateTouchFromMouseEventType] -> ShowS
show :: PInputEmulateTouchFromMouseEventType -> String
$cshow :: PInputEmulateTouchFromMouseEventType -> String
showsPrec :: Int -> PInputEmulateTouchFromMouseEventType -> ShowS
$cshowsPrec :: Int -> PInputEmulateTouchFromMouseEventType -> ShowS
Show, ReadPrec [PInputEmulateTouchFromMouseEventType]
ReadPrec PInputEmulateTouchFromMouseEventType
Int -> ReadS PInputEmulateTouchFromMouseEventType
ReadS [PInputEmulateTouchFromMouseEventType]
(Int -> ReadS PInputEmulateTouchFromMouseEventType)
-> ReadS [PInputEmulateTouchFromMouseEventType]
-> ReadPrec PInputEmulateTouchFromMouseEventType
-> ReadPrec [PInputEmulateTouchFromMouseEventType]
-> Read PInputEmulateTouchFromMouseEventType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PInputEmulateTouchFromMouseEventType]
$creadListPrec :: ReadPrec [PInputEmulateTouchFromMouseEventType]
readPrec :: ReadPrec PInputEmulateTouchFromMouseEventType
$creadPrec :: ReadPrec PInputEmulateTouchFromMouseEventType
readList :: ReadS [PInputEmulateTouchFromMouseEventType]
$creadList :: ReadS [PInputEmulateTouchFromMouseEventType]
readsPrec :: Int -> ReadS PInputEmulateTouchFromMouseEventType
$creadsPrec :: Int -> ReadS PInputEmulateTouchFromMouseEventType
Read)
instance FromJSON PInputEmulateTouchFromMouseEventType where
  parseJSON :: Value -> Parser PInputEmulateTouchFromMouseEventType
parseJSON = String
-> (Text -> Parser PInputEmulateTouchFromMouseEventType)
-> Value
-> Parser PInputEmulateTouchFromMouseEventType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"PInputEmulateTouchFromMouseEventType" ((Text -> Parser PInputEmulateTouchFromMouseEventType)
 -> Value -> Parser PInputEmulateTouchFromMouseEventType)
-> (Text -> Parser PInputEmulateTouchFromMouseEventType)
-> Value
-> Parser PInputEmulateTouchFromMouseEventType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"mousePressed" -> PInputEmulateTouchFromMouseEventType
-> Parser PInputEmulateTouchFromMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMousePressed
    Text
"mouseReleased" -> PInputEmulateTouchFromMouseEventType
-> Parser PInputEmulateTouchFromMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseReleased
    Text
"mouseMoved" -> PInputEmulateTouchFromMouseEventType
-> Parser PInputEmulateTouchFromMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseMoved
    Text
"mouseWheel" -> PInputEmulateTouchFromMouseEventType
-> Parser PInputEmulateTouchFromMouseEventType
forall (f :: * -> *) a. Applicative f => a -> f a
pure PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseWheel
    Text
"_" -> String -> Parser PInputEmulateTouchFromMouseEventType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse PInputEmulateTouchFromMouseEventType"
instance ToJSON PInputEmulateTouchFromMouseEventType where
  toJSON :: PInputEmulateTouchFromMouseEventType -> Value
toJSON PInputEmulateTouchFromMouseEventType
v = Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ case PInputEmulateTouchFromMouseEventType
v of
    PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMousePressed -> Text
"mousePressed"
    PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseReleased -> Text
"mouseReleased"
    PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseMoved -> Text
"mouseMoved"
    PInputEmulateTouchFromMouseEventType
PInputEmulateTouchFromMouseEventTypeMouseWheel -> Text
"mouseWheel"
data PInputEmulateTouchFromMouseEvent = PInputEmulateTouchFromMouseEvent
  {
    -- | Type of the mouse event.
    PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEventType
pInputEmulateTouchFromMouseEventType :: PInputEmulateTouchFromMouseEventType,
    -- | X coordinate of the mouse pointer in DIP.
    PInputEmulateTouchFromMouseEvent -> Int
pInputEmulateTouchFromMouseEventX :: Int,
    -- | Y coordinate of the mouse pointer in DIP.
    PInputEmulateTouchFromMouseEvent -> Int
pInputEmulateTouchFromMouseEventY :: Int,
    -- | Mouse button. Only "none", "left", "right" are supported.
    PInputEmulateTouchFromMouseEvent -> InputMouseButton
pInputEmulateTouchFromMouseEventButton :: InputMouseButton,
    -- | Time at which the event occurred (default: current time).
    PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventTimestamp :: Maybe InputTimeSinceEpoch,
    -- | X delta in DIP for mouse wheel event (default: 0).
    PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventDeltaX :: Maybe Double,
    -- | Y delta in DIP for mouse wheel event (default: 0).
    PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventDeltaY :: Maybe Double,
    -- | Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
    --   (default: 0).
    PInputEmulateTouchFromMouseEvent -> Maybe Int
pInputEmulateTouchFromMouseEventModifiers :: Maybe Int,
    -- | Number of times the mouse button was clicked (default: 0).
    PInputEmulateTouchFromMouseEvent -> Maybe Int
pInputEmulateTouchFromMouseEventClickCount :: Maybe Int
  }
  deriving (PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEvent -> Bool
(PInputEmulateTouchFromMouseEvent
 -> PInputEmulateTouchFromMouseEvent -> Bool)
-> (PInputEmulateTouchFromMouseEvent
    -> PInputEmulateTouchFromMouseEvent -> Bool)
-> Eq PInputEmulateTouchFromMouseEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEvent -> Bool
$c/= :: PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEvent -> Bool
== :: PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEvent -> Bool
$c== :: PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEvent -> Bool
Eq, Int -> PInputEmulateTouchFromMouseEvent -> ShowS
[PInputEmulateTouchFromMouseEvent] -> ShowS
PInputEmulateTouchFromMouseEvent -> String
(Int -> PInputEmulateTouchFromMouseEvent -> ShowS)
-> (PInputEmulateTouchFromMouseEvent -> String)
-> ([PInputEmulateTouchFromMouseEvent] -> ShowS)
-> Show PInputEmulateTouchFromMouseEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputEmulateTouchFromMouseEvent] -> ShowS
$cshowList :: [PInputEmulateTouchFromMouseEvent] -> ShowS
show :: PInputEmulateTouchFromMouseEvent -> String
$cshow :: PInputEmulateTouchFromMouseEvent -> String
showsPrec :: Int -> PInputEmulateTouchFromMouseEvent -> ShowS
$cshowsPrec :: Int -> PInputEmulateTouchFromMouseEvent -> ShowS
Show)
pInputEmulateTouchFromMouseEvent
  {-
  -- | Type of the mouse event.
  -}
  :: PInputEmulateTouchFromMouseEventType
  {-
  -- | X coordinate of the mouse pointer in DIP.
  -}
  -> Int
  {-
  -- | Y coordinate of the mouse pointer in DIP.
  -}
  -> Int
  {-
  -- | Mouse button. Only "none", "left", "right" are supported.
  -}
  -> InputMouseButton
  -> PInputEmulateTouchFromMouseEvent
pInputEmulateTouchFromMouseEvent :: PInputEmulateTouchFromMouseEventType
-> Int
-> Int
-> InputMouseButton
-> PInputEmulateTouchFromMouseEvent
pInputEmulateTouchFromMouseEvent
  PInputEmulateTouchFromMouseEventType
arg_pInputEmulateTouchFromMouseEventType
  Int
arg_pInputEmulateTouchFromMouseEventX
  Int
arg_pInputEmulateTouchFromMouseEventY
  InputMouseButton
arg_pInputEmulateTouchFromMouseEventButton
  = PInputEmulateTouchFromMouseEventType
-> Int
-> Int
-> InputMouseButton
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> Maybe Int
-> PInputEmulateTouchFromMouseEvent
PInputEmulateTouchFromMouseEvent
    PInputEmulateTouchFromMouseEventType
arg_pInputEmulateTouchFromMouseEventType
    Int
arg_pInputEmulateTouchFromMouseEventX
    Int
arg_pInputEmulateTouchFromMouseEventY
    InputMouseButton
arg_pInputEmulateTouchFromMouseEventButton
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
instance ToJSON PInputEmulateTouchFromMouseEvent where
  toJSON :: PInputEmulateTouchFromMouseEvent -> Value
toJSON PInputEmulateTouchFromMouseEvent
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"type" Text -> PInputEmulateTouchFromMouseEventType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (PInputEmulateTouchFromMouseEventType -> Pair)
-> Maybe PInputEmulateTouchFromMouseEventType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PInputEmulateTouchFromMouseEventType
-> Maybe PInputEmulateTouchFromMouseEventType
forall a. a -> Maybe a
Just (PInputEmulateTouchFromMouseEvent
-> PInputEmulateTouchFromMouseEventType
pInputEmulateTouchFromMouseEventType PInputEmulateTouchFromMouseEvent
p),
    (Text
"x" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (PInputEmulateTouchFromMouseEvent -> Int
pInputEmulateTouchFromMouseEventX PInputEmulateTouchFromMouseEvent
p),
    (Text
"y" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (PInputEmulateTouchFromMouseEvent -> Int
pInputEmulateTouchFromMouseEventY PInputEmulateTouchFromMouseEvent
p),
    (Text
"button" Text -> InputMouseButton -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputMouseButton -> Pair) -> Maybe InputMouseButton -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InputMouseButton -> Maybe InputMouseButton
forall a. a -> Maybe a
Just (PInputEmulateTouchFromMouseEvent -> InputMouseButton
pInputEmulateTouchFromMouseEventButton PInputEmulateTouchFromMouseEvent
p),
    (Text
"timestamp" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventTimestamp PInputEmulateTouchFromMouseEvent
p),
    (Text
"deltaX" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventDeltaX PInputEmulateTouchFromMouseEvent
p),
    (Text
"deltaY" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputEmulateTouchFromMouseEvent -> Maybe Double
pInputEmulateTouchFromMouseEventDeltaY PInputEmulateTouchFromMouseEvent
p),
    (Text
"modifiers" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputEmulateTouchFromMouseEvent -> Maybe Int
pInputEmulateTouchFromMouseEventModifiers PInputEmulateTouchFromMouseEvent
p),
    (Text
"clickCount" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputEmulateTouchFromMouseEvent -> Maybe Int
pInputEmulateTouchFromMouseEventClickCount PInputEmulateTouchFromMouseEvent
p)
    ]
instance Command PInputEmulateTouchFromMouseEvent where
  type CommandResponse PInputEmulateTouchFromMouseEvent = ()
  commandName :: Proxy PInputEmulateTouchFromMouseEvent -> String
commandName Proxy PInputEmulateTouchFromMouseEvent
_ = String
"Input.emulateTouchFromMouseEvent"
  fromJSON :: Proxy PInputEmulateTouchFromMouseEvent
-> Value
-> Result (CommandResponse PInputEmulateTouchFromMouseEvent)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputEmulateTouchFromMouseEvent -> Result ())
-> Proxy PInputEmulateTouchFromMouseEvent
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputEmulateTouchFromMouseEvent -> ())
-> Proxy PInputEmulateTouchFromMouseEvent
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputEmulateTouchFromMouseEvent -> ()
forall a b. a -> b -> a
const ()

-- | Ignores input events (useful while auditing page).

-- | Parameters of the 'Input.setIgnoreInputEvents' command.
data PInputSetIgnoreInputEvents = PInputSetIgnoreInputEvents
  {
    -- | Ignores input events processing when set to true.
    PInputSetIgnoreInputEvents -> Bool
pInputSetIgnoreInputEventsIgnore :: Bool
  }
  deriving (PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool
(PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool)
-> (PInputSetIgnoreInputEvents
    -> PInputSetIgnoreInputEvents -> Bool)
-> Eq PInputSetIgnoreInputEvents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool
$c/= :: PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool
== :: PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool
$c== :: PInputSetIgnoreInputEvents -> PInputSetIgnoreInputEvents -> Bool
Eq, Int -> PInputSetIgnoreInputEvents -> ShowS
[PInputSetIgnoreInputEvents] -> ShowS
PInputSetIgnoreInputEvents -> String
(Int -> PInputSetIgnoreInputEvents -> ShowS)
-> (PInputSetIgnoreInputEvents -> String)
-> ([PInputSetIgnoreInputEvents] -> ShowS)
-> Show PInputSetIgnoreInputEvents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputSetIgnoreInputEvents] -> ShowS
$cshowList :: [PInputSetIgnoreInputEvents] -> ShowS
show :: PInputSetIgnoreInputEvents -> String
$cshow :: PInputSetIgnoreInputEvents -> String
showsPrec :: Int -> PInputSetIgnoreInputEvents -> ShowS
$cshowsPrec :: Int -> PInputSetIgnoreInputEvents -> ShowS
Show)
pInputSetIgnoreInputEvents
  {-
  -- | Ignores input events processing when set to true.
  -}
  :: Bool
  -> PInputSetIgnoreInputEvents
pInputSetIgnoreInputEvents :: Bool -> PInputSetIgnoreInputEvents
pInputSetIgnoreInputEvents
  Bool
arg_pInputSetIgnoreInputEventsIgnore
  = Bool -> PInputSetIgnoreInputEvents
PInputSetIgnoreInputEvents
    Bool
arg_pInputSetIgnoreInputEventsIgnore
instance ToJSON PInputSetIgnoreInputEvents where
  toJSON :: PInputSetIgnoreInputEvents -> Value
toJSON PInputSetIgnoreInputEvents
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"ignore" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Maybe Bool
forall a. a -> Maybe a
Just (PInputSetIgnoreInputEvents -> Bool
pInputSetIgnoreInputEventsIgnore PInputSetIgnoreInputEvents
p)
    ]
instance Command PInputSetIgnoreInputEvents where
  type CommandResponse PInputSetIgnoreInputEvents = ()
  commandName :: Proxy PInputSetIgnoreInputEvents -> String
commandName Proxy PInputSetIgnoreInputEvents
_ = String
"Input.setIgnoreInputEvents"
  fromJSON :: Proxy PInputSetIgnoreInputEvents
-> Value -> Result (CommandResponse PInputSetIgnoreInputEvents)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputSetIgnoreInputEvents -> Result ())
-> Proxy PInputSetIgnoreInputEvents
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputSetIgnoreInputEvents -> ())
-> Proxy PInputSetIgnoreInputEvents
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputSetIgnoreInputEvents -> ()
forall a b. a -> b -> a
const ()

-- | Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.
--   Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.

-- | Parameters of the 'Input.setInterceptDrags' command.
data PInputSetInterceptDrags = PInputSetInterceptDrags
  {
    PInputSetInterceptDrags -> Bool
pInputSetInterceptDragsEnabled :: Bool
  }
  deriving (PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool
(PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool)
-> (PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool)
-> Eq PInputSetInterceptDrags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool
$c/= :: PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool
== :: PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool
$c== :: PInputSetInterceptDrags -> PInputSetInterceptDrags -> Bool
Eq, Int -> PInputSetInterceptDrags -> ShowS
[PInputSetInterceptDrags] -> ShowS
PInputSetInterceptDrags -> String
(Int -> PInputSetInterceptDrags -> ShowS)
-> (PInputSetInterceptDrags -> String)
-> ([PInputSetInterceptDrags] -> ShowS)
-> Show PInputSetInterceptDrags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputSetInterceptDrags] -> ShowS
$cshowList :: [PInputSetInterceptDrags] -> ShowS
show :: PInputSetInterceptDrags -> String
$cshow :: PInputSetInterceptDrags -> String
showsPrec :: Int -> PInputSetInterceptDrags -> ShowS
$cshowsPrec :: Int -> PInputSetInterceptDrags -> ShowS
Show)
pInputSetInterceptDrags
  :: Bool
  -> PInputSetInterceptDrags
pInputSetInterceptDrags :: Bool -> PInputSetInterceptDrags
pInputSetInterceptDrags
  Bool
arg_pInputSetInterceptDragsEnabled
  = Bool -> PInputSetInterceptDrags
PInputSetInterceptDrags
    Bool
arg_pInputSetInterceptDragsEnabled
instance ToJSON PInputSetInterceptDrags where
  toJSON :: PInputSetInterceptDrags -> Value
toJSON PInputSetInterceptDrags
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"enabled" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Maybe Bool
forall a. a -> Maybe a
Just (PInputSetInterceptDrags -> Bool
pInputSetInterceptDragsEnabled PInputSetInterceptDrags
p)
    ]
instance Command PInputSetInterceptDrags where
  type CommandResponse PInputSetInterceptDrags = ()
  commandName :: Proxy PInputSetInterceptDrags -> String
commandName Proxy PInputSetInterceptDrags
_ = String
"Input.setInterceptDrags"
  fromJSON :: Proxy PInputSetInterceptDrags
-> Value -> Result (CommandResponse PInputSetInterceptDrags)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputSetInterceptDrags -> Result ())
-> Proxy PInputSetInterceptDrags
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputSetInterceptDrags -> ())
-> Proxy PInputSetInterceptDrags
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputSetInterceptDrags -> ()
forall a b. a -> b -> a
const ()

-- | Synthesizes a pinch gesture over a time period by issuing appropriate touch events.

-- | Parameters of the 'Input.synthesizePinchGesture' command.
data PInputSynthesizePinchGesture = PInputSynthesizePinchGesture
  {
    -- | X coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureX :: Double,
    -- | Y coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureY :: Double,
    -- | Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
    PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureScaleFactor :: Double,
    -- | Relative pointer speed in pixels per second (default: 800).
    PInputSynthesizePinchGesture -> Maybe Int
pInputSynthesizePinchGestureRelativeSpeed :: Maybe Int,
    -- | Which type of input events to be generated (default: 'default', which queries the platform
    --   for the preferred input type).
    PInputSynthesizePinchGesture -> Maybe InputGestureSourceType
pInputSynthesizePinchGestureGestureSourceType :: Maybe InputGestureSourceType
  }
  deriving (PInputSynthesizePinchGesture
-> PInputSynthesizePinchGesture -> Bool
(PInputSynthesizePinchGesture
 -> PInputSynthesizePinchGesture -> Bool)
-> (PInputSynthesizePinchGesture
    -> PInputSynthesizePinchGesture -> Bool)
-> Eq PInputSynthesizePinchGesture
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputSynthesizePinchGesture
-> PInputSynthesizePinchGesture -> Bool
$c/= :: PInputSynthesizePinchGesture
-> PInputSynthesizePinchGesture -> Bool
== :: PInputSynthesizePinchGesture
-> PInputSynthesizePinchGesture -> Bool
$c== :: PInputSynthesizePinchGesture
-> PInputSynthesizePinchGesture -> Bool
Eq, Int -> PInputSynthesizePinchGesture -> ShowS
[PInputSynthesizePinchGesture] -> ShowS
PInputSynthesizePinchGesture -> String
(Int -> PInputSynthesizePinchGesture -> ShowS)
-> (PInputSynthesizePinchGesture -> String)
-> ([PInputSynthesizePinchGesture] -> ShowS)
-> Show PInputSynthesizePinchGesture
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputSynthesizePinchGesture] -> ShowS
$cshowList :: [PInputSynthesizePinchGesture] -> ShowS
show :: PInputSynthesizePinchGesture -> String
$cshow :: PInputSynthesizePinchGesture -> String
showsPrec :: Int -> PInputSynthesizePinchGesture -> ShowS
$cshowsPrec :: Int -> PInputSynthesizePinchGesture -> ShowS
Show)
pInputSynthesizePinchGesture
  {-
  -- | X coordinate of the start of the gesture in CSS pixels.
  -}
  :: Double
  {-
  -- | Y coordinate of the start of the gesture in CSS pixels.
  -}
  -> Double
  {-
  -- | Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
  -}
  -> Double
  -> PInputSynthesizePinchGesture
pInputSynthesizePinchGesture :: Double -> Double -> Double -> PInputSynthesizePinchGesture
pInputSynthesizePinchGesture
  Double
arg_pInputSynthesizePinchGestureX
  Double
arg_pInputSynthesizePinchGestureY
  Double
arg_pInputSynthesizePinchGestureScaleFactor
  = Double
-> Double
-> Double
-> Maybe Int
-> Maybe InputGestureSourceType
-> PInputSynthesizePinchGesture
PInputSynthesizePinchGesture
    Double
arg_pInputSynthesizePinchGestureX
    Double
arg_pInputSynthesizePinchGestureY
    Double
arg_pInputSynthesizePinchGestureScaleFactor
    Maybe Int
forall a. Maybe a
Nothing
    Maybe InputGestureSourceType
forall a. Maybe a
Nothing
instance ToJSON PInputSynthesizePinchGesture where
  toJSON :: PInputSynthesizePinchGesture -> Value
toJSON PInputSynthesizePinchGesture
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureX PInputSynthesizePinchGesture
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureY PInputSynthesizePinchGesture
p),
    (Text
"scaleFactor" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizePinchGesture -> Double
pInputSynthesizePinchGestureScaleFactor PInputSynthesizePinchGesture
p),
    (Text
"relativeSpeed" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizePinchGesture -> Maybe Int
pInputSynthesizePinchGestureRelativeSpeed PInputSynthesizePinchGesture
p),
    (Text
"gestureSourceType" Text -> InputGestureSourceType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputGestureSourceType -> Pair)
-> Maybe InputGestureSourceType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizePinchGesture -> Maybe InputGestureSourceType
pInputSynthesizePinchGestureGestureSourceType PInputSynthesizePinchGesture
p)
    ]
instance Command PInputSynthesizePinchGesture where
  type CommandResponse PInputSynthesizePinchGesture = ()
  commandName :: Proxy PInputSynthesizePinchGesture -> String
commandName Proxy PInputSynthesizePinchGesture
_ = String
"Input.synthesizePinchGesture"
  fromJSON :: Proxy PInputSynthesizePinchGesture
-> Value -> Result (CommandResponse PInputSynthesizePinchGesture)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputSynthesizePinchGesture -> Result ())
-> Proxy PInputSynthesizePinchGesture
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputSynthesizePinchGesture -> ())
-> Proxy PInputSynthesizePinchGesture
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputSynthesizePinchGesture -> ()
forall a b. a -> b -> a
const ()

-- | Synthesizes a scroll gesture over a time period by issuing appropriate touch events.

-- | Parameters of the 'Input.synthesizeScrollGesture' command.
data PInputSynthesizeScrollGesture = PInputSynthesizeScrollGesture
  {
    -- | X coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizeScrollGesture -> Double
pInputSynthesizeScrollGestureX :: Double,
    -- | Y coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizeScrollGesture -> Double
pInputSynthesizeScrollGestureY :: Double,
    -- | The distance to scroll along the X axis (positive to scroll left).
    PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureXDistance :: Maybe Double,
    -- | The distance to scroll along the Y axis (positive to scroll up).
    PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureYDistance :: Maybe Double,
    -- | The number of additional pixels to scroll back along the X axis, in addition to the given
    --   distance.
    PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureXOverscroll :: Maybe Double,
    -- | The number of additional pixels to scroll back along the Y axis, in addition to the given
    --   distance.
    PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureYOverscroll :: Maybe Double,
    -- | Prevent fling (default: true).
    PInputSynthesizeScrollGesture -> Maybe Bool
pInputSynthesizeScrollGesturePreventFling :: Maybe Bool,
    -- | Swipe speed in pixels per second (default: 800).
    PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureSpeed :: Maybe Int,
    -- | Which type of input events to be generated (default: 'default', which queries the platform
    --   for the preferred input type).
    PInputSynthesizeScrollGesture -> Maybe InputGestureSourceType
pInputSynthesizeScrollGestureGestureSourceType :: Maybe InputGestureSourceType,
    -- | The number of times to repeat the gesture (default: 0).
    PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureRepeatCount :: Maybe Int,
    -- | The number of milliseconds delay between each repeat. (default: 250).
    PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureRepeatDelayMs :: Maybe Int,
    -- | The name of the interaction markers to generate, if not empty (default: "").
    PInputSynthesizeScrollGesture -> Maybe Text
pInputSynthesizeScrollGestureInteractionMarkerName :: Maybe T.Text
  }
  deriving (PInputSynthesizeScrollGesture
-> PInputSynthesizeScrollGesture -> Bool
(PInputSynthesizeScrollGesture
 -> PInputSynthesizeScrollGesture -> Bool)
-> (PInputSynthesizeScrollGesture
    -> PInputSynthesizeScrollGesture -> Bool)
-> Eq PInputSynthesizeScrollGesture
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputSynthesizeScrollGesture
-> PInputSynthesizeScrollGesture -> Bool
$c/= :: PInputSynthesizeScrollGesture
-> PInputSynthesizeScrollGesture -> Bool
== :: PInputSynthesizeScrollGesture
-> PInputSynthesizeScrollGesture -> Bool
$c== :: PInputSynthesizeScrollGesture
-> PInputSynthesizeScrollGesture -> Bool
Eq, Int -> PInputSynthesizeScrollGesture -> ShowS
[PInputSynthesizeScrollGesture] -> ShowS
PInputSynthesizeScrollGesture -> String
(Int -> PInputSynthesizeScrollGesture -> ShowS)
-> (PInputSynthesizeScrollGesture -> String)
-> ([PInputSynthesizeScrollGesture] -> ShowS)
-> Show PInputSynthesizeScrollGesture
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputSynthesizeScrollGesture] -> ShowS
$cshowList :: [PInputSynthesizeScrollGesture] -> ShowS
show :: PInputSynthesizeScrollGesture -> String
$cshow :: PInputSynthesizeScrollGesture -> String
showsPrec :: Int -> PInputSynthesizeScrollGesture -> ShowS
$cshowsPrec :: Int -> PInputSynthesizeScrollGesture -> ShowS
Show)
pInputSynthesizeScrollGesture
  {-
  -- | X coordinate of the start of the gesture in CSS pixels.
  -}
  :: Double
  {-
  -- | Y coordinate of the start of the gesture in CSS pixels.
  -}
  -> Double
  -> PInputSynthesizeScrollGesture
pInputSynthesizeScrollGesture :: Double -> Double -> PInputSynthesizeScrollGesture
pInputSynthesizeScrollGesture
  Double
arg_pInputSynthesizeScrollGestureX
  Double
arg_pInputSynthesizeScrollGestureY
  = Double
-> Double
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Double
-> Maybe Bool
-> Maybe Int
-> Maybe InputGestureSourceType
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> PInputSynthesizeScrollGesture
PInputSynthesizeScrollGesture
    Double
arg_pInputSynthesizeScrollGestureX
    Double
arg_pInputSynthesizeScrollGestureY
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Double
forall a. Maybe a
Nothing
    Maybe Bool
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe InputGestureSourceType
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Text
forall a. Maybe a
Nothing
instance ToJSON PInputSynthesizeScrollGesture where
  toJSON :: PInputSynthesizeScrollGesture -> Value
toJSON PInputSynthesizeScrollGesture
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizeScrollGesture -> Double
pInputSynthesizeScrollGestureX PInputSynthesizeScrollGesture
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizeScrollGesture -> Double
pInputSynthesizeScrollGestureY PInputSynthesizeScrollGesture
p),
    (Text
"xDistance" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureXDistance PInputSynthesizeScrollGesture
p),
    (Text
"yDistance" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureYDistance PInputSynthesizeScrollGesture
p),
    (Text
"xOverscroll" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureXOverscroll PInputSynthesizeScrollGesture
p),
    (Text
"yOverscroll" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Double
pInputSynthesizeScrollGestureYOverscroll PInputSynthesizeScrollGesture
p),
    (Text
"preventFling" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Bool
pInputSynthesizeScrollGesturePreventFling PInputSynthesizeScrollGesture
p),
    (Text
"speed" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureSpeed PInputSynthesizeScrollGesture
p),
    (Text
"gestureSourceType" Text -> InputGestureSourceType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputGestureSourceType -> Pair)
-> Maybe InputGestureSourceType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe InputGestureSourceType
pInputSynthesizeScrollGestureGestureSourceType PInputSynthesizeScrollGesture
p),
    (Text
"repeatCount" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureRepeatCount PInputSynthesizeScrollGesture
p),
    (Text
"repeatDelayMs" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Int
pInputSynthesizeScrollGestureRepeatDelayMs PInputSynthesizeScrollGesture
p),
    (Text
"interactionMarkerName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeScrollGesture -> Maybe Text
pInputSynthesizeScrollGestureInteractionMarkerName PInputSynthesizeScrollGesture
p)
    ]
instance Command PInputSynthesizeScrollGesture where
  type CommandResponse PInputSynthesizeScrollGesture = ()
  commandName :: Proxy PInputSynthesizeScrollGesture -> String
commandName Proxy PInputSynthesizeScrollGesture
_ = String
"Input.synthesizeScrollGesture"
  fromJSON :: Proxy PInputSynthesizeScrollGesture
-> Value -> Result (CommandResponse PInputSynthesizeScrollGesture)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputSynthesizeScrollGesture -> Result ())
-> Proxy PInputSynthesizeScrollGesture
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputSynthesizeScrollGesture -> ())
-> Proxy PInputSynthesizeScrollGesture
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputSynthesizeScrollGesture -> ()
forall a b. a -> b -> a
const ()

-- | Synthesizes a tap gesture over a time period by issuing appropriate touch events.

-- | Parameters of the 'Input.synthesizeTapGesture' command.
data PInputSynthesizeTapGesture = PInputSynthesizeTapGesture
  {
    -- | X coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizeTapGesture -> Double
pInputSynthesizeTapGestureX :: Double,
    -- | Y coordinate of the start of the gesture in CSS pixels.
    PInputSynthesizeTapGesture -> Double
pInputSynthesizeTapGestureY :: Double,
    -- | Duration between touchdown and touchup events in ms (default: 50).
    PInputSynthesizeTapGesture -> Maybe Int
pInputSynthesizeTapGestureDuration :: Maybe Int,
    -- | Number of times to perform the tap (e.g. 2 for double tap, default: 1).
    PInputSynthesizeTapGesture -> Maybe Int
pInputSynthesizeTapGestureTapCount :: Maybe Int,
    -- | Which type of input events to be generated (default: 'default', which queries the platform
    --   for the preferred input type).
    PInputSynthesizeTapGesture -> Maybe InputGestureSourceType
pInputSynthesizeTapGestureGestureSourceType :: Maybe InputGestureSourceType
  }
  deriving (PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool
(PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool)
-> (PInputSynthesizeTapGesture
    -> PInputSynthesizeTapGesture -> Bool)
-> Eq PInputSynthesizeTapGesture
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool
$c/= :: PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool
== :: PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool
$c== :: PInputSynthesizeTapGesture -> PInputSynthesizeTapGesture -> Bool
Eq, Int -> PInputSynthesizeTapGesture -> ShowS
[PInputSynthesizeTapGesture] -> ShowS
PInputSynthesizeTapGesture -> String
(Int -> PInputSynthesizeTapGesture -> ShowS)
-> (PInputSynthesizeTapGesture -> String)
-> ([PInputSynthesizeTapGesture] -> ShowS)
-> Show PInputSynthesizeTapGesture
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PInputSynthesizeTapGesture] -> ShowS
$cshowList :: [PInputSynthesizeTapGesture] -> ShowS
show :: PInputSynthesizeTapGesture -> String
$cshow :: PInputSynthesizeTapGesture -> String
showsPrec :: Int -> PInputSynthesizeTapGesture -> ShowS
$cshowsPrec :: Int -> PInputSynthesizeTapGesture -> ShowS
Show)
pInputSynthesizeTapGesture
  {-
  -- | X coordinate of the start of the gesture in CSS pixels.
  -}
  :: Double
  {-
  -- | Y coordinate of the start of the gesture in CSS pixels.
  -}
  -> Double
  -> PInputSynthesizeTapGesture
pInputSynthesizeTapGesture :: Double -> Double -> PInputSynthesizeTapGesture
pInputSynthesizeTapGesture
  Double
arg_pInputSynthesizeTapGestureX
  Double
arg_pInputSynthesizeTapGestureY
  = Double
-> Double
-> Maybe Int
-> Maybe Int
-> Maybe InputGestureSourceType
-> PInputSynthesizeTapGesture
PInputSynthesizeTapGesture
    Double
arg_pInputSynthesizeTapGestureX
    Double
arg_pInputSynthesizeTapGestureY
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe InputGestureSourceType
forall a. Maybe a
Nothing
instance ToJSON PInputSynthesizeTapGesture where
  toJSON :: PInputSynthesizeTapGesture -> Value
toJSON PInputSynthesizeTapGesture
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"x" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizeTapGesture -> Double
pInputSynthesizeTapGestureX PInputSynthesizeTapGesture
p),
    (Text
"y" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Maybe Double
forall a. a -> Maybe a
Just (PInputSynthesizeTapGesture -> Double
pInputSynthesizeTapGestureY PInputSynthesizeTapGesture
p),
    (Text
"duration" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeTapGesture -> Maybe Int
pInputSynthesizeTapGestureDuration PInputSynthesizeTapGesture
p),
    (Text
"tapCount" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeTapGesture -> Maybe Int
pInputSynthesizeTapGestureTapCount PInputSynthesizeTapGesture
p),
    (Text
"gestureSourceType" Text -> InputGestureSourceType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (InputGestureSourceType -> Pair)
-> Maybe InputGestureSourceType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PInputSynthesizeTapGesture -> Maybe InputGestureSourceType
pInputSynthesizeTapGestureGestureSourceType PInputSynthesizeTapGesture
p)
    ]
instance Command PInputSynthesizeTapGesture where
  type CommandResponse PInputSynthesizeTapGesture = ()
  commandName :: Proxy PInputSynthesizeTapGesture -> String
commandName Proxy PInputSynthesizeTapGesture
_ = String
"Input.synthesizeTapGesture"
  fromJSON :: Proxy PInputSynthesizeTapGesture
-> Value -> Result (CommandResponse PInputSynthesizeTapGesture)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PInputSynthesizeTapGesture -> Result ())
-> Proxy PInputSynthesizeTapGesture
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PInputSynthesizeTapGesture -> ())
-> Proxy PInputSynthesizeTapGesture
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PInputSynthesizeTapGesture -> ()
forall a b. a -> b -> a
const ()