{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell   #-}
module Graphics.Blank.JavaScript where

import           Data.Bits                       (shiftR, (.&.))
import           Data.Char                       (isAscii, isControl, ord)
import           Data.Colour
import           Data.Colour.SRGB
import           Data.Default.Class
import           Data.Ix
import qualified Data.List                       as L
import           Data.String
import           Data.Text                       (Text)
import qualified Data.Text.Lazy                  as TL
import qualified Data.Text.Lazy.Builder          as B (singleton)
import           Data.Vector.Unboxed             (Vector, toList)
import qualified Data.Vector.Unboxed             as V
import           Data.Word                       (Word8)

import           Graphics.Blank.Parser

import           Prelude.Compat

import           Text.ParserCombinators.ReadP    (choice, skipSpaces)
import           Text.ParserCombinators.ReadPrec (lift)
import           Text.Read                       (Read (..), parens,
                                                  readListPrecDefault)

import           Numeric                         (showHex)
import           TextShow
import           TextShow.Data.Floating          (showbFFloat)
import           TextShow.Data.Integral          (showbHex)
import           TextShow.TH                     (deriveTextShow)

-------------------------------------------------------------

-- | A handle to an offscreen canvas. 'CanvasContext' cannot be destroyed.
data CanvasContext = CanvasContext Int Int Int deriving (CanvasContext -> CanvasContext -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanvasContext -> CanvasContext -> Bool
$c/= :: CanvasContext -> CanvasContext -> Bool
== :: CanvasContext -> CanvasContext -> Bool
$c== :: CanvasContext -> CanvasContext -> Bool
Eq, Eq CanvasContext
CanvasContext -> CanvasContext -> Bool
CanvasContext -> CanvasContext -> Ordering
CanvasContext -> CanvasContext -> CanvasContext
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 :: CanvasContext -> CanvasContext -> CanvasContext
$cmin :: CanvasContext -> CanvasContext -> CanvasContext
max :: CanvasContext -> CanvasContext -> CanvasContext
$cmax :: CanvasContext -> CanvasContext -> CanvasContext
>= :: CanvasContext -> CanvasContext -> Bool
$c>= :: CanvasContext -> CanvasContext -> Bool
> :: CanvasContext -> CanvasContext -> Bool
$c> :: CanvasContext -> CanvasContext -> Bool
<= :: CanvasContext -> CanvasContext -> Bool
$c<= :: CanvasContext -> CanvasContext -> Bool
< :: CanvasContext -> CanvasContext -> Bool
$c< :: CanvasContext -> CanvasContext -> Bool
compare :: CanvasContext -> CanvasContext -> Ordering
$ccompare :: CanvasContext -> CanvasContext -> Ordering
Ord, Int -> CanvasContext -> ShowS
[CanvasContext] -> ShowS
CanvasContext -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanvasContext] -> ShowS
$cshowList :: [CanvasContext] -> ShowS
show :: CanvasContext -> String
$cshow :: CanvasContext -> String
showsPrec :: Int -> CanvasContext -> ShowS
$cshowsPrec :: Int -> CanvasContext -> ShowS
Show)
$(deriveTextShow ''CanvasContext)

-- | A handle to a canvas image. 'CanvasImage's cannot be destroyed.
data CanvasImage = CanvasImage Int Int Int     deriving (CanvasImage -> CanvasImage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanvasImage -> CanvasImage -> Bool
$c/= :: CanvasImage -> CanvasImage -> Bool
== :: CanvasImage -> CanvasImage -> Bool
$c== :: CanvasImage -> CanvasImage -> Bool
Eq, Eq CanvasImage
CanvasImage -> CanvasImage -> Bool
CanvasImage -> CanvasImage -> Ordering
CanvasImage -> CanvasImage -> CanvasImage
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 :: CanvasImage -> CanvasImage -> CanvasImage
$cmin :: CanvasImage -> CanvasImage -> CanvasImage
max :: CanvasImage -> CanvasImage -> CanvasImage
$cmax :: CanvasImage -> CanvasImage -> CanvasImage
>= :: CanvasImage -> CanvasImage -> Bool
$c>= :: CanvasImage -> CanvasImage -> Bool
> :: CanvasImage -> CanvasImage -> Bool
$c> :: CanvasImage -> CanvasImage -> Bool
<= :: CanvasImage -> CanvasImage -> Bool
$c<= :: CanvasImage -> CanvasImage -> Bool
< :: CanvasImage -> CanvasImage -> Bool
$c< :: CanvasImage -> CanvasImage -> Bool
compare :: CanvasImage -> CanvasImage -> Ordering
$ccompare :: CanvasImage -> CanvasImage -> Ordering
Ord, Int -> CanvasImage -> ShowS
[CanvasImage] -> ShowS
CanvasImage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanvasImage] -> ShowS
$cshowList :: [CanvasImage] -> ShowS
show :: CanvasImage -> String
$cshow :: CanvasImage -> String
showsPrec :: Int -> CanvasImage -> ShowS
$cshowsPrec :: Int -> CanvasImage -> ShowS
Show)
$(deriveTextShow ''CanvasImage)

-- | A handle to the a canvas gradient. 'CanvasGradient's cannot be destroyed.
newtype CanvasGradient = CanvasGradient Int    deriving (CanvasGradient -> CanvasGradient -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanvasGradient -> CanvasGradient -> Bool
$c/= :: CanvasGradient -> CanvasGradient -> Bool
== :: CanvasGradient -> CanvasGradient -> Bool
$c== :: CanvasGradient -> CanvasGradient -> Bool
Eq, Eq CanvasGradient
CanvasGradient -> CanvasGradient -> Bool
CanvasGradient -> CanvasGradient -> Ordering
CanvasGradient -> CanvasGradient -> CanvasGradient
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 :: CanvasGradient -> CanvasGradient -> CanvasGradient
$cmin :: CanvasGradient -> CanvasGradient -> CanvasGradient
max :: CanvasGradient -> CanvasGradient -> CanvasGradient
$cmax :: CanvasGradient -> CanvasGradient -> CanvasGradient
>= :: CanvasGradient -> CanvasGradient -> Bool
$c>= :: CanvasGradient -> CanvasGradient -> Bool
> :: CanvasGradient -> CanvasGradient -> Bool
$c> :: CanvasGradient -> CanvasGradient -> Bool
<= :: CanvasGradient -> CanvasGradient -> Bool
$c<= :: CanvasGradient -> CanvasGradient -> Bool
< :: CanvasGradient -> CanvasGradient -> Bool
$c< :: CanvasGradient -> CanvasGradient -> Bool
compare :: CanvasGradient -> CanvasGradient -> Ordering
$ccompare :: CanvasGradient -> CanvasGradient -> Ordering
Ord, Int -> CanvasGradient -> ShowS
[CanvasGradient] -> ShowS
CanvasGradient -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanvasGradient] -> ShowS
$cshowList :: [CanvasGradient] -> ShowS
show :: CanvasGradient -> String
$cshow :: CanvasGradient -> String
showsPrec :: Int -> CanvasGradient -> ShowS
$cshowsPrec :: Int -> CanvasGradient -> ShowS
Show)
$(deriveTextShow ''CanvasGradient)

