{-# LANGUAGE PatternSynonyms #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module JSDOM.Generated.SVGPathSeg
       (pattern PATHSEG_UNKNOWN, pattern PATHSEG_CLOSEPATH,
        pattern PATHSEG_MOVETO_ABS, pattern PATHSEG_MOVETO_REL,
        pattern PATHSEG_LINETO_ABS, pattern PATHSEG_LINETO_REL,
        pattern PATHSEG_CURVETO_CUBIC_ABS,
        pattern PATHSEG_CURVETO_CUBIC_REL,
        pattern PATHSEG_CURVETO_QUADRATIC_ABS,
        pattern PATHSEG_CURVETO_QUADRATIC_REL, pattern PATHSEG_ARC_ABS,
        pattern PATHSEG_ARC_REL, pattern PATHSEG_LINETO_HORIZONTAL_ABS,
        pattern PATHSEG_LINETO_HORIZONTAL_REL,
        pattern PATHSEG_LINETO_VERTICAL_ABS,
        pattern PATHSEG_LINETO_VERTICAL_REL,
        pattern PATHSEG_CURVETO_CUBIC_SMOOTH_ABS,
        pattern PATHSEG_CURVETO_CUBIC_SMOOTH_REL,
        pattern PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS,
        pattern PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, getPathSegType,
        getPathSegTypeAsLetter, SVGPathSeg(..), gTypeSVGPathSeg,
        IsSVGPathSeg, toSVGPathSeg)
       where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, realToFrac, fmap, Show, Read, Eq, Ord, Maybe(..))
import qualified Prelude (error)
import Data.Typeable (Typeable)
import Data.Traversable (mapM)
import Language.Javascript.JSaddle (JSM(..), JSVal(..), JSString, strictEqual, toJSVal, valToStr, valToNumber, valToBool, js, jss, jsf, jsg, function, asyncFunction, new, array, jsUndefined, (!), (!!))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import JSDOM.Types
import Control.Applicative ((<$>))
import Control.Monad (void)
import Control.Lens.Operators ((^.))
import JSDOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
import JSDOM.Enums
pattern $mPATHSEG_UNKNOWN :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_UNKNOWN :: forall {a}. (Eq a, Num a) => a
PATHSEG_UNKNOWN = 0
pattern $mPATHSEG_CLOSEPATH :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CLOSEPATH :: forall {a}. (Eq a, Num a) => a
PATHSEG_CLOSEPATH = 1
pattern $mPATHSEG_MOVETO_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_MOVETO_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_MOVETO_ABS = 2
pattern $mPATHSEG_MOVETO_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_MOVETO_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_MOVETO_REL = 3
pattern $mPATHSEG_LINETO_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_ABS = 4
pattern $mPATHSEG_LINETO_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_REL = 5
pattern $mPATHSEG_CURVETO_CUBIC_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_CUBIC_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_CUBIC_ABS = 6
pattern $mPATHSEG_CURVETO_CUBIC_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_CUBIC_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_CUBIC_REL = 7
pattern $mPATHSEG_CURVETO_QUADRATIC_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_QUADRATIC_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_QUADRATIC_ABS = 8
pattern $mPATHSEG_CURVETO_QUADRATIC_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_QUADRATIC_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_QUADRATIC_REL = 9
pattern $mPATHSEG_ARC_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_ARC_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_ARC_ABS = 10
pattern $mPATHSEG_ARC_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_ARC_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_ARC_REL = 11
pattern $mPATHSEG_LINETO_HORIZONTAL_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_HORIZONTAL_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_HORIZONTAL_ABS = 12
pattern $mPATHSEG_LINETO_HORIZONTAL_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_HORIZONTAL_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_HORIZONTAL_REL = 13
pattern $mPATHSEG_LINETO_VERTICAL_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_VERTICAL_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_VERTICAL_ABS = 14
pattern $mPATHSEG_LINETO_VERTICAL_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_LINETO_VERTICAL_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_LINETO_VERTICAL_REL = 15
pattern $mPATHSEG_CURVETO_CUBIC_SMOOTH_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_CUBIC_SMOOTH_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16
pattern $mPATHSEG_CURVETO_CUBIC_SMOOTH_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_CUBIC_SMOOTH_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17
pattern $mPATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18
pattern $mPATHSEG_CURVETO_QUADRATIC_SMOOTH_REL :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPATHSEG_CURVETO_QUADRATIC_SMOOTH_REL :: forall {a}. (Eq a, Num a) => a
PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSeg.pathSegType Mozilla SVGPathSeg.pathSegType documentation> 
getPathSegType :: (MonadDOM m, IsSVGPathSeg self) => self -> m Word
getPathSegType :: forall (m :: * -> *) self.
(MonadDOM m, IsSVGPathSeg self) =>
self -> m Word
getPathSegType self
self
  = DOM Word -> m Word
forall (m :: * -> *) a. MonadDOM m => DOM a -> m a
liftDOM
      (Double -> Word
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round (Double -> Word) -> JSM Double -> DOM Word
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
         (((self -> SVGPathSeg
forall o. IsSVGPathSeg o => o -> SVGPathSeg
toSVGPathSeg self
self) SVGPathSeg
-> Getting (JSM JSVal) SVGPathSeg (JSM JSVal) -> JSM JSVal
forall s a. s -> Getting a s a -> a
^. String -> IndexPreservingGetter SVGPathSeg (JSM JSVal)
forall s name.
(MakeObject s, ToJSString name) =>
name -> IndexPreservingGetter s (JSM JSVal)
js String
"pathSegType") JSM JSVal -> (JSVal -> JSM Double) -> JSM Double
forall a b. JSM a -> (a -> JSM b) -> JSM b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JSVal -> JSM Double
forall value. ToJSVal value => value -> JSM Double
valToNumber))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSeg.pathSegTypeAsLetter Mozilla SVGPathSeg.pathSegTypeAsLetter documentation> 
getPathSegTypeAsLetter ::
                       (MonadDOM m, IsSVGPathSeg self, FromJSString result) =>
                         self -> m result
getPathSegTypeAsLetter :: forall (m :: * -> *) self result.
(MonadDOM m, IsSVGPathSeg self, FromJSString result) =>
self -> m result
getPathSegTypeAsLetter self
self
  = DOM result -> m result
forall (m :: * -> *) a. MonadDOM m => DOM a -> m a
liftDOM
      (((self -> SVGPathSeg
forall o. IsSVGPathSeg o => o -> SVGPathSeg
toSVGPathSeg self
self) SVGPathSeg
-> Getting (JSM JSVal) SVGPathSeg (JSM JSVal) -> JSM JSVal
forall s a. s -> Getting a s a -> a
^. String -> IndexPreservingGetter SVGPathSeg (JSM JSVal)
forall s name.
(MakeObject s, ToJSString name) =>
name -> IndexPreservingGetter s (JSM JSVal)
js String
"pathSegTypeAsLetter") JSM JSVal -> (JSVal -> DOM result) -> DOM result
forall a b. JSM a -> (a -> JSM b) -> JSM b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
         JSVal -> DOM result
forall a. FromJSVal a => JSVal -> JSM a
fromJSValUnchecked)