{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'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.
-- 
-- t'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.

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

module GI.Gtk.Objects.ThemingEngine
    ( 

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


 -- * 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"), [hasClass]("GI.Gtk.Objects.ThemingEngine#g:method:hasClass"), [hasRegion]("GI.Gtk.Objects.ThemingEngine#g:method:hasRegion"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [lookupColor]("GI.Gtk.Objects.ThemingEngine#g:method:lookupColor"), [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"), [stateIsRunning]("GI.Gtk.Objects.ThemingEngine#g:method:stateIsRunning"), [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
-- [getBackgroundColor]("GI.Gtk.Objects.ThemingEngine#g:method:getBackgroundColor"), [getBorder]("GI.Gtk.Objects.ThemingEngine#g:method:getBorder"), [getBorderColor]("GI.Gtk.Objects.ThemingEngine#g:method:getBorderColor"), [getColor]("GI.Gtk.Objects.ThemingEngine#g:method:getColor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.ThemingEngine#g:method:getDirection"), [getFont]("GI.Gtk.Objects.ThemingEngine#g:method:getFont"), [getJunctionSides]("GI.Gtk.Objects.ThemingEngine#g:method:getJunctionSides"), [getMargin]("GI.Gtk.Objects.ThemingEngine#g:method:getMargin"), [getPadding]("GI.Gtk.Objects.ThemingEngine#g:method:getPadding"), [getPath]("GI.Gtk.Objects.ThemingEngine#g:method:getPath"), [getProperty]("GI.Gtk.Objects.ThemingEngine#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getScreen]("GI.Gtk.Objects.ThemingEngine#g:method:getScreen"), [getState]("GI.Gtk.Objects.ThemingEngine#g:method:getState"), [getStyleProperty]("GI.Gtk.Objects.ThemingEngine#g:method:getStyleProperty").
-- 
-- ==== 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").

#if defined(ENABLE_OVERLOADING)
    ResolveThemingEngineMethod              ,
#endif

-- ** getBackgroundColor #method:getBackgroundColor#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetBackgroundColorMethodInfo,
#endif
    themingEngineGetBackgroundColor         ,


-- ** getBorder #method:getBorder#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetBorderMethodInfo        ,
#endif
    themingEngineGetBorder                  ,


-- ** getBorderColor #method:getBorderColor#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetBorderColorMethodInfo   ,
#endif
    themingEngineGetBorderColor             ,


-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetColorMethodInfo         ,
#endif
    themingEngineGetColor                   ,


-- ** getDirection #method:getDirection#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetDirectionMethodInfo     ,
#endif
    themingEngineGetDirection               ,


-- ** getFont #method:getFont#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetFontMethodInfo          ,
#endif
    themingEngineGetFont                    ,


-- ** getJunctionSides #method:getJunctionSides#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetJunctionSidesMethodInfo ,
#endif
    themingEngineGetJunctionSides           ,


-- ** getMargin #method:getMargin#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetMarginMethodInfo        ,
#endif
    themingEngineGetMargin                  ,


-- ** getPadding #method:getPadding#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetPaddingMethodInfo       ,
#endif
    themingEngineGetPadding                 ,


-- ** getPath #method:getPath#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetPathMethodInfo          ,
#endif
    themingEngineGetPath                    ,


-- ** getProperty #method:getProperty#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetPropertyMethodInfo      ,
#endif
    themingEngineGetProperty                ,


-- ** getScreen #method:getScreen#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetScreenMethodInfo        ,
#endif
    themingEngineGetScreen                  ,


-- ** getState #method:getState#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetStateMethodInfo         ,
#endif
    themingEngineGetState                   ,


-- ** getStyleProperty #method:getStyleProperty#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineGetStylePropertyMethodInfo ,
#endif
    themingEngineGetStyleProperty           ,


-- ** hasClass #method:hasClass#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineHasClassMethodInfo         ,
#endif
    themingEngineHasClass                   ,


-- ** hasRegion #method:hasRegion#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineHasRegionMethodInfo        ,
#endif
    themingEngineHasRegion                  ,


-- ** load #method:load#

    themingEngineLoad                       ,


-- ** lookupColor #method:lookupColor#

#if defined(ENABLE_OVERLOADING)
    ThemingEngineLookupColorMethodInfo      ,
#endif
    themingEngineLookupColor                ,


-- ** stateIsRunning #method:stateIsRunning#

#if defined(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 defined(ENABLE_OVERLOADING)
    ThemingEngineNamePropertyInfo           ,
#endif
    constructThemingEngineName              ,
    getThemingEngineName                    ,
#if defined(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.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.Region as Cairo.Region
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.MarkupParser as GLib.MarkupParser
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Screen as Gdk.Screen
import qualified GI.Gdk.Objects.Visual as Gdk.Visual
import qualified GI.Gdk.Objects.Window as Gdk.Window
import qualified GI.Gdk.Structs.Atom as Gdk.Atom
import qualified GI.Gdk.Structs.Color as Gdk.Color
import qualified GI.Gdk.Structs.EventAny as Gdk.EventAny
import qualified GI.Gdk.Structs.EventButton as Gdk.EventButton
import qualified GI.Gdk.Structs.EventConfigure as Gdk.EventConfigure
import qualified GI.Gdk.Structs.EventCrossing as Gdk.EventCrossing
import qualified GI.Gdk.Structs.EventExpose as Gdk.EventExpose
import qualified GI.Gdk.Structs.EventFocus as Gdk.EventFocus
import qualified GI.Gdk.Structs.EventGrabBroken as Gdk.EventGrabBroken
import qualified GI.Gdk.Structs.EventKey as Gdk.EventKey
import qualified GI.Gdk.Structs.EventMotion as Gdk.EventMotion
import qualified GI.Gdk.Structs.EventOwnerChange as Gdk.EventOwnerChange
import qualified GI.Gdk.Structs.EventProperty as Gdk.EventProperty
import qualified GI.Gdk.Structs.EventProximity as Gdk.EventProximity
import qualified GI.Gdk.Structs.EventScroll as Gdk.EventScroll
import qualified GI.Gdk.Structs.EventSelection as Gdk.EventSelection
import qualified GI.Gdk.Structs.EventVisibility as Gdk.EventVisibility
import qualified GI.Gdk.Structs.EventWindowState as Gdk.EventWindowState
import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.ActionMap as Gio.ActionMap
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Objects.Application as Gio.Application
import qualified GI.Gio.Objects.Menu as Gio.Menu
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import {-# SOURCE #-} qualified GI.Gtk.Objects.Application as Gtk.Application
import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
import {-# SOURCE #-} qualified GI.Gtk.Objects.Builder as Gtk.Builder
import {-# SOURCE #-} qualified GI.Gtk.Objects.Clipboard as Gtk.Clipboard
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.IconFactory as Gtk.IconFactory
import {-# SOURCE #-} qualified GI.Gtk.Objects.RcStyle as Gtk.RcStyle
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Style as Gtk.Style
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleProperties as Gtk.StyleProperties
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextChildAnchor as Gtk.TextChildAnchor
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextMark as Gtk.TextMark
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window
import {-# SOURCE #-} qualified GI.Gtk.Objects.WindowGroup as Gtk.WindowGroup
import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelGroupEntry as Gtk.AccelGroupEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelKey as Gtk.AccelKey
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.CssSection as Gtk.CssSection
import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSet as Gtk.IconSet
import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSource as Gtk.IconSource
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import {-# SOURCE #-} qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
import {-# SOURCE #-} qualified GI.Gtk.Structs.SettingsValue as Gtk.SettingsValue
import {-# SOURCE #-} qualified GI.Gtk.Structs.SymbolicColor as Gtk.SymbolicColor
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetEntry as Gtk.TargetEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAppearance as Gtk.TextAppearance
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAttributes as Gtk.TextAttributes
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetPath as Gtk.WidgetPath
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
import qualified GI.Pango.Structs.Language as Pango.Language
import qualified GI.Pango.Structs.TabArray as Pango.TabArray

#else
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

#endif

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

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

foreign import ccall "gtk_theming_engine_get_type"
    c_gtk_theming_engine_get_type :: IO B.Types.GType

instance B.Types.TypedObject ThemingEngine where
    glibType :: IO GType
glibType = IO GType
c_gtk_theming_engine_get_type

instance B.Types.GObject ThemingEngine

-- | Type class for types which can be safely cast to `ThemingEngine`, for instance with `toThemingEngine`.
class (SP.GObject o, O.IsDescendantOf ThemingEngine o) => IsThemingEngine o
instance (SP.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 :: (MIO.MonadIO m, IsThemingEngine o) => o -> m ThemingEngine
toThemingEngine :: forall (m :: * -> *) o.
(MonadIO m, IsThemingEngine o) =>
o -> m ThemingEngine
toThemingEngine = IO ThemingEngine -> m ThemingEngine
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ThemingEngine -> m ThemingEngine)
-> (o -> IO ThemingEngine) -> o -> m ThemingEngine
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ThemingEngine -> ThemingEngine)
-> o -> IO ThemingEngine
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ThemingEngine -> ThemingEngine
ThemingEngine

-- | Convert 'ThemingEngine' 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 ThemingEngine) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_theming_engine_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ThemingEngine -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ThemingEngine
P.Nothing = Ptr GValue -> Ptr ThemingEngine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ThemingEngine
forall a. Ptr a
FP.nullPtr :: FP.Ptr ThemingEngine)
    gvalueSet_ Ptr GValue
gv (P.Just ThemingEngine
obj) = ThemingEngine -> (Ptr ThemingEngine -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ThemingEngine
obj (Ptr GValue -> Ptr ThemingEngine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ThemingEngine)
gvalueGet_ Ptr GValue
gv = do
        Ptr ThemingEngine
ptr <- Ptr GValue -> IO (Ptr ThemingEngine)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ThemingEngine)
        if Ptr ThemingEngine
ptr Ptr ThemingEngine -> Ptr ThemingEngine -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ThemingEngine
forall a. Ptr a
FP.nullPtr
        then ThemingEngine -> Maybe ThemingEngine
forall a. a -> Maybe a
P.Just (ThemingEngine -> Maybe ThemingEngine)
-> IO ThemingEngine -> IO (Maybe ThemingEngine)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ThemingEngine -> ThemingEngine)
-> Ptr ThemingEngine -> IO ThemingEngine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ThemingEngine -> ThemingEngine
ThemingEngine Ptr ThemingEngine
ptr
        else Maybe ThemingEngine -> IO (Maybe ThemingEngine)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ThemingEngine
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveThemingEngineMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod info ThemingEngine p) => OL.IsLabel t (ThemingEngine -> 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 ~ ResolveThemingEngineMethod t ThemingEngine, O.OverloadedMethod info ThemingEngine p, R.HasField t ThemingEngine p) => R.HasField t ThemingEngine p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveThemingEngineMethod t ThemingEngine, O.OverloadedMethodInfo info ThemingEngine) => OL.IsLabel t (O.MethodProxy info ThemingEngine) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsThemingEngine o) =>
o -> m (Maybe Text)
getThemingEngineName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructThemingEngineName :: forall o (m :: * -> *).
(IsThemingEngine o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructThemingEngineName Text
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 -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data ThemingEngineNamePropertyInfo
instance AttrInfo ThemingEngineNamePropertyInfo where
    type AttrAllowedOps ThemingEngineNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ThemingEngineNamePropertyInfo = IsThemingEngine
    type AttrSetTypeConstraint ThemingEngineNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ThemingEngineNamePropertyInfo = (~) T.Text
    type AttrTransferType ThemingEngineNamePropertyInfo = T.Text
    type AttrGetType ThemingEngineNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ThemingEngineNamePropertyInfo = "name"
    type AttrOrigin ThemingEngineNamePropertyInfo = ThemingEngine
    attrGet = getThemingEngineName
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructThemingEngineName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#g:attr:name"
        })
#endif

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

#if defined(ENABLE_OVERLOADING)
themingEngineName :: AttrLabelProxy "name"
themingEngineName = AttrLabelProxy

#endif

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

#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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the color for
    -> m (Gdk.RGBA.RGBA)
themingEngineGetBackgroundColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m RGBA
themingEngineGetBackgroundColor a
engine [StateFlags]
state = IO RGBA -> m RGBA
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    Ptr ThemingEngine -> CUInt -> Ptr RGBA -> IO ()
gtk_theming_engine_get_background_color Ptr ThemingEngine
engine' CUInt
state' Ptr RGBA
color
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    RGBA -> IO RGBA
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
color'

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

instance O.OverloadedMethodInfo ThemingEngineGetBackgroundColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetBackgroundColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Structs.Border.Border'.
-- 
-- /Since: 3.0/
themingEngineGetBorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the border for
    -> m (Gtk.Border.Border)
themingEngineGetBorder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m Border
themingEngineGetBorder a
engine [StateFlags]
state = IO Border -> m Border
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Border -> m Border) -> IO Border -> m Border
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr Border
border <- Int -> IO (Ptr Border)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Border.Border)
    Ptr ThemingEngine -> CUInt -> Ptr Border -> IO ()
gtk_theming_engine_get_border Ptr ThemingEngine
engine' CUInt
state' Ptr Border
border
    Border
border' <- ((ManagedPtr Border -> Border) -> Ptr Border -> IO Border
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Border -> Border
Gtk.Border.Border) Ptr Border
border
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Border -> IO Border
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Border
border'

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