-- | A handle to a canvas pattern. 'CanvasPattern's cannot be destroyed.
newtype CanvasPattern = CanvasPattern Int      deriving (CanvasPattern -> CanvasPattern -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanvasPattern -> CanvasPattern -> Bool
$c/= :: CanvasPattern -> CanvasPattern -> Bool
== :: CanvasPattern -> CanvasPattern -> Bool
$c== :: CanvasPattern -> CanvasPattern -> Bool
Eq, Eq CanvasPattern
CanvasPattern -> CanvasPattern -> Bool
CanvasPattern -> CanvasPattern -> Ordering
CanvasPattern -> CanvasPattern -> CanvasPattern
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 :: CanvasPattern -> CanvasPattern -> CanvasPattern
$cmin :: CanvasPattern -> CanvasPattern -> CanvasPattern
max :: CanvasPattern -> CanvasPattern -> CanvasPattern
$cmax :: CanvasPattern -> CanvasPattern -> CanvasPattern
>= :: CanvasPattern -> CanvasPattern -> Bool
$c>= :: CanvasPattern -> CanvasPattern -> Bool
> :: CanvasPattern -> CanvasPattern -> Bool
$c> :: CanvasPattern -> CanvasPattern -> Bool
<= :: CanvasPattern -> CanvasPattern -> Bool
$c<= :: CanvasPattern -> CanvasPattern -> Bool
< :: CanvasPattern -> CanvasPattern -> Bool
$c< :: CanvasPattern -> CanvasPattern -> Bool
compare :: CanvasPattern -> CanvasPattern -> Ordering
$ccompare :: CanvasPattern -> CanvasPattern -> Ordering
Ord, Int -> CanvasPattern -> ShowS
[CanvasPattern] -> ShowS
CanvasPattern -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanvasPattern] -> ShowS
$cshowList :: [CanvasPattern] -> ShowS
show :: CanvasPattern -> String
$cshow :: CanvasPattern -> String
showsPrec :: Int -> CanvasPattern -> ShowS
$cshowsPrec :: Int -> CanvasPattern -> ShowS
Show)
$(deriveTextShow ''CanvasPattern)

-- | A handle to a canvas audio. 'CanvasAudio's cannot be destroyed.
data CanvasAudio = CanvasAudio !Int !Double    deriving (CanvasAudio -> CanvasAudio -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanvasAudio -> CanvasAudio -> Bool
$c/= :: CanvasAudio -> CanvasAudio -> Bool
== :: CanvasAudio -> CanvasAudio -> Bool
$c== :: CanvasAudio -> CanvasAudio -> Bool
Eq, Eq CanvasAudio
CanvasAudio -> CanvasAudio -> Bool
CanvasAudio -> CanvasAudio -> Ordering
CanvasAudio -> CanvasAudio -> CanvasAudio
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 :: CanvasAudio -> CanvasAudio -> CanvasAudio
$cmin :: CanvasAudio -> CanvasAudio -> CanvasAudio
max :: CanvasAudio -> CanvasAudio -> CanvasAudio
$cmax :: CanvasAudio -> CanvasAudio -> CanvasAudio
>= :: CanvasAudio -> CanvasAudio -> Bool
$c>= :: CanvasAudio -> CanvasAudio -> Bool
> :: CanvasAudio -> CanvasAudio -> Bool
$c> :: CanvasAudio -> CanvasAudio -> Bool
<= :: CanvasAudio -> CanvasAudio -> Bool
$c<= :: CanvasAudio -> CanvasAudio -> Bool
< :: CanvasAudio -> CanvasAudio -> Bool
$c< :: CanvasAudio -> CanvasAudio -> Bool
compare :: CanvasAudio -> CanvasAudio -> Ordering
$ccompare :: CanvasAudio -> CanvasAudio -> Ordering
Ord, Int -> CanvasAudio -> ShowS
[CanvasAudio] -> ShowS
CanvasAudio -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanvasAudio] -> ShowS
$cshowList :: [CanvasAudio] -> ShowS
show :: CanvasAudio -> String
$cshow :: CanvasAudio -> String
showsPrec :: Int -> CanvasAudio -> ShowS
$cshowsPrec :: Int -> CanvasAudio -> ShowS
Show)
$(deriveTextShow ''CanvasAudio)

-------------------------------------------------------------

-- | 'ImageData' is a transliteration of JavaScript's
-- @<https://developer.mozilla.org/en-US/docs/Web/API/ImageData ImageData>@.
-- 'ImageData' consists of two 'Int's and one (unboxed) 'Vector' of 'Word8's.
-- @width@, @height@, and @data@ can be projected from 'ImageData',
-- 'Vector.length' can be used to find the @data@ length.
--
-- Note: 'ImageData' lives on the server, not the client.

data ImageData = ImageData !Int !Int !(Vector Word8) deriving (ImageData -> ImageData -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImageData -> ImageData -> Bool
$c/= :: ImageData -> ImageData -> Bool
== :: ImageData -> ImageData -> Bool
$c== :: ImageData -> ImageData -> Bool
Eq, Eq ImageData
ImageData -> ImageData -> Bool
ImageData -> ImageData -> Ordering
ImageData -> ImageData -> ImageData
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 :: ImageData -> ImageData -> ImageData
$cmin :: ImageData -> ImageData -> ImageData
max :: ImageData -> ImageData -> ImageData
$cmax :: ImageData -> ImageData -> ImageData
>= :: ImageData -> ImageData -> Bool
$c>= :: ImageData -> ImageData -> Bool
> :: ImageData -> ImageData -> Bool
$c> :: ImageData -> ImageData -> Bool
<= :: ImageData -> ImageData -> Bool
$c<= :: ImageData -> ImageData -> Bool
< :: ImageData -> ImageData -> Bool
$c< :: ImageData -> ImageData -> Bool
compare :: ImageData -> ImageData -> Ordering
$ccompare :: ImageData -> ImageData -> Ordering
Ord, Int -> ImageData -> ShowS
[ImageData] -> ShowS
ImageData -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImageData] -> ShowS
$cshowList :: [ImageData] -> ShowS
show :: ImageData -> String
$cshow :: ImageData -> String
showsPrec :: Int -> ImageData -> ShowS
$cshowsPrec :: Int -> ImageData -> ShowS
Show)

-- Defined manually to avoid an orphan T.Show (Vector a) instance
instance TextShow ImageData where
    showbPrec :: Int -> ImageData -> Builder
showbPrec Int
p (ImageData Int
w Int
h Vector Word8
d) = Bool -> Builder -> Builder
showbParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
10) forall a b. (a -> b) -> a -> b
$
        Builder
"ImageData " forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => Int -> a -> Builder
showbPrec Int
11 Int
w forall a. Semigroup a => a -> a -> a
<> Builder
showbSpace
                     forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => Int -> a -> Builder
showbPrec Int
11 Int
h forall a. Semigroup a => a -> a -> a
<> Builder
showbSpace
                     forall a. Semigroup a => a -> a -> a
<> forall a. (Int -> a -> Builder) -> Builder -> Int -> a -> Builder
showbUnaryWith forall a. TextShow a => Int -> a -> Builder
showbPrec Builder
"fromList" Int
11 (forall a. Unbox a => Vector a -> [a]
toList Vector Word8
d)

-------------------------------------------------------------

-- | Class for JavaScript objects that represent images (including the canvas itself).
class Image a where
    jsImage :: a -> Builder
    width  :: Num b => a -> b
    height :: Num b => a -> b

instance Image CanvasImage where
    jsImage :: CanvasImage -> Builder
jsImage = CanvasImage -> Builder
jsCanvasImage
    width :: forall b. Num b => CanvasImage -> b
width  (CanvasImage Int
_ Int
w Int
_) = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w
    height :: forall b. Num b => CanvasImage -> b
height (CanvasImage Int
_ Int
_ Int
h) = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
h

-- The Image of a canvas is the the canvas context, not the DOM entry, so
-- you need to indirect back to the DOM here.
instance Image CanvasContext where
    jsImage :: CanvasContext -> Builder
jsImage = (forall a. Semigroup a => a -> a -> a
<> Builder
".canvas") forall b c a. (b -> c) -> (a -> b) -> a -> c
. CanvasContext -> Builder
jsCanvasContext
    width :: forall b. Num b => CanvasContext -> b
width  (CanvasContext Int
_ Int
w Int
_) = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w
    height :: forall b. Num b => CanvasContext -> b
height (CanvasContext Int
_ Int
_ Int
h) = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
h

class Audio a where
    jsAudio  :: a -> Builder
    duration :: Fractional b => a -> b

instance Audio CanvasAudio where
  jsAudio :: CanvasAudio -> Builder
jsAudio                    = CanvasAudio -> Builder
jsCanvasAudio
  duration :: forall b. Fractional b => CanvasAudio -> b
duration (CanvasAudio Int
_ Double
d) = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
d

-- instance Element Video  -- Not supported

-----------------------------------------------------------------------------

-- | A data type that can represent a style. That is, something with one or more
-- colors.
class Style a where
    -- | Convert a value into a JavaScript string representing a style value.
    jsStyle :: a -> Builder

