{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gdk.Objects.CairoContext.CairoContext' is an object representing the platform-specific
-- draw context.
-- 
-- @/GdkCairoContexts/@ are created for a t'GI.Gdk.Objects.Display.Display' using
-- 'GI.Gdk.Objects.Surface.surfaceCreateCairoContext', and the context can then be used
-- to draw on that t'GI.Gdk.Objects.Surface.Surface'.

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

module GI.Gdk.Objects.CairoContext
    ( 

-- * Exported types
    CairoContext(..)                        ,
    IsCairoContext                          ,
    toCairoContext                          ,
    noCairoContext                          ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveCairoContextMethod               ,
#endif


-- ** cairoCreate #method:cairoCreate#

#if defined(ENABLE_OVERLOADING)
    CairoContextCairoCreateMethodInfo       ,
#endif
    cairoContextCairoCreate                 ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
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 GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Objects.DrawContext as Gdk.DrawContext

-- | Memory-managed wrapper type.
newtype CairoContext = CairoContext (ManagedPtr CairoContext)
    deriving (CairoContext -> CairoContext -> Bool
(CairoContext -> CairoContext -> Bool)
-> (CairoContext -> CairoContext -> Bool) -> Eq CairoContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CairoContext -> CairoContext -> Bool
$c/= :: CairoContext -> CairoContext -> Bool
== :: CairoContext -> CairoContext -> Bool
$c== :: CairoContext -> CairoContext -> Bool
Eq)
foreign import ccall "gdk_cairo_context_get_type"
    c_gdk_cairo_context_get_type :: IO GType

instance GObject CairoContext where
    gobjectType :: IO GType
gobjectType = IO GType
c_gdk_cairo_context_get_type
    

-- | Convert 'CairoContext' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue CairoContext where
    toGValue :: CairoContext -> IO GValue
toGValue o :: CairoContext
o = do
        GType
gtype <- IO GType
c_gdk_cairo_context_get_type
        CairoContext -> (Ptr CairoContext -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CairoContext
o (GType
-> (GValue -> Ptr CairoContext -> IO ())
-> Ptr CairoContext
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr CairoContext -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO CairoContext
fromGValue gv :: GValue
gv = do
        Ptr CairoContext
ptr <- GValue -> IO (Ptr CairoContext)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr CairoContext)
        (ManagedPtr CairoContext -> CairoContext)
-> Ptr CairoContext -> IO CairoContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CairoContext -> CairoContext
CairoContext Ptr CairoContext
ptr
        
    

-- | Type class for types which can be safely cast to `CairoContext`, for instance with `toCairoContext`.
class (GObject o, O.IsDescendantOf CairoContext o) => IsCairoContext o
instance (GObject o, O.IsDescendantOf CairoContext o) => IsCairoContext o

instance O.HasParentTypes CairoContext
type instance O.ParentTypes CairoContext = '[Gdk.DrawContext.DrawContext, GObject.Object.Object]

-- | Cast to `CairoContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCairoContext :: (MonadIO m, IsCairoContext o) => o -> m CairoContext
toCairoContext :: o -> m CairoContext
toCairoContext = IO CairoContext -> m CairoContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CairoContext -> m CairoContext)
-> (o -> IO CairoContext) -> o -> m CairoContext
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr CairoContext -> CairoContext) -> o -> IO CairoContext
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr CairoContext -> CairoContext
CairoContext

-- | A convenience alias for `Nothing` :: `Maybe` `CairoContext`.
noCairoContext :: Maybe CairoContext
noCairoContext :: Maybe CairoContext
noCairoContext = Maybe CairoContext
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveCairoContextMethod (t :: Symbol) (o :: *) :: * where
    ResolveCairoContextMethod "beginFrame" o = Gdk.DrawContext.DrawContextBeginFrameMethodInfo
    ResolveCairoContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCairoContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCairoContextMethod "cairoCreate" o = CairoContextCairoCreateMethodInfo
    ResolveCairoContextMethod "endFrame" o = Gdk.DrawContext.DrawContextEndFrameMethodInfo
    ResolveCairoContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCairoContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCairoContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCairoContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCairoContextMethod "isInFrame" o = Gdk.DrawContext.DrawContextIsInFrameMethodInfo
    ResolveCairoContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCairoContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCairoContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCairoContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCairoContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCairoContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCairoContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCairoContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCairoContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCairoContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCairoContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCairoContextMethod "getDisplay" o = Gdk.DrawContext.DrawContextGetDisplayMethodInfo
    ResolveCairoContextMethod "getFrameRegion" o = Gdk.DrawContext.DrawContextGetFrameRegionMethodInfo
    ResolveCairoContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCairoContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCairoContextMethod "getSurface" o = Gdk.DrawContext.DrawContextGetSurfaceMethodInfo
    ResolveCairoContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCairoContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCairoContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCairoContextMethod l o = O.MethodResolutionFailed l o

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CairoContext
type instance O.AttributeList CairoContext = CairoContextAttributeList
type CairoContextAttributeList = ('[ '("display", Gdk.DrawContext.DrawContextDisplayPropertyInfo), '("surface", Gdk.DrawContext.DrawContextSurfacePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList CairoContext = CairoContextSignalList
type CairoContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method CairoContext::cairo_create
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "CairoContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkCairoContext that is currently drawing"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "cairo" , name = "Context" })
-- throws : False
-- Skip return : False

foreign import ccall "gdk_cairo_context_cairo_create" gdk_cairo_context_cairo_create :: 
    Ptr CairoContext ->                     -- self : TInterface (Name {namespace = "Gdk", name = "CairoContext"})
    IO (Ptr Cairo.Context.Context)

-- | Retrieves a Cairo context to be used to draw on the t'GI.Gdk.Objects.Surface.Surface'
-- of /@context@/. A call to 'GI.Gdk.Objects.DrawContext.drawContextBeginFrame' with this
-- /@context@/ must have been done or this function will return 'P.Nothing'.
-- 
-- The returned context is guaranteed to be valid until
-- 'GI.Gdk.Objects.DrawContext.drawContextEndFrame' is called.
cairoContextCairoCreate ::
    (B.CallStack.HasCallStack, MonadIO m, IsCairoContext a) =>
    a
    -- ^ /@self@/: a t'GI.Gdk.Objects.CairoContext.CairoContext' that is currently drawing
    -> m (Maybe Cairo.Context.Context)
    -- ^ __Returns:__ a Cairo context to be used
    --   to draw the contents of the t'GI.Gdk.Objects.Surface.Surface'. 'P.Nothing' is returned
    --   when /@contet@/ is not drawing.
cairoContextCairoCreate :: a -> m (Maybe Context)
cairoContextCairoCreate self :: a
self = IO (Maybe Context) -> m (Maybe Context)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Context) -> m (Maybe Context))
-> IO (Maybe Context) -> m (Maybe Context)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CairoContext
self' <- a -> IO (Ptr CairoContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Context
result <- Ptr CairoContext -> IO (Ptr Context)
gdk_cairo_context_cairo_create Ptr CairoContext
self'
    Maybe Context
maybeResult <- Ptr Context -> (Ptr Context -> IO Context) -> IO (Maybe Context)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Context
result ((Ptr Context -> IO Context) -> IO (Maybe Context))
-> (Ptr Context -> IO Context) -> IO (Maybe Context)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Context
result' -> do
        Context
result'' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Cairo.Context.Context) Ptr Context
result'
        Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Context -> IO (Maybe Context)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Context
maybeResult

#if defined(ENABLE_OVERLOADING)
data CairoContextCairoCreateMethodInfo
instance (signature ~ (m (Maybe Cairo.Context.Context)), MonadIO m, IsCairoContext a) => O.MethodInfo CairoContextCairoCreateMethodInfo a signature where
    overloadedMethod = cairoContextCairoCreate

#endif