{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Sorts items numerically.
-- 
-- To obtain the numbers to compare, this sorter evaluates a
-- t'GI.Gtk.Objects.Expression.Expression'.

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

module GI.Gtk.Objects.NumericSorter
    ( 

-- * Exported types
    NumericSorter(..)                       ,
    IsNumericSorter                         ,
    toNumericSorter                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [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"), [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"), [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
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getExpression]("GI.Gtk.Objects.NumericSorter#g:method:getExpression"), [getOrder]("GI.Gtk.Objects.Sorter#g:method:getOrder"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSortOrder]("GI.Gtk.Objects.NumericSorter#g:method:getSortOrder").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setExpression]("GI.Gtk.Objects.NumericSorter#g:method:setExpression"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSortOrder]("GI.Gtk.Objects.NumericSorter#g:method:setSortOrder").

#if defined(ENABLE_OVERLOADING)
    ResolveNumericSorterMethod              ,
#endif

-- ** getExpression #method:getExpression#

#if defined(ENABLE_OVERLOADING)
    NumericSorterGetExpressionMethodInfo    ,
#endif
    numericSorterGetExpression              ,


-- ** getSortOrder #method:getSortOrder#

#if defined(ENABLE_OVERLOADING)
    NumericSorterGetSortOrderMethodInfo     ,
#endif
    numericSorterGetSortOrder               ,


-- ** new #method:new#

    numericSorterNew                        ,


-- ** setExpression #method:setExpression#

#if defined(ENABLE_OVERLOADING)
    NumericSorterSetExpressionMethodInfo    ,
#endif
    numericSorterSetExpression              ,


-- ** setSortOrder #method:setSortOrder#

#if defined(ENABLE_OVERLOADING)
    NumericSorterSetSortOrderMethodInfo     ,
#endif
    numericSorterSetSortOrder               ,




 -- * Properties


-- ** expression #attr:expression#
-- | The expression to evaluate on items to get a number to compare with.

#if defined(ENABLE_OVERLOADING)
    NumericSorterExpressionPropertyInfo     ,
#endif
    clearNumericSorterExpression            ,
    constructNumericSorterExpression        ,
    getNumericSorterExpression              ,
#if defined(ENABLE_OVERLOADING)
    numericSorterExpression                 ,
#endif
    setNumericSorterExpression              ,


-- ** sortOrder #attr:sortOrder#
-- | Whether the sorter will sort smaller numbers first.

#if defined(ENABLE_OVERLOADING)
    NumericSorterSortOrderPropertyInfo      ,
#endif
    constructNumericSorterSortOrder         ,
    getNumericSorterSortOrder               ,
#if defined(ENABLE_OVERLOADING)
    numericSorterSortOrder                  ,
#endif
    setNumericSorterSortOrder               ,




    ) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
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.Objects.Expression as Gtk.Expression
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter
import {-# SOURCE #-} qualified GI.Gtk.Structs.ExpressionWatch as Gtk.ExpressionWatch

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Objects.Expression as Gtk.Expression
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter

#endif

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

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

foreign import ccall "gtk_numeric_sorter_get_type"
    c_gtk_numeric_sorter_get_type :: IO B.Types.GType

instance B.Types.TypedObject NumericSorter where
    glibType :: IO GType
glibType = IO GType
c_gtk_numeric_sorter_get_type

instance B.Types.GObject NumericSorter

-- | Type class for types which can be safely cast to t'NumericSorter', for instance with `toNumericSorter`.
class (SP.GObject o, O.IsDescendantOf NumericSorter o) => IsNumericSorter o
instance (SP.GObject o, O.IsDescendantOf NumericSorter o) => IsNumericSorter o

instance O.HasParentTypes NumericSorter
type instance O.ParentTypes NumericSorter = '[Gtk.Sorter.Sorter, GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveNumericSorterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveNumericSorterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveNumericSorterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveNumericSorterMethod "changed" o = Gtk.Sorter.SorterChangedMethodInfo
    ResolveNumericSorterMethod "compare" o = Gtk.Sorter.SorterCompareMethodInfo
    ResolveNumericSorterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveNumericSorterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveNumericSorterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveNumericSorterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveNumericSorterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveNumericSorterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveNumericSorterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveNumericSorterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveNumericSorterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveNumericSorterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveNumericSorterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveNumericSorterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveNumericSorterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveNumericSorterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveNumericSorterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveNumericSorterMethod "getExpression" o = NumericSorterGetExpressionMethodInfo
    ResolveNumericSorterMethod "getOrder" o = Gtk.Sorter.SorterGetOrderMethodInfo
    ResolveNumericSorterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveNumericSorterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveNumericSorterMethod "getSortOrder" o = NumericSorterGetSortOrderMethodInfo
    ResolveNumericSorterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveNumericSorterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveNumericSorterMethod "setExpression" o = NumericSorterSetExpressionMethodInfo
    ResolveNumericSorterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveNumericSorterMethod "setSortOrder" o = NumericSorterSetSortOrderMethodInfo
    ResolveNumericSorterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveNumericSorterMethod t NumericSorter, O.OverloadedMethod info NumericSorter p) => OL.IsLabel t (NumericSorter -> 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 ~ ResolveNumericSorterMethod t NumericSorter, O.OverloadedMethod info NumericSorter p, R.HasField t NumericSorter p) => R.HasField t NumericSorter p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- VVV Prop "expression"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Expression"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@expression@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' numericSorter #expression
