{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Interfaces.TreeSortable
(
TreeSortable(..) ,
IsTreeSortable ,
toTreeSortable ,
#if defined(ENABLE_OVERLOADING)
ResolveTreeSortableMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeSortableGetSortColumnIdMethodInfo ,
#endif
treeSortableGetSortColumnId ,
#if defined(ENABLE_OVERLOADING)
TreeSortableHasDefaultSortFuncMethodInfo,
#endif
treeSortableHasDefaultSortFunc ,
#if defined(ENABLE_OVERLOADING)
TreeSortableSetDefaultSortFuncMethodInfo,
#endif
treeSortableSetDefaultSortFunc ,
#if defined(ENABLE_OVERLOADING)
TreeSortableSetSortColumnIdMethodInfo ,
#endif
treeSortableSetSortColumnId ,
#if defined(ENABLE_OVERLOADING)
TreeSortableSetSortFuncMethodInfo ,
#endif
treeSortableSetSortFunc ,
#if defined(ENABLE_OVERLOADING)
TreeSortableSortColumnChangedMethodInfo ,
#endif
treeSortableSortColumnChanged ,
TreeSortableSortColumnChangedCallback ,
#if defined(ENABLE_OVERLOADING)
TreeSortableSortColumnChangedSignalInfo ,
#endif
afterTreeSortableSortColumnChanged ,
onTreeSortableSortColumnChanged ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
newtype TreeSortable = TreeSortable (SP.ManagedPtr TreeSortable)
deriving (TreeSortable -> TreeSortable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeSortable -> TreeSortable -> Bool
$c/= :: TreeSortable -> TreeSortable -> Bool
== :: TreeSortable -> TreeSortable -> Bool
$c== :: TreeSortable -> TreeSortable -> Bool
Eq)
instance SP.ManagedPtrNewtype TreeSortable where
toManagedPtr :: TreeSortable -> ManagedPtr TreeSortable
toManagedPtr (TreeSortable ManagedPtr TreeSortable
p) = ManagedPtr TreeSortable
p
foreign import ccall "gtk_tree_sortable_get_type"
c_gtk_tree_sortable_get_type :: IO B.Types.GType
instance B.Types.TypedObject TreeSortable where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_sortable_get_type
instance B.Types.GObject TreeSortable
class (SP.GObject o, O.IsDescendantOf TreeSortable o) => IsTreeSortable o
instance (SP.GObject o, O.IsDescendantOf TreeSortable o) => IsTreeSortable o
instance O.HasParentTypes TreeSortable
type instance O.ParentTypes TreeSortable = '[Gtk.TreeModel.TreeModel, GObject.Object.Object]
toTreeSortable :: (MIO.MonadIO m, IsTreeSortable o) => o -> m TreeSortable
toTreeSortable :: forall (m :: * -> *) o.
(MonadIO m, IsTreeSortable o) =>
o -> m TreeSortable
toTreeSortable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TreeSortable -> TreeSortable
TreeSortable
instance B.GValue.IsGValue (Maybe TreeSortable) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_tree_sortable_get_type
gvalueSet_ :: Ptr GValue -> Maybe TreeSortable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeSortable
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeSortable)
gvalueSet_ Ptr GValue
gv (P.Just TreeSortable
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeSortable
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TreeSortable)
gvalueGet_ Ptr GValue
gv = do
Ptr TreeSortable
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TreeSortable)
if Ptr TreeSortable
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeSortable -> TreeSortable
TreeSortable Ptr TreeSortable
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeSortable
type instance O.AttributeList TreeSortable = TreeSortableAttributeList
type TreeSortableAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTreeSortableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTreeSortableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTreeSortableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTreeSortableMethod "filterNew" o = Gtk.TreeModel.TreeModelFilterNewMethodInfo
ResolveTreeSortableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTreeSortableMethod "foreach" o = Gtk.TreeModel.TreeModelForeachMethodInfo
ResolveTreeSortableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTreeSortableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTreeSortableMethod "hasDefaultSortFunc" o = TreeSortableHasDefaultSortFuncMethodInfo
ResolveTreeSortableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTreeSortableMethod "iterChildren" o = Gtk.TreeModel.TreeModelIterChildrenMethodInfo
ResolveTreeSortableMethod "iterHasChild" o = Gtk.TreeModel.TreeModelIterHasChildMethodInfo
ResolveTreeSortableMethod "iterNChildren" o = Gtk.TreeModel.TreeModelIterNChildrenMethodInfo
ResolveTreeSortableMethod "iterNext" o = Gtk.TreeModel.TreeModelIterNextMethodInfo
ResolveTreeSortableMethod "iterNthChild" o = Gtk.TreeModel.TreeModelIterNthChildMethodInfo
ResolveTreeSortableMethod "iterParent" o = Gtk.TreeModel.TreeModelIterParentMethodInfo
ResolveTreeSortableMethod "iterPrevious" o = Gtk.TreeModel.TreeModelIterPreviousMethodInfo
ResolveTreeSortableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTreeSortableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTreeSortableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTreeSortableMethod "refNode" o = Gtk.TreeModel.TreeModelRefNodeMethodInfo
ResolveTreeSortableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTreeSortableMethod "rowChanged" o = Gtk.TreeModel.TreeModelRowChangedMethodInfo
ResolveTreeSortableMethod "rowDeleted" o = Gtk.TreeModel.TreeModelRowDeletedMethodInfo
ResolveTreeSortableMethod "rowHasChildToggled" o = Gtk.TreeModel.TreeModelRowHasChildToggledMethodInfo
ResolveTreeSortableMethod "rowInserted" o = Gtk.TreeModel.TreeModelRowInsertedMethodInfo
ResolveTreeSortableMethod "rowsReordered" o = Gtk.TreeModel.TreeModelRowsReorderedMethodInfo
ResolveTreeSortableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTreeSortableMethod "sortColumnChanged" o = TreeSortableSortColumnChangedMethodInfo
ResolveTreeSortableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTreeSortableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTreeSortableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTreeSortableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTreeSortableMethod "unrefNode" o = Gtk.TreeModel.TreeModelUnrefNodeMethodInfo
ResolveTreeSortableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTreeSortableMethod "getColumnType" o = Gtk.TreeModel.TreeModelGetColumnTypeMethodInfo
ResolveTreeSortableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTreeSortableMethod "getFlags" o = Gtk.TreeModel.TreeModelGetFlagsMethodInfo
ResolveTreeSortableMethod "getIter" o = Gtk.TreeModel.TreeModelGetIterMethodInfo
ResolveTreeSortableMethod "getIterFirst" o = Gtk.TreeModel.TreeModelGetIterFirstMethodInfo
ResolveTreeSortableMethod "getIterFromString" o = Gtk.TreeModel.TreeModelGetIterFromStringMethodInfo
ResolveTreeSortableMethod "getNColumns" o = Gtk.TreeModel.TreeModelGetNColumnsMethodInfo
ResolveTreeSortableMethod "getPath" o = Gtk.TreeModel.TreeModelGetPathMethodInfo
ResolveTreeSortableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTreeSortableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTreeSortableMethod "getSortColumnId" o = TreeSortableGetSortColumnIdMethodInfo
ResolveTreeSortableMethod "getStringFromIter" o = Gtk.TreeModel.TreeModelGetStringFromIterMethodInfo
ResolveTreeSortableMethod "getValue" o = Gtk.TreeModel.TreeModelGetValueMethodInfo
ResolveTreeSortableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTreeSortableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTreeSortableMethod "setDefaultSortFunc" o = TreeSortableSetDefaultSortFuncMethodInfo
ResolveTreeSortableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTreeSortableMethod "setSortColumnId" o = TreeSortableSetSortColumnIdMethodInfo
ResolveTreeSortableMethod "setSortFunc" o = TreeSortableSetSortFuncMethodInfo
ResolveTreeSortableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTreeSortableMethod t TreeSortable, O.OverloadedMethod info TreeSortable p) => OL.IsLabel t (TreeSortable -> 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 ~ ResolveTreeSortableMethod t TreeSortable, O.OverloadedMethod info TreeSortable p, R.HasField t TreeSortable p) => R.HasField t TreeSortable p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTreeSortableMethod t TreeSortable, O.OverloadedMethodInfo info TreeSortable) => OL.IsLabel t (O.MethodProxy info TreeSortable) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "gtk_tree_sortable_get_sort_column_id" gtk_tree_sortable_get_sort_column_id ::
Ptr TreeSortable ->
Ptr Int32 ->
Ptr CUInt ->
IO CInt
treeSortableGetSortColumnId ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> m ((Bool, Int32, Gtk.Enums.SortType))
treeSortableGetSortColumnId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> m (Bool, Int32, SortType)
treeSortableGetSortColumnId a
sortable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
Ptr Int32
sortColumnId <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr CUInt
order <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CInt
result <- Ptr TreeSortable -> Ptr Int32 -> Ptr CUInt -> IO CInt
gtk_tree_sortable_get_sort_column_id Ptr TreeSortable
sortable' Ptr Int32
sortColumnId Ptr CUInt
order
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
sortColumnId' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
sortColumnId
CUInt
order' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
order
let order'' :: SortType
order'' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
order'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall a. Ptr a -> IO ()
freeMem Ptr Int32
sortColumnId
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
order
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
sortColumnId', SortType
order'')
#if defined(ENABLE_OVERLOADING)
data TreeSortableGetSortColumnIdMethodInfo
instance (signature ~ (m ((Bool, Int32, Gtk.Enums.SortType))), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableGetSortColumnIdMethodInfo a signature where
overloadedMethod = treeSortableGetSortColumnId
instance O.OverloadedMethodInfo TreeSortableGetSortColumnIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableGetSortColumnId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableGetSortColumnId"
})
#endif
foreign import ccall "gtk_tree_sortable_has_default_sort_func" gtk_tree_sortable_has_default_sort_func ::
Ptr TreeSortable ->
IO CInt
treeSortableHasDefaultSortFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> m Bool
treeSortableHasDefaultSortFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> m Bool
treeSortableHasDefaultSortFunc a
sortable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
CInt
result <- Ptr TreeSortable -> IO CInt
gtk_tree_sortable_has_default_sort_func Ptr TreeSortable
sortable'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TreeSortableHasDefaultSortFuncMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableHasDefaultSortFuncMethodInfo a signature where
overloadedMethod = treeSortableHasDefaultSortFunc
instance O.OverloadedMethodInfo TreeSortableHasDefaultSortFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableHasDefaultSortFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableHasDefaultSortFunc"
})
#endif
foreign import ccall "gtk_tree_sortable_set_default_sort_func" gtk_tree_sortable_set_default_sort_func ::
Ptr TreeSortable ->
FunPtr Gtk.Callbacks.C_TreeIterCompareFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
treeSortableSetDefaultSortFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> Gtk.Callbacks.TreeIterCompareFunc
-> m ()
treeSortableSetDefaultSortFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> TreeIterCompareFunc -> m ()
treeSortableSetDefaultSortFunc a
sortable TreeIterCompareFunc
sortFunc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
FunPtr C_TreeIterCompareFunc
sortFunc' <- C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)
Gtk.Callbacks.mk_TreeIterCompareFunc (Maybe (Ptr (FunPtr C_TreeIterCompareFunc))
-> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc
Gtk.Callbacks.wrap_TreeIterCompareFunc forall a. Maybe a
Nothing (TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures
Gtk.Callbacks.drop_closures_TreeIterCompareFunc TreeIterCompareFunc
sortFunc))
let userData :: Ptr ()
userData = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeIterCompareFunc
sortFunc'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr TreeSortable
-> FunPtr C_TreeIterCompareFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_tree_sortable_set_default_sort_func Ptr TreeSortable
sortable' FunPtr C_TreeIterCompareFunc
sortFunc' Ptr ()
userData forall a. FunPtr (Ptr a -> IO ())
destroy
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeSortableSetDefaultSortFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.TreeIterCompareFunc -> m ()), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableSetDefaultSortFuncMethodInfo a signature where
overloadedMethod = treeSortableSetDefaultSortFunc
instance O.OverloadedMethodInfo TreeSortableSetDefaultSortFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableSetDefaultSortFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableSetDefaultSortFunc"
})
#endif
foreign import ccall "gtk_tree_sortable_set_sort_column_id" gtk_tree_sortable_set_sort_column_id ::
Ptr TreeSortable ->
Int32 ->
CUInt ->
IO ()
treeSortableSetSortColumnId ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> Int32
-> Gtk.Enums.SortType
-> m ()
treeSortableSetSortColumnId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> Int32 -> SortType -> m ()
treeSortableSetSortColumnId a
sortable Int32
sortColumnId SortType
order = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
let order' :: CUInt
order' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) SortType
order
Ptr TreeSortable -> Int32 -> CUInt -> IO ()
gtk_tree_sortable_set_sort_column_id Ptr TreeSortable
sortable' Int32
sortColumnId CUInt
order'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeSortableSetSortColumnIdMethodInfo
instance (signature ~ (Int32 -> Gtk.Enums.SortType -> m ()), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableSetSortColumnIdMethodInfo a signature where
overloadedMethod = treeSortableSetSortColumnId
instance O.OverloadedMethodInfo TreeSortableSetSortColumnIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortColumnId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableSetSortColumnId"
})
#endif
foreign import ccall "gtk_tree_sortable_set_sort_func" gtk_tree_sortable_set_sort_func ::
Ptr TreeSortable ->
Int32 ->
FunPtr Gtk.Callbacks.C_TreeIterCompareFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
treeSortableSetSortFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> Int32
-> Gtk.Callbacks.TreeIterCompareFunc
-> m ()
treeSortableSetSortFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> Int32 -> TreeIterCompareFunc -> m ()
treeSortableSetSortFunc a
sortable Int32
sortColumnId TreeIterCompareFunc
sortFunc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
FunPtr C_TreeIterCompareFunc
sortFunc' <- C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)
Gtk.Callbacks.mk_TreeIterCompareFunc (Maybe (Ptr (FunPtr C_TreeIterCompareFunc))
-> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc
Gtk.Callbacks.wrap_TreeIterCompareFunc forall a. Maybe a
Nothing (TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures
Gtk.Callbacks.drop_closures_TreeIterCompareFunc TreeIterCompareFunc
sortFunc))
let userData :: Ptr ()
userData = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeIterCompareFunc
sortFunc'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr TreeSortable
-> Int32
-> FunPtr C_TreeIterCompareFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_tree_sortable_set_sort_func Ptr TreeSortable
sortable' Int32
sortColumnId FunPtr C_TreeIterCompareFunc
sortFunc' Ptr ()
userData forall a. FunPtr (Ptr a -> IO ())
destroy
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeSortableSetSortFuncMethodInfo
instance (signature ~ (Int32 -> Gtk.Callbacks.TreeIterCompareFunc -> m ()), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableSetSortFuncMethodInfo a signature where
overloadedMethod = treeSortableSetSortFunc
instance O.OverloadedMethodInfo TreeSortableSetSortFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableSetSortFunc"
})
#endif
foreign import ccall "gtk_tree_sortable_sort_column_changed" gtk_tree_sortable_sort_column_changed ::
Ptr TreeSortable ->
IO ()
treeSortableSortColumnChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeSortable a) =>
a
-> m ()
treeSortableSortColumnChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeSortable a) =>
a -> m ()
treeSortableSortColumnChanged a
sortable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeSortable
sortable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sortable
Ptr TreeSortable -> IO ()
gtk_tree_sortable_sort_column_changed Ptr TreeSortable
sortable'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sortable
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeSortableSortColumnChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeSortable a) => O.OverloadedMethod TreeSortableSortColumnChangedMethodInfo a signature where
overloadedMethod = treeSortableSortColumnChanged
instance O.OverloadedMethodInfo TreeSortableSortColumnChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable.treeSortableSortColumnChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#v:treeSortableSortColumnChanged"
})
#endif
type TreeSortableSortColumnChangedCallback =
IO ()
type C_TreeSortableSortColumnChangedCallback =
Ptr TreeSortable ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TreeSortableSortColumnChangedCallback :: C_TreeSortableSortColumnChangedCallback -> IO (FunPtr C_TreeSortableSortColumnChangedCallback)
wrap_TreeSortableSortColumnChangedCallback ::
GObject a => (a -> TreeSortableSortColumnChangedCallback) ->
C_TreeSortableSortColumnChangedCallback
wrap_TreeSortableSortColumnChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TreeSortableSortColumnChangedCallback
wrap_TreeSortableSortColumnChangedCallback a -> IO ()
gi'cb Ptr TreeSortable
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TreeSortable
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TreeSortable
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TreeSortable
gi'self)
onTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId
onTreeSortableSortColumnChanged :: forall a (m :: * -> *).
(IsTreeSortable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTreeSortableSortColumnChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_TreeSortableSortColumnChangedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_TreeSortableSortColumnChangedCallback
wrap_TreeSortableSortColumnChangedCallback a -> IO ()
wrapped
FunPtr C_TreeSortableSortColumnChangedCallback
wrapped'' <- C_TreeSortableSortColumnChangedCallback
-> IO (FunPtr C_TreeSortableSortColumnChangedCallback)
mk_TreeSortableSortColumnChangedCallback C_TreeSortableSortColumnChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"sort-column-changed" FunPtr C_TreeSortableSortColumnChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId
afterTreeSortableSortColumnChanged :: forall a (m :: * -> *).
(IsTreeSortable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTreeSortableSortColumnChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_TreeSortableSortColumnChangedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_TreeSortableSortColumnChangedCallback
wrap_TreeSortableSortColumnChangedCallback a -> IO ()
wrapped
FunPtr C_TreeSortableSortColumnChangedCallback
wrapped'' <- C_TreeSortableSortColumnChangedCallback
-> IO (FunPtr C_TreeSortableSortColumnChangedCallback)
mk_TreeSortableSortColumnChangedCallback C_TreeSortableSortColumnChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"sort-column-changed" FunPtr C_TreeSortableSortColumnChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TreeSortableSortColumnChangedSignalInfo
instance SignalInfo TreeSortableSortColumnChangedSignalInfo where
type HaskellCallbackType TreeSortableSortColumnChangedSignalInfo = TreeSortableSortColumnChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TreeSortableSortColumnChangedCallback cb
cb'' <- mk_TreeSortableSortColumnChangedCallback cb'
connectSignalFunPtr obj "sort-column-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.TreeSortable::sort-column-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-TreeSortable.html#g:signal:sortColumnChanged"})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TreeSortable = TreeSortableSignalList
type TreeSortableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowChanged", Gtk.TreeModel.TreeModelRowChangedSignalInfo), '("rowDeleted", Gtk.TreeModel.TreeModelRowDeletedSignalInfo), '("rowHasChildToggled", Gtk.TreeModel.TreeModelRowHasChildToggledSignalInfo), '("rowInserted", Gtk.TreeModel.TreeModelRowInsertedSignalInfo), '("sortColumnChanged", TreeSortableSortColumnChangedSignalInfo)] :: [(Symbol, DK.Type)])
#endif