instance O.OverloadedMethodInfo ThemingEngineGetBorderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetBorder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the color for
    -> m (Gdk.RGBA.RGBA)
themingEngineGetBorderColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m RGBA
themingEngineGetBorderColor a
engine [StateFlags]
state = IO RGBA -> m RGBA
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    Ptr ThemingEngine -> CUInt -> Ptr RGBA -> IO ()
gtk_theming_engine_get_border_color Ptr ThemingEngine
engine' CUInt
state' Ptr RGBA
color
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    RGBA -> IO RGBA
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
color'

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

instance O.OverloadedMethodInfo ThemingEngineGetBorderColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetBorderColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the color for
    -> m (Gdk.RGBA.RGBA)
themingEngineGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m RGBA
themingEngineGetColor a
engine [StateFlags]
state = IO RGBA -> m RGBA
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    Ptr ThemingEngine -> CUInt -> Ptr RGBA -> IO ()
gtk_theming_engine_get_color Ptr ThemingEngine
engine' CUInt
state' Ptr RGBA
color
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    RGBA -> IO RGBA
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
color'

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

instance O.OverloadedMethodInfo ThemingEngineGetColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> m Gtk.Enums.TextDirection
    -- ^ __Returns:__ the widget direction
themingEngineGetDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> m TextDirection
themingEngineGetDirection a
engine = IO TextDirection -> m TextDirection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextDirection -> m TextDirection)
-> IO TextDirection -> m TextDirection
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CUInt
result <- Ptr ThemingEngine -> IO CUInt
gtk_theming_engine_get_direction Ptr ThemingEngine
engine'
    let result' :: TextDirection