instance Style Text                 where { jsStyle :: Text -> Builder
jsStyle = Text -> Builder
jsText }
instance Style CanvasGradient       where { jsStyle :: CanvasGradient -> Builder
jsStyle = CanvasGradient -> Builder
jsCanvasGradient }
instance Style CanvasPattern        where { jsStyle :: CanvasPattern -> Builder
jsStyle = CanvasPattern -> Builder
jsCanvasPattern }
instance Style (Colour Double)      where { jsStyle :: Colour Double -> Builder
jsStyle = Colour Double -> Builder
jsColour }
instance Style (AlphaColour Double) where { jsStyle :: AlphaColour Double -> Builder
jsStyle = AlphaColour Double -> Builder
jsAlphaColour }

-- | A 'Style' containing exactly one color.
class Style a => CanvasColor a

jsCanvasColor :: CanvasColor color => color -> Builder
jsCanvasColor :: forall color. CanvasColor color => color -> Builder
jsCanvasColor = forall a. Style a => a -> Builder
jsStyle

instance CanvasColor Text
instance CanvasColor (Colour Double)
instance CanvasColor (AlphaColour Double)

-------------------------------------------------------------

-- | The direction in which a 'CanvasPattern' repeats.
data RepeatDirection = Repeat   -- ^ The pattern repeats both horizontally
                                --   and vertically (default).
                     | RepeatX  -- ^ The pattern repeats only horizontally.
                     | RepeatY  -- ^ The pattern repeats only vertically.
                     | NoRepeat -- ^ The pattern displays only once and
                                --   does not repeat.
  deriving (RepeatDirection
forall a. a -> a -> Bounded a
maxBound :: RepeatDirection
$cmaxBound :: RepeatDirection
minBound :: RepeatDirection
$cminBound :: RepeatDirection
Bounded, Int -> RepeatDirection
RepeatDirection -> Int
RepeatDirection -> [RepeatDirection]
RepeatDirection -> RepeatDirection
RepeatDirection -> RepeatDirection -> [RepeatDirection]
RepeatDirection
-> RepeatDirection -> RepeatDirection -> [RepeatDirection]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: RepeatDirection
-> RepeatDirection -> RepeatDirection -> [RepeatDirection]
$cenumFromThenTo :: RepeatDirection
-> RepeatDirection -> RepeatDirection -> [RepeatDirection]
enumFromTo :: RepeatDirection -> RepeatDirection -> [RepeatDirection]
$cenumFromTo :: RepeatDirection -> RepeatDirection -> [RepeatDirection]
enumFromThen :: RepeatDirection -> RepeatDirection -> [RepeatDirection]
$cenumFromThen :: RepeatDirection -> RepeatDirection -> [RepeatDirection]
enumFrom :: RepeatDirection -> [RepeatDirection]
$cenumFrom :: RepeatDirection -> [RepeatDirection]
fromEnum :: RepeatDirection -> Int
$cfromEnum :: RepeatDirection -> Int
toEnum :: Int -> RepeatDirection
$ctoEnum :: Int -> RepeatDirection
pred :: RepeatDirection -> RepeatDirection
$cpred :: RepeatDirection -> RepeatDirection
succ :: RepeatDirection -> RepeatDirection
$csucc :: RepeatDirection -> RepeatDirection
Enum, RepeatDirection -> RepeatDirection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatDirection -> RepeatDirection -> Bool
$c/= :: RepeatDirection -> RepeatDirection -> Bool
== :: RepeatDirection -> RepeatDirection -> Bool
$c== :: RepeatDirection -> RepeatDirection -> Bool
Eq, Ord RepeatDirection
(RepeatDirection, RepeatDirection) -> Int
(RepeatDirection, RepeatDirection) -> [RepeatDirection]
(RepeatDirection, RepeatDirection) -> RepeatDirection -> Bool
(RepeatDirection, RepeatDirection) -> RepeatDirection -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (RepeatDirection, RepeatDirection) -> Int
$cunsafeRangeSize :: (RepeatDirection, RepeatDirection) -> Int
rangeSize :: (RepeatDirection, RepeatDirection) -> Int
$crangeSize :: (RepeatDirection, RepeatDirection) -> Int
inRange :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Bool
$cinRange :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Bool
unsafeIndex :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Int
$cunsafeIndex :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Int
index :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Int
$cindex :: (RepeatDirection, RepeatDirection) -> RepeatDirection -> Int
range :: (RepeatDirection, RepeatDirection) -> [RepeatDirection]
$crange :: (RepeatDirection, RepeatDirection) -> [RepeatDirection]
Ix, Eq RepeatDirection
RepeatDirection -> RepeatDirection -> Bool
RepeatDirection -> RepeatDirection -> Ordering
RepeatDirection -> RepeatDirection -> RepeatDirection
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 :: RepeatDirection -> RepeatDirection -> RepeatDirection
$cmin :: RepeatDirection -> RepeatDirection -> RepeatDirection
max :: RepeatDirection -> RepeatDirection -> RepeatDirection
$cmax :: RepeatDirection -> RepeatDirection -> RepeatDirection
>= :: RepeatDirection -> RepeatDirection -> Bool
$c>= :: RepeatDirection -> RepeatDirection -> Bool
> :: RepeatDirection -> RepeatDirection -> Bool
$c> :: RepeatDirection -> RepeatDirection -> Bool
<= :: RepeatDirection -> RepeatDirection -> Bool
$c<= :: RepeatDirection -> RepeatDirection -> Bool
< :: RepeatDirection -> RepeatDirection -> Bool
$c< :: RepeatDirection -> RepeatDirection -> Bool
compare :: RepeatDirection -> RepeatDirection -> Ordering
$ccompare :: RepeatDirection -> RepeatDirection -> Ordering
Ord)

-- | Shorthand for 'Repeat', with an underscore to distinguish it from 'repeat'.
repeat_ :: RepeatDirection
repeat_ :: RepeatDirection
repeat_ = RepeatDirection
Repeat

-- | Shorthand for 'RepeatX'.
repeatX :: RepeatDirection
repeatX :: RepeatDirection
repeatX = RepeatDirection
RepeatX

-- | Shorthand for 'RepeatY'.
repeatY :: RepeatDirection
repeatY :: RepeatDirection
repeatY = RepeatDirection
RepeatY

-- | Shorthand for 'NoRepeat'.
noRepeat :: RepeatDirection
noRepeat :: RepeatDirection
noRepeat = RepeatDirection
NoRepeat

instance Default RepeatDirection where
  def :: RepeatDirection
def = RepeatDirection
Repeat

instance IsString RepeatDirection where
  fromString :: String -> RepeatDirection
fromString = forall a. Read a => String -> a
read

instance Read RepeatDirection where
    readPrec :: ReadPrec RepeatDirection
readPrec = forall a. ReadPrec a -> ReadPrec a
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadP a -> ReadPrec a
lift forall a b. (a -> b) -> a -> b
$ do
        ReadP ()
skipSpaces
        forall a. [ReadP a] -> ReadP a
choice
            [ RepeatDirection
Repeat   forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"repeat"
            , RepeatDirection
RepeatX  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"repeat-x"
            , RepeatDirection
RepeatY  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"repeat-y"
            , RepeatDirection
NoRepeat forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"no-repeat"
            ]
    readListPrec :: ReadPrec [RepeatDirection]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault

instance Show RepeatDirection where
    showsPrec :: Int -> RepeatDirection -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> FromTextShow a
FromTextShow

instance TextShow RepeatDirection where
    showb :: RepeatDirection -> Builder
showb RepeatDirection
Repeat   = Builder
"repeat"
    showb RepeatDirection
RepeatX  = Builder
"repeat-x"
    showb RepeatDirection
RepeatY  = Builder
"repeat-y"
    showb RepeatDirection
NoRepeat = Builder
"no-repeat"

