{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.GtkSource.Objects.Style
    ( 

-- * Exported types
    Style(..)                               ,
    IsStyle                                 ,
    toStyle                                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [apply]("GI.GtkSource.Objects.Style#g:method:apply"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [copy]("GI.GtkSource.Objects.Style#g:method:copy"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== 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)
    ResolveStyleMethod                      ,
#endif

-- ** apply #method:apply#

#if defined(ENABLE_OVERLOADING)
    StyleApplyMethodInfo                    ,
#endif
    styleApply                              ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    StyleCopyMethodInfo                     ,
#endif
    styleCopy                               ,




 -- * Properties


-- ** background #attr:background#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleBackgroundPropertyInfo             ,
#endif
    constructStyleBackground                ,
    getStyleBackground                      ,
#if defined(ENABLE_OVERLOADING)
    styleBackground                         ,
#endif


-- ** backgroundSet #attr:backgroundSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleBackgroundSetPropertyInfo          ,
#endif
    constructStyleBackgroundSet             ,
    getStyleBackgroundSet                   ,
#if defined(ENABLE_OVERLOADING)
    styleBackgroundSet                      ,
#endif


-- ** bold #attr:bold#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleBoldPropertyInfo                   ,
#endif
    constructStyleBold                      ,
    getStyleBold                            ,
#if defined(ENABLE_OVERLOADING)
    styleBold                               ,
#endif


-- ** boldSet #attr:boldSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleBoldSetPropertyInfo                ,
#endif
    constructStyleBoldSet                   ,
    getStyleBoldSet                         ,
#if defined(ENABLE_OVERLOADING)
    styleBoldSet                            ,
#endif


-- ** foreground #attr:foreground#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleForegroundPropertyInfo             ,
#endif
    constructStyleForeground                ,
    getStyleForeground                      ,
#if defined(ENABLE_OVERLOADING)
    styleForeground                         ,
#endif


-- ** foregroundSet #attr:foregroundSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleForegroundSetPropertyInfo          ,
#endif
    constructStyleForegroundSet             ,
    getStyleForegroundSet                   ,
#if defined(ENABLE_OVERLOADING)
    styleForegroundSet                      ,
#endif


-- ** italic #attr:italic#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleItalicPropertyInfo                 ,
#endif
    constructStyleItalic                    ,
    getStyleItalic                          ,
#if defined(ENABLE_OVERLOADING)
    styleItalic                             ,
#endif


-- ** italicSet #attr:italicSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleItalicSetPropertyInfo              ,
#endif
    constructStyleItalicSet                 ,
    getStyleItalicSet                       ,
#if defined(ENABLE_OVERLOADING)
    styleItalicSet                          ,
#endif


-- ** lineBackground #attr:lineBackground#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleLineBackgroundPropertyInfo         ,
#endif
    constructStyleLineBackground            ,
    getStyleLineBackground                  ,
#if defined(ENABLE_OVERLOADING)
    styleLineBackground                     ,
#endif


-- ** lineBackgroundSet #attr:lineBackgroundSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleLineBackgroundSetPropertyInfo      ,
#endif
    constructStyleLineBackgroundSet         ,
    getStyleLineBackgroundSet               ,
#if defined(ENABLE_OVERLOADING)
    styleLineBackgroundSet                  ,
#endif


-- ** pangoUnderline #attr:pangoUnderline#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StylePangoUnderlinePropertyInfo         ,
#endif
    constructStylePangoUnderline            ,
    getStylePangoUnderline                  ,
#if defined(ENABLE_OVERLOADING)
    stylePangoUnderline                     ,
#endif


-- ** scale #attr:scale#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleScalePropertyInfo                  ,
#endif
    constructStyleScale                     ,
    getStyleScale                           ,
#if defined(ENABLE_OVERLOADING)
    styleScale                              ,
#endif


-- ** scaleSet #attr:scaleSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleScaleSetPropertyInfo               ,
#endif
    constructStyleScaleSet                  ,
    getStyleScaleSet                        ,
#if defined(ENABLE_OVERLOADING)
    styleScaleSet                           ,
#endif


-- ** strikethrough #attr:strikethrough#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleStrikethroughPropertyInfo          ,
#endif
    constructStyleStrikethrough             ,
    getStyleStrikethrough                   ,
#if defined(ENABLE_OVERLOADING)
    styleStrikethrough                      ,
#endif


-- ** strikethroughSet #attr:strikethroughSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleStrikethroughSetPropertyInfo       ,
#endif
    constructStyleStrikethroughSet          ,
    getStyleStrikethroughSet                ,
#if defined(ENABLE_OVERLOADING)
    styleStrikethroughSet                   ,
#endif


-- ** underline #attr:underline#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleUnderlinePropertyInfo              ,
#endif
    constructStyleUnderline                 ,
    getStyleUnderline                       ,
#if defined(ENABLE_OVERLOADING)
    styleUnderline                          ,
#endif


-- ** underlineColor #attr:underlineColor#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleUnderlineColorPropertyInfo         ,
#endif
    constructStyleUnderlineColor            ,
    getStyleUnderlineColor                  ,
#if defined(ENABLE_OVERLOADING)
    styleUnderlineColor                     ,
#endif


-- ** underlineColorSet #attr:underlineColorSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleUnderlineColorSetPropertyInfo      ,
#endif
    constructStyleUnderlineColorSet         ,
    getStyleUnderlineColorSet               ,
#if defined(ENABLE_OVERLOADING)
    styleUnderlineColorSet                  ,
#endif


-- ** underlineSet #attr:underlineSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StyleUnderlineSetPropertyInfo           ,
#endif
    constructStyleUnderlineSet              ,
    getStyleUnderlineSet                    ,
#if defined(ENABLE_OVERLOADING)
    styleUnderlineSet                       ,
#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.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import qualified GI.Pango.Enums as Pango.Enums

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

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

foreign import ccall "gtk_source_style_get_type"
    c_gtk_source_style_get_type :: IO B.Types.GType

instance B.Types.TypedObject Style where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_style_get_type

instance B.Types.GObject Style

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveStyleMethod (t :: Symbol) (o :: *) :: * where
    ResolveStyleMethod "apply" o = StyleApplyMethodInfo
    ResolveStyleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveStyleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveStyleMethod "copy" o = StyleCopyMethodInfo
    ResolveStyleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveStyleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveStyleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveStyleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveStyleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveStyleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveStyleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveStyleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveStyleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveStyleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveStyleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveStyleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveStyleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveStyleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveStyleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveStyleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveStyleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveStyleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveStyleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveStyleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveStyleMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveStyleMethod t Style, O.OverloadedMethod info Style p) => OL.IsLabel t (Style -> 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 ~ ResolveStyleMethod t Style, O.OverloadedMethod info Style p, R.HasField t Style p) => R.HasField t Style p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

-- | Get the value of the “@background@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #background
-- @
getStyleBackground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text)
getStyleBackground :: forall (m :: * -> *) o.
(MonadIO m, IsStyle o) =>
o -> m (Maybe Text)
getStyleBackground 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
"background"

-- | Construct a `GValueConstruct` with valid value for the “@background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleBackground :: (IsStyle o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStyleBackground :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStyleBackground 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
"background" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StyleBackgroundPropertyInfo
instance AttrInfo StyleBackgroundPropertyInfo where
    type AttrAllowedOps StyleBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StyleBackgroundPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleBackgroundPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StyleBackgroundPropertyInfo = (~) T.Text
    type AttrTransferType StyleBackgroundPropertyInfo = T.Text
    type AttrGetType StyleBackgroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleBackgroundPropertyInfo = "background"
    type AttrOrigin StyleBackgroundPropertyInfo = Style
    attrGet = getStyleBackground
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleBackground
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.background"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:background"
        })
