{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.CustomSorter
(
CustomSorter(..) ,
IsCustomSorter ,
toCustomSorter ,
#if defined(ENABLE_OVERLOADING)
ResolveCustomSorterMethod ,
#endif
customSorterNew ,
#if defined(ENABLE_OVERLOADING)
CustomSorterSetSortFuncMethodInfo ,
#endif
customSorterSetSortFunc ,
) 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.Coerce as Coerce
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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter
newtype CustomSorter = CustomSorter (SP.ManagedPtr CustomSorter)
deriving (CustomSorter -> CustomSorter -> Bool
(CustomSorter -> CustomSorter -> Bool)
-> (CustomSorter -> CustomSorter -> Bool) -> Eq CustomSorter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CustomSorter -> CustomSorter -> Bool
$c/= :: CustomSorter -> CustomSorter -> Bool
== :: CustomSorter -> CustomSorter -> Bool
$c== :: CustomSorter -> CustomSorter -> Bool
Eq)
instance SP.ManagedPtrNewtype CustomSorter where
toManagedPtr :: CustomSorter -> ManagedPtr CustomSorter
toManagedPtr (CustomSorter ManagedPtr CustomSorter
p) = ManagedPtr CustomSorter
p
foreign import ccall "gtk_custom_sorter_get_type"
c_gtk_custom_sorter_get_type :: IO B.Types.GType
instance B.Types.TypedObject CustomSorter where
glibType :: IO GType
glibType = IO GType
c_gtk_custom_sorter_get_type
instance B.Types.GObject CustomSorter
class (SP.GObject o, O.IsDescendantOf CustomSorter o) => IsCustomSorter o
instance (SP.GObject o, O.IsDescendantOf CustomSorter o) => IsCustomSorter o
instance O.HasParentTypes CustomSorter
type instance O.ParentTypes CustomSorter = '[Gtk.Sorter.Sorter, GObject.Object.Object]
toCustomSorter :: (MIO.MonadIO m, IsCustomSorter o) => o -> m CustomSorter
toCustomSorter :: forall (m :: * -> *) o.
(MonadIO m, IsCustomSorter o) =>
o -> m CustomSorter
toCustomSorter = IO CustomSorter -> m CustomSorter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO CustomSorter -> m CustomSorter)
-> (o -> IO CustomSorter) -> o -> m CustomSorter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr CustomSorter -> CustomSorter) -> o -> IO CustomSorter
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr CustomSorter -> CustomSorter
CustomSorter
instance B.GValue.IsGValue (Maybe CustomSorter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_custom_sorter_get_type
gvalueSet_ :: Ptr GValue -> Maybe CustomSorter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CustomSorter
P.Nothing = Ptr GValue -> Ptr CustomSorter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr CustomSorter
forall a. Ptr a
FP.nullPtr :: FP.Ptr CustomSorter)
gvalueSet_ Ptr GValue
gv (P.Just CustomSorter
obj) = CustomSorter -> (Ptr CustomSorter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CustomSorter
obj (Ptr GValue -> Ptr CustomSorter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe CustomSorter)
gvalueGet_ Ptr GValue
gv = do
Ptr CustomSorter
ptr <- Ptr GValue -> IO (Ptr CustomSorter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr CustomSorter)
if Ptr CustomSorter
ptr Ptr CustomSorter -> Ptr CustomSorter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CustomSorter
forall a. Ptr a
FP.nullPtr
then CustomSorter -> Maybe CustomSorter
forall a. a -> Maybe a
P.Just (CustomSorter -> Maybe CustomSorter)
-> IO CustomSorter -> IO (Maybe CustomSorter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CustomSorter -> CustomSorter)
-> Ptr CustomSorter -> IO CustomSorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CustomSorter -> CustomSorter
CustomSorter Ptr CustomSorter
ptr
else Maybe CustomSorter -> IO (Maybe CustomSorter)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CustomSorter
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveCustomSorterMethod (t :: Symbol) (o :: *) :: * where
ResolveCustomSorterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCustomSorterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCustomSorterMethod "changed" o = Gtk.Sorter.SorterChangedMethodInfo
ResolveCustomSorterMethod "compare" o = Gtk.Sorter.SorterCompareMethodInfo
ResolveCustomSorterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCustomSorterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCustomSorterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCustomSorterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCustomSorterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCustomSorterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCustomSorterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCustomSorterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCustomSorterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCustomSorterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCustomSorterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCustomSorterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCustomSorterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCustomSorterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCustomSorterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCustomSorterMethod "getOrder" o = Gtk.Sorter.SorterGetOrderMethodInfo
ResolveCustomSorterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCustomSorterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCustomSorterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCustomSorterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCustomSorterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCustomSorterMethod "setSortFunc" o = CustomSorterSetSortFuncMethodInfo
ResolveCustomSorterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCustomSorterMethod t CustomSorter, O.OverloadedMethod info CustomSorter p) => OL.IsLabel t (CustomSorter -> 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 ~ ResolveCustomSorterMethod t CustomSorter, O.OverloadedMethod info CustomSorter p, R.HasField t CustomSorter p) => R.HasField t CustomSorter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveCustomSorterMethod t CustomSorter, O.OverloadedMethodInfo info CustomSorter) => OL.IsLabel t (O.MethodProxy info CustomSorter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CustomSorter
type instance O.AttributeList CustomSorter = CustomSorterAttributeList
type CustomSorterAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList CustomSorter = CustomSorterSignalList
type CustomSorterSignalList = ('[ '("changed", Gtk.Sorter.SorterChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_custom_sorter_new" gtk_custom_sorter_new ::
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr CustomSorter)
customSorterNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (GLib.Callbacks.CompareDataFunc)
-> m CustomSorter
customSorterNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe CompareDataFunc -> m CustomSorter
customSorterNew Maybe CompareDataFunc
sortFunc = IO CustomSorter -> m CustomSorter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CustomSorter -> m CustomSorter)
-> IO CustomSorter -> m CustomSorter
forall a b. (a -> b) -> a -> b
$ do
FunPtr C_CompareDataFunc
maybeSortFunc <- case Maybe CompareDataFunc
sortFunc of
Maybe CompareDataFunc
Nothing -> FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_CompareDataFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just CompareDataFunc
jSortFunc -> do
FunPtr C_CompareDataFunc
jSortFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
jSortFunc))
FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_CompareDataFunc
jSortFunc'
let userData :: Ptr ()
userData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
maybeSortFunc
let userDestroy :: FunPtr (Ptr a -> IO ())
userDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr CustomSorter
result <- FunPtr C_CompareDataFunc
-> Ptr () -> FunPtr C_DestroyNotify -> IO (Ptr CustomSorter)
gtk_custom_sorter_new FunPtr C_CompareDataFunc
maybeSortFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
userDestroy
Text -> Ptr CustomSorter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"customSorterNew" Ptr CustomSorter
result
CustomSorter
result' <- ((ManagedPtr CustomSorter -> CustomSorter)
-> Ptr CustomSorter -> IO CustomSorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr CustomSorter -> CustomSorter
CustomSorter) Ptr CustomSorter
result
CustomSorter -> IO CustomSorter
forall (m :: * -> *) a. Monad m => a -> m a
return CustomSorter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_custom_sorter_set_sort_func" gtk_custom_sorter_set_sort_func ::
Ptr CustomSorter ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
customSorterSetSortFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsCustomSorter a) =>
a
-> Maybe (GLib.Callbacks.CompareDataFunc)
-> m ()
customSorterSetSortFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCustomSorter a) =>
a -> Maybe CompareDataFunc -> m ()
customSorterSetSortFunc a
self Maybe CompareDataFunc
sortFunc = 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 CustomSorter
self' <- a -> IO (Ptr CustomSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
FunPtr C_CompareDataFunc
maybeSortFunc <- case Maybe CompareDataFunc
sortFunc of
Maybe CompareDataFunc
Nothing -> FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_CompareDataFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just CompareDataFunc
jSortFunc -> do
FunPtr C_CompareDataFunc
jSortFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
jSortFunc))
FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_CompareDataFunc
jSortFunc'
let userData :: Ptr ()
userData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
maybeSortFunc
let userDestroy :: FunPtr (Ptr a -> IO ())
userDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr CustomSorter
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_custom_sorter_set_sort_func Ptr CustomSorter
self' FunPtr C_CompareDataFunc
maybeSortFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
userDestroy
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 CustomSorterSetSortFuncMethodInfo
instance (signature ~ (Maybe (GLib.Callbacks.CompareDataFunc) -> m ()), MonadIO m, IsCustomSorter a) => O.OverloadedMethod CustomSorterSetSortFuncMethodInfo a signature where
overloadedMethod = customSorterSetSortFunc
instance O.OverloadedMethodInfo CustomSorterSetSortFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.CustomSorter.customSorterSetSortFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-CustomSorter.html#v:customSorterSetSortFunc"
})
#endif