{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.Canvas.Canvas' structure contains
-- private data and should only be accessed using the provided
-- API.
-- 
-- /Since: 1.10/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Objects.Canvas
    ( 

-- * Exported types
    Canvas(..)                              ,
    IsCanvas                                ,
    toCanvas                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [invalidate]("GI.Clutter.Interfaces.Content#g:method:invalidate"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getPreferredSize]("GI.Clutter.Interfaces.Content#g:method:getPreferredSize"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getScaleFactor]("GI.Clutter.Objects.Canvas#g:method:getScaleFactor").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setScaleFactor]("GI.Clutter.Objects.Canvas#g:method:setScaleFactor"), [setSize]("GI.Clutter.Objects.Canvas#g:method:setSize").

#if defined(ENABLE_OVERLOADING)
    ResolveCanvasMethod                     ,
#endif

-- ** getScaleFactor #method:getScaleFactor#

#if defined(ENABLE_OVERLOADING)
    CanvasGetScaleFactorMethodInfo          ,
#endif
    canvasGetScaleFactor                    ,


-- ** new #method:new#

    canvasNew                               ,


-- ** setScaleFactor #method:setScaleFactor#

#if defined(ENABLE_OVERLOADING)
    CanvasSetScaleFactorMethodInfo          ,
#endif
    canvasSetScaleFactor                    ,


-- ** setSize #method:setSize#

#if defined(ENABLE_OVERLOADING)
    CanvasSetSizeMethodInfo                 ,
#endif
    canvasSetSize                           ,




 -- * Properties


-- ** height #attr:height#
-- | The height of the canvas.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    CanvasHeightPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    canvasHeight                            ,
#endif
    constructCanvasHeight                   ,
    getCanvasHeight                         ,
    setCanvasHeight                         ,


-- ** scaleFactor #attr:scaleFactor#
-- | The scaling factor to be applied to the Cairo surface used for
-- drawing.
-- 
-- If [Canvas:scaleFactor]("GI.Clutter.Objects.Canvas#g:attr:scaleFactor") is set to a negative value, the
-- value of the [Settings:windowScalingFactor]("GI.Clutter.Objects.Settings#g:attr:windowScalingFactor") property is
-- used instead.
-- 
-- Use [Canvas:scaleFactorSet]("GI.Clutter.Objects.Canvas#g:attr:scaleFactorSet") to check if the scale factor
-- is set.
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    CanvasScaleFactorPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    canvasScaleFactor                       ,
#endif
    constructCanvasScaleFactor              ,
    getCanvasScaleFactor                    ,
    setCanvasScaleFactor                    ,


-- ** scaleFactorSet #attr:scaleFactorSet#
-- | Whether the [Canvas:scaleFactor]("GI.Clutter.Objects.Canvas#g:attr:scaleFactor") property is set.
-- 
-- If the [Canvas:scaleFactorSet]("GI.Clutter.Objects.Canvas#g:attr:scaleFactorSet") property is 'P.False'
-- then t'GI.Clutter.Objects.Canvas.Canvas' will use the [Settings:windowScalingFactor]("GI.Clutter.Objects.Settings#g:attr:windowScalingFactor")
-- property.
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    CanvasScaleFactorSetPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    canvasScaleFactorSet                    ,
#endif
    getCanvasScaleFactorSet                 ,


-- ** width #attr:width#
-- | The width of the canvas.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    CanvasWidthPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    canvasWidth                             ,
#endif
    constructCanvasWidth                    ,
    getCanvasWidth                          ,
    setCanvasWidth                          ,




 -- * Signals


-- ** draw #signal:draw#

    CanvasDrawCallback                      ,
#if defined(ENABLE_OVERLOADING)
    CanvasDrawSignalInfo                    ,
#endif
    afterCanvasDraw                         ,
    onCanvasDraw                            ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animator as Clutter.Animator
import {-# SOURCE #-} qualified GI.Clutter.Objects.Backend as Clutter.Backend
import {-# SOURCE #-} qualified GI.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeviceManager as Clutter.DeviceManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Interval as Clutter.Interval
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutMeta as Clutter.LayoutMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Script as Clutter.Script
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.State as Clutter.State
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.AnimatorKey as Clutter.AnimatorKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.ButtonEvent as Clutter.ButtonEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.StateKey as Clutter.StateKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Json.Structs.Node as Json.Node
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import qualified GI.Cairo.Structs.Context as Cairo.Context
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

-- | Memory-managed wrapper type.
newtype Canvas = Canvas (SP.ManagedPtr Canvas)
    deriving (Canvas -> Canvas -> Bool
(Canvas -> Canvas -> Bool)
-> (Canvas -> Canvas -> Bool) -> Eq Canvas
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Canvas -> Canvas -> Bool
== :: Canvas -> Canvas -> Bool
$c/= :: Canvas -> Canvas -> Bool
/= :: Canvas -> Canvas -> Bool
Eq)

instance SP.ManagedPtrNewtype Canvas where
    toManagedPtr :: Canvas -> ManagedPtr Canvas
toManagedPtr (Canvas ManagedPtr Canvas
p) = ManagedPtr Canvas
p

foreign import ccall "clutter_canvas_get_type"
    c_clutter_canvas_get_type :: IO B.Types.GType

instance B.Types.TypedObject Canvas where
    glibType :: IO GType
glibType = IO GType
c_clutter_canvas_get_type

instance B.Types.GObject Canvas

-- | Type class for types which can be safely cast to `Canvas`, for instance with `toCanvas`.
class (SP.GObject o, O.IsDescendantOf Canvas o) => IsCanvas o
instance (SP.GObject o, O.IsDescendantOf Canvas o) => IsCanvas o

instance O.HasParentTypes Canvas
type instance O.ParentTypes Canvas = '[GObject.Object.Object, Clutter.Content.Content]

-- | Cast to `Canvas`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCanvas :: (MIO.MonadIO m, IsCanvas o) => o -> m Canvas
toCanvas :: forall (m :: * -> *) o. (MonadIO m, IsCanvas o) => o -> m Canvas
toCanvas = IO Canvas -> m Canvas
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Canvas -> m Canvas) -> (o -> IO Canvas) -> o -> m Canvas
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Canvas -> Canvas) -> o -> IO Canvas
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Canvas -> Canvas
Canvas

-- | Convert 'Canvas' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Canvas) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_canvas_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Canvas -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Canvas
P.Nothing = Ptr GValue -> Ptr Canvas -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Canvas
forall a. Ptr a
FP.nullPtr :: FP.Ptr Canvas)
    gvalueSet_ Ptr GValue