#endif

-- VVV Prop "background-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleBackgroundSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleBackgroundSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleBackgroundSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"background-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleBackgroundSetPropertyInfo
instance AttrInfo StyleBackgroundSetPropertyInfo where
    type AttrAllowedOps StyleBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleBackgroundSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferType StyleBackgroundSetPropertyInfo = Bool
    type AttrGetType StyleBackgroundSetPropertyInfo = Bool
    type AttrLabel StyleBackgroundSetPropertyInfo = "background-set"
    type AttrOrigin StyleBackgroundSetPropertyInfo = Style
    attrGet = getStyleBackgroundSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleBackgroundSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.backgroundSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:backgroundSet"
        })
#endif

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

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

-- | Construct a `GValueConstruct` with valid value for the “@bold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleBold :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleBold :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleBold Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"bold" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleBoldPropertyInfo
instance AttrInfo StyleBoldPropertyInfo where
    type AttrAllowedOps StyleBoldPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleBoldPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleBoldPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleBoldPropertyInfo = (~) Bool
    type AttrTransferType StyleBoldPropertyInfo = Bool
    type AttrGetType StyleBoldPropertyInfo = Bool
    type AttrLabel StyleBoldPropertyInfo = "bold"
    type AttrOrigin StyleBoldPropertyInfo = Style
    attrGet = getStyleBold
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleBold
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.bold"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:bold"
        })
