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