ghcjs-dom-javascript-0.9.9.0: src/GHCJS/DOM/JSFFI/Generated/SVGMatrix.hs

{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE JavaScriptFFI #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
module GHCJS.DOM.JSFFI.Generated.SVGMatrix
       (js_multiply, multiply, multiply_, js_inverse, inverse, inverse_,
        js_translate, translate, translate_, js_scale, scale, scale_,
        js_scaleNonUniform, scaleNonUniform, scaleNonUniform_, js_rotate,
        rotate, rotate_, js_rotateFromVector, rotateFromVector,
        rotateFromVector_, js_flipX, flipX, flipX_, js_flipY, flipY,
        flipY_, js_skewX, skewX, skewX_, js_skewY, skewY, skewY_, js_setA,
        setA, js_getA, getA, js_setB, setB, js_getB, getB, js_setC, setC,
        js_getC, getC, js_setD, setD, js_getD, getD, js_setE, setE,
        js_getE, getE, js_setF, setF, js_getF, getF, SVGMatrix(..),
        gTypeSVGMatrix)
       where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import qualified Prelude (error)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull, jsUndefined)
import GHC.JS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import Data.Maybe (fromJust)
import Data.Traversable (mapM)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
import GHCJS.DOM.JSFFI.Generated.Enums
 
foreign import javascript safe "(($1, $2) => { return $1[\"multiply\"]($2); })" js_multiply
        :: SVGMatrix -> SVGMatrix -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.multiply Mozilla SVGMatrix.multiply documentation> 
multiply :: (MonadIO m) => SVGMatrix -> SVGMatrix -> m SVGMatrix
multiply self secondMatrix = liftIO (js_multiply self secondMatrix)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.multiply Mozilla SVGMatrix.multiply documentation> 
multiply_ :: (MonadIO m) => SVGMatrix -> SVGMatrix -> m ()
multiply_ self secondMatrix
  = liftIO (void (js_multiply self secondMatrix))
 
foreign import javascript safe "(($1) => { return $1[\"inverse\"](); })" js_inverse ::
        SVGMatrix -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.inverse Mozilla SVGMatrix.inverse documentation> 
inverse :: (MonadIO m) => SVGMatrix -> m SVGMatrix
inverse self = liftIO (js_inverse self)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.inverse Mozilla SVGMatrix.inverse documentation> 
inverse_ :: (MonadIO m) => SVGMatrix -> m ()
inverse_ self = liftIO (void (js_inverse self))
 
foreign import javascript safe "(($1, $2, $3) => { return $1[\"translate\"]($2, $3); })"
        js_translate :: SVGMatrix -> Float -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.translate Mozilla SVGMatrix.translate documentation> 