#endif

-- VVV Prop "bold-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@bold-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleBoldSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleBoldSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleBoldSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"bold-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleBoldSetPropertyInfo
instance AttrInfo StyleBoldSetPropertyInfo where
    type AttrAllowedOps StyleBoldSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleBoldSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleBoldSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleBoldSetPropertyInfo = (~) Bool
    type AttrTransferType StyleBoldSetPropertyInfo = Bool
    type AttrGetType StyleBoldSetPropertyInfo = Bool
    type AttrLabel StyleBoldSetPropertyInfo = "bold-set"
    type AttrOrigin StyleBoldSetPropertyInfo = Style
    attrGet = getStyleBoldSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleBoldSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.boldSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:boldSet"
        })
#endif

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

-- | Get the value of the “@foreground@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #foreground
-- @
getStyleForeground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text)
getStyleForeground :: forall (m :: * -> *) o.
(MonadIO m, IsStyle o) =>
o -> m (Maybe Text)
getStyleForeground 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
"foreground"

-- | Construct a `GValueConstruct` with valid value for the “@foreground@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleForeground :: (IsStyle o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStyleForeground :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStyleForeground 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
"foreground" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StyleForegroundPropertyInfo
instance AttrInfo StyleForegroundPropertyInfo where
    type AttrAllowedOps StyleForegroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StyleForegroundPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleForegroundPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StyleForegroundPropertyInfo = (~) T.Text
    type AttrTransferType StyleForegroundPropertyInfo = T.Text
    type AttrGetType StyleForegroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleForegroundPropertyInfo = "foreground"
    type AttrOrigin StyleForegroundPropertyInfo = Style
    attrGet = getStyleForeground
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleForeground
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.foreground"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:foreground"
        })
#endif

-- VVV Prop "foreground-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@foreground-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleForegroundSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleForegroundSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleForegroundSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"foreground-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleForegroundSetPropertyInfo
instance AttrInfo StyleForegroundSetPropertyInfo where
    type AttrAllowedOps StyleForegroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleForegroundSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleForegroundSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleForegroundSetPropertyInfo = (~) Bool
    type AttrTransferType StyleForegroundSetPropertyInfo = Bool
    type AttrGetType StyleForegroundSetPropertyInfo = Bool
    type AttrLabel StyleForegroundSetPropertyInfo = "foreground-set"
    type AttrOrigin StyleForegroundSetPropertyInfo = Style
    attrGet = getStyleForegroundSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleForegroundSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.foregroundSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:foregroundSet"
        })
#endif

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

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

-- | Construct a `GValueConstruct` with valid value for the “@italic@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleItalic :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleItalic :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleItalic Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"italic" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleItalicPropertyInfo
instance AttrInfo StyleItalicPropertyInfo where
    type AttrAllowedOps StyleItalicPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleItalicPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleItalicPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleItalicPropertyInfo = (~) Bool
    type AttrTransferType StyleItalicPropertyInfo = Bool
    type AttrGetType StyleItalicPropertyInfo = Bool
    type AttrLabel StyleItalicPropertyInfo = "italic"
    type AttrOrigin StyleItalicPropertyInfo = Style
    attrGet = getStyleItalic
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleItalic
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.italic"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:italic"
        })
#endif

-- VVV Prop "italic-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@italic-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleItalicSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleItalicSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleItalicSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"italic-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleItalicSetPropertyInfo
instance AttrInfo StyleItalicSetPropertyInfo where
    type AttrAllowedOps StyleItalicSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleItalicSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleItalicSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleItalicSetPropertyInfo = (~) Bool
    type AttrTransferType StyleItalicSetPropertyInfo = Bool
    type AttrGetType StyleItalicSetPropertyInfo = Bool
    type AttrLabel StyleItalicSetPropertyInfo = "italic-set"
    type AttrOrigin StyleItalicSetPropertyInfo = Style
    attrGet = getStyleItalicSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleItalicSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.italicSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:italicSet"
        })
#endif

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

-- | Get the value of the “@line-background@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #lineBackground
-- @
getStyleLineBackground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text)
getStyleLineBackground :: forall (m :: * -> *) o.
(MonadIO m, IsStyle o) =>
o -> m (Maybe Text)
getStyleLineBackground 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
"line-background"

-- | Construct a `GValueConstruct` with valid value for the “@line-background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleLineBackground :: (IsStyle o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStyleLineBackground :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStyleLineBackground 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
"line-background" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StyleLineBackgroundPropertyInfo
instance AttrInfo StyleLineBackgroundPropertyInfo where
    type AttrAllowedOps StyleLineBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StyleLineBackgroundPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleLineBackgroundPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StyleLineBackgroundPropertyInfo = (~) T.Text
    type AttrTransferType StyleLineBackgroundPropertyInfo = T.Text
    type AttrGetType StyleLineBackgroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleLineBackgroundPropertyInfo = "line-background"
    type AttrOrigin StyleLineBackgroundPropertyInfo = Style
    attrGet = getStyleLineBackground
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleLineBackground
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.lineBackground"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:lineBackground"
        })
#endif

-- VVV Prop "line-background-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@line-background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleLineBackgroundSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleLineBackgroundSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleLineBackgroundSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"line-background-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleLineBackgroundSetPropertyInfo
instance AttrInfo StyleLineBackgroundSetPropertyInfo where
    type AttrAllowedOps StyleLineBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleLineBackgroundSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleLineBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleLineBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferType StyleLineBackgroundSetPropertyInfo = Bool
    type AttrGetType StyleLineBackgroundSetPropertyInfo = Bool
    type AttrLabel StyleLineBackgroundSetPropertyInfo = "line-background-set"
    type AttrOrigin StyleLineBackgroundSetPropertyInfo = Style
    attrGet = getStyleLineBackgroundSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleLineBackgroundSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.lineBackgroundSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:lineBackgroundSet"
        })
#endif