-- @
getNumericSorterExpression :: (MonadIO m, IsNumericSorter o) => o -> m (Maybe Gtk.Expression.Expression)
getNumericSorterExpression :: forall (m :: * -> *) o.
(MonadIO m, IsNumericSorter o) =>
o -> m (Maybe Expression)
getNumericSorterExpression o
obj = IO (Maybe Expression) -> m (Maybe Expression)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Expression) -> m (Maybe Expression))
-> IO (Maybe Expression) -> m (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Expression)
forall a b. (GObject a, IsGValue b) => a -> String -> IO b
B.Properties.getObjectPropertyIsGValueInstance o
obj String
"expression"

-- | Set the value of the “@expression@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' numericSorter [ #expression 'Data.GI.Base.Attributes.:=' value ]
-- @
setNumericSorterExpression :: (MonadIO m, IsNumericSorter o, Gtk.Expression.IsExpression a) => o -> a -> m ()
setNumericSorterExpression :: forall (m :: * -> *) o a.
(MonadIO m, IsNumericSorter o, IsExpression a) =>
o -> a -> m ()
setNumericSorterExpression o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    val' <- a -> IO Expression
forall (m :: * -> *) o.
(MonadIO m, IsExpression o) =>
o -> m Expression
Gtk.Expression.toExpression a
val
    B.Properties.setObjectPropertyIsGValueInstance obj "expression" (Just val')

-- | Construct a t'GValueConstruct' with valid value for the “@expression@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructNumericSorterExpression :: (IsNumericSorter o, MIO.MonadIO m, Gtk.Expression.IsExpression a) => a -> m (GValueConstruct o)
constructNumericSorterExpression :: forall o (m :: * -> *) a.
(IsNumericSorter o, MonadIO m, IsExpression a) =>
a -> m (GValueConstruct o)
constructNumericSorterExpression a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    val' <- a -> IO Expression
forall (m :: * -> *) o.
(MonadIO m, IsExpression o) =>
o -> m Expression
Gtk.Expression.toExpression a
val
    MIO.liftIO $ B.Properties.constructObjectPropertyIsGValueInstance "expression" (P.Just val')

-- | Set the value of the “@expression@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #expression
-- @
clearNumericSorterExpression :: (MonadIO m, IsNumericSorter o) => o -> m ()
clearNumericSorterExpression :: forall (m :: * -> *) o. (MonadIO m, IsNumericSorter o) => o -> m ()
clearNumericSorterExpression o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Expression -> IO ()
forall a b. (GObject a, IsGValue b) => a -> String -> b -> IO ()
B.Properties.setObjectPropertyIsGValueInstance o
obj String
"expression" (Maybe Expression
forall a. Maybe a
Nothing :: Maybe Gtk.Expression.Expression)

#if defined(ENABLE_OVERLOADING)
data NumericSorterExpressionPropertyInfo
instance AttrInfo NumericSorterExpressionPropertyInfo where
    type AttrAllowedOps NumericSorterExpressionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint NumericSorterExpressionPropertyInfo = IsNumericSorter
    type AttrSetTypeConstraint NumericSorterExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferTypeConstraint NumericSorterExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferType NumericSorterExpressionPropertyInfo = Gtk.Expression.Expression
    type AttrGetType NumericSorterExpressionPropertyInfo = (Maybe Gtk.Expression.Expression)
    type AttrLabel NumericSorterExpressionPropertyInfo = "expression"
    type AttrOrigin NumericSorterExpressionPropertyInfo = NumericSorter
    attrGet = getNumericSorterExpression
    attrSet = setNumericSorterExpression
    attrTransfer _ v = do
        return v
    attrConstruct = constructNumericSorterExpression
    attrClear = clearNumericSorterExpression
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.expression"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#g:attr:expression"
        })
