    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A widget that renders SVG, with animations and event handling.
    --
    -- @GtkSvgWidget@ uses t'GI.Gtk.Objects.Svg.Svg' internally, and should read
    -- its documentation to learn about the supported SVG features and
    -- extensions.
    --
    -- On top of the @GtkSvg@ rendering, @GtkSvgWidget@ adds event handling.
    -- \<kbd>Tab\<\/kbd> and \<kbd>Shift\<\/kbd>+\<kbd>Tab\<\/kbd> keys can be used
    -- to move the focus and \<kbd>Enter\<\/kbd> and clicks will activate links
    -- by emitting the [SvgWidget::activate]("GI.Gtk.Objects.SvgWidget#g:signal:activate") signal.
    --
    -- The @tabindex@ and @autofocus@ attributes can be used to influence
    -- what elements act as focus locations, and where focus goes initially.
    --
    -- The styling of the SVG content is following input-related pseudo
    -- classes such as @:focus@, @:active@, @:hover@ or @:visited@.
    --
    -- If [Widget:hasTooltip]("GI.Gtk.Objects.Widget#g:attr:hasTooltip") is set, then the content
    -- of @\<title>@ elements will be shown as tooltips.
    --
    -- SVG animations and different @\<view>@s can be triggered by input
    -- events as well. The following events are supported: focus, blur,
    -- mouseenter, mouseleave, click.
    -- See the <https://svgwg.org/specs/animations/ SVG animation>
    -- specification for details.
    --
    -- /Since: 4.24/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Objects.SvgWidget
        (

    -- * Exported types
        SvgWidget(..)                           ,
        IsSvgWidget                             ,
        toSvgWidget                             ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [loadFromBytes]("GI.Gtk.Objects.SvgWidget#g:method:loadFromBytes"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updatePlatformState]("GI.Gtk.Interfaces.Accessible#g:method:updatePlatformState"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.SvgWidget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getStylesheet]("GI.Gtk.Objects.SvgWidget#g:method:getStylesheet"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.SvgWidget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStylesheet]("GI.Gtk.Objects.SvgWidget#g:method:setStylesheet"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

    #if defined(ENABLE_OVERLOADING)
        ResolveSvgWidgetMethod                  ,
    #endif

    -- ** getState #method:getState#

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetGetStateMethodInfo             ,
    #endif
        svgWidgetGetState                       ,

    -- ** getStylesheet #method:getStylesheet#

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetGetStylesheetMethodInfo        ,
    #endif
        svgWidgetGetStylesheet                  ,

    -- ** loadFromBytes #method:loadFromBytes#

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetLoadFromBytesMethodInfo        ,
    #endif
        svgWidgetLoadFromBytes                  ,

    -- ** new #method:new#

        svgWidgetNew                            ,

    -- ** setState #method:setState#

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetSetStateMethodInfo             ,
    #endif
        svgWidgetSetState                       ,

    -- ** setStylesheet #method:setStylesheet#

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetSetStylesheetMethodInfo        ,
    #endif
        svgWidgetSetStylesheet                  ,

     -- * Properties

    -- ** resource #attr:resource#
    -- | Resource to load SVG data from.
    --
    -- This property is meant for use in ui files.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetResourcePropertyInfo           ,
    #endif
        clearSvgWidgetResource                  ,
        constructSvgWidgetResource              ,
        getSvgWidgetResource                    ,
        setSvgWidgetResource                    ,
    #if defined(ENABLE_OVERLOADING)
        svgWidgetResource                       ,
    #endif

    -- ** state #attr:state#
    -- | The current state of the renderer.
    --
    -- This can be a number between 0 and 63.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetStatePropertyInfo              ,
    #endif
        constructSvgWidgetState                 ,
        getSvgWidgetState                       ,
        setSvgWidgetState                       ,
    #if defined(ENABLE_OVERLOADING)
        svgWidgetState                          ,
    #endif

    -- ** stylesheet #attr:stylesheet#
    -- | A CSS stylesheet to apply to the SVG.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        SvgWidgetStylesheetPropertyInfo         ,
    #endif
        clearSvgWidgetStylesheet                ,
        constructSvgWidgetStylesheet            ,
        getSvgWidgetStylesheet                  ,
        setSvgWidgetStylesheet                  ,
    #if defined(ENABLE_OVERLOADING)
        svgWidgetStylesheet                     ,
    #endif

     -- * Signals

    -- ** activate #signal:activate#

        SvgWidgetActivateCallback               ,
    #if defined(ENABLE_OVERLOADING)
        SvgWidgetActivateSignalInfo             ,
    #endif
        afterSvgWidgetActivate                  ,
        onSvgWidgetActivate                     ,

    -- ** error #signal:error#

        SvgWidgetErrorCallback                  ,
    #if defined(ENABLE_OVERLOADING)
        SvgWidgetErrorSignalInfo                ,
    #endif
        afterSvgWidgetError                     ,
        onSvgWidgetError                        ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
    import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Event as Gdk.Event
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Objects.Surface as Gdk.Surface
    import qualified GI.Gdk.Objects.Texture as Gdk.Texture
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Size as Graphene.Size
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
    import qualified GI.Gsk.Enums as Gsk.Enums
    import qualified GI.Gsk.Flags as Gsk.Flags
    import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
    import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
    import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
    import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
    import qualified GI.Gsk.Structs.ComponentTransfer as Gsk.ComponentTransfer
    import qualified GI.Gsk.Structs.Path as Gsk.Path
    import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
    import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
    import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
    import qualified GI.Gsk.Structs.Transform as Gsk.Transform
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout

    #else
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

    #endif

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

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

    foreign import ccall "gtk_svg_widget_get_type"
        c_gtk_svg_widget_get_type :: IO B.Types.GType

    instance B.Types.TypedObject SvgWidget where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_svg_widget_get_type

    instance B.Types.GObject SvgWidget

    -- | Type class for types which can be safely cast to t'SvgWidget', for instance with `toSvgWidget`.
    class (SP.GObject o, O.IsDescendantOf SvgWidget o) => IsSvgWidget o
    instance (SP.GObject o, O.IsDescendantOf SvgWidget o) => IsSvgWidget o

    instance O.HasParentTypes SvgWidget
    type instance O.ParentTypes SvgWidget = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

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

    -- | Convert t'SvgWidget' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe SvgWidget) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_svg_widget_get_type
        gvalueSet_ :: Ptr GValue -> Maybe SvgWidget -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe SvgWidget
    P.Nothing = Ptr GValue -> Ptr SvgWidget -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr SvgWidget
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr SvgWidget)
        gvalueSet_ Ptr GValue
    gv (P.Just SvgWidget
    obj) = SvgWidget -> (Ptr SvgWidget -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr SvgWidget
    obj (Ptr GValue -> Ptr SvgWidget -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe SvgWidget)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr SvgWidget)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr SvgWidget)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject SvgWidget ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSvgWidgetMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSvgWidgetMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
        ResolveSvgWidgetMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
        ResolveSvgWidgetMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
        ResolveSvgWidgetMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
        ResolveSvgWidgetMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
        ResolveSvgWidgetMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
        ResolveSvgWidgetMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveSvgWidgetMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveSvgWidgetMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
        ResolveSvgWidgetMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
        ResolveSvgWidgetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSvgWidgetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSvgWidgetMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveSvgWidgetMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
        ResolveSvgWidgetMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveSvgWidgetMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
        ResolveSvgWidgetMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
        ResolveSvgWidgetMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
        ResolveSvgWidgetMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveSvgWidgetMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveSvgWidgetMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
        ResolveSvgWidgetMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveSvgWidgetMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveSvgWidgetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSvgWidgetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSvgWidgetMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSvgWidgetMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveSvgWidgetMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
        ResolveSvgWidgetMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveSvgWidgetMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveSvgWidgetMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveSvgWidgetMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveSvgWidgetMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveSvgWidgetMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveSvgWidgetMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveSvgWidgetMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
        ResolveSvgWidgetMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
        ResolveSvgWidgetMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveSvgWidgetMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveSvgWidgetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSvgWidgetMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveSvgWidgetMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveSvgWidgetMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveSvgWidgetMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveSvgWidgetMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveSvgWidgetMethod "loadFromBytes" o = SvgWidgetLoadFromBytesMethodInfo
        ResolveSvgWidgetMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveSvgWidgetMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
        ResolveSvgWidgetMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveSvgWidgetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSvgWidgetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSvgWidgetMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
        ResolveSvgWidgetMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
        ResolveSvgWidgetMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
        ResolveSvgWidgetMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveSvgWidgetMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveSvgWidgetMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveSvgWidgetMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveSvgWidgetMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSvgWidgetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSvgWidgetMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
        ResolveSvgWidgetMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
        ResolveSvgWidgetMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveSvgWidgetMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveSvgWidgetMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
        ResolveSvgWidgetMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
        ResolveSvgWidgetMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
        ResolveSvgWidgetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSvgWidgetMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
        ResolveSvgWidgetMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveSvgWidgetMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveSvgWidgetMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
        ResolveSvgWidgetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSvgWidgetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSvgWidgetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSvgWidgetMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveSvgWidgetMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveSvgWidgetMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveSvgWidgetMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveSvgWidgetMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveSvgWidgetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSvgWidgetMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveSvgWidgetMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
        ResolveSvgWidgetMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
        ResolveSvgWidgetMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
        ResolveSvgWidgetMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
        ResolveSvgWidgetMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
        ResolveSvgWidgetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSvgWidgetMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
        ResolveSvgWidgetMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
        ResolveSvgWidgetMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
        ResolveSvgWidgetMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveSvgWidgetMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveSvgWidgetMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveSvgWidgetMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveSvgWidgetMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveSvgWidgetMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
        ResolveSvgWidgetMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
        ResolveSvgWidgetMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
        ResolveSvgWidgetMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveSvgWidgetMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveSvgWidgetMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
        ResolveSvgWidgetMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveSvgWidgetMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveSvgWidgetMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
        ResolveSvgWidgetMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
        ResolveSvgWidgetMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
        ResolveSvgWidgetMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
        ResolveSvgWidgetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSvgWidgetMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveSvgWidgetMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveSvgWidgetMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
        ResolveSvgWidgetMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
        ResolveSvgWidgetMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
        ResolveSvgWidgetMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveSvgWidgetMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
        ResolveSvgWidgetMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveSvgWidgetMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveSvgWidgetMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveSvgWidgetMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveSvgWidgetMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveSvgWidgetMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
        ResolveSvgWidgetMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveSvgWidgetMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveSvgWidgetMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
        ResolveSvgWidgetMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
        ResolveSvgWidgetMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
        ResolveSvgWidgetMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveSvgWidgetMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveSvgWidgetMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveSvgWidgetMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveSvgWidgetMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveSvgWidgetMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveSvgWidgetMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
        ResolveSvgWidgetMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
        ResolveSvgWidgetMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
        ResolveSvgWidgetMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveSvgWidgetMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
        ResolveSvgWidgetMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveSvgWidgetMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveSvgWidgetMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
        ResolveSvgWidgetMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveSvgWidgetMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
        ResolveSvgWidgetMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
        ResolveSvgWidgetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSvgWidgetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSvgWidgetMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveSvgWidgetMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveSvgWidgetMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveSvgWidgetMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
        ResolveSvgWidgetMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveSvgWidgetMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveSvgWidgetMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveSvgWidgetMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
        ResolveSvgWidgetMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveSvgWidgetMethod "getState" o = SvgWidgetGetStateMethodInfo
        ResolveSvgWidgetMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveSvgWidgetMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveSvgWidgetMethod "getStylesheet" o = SvgWidgetGetStylesheetMethodInfo
        ResolveSvgWidgetMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveSvgWidgetMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveSvgWidgetMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveSvgWidgetMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveSvgWidgetMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveSvgWidgetMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveSvgWidgetMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveSvgWidgetMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
        ResolveSvgWidgetMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
        ResolveSvgWidgetMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveSvgWidgetMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
        ResolveSvgWidgetMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveSvgWidgetMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
        ResolveSvgWidgetMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
        ResolveSvgWidgetMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
        ResolveSvgWidgetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSvgWidgetMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSvgWidgetMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveSvgWidgetMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
        ResolveSvgWidgetMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveSvgWidgetMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
        ResolveSvgWidgetMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveSvgWidgetMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveSvgWidgetMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveSvgWidgetMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveSvgWidgetMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveSvgWidgetMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveSvgWidgetMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
        ResolveSvgWidgetMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
        ResolveSvgWidgetMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveSvgWidgetMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveSvgWidgetMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveSvgWidgetMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveSvgWidgetMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveSvgWidgetMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveSvgWidgetMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
        ResolveSvgWidgetMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveSvgWidgetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSvgWidgetMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveSvgWidgetMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveSvgWidgetMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveSvgWidgetMethod "setState" o = SvgWidgetSetStateMethodInfo
        ResolveSvgWidgetMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveSvgWidgetMethod "setStylesheet" o = SvgWidgetSetStylesheetMethodInfo
        ResolveSvgWidgetMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveSvgWidgetMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveSvgWidgetMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveSvgWidgetMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveSvgWidgetMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveSvgWidgetMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveSvgWidgetMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal SvgWidget::activate
    -- | Emitted when a link or other element is activated.
    --
    -- Activating elements can be achieved by clicking
    -- or by hitting \<kbd>Enter\<\/kbd> while the element
    -- has focus.
    --
    -- /Since: 4.24/
    type SvgWidgetActivateCallback =
        Maybe T.Text
        -- ^ /@id@/: the ID of the element
        -> Maybe T.Text
        -- ^ /@href@/: the href, if the element is a link
        -> IO ()

    type C_SvgWidgetActivateCallback =
        Ptr SvgWidget ->                        -- object
        CString ->
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_SvgWidgetActivateCallback`.
    foreign import ccall "wrapper"
        mk_SvgWidgetActivateCallback :: C_SvgWidgetActivateCallback -> IO (FunPtr C_SvgWidgetActivateCallback)

    wrap_SvgWidgetActivateCallback ::
        GObject a => (a -> SvgWidgetActivateCallback) ->
        C_SvgWidgetActivateCallback
    wrap_SvgWidgetActivateCallback :: forall a.
    GObject a =>
    (a -> SvgWidgetActivateCallback) -> C_SvgWidgetActivateCallback
    wrap_SvgWidgetActivateCallback a -> SvgWidgetActivateCallback
    gi'cb Ptr SvgWidget
    gi'selfPtr CString
    id CString
    href Ptr ()
    _ = do
        maybeId <-
            if CString
    id CString -> CString -> Bool
    forall a. Eq a => a -> a -> Bool
    == CString
    forall a. Ptr a
    FP.nullPtr
            then Maybe Text -> IO (Maybe Text)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    forall a. Maybe a
    Nothing
            else do
                id' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    id
                return $ Just id'
        maybeHref <-
            if href == FP.nullPtr
            then return Nothing
            else do
                href' <- cstringToText href
                return $ Just href'
        B.ManagedPtr.withNewObject gi'selfPtr $ \SvgWidget
    gi'self -> a -> SvgWidgetActivateCallback
    gi'cb (SvgWidget -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SvgWidget
    gi'self)  Maybe Text
    maybeId Maybe Text
    maybeHref

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' svgWidget #activate callback
    -- @
    --
    --
    onSvgWidgetActivate :: (IsSvgWidget a, MonadIO m) => a -> ((?self :: a) => SvgWidgetActivateCallback) -> m SignalHandlerId
    onSvgWidgetActivate :: forall a (m :: * -> *).
    (IsSvgWidget a, MonadIO m) =>
    a -> ((?self::a) => SvgWidgetActivateCallback) -> m SignalHandlerId
    onSvgWidgetActivate a
    obj (?self::a) => SvgWidgetActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgWidgetActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgWidgetActivateCallback
    SvgWidgetActivateCallback
    cb
        let wrapped' :: C_SvgWidgetActivateCallback
    wrapped' = (a -> SvgWidgetActivateCallback) -> C_SvgWidgetActivateCallback
    forall a.
    GObject a =>
    (a -> SvgWidgetActivateCallback) -> C_SvgWidgetActivateCallback
    wrap_SvgWidgetActivateCallback a -> SvgWidgetActivateCallback
    wrapped
        wrapped'' <- C_SvgWidgetActivateCallback
    -> IO (FunPtr C_SvgWidgetActivateCallback)
    mk_SvgWidgetActivateCallback C_SvgWidgetActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' svgWidget #activate callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSvgWidgetActivate :: (IsSvgWidget a, MonadIO m) => a -> ((?self :: a) => SvgWidgetActivateCallback) -> m SignalHandlerId
    afterSvgWidgetActivate :: forall a (m :: * -> *).
    (IsSvgWidget a, MonadIO m) =>
    a -> ((?self::a) => SvgWidgetActivateCallback) -> m SignalHandlerId
    afterSvgWidgetActivate a
    obj (?self::a) => SvgWidgetActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgWidgetActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgWidgetActivateCallback
    SvgWidgetActivateCallback
    cb
        let wrapped' :: C_SvgWidgetActivateCallback
    wrapped' = (a -> SvgWidgetActivateCallback) -> C_SvgWidgetActivateCallback
    forall a.
    GObject a =>
    (a -> SvgWidgetActivateCallback) -> C_SvgWidgetActivateCallback
    wrap_SvgWidgetActivateCallback a -> SvgWidgetActivateCallback
    wrapped
        wrapped'' <- C_SvgWidgetActivateCallback
    -> IO (FunPtr C_SvgWidgetActivateCallback)
    mk_SvgWidgetActivateCallback C_SvgWidgetActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetActivateSignalInfo
    instance SignalInfo SvgWidgetActivateSignalInfo where
        type HaskellCallbackType SvgWidgetActivateSignalInfo = SvgWidgetActivateCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SvgWidgetActivateCallback cb
            cb'' <- mk_SvgWidgetActivateCallback cb'
            connectSignalFunPtr obj "activate" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget::activate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#g:signal:activate"})

    #endif

    -- signal SvgWidget::error
    -- | Signals that an error occurred.
    --
    -- Errors can occur both during parsing and during rendering.
    --
    -- The expected error values are in the [error/@gtk@/.SvgError] enumeration,
    -- context information about the location of parsing errors can
    -- be obtained with the various @gtk_svg_error@ functions.
    --
    -- Parsing errors are never fatal, so the parsing will resume after
    -- the error. Errors may however cause parts of the given data or
    -- even all of it to not be parsed at all. So it is a useful idea
    -- to check that the parsing succeeds by connecting to this signal.
    --
    -- ::: note
    --     This signal is emitted in the middle of parsing or rendering,
    --     and if you handle it, you must be careful. Logging the errors
    --     you receive is fine, but modifying the widget hierarchy or
    --     changing the paintable state definitively isn\'t.
    --
    --     If in doubt, defer to an idle.
    --
    -- /Since: 4.24/
    type SvgWidgetErrorCallback =
        GError
        -- ^ /@error@/: the error
        -> IO ()

    type C_SvgWidgetErrorCallback =
        Ptr SvgWidget ->                        -- object
        Ptr GError ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_SvgWidgetErrorCallback`.
    foreign import ccall "wrapper"
        mk_SvgWidgetErrorCallback :: C_SvgWidgetErrorCallback -> IO (FunPtr C_SvgWidgetErrorCallback)

    wrap_SvgWidgetErrorCallback ::
        GObject a => (a -> SvgWidgetErrorCallback) ->
        C_SvgWidgetErrorCallback
    wrap_SvgWidgetErrorCallback :: forall a.
    GObject a =>
    (a -> SvgWidgetErrorCallback) -> C_SvgWidgetErrorCallback
    wrap_SvgWidgetErrorCallback a -> SvgWidgetErrorCallback
    gi'cb Ptr SvgWidget
    gi'selfPtr Ptr GError
    error_ Ptr ()
    _ = do
        error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr GError -> GError
    GError) Ptr GError
    error_
        B.ManagedPtr.withNewObject gi'selfPtr $ \SvgWidget
    gi'self -> a -> SvgWidgetErrorCallback
    gi'cb (SvgWidget -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SvgWidget
    gi'self)  GError
    error_'

    -- | Connect a signal handler for the [error](#signal:error) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' svgWidget #error callback
    -- @
    --
    --
    onSvgWidgetError :: (IsSvgWidget a, MonadIO m) => a -> ((?self :: a) => SvgWidgetErrorCallback) -> m SignalHandlerId
    onSvgWidgetError :: forall a (m :: * -> *).
    (IsSvgWidget a, MonadIO m) =>
    a -> ((?self::a) => SvgWidgetErrorCallback) -> m SignalHandlerId
    onSvgWidgetError a
    obj (?self::a) => SvgWidgetErrorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgWidgetErrorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgWidgetErrorCallback
    SvgWidgetErrorCallback
    cb
        let wrapped' :: C_SvgWidgetErrorCallback
    wrapped' = (a -> SvgWidgetErrorCallback) -> C_SvgWidgetErrorCallback
    forall a.
    GObject a =>
    (a -> SvgWidgetErrorCallback) -> C_SvgWidgetErrorCallback
    wrap_SvgWidgetErrorCallback a -> SvgWidgetErrorCallback
    wrapped
        wrapped'' <- C_SvgWidgetErrorCallback -> IO (FunPtr C_SvgWidgetErrorCallback)
    mk_SvgWidgetErrorCallback C_SvgWidgetErrorCallback
    wrapped'
        connectSignalFunPtr obj "error" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [error](#signal:error) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' svgWidget #error callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSvgWidgetError :: (IsSvgWidget a, MonadIO m) => a -> ((?self :: a) => SvgWidgetErrorCallback) -> m SignalHandlerId
    afterSvgWidgetError :: forall a (m :: * -> *).
    (IsSvgWidget a, MonadIO m) =>
    a -> ((?self::a) => SvgWidgetErrorCallback) -> m SignalHandlerId
    afterSvgWidgetError a
    obj (?self::a) => SvgWidgetErrorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgWidgetErrorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgWidgetErrorCallback
    SvgWidgetErrorCallback
    cb
        let wrapped' :: C_SvgWidgetErrorCallback
    wrapped' = (a -> SvgWidgetErrorCallback) -> C_SvgWidgetErrorCallback
    forall a.
    GObject a =>
    (a -> SvgWidgetErrorCallback) -> C_SvgWidgetErrorCallback
    wrap_SvgWidgetErrorCallback a -> SvgWidgetErrorCallback
    wrapped
        wrapped'' <- C_SvgWidgetErrorCallback -> IO (FunPtr C_SvgWidgetErrorCallback)
    mk_SvgWidgetErrorCallback C_SvgWidgetErrorCallback
    wrapped'
        connectSignalFunPtr obj "error" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetErrorSignalInfo
    instance SignalInfo SvgWidgetErrorSignalInfo where
        type HaskellCallbackType SvgWidgetErrorSignalInfo = SvgWidgetErrorCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SvgWidgetErrorCallback cb
            cb'' <- mk_SvgWidgetErrorCallback cb'
            connectSignalFunPtr obj "error" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget::error"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#g:signal:error"})

    #endif

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

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

    -- | Set the value of the “@resource@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svgWidget [ #resource 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgWidgetResource :: (MonadIO m, IsSvgWidget o) => o -> T.Text -> m ()
    setSvgWidgetResource :: forall (m :: * -> *) o.
    (MonadIO m, IsSvgWidget o) =>
    o -> Text -> m ()
    setSvgWidgetResource o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "resource" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    val)

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

    -- | Set the value of the “@resource@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #resource
    -- @
    clearSvgWidgetResource :: (MonadIO m, IsSvgWidget o) => o -> m ()
    clearSvgWidgetResource :: forall (m :: * -> *) o. (MonadIO m, IsSvgWidget o) => o -> m ()
    clearSvgWidgetResource o
    obj = 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
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "resource" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetResourcePropertyInfo
    instance AttrInfo SvgWidgetResourcePropertyInfo where
        type AttrAllowedOps SvgWidgetResourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SvgWidgetResourcePropertyInfo = IsSvgWidget
        type AttrSetTypeConstraint SvgWidgetResourcePropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SvgWidgetResourcePropertyInfo = (~) T.Text
        type AttrTransferType SvgWidgetResourcePropertyInfo = T.Text
        type AttrGetType SvgWidgetResourcePropertyInfo = (Maybe T.Text)
        type AttrLabel SvgWidgetResourcePropertyInfo = "resource"
        type AttrOrigin SvgWidgetResourcePropertyInfo = SvgWidget
        attrGet = getSvgWidgetResource
        attrSet = setSvgWidgetResource
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgWidgetResource
        attrClear = clearSvgWidgetResource
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.resource"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#g:attr:resource"
            })
    #endif

    -- VVV Prop "state"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    -- | Set the value of the “@state@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svgWidget [ #state 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgWidgetState :: (MonadIO m, IsSvgWidget o) => o -> Word32 -> m ()
    setSvgWidgetState :: forall (m :: * -> *) o.
    (MonadIO m, IsSvgWidget o) =>
    o -> Word32 -> m ()
    setSvgWidgetState o
    obj Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "state" Word32
    val

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

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetStatePropertyInfo
    instance AttrInfo SvgWidgetStatePropertyInfo where
        type AttrAllowedOps SvgWidgetStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgWidgetStatePropertyInfo = IsSvgWidget
        type AttrSetTypeConstraint SvgWidgetStatePropertyInfo = (~) Word32
        type AttrTransferTypeConstraint SvgWidgetStatePropertyInfo = (~) Word32
        type AttrTransferType SvgWidgetStatePropertyInfo = Word32
        type AttrGetType SvgWidgetStatePropertyInfo = Word32
        type AttrLabel SvgWidgetStatePropertyInfo = "state"
        type AttrOrigin SvgWidgetStatePropertyInfo = SvgWidget
        attrGet = getSvgWidgetState
        attrSet = setSvgWidgetState
        attrPut = setSvgWidgetState
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgWidgetState
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.state"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#g:attr:state"
            })
    #endif

    -- VVV Prop "stylesheet"
       -- Type: TInterface (Name {namespace = "GLib", name = "Bytes"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Just True)

    -- | Get the value of the “@stylesheet@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svgWidget #stylesheet
    -- @
    getSvgWidgetStylesheet :: (MonadIO m, IsSvgWidget o) => o -> m (Maybe GLib.Bytes.Bytes)
    getSvgWidgetStylesheet :: forall (m :: * -> *) o.
    (MonadIO m, IsSvgWidget o) =>
    o -> m (Maybe Bytes)
    getSvgWidgetStylesheet o
    obj = IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
    -> IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Bytes -> Bytes) -> IO (Maybe Bytes)
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyBoxed o
    obj String
    "stylesheet" ManagedPtr Bytes -> Bytes
    GLib.Bytes.Bytes

    -- | Set the value of the “@stylesheet@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svgWidget [ #stylesheet 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgWidgetStylesheet :: (MonadIO m, IsSvgWidget o) => o -> GLib.Bytes.Bytes -> m ()
    setSvgWidgetStylesheet :: forall (m :: * -> *) o.
    (MonadIO m, IsSvgWidget o) =>
    o -> Bytes -> m ()
    setSvgWidgetStylesheet o
    obj Bytes
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Bytes -> IO ()
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyBoxed o
    obj String
    "stylesheet" (Bytes -> Maybe Bytes
    forall a. a -> Maybe a
    Just Bytes
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@stylesheet@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgWidgetStylesheet :: (IsSvgWidget o, MIO.MonadIO m) => GLib.Bytes.Bytes -> m (GValueConstruct o)
    constructSvgWidgetStylesheet :: forall o (m :: * -> *).
    (IsSvgWidget o, MonadIO m) =>
    Bytes -> m (GValueConstruct o)
    constructSvgWidgetStylesheet Bytes
    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 Bytes -> IO (GValueConstruct o)
    forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBoxed String
    "stylesheet" (Bytes -> Maybe Bytes
    forall a. a -> Maybe a
    P.Just Bytes
    val)

    -- | Set the value of the “@stylesheet@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #stylesheet
    -- @
    clearSvgWidgetStylesheet :: (MonadIO m, IsSvgWidget o) => o -> m ()
    clearSvgWidgetStylesheet :: forall (m :: * -> *) o. (MonadIO m, IsSvgWidget o) => o -> m ()
    clearSvgWidgetStylesheet o
    obj = 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
    $ o -> String -> Maybe Bytes -> IO ()
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyBoxed o
    obj String
    "stylesheet" (Maybe Bytes
    forall a. Maybe a
    Nothing :: Maybe GLib.Bytes.Bytes)

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetStylesheetPropertyInfo
    instance AttrInfo SvgWidgetStylesheetPropertyInfo where
        type AttrAllowedOps SvgWidgetStylesheetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SvgWidgetStylesheetPropertyInfo = IsSvgWidget
        type AttrSetTypeConstraint SvgWidgetStylesheetPropertyInfo = (~) GLib.Bytes.Bytes
        type AttrTransferTypeConstraint SvgWidgetStylesheetPropertyInfo = (~) GLib.Bytes.Bytes
        type AttrTransferType SvgWidgetStylesheetPropertyInfo = GLib.Bytes.Bytes
        type AttrGetType SvgWidgetStylesheetPropertyInfo = (Maybe GLib.Bytes.Bytes)
        type AttrLabel SvgWidgetStylesheetPropertyInfo = "stylesheet"
        type AttrOrigin SvgWidgetStylesheetPropertyInfo = SvgWidget
        attrGet = getSvgWidgetStylesheet
        attrSet = setSvgWidgetStylesheet
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgWidgetStylesheet
        attrClear = clearSvgWidgetStylesheet
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.stylesheet"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#g:attr:stylesheet"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList SvgWidget
    type instance O.AttributeList SvgWidget = SvgWidgetAttributeList
    type SvgWidgetAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resource", SvgWidgetResourcePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("state", SvgWidgetStatePropertyInfo), '("stylesheet", SvgWidgetStylesheetPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    svgWidgetResource :: AttrLabelProxy "resource"
    svgWidgetResource = AttrLabelProxy

    svgWidgetState :: AttrLabelProxy "state"
    svgWidgetState = AttrLabelProxy

    svgWidgetStylesheet :: AttrLabelProxy "stylesheet"
    svgWidgetStylesheet = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList SvgWidget = SvgWidgetSignalList
    type SvgWidgetSignalList = ('[ '("activate", SvgWidgetActivateSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("error", SvgWidgetErrorSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method SvgWidget::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SvgWidget" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_new" gtk_svg_widget_new ::
        IO (Ptr SvgWidget)

    -- | Creates a new, empty @GtkSvgWidget@.
    --
    -- /Since: 4.24/
    svgWidgetNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m SvgWidget
        -- ^ __Returns:__ the new widget
    svgWidgetNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m SvgWidget
    svgWidgetNew  = IO SvgWidget -> m SvgWidget
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SvgWidget -> m SvgWidget) -> IO SvgWidget -> m SvgWidget
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr SvgWidget)
    gtk_svg_widget_new
        checkUnexpectedReturnNULL "svgWidgetNew" result
        result' <- (newObject SvgWidget) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method SvgWidget::get_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgWidget" }
    --           , argCType = Just "GtkSvgWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_get_state" gtk_svg_widget_get_state ::
        Ptr SvgWidget ->                        -- self : TInterface (Name {namespace = "Gtk", name = "SvgWidget"})
        IO Word32

    -- | Gets the current state of the widget.
    --
    -- /Since: 4.24/
    svgWidgetGetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvgWidget a) =>
        a
        -- ^ /@self@/: an SVG widget
        -> m Word32
        -- ^ __Returns:__ the state
    svgWidgetGetState :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvgWidget a) =>
    a -> m Word32
    svgWidgetGetState a
    self = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr SvgWidget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_widget_get_state self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetGetStateMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsSvgWidget a) => O.OverloadedMethod SvgWidgetGetStateMethodInfo a signature where
        overloadedMethod = svgWidgetGetState

    instance O.OverloadedMethodInfo SvgWidgetGetStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.svgWidgetGetState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#v:svgWidgetGetState"
            })

    #endif

    -- method SvgWidget::get_stylesheet
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgWidget" }
    --           , argCType = Just "GtkSvgWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_get_stylesheet" gtk_svg_widget_get_stylesheet ::
        Ptr SvgWidget ->                        -- self : TInterface (Name {namespace = "Gtk", name = "SvgWidget"})
        IO (Ptr GLib.Bytes.Bytes)

    -- | Gets the CSS user stylesheet.
    --
    -- /Since: 4.24/
    svgWidgetGetStylesheet ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvgWidget a) =>
        a
        -- ^ /@self@/: an SVG widget
        -> m (Maybe GLib.Bytes.Bytes)
        -- ^ __Returns:__ a @GBytes@ with the CSS data
    svgWidgetGetStylesheet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvgWidget a) =>
    a -> m (Maybe Bytes)
    svgWidgetGetStylesheet a
    self = IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
    -> IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr SvgWidget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_widget_get_stylesheet self'
        maybeResult <- convertIfNonNull result $ \Ptr Bytes
    result' -> do
            result'' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Bytes -> Bytes
    GLib.Bytes.Bytes) Ptr Bytes
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetGetStylesheetMethodInfo
    instance (signature ~ (m (Maybe GLib.Bytes.Bytes)), MonadIO m, IsSvgWidget a) => O.OverloadedMethod SvgWidgetGetStylesheetMethodInfo a signature where
        overloadedMethod = svgWidgetGetStylesheet

    instance O.OverloadedMethodInfo SvgWidgetGetStylesheetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.svgWidgetGetStylesheet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#v:svgWidgetGetStylesheet"
            })

    #endif

    -- method SvgWidget::load_from_bytes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgWidget" }
    --           , argCType = Just "GtkSvgWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the data to data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_load_from_bytes" gtk_svg_widget_load_from_bytes ::
        Ptr SvgWidget ->                        -- self : TInterface (Name {namespace = "Gtk", name = "SvgWidget"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    -- | Loads SVG content into an existing SVG widget.
    --
    -- To track errors while loading SVG content, connect
    -- to the [SvgWidget::error]("GI.Gtk.Objects.SvgWidget#g:signal:error") signal.
    --
    -- This clears any previously loaded content.
    --
    -- /Since: 4.24/
    svgWidgetLoadFromBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvgWidget a) =>
        a
        -- ^ /@self@/: an SVG widget
        -> GLib.Bytes.Bytes
        -- ^ /@bytes@/: the data to data
        -> m ()
    svgWidgetLoadFromBytes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvgWidget a) =>
    a -> Bytes -> m ()
    svgWidgetLoadFromBytes a
    self Bytes
    bytes = 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
        self' <- a -> IO (Ptr SvgWidget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        bytes' <- unsafeManagedPtrGetPtr bytes
        gtk_svg_widget_load_from_bytes self' bytes'
        touchManagedPtr self
        touchManagedPtr bytes
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetLoadFromBytesMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m, IsSvgWidget a) => O.OverloadedMethod SvgWidgetLoadFromBytesMethodInfo a signature where
        overloadedMethod = svgWidgetLoadFromBytes

    instance O.OverloadedMethodInfo SvgWidgetLoadFromBytesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.svgWidgetLoadFromBytes",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#v:svgWidgetLoadFromBytes"
            })

    #endif

    -- method SvgWidget::set_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgWidget" }
    --           , argCType = Just "GtkSvgWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "state"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the state to set, as a value between 0 and 63"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_set_state" gtk_svg_widget_set_state ::
        Ptr SvgWidget ->                        -- self : TInterface (Name {namespace = "Gtk", name = "SvgWidget"})
        Word32 ->                               -- state : TBasicType TUInt
        IO ()

    -- | Sets the state of the widget.
    --
    -- The state change will apply transitions that are defined
    -- in the SVG. See t'GI.Gtk.Objects.Svg.Svg' for details about states
    -- and transitions.
    --
    -- /Since: 4.24/
    svgWidgetSetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvgWidget a) =>
        a
        -- ^ /@self@/: an SVG widget
        -> Word32
        -- ^ /@state@/: the state to set, as a value between 0 and 63
        -> m ()
    svgWidgetSetState :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvgWidget a) =>
    a -> Word32 -> m ()
    svgWidgetSetState a
    self Word32
    state = 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
        self' <- a -> IO (Ptr SvgWidget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_svg_widget_set_state self' state
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetSetStateMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsSvgWidget a) => O.OverloadedMethod SvgWidgetSetStateMethodInfo a signature where
        overloadedMethod = svgWidgetSetState

    instance O.OverloadedMethodInfo SvgWidgetSetStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.svgWidgetSetState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#v:svgWidgetSetState"
            })

    #endif

    -- method SvgWidget::set_stylesheet
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgWidget" }
    --           , argCType = Just "GtkSvgWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "CSS data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_widget_set_stylesheet" gtk_svg_widget_set_stylesheet ::
        Ptr SvgWidget ->                        -- self : TInterface (Name {namespace = "Gtk", name = "SvgWidget"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    -- | Sets a CSS user stylesheet to use.
    --
    -- Note that styles are applied at load time, so this
    -- function must be called before loading SVG.
    --
    -- /Since: 4.24/
    svgWidgetSetStylesheet ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvgWidget a) =>
        a
        -- ^ /@self@/: an SVG widget
        -> Maybe (GLib.Bytes.Bytes)
        -- ^ /@bytes@/: CSS data
        -> m ()
    svgWidgetSetStylesheet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvgWidget a) =>
    a -> Maybe Bytes -> m ()
    svgWidgetSetStylesheet a
    self Maybe Bytes
    bytes = 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
        self' <- a -> IO (Ptr SvgWidget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeBytes <- case bytes of
            Maybe Bytes
    Nothing -> Ptr Bytes -> IO (Ptr Bytes)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Bytes
    forall a. Ptr a
    FP.nullPtr
            Just Bytes
    jBytes -> do
                jBytes' <- Bytes -> IO (Ptr Bytes)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Bytes
    jBytes
                return jBytes'
        gtk_svg_widget_set_stylesheet self' maybeBytes
        touchManagedPtr self
        whenJust bytes touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgWidgetSetStylesheetMethodInfo
    instance (signature ~ (Maybe (GLib.Bytes.Bytes) -> m ()), MonadIO m, IsSvgWidget a) => O.OverloadedMethod SvgWidgetSetStylesheetMethodInfo a signature where
        overloadedMethod = svgWidgetSetStylesheet

    instance O.OverloadedMethodInfo SvgWidgetSetStylesheetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SvgWidget.svgWidgetSetStylesheet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SvgWidget.html#v:svgWidgetSetStylesheet"
            })

    #endif