result' = (Int -> TextDirection
forall a. Enum a => Int -> a
toEnum (Int -> TextDirection) -> (CUInt -> Int) -> CUInt -> TextDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    TextDirection -> IO TextDirection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextDirection
result'

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

instance O.OverloadedMethodInfo ThemingEngineGetDirectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetDirection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the font for
    -> m Pango.FontDescription.FontDescription
    -- ^ __Returns:__ the t'GI.Pango.Structs.FontDescription.FontDescription' for the given
    --          state. This object is owned by GTK+ and should not be
    --          freed.
themingEngineGetFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m FontDescription
themingEngineGetFont a
engine [StateFlags]
state = IO FontDescription -> m FontDescription
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontDescription -> m FontDescription)
-> IO FontDescription -> m FontDescription
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr FontDescription
result <- Ptr ThemingEngine -> CUInt -> IO (Ptr FontDescription)
gtk_theming_engine_get_font Ptr ThemingEngine
engine' CUInt
state'
    Text -> Ptr FontDescription -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"themingEngineGetFont" Ptr FontDescription
result
    FontDescription
result' <- ((ManagedPtr FontDescription -> FontDescription)
-> Ptr FontDescription -> IO FontDescription
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr FontDescription -> FontDescription
Pango.FontDescription.FontDescription) Ptr FontDescription
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    FontDescription -> IO FontDescription
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontDescription
result'

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

