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