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

GtkWidgetPath is a boxed type that represents a widget hierarchy from
the topmost widget, typically a toplevel, to any child. This widget
path abstraction is used in 'GI.Gtk.Objects.StyleContext.StyleContext' on behalf of the real
widget in order to query style information.

If you are using GTK+ widgets, you probably will not need to use
this API directly, as there is 'GI.Gtk.Objects.Widget.widgetGetPath', and the style
context returned by 'GI.Gtk.Objects.Widget.widgetGetStyleContext' will be automatically
updated on widget hierarchy changes.

The widget path generation is generally simple:

== Defining a button within a window


=== /C code/
>
>{
>  GtkWidgetPath *path;
>
>  path = gtk_widget_path_new ();
>  gtk_widget_path_append_type (path, GTK_TYPE_WINDOW);
>  gtk_widget_path_append_type (path, GTK_TYPE_BUTTON);
>}


Although more complex information, such as widget names, or
different classes (property that may be used by other widget
types) and intermediate regions may be included:

== Defining the first tab widget in a notebook


=== /C code/
>
>{
>  GtkWidgetPath *path;
>  guint pos;
>
>  path = gtk_widget_path_new ();
>
>  pos = gtk_widget_path_append_type (path, GTK_TYPE_NOTEBOOK);
>  gtk_widget_path_iter_add_region (path, pos, "tab", GTK_REGION_EVEN | GTK_REGION_FIRST);
>
>  pos = gtk_widget_path_append_type (path, GTK_TYPE_LABEL);
>  gtk_widget_path_iter_set_name (path, pos, "first tab label");
>}


All this information will be used to match the style information
that applies to the described widget.
-}

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