instance O.OverloadedMethodInfo ThemingEngineGetFontMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetFont",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> m [Gtk.Flags.JunctionSides]
    -- ^ __Returns:__ the widget direction
themingEngineGetJunctionSides :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> m [JunctionSides]
themingEngineGetJunctionSides a
engine = IO [JunctionSides] -> m [JunctionSides]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [JunctionSides] -> m [JunctionSides])
-> IO [JunctionSides] -> m [JunctionSides]
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CUInt
result <- Ptr ThemingEngine -> IO CUInt
gtk_theming_engine_get_junction_sides Ptr ThemingEngine
engine'
    let result' :: [JunctionSides]
result' = CUInt -> [JunctionSides]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    [JunctionSides] -> IO [JunctionSides]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [JunctionSides]
result'

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

instance O.OverloadedMethodInfo ThemingEngineGetJunctionSidesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetJunctionSides",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Structs.Border.Border'.
-- 
-- /Since: 3.0/
themingEngineGetMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the border for
    -> m (Gtk.Border.Border)
themingEngineGetMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m Border
themingEngineGetMargin a
engine [StateFlags]
state = IO Border -> m Border
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Border -> m Border) -> IO Border -> m Border
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr Border
margin <- Int -> IO (Ptr Border)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Border.Border)
    Ptr ThemingEngine -> CUInt -> Ptr Border -> IO ()