-- VVV Prop "pango-underline"
   -- Type: TInterface (Name {namespace = "Pango", name = "Underline"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@pango-underline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #pangoUnderline
-- @
getStylePangoUnderline :: (MonadIO m, IsStyle o) => o -> m Pango.Enums.Underline
getStylePangoUnderline :: forall (m :: * -> *) o. (MonadIO m, IsStyle o) => o -> m Underline
getStylePangoUnderline o
obj = IO Underline -> m Underline
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Underline -> m Underline) -> IO Underline -> m Underline
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Underline
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"pango-underline"

-- | Construct a `GValueConstruct` with valid value for the “@pango-underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStylePangoUnderline :: (IsStyle o, MIO.MonadIO m) => Pango.Enums.Underline -> m (GValueConstruct o)
constructStylePangoUnderline :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Underline -> m (GValueConstruct o)
constructStylePangoUnderline Underline
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 -> Underline -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"pango-underline" Underline
val

#if defined(ENABLE_OVERLOADING)
data StylePangoUnderlinePropertyInfo
instance AttrInfo StylePangoUnderlinePropertyInfo where
    type AttrAllowedOps StylePangoUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StylePangoUnderlinePropertyInfo = IsStyle
    type AttrSetTypeConstraint StylePangoUnderlinePropertyInfo = (~) Pango.Enums.Underline
    type AttrTransferTypeConstraint StylePangoUnderlinePropertyInfo = (~) Pango.Enums.Underline
    type AttrTransferType StylePangoUnderlinePropertyInfo = Pango.Enums.Underline
    type AttrGetType StylePangoUnderlinePropertyInfo = Pango.Enums.Underline
    type AttrLabel StylePangoUnderlinePropertyInfo = "pango-underline"
    type AttrOrigin StylePangoUnderlinePropertyInfo = Style
    attrGet = getStylePangoUnderline
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStylePangoUnderline
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.pangoUnderline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:pangoUnderline"
        })
#endif

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

-- | Get the value of the “@scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #scale
-- @
getStyleScale :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text)
getStyleScale :: forall (m :: * -> *) o.
(MonadIO m, IsStyle o) =>
o -> m (Maybe Text)
getStyleScale 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
"scale"

-- | Construct a `GValueConstruct` with valid value for the “@scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleScale :: (IsStyle o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStyleScale :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStyleScale 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
"scale" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StyleScalePropertyInfo
instance AttrInfo StyleScalePropertyInfo where
    type AttrAllowedOps StyleScalePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StyleScalePropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleScalePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StyleScalePropertyInfo = (~) T.Text
    type AttrTransferType StyleScalePropertyInfo = T.Text
    type AttrGetType StyleScalePropertyInfo = (Maybe T.Text)
    type AttrLabel StyleScalePropertyInfo = "scale"
    type AttrOrigin StyleScalePropertyInfo = Style
    attrGet = getStyleScale
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleScale
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.scale"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:scale"
        })
#endif

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

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

-- | Construct a `GValueConstruct` with valid value for the “@scale-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleScaleSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleScaleSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleScaleSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"scale-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleScaleSetPropertyInfo
instance AttrInfo StyleScaleSetPropertyInfo where
    type AttrAllowedOps StyleScaleSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleScaleSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleScaleSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleScaleSetPropertyInfo = (~) Bool
    type AttrTransferType StyleScaleSetPropertyInfo = Bool
    type AttrGetType StyleScaleSetPropertyInfo = Bool
    type AttrLabel StyleScaleSetPropertyInfo = "scale-set"
    type AttrOrigin StyleScaleSetPropertyInfo = Style
    attrGet = getStyleScaleSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleScaleSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.scaleSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:scaleSet"
        })
#endif

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

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

-- | Construct a `GValueConstruct` with valid value for the “@strikethrough@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleStrikethrough :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleStrikethrough :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleStrikethrough Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"strikethrough" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleStrikethroughPropertyInfo
instance AttrInfo StyleStrikethroughPropertyInfo where
    type AttrAllowedOps StyleStrikethroughPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleStrikethroughPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleStrikethroughPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleStrikethroughPropertyInfo = (~) Bool
    type AttrTransferType StyleStrikethroughPropertyInfo = Bool
    type AttrGetType StyleStrikethroughPropertyInfo = Bool
    type AttrLabel StyleStrikethroughPropertyInfo = "strikethrough"
    type AttrOrigin StyleStrikethroughPropertyInfo = Style
    attrGet = getStyleStrikethrough
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleStrikethrough
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.strikethrough"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:strikethrough"
        })
#endif

-- VVV Prop "strikethrough-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@strikethrough-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleStrikethroughSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleStrikethroughSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleStrikethroughSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"strikethrough-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleStrikethroughSetPropertyInfo
instance AttrInfo StyleStrikethroughSetPropertyInfo where
    type AttrAllowedOps StyleStrikethroughSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleStrikethroughSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleStrikethroughSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleStrikethroughSetPropertyInfo = (~) Bool
    type AttrTransferType StyleStrikethroughSetPropertyInfo = Bool
    type AttrGetType StyleStrikethroughSetPropertyInfo = Bool
    type AttrLabel StyleStrikethroughSetPropertyInfo = "strikethrough-set"
    type AttrOrigin StyleStrikethroughSetPropertyInfo = Style
    attrGet = getStyleStrikethroughSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleStrikethroughSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.strikethroughSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:strikethroughSet"
        })
#endif

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

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

-- | Construct a `GValueConstruct` with valid value for the “@underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleUnderline :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleUnderline :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleUnderline Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"underline" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleUnderlinePropertyInfo
instance AttrInfo StyleUnderlinePropertyInfo where
    type AttrAllowedOps StyleUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleUnderlinePropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleUnderlinePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleUnderlinePropertyInfo = (~) Bool
    type AttrTransferType StyleUnderlinePropertyInfo = Bool
    type AttrGetType StyleUnderlinePropertyInfo = Bool
    type AttrLabel StyleUnderlinePropertyInfo = "underline"
    type AttrOrigin StyleUnderlinePropertyInfo = Style
    attrGet = getStyleUnderline
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleUnderline
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.underline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:underline"
        })
#endif

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

-- | Get the value of the “@underline-color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' style #underlineColor
-- @
getStyleUnderlineColor :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text)
getStyleUnderlineColor :: forall (m :: * -> *) o.
(MonadIO m, IsStyle o) =>
o -> m (Maybe Text)
getStyleUnderlineColor 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
"underline-color"

-- | Construct a `GValueConstruct` with valid value for the “@underline-color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleUnderlineColor :: (IsStyle o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStyleUnderlineColor :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStyleUnderlineColor 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
"underline-color" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StyleUnderlineColorPropertyInfo
instance AttrInfo StyleUnderlineColorPropertyInfo where
    type AttrAllowedOps StyleUnderlineColorPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StyleUnderlineColorPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleUnderlineColorPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StyleUnderlineColorPropertyInfo = (~) T.Text
    type AttrTransferType StyleUnderlineColorPropertyInfo = T.Text
    type AttrGetType StyleUnderlineColorPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleUnderlineColorPropertyInfo = "underline-color"
    type AttrOrigin StyleUnderlineColorPropertyInfo = Style
    attrGet = getStyleUnderlineColor
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleUnderlineColor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.underlineColor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:underlineColor"
        })
#endif

-- VVV Prop "underline-color-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@underline-color-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleUnderlineColorSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleUnderlineColorSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleUnderlineColorSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"underline-color-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleUnderlineColorSetPropertyInfo
instance AttrInfo StyleUnderlineColorSetPropertyInfo where
    type AttrAllowedOps StyleUnderlineColorSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleUnderlineColorSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleUnderlineColorSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleUnderlineColorSetPropertyInfo = (~) Bool
    type AttrTransferType StyleUnderlineColorSetPropertyInfo = Bool
    type AttrGetType StyleUnderlineColorSetPropertyInfo = Bool
    type AttrLabel StyleUnderlineColorSetPropertyInfo = "underline-color-set"
    type AttrOrigin StyleUnderlineColorSetPropertyInfo = Style
    attrGet = getStyleUnderlineColorSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleUnderlineColorSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.underlineColorSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:underlineColorSet"
        })
#endif

-- VVV Prop "underline-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@underline-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStyleUnderlineSet :: (IsStyle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStyleUnderlineSet :: forall o (m :: * -> *).
(IsStyle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStyleUnderlineSet Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"underline-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data StyleUnderlineSetPropertyInfo
instance AttrInfo StyleUnderlineSetPropertyInfo where
    type AttrAllowedOps StyleUnderlineSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StyleUnderlineSetPropertyInfo = IsStyle
    type AttrSetTypeConstraint StyleUnderlineSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StyleUnderlineSetPropertyInfo = (~) Bool
    type AttrTransferType StyleUnderlineSetPropertyInfo = Bool
    type AttrGetType StyleUnderlineSetPropertyInfo = Bool
    type AttrLabel StyleUnderlineSetPropertyInfo = "underline-set"
    type AttrOrigin StyleUnderlineSetPropertyInfo = Style
    attrGet = getStyleUnderlineSet
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStyleUnderlineSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.underlineSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#g:attr:underlineSet"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Style
type instance O.AttributeList Style = StyleAttributeList
type StyleAttributeList = ('[ '("background", StyleBackgroundPropertyInfo), '("backgroundSet", StyleBackgroundSetPropertyInfo), '("bold", StyleBoldPropertyInfo), '("boldSet", StyleBoldSetPropertyInfo), '("foreground", StyleForegroundPropertyInfo), '("foregroundSet", StyleForegroundSetPropertyInfo), '("italic", StyleItalicPropertyInfo), '("italicSet", StyleItalicSetPropertyInfo), '("lineBackground", StyleLineBackgroundPropertyInfo), '("lineBackgroundSet", StyleLineBackgroundSetPropertyInfo), '("pangoUnderline", StylePangoUnderlinePropertyInfo), '("scale", StyleScalePropertyInfo), '("scaleSet", StyleScaleSetPropertyInfo), '("strikethrough", StyleStrikethroughPropertyInfo), '("strikethroughSet", StyleStrikethroughSetPropertyInfo), '("underline", StyleUnderlinePropertyInfo), '("underlineColor", StyleUnderlineColorPropertyInfo), '("underlineColorSet", StyleUnderlineColorSetPropertyInfo), '("underlineSet", StyleUnderlineSetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
styleBackground :: AttrLabelProxy "background"
styleBackground = AttrLabelProxy

styleBackgroundSet :: AttrLabelProxy "backgroundSet"
styleBackgroundSet = AttrLabelProxy

styleBold :: AttrLabelProxy "bold"
styleBold = AttrLabelProxy

styleBoldSet :: AttrLabelProxy "boldSet"
styleBoldSet = AttrLabelProxy

styleForeground :: AttrLabelProxy "foreground"
styleForeground = AttrLabelProxy

styleForegroundSet :: AttrLabelProxy "foregroundSet"
styleForegroundSet = AttrLabelProxy

styleItalic :: AttrLabelProxy "italic"
styleItalic = AttrLabelProxy

styleItalicSet :: AttrLabelProxy "italicSet"
styleItalicSet = AttrLabelProxy

styleLineBackground :: AttrLabelProxy "lineBackground"
styleLineBackground = AttrLabelProxy

styleLineBackgroundSet :: AttrLabelProxy "lineBackgroundSet"
styleLineBackgroundSet = AttrLabelProxy

stylePangoUnderline :: AttrLabelProxy "pangoUnderline"
stylePangoUnderline = AttrLabelProxy

styleScale :: AttrLabelProxy "scale"
styleScale = AttrLabelProxy

styleScaleSet :: AttrLabelProxy "scaleSet"
styleScaleSet = AttrLabelProxy

styleStrikethrough :: AttrLabelProxy "strikethrough"
styleStrikethrough = AttrLabelProxy

styleStrikethroughSet :: AttrLabelProxy "strikethroughSet"
styleStrikethroughSet = AttrLabelProxy

styleUnderline :: AttrLabelProxy "underline"
styleUnderline = AttrLabelProxy

styleUnderlineColor :: AttrLabelProxy "underlineColor"
styleUnderlineColor = AttrLabelProxy

styleUnderlineColorSet :: AttrLabelProxy "underlineColorSet"
styleUnderlineColorSet = AttrLabelProxy

styleUnderlineSet :: AttrLabelProxy "underlineSet"
styleUnderlineSet = AttrLabelProxy

#endif

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

#endif

-- method Style::apply
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "style"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Style" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceStyle to apply, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkTextTag to apply styles to."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_style_apply" gtk_source_style_apply :: 
    Ptr Style ->                            -- style : TInterface (Name {namespace = "GtkSource", name = "Style"})
    Ptr Gtk.TextTag.TextTag ->              -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"})
    IO ()

-- | This function modifies the t'GI.Gtk.Objects.TextTag.TextTag' properties that are related to the
-- t'GI.GtkSource.Objects.Style.Style' properties. Other t'GI.Gtk.Objects.TextTag.TextTag' properties are left untouched.
-- 
-- If /@style@/ is non-'P.Nothing', applies /@style@/ to /@tag@/.
-- 
-- If /@style@/ is 'P.Nothing', the related *-set properties of t'GI.Gtk.Objects.TextTag.TextTag' are set to
-- 'P.False'.
-- 
-- /Since: 3.22/
styleApply ::
    (B.CallStack.HasCallStack, MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) =>
    a
    -- ^ /@style@/: a t'GI.GtkSource.Objects.Style.Style' to apply, or 'P.Nothing'.
    -> b
    -- ^ /@tag@/: a t'GI.Gtk.Objects.TextTag.TextTag' to apply styles to.
    -> m ()
styleApply :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsStyle a, IsTextTag b) =>
a -> b -> m ()
styleApply a
style b
tag = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Style
style' <- a -> IO (Ptr Style)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
style
    Ptr TextTag
tag' <- b -> IO (Ptr TextTag)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
tag
    Ptr Style -> Ptr TextTag -> IO ()
gtk_source_style_apply Ptr Style
style' Ptr TextTag
tag'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
style
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
tag
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StyleApplyMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) => O.OverloadedMethod StyleApplyMethodInfo a signature where
    overloadedMethod = styleApply

instance O.OverloadedMethodInfo StyleApplyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.styleApply",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#v:styleApply"
        })


#endif

-- method Style::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "style"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Style" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceStyle structure to copy."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "Style" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_style_copy" gtk_source_style_copy :: 
    Ptr Style ->                            -- style : TInterface (Name {namespace = "GtkSource", name = "Style"})
    IO (Ptr Style)

-- | Creates a copy of /@style@/, that is a new t'GI.GtkSource.Objects.Style.Style' instance which
-- has the same attributes set.
-- 
-- /Since: 2.0/
styleCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsStyle a) =>
    a
    -- ^ /@style@/: a t'GI.GtkSource.Objects.Style.Style' structure to copy.
    -> m Style
    -- ^ __Returns:__ copy of /@style@/, call 'GI.GObject.Objects.Object.objectUnref'
    -- when you are done with it.
styleCopy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStyle a) =>
a -> m Style
styleCopy a
style = IO Style -> m Style
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Style -> m Style) -> IO Style -> m Style
forall a b. (a -> b) -> a -> b
$ do
    Ptr Style
style' <- a -> IO (Ptr Style)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
style
    Ptr Style
result <- Ptr Style -> IO (Ptr Style)
gtk_source_style_copy Ptr Style
style'
    Text -> Ptr Style -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"styleCopy" Ptr Style
result
    Style
result' <- ((ManagedPtr Style -> Style) -> Ptr Style -> IO Style
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Style -> Style
Style) Ptr Style
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
style
    Style -> IO Style
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Style
result'

#if defined(ENABLE_OVERLOADING)
data StyleCopyMethodInfo
instance (signature ~ (m Style), MonadIO m, IsStyle a) => O.OverloadedMethod StyleCopyMethodInfo a signature where
    overloadedMethod = styleCopy

instance O.OverloadedMethodInfo StyleCopyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Style.styleCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-Style.html#v:styleCopy"
        })


#endif