gi-gtksource-3.0.18: GI/GtkSource/Objects/Style.hs

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

/No description available in the introspection data./
-}

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

module GI.GtkSource.Objects.Style
    ( 

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


 -- * Methods
-- ** apply #method:apply#

#if ENABLE_OVERLOADING
    StyleApplyMethodInfo                    ,
#endif
    styleApply                              ,


-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    StyleCopyMethodInfo                     ,
#endif
    styleCopy                               ,




 -- * Properties
-- ** background #attr:background#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleBackgroundPropertyInfo             ,
#endif
    constructStyleBackground                ,
    getStyleBackground                      ,
#if ENABLE_OVERLOADING
    styleBackground                         ,
#endif


-- ** backgroundSet #attr:backgroundSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleBackgroundSetPropertyInfo          ,
#endif
    constructStyleBackgroundSet             ,
    getStyleBackgroundSet                   ,
#if ENABLE_OVERLOADING
    styleBackgroundSet                      ,
#endif


-- ** bold #attr:bold#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleBoldPropertyInfo                   ,
#endif
    constructStyleBold                      ,
    getStyleBold                            ,
#if ENABLE_OVERLOADING
    styleBold                               ,
#endif


-- ** boldSet #attr:boldSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleBoldSetPropertyInfo                ,
#endif
    constructStyleBoldSet                   ,
    getStyleBoldSet                         ,
#if ENABLE_OVERLOADING
    styleBoldSet                            ,
#endif


-- ** foreground #attr:foreground#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleForegroundPropertyInfo             ,
#endif
    constructStyleForeground                ,
    getStyleForeground                      ,
#if ENABLE_OVERLOADING
    styleForeground                         ,
#endif


-- ** foregroundSet #attr:foregroundSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleForegroundSetPropertyInfo          ,
#endif
    constructStyleForegroundSet             ,
    getStyleForegroundSet                   ,
#if ENABLE_OVERLOADING
    styleForegroundSet                      ,
#endif


-- ** italic #attr:italic#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleItalicPropertyInfo                 ,
#endif
    constructStyleItalic                    ,
    getStyleItalic                          ,
#if ENABLE_OVERLOADING
    styleItalic                             ,
#endif


-- ** italicSet #attr:italicSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleItalicSetPropertyInfo              ,
#endif
    constructStyleItalicSet                 ,
    getStyleItalicSet                       ,
#if ENABLE_OVERLOADING
    styleItalicSet                          ,
#endif


-- ** lineBackground #attr:lineBackground#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleLineBackgroundPropertyInfo         ,
#endif
    constructStyleLineBackground            ,
    getStyleLineBackground                  ,
#if ENABLE_OVERLOADING
    styleLineBackground                     ,
#endif


-- ** lineBackgroundSet #attr:lineBackgroundSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleLineBackgroundSetPropertyInfo      ,
#endif
    constructStyleLineBackgroundSet         ,
    getStyleLineBackgroundSet               ,
#if ENABLE_OVERLOADING
    styleLineBackgroundSet                  ,
#endif


-- ** pangoUnderline #attr:pangoUnderline#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StylePangoUnderlinePropertyInfo         ,
#endif
    constructStylePangoUnderline            ,
    getStylePangoUnderline                  ,
#if ENABLE_OVERLOADING
    stylePangoUnderline                     ,
#endif


-- ** scale #attr:scale#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleScalePropertyInfo                  ,
#endif
    constructStyleScale                     ,
    getStyleScale                           ,
#if ENABLE_OVERLOADING
    styleScale                              ,
#endif


-- ** scaleSet #attr:scaleSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleScaleSetPropertyInfo               ,
#endif
    constructStyleScaleSet                  ,
    getStyleScaleSet                        ,
#if ENABLE_OVERLOADING
    styleScaleSet                           ,
#endif


-- ** strikethrough #attr:strikethrough#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleStrikethroughPropertyInfo          ,
#endif
    constructStyleStrikethrough             ,
    getStyleStrikethrough                   ,
#if ENABLE_OVERLOADING
    styleStrikethrough                      ,
#endif


-- ** strikethroughSet #attr:strikethroughSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleStrikethroughSetPropertyInfo       ,
#endif
    constructStyleStrikethroughSet          ,
    getStyleStrikethroughSet                ,
#if ENABLE_OVERLOADING
    styleStrikethroughSet                   ,
#endif


-- ** underline #attr:underline#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleUnderlinePropertyInfo              ,
#endif
    constructStyleUnderline                 ,
    getStyleUnderline                       ,
#if ENABLE_OVERLOADING
    styleUnderline                          ,
#endif


-- ** underlineColor #attr:underlineColor#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleUnderlineColorPropertyInfo         ,
#endif
    constructStyleUnderlineColor            ,
    getStyleUnderlineColor                  ,
#if ENABLE_OVERLOADING
    styleUnderlineColor                     ,
#endif


-- ** underlineColorSet #attr:underlineColorSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleUnderlineColorSetPropertyInfo      ,
#endif
    constructStyleUnderlineColorSet         ,
    getStyleUnderlineColorSet               ,
#if ENABLE_OVERLOADING
    styleUnderlineColorSet                  ,
#endif


-- ** underlineSet #attr:underlineSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    StyleUnderlineSetPropertyInfo           ,
#endif
    constructStyleUnderlineSet              ,
    getStyleUnderlineSet                    ,
#if 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import qualified GI.Pango.Enums as Pango.Enums

-- | Memory-managed wrapper type.
newtype Style = Style (ManagedPtr Style)
foreign import ccall "gtk_source_style_get_type"
    c_gtk_source_style_get_type :: IO GType

instance GObject Style where
    gobjectType = c_gtk_source_style_get_type
    

-- | Type class for types which can be safely cast to `Style`, for instance with `toStyle`.
class (GObject o, O.IsDescendantOf Style o) => IsStyle o
instance (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 :: (MonadIO m, IsStyle o) => o -> m Style
toStyle = liftIO . unsafeCastTo Style

-- | A convenience alias for `Nothing` :: `Maybe` `Style`.
noStyle :: Maybe Style
noStyle = Nothing

#if 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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveStyleMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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) => T.Text -> IO (GValueConstruct o)
constructStyleBackground val = B.Properties.constructObjectPropertyString "background" (Just val)

#if ENABLE_OVERLOADING
data StyleBackgroundPropertyInfo
instance AttrInfo StyleBackgroundPropertyInfo where
    type AttrAllowedOps StyleBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StyleBackgroundPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint StyleBackgroundPropertyInfo = IsStyle
    type AttrGetType StyleBackgroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleBackgroundPropertyInfo = "background"
    type AttrOrigin StyleBackgroundPropertyInfo = Style
    attrGet _ = getStyleBackground
    attrSet _ = undefined
    attrConstruct _ = constructStyleBackground
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleBackgroundSet val = B.Properties.constructObjectPropertyBool "background-set" val

#if ENABLE_OVERLOADING
data StyleBackgroundSetPropertyInfo
instance AttrInfo StyleBackgroundSetPropertyInfo where
    type AttrAllowedOps StyleBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleBackgroundSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleBackgroundSetPropertyInfo = IsStyle
    type AttrGetType StyleBackgroundSetPropertyInfo = Bool
    type AttrLabel StyleBackgroundSetPropertyInfo = "background-set"
    type AttrOrigin StyleBackgroundSetPropertyInfo = Style
    attrGet _ = getStyleBackgroundSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleBackgroundSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleBold val = B.Properties.constructObjectPropertyBool "bold" val

#if ENABLE_OVERLOADING
data StyleBoldPropertyInfo
instance AttrInfo StyleBoldPropertyInfo where
    type AttrAllowedOps StyleBoldPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleBoldPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleBoldPropertyInfo = IsStyle
    type AttrGetType StyleBoldPropertyInfo = Bool
    type AttrLabel StyleBoldPropertyInfo = "bold"
    type AttrOrigin StyleBoldPropertyInfo = Style
    attrGet _ = getStyleBold
    attrSet _ = undefined
    attrConstruct _ = constructStyleBold
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleBoldSet val = B.Properties.constructObjectPropertyBool "bold-set" val

#if ENABLE_OVERLOADING
data StyleBoldSetPropertyInfo
instance AttrInfo StyleBoldSetPropertyInfo where
    type AttrAllowedOps StyleBoldSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleBoldSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleBoldSetPropertyInfo = IsStyle
    type AttrGetType StyleBoldSetPropertyInfo = Bool
    type AttrLabel StyleBoldSetPropertyInfo = "bold-set"
    type AttrOrigin StyleBoldSetPropertyInfo = Style
    attrGet _ = getStyleBoldSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleBoldSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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) => T.Text -> IO (GValueConstruct o)
constructStyleForeground val = B.Properties.constructObjectPropertyString "foreground" (Just val)

#if ENABLE_OVERLOADING
data StyleForegroundPropertyInfo
instance AttrInfo StyleForegroundPropertyInfo where
    type AttrAllowedOps StyleForegroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StyleForegroundPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint StyleForegroundPropertyInfo = IsStyle
    type AttrGetType StyleForegroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleForegroundPropertyInfo = "foreground"
    type AttrOrigin StyleForegroundPropertyInfo = Style
    attrGet _ = getStyleForeground
    attrSet _ = undefined
    attrConstruct _ = constructStyleForeground
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleForegroundSet val = B.Properties.constructObjectPropertyBool "foreground-set" val

#if ENABLE_OVERLOADING
data StyleForegroundSetPropertyInfo
instance AttrInfo StyleForegroundSetPropertyInfo where
    type AttrAllowedOps StyleForegroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleForegroundSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleForegroundSetPropertyInfo = IsStyle
    type AttrGetType StyleForegroundSetPropertyInfo = Bool
    type AttrLabel StyleForegroundSetPropertyInfo = "foreground-set"
    type AttrOrigin StyleForegroundSetPropertyInfo = Style
    attrGet _ = getStyleForegroundSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleForegroundSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleItalic val = B.Properties.constructObjectPropertyBool "italic" val

#if ENABLE_OVERLOADING
data StyleItalicPropertyInfo
instance AttrInfo StyleItalicPropertyInfo where
    type AttrAllowedOps StyleItalicPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleItalicPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleItalicPropertyInfo = IsStyle
    type AttrGetType StyleItalicPropertyInfo = Bool
    type AttrLabel StyleItalicPropertyInfo = "italic"
    type AttrOrigin StyleItalicPropertyInfo = Style
    attrGet _ = getStyleItalic
    attrSet _ = undefined
    attrConstruct _ = constructStyleItalic
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleItalicSet val = B.Properties.constructObjectPropertyBool "italic-set" val

#if ENABLE_OVERLOADING
data StyleItalicSetPropertyInfo
instance AttrInfo StyleItalicSetPropertyInfo where
    type AttrAllowedOps StyleItalicSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleItalicSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleItalicSetPropertyInfo = IsStyle
    type AttrGetType StyleItalicSetPropertyInfo = Bool
    type AttrLabel StyleItalicSetPropertyInfo = "italic-set"
    type AttrOrigin StyleItalicSetPropertyInfo = Style
    attrGet _ = getStyleItalicSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleItalicSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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) => T.Text -> IO (GValueConstruct o)