translate ::
          (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
translate self x y = liftIO (js_translate self x y)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.translate Mozilla SVGMatrix.translate documentation> 
translate_ :: (MonadIO m) => SVGMatrix -> Float -> Float -> m ()
translate_ self x y = liftIO (void (js_translate self x y))
 
foreign import javascript safe "(($1, $2) => { return $1[\"scale\"]($2); })" js_scale ::
        SVGMatrix -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scale Mozilla SVGMatrix.scale documentation> 
scale :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
scale self scaleFactor = liftIO (js_scale self scaleFactor)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scale Mozilla SVGMatrix.scale documentation> 
scale_ :: (MonadIO m) => SVGMatrix -> Float -> m ()
scale_ self scaleFactor = liftIO (void (js_scale self scaleFactor))
 
foreign import javascript safe "(($1, $2, $3) => { return $1[\"scaleNonUniform\"]($2, $3); })"
        js_scaleNonUniform :: SVGMatrix -> Float -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scaleNonUniform Mozilla SVGMatrix.scaleNonUniform documentation> 
scaleNonUniform ::
                (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
scaleNonUniform self scaleFactorX scaleFactorY
  = liftIO (js_scaleNonUniform self scaleFactorX scaleFactorY)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scaleNonUniform Mozilla SVGMatrix.scaleNonUniform documentation> 
scaleNonUniform_ ::
                 (MonadIO m) => SVGMatrix -> Float -> Float -> m ()
scaleNonUniform_ self scaleFactorX scaleFactorY
  = liftIO (void (js_scaleNonUniform self scaleFactorX scaleFactorY))
 
foreign import javascript safe "(($1, $2) => { return $1[\"rotate\"]($2); })" js_rotate ::
        SVGMatrix -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotate Mozilla SVGMatrix.rotate documentation> 
rotate :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
rotate self angle = liftIO (js_rotate self angle)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotate Mozilla SVGMatrix.rotate documentation> 
rotate_ :: (MonadIO m) => SVGMatrix -> Float -> m ()
rotate_ self angle = liftIO (void (js_rotate self angle))
 
foreign import javascript safe "(($1, $2, $3) => { return $1[\"rotateFromVector\"]($2, $3); })"
        js_rotateFromVector :: SVGMatrix -> Float -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotateFromVector Mozilla SVGMatrix.rotateFromVector documentation> 
rotateFromVector ::
                 (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
rotateFromVector self x y = liftIO (js_rotateFromVector self x y)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotateFromVector Mozilla SVGMatrix.rotateFromVector documentation> 
rotateFromVector_ ::
                  (MonadIO m) => SVGMatrix -> Float -> Float -> m ()
rotateFromVector_ self x y
  = liftIO (void (js_rotateFromVector self x y))
 
foreign import javascript safe "(($1) => { return $1[\"flipX\"](); })" js_flipX ::
        SVGMatrix -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipX Mozilla SVGMatrix.flipX documentation> 
flipX :: (MonadIO m) => SVGMatrix -> m SVGMatrix
flipX self = liftIO (js_flipX self)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipX Mozilla SVGMatrix.flipX documentation> 
flipX_ :: (MonadIO m) => SVGMatrix -> m ()
flipX_ self = liftIO (void (js_flipX self))
 
foreign import javascript safe "(($1) => { return $1[\"flipY\"](); })" js_flipY ::
        SVGMatrix -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipY Mozilla SVGMatrix.flipY documentation> 
flipY :: (MonadIO m) => SVGMatrix -> m SVGMatrix
flipY self = liftIO (js_flipY self)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipY Mozilla SVGMatrix.flipY documentation> 
flipY_ :: (MonadIO m) => SVGMatrix -> m ()
flipY_ self = liftIO (void (js_flipY self))
 
foreign import javascript safe "(($1, $2) => { return $1[\"skewX\"]($2); })" js_skewX ::
        SVGMatrix -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewX Mozilla SVGMatrix.skewX documentation> 
skewX :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
skewX self angle = liftIO (js_skewX self angle)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewX Mozilla SVGMatrix.skewX documentation> 
skewX_ :: (MonadIO m) => SVGMatrix -> Float -> m ()
skewX_ self angle = liftIO (void (js_skewX self angle))
 
foreign import javascript safe "(($1, $2) => { return $1[\"skewY\"]($2); })" js_skewY ::
        SVGMatrix -> Float -> IO SVGMatrix

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewY Mozilla SVGMatrix.skewY documentation> 
skewY :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
skewY self angle = liftIO (js_skewY self angle)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewY Mozilla SVGMatrix.skewY documentation> 
skewY_ :: (MonadIO m) => SVGMatrix -> Float -> m ()
skewY_ self angle = liftIO (void (js_skewY self angle))
 
foreign import javascript safe "(($1, $2) => { $1[\"a\"] = $2; })" js_setA ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.a Mozilla SVGMatrix.a documentation> 
setA :: (MonadIO m) => SVGMatrix -> Double -> m ()
setA self val = liftIO (js_setA self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"a\"]; })" js_getA ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.a Mozilla SVGMatrix.a documentation> 
getA :: (MonadIO m) => SVGMatrix -> m Double
getA self = liftIO (js_getA self)
 
foreign import javascript safe "(($1, $2) => { $1[\"b\"] = $2; })" js_setB ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.b Mozilla SVGMatrix.b documentation> 
setB :: (MonadIO m) => SVGMatrix -> Double -> m ()
setB self val = liftIO (js_setB self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"b\"]; })" js_getB ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.b Mozilla SVGMatrix.b documentation> 
getB :: (MonadIO m) => SVGMatrix -> m Double
getB self = liftIO (js_getB self)
 
foreign import javascript safe "(($1, $2) => { $1[\"c\"] = $2; })" js_setC ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.c Mozilla SVGMatrix.c documentation> 
setC :: (MonadIO m) => SVGMatrix -> Double -> m ()
setC self val = liftIO (js_setC self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"c\"]; })" js_getC ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.c Mozilla SVGMatrix.c documentation> 
getC :: (MonadIO m) => SVGMatrix -> m Double
getC self = liftIO (js_getC self)
 
foreign import javascript safe "(($1, $2) => { $1[\"d\"] = $2; })" js_setD ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.d Mozilla SVGMatrix.d documentation> 
setD :: (MonadIO m) => SVGMatrix -> Double -> m ()
setD self val = liftIO (js_setD self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"d\"]; })" js_getD ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.d Mozilla SVGMatrix.d documentation> 
getD :: (MonadIO m) => SVGMatrix -> m Double
getD self = liftIO (js_getD self)
 
foreign import javascript safe "(($1, $2) => { $1[\"e\"] = $2; })" js_setE ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.e Mozilla SVGMatrix.e documentation> 
setE :: (MonadIO m) => SVGMatrix -> Double -> m ()
setE self val = liftIO (js_setE self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"e\"]; })" js_getE ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.e Mozilla SVGMatrix.e documentation> 
getE :: (MonadIO m) => SVGMatrix -> m Double
getE self = liftIO (js_getE self)
 
foreign import javascript safe "(($1, $2) => { $1[\"f\"] = $2; })" js_setF ::
        SVGMatrix -> Double -> IO ()

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.f Mozilla SVGMatrix.f documentation> 
setF :: (MonadIO m) => SVGMatrix -> Double -> m ()
setF self val = liftIO (js_setF self val)
 
foreign import javascript unsafe "(($1) => { return $1[\"f\"]; })" js_getF ::
        SVGMatrix -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.f Mozilla SVGMatrix.f documentation> 
getF :: (MonadIO m) => SVGMatrix -> m Double
getF self = liftIO (js_getF self)