#endif

-- VVV Prop "sort-order"
   -- Type: TInterface (Name {namespace = "Gtk", name = "SortType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@sort-order@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' numericSorter #sortOrder
-- @
getNumericSorterSortOrder :: (MonadIO m, IsNumericSorter o) => o -> m Gtk.Enums.SortType
getNumericSorterSortOrder :: forall (m :: * -> *) o.
(MonadIO m, IsNumericSorter o) =>
o -> m SortType
getNumericSorterSortOrder o
obj = IO SortType -> m SortType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO SortType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"sort-order"

-- | Set the value of the “@sort-order@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' numericSorter [ #sortOrder 'Data.GI.Base.Attributes.:=' value ]
-- @
setNumericSorterSortOrder :: (MonadIO m, IsNumericSorter o) => o -> Gtk.Enums.SortType -> m ()
setNumericSorterSortOrder :: forall (m :: * -> *) o.
(MonadIO m, IsNumericSorter o) =>
o -> SortType -> m ()
setNumericSorterSortOrder o
obj SortType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> SortType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"sort-order" SortType
val

-- | Construct a t'GValueConstruct' with valid value for the “@sort-order@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructNumericSorterSortOrder :: (IsNumericSorter o, MIO.MonadIO m) => Gtk.Enums.SortType -> m (GValueConstruct o)
constructNumericSorterSortOrder :: forall o (m :: * -> *).
(IsNumericSorter o, MonadIO m) =>
SortType -> m (GValueConstruct o)
constructNumericSorterSortOrder SortType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> SortType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"sort-order" SortType
val

#if defined(ENABLE_OVERLOADING)
data NumericSorterSortOrderPropertyInfo
instance AttrInfo NumericSorterSortOrderPropertyInfo where
    type AttrAllowedOps NumericSorterSortOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint NumericSorterSortOrderPropertyInfo = IsNumericSorter
    type AttrSetTypeConstraint NumericSorterSortOrderPropertyInfo = (~) Gtk.Enums.SortType
    type AttrTransferTypeConstraint NumericSorterSortOrderPropertyInfo = (~) Gtk.Enums.SortType
    type AttrTransferType NumericSorterSortOrderPropertyInfo = Gtk.Enums.SortType
    type AttrGetType NumericSorterSortOrderPropertyInfo = Gtk.Enums.SortType
    type AttrLabel NumericSorterSortOrderPropertyInfo = "sort-order"
    type AttrOrigin NumericSorterSortOrderPropertyInfo = NumericSorter
    attrGet = getNumericSorterSortOrder
    attrSet = setNumericSorterSortOrder
    attrTransfer _ v = do
        return v
    attrConstruct = constructNumericSorterSortOrder
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.sortOrder"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#g:attr:sortOrder"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList NumericSorter
type instance O.AttributeList NumericSorter = NumericSorterAttributeList
type NumericSorterAttributeList = ('[ '("expression", NumericSorterExpressionPropertyInfo), '("sortOrder", NumericSorterSortOrderPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
numericSorterExpression :: AttrLabelProxy "expression"
numericSorterExpression = AttrLabelProxy

numericSorterSortOrder :: AttrLabelProxy "sortOrder"
numericSorterSortOrder = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList NumericSorter = NumericSorterSignalList
type NumericSorterSignalList = ('[ '("changed", Gtk.Sorter.SorterChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method NumericSorter::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "expression"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Expression" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The expression to evaluate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "NumericSorter" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_numeric_sorter_new" gtk_numeric_sorter_new :: 
    Ptr Gtk.Expression.Expression ->        -- expression : TInterface (Name {namespace = "Gtk", name = "Expression"})
    IO (Ptr NumericSorter)

-- | Creates a new numeric sorter using the given /@expression@/.
-- 
-- Smaller numbers will be sorted first. You can call
-- 'GI.Gtk.Objects.NumericSorter.numericSorterSetSortOrder' to change this.
numericSorterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Expression.IsExpression a) =>
    Maybe (a)
    -- ^ /@expression@/: The expression to evaluate
    -> m NumericSorter
    -- ^ __Returns:__ a new @GtkNumericSorter@
numericSorterNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsExpression a) =>
Maybe a -> m NumericSorter
numericSorterNew Maybe a
expression = IO NumericSorter -> m NumericSorter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO NumericSorter -> m NumericSorter)
-> IO NumericSorter -> m NumericSorter
forall a b. (a -> b) -> a -> b
$ do
    maybeExpression <- case Maybe a
expression of
        Maybe a
Nothing -> Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
forall a. Ptr a
FP.nullPtr
        Just a
jExpression -> do
            jExpression' <- a -> IO (Ptr Expression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
B.ManagedPtr.disownManagedPtr a
jExpression
            return jExpression'
    result <- gtk_numeric_sorter_new maybeExpression
    checkUnexpectedReturnNULL "numericSorterNew" result
    result' <- (wrapObject NumericSorter) result
    whenJust expression touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method NumericSorter::get_expression
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "NumericSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkNumericSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Expression" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_numeric_sorter_get_expression" gtk_numeric_sorter_get_expression :: 
    Ptr NumericSorter ->                    -- self : TInterface (Name {namespace = "Gtk", name = "NumericSorter"})
    IO (Ptr Gtk.Expression.Expression)

-- | Gets the expression that is evaluated to obtain numbers from items.
numericSorterGetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsNumericSorter a) =>
    a
    -- ^ /@self@/: a @GtkNumericSorter@
    -> m (Maybe Gtk.Expression.Expression)
    -- ^ __Returns:__ a @GtkExpression@
numericSorterGetExpression :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNumericSorter a) =>
a -> m (Maybe Expression)
numericSorterGetExpression a
self = IO (Maybe Expression) -> m (Maybe Expression)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Expression) -> m (Maybe Expression))
-> IO (Maybe Expression) -> m (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr NumericSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_numeric_sorter_get_expression self'
    maybeResult <- convertIfNonNull result $ \Ptr Expression
result' -> do
        result'' <- ((ManagedPtr Expression -> Expression)
-> Ptr Expression -> IO Expression
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Expression -> Expression
Gtk.Expression.Expression) Ptr Expression
result'
        return result''
    touchManagedPtr self
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NumericSorterGetExpressionMethodInfo
instance (signature ~ (m (Maybe Gtk.Expression.Expression)), MonadIO m, IsNumericSorter a) => O.OverloadedMethod NumericSorterGetExpressionMethodInfo a signature where
    overloadedMethod = numericSorterGetExpression

instance O.OverloadedMethodInfo NumericSorterGetExpressionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.numericSorterGetExpression",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#v:numericSorterGetExpression"
        })


#endif

-- method NumericSorter::get_sort_order
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "NumericSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkNumericSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SortType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_numeric_sorter_get_sort_order" gtk_numeric_sorter_get_sort_order :: 
    Ptr NumericSorter ->                    -- self : TInterface (Name {namespace = "Gtk", name = "NumericSorter"})
    IO CUInt

-- | Gets whether this sorter will sort smaller numbers first.
numericSorterGetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNumericSorter a) =>
    a
    -- ^ /@self@/: a @GtkNumericSorter@
    -> m Gtk.Enums.SortType
    -- ^ __Returns:__ the order of the numbers
numericSorterGetSortOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNumericSorter a) =>
a -> m SortType
numericSorterGetSortOrder a
self = IO SortType -> m SortType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr NumericSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_numeric_sorter_get_sort_order self'
    let result' = (Int -> SortType
forall a. Enum a => Int -> a
toEnum (Int -> SortType) -> (CUInt -> Int) -> CUInt -> SortType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data NumericSorterGetSortOrderMethodInfo
instance (signature ~ (m Gtk.Enums.SortType), MonadIO m, IsNumericSorter a) => O.OverloadedMethod NumericSorterGetSortOrderMethodInfo a signature where
    overloadedMethod = numericSorterGetSortOrder

instance O.OverloadedMethodInfo NumericSorterGetSortOrderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.numericSorterGetSortOrder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#v:numericSorterGetSortOrder"
        })


