module GHCJS.DOM.JSFFI.Generated.CanvasRenderingContext2D
(js_save, save, js_restore, restore, js_scale, scale, js_rotate,
rotate, js_translate, translate, js_transform, transform,
js_setTransform, setTransform, js_createLinearGradient,
createLinearGradient, createLinearGradient_,
createLinearGradientUnsafe, createLinearGradientUnchecked,
js_createRadialGradient, createRadialGradient,
createRadialGradient_, createRadialGradientUnsafe,
createRadialGradientUnchecked, js_setLineDash, setLineDash,
js_getLineDash, getLineDash, getLineDash_, js_clearRect, clearRect,
js_fillRect, fillRect, js_beginPath, beginPath, js_closePath,
closePath, js_moveTo, moveTo, js_lineTo, lineTo,
js_quadraticCurveTo, quadraticCurveTo, js_bezierCurveTo,
bezierCurveTo, js_arcTo, arcTo, js_rect, rect, js_arc, arc,
js_fillPath, fillPath, js_strokePath, strokePath, js_clipPath,
clipPath, js_fill, fill, js_stroke, stroke, js_clip, clip,
js_isPointInPathPath, isPointInPathPath, isPointInPathPath_,
js_isPointInStrokePath, isPointInStrokePath, isPointInStrokePath_,
js_isPointInPath, isPointInPath, isPointInPath_,
js_isPointInStroke, isPointInStroke, isPointInStroke_,
js_measureText, measureText, measureText_, measureTextUnsafe,
measureTextUnchecked, js_setAlpha, setAlpha,
js_setCompositeOperation, setCompositeOperation,
js_setLineWidthFunction, setLineWidthFunction,
js_setLineCapFunction, setLineCapFunction, js_setLineJoinFunction,
setLineJoinFunction, js_setMiterLimitFunction,
setMiterLimitFunction, js_clearShadow, clearShadow, js_fillText,
fillText, js_strokeText, strokeText, js_setStrokeColor,
setStrokeColor, js_setStrokeColorGray, setStrokeColorGray,
js_setStrokeColorRGB, setStrokeColorRGB, js_setStrokeColorCYMK,
setStrokeColorCYMK, js_setFillColor, setFillColor,
js_setFillColorGray, setFillColorGray, js_setFillColorRGB,
setFillColorRGB, js_setFillColorCYMK, setFillColorCYMK,
js_strokeRect, strokeRect, js_drawImage, drawImage,
js_drawImageScaled, drawImageScaled, js_drawImagePart,
drawImagePart, js_drawImageFromCanvas, drawImageFromCanvas,
js_drawImageFromCanvasScaled, drawImageFromCanvasScaled,
js_drawImageFromCanvasPart, drawImageFromCanvasPart,
js_drawImageFromVideo, drawImageFromVideo,
js_drawImageFromVideoScaled, drawImageFromVideoScaled,
js_drawImageFromVideoPart, drawImageFromVideoPart,
js_drawImageFromRect, drawImageFromRect, js_setShadow, setShadow,
js_setShadowGray, setShadowGray, js_setShadowRGB, setShadowRGB,
js_setShadowCYMK, setShadowCYMK, js_putImageData, putImageData,
js_putImageDataDirty, putImageDataDirty, js_webkitPutImageDataHD,
webkitPutImageDataHD, js_webkitPutImageDataHDDirty,
webkitPutImageDataHDDirty, js_createPatternFromCanvas,
createPatternFromCanvas, createPatternFromCanvas_,
createPatternFromCanvasUnsafe, createPatternFromCanvasUnchecked,
js_createPattern, createPattern, createPattern_,
createPatternUnsafe, createPatternUnchecked, js_createImageData,
createImageData, createImageData_, createImageDataUnsafe,
createImageDataUnchecked, js_createImageDataSize,
createImageDataSize, createImageDataSize_,
createImageDataSizeUnsafe, createImageDataSizeUnchecked,
js_getImageData, getImageData, getImageData_, getImageDataUnsafe,
getImageDataUnchecked, js_webkitGetImageDataHD,
webkitGetImageDataHD, webkitGetImageDataHD_,
webkitGetImageDataHDUnsafe, webkitGetImageDataHDUnchecked,
js_drawFocusIfNeeded, drawFocusIfNeeded, js_drawFocusIfNeededPath,
drawFocusIfNeededPath, js_setGlobalAlpha, setGlobalAlpha,
js_getGlobalAlpha, getGlobalAlpha, js_setGlobalCompositeOperation,
setGlobalCompositeOperation, js_getGlobalCompositeOperation,
getGlobalCompositeOperation, getGlobalCompositeOperationUnsafe,
getGlobalCompositeOperationUnchecked, js_setLineWidth,
setLineWidth, js_getLineWidth, getLineWidth, js_setLineCap,
setLineCap, js_getLineCap, getLineCap, getLineCapUnsafe,
getLineCapUnchecked, js_setLineJoin, setLineJoin, js_getLineJoin,
getLineJoin, getLineJoinUnsafe, getLineJoinUnchecked,
js_setMiterLimit, setMiterLimit, js_getMiterLimit, getMiterLimit,
js_setShadowOffsetX, setShadowOffsetX, js_getShadowOffsetX,
getShadowOffsetX, js_setShadowOffsetY, setShadowOffsetY,
js_getShadowOffsetY, getShadowOffsetY, js_setShadowBlur,
setShadowBlur, js_getShadowBlur, getShadowBlur, js_setShadowColor,
setShadowColor, js_getShadowColor, getShadowColor,
getShadowColorUnsafe, getShadowColorUnchecked,
js_setLineDashOffset, setLineDashOffset, js_getLineDashOffset,
getLineDashOffset, js_setWebkitLineDash, setWebkitLineDash,
js_getWebkitLineDash, getWebkitLineDash, getWebkitLineDashUnsafe,
getWebkitLineDashUnchecked, js_setWebkitLineDashOffset,
setWebkitLineDashOffset, js_getWebkitLineDashOffset,
getWebkitLineDashOffset, js_setFont, setFont, js_getFont, getFont,
js_setTextAlign, setTextAlign, js_getTextAlign, getTextAlign,
js_setTextBaseline, setTextBaseline, js_getTextBaseline,
getTextBaseline, js_setDirection, setDirection, js_getDirection,
getDirection, js_setStrokeStyle, setStrokeStyle, js_getStrokeStyle,
getStrokeStyle, getStrokeStyleUnsafe, getStrokeStyleUnchecked,
js_setFillStyle, setFillStyle, js_getFillStyle, getFillStyle,
getFillStyleUnsafe, getFillStyleUnchecked,
js_getWebkitBackingStorePixelRatio,
getWebkitBackingStorePixelRatio, js_setWebkitImageSmoothingEnabled,
setWebkitImageSmoothingEnabled, js_getWebkitImageSmoothingEnabled,
getWebkitImageSmoothingEnabled, CanvasRenderingContext2D(..),
gTypeCanvasRenderingContext2D)
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)
import GHCJS.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 GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
import GHCJS.DOM.JSFFI.Generated.Enums
foreign import javascript unsafe "$1[\"save\"]()" js_save ::
CanvasRenderingContext2D -> IO ()
save :: (MonadIO m) => CanvasRenderingContext2D -> m ()
save self = liftIO (js_save (self))
foreign import javascript unsafe "$1[\"restore\"]()" js_restore ::
CanvasRenderingContext2D -> IO ()
restore :: (MonadIO m) => CanvasRenderingContext2D -> m ()
restore self = liftIO (js_restore (self))
foreign import javascript unsafe "$1[\"scale\"]($2, $3)" js_scale
:: CanvasRenderingContext2D -> Float -> Float -> IO ()
scale ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
scale self sx sy = liftIO (js_scale (self) sx sy)
foreign import javascript unsafe "$1[\"rotate\"]($2)" js_rotate ::
CanvasRenderingContext2D -> Float -> IO ()
rotate :: (MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
rotate self angle = liftIO (js_rotate (self) angle)
foreign import javascript unsafe "$1[\"translate\"]($2, $3)"
js_translate :: CanvasRenderingContext2D -> Float -> Float -> IO ()
translate ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
translate self tx ty = liftIO (js_translate (self) tx ty)
foreign import javascript unsafe
"$1[\"transform\"]($2, $3, $4, $5,\n$6, $7)" js_transform ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
transform ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
transform self m11 m12 m21 m22 dx dy
= liftIO (js_transform (self) m11 m12 m21 m22 dx dy)
foreign import javascript unsafe
"$1[\"setTransform\"]($2, $3, $4,\n$5, $6, $7)" js_setTransform ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
setTransform ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
setTransform self m11 m12 m21 m22 dx dy
= liftIO (js_setTransform (self) m11 m12 m21 m22 dx dy)
foreign import javascript unsafe
"$1[\"createLinearGradient\"]($2,\n$3, $4, $5)"
js_createLinearGradient ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO (Nullable CanvasGradient)
createLinearGradient ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m (Maybe CanvasGradient)
createLinearGradient self x0 y0 x1 y1
= liftIO
(nullableToMaybe <$> (js_createLinearGradient (self) x0 y0 x1 y1))
createLinearGradient_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
createLinearGradient_ self x0 y0 x1 y1
= liftIO (void (js_createLinearGradient (self) x0 y0 x1 y1))
createLinearGradientUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m CanvasGradient
createLinearGradientUnsafe self x0 y0 x1 y1
= liftIO
((nullableToMaybe <$> (js_createLinearGradient (self) x0 y0 x1 y1))
>>= maybe (Prelude.error "Nothing to return") return)
createLinearGradientUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m CanvasGradient
createLinearGradientUnchecked self x0 y0 x1 y1
= liftIO
(fromJust . nullableToMaybe <$>
(js_createLinearGradient (self) x0 y0 x1 y1))
foreign import javascript unsafe
"$1[\"createRadialGradient\"]($2,\n$3, $4, $5, $6, $7)"
js_createRadialGradient ::
CanvasRenderingContext2D ->
Float ->
Float ->
Float -> Float -> Float -> Float -> IO (Nullable CanvasGradient)
createRadialGradient ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float ->
Float ->
Float -> Float -> Float -> Float -> m (Maybe CanvasGradient)
createRadialGradient self x0 y0 r0 x1 y1 r1
= liftIO
(nullableToMaybe <$>
(js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
createRadialGradient_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
createRadialGradient_ self x0 y0 r0 x1 y1 r1
= liftIO (void (js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
createRadialGradientUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D ->
Float ->
Float -> Float -> Float -> Float -> Float -> m CanvasGradient
createRadialGradientUnsafe self x0 y0 r0 x1 y1 r1
= liftIO
((nullableToMaybe <$>
(js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
>>= maybe (Prelude.error "Nothing to return") return)
createRadialGradientUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float ->
Float -> Float -> Float -> Float -> Float -> m CanvasGradient
createRadialGradientUnchecked self x0 y0 r0 x1 y1 r1
= liftIO
(fromJust . nullableToMaybe <$>
(js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
foreign import javascript unsafe "$1[\"setLineDash\"]($2)"
js_setLineDash :: CanvasRenderingContext2D -> JSVal -> IO ()
setLineDash ::
(MonadIO m) => CanvasRenderingContext2D -> [Float] -> m ()
setLineDash self dash
= liftIO (toJSVal dash >>= \ dash' -> js_setLineDash (self) dash')
foreign import javascript unsafe "$1[\"getLineDash\"]()"
js_getLineDash :: CanvasRenderingContext2D -> IO JSVal
getLineDash :: (MonadIO m) => CanvasRenderingContext2D -> m [Float]
getLineDash self
= liftIO ((js_getLineDash (self)) >>= fromJSValUnchecked)
getLineDash_ :: (MonadIO m) => CanvasRenderingContext2D -> m ()
getLineDash_ self = liftIO (void (js_getLineDash (self)))
foreign import javascript unsafe
"$1[\"clearRect\"]($2, $3, $4, $5)" js_clearRect ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
clearRect ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
clearRect self x y width height
= liftIO (js_clearRect (self) x y width height)
foreign import javascript unsafe "$1[\"fillRect\"]($2, $3, $4, $5)"
js_fillRect ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
fillRect ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
fillRect self x y width height
= liftIO (js_fillRect (self) x y width height)
foreign import javascript unsafe "$1[\"beginPath\"]()" js_beginPath
:: CanvasRenderingContext2D -> IO ()
beginPath :: (MonadIO m) => CanvasRenderingContext2D -> m ()
beginPath self = liftIO (js_beginPath (self))
foreign import javascript unsafe "$1[\"closePath\"]()" js_closePath
:: CanvasRenderingContext2D -> IO ()
closePath :: (MonadIO m) => CanvasRenderingContext2D -> m ()
closePath self = liftIO (js_closePath (self))
foreign import javascript unsafe "$1[\"moveTo\"]($2, $3)" js_moveTo
:: CanvasRenderingContext2D -> Float -> Float -> IO ()
moveTo ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
moveTo self x y = liftIO (js_moveTo (self) x y)
foreign import javascript unsafe "$1[\"lineTo\"]($2, $3)" js_lineTo
:: CanvasRenderingContext2D -> Float -> Float -> IO ()
lineTo ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
lineTo self x y = liftIO (js_lineTo (self) x y)
foreign import javascript unsafe
"$1[\"quadraticCurveTo\"]($2, $3,\n$4, $5)" js_quadraticCurveTo ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
quadraticCurveTo ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
quadraticCurveTo self cpx cpy x y
= liftIO (js_quadraticCurveTo (self) cpx cpy x y)
foreign import javascript unsafe
"$1[\"bezierCurveTo\"]($2, $3, $4,\n$5, $6, $7)" js_bezierCurveTo
::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
bezierCurveTo ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
bezierCurveTo self cp1x cp1y cp2x cp2y x y
= liftIO (js_bezierCurveTo (self) cp1x cp1y cp2x cp2y x y)
foreign import javascript unsafe
"$1[\"arcTo\"]($2, $3, $4, $5, $6)" js_arcTo ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> IO ()
arcTo ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> m ()
arcTo self x1 y1 x2 y2 radius
= liftIO (js_arcTo (self) x1 y1 x2 y2 radius)
foreign import javascript unsafe "$1[\"rect\"]($2, $3, $4, $5)"
js_rect ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
rect ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
rect self x y width height
= liftIO (js_rect (self) x y width height)
foreign import javascript unsafe
"$1[\"arc\"]($2, $3, $4, $5, $6,\n$7)" js_arc ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Bool -> IO ()
arc ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Bool -> m ()
arc self x y radius startAngle endAngle anticlockwise
= liftIO
(js_arc (self) x y radius startAngle endAngle anticlockwise)
foreign import javascript unsafe "$1[\"fill\"]($2, $3)" js_fillPath
:: CanvasRenderingContext2D -> Nullable Path2D -> JSVal -> IO ()
fillPath ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe Path2D -> CanvasWindingRule -> m ()
fillPath self path winding
= liftIO
(js_fillPath (self) (maybeToNullable path) (pToJSVal winding))
foreign import javascript unsafe "$1[\"stroke\"]($2)" js_strokePath
:: CanvasRenderingContext2D -> Nullable Path2D -> IO ()
strokePath ::
(MonadIO m) => CanvasRenderingContext2D -> Maybe Path2D -> m ()
strokePath self path
= liftIO (js_strokePath (self) (maybeToNullable path))
foreign import javascript unsafe "$1[\"clip\"]($2, $3)" js_clipPath
:: CanvasRenderingContext2D -> Nullable Path2D -> JSVal -> IO ()
clipPath ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe Path2D -> CanvasWindingRule -> m ()
clipPath self path winding
= liftIO
(js_clipPath (self) (maybeToNullable path) (pToJSVal winding))
foreign import javascript unsafe "$1[\"fill\"]($2)" js_fill ::
CanvasRenderingContext2D -> JSVal -> IO ()
fill ::
(MonadIO m) =>
CanvasRenderingContext2D -> CanvasWindingRule -> m ()
fill self winding = liftIO (js_fill (self) (pToJSVal winding))
foreign import javascript unsafe "$1[\"stroke\"]()" js_stroke ::
CanvasRenderingContext2D -> IO ()
stroke :: (MonadIO m) => CanvasRenderingContext2D -> m ()
stroke self = liftIO (js_stroke (self))
foreign import javascript unsafe "$1[\"clip\"]($2)" js_clip ::
CanvasRenderingContext2D -> JSVal -> IO ()
clip ::
(MonadIO m) =>
CanvasRenderingContext2D -> CanvasWindingRule -> m ()
clip self winding = liftIO (js_clip (self) (pToJSVal winding))
foreign import javascript unsafe
"($1[\"isPointInPath\"]($2, $3, $4,\n$5) ? 1 : 0)"
js_isPointInPathPath ::
CanvasRenderingContext2D ->
Nullable Path2D -> Float -> Float -> JSVal -> IO Bool
isPointInPathPath ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe Path2D -> Float -> Float -> CanvasWindingRule -> m Bool
isPointInPathPath self path x y winding
= liftIO
(js_isPointInPathPath (self) (maybeToNullable path) x y
(pToJSVal winding))
isPointInPathPath_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe Path2D -> Float -> Float -> CanvasWindingRule -> m ()
isPointInPathPath_ self path x y winding
= liftIO
(void
(js_isPointInPathPath (self) (maybeToNullable path) x y
(pToJSVal winding)))
foreign import javascript unsafe
"($1[\"isPointInStroke\"]($2, $3,\n$4) ? 1 : 0)"
js_isPointInStrokePath ::
CanvasRenderingContext2D ->
Nullable Path2D -> Float -> Float -> IO Bool
isPointInStrokePath ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe Path2D -> Float -> Float -> m Bool
isPointInStrokePath self path x y
= liftIO (js_isPointInStrokePath (self) (maybeToNullable path) x y)
isPointInStrokePath_ ::
(MonadIO m) =>
CanvasRenderingContext2D -> Maybe Path2D -> Float -> Float -> m ()
isPointInStrokePath_ self path x y
= liftIO
(void (js_isPointInStrokePath (self) (maybeToNullable path) x y))
foreign import javascript unsafe
"($1[\"isPointInPath\"]($2, $3,\n$4) ? 1 : 0)" js_isPointInPath ::
CanvasRenderingContext2D -> Float -> Float -> JSVal -> IO Bool
isPointInPath ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> CanvasWindingRule -> m Bool
isPointInPath self x y winding
= liftIO (js_isPointInPath (self) x y (pToJSVal winding))
isPointInPath_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> CanvasWindingRule -> m ()
isPointInPath_ self x y winding
= liftIO (void (js_isPointInPath (self) x y (pToJSVal winding)))
foreign import javascript unsafe
"($1[\"isPointInStroke\"]($2,\n$3) ? 1 : 0)" js_isPointInStroke ::
CanvasRenderingContext2D -> Float -> Float -> IO Bool
isPointInStroke ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m Bool
isPointInStroke self x y = liftIO (js_isPointInStroke (self) x y)
isPointInStroke_ ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
isPointInStroke_ self x y
= liftIO (void (js_isPointInStroke (self) x y))
foreign import javascript unsafe "$1[\"measureText\"]($2)"
js_measureText ::
CanvasRenderingContext2D -> JSString -> IO (Nullable TextMetrics)
measureText ::
(MonadIO m, ToJSString text) =>
CanvasRenderingContext2D -> text -> m (Maybe TextMetrics)
measureText self text
= liftIO
(nullableToMaybe <$> (js_measureText (self) (toJSString text)))
measureText_ ::
(MonadIO m, ToJSString text) =>
CanvasRenderingContext2D -> text -> m ()
measureText_ self text
= liftIO (void (js_measureText (self) (toJSString text)))
measureTextUnsafe ::
(MonadIO m, ToJSString text, HasCallStack) =>
CanvasRenderingContext2D -> text -> m TextMetrics
measureTextUnsafe self text
= liftIO
((nullableToMaybe <$> (js_measureText (self) (toJSString text)))
>>= maybe (Prelude.error "Nothing to return") return)
measureTextUnchecked ::
(MonadIO m, ToJSString text) =>
CanvasRenderingContext2D -> text -> m TextMetrics
measureTextUnchecked self text
= liftIO
(fromJust . nullableToMaybe <$>
(js_measureText (self) (toJSString text)))
foreign import javascript unsafe "$1[\"setAlpha\"]($2)" js_setAlpha
:: CanvasRenderingContext2D -> Float -> IO ()
setAlpha ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setAlpha self alpha = liftIO (js_setAlpha (self) alpha)
foreign import javascript unsafe
"$1[\"setCompositeOperation\"]($2)" js_setCompositeOperation ::
CanvasRenderingContext2D -> JSString -> IO ()
setCompositeOperation ::
(MonadIO m, ToJSString compositeOperation) =>
CanvasRenderingContext2D -> compositeOperation -> m ()
setCompositeOperation self compositeOperation
= liftIO
(js_setCompositeOperation (self) (toJSString compositeOperation))
foreign import javascript unsafe "$1[\"setLineWidth\"]($2)"
js_setLineWidthFunction ::
CanvasRenderingContext2D -> Float -> IO ()
setLineWidthFunction ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setLineWidthFunction self width
= liftIO (js_setLineWidthFunction (self) width)
foreign import javascript unsafe "$1[\"setLineCap\"]($2)"
js_setLineCapFunction ::
CanvasRenderingContext2D -> JSString -> IO ()
setLineCapFunction ::
(MonadIO m, ToJSString cap) =>
CanvasRenderingContext2D -> cap -> m ()
setLineCapFunction self cap
= liftIO (js_setLineCapFunction (self) (toJSString cap))
foreign import javascript unsafe "$1[\"setLineJoin\"]($2)"
js_setLineJoinFunction ::
CanvasRenderingContext2D -> JSString -> IO ()
setLineJoinFunction ::
(MonadIO m, ToJSString join) =>
CanvasRenderingContext2D -> join -> m ()
setLineJoinFunction self join
= liftIO (js_setLineJoinFunction (self) (toJSString join))
foreign import javascript unsafe "$1[\"setMiterLimit\"]($2)"
js_setMiterLimitFunction ::
CanvasRenderingContext2D -> Float -> IO ()
setMiterLimitFunction ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setMiterLimitFunction self limit
= liftIO (js_setMiterLimitFunction (self) limit)
foreign import javascript unsafe "$1[\"clearShadow\"]()"
js_clearShadow :: CanvasRenderingContext2D -> IO ()
clearShadow :: (MonadIO m) => CanvasRenderingContext2D -> m ()
clearShadow self = liftIO (js_clearShadow (self))
foreign import javascript unsafe "$1[\"fillText\"]($2, $3, $4, $5)"
js_fillText ::
CanvasRenderingContext2D ->
JSString -> Float -> Float -> Float -> IO ()
fillText ::
(MonadIO m, ToJSString text) =>
CanvasRenderingContext2D -> text -> Float -> Float -> Float -> m ()
fillText self text x y maxWidth
= liftIO (js_fillText (self) (toJSString text) x y maxWidth)
foreign import javascript unsafe
"$1[\"strokeText\"]($2, $3, $4, $5)" js_strokeText ::
CanvasRenderingContext2D ->
JSString -> Float -> Float -> Float -> IO ()
strokeText ::
(MonadIO m, ToJSString text) =>
CanvasRenderingContext2D -> text -> Float -> Float -> Float -> m ()
strokeText self text x y maxWidth
= liftIO (js_strokeText (self) (toJSString text) x y maxWidth)
foreign import javascript unsafe "$1[\"setStrokeColor\"]($2, $3)"
js_setStrokeColor ::
CanvasRenderingContext2D -> JSString -> Float -> IO ()
setStrokeColor ::
(MonadIO m, ToJSString color) =>
CanvasRenderingContext2D -> color -> Float -> m ()
setStrokeColor self color alpha
= liftIO (js_setStrokeColor (self) (toJSString color) alpha)
foreign import javascript unsafe "$1[\"setStrokeColor\"]($2, $3)"
js_setStrokeColorGray ::
CanvasRenderingContext2D -> Float -> Float -> IO ()
setStrokeColorGray ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
setStrokeColorGray self grayLevel alpha
= liftIO (js_setStrokeColorGray (self) grayLevel alpha)
foreign import javascript unsafe
"$1[\"setStrokeColor\"]($2, $3, $4,\n$5)" js_setStrokeColorRGB ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
setStrokeColorRGB ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
setStrokeColorRGB self r g b a
= liftIO (js_setStrokeColorRGB (self) r g b a)
foreign import javascript unsafe
"$1[\"setStrokeColor\"]($2, $3, $4,\n$5, $6)" js_setStrokeColorCYMK
::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> IO ()
setStrokeColorCYMK ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> m ()
setStrokeColorCYMK self c m y k a
= liftIO (js_setStrokeColorCYMK (self) c m y k a)
foreign import javascript unsafe "$1[\"setFillColor\"]($2, $3)"
js_setFillColor ::
CanvasRenderingContext2D -> JSString -> Float -> IO ()
setFillColor ::
(MonadIO m, ToJSString color) =>
CanvasRenderingContext2D -> color -> Float -> m ()
setFillColor self color alpha
= liftIO (js_setFillColor (self) (toJSString color) alpha)
foreign import javascript unsafe "$1[\"setFillColor\"]($2, $3)"
js_setFillColorGray ::
CanvasRenderingContext2D -> Float -> Float -> IO ()
setFillColorGray ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
setFillColorGray self grayLevel alpha
= liftIO (js_setFillColorGray (self) grayLevel alpha)
foreign import javascript unsafe
"$1[\"setFillColor\"]($2, $3, $4,\n$5)" js_setFillColorRGB ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
setFillColorRGB ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
setFillColorRGB self r g b a
= liftIO (js_setFillColorRGB (self) r g b a)
foreign import javascript unsafe
"$1[\"setFillColor\"]($2, $3, $4,\n$5, $6)" js_setFillColorCYMK ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> IO ()
setFillColorCYMK ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> m ()
setFillColorCYMK self c m y k a
= liftIO (js_setFillColorCYMK (self) c m y k a)
foreign import javascript unsafe
"$1[\"strokeRect\"]($2, $3, $4, $5)" js_strokeRect ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO ()
strokeRect ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
strokeRect self x y width height
= liftIO (js_strokeRect (self) x y width height)
foreign import javascript unsafe "$1[\"drawImage\"]($2, $3, $4)"
js_drawImage ::
CanvasRenderingContext2D ->
Nullable HTMLImageElement -> Float -> Float -> IO ()
drawImage ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement -> Float -> Float -> m ()
drawImage self image x y
= liftIO (js_drawImage (self) (maybeToNullable image) x y)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6)" js_drawImageScaled ::
CanvasRenderingContext2D ->
Nullable HTMLImageElement ->
Float -> Float -> Float -> Float -> IO ()
drawImageScaled ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement -> Float -> Float -> Float -> Float -> m ()
drawImageScaled self image x y width height
= liftIO
(js_drawImageScaled (self) (maybeToNullable image) x y width
height)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6, $7, $8, $9, $10)"
js_drawImagePart ::
CanvasRenderingContext2D ->
Nullable HTMLImageElement ->
Float ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
drawImagePart ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> Float -> m ()
drawImagePart self image sx sy sw sh dx dy dw dh
= liftIO
(js_drawImagePart (self) (maybeToNullable image) sx sy sw sh dx dy
dw
dh)
foreign import javascript unsafe "$1[\"drawImage\"]($2, $3, $4)"
js_drawImageFromCanvas ::
CanvasRenderingContext2D ->
Nullable HTMLCanvasElement -> Float -> Float -> IO ()
drawImageFromCanvas ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement -> Float -> Float -> m ()
drawImageFromCanvas self canvas x y
= liftIO
(js_drawImageFromCanvas (self) (maybeToNullable canvas) x y)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6)"
js_drawImageFromCanvasScaled ::
CanvasRenderingContext2D ->
Nullable HTMLCanvasElement ->
Float -> Float -> Float -> Float -> IO ()
drawImageFromCanvasScaled ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement -> Float -> Float -> Float -> Float -> m ()
drawImageFromCanvasScaled self canvas x y width height
= liftIO
(js_drawImageFromCanvasScaled (self) (maybeToNullable canvas) x y
width
height)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6, $7, $8, $9, $10)"
js_drawImageFromCanvasPart ::
CanvasRenderingContext2D ->
Nullable HTMLCanvasElement ->
Float ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
drawImageFromCanvasPart ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> Float -> m ()
drawImageFromCanvasPart self canvas sx sy sw sh dx dy dw dh
= liftIO
(js_drawImageFromCanvasPart (self) (maybeToNullable canvas) sx sy
sw
sh
dx
dy
dw
dh)
foreign import javascript unsafe "$1[\"drawImage\"]($2, $3, $4)"
js_drawImageFromVideo ::
CanvasRenderingContext2D ->
Nullable HTMLVideoElement -> Float -> Float -> IO ()
drawImageFromVideo ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLVideoElement -> Float -> Float -> m ()
drawImageFromVideo self video x y
= liftIO (js_drawImageFromVideo (self) (maybeToNullable video) x y)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6)"
js_drawImageFromVideoScaled ::
CanvasRenderingContext2D ->
Nullable HTMLVideoElement ->
Float -> Float -> Float -> Float -> IO ()
drawImageFromVideoScaled ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLVideoElement -> Float -> Float -> Float -> Float -> m ()
drawImageFromVideoScaled self video x y width height
= liftIO
(js_drawImageFromVideoScaled (self) (maybeToNullable video) x y
width
height)
foreign import javascript unsafe
"$1[\"drawImage\"]($2, $3, $4, $5,\n$6, $7, $8, $9, $10)"
js_drawImageFromVideoPart ::
CanvasRenderingContext2D ->
Nullable HTMLVideoElement ->
Float ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
drawImageFromVideoPart ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe HTMLVideoElement ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> Float -> m ()
drawImageFromVideoPart self video sx sy sw sh dx dy dw dh
= liftIO
(js_drawImageFromVideoPart (self) (maybeToNullable video) sx sy sw
sh
dx
dy
dw
dh)
foreign import javascript unsafe
"$1[\"drawImageFromRect\"]($2, $3,\n$4, $5, $6, $7, $8, $9, $10,\n$11)"
js_drawImageFromRect ::
CanvasRenderingContext2D ->
Nullable HTMLImageElement ->
Float ->
Float ->
Float ->
Float -> Float -> Float -> Float -> Float -> JSString -> IO ()
drawImageFromRect ::
(MonadIO m, ToJSString compositeOperation) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement ->
Float ->
Float ->
Float ->
Float ->
Float -> Float -> Float -> Float -> compositeOperation -> m ()
drawImageFromRect self image sx sy sw sh dx dy dw dh
compositeOperation
= liftIO
(js_drawImageFromRect (self) (maybeToNullable image) sx sy sw sh dx
dy
dw
dh
(toJSString compositeOperation))
foreign import javascript unsafe
"$1[\"setShadow\"]($2, $3, $4, $5,\n$6)" js_setShadow ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> JSString -> Float -> IO ()
setShadow ::
(MonadIO m, ToJSString color) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> color -> Float -> m ()
setShadow self width height blur color alpha
= liftIO
(js_setShadow (self) width height blur (toJSString color) alpha)
foreign import javascript unsafe
"$1[\"setShadow\"]($2, $3, $4, $5,\n$6)" js_setShadowGray ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> IO ()
setShadowGray ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> m ()
setShadowGray self width height blur grayLevel alpha
= liftIO
(js_setShadowGray (self) width height blur grayLevel alpha)
foreign import javascript unsafe
"$1[\"setShadow\"]($2, $3, $4, $5,\n$6, $7, $8)" js_setShadowRGB ::
CanvasRenderingContext2D ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
setShadowRGB ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> Float -> Float -> Float -> m ()
setShadowRGB self width height blur r g b a
= liftIO (js_setShadowRGB (self) width height blur r g b a)
foreign import javascript unsafe
"$1[\"setShadow\"]($2, $3, $4, $5,\n$6, $7, $8, $9)"
js_setShadowCYMK ::
CanvasRenderingContext2D ->
Float ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
setShadowCYMK ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float ->
Float -> Float -> Float -> Float -> Float -> Float -> Float -> m ()
setShadowCYMK self width height blur c m y k a
= liftIO (js_setShadowCYMK (self) width height blur c m y k a)
foreign import javascript unsafe "$1[\"putImageData\"]($2, $3, $4)"
js_putImageData ::
CanvasRenderingContext2D ->
Nullable ImageData -> Float -> Float -> IO ()
putImageData ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe ImageData -> Float -> Float -> m ()
putImageData self imagedata dx dy
= liftIO (js_putImageData (self) (maybeToNullable imagedata) dx dy)
foreign import javascript unsafe
"$1[\"putImageData\"]($2, $3, $4,\n$5, $6, $7, $8)"
js_putImageDataDirty ::
CanvasRenderingContext2D ->
Nullable ImageData ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
putImageDataDirty ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe ImageData ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
putImageDataDirty self imagedata dx dy dirtyX dirtyY dirtyWidth
dirtyHeight
= liftIO
(js_putImageDataDirty (self) (maybeToNullable imagedata) dx dy
dirtyX
dirtyY
dirtyWidth
dirtyHeight)
foreign import javascript unsafe
"$1[\"webkitPutImageDataHD\"]($2,\n$3, $4)" js_webkitPutImageDataHD
::
CanvasRenderingContext2D ->
Nullable ImageData -> Float -> Float -> IO ()
webkitPutImageDataHD ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe ImageData -> Float -> Float -> m ()
webkitPutImageDataHD self imagedata dx dy
= liftIO
(js_webkitPutImageDataHD (self) (maybeToNullable imagedata) dx dy)
foreign import javascript unsafe
"$1[\"webkitPutImageDataHD\"]($2,\n$3, $4, $5, $6, $7, $8)"
js_webkitPutImageDataHDDirty ::
CanvasRenderingContext2D ->
Nullable ImageData ->
Float -> Float -> Float -> Float -> Float -> Float -> IO ()
webkitPutImageDataHDDirty ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Maybe ImageData ->
Float -> Float -> Float -> Float -> Float -> Float -> m ()
webkitPutImageDataHDDirty self imagedata dx dy dirtyX dirtyY
dirtyWidth dirtyHeight
= liftIO
(js_webkitPutImageDataHDDirty (self) (maybeToNullable imagedata) dx
dy
dirtyX
dirtyY
dirtyWidth
dirtyHeight)
foreign import javascript unsafe "$1[\"createPattern\"]($2, $3)"
js_createPatternFromCanvas ::
CanvasRenderingContext2D ->
Nullable HTMLCanvasElement ->
Nullable JSString -> IO (Nullable CanvasPattern)
createPatternFromCanvas ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement ->
Maybe repetitionType -> m (Maybe CanvasPattern)
createPatternFromCanvas self canvas repetitionType
= liftIO
(nullableToMaybe <$>
(js_createPatternFromCanvas (self) (maybeToNullable canvas)
(toMaybeJSString repetitionType)))
createPatternFromCanvas_ ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement -> Maybe repetitionType -> m ()
createPatternFromCanvas_ self canvas repetitionType
= liftIO
(void
(js_createPatternFromCanvas (self) (maybeToNullable canvas)
(toMaybeJSString repetitionType)))
createPatternFromCanvasUnsafe ::
(MonadIO m, ToJSString repetitionType, HasCallStack) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement -> Maybe repetitionType -> m CanvasPattern
createPatternFromCanvasUnsafe self canvas repetitionType
= liftIO
((nullableToMaybe <$>
(js_createPatternFromCanvas (self) (maybeToNullable canvas)
(toMaybeJSString repetitionType)))
>>= maybe (Prelude.error "Nothing to return") return)
createPatternFromCanvasUnchecked ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLCanvasElement ->
Maybe repetitionType -> m CanvasPattern
createPatternFromCanvasUnchecked self canvas repetitionType
= liftIO
(fromJust . nullableToMaybe <$>
(js_createPatternFromCanvas (self) (maybeToNullable canvas)
(toMaybeJSString repetitionType)))
foreign import javascript unsafe "$1[\"createPattern\"]($2, $3)"
js_createPattern ::
CanvasRenderingContext2D ->
Nullable HTMLImageElement ->
Nullable JSString -> IO (Nullable CanvasPattern)
createPattern ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement ->
Maybe repetitionType -> m (Maybe CanvasPattern)
createPattern self image repetitionType
= liftIO
(nullableToMaybe <$>
(js_createPattern (self) (maybeToNullable image)
(toMaybeJSString repetitionType)))
createPattern_ ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement -> Maybe repetitionType -> m ()
createPattern_ self image repetitionType
= liftIO
(void
(js_createPattern (self) (maybeToNullable image)
(toMaybeJSString repetitionType)))
createPatternUnsafe ::
(MonadIO m, ToJSString repetitionType, HasCallStack) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement -> Maybe repetitionType -> m CanvasPattern
createPatternUnsafe self image repetitionType
= liftIO
((nullableToMaybe <$>
(js_createPattern (self) (maybeToNullable image)
(toMaybeJSString repetitionType)))
>>= maybe (Prelude.error "Nothing to return") return)
createPatternUnchecked ::
(MonadIO m, ToJSString repetitionType) =>
CanvasRenderingContext2D ->
Maybe HTMLImageElement -> Maybe repetitionType -> m CanvasPattern
createPatternUnchecked self image repetitionType
= liftIO
(fromJust . nullableToMaybe <$>
(js_createPattern (self) (maybeToNullable image)
(toMaybeJSString repetitionType)))
foreign import javascript unsafe "$1[\"createImageData\"]($2)"
js_createImageData ::
CanvasRenderingContext2D ->
Nullable ImageData -> IO (Nullable ImageData)
createImageData ::
(MonadIO m) =>
CanvasRenderingContext2D -> Maybe ImageData -> m (Maybe ImageData)
createImageData self imagedata
= liftIO
(nullableToMaybe <$>
(js_createImageData (self) (maybeToNullable imagedata)))
createImageData_ ::
(MonadIO m) => CanvasRenderingContext2D -> Maybe ImageData -> m ()
createImageData_ self imagedata
= liftIO
(void (js_createImageData (self) (maybeToNullable imagedata)))
createImageDataUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D -> Maybe ImageData -> m ImageData
createImageDataUnsafe self imagedata
= liftIO
((nullableToMaybe <$>
(js_createImageData (self) (maybeToNullable imagedata)))
>>= maybe (Prelude.error "Nothing to return") return)
createImageDataUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D -> Maybe ImageData -> m ImageData
createImageDataUnchecked self imagedata
= liftIO
(fromJust . nullableToMaybe <$>
(js_createImageData (self) (maybeToNullable imagedata)))
foreign import javascript unsafe "$1[\"createImageData\"]($2, $3)"
js_createImageDataSize ::
CanvasRenderingContext2D ->
Float -> Float -> IO (Nullable ImageData)
createImageDataSize ::
(MonadIO m) =>
CanvasRenderingContext2D -> Float -> Float -> m (Maybe ImageData)
createImageDataSize self sw sh
= liftIO
(nullableToMaybe <$> (js_createImageDataSize (self) sw sh))
createImageDataSize_ ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> Float -> m ()
createImageDataSize_ self sw sh
= liftIO (void (js_createImageDataSize (self) sw sh))
createImageDataSizeUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D -> Float -> Float -> m ImageData
createImageDataSizeUnsafe self sw sh
= liftIO
((nullableToMaybe <$> (js_createImageDataSize (self) sw sh)) >>=
maybe (Prelude.error "Nothing to return") return)
createImageDataSizeUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D -> Float -> Float -> m ImageData
createImageDataSizeUnchecked self sw sh
= liftIO
(fromJust . nullableToMaybe <$>
(js_createImageDataSize (self) sw sh))
foreign import javascript unsafe
"$1[\"getImageData\"]($2, $3, $4,\n$5)" js_getImageData ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO (Nullable ImageData)
getImageData ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m (Maybe ImageData)
getImageData self sx sy sw sh
= liftIO (nullableToMaybe <$> (js_getImageData (self) sx sy sw sh))
getImageData_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
getImageData_ self sx sy sw sh
= liftIO (void (js_getImageData (self) sx sy sw sh))
getImageDataUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ImageData
getImageDataUnsafe self sx sy sw sh
= liftIO
((nullableToMaybe <$> (js_getImageData (self) sx sy sw sh)) >>=
maybe (Prelude.error "Nothing to return") return)
getImageDataUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ImageData
getImageDataUnchecked self sx sy sw sh
= liftIO
(fromJust . nullableToMaybe <$>
(js_getImageData (self) sx sy sw sh))
foreign import javascript unsafe
"$1[\"webkitGetImageDataHD\"]($2,\n$3, $4, $5)"
js_webkitGetImageDataHD ::
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> IO (Nullable ImageData)
webkitGetImageDataHD ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m (Maybe ImageData)
webkitGetImageDataHD self sx sy sw sh
= liftIO
(nullableToMaybe <$> (js_webkitGetImageDataHD (self) sx sy sw sh))
webkitGetImageDataHD_ ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ()
webkitGetImageDataHD_ self sx sy sw sh
= liftIO (void (js_webkitGetImageDataHD (self) sx sy sw sh))
webkitGetImageDataHDUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ImageData
webkitGetImageDataHDUnsafe self sx sy sw sh
= liftIO
((nullableToMaybe <$> (js_webkitGetImageDataHD (self) sx sy sw sh))
>>= maybe (Prelude.error "Nothing to return") return)
webkitGetImageDataHDUnchecked ::
(MonadIO m) =>
CanvasRenderingContext2D ->
Float -> Float -> Float -> Float -> m ImageData
webkitGetImageDataHDUnchecked self sx sy sw sh
= liftIO
(fromJust . nullableToMaybe <$>
(js_webkitGetImageDataHD (self) sx sy sw sh))
foreign import javascript unsafe "$1[\"drawFocusIfNeeded\"]($2)"
js_drawFocusIfNeeded ::
CanvasRenderingContext2D -> Nullable Element -> IO ()
drawFocusIfNeeded ::
(MonadIO m, IsElement element) =>
CanvasRenderingContext2D -> Maybe element -> m ()
drawFocusIfNeeded self element
= liftIO
(js_drawFocusIfNeeded (self)
(maybeToNullable (fmap toElement element)))
foreign import javascript unsafe
"$1[\"drawFocusIfNeeded\"]($2, $3)" js_drawFocusIfNeededPath ::
CanvasRenderingContext2D ->
Nullable Path2D -> Nullable Element -> IO ()
drawFocusIfNeededPath ::
(MonadIO m, IsElement element) =>
CanvasRenderingContext2D -> Maybe Path2D -> Maybe element -> m ()
drawFocusIfNeededPath self path element
= liftIO
(js_drawFocusIfNeededPath (self) (maybeToNullable path)
(maybeToNullable (fmap toElement element)))
foreign import javascript unsafe "$1[\"globalAlpha\"] = $2;"
js_setGlobalAlpha :: CanvasRenderingContext2D -> Float -> IO ()
setGlobalAlpha ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setGlobalAlpha self val = liftIO (js_setGlobalAlpha (self) val)
foreign import javascript unsafe "$1[\"globalAlpha\"]"
js_getGlobalAlpha :: CanvasRenderingContext2D -> IO Float
getGlobalAlpha ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getGlobalAlpha self = liftIO (js_getGlobalAlpha (self))
foreign import javascript unsafe
"$1[\"globalCompositeOperation\"] = $2;"
js_setGlobalCompositeOperation ::
CanvasRenderingContext2D -> Nullable JSString -> IO ()
setGlobalCompositeOperation ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setGlobalCompositeOperation self val
= liftIO
(js_setGlobalCompositeOperation (self) (toMaybeJSString val))
foreign import javascript unsafe "$1[\"globalCompositeOperation\"]"
js_getGlobalCompositeOperation ::
CanvasRenderingContext2D -> IO (Nullable JSString)
getGlobalCompositeOperation ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m (Maybe result)
getGlobalCompositeOperation self
= liftIO
(fromMaybeJSString <$> (js_getGlobalCompositeOperation (self)))
getGlobalCompositeOperationUnsafe ::
(MonadIO m, HasCallStack, FromJSString result) =>
CanvasRenderingContext2D -> m result
getGlobalCompositeOperationUnsafe self
= liftIO
((fromMaybeJSString <$> (js_getGlobalCompositeOperation (self)))
>>= maybe (Prelude.error "Nothing to return") return)
getGlobalCompositeOperationUnchecked ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getGlobalCompositeOperationUnchecked self
= liftIO
(fromJust . fromMaybeJSString <$>
(js_getGlobalCompositeOperation (self)))
foreign import javascript unsafe "$1[\"lineWidth\"] = $2;"
js_setLineWidth :: CanvasRenderingContext2D -> Float -> IO ()
setLineWidth ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setLineWidth self val = liftIO (js_setLineWidth (self) val)
foreign import javascript unsafe "$1[\"lineWidth\"]"
js_getLineWidth :: CanvasRenderingContext2D -> IO Float
getLineWidth :: (MonadIO m) => CanvasRenderingContext2D -> m Float
getLineWidth self = liftIO (js_getLineWidth (self))
foreign import javascript unsafe "$1[\"lineCap\"] = $2;"
js_setLineCap ::
CanvasRenderingContext2D -> Nullable JSString -> IO ()
setLineCap ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setLineCap self val
= liftIO (js_setLineCap (self) (toMaybeJSString val))
foreign import javascript unsafe "$1[\"lineCap\"]" js_getLineCap ::
CanvasRenderingContext2D -> IO (Nullable JSString)
getLineCap ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m (Maybe result)
getLineCap self
= liftIO (fromMaybeJSString <$> (js_getLineCap (self)))
getLineCapUnsafe ::
(MonadIO m, HasCallStack, FromJSString result) =>
CanvasRenderingContext2D -> m result
getLineCapUnsafe self
= liftIO
((fromMaybeJSString <$> (js_getLineCap (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getLineCapUnchecked ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getLineCapUnchecked self
= liftIO (fromJust . fromMaybeJSString <$> (js_getLineCap (self)))
foreign import javascript unsafe "$1[\"lineJoin\"] = $2;"
js_setLineJoin ::
CanvasRenderingContext2D -> Nullable JSString -> IO ()
setLineJoin ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setLineJoin self val
= liftIO (js_setLineJoin (self) (toMaybeJSString val))
foreign import javascript unsafe "$1[\"lineJoin\"]" js_getLineJoin
:: CanvasRenderingContext2D -> IO (Nullable JSString)
getLineJoin ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m (Maybe result)
getLineJoin self
= liftIO (fromMaybeJSString <$> (js_getLineJoin (self)))
getLineJoinUnsafe ::
(MonadIO m, HasCallStack, FromJSString result) =>
CanvasRenderingContext2D -> m result
getLineJoinUnsafe self
= liftIO
((fromMaybeJSString <$> (js_getLineJoin (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getLineJoinUnchecked ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getLineJoinUnchecked self
= liftIO (fromJust . fromMaybeJSString <$> (js_getLineJoin (self)))
foreign import javascript unsafe "$1[\"miterLimit\"] = $2;"
js_setMiterLimit :: CanvasRenderingContext2D -> Float -> IO ()
setMiterLimit ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setMiterLimit self val = liftIO (js_setMiterLimit (self) val)
foreign import javascript unsafe "$1[\"miterLimit\"]"
js_getMiterLimit :: CanvasRenderingContext2D -> IO Float
getMiterLimit :: (MonadIO m) => CanvasRenderingContext2D -> m Float
getMiterLimit self = liftIO (js_getMiterLimit (self))
foreign import javascript unsafe "$1[\"shadowOffsetX\"] = $2;"
js_setShadowOffsetX :: CanvasRenderingContext2D -> Float -> IO ()
setShadowOffsetX ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setShadowOffsetX self val = liftIO (js_setShadowOffsetX (self) val)
foreign import javascript unsafe "$1[\"shadowOffsetX\"]"
js_getShadowOffsetX :: CanvasRenderingContext2D -> IO Float
getShadowOffsetX ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getShadowOffsetX self = liftIO (js_getShadowOffsetX (self))
foreign import javascript unsafe "$1[\"shadowOffsetY\"] = $2;"
js_setShadowOffsetY :: CanvasRenderingContext2D -> Float -> IO ()
setShadowOffsetY ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setShadowOffsetY self val = liftIO (js_setShadowOffsetY (self) val)
foreign import javascript unsafe "$1[\"shadowOffsetY\"]"
js_getShadowOffsetY :: CanvasRenderingContext2D -> IO Float
getShadowOffsetY ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getShadowOffsetY self = liftIO (js_getShadowOffsetY (self))
foreign import javascript unsafe "$1[\"shadowBlur\"] = $2;"
js_setShadowBlur :: CanvasRenderingContext2D -> Float -> IO ()
setShadowBlur ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setShadowBlur self val = liftIO (js_setShadowBlur (self) val)
foreign import javascript unsafe "$1[\"shadowBlur\"]"
js_getShadowBlur :: CanvasRenderingContext2D -> IO Float
getShadowBlur :: (MonadIO m) => CanvasRenderingContext2D -> m Float
getShadowBlur self = liftIO (js_getShadowBlur (self))
foreign import javascript unsafe "$1[\"shadowColor\"] = $2;"
js_setShadowColor ::
CanvasRenderingContext2D -> Nullable JSString -> IO ()
setShadowColor ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setShadowColor self val
= liftIO (js_setShadowColor (self) (toMaybeJSString val))
foreign import javascript unsafe "$1[\"shadowColor\"]"
js_getShadowColor ::
CanvasRenderingContext2D -> IO (Nullable JSString)
getShadowColor ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m (Maybe result)
getShadowColor self
= liftIO (fromMaybeJSString <$> (js_getShadowColor (self)))
getShadowColorUnsafe ::
(MonadIO m, HasCallStack, FromJSString result) =>
CanvasRenderingContext2D -> m result
getShadowColorUnsafe self
= liftIO
((fromMaybeJSString <$> (js_getShadowColor (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getShadowColorUnchecked ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getShadowColorUnchecked self
= liftIO
(fromJust . fromMaybeJSString <$> (js_getShadowColor (self)))
foreign import javascript unsafe "$1[\"lineDashOffset\"] = $2;"
js_setLineDashOffset :: CanvasRenderingContext2D -> Float -> IO ()
setLineDashOffset ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setLineDashOffset self val
= liftIO (js_setLineDashOffset (self) val)
foreign import javascript unsafe "$1[\"lineDashOffset\"]"
js_getLineDashOffset :: CanvasRenderingContext2D -> IO Float
getLineDashOffset ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getLineDashOffset self = liftIO (js_getLineDashOffset (self))
foreign import javascript unsafe "$1[\"webkitLineDash\"] = $2;"
js_setWebkitLineDash ::
CanvasRenderingContext2D -> Nullable Array -> IO ()
setWebkitLineDash ::
(MonadIO m, IsArray val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setWebkitLineDash self val
= liftIO
(js_setWebkitLineDash (self) (maybeToNullable (fmap toArray val)))
foreign import javascript unsafe "$1[\"webkitLineDash\"]"
js_getWebkitLineDash ::
CanvasRenderingContext2D -> IO (Nullable Array)
getWebkitLineDash ::
(MonadIO m) => CanvasRenderingContext2D -> m (Maybe Array)
getWebkitLineDash self
= liftIO (nullableToMaybe <$> (js_getWebkitLineDash (self)))
getWebkitLineDashUnsafe ::
(MonadIO m, HasCallStack) => CanvasRenderingContext2D -> m Array
getWebkitLineDashUnsafe self
= liftIO
((nullableToMaybe <$> (js_getWebkitLineDash (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getWebkitLineDashUnchecked ::
(MonadIO m) => CanvasRenderingContext2D -> m Array
getWebkitLineDashUnchecked self
= liftIO
(fromJust . nullableToMaybe <$> (js_getWebkitLineDash (self)))
foreign import javascript unsafe
"$1[\"webkitLineDashOffset\"] = $2;" js_setWebkitLineDashOffset ::
CanvasRenderingContext2D -> Float -> IO ()
setWebkitLineDashOffset ::
(MonadIO m) => CanvasRenderingContext2D -> Float -> m ()
setWebkitLineDashOffset self val
= liftIO (js_setWebkitLineDashOffset (self) val)
foreign import javascript unsafe "$1[\"webkitLineDashOffset\"]"
js_getWebkitLineDashOffset :: CanvasRenderingContext2D -> IO Float
getWebkitLineDashOffset ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getWebkitLineDashOffset self
= liftIO (js_getWebkitLineDashOffset (self))
foreign import javascript unsafe "$1[\"font\"] = $2;" js_setFont ::
CanvasRenderingContext2D -> JSString -> IO ()
setFont ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> val -> m ()
setFont self val = liftIO (js_setFont (self) (toJSString val))
foreign import javascript unsafe "$1[\"font\"]" js_getFont ::
CanvasRenderingContext2D -> IO JSString
getFont ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getFont self = liftIO (fromJSString <$> (js_getFont (self)))
foreign import javascript unsafe "$1[\"textAlign\"] = $2;"
js_setTextAlign :: CanvasRenderingContext2D -> JSString -> IO ()
setTextAlign ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> val -> m ()
setTextAlign self val
= liftIO (js_setTextAlign (self) (toJSString val))
foreign import javascript unsafe "$1[\"textAlign\"]"
js_getTextAlign :: CanvasRenderingContext2D -> IO JSString
getTextAlign ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getTextAlign self
= liftIO (fromJSString <$> (js_getTextAlign (self)))
foreign import javascript unsafe "$1[\"textBaseline\"] = $2;"
js_setTextBaseline :: CanvasRenderingContext2D -> JSString -> IO ()
setTextBaseline ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> val -> m ()
setTextBaseline self val
= liftIO (js_setTextBaseline (self) (toJSString val))
foreign import javascript unsafe "$1[\"textBaseline\"]"
js_getTextBaseline :: CanvasRenderingContext2D -> IO JSString
getTextBaseline ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getTextBaseline self
= liftIO (fromJSString <$> (js_getTextBaseline (self)))
foreign import javascript unsafe "$1[\"direction\"] = $2;"
js_setDirection :: CanvasRenderingContext2D -> JSString -> IO ()
setDirection ::
(MonadIO m, ToJSString val) =>
CanvasRenderingContext2D -> val -> m ()
setDirection self val
= liftIO (js_setDirection (self) (toJSString val))
foreign import javascript unsafe "$1[\"direction\"]"
js_getDirection :: CanvasRenderingContext2D -> IO JSString
getDirection ::
(MonadIO m, FromJSString result) =>
CanvasRenderingContext2D -> m result
getDirection self
= liftIO (fromJSString <$> (js_getDirection (self)))
foreign import javascript unsafe "$1[\"strokeStyle\"] = $2;"
js_setStrokeStyle ::
CanvasRenderingContext2D -> Nullable CanvasStyle -> IO ()
setStrokeStyle ::
(MonadIO m, IsCanvasStyle val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setStrokeStyle self val
= liftIO
(js_setStrokeStyle (self)
(maybeToNullable (fmap toCanvasStyle val)))
foreign import javascript unsafe "$1[\"strokeStyle\"]"
js_getStrokeStyle ::
CanvasRenderingContext2D -> IO (Nullable CanvasStyle)
getStrokeStyle ::
(MonadIO m) => CanvasRenderingContext2D -> m (Maybe CanvasStyle)
getStrokeStyle self
= liftIO (nullableToMaybe <$> (js_getStrokeStyle (self)))
getStrokeStyleUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D -> m CanvasStyle
getStrokeStyleUnsafe self
= liftIO
((nullableToMaybe <$> (js_getStrokeStyle (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getStrokeStyleUnchecked ::
(MonadIO m) => CanvasRenderingContext2D -> m CanvasStyle
getStrokeStyleUnchecked self
= liftIO
(fromJust . nullableToMaybe <$> (js_getStrokeStyle (self)))
foreign import javascript unsafe "$1[\"fillStyle\"] = $2;"
js_setFillStyle ::
CanvasRenderingContext2D -> Nullable CanvasStyle -> IO ()
setFillStyle ::
(MonadIO m, IsCanvasStyle val) =>
CanvasRenderingContext2D -> Maybe val -> m ()
setFillStyle self val
= liftIO
(js_setFillStyle (self) (maybeToNullable (fmap toCanvasStyle val)))
foreign import javascript unsafe "$1[\"fillStyle\"]"
js_getFillStyle ::
CanvasRenderingContext2D -> IO (Nullable CanvasStyle)
getFillStyle ::
(MonadIO m) => CanvasRenderingContext2D -> m (Maybe CanvasStyle)
getFillStyle self
= liftIO (nullableToMaybe <$> (js_getFillStyle (self)))
getFillStyleUnsafe ::
(MonadIO m, HasCallStack) =>
CanvasRenderingContext2D -> m CanvasStyle
getFillStyleUnsafe self
= liftIO
((nullableToMaybe <$> (js_getFillStyle (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getFillStyleUnchecked ::
(MonadIO m) => CanvasRenderingContext2D -> m CanvasStyle
getFillStyleUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getFillStyle (self)))
foreign import javascript unsafe
"$1[\"webkitBackingStorePixelRatio\"]"
js_getWebkitBackingStorePixelRatio ::
CanvasRenderingContext2D -> IO Float
getWebkitBackingStorePixelRatio ::
(MonadIO m) => CanvasRenderingContext2D -> m Float
getWebkitBackingStorePixelRatio self
= liftIO (js_getWebkitBackingStorePixelRatio (self))
foreign import javascript unsafe
"$1[\"webkitImageSmoothingEnabled\"] = $2;"
js_setWebkitImageSmoothingEnabled ::
CanvasRenderingContext2D -> Bool -> IO ()
setWebkitImageSmoothingEnabled ::
(MonadIO m) => CanvasRenderingContext2D -> Bool -> m ()
setWebkitImageSmoothingEnabled self val
= liftIO (js_setWebkitImageSmoothingEnabled (self) val)
foreign import javascript unsafe
"($1[\"webkitImageSmoothingEnabled\"] ? 1 : 0)"
js_getWebkitImageSmoothingEnabled ::
CanvasRenderingContext2D -> IO Bool
getWebkitImageSmoothingEnabled ::
(MonadIO m) => CanvasRenderingContext2D -> m Bool
getWebkitImageSmoothingEnabled self
= liftIO (js_getWebkitImageSmoothingEnabled (self))