-- | The style of the caps on the endpoints of a line.
data LineEndCap = ButtCap   -- ^ Flat edges (default).
                | RoundCap  -- ^ Semicircular end caps
                | SquareCap -- ^ Square end caps
  deriving (LineEndCap
forall a. a -> a -> Bounded a
maxBound :: LineEndCap
$cmaxBound :: LineEndCap
minBound :: LineEndCap
$cminBound :: LineEndCap
Bounded, Int -> LineEndCap
LineEndCap -> Int
LineEndCap -> [LineEndCap]
LineEndCap -> LineEndCap
LineEndCap -> LineEndCap -> [LineEndCap]
LineEndCap -> LineEndCap -> LineEndCap -> [LineEndCap]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: LineEndCap -> LineEndCap -> LineEndCap -> [LineEndCap]
$cenumFromThenTo :: LineEndCap -> LineEndCap -> LineEndCap -> [LineEndCap]
enumFromTo :: LineEndCap -> LineEndCap -> [LineEndCap]
$cenumFromTo :: LineEndCap -> LineEndCap -> [LineEndCap]
enumFromThen :: LineEndCap -> LineEndCap -> [LineEndCap]
$cenumFromThen :: LineEndCap -> LineEndCap -> [LineEndCap]
enumFrom :: LineEndCap -> [LineEndCap]
$cenumFrom :: LineEndCap -> [LineEndCap]
fromEnum :: LineEndCap -> Int
$cfromEnum :: LineEndCap -> Int
toEnum :: Int -> LineEndCap
$ctoEnum :: Int -> LineEndCap
pred :: LineEndCap -> LineEndCap
$cpred :: LineEndCap -> LineEndCap
succ :: LineEndCap -> LineEndCap
$csucc :: LineEndCap -> LineEndCap
Enum, LineEndCap -> LineEndCap -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineEndCap -> LineEndCap -> Bool
$c/= :: LineEndCap -> LineEndCap -> Bool
== :: LineEndCap -> LineEndCap -> Bool
$c== :: LineEndCap -> LineEndCap -> Bool
Eq, Ord LineEndCap
(LineEndCap, LineEndCap) -> Int
(LineEndCap, LineEndCap) -> [LineEndCap]
(LineEndCap, LineEndCap) -> LineEndCap -> Bool
(LineEndCap, LineEndCap) -> LineEndCap -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (LineEndCap, LineEndCap) -> Int
$cunsafeRangeSize :: (LineEndCap, LineEndCap) -> Int
rangeSize :: (LineEndCap, LineEndCap) -> Int
$crangeSize :: (LineEndCap, LineEndCap) -> Int
inRange :: (LineEndCap, LineEndCap) -> LineEndCap -> Bool
$cinRange :: (LineEndCap, LineEndCap) -> LineEndCap -> Bool
unsafeIndex :: (LineEndCap, LineEndCap) -> LineEndCap -> Int
$cunsafeIndex :: (LineEndCap, LineEndCap) -> LineEndCap -> Int
index :: (LineEndCap, LineEndCap) -> LineEndCap -> Int
$cindex :: (LineEndCap, LineEndCap) -> LineEndCap -> Int
range :: (LineEndCap, LineEndCap) -> [LineEndCap]
$crange :: (LineEndCap, LineEndCap) -> [LineEndCap]
Ix, Eq LineEndCap
LineEndCap -> LineEndCap -> Bool
LineEndCap -> LineEndCap -> Ordering
LineEndCap -> LineEndCap -> LineEndCap
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 :: LineEndCap -> LineEndCap -> LineEndCap
$cmin :: LineEndCap -> LineEndCap -> LineEndCap
max :: LineEndCap -> LineEndCap -> LineEndCap
$cmax :: LineEndCap -> LineEndCap -> LineEndCap
>= :: LineEndCap -> LineEndCap -> Bool
$c>= :: LineEndCap -> LineEndCap -> Bool
> :: LineEndCap -> LineEndCap -> Bool
$c> :: LineEndCap -> LineEndCap -> Bool
<= :: LineEndCap -> LineEndCap -> Bool
$c<= :: LineEndCap -> LineEndCap -> Bool
< :: LineEndCap -> LineEndCap -> Bool
$c< :: LineEndCap -> LineEndCap -> Bool
compare :: LineEndCap -> LineEndCap -> Ordering
$ccompare :: LineEndCap -> LineEndCap -> Ordering
Ord)

-- | Shorthand for 'ButtCap'.
butt :: LineEndCap
butt :: LineEndCap
butt = LineEndCap
ButtCap

-- | Shorthand for 'SquareCap'.
square :: LineEndCap
square :: LineEndCap
square = LineEndCap
SquareCap

instance Default LineEndCap where
    def :: LineEndCap
def = LineEndCap
ButtCap

instance IsString LineEndCap where
    fromString :: String -> LineEndCap
fromString = forall a. Read a => String -> a
read

instance Read LineEndCap where
    readPrec :: ReadPrec LineEndCap
readPrec = forall a. ReadPrec a -> ReadPrec a
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadP a -> ReadPrec a
lift forall a b. (a -> b) -> a -> b
$ do
        ReadP ()
skipSpaces
        forall a. [ReadP a] -> ReadP a
choice
            [ LineEndCap
ButtCap   forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"butt"
            , LineEndCap
RoundCap  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"round"
            , LineEndCap
SquareCap forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"square"
            ]
    readListPrec :: ReadPrec [LineEndCap]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault

instance RoundProperty LineEndCap where
    round_ :: LineEndCap
round_ = LineEndCap
RoundCap

instance Show LineEndCap where
    showsPrec :: Int -> LineEndCap -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> FromTextShow a
FromTextShow

instance TextShow LineEndCap where
    showb :: LineEndCap -> Builder
showb LineEndCap
ButtCap   = Builder
"butt"
    showb LineEndCap
RoundCap  = Builder
"round"
    showb LineEndCap
SquareCap = Builder
"square"

-- | The style of corner that is created when two lines join.
data LineJoinCorner = BevelCorner -- ^ A filled triangle with a beveled edge
                                  --   connects two lines.
                    | RoundCorner -- ^ A filled arc connects two lines.
                    | MiterCorner -- ^ A filled triangle with a sharp edge
                                  --   connects two lines (default).
  deriving (LineJoinCorner
forall a. a -> a -> Bounded a
maxBound :: LineJoinCorner
$cmaxBound :: LineJoinCorner
minBound :: LineJoinCorner
$cminBound :: LineJoinCorner
Bounded, Int -> LineJoinCorner
LineJoinCorner -> Int
LineJoinCorner -> [LineJoinCorner]
LineJoinCorner -> LineJoinCorner
LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
LineJoinCorner
-> LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: LineJoinCorner
-> LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
$cenumFromThenTo :: LineJoinCorner
-> LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
enumFromTo :: LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
$cenumFromTo :: LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
enumFromThen :: LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
$cenumFromThen :: LineJoinCorner -> LineJoinCorner -> [LineJoinCorner]
enumFrom :: LineJoinCorner -> [LineJoinCorner]
$cenumFrom :: LineJoinCorner -> [LineJoinCorner]
fromEnum :: LineJoinCorner -> Int
$cfromEnum :: LineJoinCorner -> Int
toEnum :: Int -> LineJoinCorner
$ctoEnum :: Int -> LineJoinCorner
pred :: LineJoinCorner -> LineJoinCorner
$cpred :: LineJoinCorner -> LineJoinCorner
succ :: LineJoinCorner -> LineJoinCorner
$csucc :: LineJoinCorner -> LineJoinCorner
Enum, LineJoinCorner -> LineJoinCorner -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineJoinCorner -> LineJoinCorner -> Bool
$c/= :: LineJoinCorner -> LineJoinCorner -> Bool
== :: LineJoinCorner -> LineJoinCorner -> Bool
$c== :: LineJoinCorner -> LineJoinCorner -> Bool
Eq, Ord LineJoinCorner
(LineJoinCorner, LineJoinCorner) -> Int
(LineJoinCorner, LineJoinCorner) -> [LineJoinCorner]
(LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Bool
(LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (LineJoinCorner, LineJoinCorner) -> Int
$cunsafeRangeSize :: (LineJoinCorner, LineJoinCorner) -> Int
rangeSize :: (LineJoinCorner, LineJoinCorner) -> Int
$crangeSize :: (LineJoinCorner, LineJoinCorner) -> Int
inRange :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Bool
$cinRange :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Bool
unsafeIndex :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Int
$cunsafeIndex :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Int
index :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Int
$cindex :: (LineJoinCorner, LineJoinCorner) -> LineJoinCorner -> Int
range :: (LineJoinCorner, LineJoinCorner) -> [LineJoinCorner]
$crange :: (LineJoinCorner, LineJoinCorner) -> [LineJoinCorner]
Ix, Eq LineJoinCorner
LineJoinCorner -> LineJoinCorner -> Bool
LineJoinCorner -> LineJoinCorner -> Ordering
LineJoinCorner -> LineJoinCorner -> LineJoinCorner
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 :: LineJoinCorner -> LineJoinCorner -> LineJoinCorner
$cmin :: LineJoinCorner -> LineJoinCorner -> LineJoinCorner
max :: LineJoinCorner -> LineJoinCorner -> LineJoinCorner
$cmax :: LineJoinCorner -> LineJoinCorner -> LineJoinCorner
>= :: LineJoinCorner -> LineJoinCorner -> Bool
$c>= :: LineJoinCorner -> LineJoinCorner -> Bool
> :: LineJoinCorner -> LineJoinCorner -> Bool
$c> :: LineJoinCorner -> LineJoinCorner -> Bool
<= :: LineJoinCorner -> LineJoinCorner -> Bool
$c<= :: LineJoinCorner -> LineJoinCorner -> Bool
< :: LineJoinCorner -> LineJoinCorner -> Bool
$c< :: LineJoinCorner -> LineJoinCorner -> Bool
compare :: LineJoinCorner -> LineJoinCorner -> Ordering
$ccompare :: LineJoinCorner -> LineJoinCorner -> Ordering
Ord)

-- | Shorthand for 'BevelCorner'.
bevel :: LineJoinCorner
bevel :: LineJoinCorner
bevel = LineJoinCorner
BevelCorner

-- | Shorthand for 'MiterCorner'.
miter :: LineJoinCorner
miter :: LineJoinCorner
miter = LineJoinCorner
MiterCorner

instance Default LineJoinCorner where
    def :: LineJoinCorner
def = LineJoinCorner
MiterCorner

instance IsString LineJoinCorner where
    fromString :: String -> LineJoinCorner
fromString = forall a. Read a => String -> a
read

instance Read LineJoinCorner where
    readPrec :: ReadPrec LineJoinCorner
readPrec = forall a. ReadPrec a -> ReadPrec a
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadP a -> ReadPrec a
lift forall a b. (a -> b) -> a -> b
$ do
        ReadP ()
skipSpaces
        forall a. [ReadP a] -> ReadP a
choice
            [ LineJoinCorner
BevelCorner forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"bevel"
            , LineJoinCorner
RoundCorner forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"round"
            , LineJoinCorner
MiterCorner forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"miter"
            ]
    readListPrec :: ReadPrec [LineJoinCorner]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault

instance RoundProperty LineJoinCorner where
    round_ :: LineJoinCorner
round_ = LineJoinCorner
RoundCorner

instance Show LineJoinCorner where
    showsPrec :: Int -> LineJoinCorner -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> FromTextShow a
FromTextShow

instance TextShow LineJoinCorner where
    showb :: LineJoinCorner -> Builder
showb LineJoinCorner
BevelCorner = Builder
"bevel"
    showb LineJoinCorner
RoundCorner = Builder
"round"
    showb LineJoinCorner
MiterCorner = Builder
"miter"

-- | The anchor point for text in the current 'DeviceContext'.
data TextAnchorAlignment = StartAnchor  -- ^ The text is anchored at either its left edge
                                        --   (if the canvas is left-to-right) or its right
                                        --   edge (if the canvas is right-to-left).
                         | EndAnchor    -- ^ The text is anchored at either its right edge
                                        --   (if the canvas is left-to-right) or its left
                                        --   edge (if the canvas is right-to-left).
                         | CenterAnchor -- ^ The text is anchored in its center.
                         | LeftAnchor   -- ^ The text is anchored at its left edge.
                         | RightAnchor  -- ^ the text is anchored at its right edge.
  deriving (TextAnchorAlignment
forall a. a -> a -> Bounded a
maxBound :: TextAnchorAlignment
$cmaxBound :: TextAnchorAlignment
minBound :: TextAnchorAlignment
$cminBound :: TextAnchorAlignment
Bounded, Int -> TextAnchorAlignment
TextAnchorAlignment -> Int
TextAnchorAlignment -> [TextAnchorAlignment]
TextAnchorAlignment -> TextAnchorAlignment
TextAnchorAlignment -> TextAnchorAlignment -> [TextAnchorAlignment]
TextAnchorAlignment
-> TextAnchorAlignment
-> TextAnchorAlignment
-> [TextAnchorAlignment]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: TextAnchorAlignment
-> TextAnchorAlignment
-> TextAnchorAlignment
-> [TextAnchorAlignment]
$cenumFromThenTo :: TextAnchorAlignment
-> TextAnchorAlignment
-> TextAnchorAlignment
-> [TextAnchorAlignment]
enumFromTo :: TextAnchorAlignment -> TextAnchorAlignment -> [TextAnchorAlignment]
$cenumFromTo :: TextAnchorAlignment -> TextAnchorAlignment -> [TextAnchorAlignment]
enumFromThen :: TextAnchorAlignment -> TextAnchorAlignment -> [TextAnchorAlignment]
$cenumFromThen :: TextAnchorAlignment -> TextAnchorAlignment -> [TextAnchorAlignment]
enumFrom :: TextAnchorAlignment -> [TextAnchorAlignment]
$cenumFrom :: TextAnchorAlignment -> [TextAnchorAlignment]
fromEnum :: TextAnchorAlignment -> Int
$cfromEnum :: TextAnchorAlignment -> Int
toEnum :: Int -> TextAnchorAlignment
$ctoEnum :: Int -> TextAnchorAlignment
pred :: TextAnchorAlignment -> TextAnchorAlignment
$cpred :: TextAnchorAlignment -> TextAnchorAlignment
succ :: TextAnchorAlignment -> TextAnchorAlignment
$csucc :: TextAnchorAlignment -> TextAnchorAlignment
Enum, TextAnchorAlignment -> TextAnchorAlignment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c/= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
== :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c== :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
Eq, Ord TextAnchorAlignment
(TextAnchorAlignment, TextAnchorAlignment) -> Int
(TextAnchorAlignment, TextAnchorAlignment) -> [TextAnchorAlignment]
(TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Bool
(TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (TextAnchorAlignment, TextAnchorAlignment) -> Int
$cunsafeRangeSize :: (TextAnchorAlignment, TextAnchorAlignment) -> Int
rangeSize :: (TextAnchorAlignment, TextAnchorAlignment) -> Int
$crangeSize :: (TextAnchorAlignment, TextAnchorAlignment) -> Int
inRange :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Bool
$cinRange :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Bool
unsafeIndex :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Int
$cunsafeIndex :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Int
index :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Int
$cindex :: (TextAnchorAlignment, TextAnchorAlignment)
-> TextAnchorAlignment -> Int
range :: (TextAnchorAlignment, TextAnchorAlignment) -> [TextAnchorAlignment]
$crange :: (TextAnchorAlignment, TextAnchorAlignment) -> [TextAnchorAlignment]
Ix, Eq TextAnchorAlignment
TextAnchorAlignment -> TextAnchorAlignment -> Bool
TextAnchorAlignment -> TextAnchorAlignment -> Ordering
TextAnchorAlignment -> TextAnchorAlignment -> TextAnchorAlignment
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 :: TextAnchorAlignment -> TextAnchorAlignment -> TextAnchorAlignment
$cmin :: TextAnchorAlignment -> TextAnchorAlignment -> TextAnchorAlignment
max :: TextAnchorAlignment -> TextAnchorAlignment -> TextAnchorAlignment
$cmax :: TextAnchorAlignment -> TextAnchorAlignment -> TextAnchorAlignment
>= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c>= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
> :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c> :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
<= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c<= :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
< :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
$c< :: TextAnchorAlignment -> TextAnchorAlignment -> Bool
compare :: TextAnchorAlignment -> TextAnchorAlignment -> Ordering
$ccompare :: TextAnchorAlignment -> TextAnchorAlignment -> Ordering
Ord)

-- | Shorthand for 'StartAnchor'.
start :: TextAnchorAlignment
start :: TextAnchorAlignment
start = TextAnchorAlignment
StartAnchor

-- | Shorthand for 'EndAnchor'.
end :: TextAnchorAlignment
end :: TextAnchorAlignment
end = TextAnchorAlignment
EndAnchor

-- | Shorthand for 'CenterAnchor'.
center :: TextAnchorAlignment
center :: TextAnchorAlignment
center = TextAnchorAlignment
CenterAnchor

-- | Shorthand for 'LeftAnchor'.
left :: TextAnchorAlignment
left :: TextAnchorAlignment
left = TextAnchorAlignment
LeftAnchor

-- | Shorthand for 'RightAnchor'.
right :: TextAnchorAlignment
right :: TextAnchorAlignment
right = TextAnchorAlignment
RightAnchor

instance Default TextAnchorAlignment where
    def :: TextAnchorAlignment
def = TextAnchorAlignment
StartAnchor

instance IsString TextAnchorAlignment where
    fromString :: String -> TextAnchorAlignment
fromString = forall a. Read a => String -> a
read

instance Read TextAnchorAlignment where
    readPrec :: ReadPrec TextAnchorAlignment
readPrec = forall a. ReadPrec a -> ReadPrec a
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadP a -> ReadPrec a
lift forall a b. (a -> b) -> a -> b
$ do
        ReadP ()
skipSpaces
        forall a. [ReadP a] -> ReadP a
choice
            [ TextAnchorAlignment
StartAnchor  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"start"
            , TextAnchorAlignment
EndAnchor    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"end"
            , TextAnchorAlignment
CenterAnchor forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"center"
            , TextAnchorAlignment
LeftAnchor   forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"left"
            , TextAnchorAlignment
RightAnchor  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"right"
            ]
    readListPrec :: ReadPrec [TextAnchorAlignment]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault

instance Show TextAnchorAlignment where
    showsPrec :: Int -> TextAnchorAlignment -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> FromTextShow a
FromTextShow

instance TextShow TextAnchorAlignment where
    showb :: TextAnchorAlignment -> Builder
showb TextAnchorAlignment
StartAnchor  = Builder
"start"
    showb TextAnchorAlignment
EndAnchor    = Builder
"end"
    showb TextAnchorAlignment
CenterAnchor = Builder
"center"
    showb TextAnchorAlignment
LeftAnchor   = Builder
"left"
    showb TextAnchorAlignment
RightAnchor  = Builder
"right"

-- | The baseline alignment used when drawing text in the current 'DeviceContext'.
--   The baselines are ordered from highest ('Top') to lowest ('Bottom').
data TextBaselineAlignment = TopBaseline
                           | HangingBaseline
                           | MiddleBaseline
                           | AlphabeticBaseline
                           | IdeographicBaseline
                           | BottomBaseline
  deriving (TextBaselineAlignment
forall a. a -> a -> Bounded a
maxBound :: TextBaselineAlignment
$cmaxBound :: TextBaselineAlignment
minBound :: TextBaselineAlignment
$cminBound :: TextBaselineAlignment
Bounded, Int -> TextBaselineAlignment
TextBaselineAlignment -> Int
TextBaselineAlignment -> [TextBaselineAlignment]
TextBaselineAlignment -> TextBaselineAlignment
TextBaselineAlignment
-> TextBaselineAlignment -> [TextBaselineAlignment]
TextBaselineAlignment
-> TextBaselineAlignment
-> TextBaselineAlignment
-> [TextBaselineAlignment]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: TextBaselineAlignment
-> TextBaselineAlignment
-> TextBaselineAlignment
-> [TextBaselineAlignment]
$cenumFromThenTo :: TextBaselineAlignment
-> TextBaselineAlignment
-> TextBaselineAlignment
-> [TextBaselineAlignment]
enumFromTo :: TextBaselineAlignment
-> TextBaselineAlignment -> [TextBaselineAlignment]
$cenumFromTo :: TextBaselineAlignment
-> TextBaselineAlignment -> [TextBaselineAlignment]
enumFromThen :: TextBaselineAlignment
-> TextBaselineAlignment -> [TextBaselineAlignment]
$cenumFromThen :: TextBaselineAlignment
-> TextBaselineAlignment -> [TextBaselineAlignment]
enumFrom :: TextBaselineAlignment -> [TextBaselineAlignment]
$cenumFrom :: TextBaselineAlignment -> [TextBaselineAlignment]
fromEnum :: TextBaselineAlignment -> Int
$cfromEnum :: TextBaselineAlignment -> Int
toEnum :: Int -> TextBaselineAlignment
$ctoEnum :: Int -> TextBaselineAlignment
pred :: TextBaselineAlignment -> TextBaselineAlignment
$cpred :: TextBaselineAlignment -> TextBaselineAlignment
succ :: TextBaselineAlignment -> TextBaselineAlignment
$csucc :: TextBaselineAlignment -> TextBaselineAlignment
Enum, TextBaselineAlignment -> TextBaselineAlignment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c/= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
== :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c== :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
Eq, Ord TextBaselineAlignment
(TextBaselineAlignment, TextBaselineAlignment) -> Int
(TextBaselineAlignment, TextBaselineAlignment)
-> [TextBaselineAlignment]
(TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Bool
(TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (TextBaselineAlignment, TextBaselineAlignment) -> Int
$cunsafeRangeSize :: (TextBaselineAlignment, TextBaselineAlignment) -> Int
rangeSize :: (TextBaselineAlignment, TextBaselineAlignment) -> Int
$crangeSize :: (TextBaselineAlignment, TextBaselineAlignment) -> Int
inRange :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Bool
$cinRange :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Bool
unsafeIndex :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Int
$cunsafeIndex :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Int
index :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Int
$cindex :: (TextBaselineAlignment, TextBaselineAlignment)
-> TextBaselineAlignment -> Int
range :: (TextBaselineAlignment, TextBaselineAlignment)
-> [TextBaselineAlignment]
$crange :: (TextBaselineAlignment, TextBaselineAlignment)
-> [TextBaselineAlignment]
Ix, Eq TextBaselineAlignment
TextBaselineAlignment -> TextBaselineAlignment -> Bool
TextBaselineAlignment -> TextBaselineAlignment -> Ordering
TextBaselineAlignment
-> TextBaselineAlignment -> TextBaselineAlignment
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 :: TextBaselineAlignment
-> TextBaselineAlignment -> TextBaselineAlignment
$cmin :: TextBaselineAlignment
-> TextBaselineAlignment -> TextBaselineAlignment
max :: TextBaselineAlignment
-> TextBaselineAlignment -> TextBaselineAlignment
$cmax :: TextBaselineAlignment
-> TextBaselineAlignment -> TextBaselineAlignment
>= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c>= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
> :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c> :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
<= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c<= :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
< :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
$c< :: TextBaselineAlignment -> TextBaselineAlignment -> Bool
compare :: TextBaselineAlignment -> TextBaselineAlignment -> Ordering
$ccompare :: TextBaselineAlignment -> TextBaselineAlignment -> Ordering
Ord)

-- | Shorthand for 'TopBaseline'.
top :: TextBaselineAlignment
top :: TextBaselineAlignment
top = TextBaselineAlignment
TopBaseline

-- | Shorthand for 'HangingBaseline'.
hanging :: TextBaselineAlignment
hanging :: TextBaselineAlignment
hanging = TextBaselineAlignment
HangingBaseline

-- | Shorthand for 'MiddleBaseline'.
middle :: TextBaselineAlignment
middle :: TextBaselineAlignment
middle = TextBaselineAlignment
MiddleBaseline

-- | Shorthand for 'AlphabeticBaseline'.
alphabetic :: TextBaselineAlignment
alphabetic :: TextBaselineAlignment
alphabetic = TextBaselineAlignment
AlphabeticBaseline

-- | Shorthand for 'IdeographicBaseline'.
ideographic :: TextBaselineAlignment
ideographic :: TextBaselineAlignment
ideographic = TextBaselineAlignment
IdeographicBaseline

-- | Shorthand for 'BottomBaseline'.
bottom :: TextBaselineAlignment
bottom :: TextBaselineAlignment
bottom = TextBaselineAlignment
BottomBaseline

instance Default TextBaselineAlignment where
    def :: TextBaselineAlignment
def = TextBaselineAlignment
AlphabeticBaseline

instance IsString TextBaselineAlignment where
    fromString :: String -> TextBaselineAlignment
fromString = forall a. Read a => String -> a
read

instance Read TextBaselineAlignment where
    readPrec :: ReadPrec TextBaselineAlignment
readPrec = forall a. ReadPrec a -> ReadPrec a
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadP a -> ReadPrec a
lift forall a b. (a -> b) -> a -> b
$ do
        ReadP ()
skipSpaces
        forall a. [ReadP a] -> ReadP a
choice
            [ TextBaselineAlignment
TopBaseline         forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"top"
            , TextBaselineAlignment
HangingBaseline     forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"hanging"
            , TextBaselineAlignment
MiddleBaseline      forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"middle"
            , TextBaselineAlignment
AlphabeticBaseline  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"alphabetic"
            , TextBaselineAlignment
IdeographicBaseline forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"ideographic"
            , TextBaselineAlignment
BottomBaseline      forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> ReadP String
stringCI String
"bottom"
            ]
    readListPrec :: ReadPrec [TextBaselineAlignment]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault

instance Show TextBaselineAlignment where
    showsPrec :: Int -> TextBaselineAlignment -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> FromTextShow a
FromTextShow

instance TextShow TextBaselineAlignment where
    showb :: TextBaselineAlignment -> Builder
showb TextBaselineAlignment
TopBaseline         = Builder
"top"
    showb TextBaselineAlignment
HangingBaseline     = Builder
"hanging"
    showb TextBaselineAlignment
MiddleBaseline      = Builder
"middle"
    showb TextBaselineAlignment
AlphabeticBaseline  = Builder
"alphabetic"
    showb TextBaselineAlignment
IdeographicBaseline = Builder
"ideographic"
    showb TextBaselineAlignment
BottomBaseline      = Builder
"bottom"

-- | Class for @round@ CSS property values.
class RoundProperty a where
    -- | Shorthand for 'RoundCap' or 'RoundCorner', with an underscore to
    -- distinguish it from 'round'.
    round_ :: a

-------------------------------------------------------------

-- | Class for Haskell data types which represent JavaScript data.
class JSArg a where
    -- | Display a value as JavaScript data.
    showbJS :: a -> Builder

instance JSArg (AlphaColour Double) where
  showbJS :: AlphaColour Double -> Builder
showbJS = AlphaColour Double -> Builder
jsAlphaColour

jsAlphaColour :: AlphaColour Double -> Builder
jsAlphaColour :: AlphaColour Double -> Builder
jsAlphaColour AlphaColour Double
aCol
    | Double
a forall a. Ord a => a -> a -> Bool
>= Double
1    = Colour Double -> Builder
jsColour Colour Double
rgbCol
    | Double
a forall a. Ord a => a -> a -> Bool
<= Double
0    = Builder -> Builder
jsLiteralBuilder Builder
"rgba(0,0,0,0)"
    | Bool
otherwise = Builder -> Builder
jsLiteralBuilder forall a b. (a -> b) -> a -> b
$ Builder
"rgba("
        forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Word8
r    forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
','
        forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Word8
g    forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
','
        forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Word8
b    forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
','
        forall a. Semigroup a => a -> a -> a
<> Double -> Builder
jsDouble Double
a forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
')'
  where
    a :: Double
a         = forall a. AlphaColour a -> a
alphaChannel AlphaColour Double
aCol
    rgbCol :: Colour Double
rgbCol    = forall (f :: * -> *) a. (ColourOps f, Num a) => a -> f a -> f a
darken (forall a. Fractional a => a -> a
recip Double
a) forall a b. (a -> b) -> a -> b
$ AlphaColour Double
aCol forall (f :: * -> *) a.
(ColourOps f, Num a) =>
AlphaColour a -> f a -> f a
`over` forall a. Num a => Colour a
black
    RGB Word8
r Word8
g Word8
b = forall b. (RealFrac b, Floating b) => Colour b -> RGB Word8
toSRGB24 Colour Double
rgbCol

instance JSArg Bool where
    showbJS :: Bool -> Builder
showbJS = Bool -> Builder
jsBool

jsBool :: Bool -> Builder
jsBool :: Bool -> Builder
jsBool Bool
True  = Builder
"true"
jsBool Bool
False = Builder
"false"

instance JSArg CanvasAudio where
  showbJS :: CanvasAudio -> Builder
showbJS = CanvasAudio -> Builder
jsCanvasAudio

jsCanvasAudio :: CanvasAudio -> Builder
jsCanvasAudio :: CanvasAudio -> Builder
jsCanvasAudio (CanvasAudio Int
n Double
_ ) = Builder
"sounds[" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
n forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
']'

instance JSArg CanvasContext where
    showbJS :: CanvasContext -> Builder
showbJS = CanvasContext -> Builder
jsCanvasContext

jsCanvasContext :: CanvasContext -> Builder
jsCanvasContext :: CanvasContext -> Builder
jsCanvasContext (CanvasContext Int
n Int
_ Int
_) = Builder
"canvasbuffers[" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
n forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
']'

instance JSArg CanvasImage where
    showbJS :: CanvasImage -> Builder
showbJS = CanvasImage -> Builder
jsCanvasImage

jsCanvasImage :: CanvasImage -> Builder
jsCanvasImage :: CanvasImage -> Builder
jsCanvasImage (CanvasImage Int
n Int
_ Int
_) = Builder
"images[" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
n forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
']'

instance JSArg CanvasGradient where
    showbJS :: CanvasGradient -> Builder
showbJS = CanvasGradient -> Builder
jsCanvasGradient

jsCanvasGradient :: CanvasGradient -> Builder
jsCanvasGradient :: CanvasGradient -> Builder
jsCanvasGradient (CanvasGradient Int
n) = Builder
"gradient_" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
n

instance JSArg CanvasPattern where
    showbJS :: CanvasPattern -> Builder
showbJS = CanvasPattern -> Builder
jsCanvasPattern

jsCanvasPattern :: CanvasPattern -> Builder
jsCanvasPattern :: CanvasPattern -> Builder
jsCanvasPattern (CanvasPattern Int
n) = Builder
"pattern_" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
n

instance JSArg (Colour Double) where
    showbJS :: Colour Double -> Builder
showbJS = Colour Double -> Builder
jsColour

jsColour :: Colour Double -> Builder
jsColour :: Colour Double -> Builder
jsColour = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b. (Floating b, RealFrac b) => Colour b -> Builder
sRGB24showb

-- | Convert a colour in hexadecimal 'Builder' form, e.g. \"#00aaff\"
sRGB24showb :: (Floating b, RealFrac b) => Colour b -> Builder
sRGB24showb :: forall b. (Floating b, RealFrac b) => Colour b -> Builder
sRGB24showb Colour b
c =
    Char -> Builder
B.singleton Char
'#' forall a. Semigroup a => a -> a -> a
<> forall {a}. (Integral a, TextShow a) => a -> Builder
showbHex2 Word8
r' forall a. Semigroup a => a -> a -> a
<> forall {a}. (Integral a, TextShow a) => a -> Builder
showbHex2 Word8
g' forall a. Semigroup a => a -> a -> a
<> forall {a}. (Integral a, TextShow a) => a -> Builder
showbHex2 Word8
b'
  where
    RGB Word8
r' Word8
g' Word8
b' = forall b. (RealFrac b, Floating b) => Colour b -> RGB Word8
toSRGB24 Colour b
c
    showbHex2 :: a -> Builder
showbHex2 a
x | a
x forall a. Ord a => a -> a -> Bool
<= a
0xf = Char -> Builder
B.singleton Char
'0' forall a. Semigroup a => a -> a -> a
<> forall {a}. (Integral a, TextShow a) => a -> Builder
showbHex a
x
                | Bool
otherwise = forall {a}. (Integral a, TextShow a) => a -> Builder
showbHex a
x

instance JSArg Double where
    showbJS :: Double -> Builder
showbJS = Double -> Builder
jsDouble

jsDouble :: Double -> Builder
jsDouble :: Double -> Builder
jsDouble = forall a. RealFloat a => Maybe Int -> a -> Builder
showbFFloat forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Int
3

instance JSArg ImageData where
    showbJS :: ImageData -> Builder
showbJS = ImageData -> Builder
jsImageData

jsImageData :: ImageData -> Builder
jsImageData :: ImageData -> Builder
jsImageData (ImageData Int
w Int
h Vector Word8
d) = Builder
"ImageData(" forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
w
    forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
',' forall a. Semigroup a => a -> a -> a
<> forall a. TextShow a => a -> Builder
showb Int
h
    forall a. Semigroup a => a -> a -> a
<> Builder
",[" forall a. Semigroup a => a -> a -> a
<> Builder
vs forall a. Semigroup a => a -> a -> a
<> Builder
"])"
  where
    vs :: Builder
vs = forall a. (a -> Builder) -> [a] -> Builder
jsList forall a. TextShow a => a -> Builder
showb forall a b. (a -> b) -> a -> b
$ forall a. Unbox a => Vector a -> [a]
V.toList Vector Word8
d

instance JSArg Int where
    showbJS :: Int -> Builder
showbJS = Int -> Builder
jsInt

jsInt :: Int -> Builder
jsInt :: Int -> Builder
jsInt = forall a. TextShow a => a -> Builder
showb

instance JSArg LineEndCap where
    showbJS :: LineEndCap -> Builder
showbJS = LineEndCap -> Builder
jsLineEndCap

jsLineEndCap :: LineEndCap -> Builder
jsLineEndCap :: LineEndCap -> Builder
jsLineEndCap = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TextShow a => a -> Builder
showb

instance JSArg LineJoinCorner where
    showbJS :: LineJoinCorner -> Builder
showbJS = LineJoinCorner -> Builder
jsLineJoinCorner

jsLineJoinCorner :: LineJoinCorner -> Builder
jsLineJoinCorner :: LineJoinCorner -> Builder
jsLineJoinCorner = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TextShow a => a -> Builder
showb

jsList :: (a -> Builder) -> [a] -> Builder
jsList :: forall a. (a -> Builder) -> [a] -> Builder
jsList a -> Builder
js = forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
L.intersperse Builder
"," forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map a -> Builder
js

instance JSArg RepeatDirection where
    showbJS :: RepeatDirection -> Builder
showbJS = RepeatDirection -> Builder
jsRepeatDirection

jsRepeatDirection :: RepeatDirection -> Builder
jsRepeatDirection :: RepeatDirection -> Builder
jsRepeatDirection = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TextShow a => a -> Builder
showb

instance JSArg Text where
    showbJS :: Text -> Builder
showbJS = Text -> Builder
jsText

jsText :: Text -> Builder
jsText :: Text -> Builder
jsText = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Builder
fromText

instance JSArg TextAnchorAlignment where
    showbJS :: TextAnchorAlignment -> Builder
showbJS = TextAnchorAlignment -> Builder
jsTextAnchorAlignment

jsTextAnchorAlignment :: TextAnchorAlignment -> Builder
jsTextAnchorAlignment :: TextAnchorAlignment -> Builder
jsTextAnchorAlignment = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TextShow a => a -> Builder
showb

instance JSArg TextBaselineAlignment where
    showbJS :: TextBaselineAlignment -> Builder
showbJS = TextBaselineAlignment -> Builder
jsTextBaselineAlignment

jsTextBaselineAlignment :: TextBaselineAlignment -> Builder
jsTextBaselineAlignment :: TextBaselineAlignment -> Builder
jsTextBaselineAlignment = Builder -> Builder
jsLiteralBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TextShow a => a -> Builder
showb

-- The following was adapted from our Sunroof compiler.
-- -------------------------------------------------------------
-- Builder Conversion Utilities: Haskell -> JS
-- -------------------------------------------------------------

-- | Convert a 'Builder' to a representation as a JS string literal.
jsLiteralBuilder :: Builder -> Builder
jsLiteralBuilder :: Builder -> Builder
jsLiteralBuilder = Builder -> Builder
jsQuoteBuilder forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Builder
jsEscapeBuilder

-- | Add quotes to a 'Builder'.
jsQuoteBuilder :: Builder -> Builder
jsQuoteBuilder :: Builder -> Builder
jsQuoteBuilder Builder
b = Char -> Builder
B.singleton Char
'"' forall a. Semigroup a => a -> a -> a
<> Builder
b forall a. Semigroup a => a -> a -> a
<> Char -> Builder
B.singleton Char
'"'

-- | Correctly replace a `Builder'`s characters by the JS escape sequences.
jsEscapeBuilder :: Builder -> Builder
jsEscapeBuilder :: Builder -> Builder
jsEscapeBuilder = Text -> Builder
fromLazyText forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Text) -> Text -> Text
TL.concatMap Char -> Text
jsEscapeChar forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Text
toLazyText

-- | Correctly replace Haskell characters by the JS escape sequences.
jsEscapeChar :: Char -> TL.Text
jsEscapeChar :: Char -> Text
jsEscapeChar Char
'\\' = Text
"\\\\"
-- Special control sequences.
jsEscapeChar Char
'\b' = Text
"\\b"
jsEscapeChar Char
'\f' = Text
"\\f"
jsEscapeChar Char
'\n' = Text
"\\n"
jsEscapeChar Char
'\r' = Text
"\\r"
jsEscapeChar Char
'\t' = Text
"\\t"
jsEscapeChar Char
'\v' = Text
"\\v"
jsEscapeChar Char
'\"' = Text
"\\\""
jsEscapeChar Char
'\'' = Text
"\\'"
-- Code borrowed from GHCJS implementation: https://github.com/ghcjs/ghcjs/blob/718b37fc7167269ebca633914c716c3dbe6d0faf/src/Compiler/JMacro/Base.hs#L887-L905
jsEscapeChar Char
'/'  = Text
"\\/"
jsEscapeChar Char
c
    -- Non-control ASCII characters can remain as they are.
    | Bool -> Bool
not (Char -> Bool
isControl Char
c) Bool -> Bool -> Bool
&& Char -> Bool
isAscii Char
c = Char -> Text
TL.singleton Char
c
    | Char -> Int
ord Char
c forall a. Ord a => a -> a -> Bool
<= Int
0xff   = forall {p}. (Integral p, Show p) => String -> Int -> p -> Text
hexxs String
"\\x" Int
2 (Char -> Int
ord Char
c)
    -- All other non ASCII signs are escaped to unicode.
    | Char -> Int
ord Char
c forall a. Ord a => a -> a -> Bool
<= Int
0xffff = forall {p}. (Integral p, Show p) => String -> Int -> p -> Text
hexxs String
"\\u" Int
4 (Char -> Int
ord Char
c)
    | Bool
otherwise      = let cp0 :: Int
cp0 = Char -> Int
ord Char
c forall a. Num a => a -> a -> a
- Int
0x10000 -- output surrogate pair
                       in forall {p}. (Integral p, Show p) => String -> Int -> p -> Text
hexxs String
"\\u" Int
4 ((Int
cp0 forall a. Bits a => a -> Int -> a
`shiftR` Int
10) forall a. Num a => a -> a -> a
+ Int
0xd800) forall a. Monoid a => a -> a -> a
`mappend`
                          forall {p}. (Integral p, Show p) => String -> Int -> p -> Text
hexxs String
"\\u" Int
4 ((Int
cp0 forall a. Bits a => a -> a -> a
.&. Int
0x3ff) forall a. Num a => a -> a -> a
+ Int
0xdc00)
    where hexxs :: String -> Int -> p -> Text
hexxs String
prefix Int
pad p
cp =
            let h :: String
h = forall a. (Integral a, Show a) => a -> ShowS
showHex p
cp String
""
            in  String -> Text
TL.pack (String
prefix forall a. [a] -> [a] -> [a]
++ forall a. Int -> a -> [a]
replicate (Int
pad forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. Foldable t => t a -> Int
length String
h) Char
'0' forall a. [a] -> [a] -> [a]
++ String
h)