gtk_theming_engine_get_margin Ptr ThemingEngine
engine' CUInt
state' Ptr Border
margin
    Border
margin' <- ((ManagedPtr Border -> Border) -> Ptr Border -> IO Border
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Border -> Border
Gtk.Border.Border) Ptr Border
margin
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Border -> IO Border
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Border
margin'

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

instance O.OverloadedMethodInfo ThemingEngineGetMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Structs.Border.Border'.
-- 
-- /Since: 3.0/
themingEngineGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the padding for
    -> m (Gtk.Border.Border)
themingEngineGetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> [StateFlags] -> m Border
themingEngineGetPadding a
engine [StateFlags]
state = IO Border -> m Border
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Border -> m Border) -> IO Border -> m Border
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr Border
padding <- Int -> IO (Ptr Border)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Border.Border)
    Ptr ThemingEngine -> CUInt -> Ptr Border -> IO ()
gtk_theming_engine_get_padding Ptr ThemingEngine
engine' CUInt
state' Ptr Border
padding
    Border
padding' <- ((ManagedPtr Border -> Border) -> Ptr Border -> IO Border
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Border -> Border
Gtk.Border.Border) Ptr Border
padding
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Border -> IO Border
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Border
padding'

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

instance O.OverloadedMethodInfo ThemingEngineGetPaddingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetPadding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> m Gtk.WidgetPath.WidgetPath
    -- ^ __Returns:__ A t'GI.Gtk.Structs.WidgetPath.WidgetPath'
themingEngineGetPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> m WidgetPath
themingEngineGetPath a
engine = IO WidgetPath -> m WidgetPath
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WidgetPath -> m WidgetPath) -> IO WidgetPath -> m WidgetPath
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr WidgetPath
result <- Ptr ThemingEngine -> IO (Ptr WidgetPath)
gtk_theming_engine_get_path Ptr ThemingEngine
engine'
    Text -> Ptr WidgetPath -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"themingEngineGetPath" Ptr WidgetPath
result
    WidgetPath
result' <- ((ManagedPtr WidgetPath -> WidgetPath)
-> Ptr WidgetPath -> IO WidgetPath
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr WidgetPath -> WidgetPath
Gtk.WidgetPath.WidgetPath) Ptr WidgetPath
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    WidgetPath -> IO WidgetPath
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetPath
result'

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

instance O.OverloadedMethodInfo ThemingEngineGetPathMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetPath",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , 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
--           , argCallbackUserData = False
--           , 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 : TGValue
    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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> T.Text
    -- ^ /@property@/: the property name
    -> [Gtk.Flags.StateFlags]
    -- ^ /@state@/: state to retrieve the value for
    -> m (GValue)
themingEngineGetProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> Text -> [StateFlags] -> m GValue
themingEngineGetProperty a
engine Text
property [StateFlags]
state = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
property' <- Text -> IO CString
textToCString Text
property
    let state' :: CUInt
state' = [StateFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StateFlags]
state
    Ptr GValue
value <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    Ptr ThemingEngine -> CString -> CUInt -> Ptr GValue -> IO ()
gtk_theming_engine_get_property Ptr ThemingEngine
engine' CString
property' CUInt
state' Ptr GValue
value
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
property'
    GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'

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

instance O.OverloadedMethodInfo ThemingEngineGetPropertyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetProperty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 t'GI.Gdk.Objects.Screen.Screen' to which /@engine@/ currently rendering to.
themingEngineGetScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> m (Maybe Gdk.Screen.Screen)
    -- ^ __Returns:__ a t'GI.Gdk.Objects.Screen.Screen', or 'P.Nothing'.
themingEngineGetScreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> m (Maybe Screen)
themingEngineGetScreen a
engine = IO (Maybe Screen) -> m (Maybe Screen)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Screen) -> m (Maybe Screen))
-> IO (Maybe Screen) -> m (Maybe Screen)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Screen
result <- Ptr ThemingEngine -> IO (Ptr Screen)
gtk_theming_engine_get_screen Ptr ThemingEngine
engine'
    Maybe Screen
