{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

'GI.Gtk.Objects.ThemingEngine.ThemingEngine' was the object used for rendering themed content
in GTK+ widgets. It used to allow overriding GTK+\'s default
implementation of rendering functions by allowing engines to be
loaded as modules.

'GI.Gtk.Objects.ThemingEngine.ThemingEngine' has been deprecated in GTK+ 3.14 and will be
ignored for rendering. The advancements in CSS theming are good
enough to allow themers to achieve their goals without the need
to modify source code.
-}

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

module GI.Gtk.Objects.ThemingEngine
    (

-- * Exported types
    ThemingEngine(..)                       ,
    IsThemingEngine                         ,
    toThemingEngine                         ,
    noThemingEngine                         ,


 -- * Methods
-- ** getBackgroundColor #method:getBackgroundColor#

#if ENABLE_OVERLOADING
    ThemingEngineGetBackgroundColorMethodInfo,
#endif
    themingEngineGetBackgroundColor         ,


-- ** getBorder #method:getBorder#

#if ENABLE_OVERLOADING
    ThemingEngineGetBorderMethodInfo        ,
#endif
    themingEngineGetBorder                  ,


-- ** getBorderColor #method:getBorderColor#

#if ENABLE_OVERLOADING
    ThemingEngineGetBorderColorMethodInfo   ,
#endif
    themingEngineGetBorderColor             ,


-- ** getColor #method:getColor#

#if ENABLE_OVERLOADING
    ThemingEngineGetColorMethodInfo         ,
#endif
    themingEngineGetColor                   ,


-- ** getDirection #method:getDirection#

#if ENABLE_OVERLOADING
    ThemingEngineGetDirectionMethodInfo     ,
#endif
    themingEngineGetDirection               ,


-- ** getFont #method:getFont#

#if ENABLE_OVERLOADING
    ThemingEngineGetFontMethodInfo          ,
#endif
    themingEngineGetFont                    ,


-- ** getJunctionSides #method:getJunctionSides#

#if ENABLE_OVERLOADING
    ThemingEngineGetJunctionSidesMethodInfo ,
#endif
    themingEngineGetJunctionSides           ,


-- ** getMargin #method:getMargin#

#if ENABLE_OVERLOADING
    ThemingEngineGetMarginMethodInfo        ,
#endif
    themingEngineGetMargin                  ,


-- ** getPadding #method:getPadding#

#if ENABLE_OVERLOADING
    ThemingEngineGetPaddingMethodInfo       ,
#endif
    themingEngineGetPadding                 ,


-- ** getPath #method:getPath#

#if ENABLE_OVERLOADING
    ThemingEngineGetPathMethodInfo          ,
#endif
    themingEngineGetPath                    ,


-- ** getProperty #method:getProperty#

#if ENABLE_OVERLOADING
    ThemingEngineGetPropertyMethodInfo      ,
#endif
    themingEngineGetProperty                ,


-- ** getScreen #method:getScreen#

#if ENABLE_OVERLOADING
    ThemingEngineGetScreenMethodInfo        ,
#endif
    themingEngineGetScreen                  ,


-- ** getState #method:getState#

#if ENABLE_OVERLOADING
    ThemingEngineGetStateMethodInfo         ,
#endif
    themingEngineGetState                   ,


-- ** getStyleProperty #method:getStyleProperty#

#if ENABLE_OVERLOADING
    ThemingEngineGetStylePropertyMethodInfo ,
#endif
    themingEngineGetStyleProperty           ,


-- ** hasClass #method:hasClass#

#if ENABLE_OVERLOADING
    ThemingEngineHasClassMethodInfo         ,
#endif
    themingEngineHasClass                   ,


-- ** hasRegion #method:hasRegion#

#if ENABLE_OVERLOADING
    ThemingEngineHasRegionMethodInfo        ,
#endif
    themingEngineHasRegion                  ,


-- ** load #method:load#

    themingEngineLoad                       ,


-- ** lookupColor #method:lookupColor#

#if ENABLE_OVERLOADING
    ThemingEngineLookupColorMethodInfo      ,
#endif
    themingEngineLookupColor                ,


-- ** stateIsRunning #method:stateIsRunning#

#if ENABLE_OVERLOADING
    ThemingEngineStateIsRunningMethodInfo   ,
#endif
    themingEngineStateIsRunning             ,




 -- * Properties
-- ** name #attr:name#
{- | The theming engine name, this name will be used when registering
custom properties, for a theming engine named \"Clearlooks\" registering
a \"glossy\" custom property, it could be referenced in the CSS file as

>
>-Clearlooks-glossy: true;


/Since: 3.0/
-}
#if ENABLE_OVERLOADING
    ThemingEngineNamePropertyInfo           ,
#endif
    constructThemingEngineName              ,
    getThemingEngineName                    ,
#if ENABLE_OVERLOADING
    themingEngineName                       ,
#endif




    ) 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.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.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Objects.Screen as Gdk.Screen
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetPath as Gtk.WidgetPath
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription

-- | Memory-managed wrapper type.
newtype ThemingEngine = ThemingEngine (ManagedPtr ThemingEngine)
foreign import ccall "gtk_theming_engine_get_type"
    c_gtk_theming_engine_get_type :: IO GType

instance GObject ThemingEngine where
    gobjectType = c_gtk_theming_engine_get_type


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

instance O.HasParentTypes ThemingEngine
type instance O.ParentTypes ThemingEngine = '[GObject.Object.Object]

-- | Cast to `ThemingEngine`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toThemingEngine :: (MonadIO m, IsThemingEngine o) => o -> m ThemingEngine
toThemingEngine = liftIO . unsafeCastTo ThemingEngine

-- | A convenience alias for `Nothing` :: `Maybe` `ThemingEngine`.
noThemingEngine :: Maybe ThemingEngine
noThemingEngine = Nothing

#if ENABLE_OVERLOADING
type family ResolveThemingEngineMethod (t :: Symbol) (o :: *) :: * where
    ResolveThemingEngineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveThemingEngineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveThemingEngineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveThemingEngineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveThemingEngineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveThemingEngineMethod "hasClass" o = ThemingEngineHasClassMethodInfo
    ResolveThemingEngineMethod "hasRegion" o = ThemingEngineHasRegionMethodInfo
    ResolveThemingEngineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveThemingEngineMethod "lookupColor" o = ThemingEngineLookupColorMethodInfo
    ResolveThemingEngineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveThemingEngineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveThemingEngineMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveThemingEngineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveThemingEngineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveThemingEngineMethod "stateIsRunning" o = ThemingEngineStateIsRunningMethodInfo
    ResolveThemingEngineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveThemingEngineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveThemingEngineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveThemingEngineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveThemingEngineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveThemingEngineMethod "getBackgroundColor" o = ThemingEngineGetBackgroundColorMethodInfo
    ResolveThemingEngineMethod "getBorder" o = ThemingEngineGetBorderMethodInfo
    ResolveThemingEngineMethod "getBorderColor" o = ThemingEngineGetBorderColorMethodInfo
    ResolveThemingEngineMethod "getColor" o = ThemingEngineGetColorMethodInfo
    ResolveThemingEngineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveThemingEngineMethod "getDirection" o = ThemingEngineGetDirectionMethodInfo
    ResolveThemingEngineMethod "getFont" o = ThemingEngineGetFontMethodInfo
    ResolveThemingEngineMethod "getJunctionSides" o = ThemingEngineGetJunctionSidesMethodInfo
    ResolveThemingEngineMethod "getMargin" o = ThemingEngineGetMarginMethodInfo
    ResolveThemingEngineMethod "getPadding" o = ThemingEngineGetPaddingMethodInfo
    ResolveThemingEngineMethod "getPath" o = ThemingEngineGetPathMethodInfo
    ResolveThemingEngineMethod "getProperty" o = ThemingEngineGetPropertyMethodInfo
    ResolveThemingEngineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveThemingEngineMethod "getScreen" o = ThemingEngineGetScreenMethodInfo
    ResolveThemingEngineMethod "getState" o = ThemingEngineGetStateMethodInfo
    ResolveThemingEngineMethod "getStyleProperty" o = ThemingEngineGetStylePropertyMethodInfo
    ResolveThemingEngineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveThemingEngineMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveThemingEngineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveThemingEngineMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' themingEngine #name
@
-}
getThemingEngineName :: (MonadIO m, IsThemingEngine o) => o -> m (Maybe T.Text)
getThemingEngineName obj = liftIO $ B.Properties.getObjectPropertyString obj "name"

{- |
Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructThemingEngineName :: (IsThemingEngine o) => T.Text -> IO (GValueConstruct o)
constructThemingEngineName val = B.Properties.constructObjectPropertyString "name" (Just val)

#if ENABLE_OVERLOADING
data ThemingEngineNamePropertyInfo
instance AttrInfo ThemingEngineNamePropertyInfo where
    type AttrAllowedOps ThemingEngineNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ThemingEngineNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ThemingEngineNamePropertyInfo = IsThemingEngine
    type AttrGetType ThemingEngineNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ThemingEngineNamePropertyInfo = "name"
    type AttrOrigin ThemingEngineNamePropertyInfo = ThemingEngine
    attrGet _ = getThemingEngineName
    attrSet _ = undefined
    attrConstruct _ = constructThemingEngineName
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList ThemingEngine
type instance O.AttributeList ThemingEngine = ThemingEngineAttributeList
type ThemingEngineAttributeList = ('[ '("name", ThemingEngineNamePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
themingEngineName :: AttrLabelProxy "name"
themingEngineName = AttrLabelProxy

#endif

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

#endif

-- method ThemingEngine::get_background_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the color for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_background_color" gtk_theming_engine_get_background_color ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED themingEngineGetBackgroundColor ["(Since version 3.14)"] #-}
{- |
Gets the background color for a given state.

/Since: 3.0/
-}
themingEngineGetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the color for -}
    -> m (Gdk.RGBA.RGBA)
themingEngineGetBackgroundColor engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    gtk_theming_engine_get_background_color engine' state' color
    color' <- (wrapBoxed Gdk.RGBA.RGBA) color
    touchManagedPtr engine
    return color'

#if ENABLE_OVERLOADING
data ThemingEngineGetBackgroundColorMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gdk.RGBA.RGBA)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetBackgroundColorMethodInfo a signature where
    overloadedMethod _ = themingEngineGetBackgroundColor

#endif

-- method ThemingEngine::get_border
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the border for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "border", argType = TInterface (Name {namespace = "Gtk", name = "Border"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the border settings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_border" gtk_theming_engine_get_border ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gtk.Border.Border ->                -- border : TInterface (Name {namespace = "Gtk", name = "Border"})
    IO ()

{-# DEPRECATED themingEngineGetBorder ["(Since version 3.14)"] #-}
{- |
Gets the border for a given state as a 'GI.Gtk.Structs.Border.Border'.

/Since: 3.0/
-}
themingEngineGetBorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the border for -}
    -> m (Gtk.Border.Border)
themingEngineGetBorder engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    border <- callocBoxedBytes 8 :: IO (Ptr Gtk.Border.Border)
    gtk_theming_engine_get_border engine' state' border
    border' <- (wrapBoxed Gtk.Border.Border) border
    touchManagedPtr engine
    return border'

#if ENABLE_OVERLOADING
data ThemingEngineGetBorderMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gtk.Border.Border)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetBorderMethodInfo a signature where
    overloadedMethod _ = themingEngineGetBorder

#endif

-- method ThemingEngine::get_border_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the color for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the border color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_border_color" gtk_theming_engine_get_border_color ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED themingEngineGetBorderColor ["(Since version 3.14)"] #-}
{- |
Gets the border color for a given state.

/Since: 3.0/
-}
themingEngineGetBorderColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the color for -}
    -> m (Gdk.RGBA.RGBA)
themingEngineGetBorderColor engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    gtk_theming_engine_get_border_color engine' state' color
    color' <- (wrapBoxed Gdk.RGBA.RGBA) color
    touchManagedPtr engine
    return color'

#if ENABLE_OVERLOADING
data ThemingEngineGetBorderColorMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gdk.RGBA.RGBA)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetBorderColorMethodInfo a signature where
    overloadedMethod _ = themingEngineGetBorderColor

#endif

-- method ThemingEngine::get_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the color for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the foreground color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_color" gtk_theming_engine_get_color ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED themingEngineGetColor ["(Since version 3.14)"] #-}
{- |
Gets the foreground color for a given state.

/Since: 3.0/
-}
themingEngineGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the color for -}
    -> m (Gdk.RGBA.RGBA)
themingEngineGetColor engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    gtk_theming_engine_get_color engine' state' color
    color' <- (wrapBoxed Gdk.RGBA.RGBA) color
    touchManagedPtr engine
    return color'

#if ENABLE_OVERLOADING
data ThemingEngineGetColorMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gdk.RGBA.RGBA)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetColorMethodInfo a signature where
    overloadedMethod _ = themingEngineGetColor

#endif

-- method ThemingEngine::get_direction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextDirection"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_direction" gtk_theming_engine_get_direction ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    IO CUInt

{-# DEPRECATED themingEngineGetDirection ["(Since version 3.8)","Use 'GI.Gtk.Objects.ThemingEngine.themingEngineGetState' and","  check for @/GTK_STATE_FLAG_DIR_LTR/@ and","  @/GTK_STATE_FLAG_DIR_RTL/@ instead."] #-}
{- |
Returns the widget direction used for rendering.

/Since: 3.0/
-}
themingEngineGetDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> m Gtk.Enums.TextDirection
    {- ^ __Returns:__ the widget direction -}
themingEngineGetDirection engine = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    result <- gtk_theming_engine_get_direction engine'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr engine
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineGetDirectionMethodInfo
instance (signature ~ (m Gtk.Enums.TextDirection), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetDirectionMethodInfo a signature where
    overloadedMethod _ = themingEngineGetDirection

#endif

-- method ThemingEngine::get_font
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the font for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "FontDescription"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_font" gtk_theming_engine_get_font ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    IO (Ptr Pango.FontDescription.FontDescription)

{-# DEPRECATED themingEngineGetFont ["(Since version 3.8)","Use @/gtk_theming_engine_get()/@"] #-}
{- |
Returns the font description for a given state.

/Since: 3.0/
-}
themingEngineGetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the font for -}
    -> m Pango.FontDescription.FontDescription
    {- ^ __Returns:__ the 'GI.Pango.Structs.FontDescription.FontDescription' for the given
         state. This object is owned by GTK+ and should not be
         freed. -}
themingEngineGetFont engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    result <- gtk_theming_engine_get_font engine' state'
    checkUnexpectedReturnNULL "themingEngineGetFont" result
    result' <- (newBoxed Pango.FontDescription.FontDescription) result
    touchManagedPtr engine
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineGetFontMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m Pango.FontDescription.FontDescription), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetFontMethodInfo a signature where
    overloadedMethod _ = themingEngineGetFont

#endif

-- method ThemingEngine::get_junction_sides
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "JunctionSides"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_junction_sides" gtk_theming_engine_get_junction_sides ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    IO CUInt

{-# DEPRECATED themingEngineGetJunctionSides ["(Since version 3.14)"] #-}
{- |
Returns the widget direction used for rendering.

/Since: 3.0/
-}
themingEngineGetJunctionSides ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> m [Gtk.Flags.JunctionSides]
    {- ^ __Returns:__ the widget direction -}
themingEngineGetJunctionSides engine = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    result <- gtk_theming_engine_get_junction_sides engine'
    let result' = wordToGFlags result
    touchManagedPtr engine
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineGetJunctionSidesMethodInfo
instance (signature ~ (m [Gtk.Flags.JunctionSides]), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetJunctionSidesMethodInfo a signature where
    overloadedMethod _ = themingEngineGetJunctionSides

#endif

-- method ThemingEngine::get_margin
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the border for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TInterface (Name {namespace = "Gtk", name = "Border"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the margin settings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_margin" gtk_theming_engine_get_margin ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gtk.Border.Border ->                -- margin : TInterface (Name {namespace = "Gtk", name = "Border"})
    IO ()

{-# DEPRECATED themingEngineGetMargin ["(Since version 3.14)"] #-}
{- |
Gets the margin for a given state as a 'GI.Gtk.Structs.Border.Border'.

/Since: 3.0/
-}
themingEngineGetMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the border for -}
    -> m (Gtk.Border.Border)
themingEngineGetMargin engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    margin <- callocBoxedBytes 8 :: IO (Ptr Gtk.Border.Border)
    gtk_theming_engine_get_margin engine' state' margin
    margin' <- (wrapBoxed Gtk.Border.Border) margin
    touchManagedPtr engine
    return margin'

#if ENABLE_OVERLOADING
data ThemingEngineGetMarginMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gtk.Border.Border)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetMarginMethodInfo a signature where
    overloadedMethod _ = themingEngineGetMargin

#endif

-- method ThemingEngine::get_padding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the padding for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "padding", argType = TInterface (Name {namespace = "Gtk", name = "Border"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the padding settings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_padding" gtk_theming_engine_get_padding ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gtk.Border.Border ->                -- padding : TInterface (Name {namespace = "Gtk", name = "Border"})
    IO ()

{-# DEPRECATED themingEngineGetPadding ["(Since version 3.14)"] #-}
{- |
Gets the padding for a given state as a 'GI.Gtk.Structs.Border.Border'.

/Since: 3.0/
-}
themingEngineGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the padding for -}
    -> m (Gtk.Border.Border)
themingEngineGetPadding engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = gflagsToWord state
    padding <- callocBoxedBytes 8 :: IO (Ptr Gtk.Border.Border)
    gtk_theming_engine_get_padding engine' state' padding
    padding' <- (wrapBoxed Gtk.Border.Border) padding
    touchManagedPtr engine
    return padding'

#if ENABLE_OVERLOADING
data ThemingEngineGetPaddingMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m (Gtk.Border.Border)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetPaddingMethodInfo a signature where
    overloadedMethod _ = themingEngineGetPadding

#endif

-- method ThemingEngine::get_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "WidgetPath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_path" gtk_theming_engine_get_path ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    IO (Ptr Gtk.WidgetPath.WidgetPath)

{-# DEPRECATED themingEngineGetPath ["(Since version 3.14)"] #-}
{- |
Returns the widget path used for style matching.

/Since: 3.0/
-}
themingEngineGetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> m Gtk.WidgetPath.WidgetPath
    {- ^ __Returns:__ A 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
themingEngineGetPath engine = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    result <- gtk_theming_engine_get_path engine'
    checkUnexpectedReturnNULL "themingEngineGetPath" result
    result' <- (newBoxed Gtk.WidgetPath.WidgetPath) result
    touchManagedPtr engine
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineGetPathMethodInfo
instance (signature ~ (m Gtk.WidgetPath.WidgetPath), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetPathMethodInfo a signature where
    overloadedMethod _ = themingEngineGetPath

#endif

-- method ThemingEngine::get_property
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state to retrieve the value for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the property value,\n        you must free this memory using g_value_unset() once you are\n        done with it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_property" gtk_theming_engine_get_property ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CString ->                              -- property : TBasicType TUTF8
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO ()

{-# DEPRECATED themingEngineGetProperty ["(Since version 3.14)"] #-}
{- |
Gets a property value as retrieved from the style settings that apply
to the currently rendered element.

/Since: 3.0/
-}
themingEngineGetProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> T.Text
    {- ^ /@property@/: the property name -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state to retrieve the value for -}
    -> m (GValue)
themingEngineGetProperty engine property state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    property' <- textToCString property
    let state' = gflagsToWord state
    value <- callocBoxedBytes 24 :: IO (Ptr GValue)
    gtk_theming_engine_get_property engine' property' state' value
    value' <- (wrapBoxed GValue) value
    touchManagedPtr engine
    freeMem property'
    return value'

#if ENABLE_OVERLOADING
data ThemingEngineGetPropertyMethodInfo
instance (signature ~ (T.Text -> [Gtk.Flags.StateFlags] -> m (GValue)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetPropertyMethodInfo a signature where
    overloadedMethod _ = themingEngineGetProperty

#endif

-- method ThemingEngine::get_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Screen"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_screen" gtk_theming_engine_get_screen ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    IO (Ptr Gdk.Screen.Screen)

{-# DEPRECATED themingEngineGetScreen ["(Since version 3.14)"] #-}
{- |
Returns the 'GI.Gdk.Objects.Screen.Screen' to which /@engine@/ currently rendering to.
-}
themingEngineGetScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> m (Maybe Gdk.Screen.Screen)
    {- ^ __Returns:__ a 'GI.Gdk.Objects.Screen.Screen', or 'Nothing'. -}
themingEngineGetScreen engine = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    result <- gtk_theming_engine_get_screen engine'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Screen.Screen) result'
        return result''
    touchManagedPtr engine
    return maybeResult

#if ENABLE_OVERLOADING
data ThemingEngineGetScreenMethodInfo
instance (signature ~ (m (Maybe Gdk.Screen.Screen)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetScreenMethodInfo a signature where
    overloadedMethod _ = themingEngineGetScreen

#endif

-- method ThemingEngine::get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StateFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_state" gtk_theming_engine_get_state ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    IO CUInt

{-# DEPRECATED themingEngineGetState ["(Since version 3.14)"] #-}
{- |
returns the state used when rendering.

/Since: 3.0/
-}
themingEngineGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> m [Gtk.Flags.StateFlags]
    {- ^ __Returns:__ the state flags -}
themingEngineGetState engine = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    result <- gtk_theming_engine_get_state engine'
    let result' = wordToGFlags result
    touchManagedPtr engine
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineGetStateMethodInfo
instance (signature ~ (m [Gtk.Flags.StateFlags]), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetStateMethodInfo a signature where
    overloadedMethod _ = themingEngineGetState

#endif

-- method ThemingEngine::get_style_property
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the widget style property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the property value, free with\n        g_value_unset() after use.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_get_style_property" gtk_theming_engine_get_style_property ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO ()

{-# DEPRECATED themingEngineGetStyleProperty ["(Since version 3.14)"] #-}
{- |
Gets the value for a widget style property.

/Since: 3.0/
-}
themingEngineGetStyleProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> T.Text
    {- ^ /@propertyName@/: the name of the widget style property -}
    -> m (GValue)
themingEngineGetStyleProperty engine propertyName = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    propertyName' <- textToCString propertyName
    value <- callocBoxedBytes 24 :: IO (Ptr GValue)
    gtk_theming_engine_get_style_property engine' propertyName' value
    value' <- (wrapBoxed GValue) value
    touchManagedPtr engine
    freeMem propertyName'
    return value'

#if ENABLE_OVERLOADING
data ThemingEngineGetStylePropertyMethodInfo
instance (signature ~ (T.Text -> m (GValue)), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineGetStylePropertyMethodInfo a signature where
    overloadedMethod _ = themingEngineGetStyleProperty

#endif

-- method ThemingEngine::has_class
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class name to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_has_class" gtk_theming_engine_has_class ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CString ->                              -- style_class : TBasicType TUTF8
    IO CInt

{-# DEPRECATED themingEngineHasClass ["(Since version 3.14)"] #-}
{- |
Returns 'True' if the currently rendered contents have
defined the given class name.

/Since: 3.0/
-}
themingEngineHasClass ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> T.Text
    {- ^ /@styleClass@/: class name to look up -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@engine@/ has /@className@/ defined -}
themingEngineHasClass engine styleClass = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    styleClass' <- textToCString styleClass
    result <- gtk_theming_engine_has_class engine' styleClass'
    let result' = (/= 0) result
    touchManagedPtr engine
    freeMem styleClass'
    return result'

#if ENABLE_OVERLOADING
data ThemingEngineHasClassMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineHasClassMethodInfo a signature where
    overloadedMethod _ = themingEngineHasClass

#endif

-- method ThemingEngine::has_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style_region", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a region name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "RegionFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for region flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_has_region" gtk_theming_engine_has_region ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CString ->                              -- style_region : TBasicType TUTF8
    Ptr CUInt ->                            -- flags : TInterface (Name {namespace = "Gtk", name = "RegionFlags"})
    IO CInt

{-# DEPRECATED themingEngineHasRegion ["(Since version 3.14)"] #-}
{- |
Returns 'True' if the currently rendered contents have the
region defined. If /@flagsReturn@/ is not 'Nothing', it is set
to the flags affecting the region.

/Since: 3.0/
-}
themingEngineHasRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> T.Text
    {- ^ /@styleRegion@/: a region name -}
    -> m ((Bool, [Gtk.Flags.RegionFlags]))
    {- ^ __Returns:__ 'True' if region is defined -}
themingEngineHasRegion engine styleRegion = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    styleRegion' <- textToCString styleRegion
    flags <- allocMem :: IO (Ptr CUInt)
    result <- gtk_theming_engine_has_region engine' styleRegion' flags
    let result' = (/= 0) result
    flags' <- peek flags
    let flags'' = wordToGFlags flags'
    touchManagedPtr engine
    freeMem styleRegion'
    freeMem flags
    return (result', flags'')

#if ENABLE_OVERLOADING
data ThemingEngineHasRegionMethodInfo
instance (signature ~ (T.Text -> m ((Bool, [Gtk.Flags.RegionFlags]))), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineHasRegionMethodInfo a signature where
    overloadedMethod _ = themingEngineHasRegion

#endif

-- method ThemingEngine::lookup_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "color name to lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the looked up color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_lookup_color" gtk_theming_engine_lookup_color ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CString ->                              -- color_name : TBasicType TUTF8
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO CInt

{-# DEPRECATED themingEngineLookupColor ["(Since version 3.14)"] #-}
{- |
Looks up and resolves a color name in the current style’s color map.

/Since: 3.0/
-}
themingEngineLookupColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> T.Text
    {- ^ /@colorName@/: color name to lookup -}
    -> m ((Bool, Gdk.RGBA.RGBA))
    {- ^ __Returns:__ 'True' if /@colorName@/ was found and resolved, 'False' otherwise -}
themingEngineLookupColor engine colorName = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    colorName' <- textToCString colorName
    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    result <- gtk_theming_engine_lookup_color engine' colorName' color
    let result' = (/= 0) result
    color' <- (wrapBoxed Gdk.RGBA.RGBA) color
    touchManagedPtr engine
    freeMem colorName'
    return (result', color')

#if ENABLE_OVERLOADING
data ThemingEngineLookupColorMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineLookupColorMethodInfo a signature where
    overloadedMethod _ = themingEngineLookupColor

#endif

-- method ThemingEngine::state_is_running
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "engine", argType = TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkThemingEngine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the transition progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_state_is_running" gtk_theming_engine_state_is_running ::
    Ptr ThemingEngine ->                    -- engine : TInterface (Name {namespace = "Gtk", name = "ThemingEngine"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    Ptr CDouble ->                          -- progress : TBasicType TDouble
    IO CInt

{-# DEPRECATED themingEngineStateIsRunning ["(Since version 3.6)","Always returns 'False'"] #-}
{- |
Returns 'True' if there is a transition animation running for the
current region (see 'GI.Gtk.Objects.StyleContext.styleContextPushAnimatableRegion').

If /@progress@/ is not 'Nothing', the animation progress will be returned
there, 0.0 means the state is closest to being 'False', while 1.0 means
it’s closest to being 'True'. This means transition animations will
run from 0 to 1 when /@state@/ is being set to 'True' and from 1 to 0 when
it’s being set to 'False'.

/Since: 3.0/
-}
themingEngineStateIsRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    {- ^ /@engine@/: a 'GI.Gtk.Objects.ThemingEngine.ThemingEngine' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: a widget state -}
    -> m ((Bool, Double))
    {- ^ __Returns:__ 'True' if there is a running transition animation for /@state@/. -}
themingEngineStateIsRunning engine state = liftIO $ do
    engine' <- unsafeManagedPtrCastPtr engine
    let state' = (fromIntegral . fromEnum) state
    progress <- allocMem :: IO (Ptr CDouble)
    result <- gtk_theming_engine_state_is_running engine' state' progress
    let result' = (/= 0) result
    progress' <- peek progress
    let progress'' = realToFrac progress'
    touchManagedPtr engine
    freeMem progress
    return (result', progress'')

#if ENABLE_OVERLOADING
data ThemingEngineStateIsRunningMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> m ((Bool, Double))), MonadIO m, IsThemingEngine a) => O.MethodInfo ThemingEngineStateIsRunningMethodInfo a signature where
    overloadedMethod _ = themingEngineStateIsRunning

#endif

-- method ThemingEngine::load
-- method type : MemberFunction
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Theme engine name to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "ThemingEngine"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_theming_engine_load" gtk_theming_engine_load ::
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr ThemingEngine)

{-# DEPRECATED themingEngineLoad ["(Since version 3.14)"] #-}
{- |
Loads and initializes a theming engine module from the
standard directories.
-}
themingEngineLoad ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: Theme engine name to load -}
    -> m (Maybe ThemingEngine)
    {- ^ __Returns:__ A theming engine, or 'Nothing' if
the engine /@name@/ doesn’t exist. -}
themingEngineLoad name = liftIO $ do
    name' <- textToCString name
    result <- gtk_theming_engine_load name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject ThemingEngine) result'
        return result''
    freeMem name'
    return maybeResult

#if ENABLE_OVERLOADING
#endif