#endif

-- method NumericSorter::set_expression
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "NumericSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkNumericSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expression"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Expression" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkExpression`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_numeric_sorter_set_expression" gtk_numeric_sorter_set_expression :: 
    Ptr NumericSorter ->                    -- self : TInterface (Name {namespace = "Gtk", name = "NumericSorter"})
    Ptr Gtk.Expression.Expression ->        -- expression : TInterface (Name {namespace = "Gtk", name = "Expression"})
    IO ()

-- | Sets the expression that is evaluated to obtain numbers from items.
-- 
-- Unless an expression is set on /@self@/, the sorter will always
-- compare items as invalid.
-- 
-- The expression must have a return type that can be compared
-- numerically, such as @/G_TYPE_INT/@ or @/G_TYPE_DOUBLE/@.
numericSorterSetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsNumericSorter a, Gtk.Expression.IsExpression b) =>
    a
    -- ^ /@self@/: a @GtkNumericSorter@
    -> Maybe (b)
    -- ^ /@expression@/: a @GtkExpression@
    -> m ()
numericSorterSetExpression :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNumericSorter a, IsExpression b) =>
a -> Maybe b -> m ()
numericSorterSetExpression a
self Maybe b
expression = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr NumericSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    maybeExpression <- case expression of
        Maybe b
Nothing -> Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
forall a. Ptr a
FP.nullPtr
        Just b
jExpression -> do
            jExpression' <- b -> IO (Ptr Expression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jExpression
            return jExpression'
    gtk_numeric_sorter_set_expression self' maybeExpression
    touchManagedPtr self
    whenJust expression touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING)
data NumericSorterSetExpressionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsNumericSorter a, Gtk.Expression.IsExpression b) => O.OverloadedMethod NumericSorterSetExpressionMethodInfo a signature where
    overloadedMethod = numericSorterSetExpression

instance O.OverloadedMethodInfo NumericSorterSetExpressionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.numericSorterSetExpression",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#v:numericSorterSetExpression"
        })


#endif

-- method NumericSorter::set_sort_order
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "NumericSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkNumericSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sort_order"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "SortType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to sort smaller numbers first"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_numeric_sorter_set_sort_order" gtk_numeric_sorter_set_sort_order :: 
    Ptr NumericSorter ->                    -- self : TInterface (Name {namespace = "Gtk", name = "NumericSorter"})
    CUInt ->                                -- sort_order : TInterface (Name {namespace = "Gtk", name = "SortType"})
    IO ()

-- | Sets whether to sort smaller numbers before larger ones.
numericSorterSetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNumericSorter a) =>
    a
    -- ^ /@self@/: a @GtkNumericSorter@
    -> Gtk.Enums.SortType
    -- ^ /@sortOrder@/: whether to sort smaller numbers first
    -> m ()
numericSorterSetSortOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNumericSorter a) =>
a -> SortType -> m ()
numericSorterSetSortOrder a
self SortType
sortOrder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr NumericSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let sortOrder' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SortType -> Int) -> SortType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SortType -> Int
forall a. Enum a => a -> Int
fromEnum) SortType
sortOrder
    gtk_numeric_sorter_set_sort_order self' sortOrder'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data NumericSorterSetSortOrderMethodInfo
instance (signature ~ (Gtk.Enums.SortType -> m ()), MonadIO m, IsNumericSorter a) => O.OverloadedMethod NumericSorterSetSortOrderMethodInfo a signature where
    overloadedMethod = numericSorterSetSortOrder

instance O.OverloadedMethodInfo NumericSorterSetSortOrderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.NumericSorter.numericSorterSetSortOrder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-NumericSorter.html#v:numericSorterSetSortOrder"
        })


#endif