gv (P.Just Canvas
obj) = Canvas -> (Ptr Canvas -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Canvas
obj (Ptr GValue -> Ptr Canvas -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Canvas)
gvalueGet_ Ptr GValue
gv = do
        Ptr Canvas
ptr <- Ptr GValue -> IO (Ptr Canvas)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Canvas)
        if Ptr Canvas
ptr Ptr Canvas -> Ptr Canvas -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Canvas
forall a. Ptr a
FP.nullPtr
        then Canvas -> Maybe Canvas
forall a. a -> Maybe a
P.Just (Canvas -> Maybe Canvas) -> IO Canvas -> IO (Maybe Canvas)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Canvas -> Canvas) -> Ptr Canvas -> IO Canvas
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Canvas -> Canvas
Canvas Ptr Canvas
ptr
        else Maybe Canvas -> IO (Maybe Canvas)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Canvas
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveCanvasMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveCanvasMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCanvasMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCanvasMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCanvasMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCanvasMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCanvasMethod "invalidate" o = Clutter.Content.ContentInvalidateMethodInfo
    ResolveCanvasMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCanvasMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCanvasMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCanvasMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCanvasMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCanvasMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCanvasMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCanvasMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCanvasMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCanvasMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCanvasMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCanvasMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCanvasMethod "getPreferredSize" o = Clutter.Content.ContentGetPreferredSizeMethodInfo
    ResolveCanvasMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCanvasMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCanvasMethod "getScaleFactor" o = CanvasGetScaleFactorMethodInfo
    ResolveCanvasMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCanvasMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCanvasMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCanvasMethod "setScaleFactor" o = CanvasSetScaleFactorMethodInfo
    ResolveCanvasMethod "setSize" o = CanvasSetSizeMethodInfo
    ResolveCanvasMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCanvasMethod t Canvas, O.OverloadedMethod info Canvas p) => OL.IsLabel t (Canvas -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveCanvasMethod t Canvas, O.OverloadedMethod info Canvas p, R.HasField t Canvas p) => R.HasField t Canvas p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveCanvasMethod t Canvas, O.OverloadedMethodInfo info Canvas) => OL.IsLabel t (O.MethodProxy info Canvas) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Canvas::draw