constructStyleLineBackground val = B.Properties.constructObjectPropertyString "line-background" (Just val)

#if ENABLE_OVERLOADING
data StyleLineBackgroundPropertyInfo
instance AttrInfo StyleLineBackgroundPropertyInfo where
    type AttrAllowedOps StyleLineBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StyleLineBackgroundPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint StyleLineBackgroundPropertyInfo = IsStyle
    type AttrGetType StyleLineBackgroundPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleLineBackgroundPropertyInfo = "line-background"
    type AttrOrigin StyleLineBackgroundPropertyInfo = Style
    attrGet _ = getStyleLineBackground
    attrSet _ = undefined
    attrConstruct _ = constructStyleLineBackground
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleLineBackgroundSet val = B.Properties.constructObjectPropertyBool "line-background-set" val

#if ENABLE_OVERLOADING
data StyleLineBackgroundSetPropertyInfo
instance AttrInfo StyleLineBackgroundSetPropertyInfo where
    type AttrAllowedOps StyleLineBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleLineBackgroundSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleLineBackgroundSetPropertyInfo = IsStyle
    type AttrGetType StyleLineBackgroundSetPropertyInfo = Bool
    type AttrLabel StyleLineBackgroundSetPropertyInfo = "line-background-set"
    type AttrOrigin StyleLineBackgroundSetPropertyInfo = Style
    attrGet _ = getStyleLineBackgroundSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleLineBackgroundSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyEnum obj "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) => Pango.Enums.Underline -> IO (GValueConstruct o)