module GI.Gtk.Structs.WidgetPath
    (

-- * Exported types
    WidgetPath(..)                          ,
    noWidgetPath                            ,


 -- * Methods
-- ** appendForWidget #method:appendForWidget#

#if ENABLE_OVERLOADING
    WidgetPathAppendForWidgetMethodInfo     ,
#endif
    widgetPathAppendForWidget               ,


-- ** appendType #method:appendType#

#if ENABLE_OVERLOADING
    WidgetPathAppendTypeMethodInfo          ,
#endif
    widgetPathAppendType                    ,


-- ** appendWithSiblings #method:appendWithSiblings#

#if ENABLE_OVERLOADING
    WidgetPathAppendWithSiblingsMethodInfo  ,
#endif
    widgetPathAppendWithSiblings            ,


-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    WidgetPathCopyMethodInfo                ,
#endif
    widgetPathCopy                          ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    WidgetPathFreeMethodInfo                ,
#endif
    widgetPathFree                          ,


-- ** getObjectType #method:getObjectType#

#if ENABLE_OVERLOADING
    WidgetPathGetObjectTypeMethodInfo       ,
#endif
    widgetPathGetObjectType                 ,


-- ** hasParent #method:hasParent#

#if ENABLE_OVERLOADING
    WidgetPathHasParentMethodInfo           ,
#endif
    widgetPathHasParent                     ,


-- ** isType #method:isType#

#if ENABLE_OVERLOADING
    WidgetPathIsTypeMethodInfo              ,
#endif
    widgetPathIsType                        ,


-- ** iterAddClass #method:iterAddClass#

#if ENABLE_OVERLOADING
    WidgetPathIterAddClassMethodInfo        ,
#endif
    widgetPathIterAddClass                  ,


-- ** iterAddRegion #method:iterAddRegion#

#if ENABLE_OVERLOADING
    WidgetPathIterAddRegionMethodInfo       ,
#endif
    widgetPathIterAddRegion                 ,


-- ** iterClearClasses #method:iterClearClasses#

#if ENABLE_OVERLOADING
    WidgetPathIterClearClassesMethodInfo    ,
#endif
    widgetPathIterClearClasses              ,


-- ** iterClearRegions #method:iterClearRegions#

#if ENABLE_OVERLOADING
    WidgetPathIterClearRegionsMethodInfo    ,
#endif
    widgetPathIterClearRegions              ,


-- ** iterGetName #method:iterGetName#

#if ENABLE_OVERLOADING
    WidgetPathIterGetNameMethodInfo         ,
#endif
    widgetPathIterGetName                   ,


-- ** iterGetObjectName #method:iterGetObjectName#

#if ENABLE_OVERLOADING
    WidgetPathIterGetObjectNameMethodInfo   ,
#endif
    widgetPathIterGetObjectName             ,


-- ** iterGetObjectType #method:iterGetObjectType#

#if ENABLE_OVERLOADING
    WidgetPathIterGetObjectTypeMethodInfo   ,
#endif
    widgetPathIterGetObjectType             ,


-- ** iterGetSiblingIndex #method:iterGetSiblingIndex#

#if ENABLE_OVERLOADING
    WidgetPathIterGetSiblingIndexMethodInfo ,
#endif
    widgetPathIterGetSiblingIndex           ,


-- ** iterGetSiblings #method:iterGetSiblings#

#if ENABLE_OVERLOADING
    WidgetPathIterGetSiblingsMethodInfo     ,
#endif
    widgetPathIterGetSiblings               ,


-- ** iterGetState #method:iterGetState#

#if ENABLE_OVERLOADING
    WidgetPathIterGetStateMethodInfo        ,
#endif
    widgetPathIterGetState                  ,


-- ** iterHasClass #method:iterHasClass#

#if ENABLE_OVERLOADING
    WidgetPathIterHasClassMethodInfo        ,
#endif
    widgetPathIterHasClass                  ,


-- ** iterHasName #method:iterHasName#

#if ENABLE_OVERLOADING
    WidgetPathIterHasNameMethodInfo         ,
#endif
    widgetPathIterHasName                   ,


-- ** iterHasQclass #method:iterHasQclass#

#if ENABLE_OVERLOADING
    WidgetPathIterHasQclassMethodInfo       ,
#endif
    widgetPathIterHasQclass                 ,


-- ** iterHasQname #method:iterHasQname#

#if ENABLE_OVERLOADING
    WidgetPathIterHasQnameMethodInfo        ,
#endif
    widgetPathIterHasQname                  ,


-- ** iterHasQregion #method:iterHasQregion#

#if ENABLE_OVERLOADING
    WidgetPathIterHasQregionMethodInfo      ,
#endif
    widgetPathIterHasQregion                ,


-- ** iterHasRegion #method:iterHasRegion#

#if ENABLE_OVERLOADING
    WidgetPathIterHasRegionMethodInfo       ,
#endif
    widgetPathIterHasRegion                 ,


-- ** iterListClasses #method:iterListClasses#

#if ENABLE_OVERLOADING
    WidgetPathIterListClassesMethodInfo     ,
#endif
    widgetPathIterListClasses               ,


-- ** iterListRegions #method:iterListRegions#

#if ENABLE_OVERLOADING
    WidgetPathIterListRegionsMethodInfo     ,
#endif
    widgetPathIterListRegions               ,


-- ** iterRemoveClass #method:iterRemoveClass#

#if ENABLE_OVERLOADING
    WidgetPathIterRemoveClassMethodInfo     ,
#endif
    widgetPathIterRemoveClass               ,


-- ** iterRemoveRegion #method:iterRemoveRegion#

#if ENABLE_OVERLOADING
    WidgetPathIterRemoveRegionMethodInfo    ,
#endif
    widgetPathIterRemoveRegion              ,


-- ** iterSetName #method:iterSetName#

#if ENABLE_OVERLOADING
    WidgetPathIterSetNameMethodInfo         ,
#endif
    widgetPathIterSetName                   ,


-- ** iterSetObjectName #method:iterSetObjectName#

#if ENABLE_OVERLOADING
    WidgetPathIterSetObjectNameMethodInfo   ,
#endif
    widgetPathIterSetObjectName             ,


-- ** iterSetObjectType #method:iterSetObjectType#

#if ENABLE_OVERLOADING
    WidgetPathIterSetObjectTypeMethodInfo   ,
#endif
    widgetPathIterSetObjectType             ,


-- ** iterSetState #method:iterSetState#

#if ENABLE_OVERLOADING
    WidgetPathIterSetStateMethodInfo        ,
#endif
    widgetPathIterSetState                  ,


-- ** length #method:length#

#if ENABLE_OVERLOADING
    WidgetPathLengthMethodInfo              ,
#endif
    widgetPathLength                        ,


-- ** new #method:new#

    widgetPathNew                           ,


-- ** prependType #method:prependType#

#if ENABLE_OVERLOADING
    WidgetPathPrependTypeMethodInfo         ,
#endif
    widgetPathPrependType                   ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    WidgetPathRefMethodInfo                 ,
#endif
    widgetPathRef                           ,


-- ** toString #method:toString#

#if ENABLE_OVERLOADING
    WidgetPathToStringMethodInfo            ,
#endif
    widgetPathToString                      ,


-- ** unref #method:unref#

#if ENABLE_OVERLOADING
    WidgetPathUnrefMethodInfo               ,
#endif
    widgetPathUnref                         ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype WidgetPath = WidgetPath (ManagedPtr WidgetPath)
foreign import ccall "gtk_widget_path_get_type" c_gtk_widget_path_get_type ::
    IO GType

instance BoxedObject WidgetPath where
    boxedType _ = c_gtk_widget_path_get_type

-- | A convenience alias for `Nothing` :: `Maybe` `WidgetPath`.
noWidgetPath :: Maybe WidgetPath
noWidgetPath = Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList WidgetPath
type instance O.AttributeList WidgetPath = WidgetPathAttributeList
type WidgetPathAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "gtk_widget_path_new" gtk_widget_path_new ::
    IO (Ptr WidgetPath)

{- |
Returns an empty widget path.

/Since: 3.0/
-}
widgetPathNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WidgetPath
    {- ^ __Returns:__ A newly created, empty, 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
widgetPathNew  = liftIO $ do
    result <- gtk_widget_path_new
    checkUnexpectedReturnNULL "widgetPathNew" result
    result' <- (wrapBoxed WidgetPath) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method WidgetPath::append_for_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget to append to the widget path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_append_for_widget" gtk_widget_path_append_for_widget ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Appends the data from /@widget@/ to the widget hierarchy represented
by /@path@/. This function is a shortcut for adding information from
/@widget@/ to the given /@path@/. This includes setting the name or
adding the style classes from /@widget@/.

/Since: 3.2/
-}
widgetPathAppendForWidget ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
    WidgetPath
    {- ^ /@path@/: a widget path -}
    -> a
    {- ^ /@widget@/: the widget to append to the widget path -}
    -> m Int32
    {- ^ __Returns:__ the position where the data was inserted -}
widgetPathAppendForWidget path widget = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_path_append_for_widget path' widget'
    touchManagedPtr path
    touchManagedPtr widget
    return result

#if ENABLE_OVERLOADING
data WidgetPathAppendForWidgetMethodInfo
instance (signature ~ (a -> m Int32), MonadIO m, Gtk.Widget.IsWidget a) => O.MethodInfo WidgetPathAppendForWidgetMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathAppendForWidget

#endif

-- method WidgetPath::append_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget type to append", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_append_type" gtk_widget_path_append_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    CGType ->                               -- type : TBasicType TGType
    IO Int32

{- |
Appends a widget type to the widget hierarchy represented by /@path@/.

/Since: 3.0/
-}
widgetPathAppendType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> GType
    {- ^ /@type@/: widget type to append -}
    -> m Int32
    {- ^ __Returns:__ the position where the element was inserted -}
widgetPathAppendType path type_ = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let type_' = gtypeToCGType type_
    result <- gtk_widget_path_append_type path' type_'
    touchManagedPtr path
    return result

#if ENABLE_OVERLOADING
data WidgetPathAppendTypeMethodInfo
instance (signature ~ (GType -> m Int32), MonadIO m) => O.MethodInfo WidgetPathAppendTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathAppendType

#endif

-- method WidgetPath::append_with_siblings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget path to append to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "siblings", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget path describing a list of siblings. This path\n  may not contain any siblings itself and it must not be modified\n  afterwards.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sibling_index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index into @siblings for where the added element is\n  positioned.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_append_with_siblings" gtk_widget_path_append_with_siblings ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Ptr WidgetPath ->                       -- siblings : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Word32 ->                               -- sibling_index : TBasicType TUInt
    IO Int32

{- |
Appends a widget type with all its siblings to the widget hierarchy
represented by /@path@/. Using this function instead of
'GI.Gtk.Structs.WidgetPath.widgetPathAppendType' will allow the CSS theming to use
sibling matches in selectors and apply :nth-@/child()/@ pseudo classes.
In turn, it requires a lot more care in widget implementations as
widgets need to make sure to call 'GI.Gtk.Objects.Widget.widgetResetStyle' on all
involved widgets when the /@siblings@/ path changes.

/Since: 3.2/
-}
widgetPathAppendWithSiblings ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: the widget path to append to -}
    -> WidgetPath
    {- ^ /@siblings@/: a widget path describing a list of siblings. This path
  may not contain any siblings itself and it must not be modified
  afterwards. -}
    -> Word32
    {- ^ /@siblingIndex@/: index into /@siblings@/ for where the added element is
  positioned. -}
    -> m Int32
    {- ^ __Returns:__ the position where the element was inserted. -}