-- | The [Canvas::draw]("GI.Clutter.Objects.Canvas#g:signal:draw") signal is emitted each time a canvas is
-- invalidated.
-- 
-- It is safe to connect multiple handlers to this signal: each
-- handler invocation will be automatically protected by @/cairo_save()/@
-- and @/cairo_restore()/@ pairs.
-- 
-- /Since: 1.10/
type CanvasDrawCallback =
    Cairo.Context.Context
    -- ^ /@cr@/: the Cairo context used to draw
    -> Int32
    -- ^ /@width@/: the width of the /@canvas@/
    -> Int32
    -- ^ /@height@/: the height of the /@canvas@/
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the signal emission should stop, and
    --   'P.False' otherwise

type C_CanvasDrawCallback =
    Ptr Canvas ->                           -- object
    Ptr Cairo.Context.Context ->
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_CanvasDrawCallback`.
foreign import ccall "wrapper"
    mk_CanvasDrawCallback :: C_CanvasDrawCallback -> IO (FunPtr C_CanvasDrawCallback)

wrap_CanvasDrawCallback :: 
    GObject a => (a -> CanvasDrawCallback) ->
    C_CanvasDrawCallback
wrap_CanvasDrawCallback :: forall a.
GObject a =>
(a -> CanvasDrawCallback) -> C_CanvasDrawCallback
wrap_CanvasDrawCallback a -> CanvasDrawCallback
gi'cb Ptr Canvas
gi'selfPtr Ptr Context
cr Int32
width Int32
height Ptr ()
_ = do
    Ptr Context -> (Context -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Context
cr ((Context -> IO CInt) -> IO CInt)
-> (Context -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Context
cr' -> do
        Bool
result <- Ptr Canvas -> (Canvas -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Canvas
gi'selfPtr ((Canvas -> IO Bool) -> IO Bool) -> (Canvas -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Canvas
gi'self -> a -> CanvasDrawCallback
gi'cb (Canvas -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Canvas
gi'self)  Context
cr' Int32
width Int32
height
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [draw](#signal:draw) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' canvas #draw callback
-- @
-- 
-- 
onCanvasDraw :: (IsCanvas a, MonadIO m) => a -> ((?self :: a) => CanvasDrawCallback) -> m SignalHandlerId
onCanvasDraw :: forall a (m :: * -> *).
(IsCanvas a, MonadIO m) =>
a -> ((?self::a) => CanvasDrawCallback) -> m SignalHandlerId
onCanvasDraw a
obj (?self::a) => CanvasDrawCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> CanvasDrawCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CanvasDrawCallback
CanvasDrawCallback
cb
    let wrapped' :: C_CanvasDrawCallback
wrapped' = (a -> CanvasDrawCallback) -> C_CanvasDrawCallback
forall a.
GObject a =>
(a -> CanvasDrawCallback) -> C_CanvasDrawCallback
wrap_CanvasDrawCallback a -> CanvasDrawCallback
wrapped
    FunPtr C_CanvasDrawCallback
wrapped'' <- C_CanvasDrawCallback -> IO (FunPtr C_CanvasDrawCallback)
mk_CanvasDrawCallback C_CanvasDrawCallback
wrapped'
    a
-> Text
-> FunPtr C_CanvasDrawCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"draw" FunPtr C_CanvasDrawCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [draw](#signal:draw) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' canvas #draw callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCanvasDraw :: (IsCanvas a, MonadIO m) => a -> ((?self :: a) => CanvasDrawCallback) -> m SignalHandlerId
afterCanvasDraw :: forall a (m :: * -> *).
(IsCanvas a, MonadIO m) =>
a -> ((?self::a) => CanvasDrawCallback) -> m SignalHandlerId
afterCanvasDraw a
obj (?self::a) => CanvasDrawCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> CanvasDrawCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CanvasDrawCallback
CanvasDrawCallback
cb
    let wrapped' :: C_CanvasDrawCallback
wrapped' = (a -> CanvasDrawCallback) -> C_CanvasDrawCallback
forall a.
GObject a =>
(a -> CanvasDrawCallback) -> C_CanvasDrawCallback
wrap_CanvasDrawCallback a -> CanvasDrawCallback
wrapped
    FunPtr C_CanvasDrawCallback
wrapped'' <- C_CanvasDrawCallback -> IO (FunPtr C_CanvasDrawCallback)
mk_CanvasDrawCallback C_CanvasDrawCallback
wrapped'
    a
-> Text
-> FunPtr C_CanvasDrawCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"draw" FunPtr C_CanvasDrawCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CanvasDrawSignalInfo
instance SignalInfo CanvasDrawSignalInfo where
    type HaskellCallbackType CanvasDrawSignalInfo = CanvasDrawCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CanvasDrawCallback cb
        cb'' <- mk_CanvasDrawCallback cb'
        connectSignalFunPtr obj "draw" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas::draw"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#g:signal:draw"})

#endif

-- VVV Prop "height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' canvas #height
-- @
getCanvasHeight :: (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasHeight :: forall (m :: * -> *) o. (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasHeight o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"height"

-- | Set the value of the “@height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' canvas [ #height 'Data.GI.Base.Attributes.:=' value ]
-- @
setCanvasHeight :: (MonadIO m, IsCanvas o) => o -> Int32 -> m ()
setCanvasHeight :: forall (m :: * -> *) o.
(MonadIO m, IsCanvas o) =>
o -> Int32 -> m ()
setCanvasHeight o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"height" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCanvasHeight :: (IsCanvas o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructCanvasHeight :: forall o (m :: * -> *).
(IsCanvas o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructCanvasHeight Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"height" Int32
val

#if defined(ENABLE_OVERLOADING)
data CanvasHeightPropertyInfo
instance AttrInfo CanvasHeightPropertyInfo where
    type AttrAllowedOps CanvasHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CanvasHeightPropertyInfo = IsCanvas
    type AttrSetTypeConstraint CanvasHeightPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint CanvasHeightPropertyInfo = (~) Int32
    type AttrTransferType CanvasHeightPropertyInfo = Int32
    type AttrGetType CanvasHeightPropertyInfo = Int32
    type AttrLabel CanvasHeightPropertyInfo = "height"
    type AttrOrigin CanvasHeightPropertyInfo = Canvas
    attrGet = getCanvasHeight
    attrSet = setCanvasHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructCanvasHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.height"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#g:attr:height"
        })
#endif

-- VVV Prop "scale-factor"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@scale-factor@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' canvas #scaleFactor
-- @
getCanvasScaleFactor :: (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasScaleFactor :: forall (m :: * -> *) o. (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasScaleFactor o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"scale-factor"

-- | Set the value of the “@scale-factor@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' canvas [ #scaleFactor 'Data.GI.Base.Attributes.:=' value ]
-- @
setCanvasScaleFactor :: (MonadIO m, IsCanvas o) => o -> Int32 -> m ()
setCanvasScaleFactor :: forall (m :: * -> *) o.
(MonadIO m, IsCanvas o) =>
o -> Int32 -> m ()
setCanvasScaleFactor o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"scale-factor" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-factor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCanvasScaleFactor :: (IsCanvas o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructCanvasScaleFactor :: forall o (m :: * -> *).
(IsCanvas o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructCanvasScaleFactor Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"scale-factor" Int32
val

#if defined(ENABLE_OVERLOADING)
data CanvasScaleFactorPropertyInfo
instance AttrInfo CanvasScaleFactorPropertyInfo where
    type AttrAllowedOps CanvasScaleFactorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CanvasScaleFactorPropertyInfo = IsCanvas
    type AttrSetTypeConstraint CanvasScaleFactorPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint CanvasScaleFactorPropertyInfo = (~) Int32
    type AttrTransferType CanvasScaleFactorPropertyInfo = Int32
    type AttrGetType CanvasScaleFactorPropertyInfo = Int32
    type AttrLabel CanvasScaleFactorPropertyInfo = "scale-factor"
    type AttrOrigin CanvasScaleFactorPropertyInfo = Canvas
    attrGet = getCanvasScaleFactor
    attrSet = setCanvasScaleFactor
    attrTransfer _ v = do
        return v
    attrConstruct = constructCanvasScaleFactor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.scaleFactor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#g:attr:scaleFactor"
        })
#endif

-- VVV Prop "scale-factor-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scale-factor-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' canvas #scaleFactorSet
-- @
getCanvasScaleFactorSet :: (MonadIO m, IsCanvas o) => o -> m Bool
getCanvasScaleFactorSet :: forall (m :: * -> *) o. (MonadIO m, IsCanvas o) => o -> m Bool
getCanvasScaleFactorSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"scale-factor-set"

#if defined(ENABLE_OVERLOADING)
data CanvasScaleFactorSetPropertyInfo
instance AttrInfo CanvasScaleFactorSetPropertyInfo where
    type AttrAllowedOps CanvasScaleFactorSetPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint CanvasScaleFactorSetPropertyInfo = IsCanvas
    type AttrSetTypeConstraint CanvasScaleFactorSetPropertyInfo = (~) ()
    type AttrTransferTypeConstraint CanvasScaleFactorSetPropertyInfo = (~) ()
    type AttrTransferType CanvasScaleFactorSetPropertyInfo = ()
    type AttrGetType CanvasScaleFactorSetPropertyInfo = Bool
    type AttrLabel CanvasScaleFactorSetPropertyInfo = "scale-factor-set"
    type AttrOrigin CanvasScaleFactorSetPropertyInfo = Canvas
    attrGet = getCanvasScaleFactorSet
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.scaleFactorSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#g:attr:scaleFactorSet"
        })
#endif

-- VVV Prop "width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' canvas #width
-- @
getCanvasWidth :: (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasWidth :: forall (m :: * -> *) o. (MonadIO m, IsCanvas o) => o -> m Int32
getCanvasWidth o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"width"

-- | Set the value of the “@width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' canvas [ #width 'Data.GI.Base.Attributes.:=' value ]
-- @
setCanvasWidth :: (MonadIO m, IsCanvas o) => o -> Int32 -> m ()
setCanvasWidth :: forall (m :: * -> *) o.
(MonadIO m, IsCanvas o) =>
o -> Int32 -> m ()
setCanvasWidth o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"width" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCanvasWidth :: (IsCanvas o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructCanvasWidth :: forall o (m :: * -> *).
(IsCanvas o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructCanvasWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"width" Int32
val

#if defined(ENABLE_OVERLOADING)
data CanvasWidthPropertyInfo
instance AttrInfo CanvasWidthPropertyInfo where
    type AttrAllowedOps CanvasWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CanvasWidthPropertyInfo = IsCanvas
    type AttrSetTypeConstraint CanvasWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint CanvasWidthPropertyInfo = (~) Int32
    type AttrTransferType CanvasWidthPropertyInfo = Int32
    type AttrGetType CanvasWidthPropertyInfo = Int32
    type AttrLabel CanvasWidthPropertyInfo = "width"
    type AttrOrigin CanvasWidthPropertyInfo = Canvas
    attrGet = getCanvasWidth
    attrSet = setCanvasWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructCanvasWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.width"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#g:attr:width"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Canvas
type instance O.AttributeList Canvas = CanvasAttributeList
type CanvasAttributeList = ('[ '("height", CanvasHeightPropertyInfo), '("scaleFactor", CanvasScaleFactorPropertyInfo), '("scaleFactorSet", CanvasScaleFactorSetPropertyInfo), '("width", CanvasWidthPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
canvasHeight :: AttrLabelProxy "height"
canvasHeight = AttrLabelProxy

canvasScaleFactor :: AttrLabelProxy "scaleFactor"
canvasScaleFactor = AttrLabelProxy

canvasScaleFactorSet :: AttrLabelProxy "scaleFactorSet"
canvasScaleFactorSet = AttrLabelProxy

canvasWidth :: AttrLabelProxy "width"
canvasWidth = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Canvas = CanvasSignalList
type CanvasSignalList = ('[ '("attached", Clutter.Content.ContentAttachedSignalInfo), '("detached", Clutter.Content.ContentDetachedSignalInfo), '("draw", CanvasDrawSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Canvas::get_scale_factor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "canvas"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Canvas" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterCanvas" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_canvas_get_scale_factor" clutter_canvas_get_scale_factor :: 
    Ptr Canvas ->                           -- canvas : TInterface (Name {namespace = "Clutter", name = "Canvas"})
    IO Int32

-- | Retrieves the scaling factor of /@canvas@/, as set using
-- 'GI.Clutter.Objects.Canvas.canvasSetScaleFactor'.
-- 
-- /Since: 1.18/
canvasGetScaleFactor ::
    (B.CallStack.HasCallStack, MonadIO m, IsCanvas a) =>
    a
    -- ^ /@canvas@/: a t'GI.Clutter.Objects.Canvas.Canvas'
    -> m Int32
    -- ^ __Returns:__ the scaling factor, or -1 if the /@canvas@/
    --   uses the default from t'GI.Clutter.Objects.Settings.Settings'
canvasGetScaleFactor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCanvas a) =>
a -> m Int32
canvasGetScaleFactor a
canvas = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Canvas
canvas' <- a -> IO (Ptr Canvas)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
canvas
    Int32
result <- Ptr Canvas -> IO Int32
clutter_canvas_get_scale_factor Ptr Canvas
canvas'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
canvas
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data CanvasGetScaleFactorMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCanvas a) => O.OverloadedMethod CanvasGetScaleFactorMethodInfo a signature where
    overloadedMethod = canvasGetScaleFactor

instance O.OverloadedMethodInfo CanvasGetScaleFactorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.canvasGetScaleFactor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#v:canvasGetScaleFactor"
        })


#endif

-- method Canvas::set_scale_factor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "canvas"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Canvas" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterCanvas" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scale factor, or -1 for the default"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_canvas_set_scale_factor" clutter_canvas_set_scale_factor :: 
    Ptr Canvas ->                           -- canvas : TInterface (Name {namespace = "Clutter", name = "Canvas"})
    Int32 ->                                -- scale : TBasicType TInt
    IO ()

-- | Sets the scaling factor for the Cairo surface used by /@canvas@/.
-- 
-- This function should rarely be used.
-- 
-- The default scaling factor of a t'GI.Clutter.Objects.Canvas.Canvas' content uses the
-- [Settings:windowScalingFactor]("GI.Clutter.Objects.Settings#g:attr:windowScalingFactor") property, which is set by
-- the windowing system. By using this function it is possible to
-- override that setting.
-- 
-- Changing the scale factor will invalidate the /@canvas@/.
-- 
-- /Since: 1.18/
canvasSetScaleFactor ::
    (B.CallStack.HasCallStack, MonadIO m, IsCanvas a) =>
    a
    -- ^ /@canvas@/: a t'GI.Clutter.Objects.Canvas.Canvas'
    -> Int32
    -- ^ /@scale@/: the scale factor, or -1 for the default
    -> m ()
canvasSetScaleFactor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCanvas a) =>
a -> Int32 -> m ()
canvasSetScaleFactor a
canvas Int32
scale = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Canvas
canvas' <- a -> IO (Ptr Canvas)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
canvas
    Ptr Canvas -> Int32 -> IO ()
clutter_canvas_set_scale_factor Ptr Canvas
canvas' Int32
scale
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
canvas
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CanvasSetScaleFactorMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsCanvas a) => O.OverloadedMethod CanvasSetScaleFactorMethodInfo a signature where
    overloadedMethod = canvasSetScaleFactor

instance O.OverloadedMethodInfo CanvasSetScaleFactorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.canvasSetScaleFactor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#v:canvasSetScaleFactor"
        })


#endif

-- method Canvas::set_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "canvas"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Canvas" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterCanvas" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width of the canvas, in pixels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height of the canvas, in pixels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_canvas_set_size" clutter_canvas_set_size :: 
    Ptr Canvas ->                           -- canvas : TInterface (Name {namespace = "Clutter", name = "Canvas"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO CInt

-- | Sets the size of the /@canvas@/, and invalidates the content.
-- 
-- This function will cause the /@canvas@/ to be invalidated only
-- if the size of the canvas surface has changed.
-- 
-- If you want to invalidate the contents of the /@canvas@/ when setting
-- the size, you can use the return value of the function to conditionally
-- call 'GI.Clutter.Interfaces.Content.contentInvalidate':
-- 
-- >
-- >  if (!clutter_canvas_set_size (canvas, width, height))
-- >    clutter_content_invalidate (CLUTTER_CONTENT (canvas));
-- 
-- 
-- /Since: 1.10/
canvasSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCanvas a) =>
    a
    -- ^ /@canvas@/: a t'GI.Clutter.Objects.Canvas.Canvas'
    -> Int32
    -- ^ /@width@/: the width of the canvas, in pixels
    -> Int32
    -- ^ /@height@/: the height of the canvas, in pixels
    -> m Bool
    -- ^ __Returns:__ this function returns 'P.True' if the size change
    --   caused a content invalidation, and 'P.False' otherwise
canvasSetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCanvas a) =>
a -> Int32 -> Int32 -> m Bool
canvasSetSize a
canvas Int32
width Int32
height = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Canvas
canvas' <- a -> IO (Ptr Canvas)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
canvas
    CInt
result <- Ptr Canvas -> Int32 -> Int32 -> IO CInt
clutter_canvas_set_size Ptr Canvas
canvas' Int32
width Int32
height
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
canvas
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CanvasSetSizeMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsCanvas a) => O.OverloadedMethod CanvasSetSizeMethodInfo a signature where
    overloadedMethod = canvasSetSize

instance O.OverloadedMethodInfo CanvasSetSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Canvas.canvasSetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Canvas.html#v:canvasSetSize"
        })


#endif

-- method Canvas::new
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Content" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_canvas_new" clutter_canvas_new :: 
    IO (Ptr Clutter.Content.Content)

-- | Creates a new instance of t'GI.Clutter.Objects.Canvas.Canvas'.
-- 
-- You should call 'GI.Clutter.Objects.Canvas.canvasSetSize' to set the size of the canvas.
-- 
-- You should call 'GI.Clutter.Interfaces.Content.contentInvalidate' every time you wish to
-- draw the contents of the canvas.
-- 
-- /Since: 1.10/
canvasNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Clutter.Content.Content
    -- ^ __Returns:__ The newly allocated instance of
    --   t'GI.Clutter.Objects.Canvas.Canvas'. Use 'GI.GObject.Objects.Object.objectUnref' when done.
canvasNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Content
canvasNew  = IO Content -> m Content
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Content -> m Content) -> IO Content -> m Content
forall a b. (a -> b) -> a -> b
$ do
    Ptr Content
result <- IO (Ptr Content)
clutter_canvas_new
    Text -> Ptr Content -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"canvasNew" Ptr Content
result
    Content
result' <- ((ManagedPtr Content -> Content) -> Ptr Content -> IO Content
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Content -> Content
Clutter.Content.Content) Ptr Content
result
    Content -> IO Content
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Content
result'

#if defined(ENABLE_OVERLOADING)
#endif