constructStylePangoUnderline val = B.Properties.constructObjectPropertyEnum "pango-underline" val

#if ENABLE_OVERLOADING
data StylePangoUnderlinePropertyInfo
instance AttrInfo StylePangoUnderlinePropertyInfo where
    type AttrAllowedOps StylePangoUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StylePangoUnderlinePropertyInfo = (~) Pango.Enums.Underline
    type AttrBaseTypeConstraint StylePangoUnderlinePropertyInfo = IsStyle
    type AttrGetType StylePangoUnderlinePropertyInfo = Pango.Enums.Underline
    type AttrLabel StylePangoUnderlinePropertyInfo = "pango-underline"
    type AttrOrigin StylePangoUnderlinePropertyInfo = Style
    attrGet _ = getStylePangoUnderline
    attrSet _ = undefined
    attrConstruct _ = constructStylePangoUnderline
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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) => T.Text -> IO (GValueConstruct o)
constructStyleScale val = B.Properties.constructObjectPropertyString "scale" (Just val)

#if ENABLE_OVERLOADING
data StyleScalePropertyInfo
instance AttrInfo StyleScalePropertyInfo where
    type AttrAllowedOps StyleScalePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StyleScalePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint StyleScalePropertyInfo = IsStyle
    type AttrGetType StyleScalePropertyInfo = (Maybe T.Text)
    type AttrLabel StyleScalePropertyInfo = "scale"
    type AttrOrigin StyleScalePropertyInfo = Style
    attrGet _ = getStyleScale
    attrSet _ = undefined
    attrConstruct _ = constructStyleScale
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleScaleSet val = B.Properties.constructObjectPropertyBool "scale-set" val

#if ENABLE_OVERLOADING
data StyleScaleSetPropertyInfo
instance AttrInfo StyleScaleSetPropertyInfo where
    type AttrAllowedOps StyleScaleSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleScaleSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleScaleSetPropertyInfo = IsStyle
    type AttrGetType StyleScaleSetPropertyInfo = Bool
    type AttrLabel StyleScaleSetPropertyInfo = "scale-set"
    type AttrOrigin StyleScaleSetPropertyInfo = Style
    attrGet _ = getStyleScaleSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleScaleSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleStrikethrough val = B.Properties.constructObjectPropertyBool "strikethrough" val

#if ENABLE_OVERLOADING
data StyleStrikethroughPropertyInfo
instance AttrInfo StyleStrikethroughPropertyInfo where
    type AttrAllowedOps StyleStrikethroughPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleStrikethroughPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleStrikethroughPropertyInfo = IsStyle
    type AttrGetType StyleStrikethroughPropertyInfo = Bool
    type AttrLabel StyleStrikethroughPropertyInfo = "strikethrough"
    type AttrOrigin StyleStrikethroughPropertyInfo = Style
    attrGet _ = getStyleStrikethrough
    attrSet _ = undefined
    attrConstruct _ = constructStyleStrikethrough
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleStrikethroughSet val = B.Properties.constructObjectPropertyBool "strikethrough-set" val

#if ENABLE_OVERLOADING
data StyleStrikethroughSetPropertyInfo
instance AttrInfo StyleStrikethroughSetPropertyInfo where
    type AttrAllowedOps StyleStrikethroughSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleStrikethroughSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleStrikethroughSetPropertyInfo = IsStyle
    type AttrGetType StyleStrikethroughSetPropertyInfo = Bool
    type AttrLabel StyleStrikethroughSetPropertyInfo = "strikethrough-set"
    type AttrOrigin StyleStrikethroughSetPropertyInfo = Style
    attrGet _ = getStyleStrikethroughSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleStrikethroughSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleUnderline val = B.Properties.constructObjectPropertyBool "underline" val

#if ENABLE_OVERLOADING
data StyleUnderlinePropertyInfo
instance AttrInfo StyleUnderlinePropertyInfo where
    type AttrAllowedOps StyleUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleUnderlinePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleUnderlinePropertyInfo = IsStyle
    type AttrGetType StyleUnderlinePropertyInfo = Bool
    type AttrLabel StyleUnderlinePropertyInfo = "underline"
    type AttrOrigin StyleUnderlinePropertyInfo = Style
    attrGet _ = getStyleUnderline
    attrSet _ = undefined
    attrConstruct _ = constructStyleUnderline
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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) => T.Text -> IO (GValueConstruct o)
constructStyleUnderlineColor val = B.Properties.constructObjectPropertyString "underline-color" (Just val)

#if ENABLE_OVERLOADING
data StyleUnderlineColorPropertyInfo
instance AttrInfo StyleUnderlineColorPropertyInfo where
    type AttrAllowedOps StyleUnderlineColorPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StyleUnderlineColorPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint StyleUnderlineColorPropertyInfo = IsStyle
    type AttrGetType StyleUnderlineColorPropertyInfo = (Maybe T.Text)
    type AttrLabel StyleUnderlineColorPropertyInfo = "underline-color"
    type AttrOrigin StyleUnderlineColorPropertyInfo = Style
    attrGet _ = getStyleUnderlineColor
    attrSet _ = undefined
    attrConstruct _ = constructStyleUnderlineColor
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleUnderlineColorSet val = B.Properties.constructObjectPropertyBool "underline-color-set" val

#if ENABLE_OVERLOADING
data StyleUnderlineColorSetPropertyInfo
instance AttrInfo StyleUnderlineColorSetPropertyInfo where
    type AttrAllowedOps StyleUnderlineColorSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleUnderlineColorSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleUnderlineColorSetPropertyInfo = IsStyle
    type AttrGetType StyleUnderlineColorSetPropertyInfo = Bool
    type AttrLabel StyleUnderlineColorSetPropertyInfo = "underline-color-set"
    type AttrOrigin StyleUnderlineColorSetPropertyInfo = Style
    attrGet _ = getStyleUnderlineColorSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleUnderlineColorSet
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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) => Bool -> IO (GValueConstruct o)
constructStyleUnderlineSet val = B.Properties.constructObjectPropertyBool "underline-set" val

#if ENABLE_OVERLOADING
data StyleUnderlineSetPropertyInfo
instance AttrInfo StyleUnderlineSetPropertyInfo where
    type AttrAllowedOps StyleUnderlineSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint StyleUnderlineSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint StyleUnderlineSetPropertyInfo = IsStyle
    type AttrGetType StyleUnderlineSetPropertyInfo = Bool
    type AttrLabel StyleUnderlineSetPropertyInfo = "underline-set"
    type AttrOrigin StyleUnderlineSetPropertyInfo = Style
    attrGet _ = getStyleUnderlineSet
    attrSet _ = undefined
    attrConstruct _ = constructStyleUnderlineSet
    attrClear _ = undefined
#endif

#if 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 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 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 'GI.Gtk.Objects.TextTag.TextTag' properties that are related to the
'GI.GtkSource.Objects.Style.Style' properties. Other 'GI.Gtk.Objects.TextTag.TextTag' properties are left untouched.

If /@style@/ is non-'Nothing', applies /@style@/ to /@tag@/.

If /@style@/ is 'Nothing', the related *-set properties of 'GI.Gtk.Objects.TextTag.TextTag' are set to
'False'.

/Since: 3.22/
-}
styleApply ::
    (B.CallStack.HasCallStack, MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) =>
    a
    {- ^ /@style@/: a 'GI.GtkSource.Objects.Style.Style' to apply, or 'Nothing'. -}
    -> b
    {- ^ /@tag@/: a 'GI.Gtk.Objects.TextTag.TextTag' to apply styles to. -}
    -> m ()
styleApply style tag = liftIO $ do
    style' <- unsafeManagedPtrCastPtr style
    tag' <- unsafeManagedPtrCastPtr tag
    gtk_source_style_apply style' tag'
    touchManagedPtr style
    touchManagedPtr tag
    return ()

#if ENABLE_OVERLOADING
data StyleApplyMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) => O.MethodInfo StyleApplyMethodInfo a signature where
    overloadedMethod _ = 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 '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 '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 style = liftIO $ do
    style' <- unsafeManagedPtrCastPtr style
    result <- gtk_source_style_copy style'
    checkUnexpectedReturnNULL "styleCopy" result
    result' <- (wrapObject Style) result
    touchManagedPtr style
    return result'

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

#endif