widgetPathAppendWithSiblings path siblings siblingIndex = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    siblings' <- unsafeManagedPtrGetPtr siblings
    result <- gtk_widget_path_append_with_siblings path' siblings' siblingIndex
    touchManagedPtr path
    touchManagedPtr siblings
    return result

#if ENABLE_OVERLOADING
data WidgetPathAppendWithSiblingsMethodInfo
instance (signature ~ (WidgetPath -> Word32 -> m Int32), MonadIO m) => O.MethodInfo WidgetPathAppendWithSiblingsMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathAppendWithSiblings

#endif

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

foreign import ccall "gtk_widget_path_copy" gtk_widget_path_copy ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO (Ptr WidgetPath)

{- |
Returns a copy of /@path@/

/Since: 3.0/
-}
widgetPathCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> m WidgetPath
    {- ^ __Returns:__ a copy of /@path@/ -}
widgetPathCopy path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_copy path'
    checkUnexpectedReturnNULL "widgetPathCopy" result
    result' <- (wrapBoxed WidgetPath) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathCopyMethodInfo
instance (signature ~ (m WidgetPath), MonadIO m) => O.MethodInfo WidgetPathCopyMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathCopy

#endif

-- method WidgetPath::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_free" gtk_widget_path_free ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO ()

{- |
Decrements the reference count on /@path@/, freeing the structure
if the reference count reaches 0.

/Since: 3.0/
-}
widgetPathFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> m ()
widgetPathFree path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    gtk_widget_path_free path'
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo WidgetPathFreeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathFree

#endif

-- method WidgetPath::get_object_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_get_object_type" gtk_widget_path_get_object_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO CGType

{- |
Returns the topmost object type, that is, the object type this path
is representing.

/Since: 3.0/
-}
widgetPathGetObjectType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m GType
    {- ^ __Returns:__ The object type -}
widgetPathGetObjectType path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_get_object_type path'
    let result' = GType result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathGetObjectTypeMethodInfo
instance (signature ~ (m GType), MonadIO m) => O.MethodInfo WidgetPathGetObjectTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathGetObjectType

#endif

-- method WidgetPath::has_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget type to check in parents", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_has_parent" gtk_widget_path_has_parent ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    CGType ->                               -- type : TBasicType TGType
    IO CInt

{- |
Returns 'True' if any of the parents of the widget represented
in /@path@/ is of type /@type@/, or any subtype of it.

/Since: 3.0/
-}
widgetPathHasParent ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> GType
    {- ^ /@type@/: widget type to check in parents -}
    -> m Bool
    {- ^ __Returns:__ 'True' if any parent is of type /@type@/ -}
widgetPathHasParent path type_ = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let type_' = gtypeToCGType type_
    result <- gtk_widget_path_has_parent path' type_'
    let result' = (/= 0) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathHasParentMethodInfo
instance (signature ~ (GType -> m Bool), MonadIO m) => O.MethodInfo WidgetPathHasParentMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathHasParent

#endif

-- method WidgetPath::is_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget type to match", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_is_type" gtk_widget_path_is_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    CGType ->                               -- type : TBasicType TGType
    IO CInt

{- |
Returns 'True' if the widget type represented by this path
is /@type@/, or a subtype of it.

/Since: 3.0/
-}
widgetPathIsType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> GType
    {- ^ /@type@/: widget type to match -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget represented by /@path@/ is of type /@type@/ -}
widgetPathIsType path type_ = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let type_' = gtypeToCGType type_
    result <- gtk_widget_path_is_type path' type_'
    let result' = (/= 0) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIsTypeMethodInfo
instance (signature ~ (GType -> m Bool), MonadIO m) => O.MethodInfo WidgetPathIsTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIsType

#endif

-- method WidgetPath::iter_add_class
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_add_class" gtk_widget_path_iter_add_class ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Adds the class /@name@/ to the widget at position /@pos@/ in
the hierarchy defined in /@path@/. See
'GI.Gtk.Objects.StyleContext.styleContextAddClass'.

/Since: 3.0/
-}
widgetPathIterAddClass ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: a class name -}
    -> m ()
widgetPathIterAddClass path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    gtk_widget_path_iter_add_class path' pos name'
    touchManagedPtr path
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterAddClassMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterAddClassMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterAddClass

#endif

-- method WidgetPath::iter_add_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "region name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "RegionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting the region", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_add_region" gtk_widget_path_iter_add_region ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "RegionFlags"})
    IO ()

{-# DEPRECATED widgetPathIterAddRegion ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
Adds the region /@name@/ to the widget at position /@pos@/ in
the hierarchy defined in /@path@/. See
'GI.Gtk.Objects.StyleContext.styleContextAddRegion'.

Region names must only contain lowercase letters
and “-”, starting always with a lowercase letter.

/Since: 3.0/
-}
widgetPathIterAddRegion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: region name -}
    -> [Gtk.Flags.RegionFlags]
    {- ^ /@flags@/: flags affecting the region -}
    -> m ()
widgetPathIterAddRegion path pos name flags = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    let flags' = gflagsToWord flags
    gtk_widget_path_iter_add_region path' pos name' flags'
    touchManagedPtr path
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterAddRegionMethodInfo
instance (signature ~ (Int32 -> T.Text -> [Gtk.Flags.RegionFlags] -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterAddRegionMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterAddRegion

#endif

-- method WidgetPath::iter_clear_classes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_clear_classes" gtk_widget_path_iter_clear_classes ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO ()

{- |
Removes all classes from the widget at position /@pos@/ in the
hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterClearClasses ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> m ()
widgetPathIterClearClasses path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    gtk_widget_path_iter_clear_classes path' pos
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterClearClassesMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterClearClassesMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterClearClasses

#endif

-- method WidgetPath::iter_clear_regions
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_clear_regions" gtk_widget_path_iter_clear_regions ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO ()

{-# DEPRECATED widgetPathIterClearRegions ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
Removes all regions from the widget at position /@pos@/ in the
hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterClearRegions ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> m ()
widgetPathIterClearRegions path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    gtk_widget_path_iter_clear_regions path' pos
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterClearRegionsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterClearRegionsMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterClearRegions

#endif

-- method WidgetPath::iter_get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the widget name for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_name" gtk_widget_path_iter_get_name ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO CString

{- |
Returns the name corresponding to the widget found at
the position /@pos@/ in the widget hierarchy defined by
/@path@/
-}
widgetPathIterGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the widget name for, -1 for the path head -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ The widget name, or 'Nothing' if none was set. -}
widgetPathIterGetName path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_name path' pos
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr path
    return maybeResult

#if ENABLE_OVERLOADING
data WidgetPathIterGetNameMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo WidgetPathIterGetNameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetName

#endif

-- method WidgetPath::iter_get_object_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the object name for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_object_name" gtk_widget_path_iter_get_object_name ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO CString

{- |
Returns the object name that is at position /@pos@/ in the widget
hierarchy defined in /@path@/.

/Since: 3.20/
-}
widgetPathIterGetObjectName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the object name for, -1 for the path head -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the name or 'Nothing' -}
widgetPathIterGetObjectName path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_object_name path' pos
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr path
    return maybeResult

#if ENABLE_OVERLOADING
data WidgetPathIterGetObjectNameMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo WidgetPathIterGetObjectNameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetObjectName

#endif

-- method WidgetPath::iter_get_object_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the object type for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_object_type" gtk_widget_path_iter_get_object_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO CGType

{- |
Returns the object 'GType' that is at position /@pos@/ in the widget
hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterGetObjectType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the object type for, -1 for the path head -}
    -> m GType
    {- ^ __Returns:__ a widget type -}
widgetPathIterGetObjectType path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_object_type path' pos
    let result' = GType result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterGetObjectTypeMethodInfo
instance (signature ~ (Int32 -> m GType), MonadIO m) => O.MethodInfo WidgetPathIterGetObjectTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetObjectType

#endif

-- method WidgetPath::iter_get_sibling_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the sibling index for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_sibling_index" gtk_widget_path_iter_get_sibling_index ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO Word32

{- |
Returns the index into the list of siblings for the element at /@pos@/ as
returned by 'GI.Gtk.Structs.WidgetPath.widgetPathIterGetSiblings'. If that function would
return 'Nothing' because the element at /@pos@/ has no siblings, this function
will return 0.
-}
widgetPathIterGetSiblingIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the sibling index for, -1 for the path head -}
    -> m Word32
    {- ^ __Returns:__ 0 or the index into the list of siblings for the element at /@pos@/. -}
widgetPathIterGetSiblingIndex path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_sibling_index path' pos
    touchManagedPtr path
    return result

#if ENABLE_OVERLOADING
data WidgetPathIterGetSiblingIndexMethodInfo
instance (signature ~ (Int32 -> m Word32), MonadIO m) => O.MethodInfo WidgetPathIterGetSiblingIndexMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetSiblingIndex

#endif

-- method WidgetPath::iter_get_siblings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the siblings for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "WidgetPath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_siblings" gtk_widget_path_iter_get_siblings ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO (Ptr WidgetPath)

{- |
Returns the list of siblings for the element at /@pos@/. If the element
was not added with siblings, 'Nothing' is returned.
-}
widgetPathIterGetSiblings ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the siblings for, -1 for the path head -}
    -> m WidgetPath
    {- ^ __Returns:__ 'Nothing' or the list of siblings for the element at /@pos@/. -}
widgetPathIterGetSiblings path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_siblings path' pos
    checkUnexpectedReturnNULL "widgetPathIterGetSiblings" result
    result' <- (newBoxed WidgetPath) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterGetSiblingsMethodInfo
instance (signature ~ (Int32 -> m WidgetPath), MonadIO m) => O.MethodInfo WidgetPathIterGetSiblingsMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetSiblings

#endif

-- method WidgetPath::iter_get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to get the state for, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StateFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_get_state" gtk_widget_path_iter_get_state ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO CUInt

{- |
Returns the state flags corresponding to the widget found at
the position /@pos@/ in the widget hierarchy defined by
/@path@/

/Since: 3.14/
-}
widgetPathIterGetState ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to get the state for, -1 for the path head -}
    -> m [Gtk.Flags.StateFlags]
    {- ^ __Returns:__ The state flags -}
widgetPathIterGetState path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_get_state path' pos
    let result' = wordToGFlags result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterGetStateMethodInfo
instance (signature ~ (Int32 -> m [Gtk.Flags.StateFlags]), MonadIO m) => O.MethodInfo WidgetPathIterGetStateMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterGetState

#endif

-- method WidgetPath::iter_has_class
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_class" gtk_widget_path_iter_has_class ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

{- |
Returns 'True' if the widget at position /@pos@/ has the class /@name@/
defined, 'False' otherwise.

/Since: 3.0/
-}
widgetPathIterHasClass ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: class name -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the class /@name@/ is defined for the widget at /@pos@/ -}
widgetPathIterHasClass path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    result <- gtk_widget_path_iter_has_class path' pos name'
    let result' = (/= 0) result
    touchManagedPtr path
    freeMem name'
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterHasClassMethodInfo
instance (signature ~ (Int32 -> T.Text -> m Bool), MonadIO m) => O.MethodInfo WidgetPathIterHasClassMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasClass

#endif

-- method WidgetPath::iter_has_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_name" gtk_widget_path_iter_has_name ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

{- |
Returns 'True' if the widget at position /@pos@/ has the name /@name@/,
'False' otherwise.

/Since: 3.0/
-}
widgetPathIterHasName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: a widget name -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget at /@pos@/ has this name -}
widgetPathIterHasName path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    result <- gtk_widget_path_iter_has_name path' pos name'
    let result' = (/= 0) result
    touchManagedPtr path
    freeMem name'
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterHasNameMethodInfo
instance (signature ~ (Int32 -> T.Text -> m Bool), MonadIO m) => O.MethodInfo WidgetPathIterHasNameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasName

#endif

-- method WidgetPath::iter_has_qclass
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "qname", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class name as a #GQuark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_qclass" gtk_widget_path_iter_has_qclass ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    Word32 ->                               -- qname : TBasicType TUInt32
    IO CInt

{- |
See 'GI.Gtk.Structs.WidgetPath.widgetPathIterHasClass'. This is a version that operates
with GQuarks.

/Since: 3.0/
-}
widgetPathIterHasQclass ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> Word32
    {- ^ /@qname@/: class name as a @/GQuark/@ -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget at /@pos@/ has the class defined. -}
widgetPathIterHasQclass path pos qname = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_has_qclass path' pos qname
    let result' = (/= 0) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterHasQclassMethodInfo
instance (signature ~ (Int32 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo WidgetPathIterHasQclassMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasQclass

#endif

-- method WidgetPath::iter_has_qname
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "qname", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget name as a #GQuark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_qname" gtk_widget_path_iter_has_qname ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    Word32 ->                               -- qname : TBasicType TUInt32
    IO CInt

{- |
See 'GI.Gtk.Structs.WidgetPath.widgetPathIterHasName'. This is a version
that operates on @/GQuarks/@.

/Since: 3.0/
-}
widgetPathIterHasQname ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> Word32
    {- ^ /@qname@/: widget name as a @/GQuark/@ -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget at /@pos@/ has this name -}
widgetPathIterHasQname path pos qname = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_has_qname path' pos qname
    let result' = (/= 0) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathIterHasQnameMethodInfo
instance (signature ~ (Int32 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo WidgetPathIterHasQnameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasQname

#endif

-- method WidgetPath::iter_has_qregion
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "qname", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "region name as a #GQuark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "RegionFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the region flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_qregion" gtk_widget_path_iter_has_qregion ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    Word32 ->                               -- qname : TBasicType TUInt32
    Ptr CUInt ->                            -- flags : TInterface (Name {namespace = "Gtk", name = "RegionFlags"})
    IO CInt

{-# DEPRECATED widgetPathIterHasQregion ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
See 'GI.Gtk.Structs.WidgetPath.widgetPathIterHasRegion'. This is a version that operates
with GQuarks.

/Since: 3.0/
-}
widgetPathIterHasQregion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> Word32
    {- ^ /@qname@/: region name as a @/GQuark/@ -}
    -> m ((Bool, [Gtk.Flags.RegionFlags]))
    {- ^ __Returns:__ 'True' if the widget at /@pos@/ has the region defined. -}
widgetPathIterHasQregion path pos qname = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    flags <- allocMem :: IO (Ptr CUInt)
    result <- gtk_widget_path_iter_has_qregion path' pos qname flags
    let result' = (/= 0) result
    flags' <- peek flags
    let flags'' = wordToGFlags flags'
    touchManagedPtr path
    freeMem flags
    return (result', flags'')

#if ENABLE_OVERLOADING
data WidgetPathIterHasQregionMethodInfo
instance (signature ~ (Int32 -> Word32 -> m ((Bool, [Gtk.Flags.RegionFlags]))), MonadIO m) => O.MethodInfo WidgetPathIterHasQregionMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasQregion

#endif

-- method WidgetPath::iter_has_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "region name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "RegionFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the region flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_has_region" gtk_widget_path_iter_has_region ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    Ptr CUInt ->                            -- flags : TInterface (Name {namespace = "Gtk", name = "RegionFlags"})
    IO CInt

{-# DEPRECATED widgetPathIterHasRegion ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
Returns 'True' if the widget at position /@pos@/ has the class /@name@/
defined, 'False' otherwise.

/Since: 3.0/
-}
widgetPathIterHasRegion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: region name -}
    -> m ((Bool, [Gtk.Flags.RegionFlags]))
    {- ^ __Returns:__ 'True' if the class /@name@/ is defined for the widget at /@pos@/ -}
widgetPathIterHasRegion path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    flags <- allocMem :: IO (Ptr CUInt)
    result <- gtk_widget_path_iter_has_region path' pos name' flags
    let result' = (/= 0) result
    flags' <- peek flags
    let flags'' = wordToGFlags flags'
    touchManagedPtr path
    freeMem name'
    freeMem flags
    return (result', flags'')

#if ENABLE_OVERLOADING
data WidgetPathIterHasRegionMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ((Bool, [Gtk.Flags.RegionFlags]))), MonadIO m) => O.MethodInfo WidgetPathIterHasRegionMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterHasRegion

#endif

-- method WidgetPath::iter_list_classes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_list_classes" gtk_widget_path_iter_list_classes ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO (Ptr (GSList CString))

{- |
Returns a list with all the class names defined for the widget
at position /@pos@/ in the hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterListClasses ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> m [T.Text]
    {- ^ __Returns:__ The list of
         classes, This is a list of strings, the 'GI.GLib.Structs.SList.SList' contents
         are owned by GTK+, but you should use @/g_slist_free()/@ to
         free the list itself. -}
widgetPathIterListClasses path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_list_classes path' pos
    result' <- unpackGSList result
    result'' <- mapM cstringToText result'
    g_slist_free result
    touchManagedPtr path
    return result''

#if ENABLE_OVERLOADING
data WidgetPathIterListClassesMethodInfo
instance (signature ~ (Int32 -> m [T.Text]), MonadIO m) => O.MethodInfo WidgetPathIterListClassesMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterListClasses

#endif

-- method WidgetPath::iter_list_regions
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to query, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_list_regions" gtk_widget_path_iter_list_regions ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    IO (Ptr (GSList CString))

{-# DEPRECATED widgetPathIterListRegions ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
Returns a list with all the region names defined for the widget
at position /@pos@/ in the hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterListRegions ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to query, -1 for the path head -}
    -> m [T.Text]
    {- ^ __Returns:__ The list of
         regions, This is a list of strings, the 'GI.GLib.Structs.SList.SList' contents
         are owned by GTK+, but you should use @/g_slist_free()/@ to
         free the list itself. -}
widgetPathIterListRegions path pos = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_iter_list_regions path' pos
    result' <- unpackGSList result
    result'' <- mapM cstringToText result'
    g_slist_free result
    touchManagedPtr path
    return result''

#if ENABLE_OVERLOADING
data WidgetPathIterListRegionsMethodInfo
instance (signature ~ (Int32 -> m [T.Text]), MonadIO m) => O.MethodInfo WidgetPathIterListRegionsMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterListRegions

#endif

-- method WidgetPath::iter_remove_class
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_remove_class" gtk_widget_path_iter_remove_class ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Removes the class /@name@/ from the widget at position /@pos@/ in
the hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterRemoveClass ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: class name -}
    -> m ()
widgetPathIterRemoveClass path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    gtk_widget_path_iter_remove_class path' pos name'
    touchManagedPtr path
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterRemoveClassMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterRemoveClassMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterRemoveClass

#endif

-- method WidgetPath::iter_remove_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "region name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_remove_region" gtk_widget_path_iter_remove_region ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{-# DEPRECATED widgetPathIterRemoveRegion ["(Since version 3.14)","The use of regions is deprecated."] #-}
{- |
Removes the region /@name@/ from the widget at position /@pos@/ in
the hierarchy defined in /@path@/.

/Since: 3.0/
-}
widgetPathIterRemoveRegion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: region name -}
    -> m ()
widgetPathIterRemoveRegion path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    gtk_widget_path_iter_remove_region path' pos name'
    touchManagedPtr path
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterRemoveRegionMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterRemoveRegionMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterRemoveRegion

#endif

-- method WidgetPath::iter_set_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_set_name" gtk_widget_path_iter_set_name ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Sets the widget name for the widget found at position /@pos@/
in the widget hierarchy defined by /@path@/.

/Since: 3.0/
-}
widgetPathIterSetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> T.Text
    {- ^ /@name@/: widget name -}
    -> m ()
widgetPathIterSetName path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    name' <- textToCString name
    gtk_widget_path_iter_set_name path' pos name'
    touchManagedPtr path
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterSetNameMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterSetNameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterSetName

#endif

-- method WidgetPath::iter_set_object_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "object name to set or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_set_object_name" gtk_widget_path_iter_set_object_name ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Sets the object name for a given position in the widget hierarchy
defined by /@path@/.

When set, the object name overrides the object type when matching
CSS.

/Since: 3.20/
-}
widgetPathIterSetObjectName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> Maybe (T.Text)
    {- ^ /@name@/: object name to set or 'Nothing' to unset -}
    -> m ()
widgetPathIterSetObjectName path pos name = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    gtk_widget_path_iter_set_object_name path' pos maybeName
    touchManagedPtr path
    freeMem maybeName
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterSetObjectNameMethodInfo
instance (signature ~ (Int32 -> Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterSetObjectNameMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterSetObjectName

#endif

-- method WidgetPath::iter_set_object_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "object type to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_set_object_type" gtk_widget_path_iter_set_object_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CGType ->                               -- type : TBasicType TGType
    IO ()

{- |
Sets the object type for a given position in the widget hierarchy
defined by /@path@/.

/Since: 3.0/
-}
widgetPathIterSetObjectType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> GType
    {- ^ /@type@/: object type to set -}
    -> m ()
widgetPathIterSetObjectType path pos type_ = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let type_' = gtypeToCGType type_
    gtk_widget_path_iter_set_object_type path' pos type_'
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterSetObjectTypeMethodInfo
instance (signature ~ (Int32 -> GType -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterSetObjectTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterSetObjectType

#endif

-- method WidgetPath::iter_set_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to modify, -1 for the path head", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "state flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_iter_set_state" gtk_widget_path_iter_set_state ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    Int32 ->                                -- pos : TBasicType TInt
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    IO ()

{- |
Sets the widget name for the widget found at position /@pos@/
in the widget hierarchy defined by /@path@/.

If you want to update just a single state flag, you need to do
this manually, as this function updates all state flags.

== Setting a flag


=== /C code/
>
>gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) | flag);


== Unsetting a flag


=== /C code/
>
>gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) & ~flag);


/Since: 3.14/
-}
widgetPathIterSetState ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> Int32
    {- ^ /@pos@/: position to modify, -1 for the path head -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: state flags -}
    -> m ()
widgetPathIterSetState path pos state = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let state' = gflagsToWord state
    gtk_widget_path_iter_set_state path' pos state'
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathIterSetStateMethodInfo
instance (signature ~ (Int32 -> [Gtk.Flags.StateFlags] -> m ()), MonadIO m) => O.MethodInfo WidgetPathIterSetStateMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathIterSetState

#endif

-- method WidgetPath::length
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_length" gtk_widget_path_length ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO Int32

{- |
Returns the number of 'GI.Gtk.Objects.Widget.Widget' @/GTypes/@ between the represented
widget and its topmost container.

/Since: 3.0/
-}
widgetPathLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> m Int32
    {- ^ __Returns:__ the number of elements in the path -}
widgetPathLength path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_length path'
    touchManagedPtr path
    return result

#if ENABLE_OVERLOADING
data WidgetPathLengthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo WidgetPathLengthMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathLength

#endif

-- method WidgetPath::prepend_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget type to prepend", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_prepend_type" gtk_widget_path_prepend_type ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    CGType ->                               -- type : TBasicType TGType
    IO ()

{- |
Prepends a widget type to the widget hierachy represented by /@path@/.

/Since: 3.0/
-}
widgetPathPrependType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> GType
    {- ^ /@type@/: widget type to prepend -}
    -> m ()
widgetPathPrependType path type_ = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    let type_' = gtypeToCGType type_
    gtk_widget_path_prepend_type path' type_'
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathPrependTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.MethodInfo WidgetPathPrependTypeMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathPrependType

#endif

-- method WidgetPath::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "WidgetPath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_ref" gtk_widget_path_ref ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO (Ptr WidgetPath)

{- |
Increments the reference count on /@path@/.

/Since: 3.2/
-}
widgetPathRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> m WidgetPath
    {- ^ __Returns:__ /@path@/ itself. -}
widgetPathRef path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_ref path'
    checkUnexpectedReturnNULL "widgetPathRef" result
    result' <- (wrapBoxed WidgetPath) result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathRefMethodInfo
instance (signature ~ (m WidgetPath), MonadIO m) => O.MethodInfo WidgetPathRefMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathRef

#endif

-- method WidgetPath::to_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_to_string" gtk_widget_path_to_string ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO CString

{- |
Dumps the widget path into a string representation. It tries to match
the CSS style as closely as possible (Note that there might be paths
that cannot be represented in CSS).

The main use of this code is for debugging purposes, so that you can
@/g_print()/@ the path or dump it in a gdb session.

/Since: 3.2/
-}
widgetPathToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: the path -}
    -> m T.Text
    {- ^ __Returns:__ A new string describing /@path@/. -}
widgetPathToString path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_widget_path_to_string path'
    checkUnexpectedReturnNULL "widgetPathToString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr path
    return result'

#if ENABLE_OVERLOADING
data WidgetPathToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo WidgetPathToStringMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathToString

#endif

-- method WidgetPath::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "WidgetPath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidgetPath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path_unref" gtk_widget_path_unref ::
    Ptr WidgetPath ->                       -- path : TInterface (Name {namespace = "Gtk", name = "WidgetPath"})
    IO ()

{- |
Decrements the reference count on /@path@/, freeing the structure
if the reference count reaches 0.

/Since: 3.2/
-}
widgetPathUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetPath
    {- ^ /@path@/: a 'GI.Gtk.Structs.WidgetPath.WidgetPath' -}
    -> m ()
widgetPathUnref path = liftIO $ do
    path' <- unsafeManagedPtrGetPtr path
    gtk_widget_path_unref path'
    touchManagedPtr path
    return ()

#if ENABLE_OVERLOADING
data WidgetPathUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo WidgetPathUnrefMethodInfo WidgetPath signature where
    overloadedMethod _ = widgetPathUnref

#endif

#if ENABLE_OVERLOADING
type family ResolveWidgetPathMethod (t :: Symbol) (o :: *) :: * where
    ResolveWidgetPathMethod "appendForWidget" o = WidgetPathAppendForWidgetMethodInfo
    ResolveWidgetPathMethod "appendType" o = WidgetPathAppendTypeMethodInfo
    ResolveWidgetPathMethod "appendWithSiblings" o = WidgetPathAppendWithSiblingsMethodInfo
    ResolveWidgetPathMethod "copy" o = WidgetPathCopyMethodInfo
    ResolveWidgetPathMethod "free" o = WidgetPathFreeMethodInfo
    ResolveWidgetPathMethod "hasParent" o = WidgetPathHasParentMethodInfo
    ResolveWidgetPathMethod "isType" o = WidgetPathIsTypeMethodInfo
    ResolveWidgetPathMethod "iterAddClass" o = WidgetPathIterAddClassMethodInfo
    ResolveWidgetPathMethod "iterAddRegion" o = WidgetPathIterAddRegionMethodInfo
    ResolveWidgetPathMethod "iterClearClasses" o = WidgetPathIterClearClassesMethodInfo
    ResolveWidgetPathMethod "iterClearRegions" o = WidgetPathIterClearRegionsMethodInfo
    ResolveWidgetPathMethod "iterGetName" o = WidgetPathIterGetNameMethodInfo
    ResolveWidgetPathMethod "iterGetObjectName" o = WidgetPathIterGetObjectNameMethodInfo
    ResolveWidgetPathMethod "iterGetObjectType" o = WidgetPathIterGetObjectTypeMethodInfo
    ResolveWidgetPathMethod "iterGetSiblingIndex" o = WidgetPathIterGetSiblingIndexMethodInfo
    ResolveWidgetPathMethod "iterGetSiblings" o = WidgetPathIterGetSiblingsMethodInfo
    ResolveWidgetPathMethod "iterGetState" o = WidgetPathIterGetStateMethodInfo
    ResolveWidgetPathMethod "iterHasClass" o = WidgetPathIterHasClassMethodInfo
    ResolveWidgetPathMethod "iterHasName" o = WidgetPathIterHasNameMethodInfo
    ResolveWidgetPathMethod "iterHasQclass" o = WidgetPathIterHasQclassMethodInfo
    ResolveWidgetPathMethod "iterHasQname" o = WidgetPathIterHasQnameMethodInfo
    ResolveWidgetPathMethod "iterHasQregion" o = WidgetPathIterHasQregionMethodInfo
    ResolveWidgetPathMethod "iterHasRegion" o = WidgetPathIterHasRegionMethodInfo
    ResolveWidgetPathMethod "iterListClasses" o = WidgetPathIterListClassesMethodInfo
    ResolveWidgetPathMethod "iterListRegions" o = WidgetPathIterListRegionsMethodInfo
    ResolveWidgetPathMethod "iterRemoveClass" o = WidgetPathIterRemoveClassMethodInfo
    ResolveWidgetPathMethod "iterRemoveRegion" o = WidgetPathIterRemoveRegionMethodInfo
    ResolveWidgetPathMethod "iterSetName" o = WidgetPathIterSetNameMethodInfo
    ResolveWidgetPathMethod "iterSetObjectName" o = WidgetPathIterSetObjectNameMethodInfo
    ResolveWidgetPathMethod "iterSetObjectType" o = WidgetPathIterSetObjectTypeMethodInfo
    ResolveWidgetPathMethod "iterSetState" o = WidgetPathIterSetStateMethodInfo
    ResolveWidgetPathMethod "length" o = WidgetPathLengthMethodInfo
    ResolveWidgetPathMethod "prependType" o = WidgetPathPrependTypeMethodInfo
    ResolveWidgetPathMethod "ref" o = WidgetPathRefMethodInfo
    ResolveWidgetPathMethod "toString" o = WidgetPathToStringMethodInfo
    ResolveWidgetPathMethod "unref" o = WidgetPathUnrefMethodInfo
    ResolveWidgetPathMethod "getObjectType" o = WidgetPathGetObjectTypeMethodInfo
    ResolveWidgetPathMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWidgetPathMethod t WidgetPath, O.MethodInfo info WidgetPath p) => O.IsLabelProxy t (WidgetPath -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif