{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- GtkMultiSorter combines multiple sorters by trying them
-- in turn. If the first sorter compares two items as equal,
-- the second is tried next, and so on.

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

module GI.Gtk.Objects.MultiSorter
    ( 

-- * Exported types
    MultiSorter(..)                         ,
    IsMultiSorter                           ,
    toMultiSorter                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [append]("GI.Gtk.Objects.MultiSorter#g:method:append"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [changed]("GI.Gtk.Objects.Sorter#g:method:changed"), [compare]("GI.Gtk.Objects.Sorter#g:method:compare"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [itemsChanged]("GI.Gio.Interfaces.ListModel#g:method:itemsChanged"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Gtk.Objects.MultiSorter#g:method:remove"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getItem]("GI.Gio.Interfaces.ListModel#g:method:getItem"), [getItemType]("GI.Gio.Interfaces.ListModel#g:method:getItemType"), [getNItems]("GI.Gio.Interfaces.ListModel#g:method:getNItems"), [getOrder]("GI.Gtk.Objects.Sorter#g:method:getOrder"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveMultiSorterMethod                ,
#endif

-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    MultiSorterAppendMethodInfo             ,
#endif
    multiSorterAppend                       ,


-- ** new #method:new#

    multiSorterNew                          ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    MultiSorterRemoveMethodInfo             ,
#endif
    multiSorterRemove                       ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter

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

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

foreign import ccall "gtk_multi_sorter_get_type"
    c_gtk_multi_sorter_get_type :: IO B.Types.GType

instance B.Types.TypedObject MultiSorter where
    glibType :: IO GType
glibType = IO GType
c_gtk_multi_sorter_get_type

instance B.Types.GObject MultiSorter

-- | Type class for types which can be safely cast to `MultiSorter`, for instance with `toMultiSorter`.
class (SP.GObject o, O.IsDescendantOf MultiSorter o) => IsMultiSorter o
instance (SP.GObject o, O.IsDescendantOf MultiSorter o) => IsMultiSorter o

instance O.HasParentTypes MultiSorter
type instance O.ParentTypes MultiSorter = '[Gtk.Sorter.Sorter, GObject.Object.Object, Gio.ListModel.ListModel, Gtk.Buildable.Buildable]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveMultiSorterMethod (t :: Symbol) (o :: *) :: * where
    ResolveMultiSorterMethod "append" o = MultiSorterAppendMethodInfo
    ResolveMultiSorterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveMultiSorterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveMultiSorterMethod "changed" o = Gtk.Sorter.SorterChangedMethodInfo
    ResolveMultiSorterMethod "compare" o = Gtk.Sorter.SorterCompareMethodInfo
    ResolveMultiSorterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveMultiSorterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveMultiSorterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveMultiSorterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveMultiSorterMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
    ResolveMultiSorterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveMultiSorterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveMultiSorterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveMultiSorterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveMultiSorterMethod "remove" o = MultiSorterRemoveMethodInfo
    ResolveMultiSorterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveMultiSorterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveMultiSorterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveMultiSorterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveMultiSorterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveMultiSorterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveMultiSorterMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveMultiSorterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveMultiSorterMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
    ResolveMultiSorterMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
    ResolveMultiSorterMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
    ResolveMultiSorterMethod "getOrder" o = Gtk.Sorter.SorterGetOrderMethodInfo
    ResolveMultiSorterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveMultiSorterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveMultiSorterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveMultiSorterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveMultiSorterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveMultiSorterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMultiSorterMethod t MultiSorter, O.OverloadedMethod info MultiSorter p) => OL.IsLabel t (MultiSorter -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMultiSorterMethod t MultiSorter, O.OverloadedMethod info MultiSorter p, R.HasField t MultiSorter p) => R.HasField t MultiSorter p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MultiSorter = MultiSorterSignalList
type MultiSorterSignalList = ('[ '("changed", Gtk.Sorter.SorterChangedSignalInfo), '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "gtk_multi_sorter_new" gtk_multi_sorter_new :: 
    IO (Ptr MultiSorter)

-- | Creates a new multi sorter.
-- 
-- This sorter compares items by trying each of the sorters
-- in turn, until one returns non-zero. In particular, if
-- no sorter has been added to it, it will always compare
-- items as equal.
multiSorterNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m MultiSorter
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MultiSorter.MultiSorter'
multiSorterNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MultiSorter
multiSorterNew  = IO MultiSorter -> m MultiSorter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MultiSorter -> m MultiSorter)
-> IO MultiSorter -> m MultiSorter
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultiSorter
result <- IO (Ptr MultiSorter)
gtk_multi_sorter_new
    Text -> Ptr MultiSorter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"multiSorterNew" Ptr MultiSorter
result
    MultiSorter
result' <- ((ManagedPtr MultiSorter -> MultiSorter)
-> Ptr MultiSorter -> IO MultiSorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MultiSorter -> MultiSorter
MultiSorter) Ptr MultiSorter
result
    MultiSorter -> IO MultiSorter
forall (m :: * -> *) a. Monad m => a -> m a
return MultiSorter
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MultiSorter::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MultiSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMultiSorter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sorter"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Sorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a sorter to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_multi_sorter_append" gtk_multi_sorter_append :: 
    Ptr MultiSorter ->                      -- self : TInterface (Name {namespace = "Gtk", name = "MultiSorter"})
    Ptr Gtk.Sorter.Sorter ->                -- sorter : TInterface (Name {namespace = "Gtk", name = "Sorter"})
    IO ()

-- | Add /@sorter@/ to /@self@/ to use for sorting at the end. /@self@/
-- will consult all existing sorters before it will sort with
-- the given /@sorter@/.
multiSorterAppend ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultiSorter a, Gtk.Sorter.IsSorter b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MultiSorter.MultiSorter'
    -> b
    -- ^ /@sorter@/: a sorter to add
    -> m ()
multiSorterAppend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMultiSorter a, IsSorter b) =>
a -> b -> m ()
multiSorterAppend a
self b
sorter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultiSorter
self' <- a -> IO (Ptr MultiSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Sorter
sorter' <- b -> IO (Ptr Sorter)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
sorter
    Ptr MultiSorter -> Ptr Sorter -> IO ()
gtk_multi_sorter_append Ptr MultiSorter
self' Ptr Sorter
sorter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sorter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MultiSorterAppendMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsMultiSorter a, Gtk.Sorter.IsSorter b) => O.OverloadedMethod MultiSorterAppendMethodInfo a signature where
    overloadedMethod = multiSorterAppend

instance O.OverloadedMethodInfo MultiSorterAppendMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.MultiSorter.multiSorterAppend",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-MultiSorter.html#v:multiSorterAppend"
        }


#endif

-- method MultiSorter::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MultiSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMultiSorter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "position of sorter to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Removes the sorter at the given /@position@/ from the list of sorter
-- used by /@self@/.
-- 
-- If /@position@/ is larger than the number of sorters, nothing happens.
multiSorterRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultiSorter a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MultiSorter.MultiSorter'
    -> Word32
    -- ^ /@position@/: position of sorter to remove
    -> m ()
multiSorterRemove :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMultiSorter a) =>
a -> Word32 -> m ()
multiSorterRemove a
self Word32
position = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultiSorter
self' <- a -> IO (Ptr MultiSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MultiSorter -> Word32 -> IO ()
gtk_multi_sorter_remove Ptr MultiSorter
self' Word32
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MultiSorterRemoveMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsMultiSorter a) => O.OverloadedMethod MultiSorterRemoveMethodInfo a signature where
    overloadedMethod = multiSorterRemove

instance O.OverloadedMethodInfo MultiSorterRemoveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.MultiSorter.multiSorterRemove",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-MultiSorter.html#v:multiSorterRemove"
        }


#endif