maybeResult <- Ptr Screen -> (Ptr Screen -> IO Screen) -> IO (Maybe Screen)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Screen
result ((Ptr Screen -> IO Screen) -> IO (Maybe Screen))
-> (Ptr Screen -> IO Screen) -> IO (Maybe Screen)
forall a b. (a -> b) -> a -> b
$ \Ptr Screen
result' -> do
        Screen
result'' <- ((ManagedPtr Screen -> Screen) -> Ptr Screen -> IO Screen
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Screen -> Screen
Gdk.Screen.Screen) Ptr Screen
result'
        Screen -> IO Screen
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Screen
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Maybe Screen -> IO (Maybe Screen)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Screen
maybeResult

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

instance O.OverloadedMethodInfo ThemingEngineGetScreenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetScreen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> m [Gtk.Flags.StateFlags]
    -- ^ __Returns:__ the state flags
themingEngineGetState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> m [StateFlags]
themingEngineGetState a
engine = IO [StateFlags] -> m [StateFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StateFlags] -> m [StateFlags])
-> IO [StateFlags] -> m [StateFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CUInt
result <- Ptr ThemingEngine -> IO CUInt
gtk_theming_engine_get_state Ptr ThemingEngine
engine'
    let result' :: [StateFlags]
result' = CUInt -> [StateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    [StateFlags] -> IO [StateFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [StateFlags]
result'

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

instance O.OverloadedMethodInfo ThemingEngineGetStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , 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
--           , argCallbackUserData = False
--           , 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 : TGValue
    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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> T.Text
    -- ^ /@propertyName@/: the name of the widget style property
    -> m (GValue)
themingEngineGetStyleProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> Text -> m GValue
themingEngineGetStyleProperty a
engine Text
propertyName = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    Ptr ThemingEngine -> CString -> Ptr GValue -> IO ()
gtk_theming_engine_get_style_property Ptr ThemingEngine
engine' CString
propertyName' Ptr GValue
value
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'

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

instance O.OverloadedMethodInfo ThemingEngineGetStylePropertyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineGetStyleProperty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 'P.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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> T.Text
    -- ^ /@styleClass@/: class name to look up
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@engine@/ has /@className@/ defined
themingEngineHasClass :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> Text -> m Bool
themingEngineHasClass a
engine Text
styleClass = 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 ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
styleClass' <- Text -> IO CString
textToCString Text
styleClass
    CInt
result <- Ptr ThemingEngine -> CString -> IO CInt
gtk_theming_engine_has_class Ptr ThemingEngine
engine' CString
styleClass'
    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
engine
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
styleClass'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo ThemingEngineHasClassMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineHasClass",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 'P.True' if the currently rendered contents have the
-- region defined. If /@flagsReturn@/ is not 'P.Nothing', it is set
-- to the flags affecting the region.
-- 
-- /Since: 3.0/
themingEngineHasRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> T.Text
    -- ^ /@styleRegion@/: a region name
    -> m ((Bool, [Gtk.Flags.RegionFlags]))
    -- ^ __Returns:__ 'P.True' if region is defined
themingEngineHasRegion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> Text -> m (Bool, [RegionFlags])
themingEngineHasRegion a
engine Text
styleRegion = IO (Bool, [RegionFlags]) -> m (Bool, [RegionFlags])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [RegionFlags]) -> m (Bool, [RegionFlags]))
-> IO (Bool, [RegionFlags]) -> m (Bool, [RegionFlags])
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
styleRegion' <- Text -> IO CString
textToCString Text
styleRegion
    Ptr CUInt
flags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    CInt
result <- Ptr ThemingEngine -> CString -> Ptr CUInt -> IO CInt
gtk_theming_engine_has_region Ptr ThemingEngine
engine' CString
styleRegion' Ptr CUInt
flags
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CUInt
flags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
flags
    let flags'' :: [RegionFlags]
flags'' = CUInt -> [RegionFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
styleRegion'
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
flags
    (Bool, [RegionFlags]) -> IO (Bool, [RegionFlags])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [RegionFlags]
flags'')

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

instance O.OverloadedMethodInfo ThemingEngineHasRegionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineHasRegion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , 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 t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> T.Text
    -- ^ /@colorName@/: color name to lookup
    -> m ((Bool, Gdk.RGBA.RGBA))
    -- ^ __Returns:__ 'P.True' if /@colorName@/ was found and resolved, 'P.False' otherwise
themingEngineLookupColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> Text -> m (Bool, RGBA)
themingEngineLookupColor a
engine Text
colorName = IO (Bool, RGBA) -> m (Bool, RGBA)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, RGBA) -> m (Bool, RGBA))
-> IO (Bool, RGBA) -> m (Bool, RGBA)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
colorName' <- Text -> IO CString
textToCString Text
colorName
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    CInt
result <- Ptr ThemingEngine -> CString -> Ptr RGBA -> IO CInt
gtk_theming_engine_lookup_color Ptr ThemingEngine
engine' CString
colorName' Ptr RGBA
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
colorName'
    (Bool, RGBA) -> IO (Bool, RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', RGBA
color')

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

instance O.OverloadedMethodInfo ThemingEngineLookupColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineLookupColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 'P.False'"] #-}
-- | Returns 'P.True' if there is a transition animation running for the
-- current region (see 'GI.Gtk.Objects.StyleContext.styleContextPushAnimatableRegion').
-- 
-- If /@progress@/ is not 'P.Nothing', the animation progress will be returned
-- there, 0.0 means the state is closest to being 'P.False', while 1.0 means
-- it’s closest to being 'P.True'. This means transition animations will
-- run from 0 to 1 when /@state@/ is being set to 'P.True' and from 1 to 0 when
-- it’s being set to 'P.False'.
-- 
-- /Since: 3.0/
themingEngineStateIsRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsThemingEngine a) =>
    a
    -- ^ /@engine@/: a t'GI.Gtk.Objects.ThemingEngine.ThemingEngine'
    -> Gtk.Enums.StateType
    -- ^ /@state@/: a widget state
    -> m ((Bool, Double))
    -- ^ __Returns:__ 'P.True' if there is a running transition animation for /@state@/.
themingEngineStateIsRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsThemingEngine a) =>
a -> StateType -> m (Bool, Double)
themingEngineStateIsRunning a
engine StateType
state = IO (Bool, Double) -> m (Bool, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double) -> m (Bool, Double))
-> IO (Bool, Double) -> m (Bool, Double)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ThemingEngine
engine' <- a -> IO (Ptr ThemingEngine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (StateType -> Int) -> StateType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateType -> Int
forall a. Enum a => a -> Int
fromEnum) StateType
state
    Ptr CDouble
progress <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
    CInt
result <- Ptr ThemingEngine -> CUInt -> Ptr CDouble -> IO CInt
gtk_theming_engine_state_is_running Ptr ThemingEngine
engine' CUInt
state' Ptr CDouble
progress
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CDouble
progress' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
progress
    let progress'' :: Double
progress'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
progress'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
progress
    (Bool, Double) -> IO (Bool, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
progress'')

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

instance O.OverloadedMethodInfo ThemingEngineStateIsRunningMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ThemingEngine.themingEngineStateIsRunning",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-ThemingEngine.html#v: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
--           , argCallbackUserData = 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 'P.Nothing' if
    -- the engine /@name@/ doesn’t exist.
themingEngineLoad :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe ThemingEngine)
themingEngineLoad Text
name = IO (Maybe ThemingEngine) -> m (Maybe ThemingEngine)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ThemingEngine) -> m (Maybe ThemingEngine))
-> IO (Maybe ThemingEngine) -> m (Maybe ThemingEngine)
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr ThemingEngine
result <- CString -> IO (Ptr ThemingEngine)
gtk_theming_engine_load CString
name'
    Maybe ThemingEngine
maybeResult <- Ptr ThemingEngine
-> (Ptr ThemingEngine -> IO ThemingEngine)
-> IO (Maybe ThemingEngine)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ThemingEngine
result ((Ptr ThemingEngine -> IO ThemingEngine)
 -> IO (Maybe ThemingEngine))
-> (Ptr ThemingEngine -> IO ThemingEngine)
-> IO (Maybe ThemingEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr ThemingEngine
result' -> do
        ThemingEngine
result'' <- ((ManagedPtr ThemingEngine -> ThemingEngine)
-> Ptr ThemingEngine -> IO ThemingEngine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ThemingEngine -> ThemingEngine
ThemingEngine) Ptr ThemingEngine
result'
        ThemingEngine -> IO ThemingEngine
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ThemingEngine
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Maybe ThemingEngine -> IO (Maybe ThemingEngine)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ThemingEngine
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif