{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.StringSorter
(
StringSorter(..) ,
IsStringSorter ,
toStringSorter ,
#if defined(ENABLE_OVERLOADING)
ResolveStringSorterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StringSorterGetCollationMethodInfo ,
#endif
stringSorterGetCollation ,
#if defined(ENABLE_OVERLOADING)
StringSorterGetExpressionMethodInfo ,
#endif
stringSorterGetExpression ,
#if defined(ENABLE_OVERLOADING)
StringSorterGetIgnoreCaseMethodInfo ,
#endif
stringSorterGetIgnoreCase ,
stringSorterNew ,
#if defined(ENABLE_OVERLOADING)
StringSorterSetCollationMethodInfo ,
#endif
stringSorterSetCollation ,
#if defined(ENABLE_OVERLOADING)
StringSorterSetExpressionMethodInfo ,
#endif
stringSorterSetExpression ,
#if defined(ENABLE_OVERLOADING)
StringSorterSetIgnoreCaseMethodInfo ,
#endif
stringSorterSetIgnoreCase ,
#if defined(ENABLE_OVERLOADING)
StringSorterCollationPropertyInfo ,
#endif
constructStringSorterCollation ,
getStringSorterCollation ,
setStringSorterCollation ,
#if defined(ENABLE_OVERLOADING)
stringSorterCollation ,
#endif
#if defined(ENABLE_OVERLOADING)
StringSorterExpressionPropertyInfo ,
#endif
clearStringSorterExpression ,
constructStringSorterExpression ,
getStringSorterExpression ,
setStringSorterExpression ,
#if defined(ENABLE_OVERLOADING)
stringSorterExpression ,
#endif
#if defined(ENABLE_OVERLOADING)
StringSorterIgnoreCasePropertyInfo ,
#endif
constructStringSorterIgnoreCase ,
getStringSorterIgnoreCase ,
setStringSorterIgnoreCase ,
#if defined(ENABLE_OVERLOADING)
stringSorterIgnoreCase ,
#endif
) 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.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
newtype StringSorter = StringSorter (SP.ManagedPtr StringSorter)
deriving (StringSorter -> StringSorter -> Bool
(StringSorter -> StringSorter -> Bool)
-> (StringSorter -> StringSorter -> Bool) -> Eq StringSorter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringSorter -> StringSorter -> Bool
== :: StringSorter -> StringSorter -> Bool
$c/= :: StringSorter -> StringSorter -> Bool
/= :: StringSorter -> StringSorter -> Bool
Eq)
instance SP.ManagedPtrNewtype StringSorter where
toManagedPtr :: StringSorter -> ManagedPtr StringSorter
toManagedPtr (StringSorter ManagedPtr StringSorter
p) = ManagedPtr StringSorter
p
foreign import ccall "gtk_string_sorter_get_type"
c_gtk_string_sorter_get_type :: IO B.Types.GType
instance B.Types.TypedObject StringSorter where
glibType :: IO GType
glibType = IO GType
c_gtk_string_sorter_get_type
instance B.Types.GObject StringSorter
class (SP.GObject o, O.IsDescendantOf StringSorter o) => IsStringSorter o
instance (SP.GObject o, O.IsDescendantOf StringSorter o) => IsStringSorter o
instance O.HasParentTypes StringSorter
type instance O.ParentTypes StringSorter = '[Gtk.Sorter.Sorter, GObject.Object.Object]
toStringSorter :: (MIO.MonadIO m, IsStringSorter o) => o -> m StringSorter
toStringSorter :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> m StringSorter
toStringSorter = IO StringSorter -> m StringSorter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO StringSorter -> m StringSorter)
-> (o -> IO StringSorter) -> o -> m StringSorter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr StringSorter -> StringSorter) -> o -> IO StringSorter
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr StringSorter -> StringSorter
StringSorter
instance B.GValue.IsGValue (Maybe StringSorter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_string_sorter_get_type
gvalueSet_ :: Ptr GValue -> Maybe StringSorter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StringSorter
P.Nothing = Ptr GValue -> Ptr StringSorter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr StringSorter
forall a. Ptr a
FP.nullPtr :: FP.Ptr StringSorter)
gvalueSet_ Ptr GValue
gv (P.Just StringSorter
obj) = StringSorter -> (Ptr StringSorter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StringSorter
obj (Ptr GValue -> Ptr StringSorter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe StringSorter)
gvalueGet_ Ptr GValue
gv = do
Ptr StringSorter
ptr <- Ptr GValue -> IO (Ptr StringSorter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr StringSorter)
if Ptr StringSorter
ptr Ptr StringSorter -> Ptr StringSorter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StringSorter
forall a. Ptr a
FP.nullPtr
then StringSorter -> Maybe StringSorter
forall a. a -> Maybe a
P.Just (StringSorter -> Maybe StringSorter)
-> IO StringSorter -> IO (Maybe StringSorter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr StringSorter -> StringSorter)
-> Ptr StringSorter -> IO StringSorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr StringSorter -> StringSorter
StringSorter Ptr StringSorter
ptr
else Maybe StringSorter -> IO (Maybe StringSorter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StringSorter
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveStringSorterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveStringSorterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveStringSorterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveStringSorterMethod "changed" o = Gtk.Sorter.SorterChangedMethodInfo
ResolveStringSorterMethod "compare" o = Gtk.Sorter.SorterCompareMethodInfo
ResolveStringSorterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveStringSorterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveStringSorterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveStringSorterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveStringSorterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveStringSorterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveStringSorterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveStringSorterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveStringSorterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveStringSorterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveStringSorterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveStringSorterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveStringSorterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveStringSorterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveStringSorterMethod "getCollation" o = StringSorterGetCollationMethodInfo
ResolveStringSorterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveStringSorterMethod "getExpression" o = StringSorterGetExpressionMethodInfo
ResolveStringSorterMethod "getIgnoreCase" o = StringSorterGetIgnoreCaseMethodInfo
ResolveStringSorterMethod "getOrder" o = Gtk.Sorter.SorterGetOrderMethodInfo
ResolveStringSorterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveStringSorterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveStringSorterMethod "setCollation" o = StringSorterSetCollationMethodInfo
ResolveStringSorterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveStringSorterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveStringSorterMethod "setExpression" o = StringSorterSetExpressionMethodInfo
ResolveStringSorterMethod "setIgnoreCase" o = StringSorterSetIgnoreCaseMethodInfo
ResolveStringSorterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveStringSorterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveStringSorterMethod t StringSorter, O.OverloadedMethod info StringSorter p) => OL.IsLabel t (StringSorter -> 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 ~ ResolveStringSorterMethod t StringSorter, O.OverloadedMethod info StringSorter p, R.HasField t StringSorter p) => R.HasField t StringSorter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveStringSorterMethod t StringSorter, O.OverloadedMethodInfo info StringSorter) => OL.IsLabel t (O.MethodProxy info StringSorter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getStringSorterCollation :: (MonadIO m, IsStringSorter o) => o -> m Gtk.Enums.Collation
getStringSorterCollation :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> m Collation
getStringSorterCollation o
obj = IO Collation -> m Collation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Collation -> m Collation) -> IO Collation -> m Collation
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Collation
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"collation"
setStringSorterCollation :: (MonadIO m, IsStringSorter o) => o -> Gtk.Enums.Collation -> m ()
setStringSorterCollation :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> Collation -> m ()
setStringSorterCollation o
obj Collation
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 -> Collation -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"collation" Collation
val
constructStringSorterCollation :: (IsStringSorter o, MIO.MonadIO m) => Gtk.Enums.Collation -> m (GValueConstruct o)
constructStringSorterCollation :: forall o (m :: * -> *).
(IsStringSorter o, MonadIO m) =>
Collation -> m (GValueConstruct o)
constructStringSorterCollation Collation
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 -> Collation -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"collation" Collation
val
#if defined(ENABLE_OVERLOADING)
data StringSorterCollationPropertyInfo
instance AttrInfo StringSorterCollationPropertyInfo where
type AttrAllowedOps StringSorterCollationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint StringSorterCollationPropertyInfo = IsStringSorter
type AttrSetTypeConstraint StringSorterCollationPropertyInfo = (~) Gtk.Enums.Collation
type AttrTransferTypeConstraint StringSorterCollationPropertyInfo = (~) Gtk.Enums.Collation
type AttrTransferType StringSorterCollationPropertyInfo = Gtk.Enums.Collation
type AttrGetType StringSorterCollationPropertyInfo = Gtk.Enums.Collation
type AttrLabel StringSorterCollationPropertyInfo = "collation"
type AttrOrigin StringSorterCollationPropertyInfo = StringSorter
attrGet = getStringSorterCollation
attrSet = setStringSorterCollation
attrTransfer _ v = do
return v
attrConstruct = constructStringSorterCollation
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.collation"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#g:attr:collation"
})
#endif
getStringSorterExpression :: (MonadIO m, IsStringSorter o) => o -> m (Maybe Gtk.Expression.Expression)
getStringSorterExpression :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> m (Maybe Expression)
getStringSorterExpression 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"
setStringSorterExpression :: (MonadIO m, IsStringSorter o, Gtk.Expression.IsExpression a) => o -> a -> m ()
setStringSorterExpression :: forall (m :: * -> *) o a.
(MonadIO m, IsStringSorter o, IsExpression a) =>
o -> a -> m ()
setStringSorterExpression 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
Expression
val' <- a -> IO Expression
forall (m :: * -> *) o.
(MonadIO m, IsExpression o) =>
o -> m Expression
Gtk.Expression.toExpression a
val
o -> String -> Maybe Expression -> IO ()
forall a b. (GObject a, IsGValue b) => a -> String -> b -> IO ()
B.Properties.setObjectPropertyIsGValueInstance o
obj String
"expression" (Expression -> Maybe Expression
forall a. a -> Maybe a
Just Expression
val')
constructStringSorterExpression :: (IsStringSorter o, MIO.MonadIO m, Gtk.Expression.IsExpression a) => a -> m (GValueConstruct o)
constructStringSorterExpression :: forall o (m :: * -> *) a.
(IsStringSorter o, MonadIO m, IsExpression a) =>
a -> m (GValueConstruct o)
constructStringSorterExpression 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
Expression
val' <- a -> IO Expression
forall (m :: * -> *) o.
(MonadIO m, IsExpression o) =>
o -> m Expression
Gtk.Expression.toExpression a
val
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 -> Maybe Expression -> IO (GValueConstruct o)
forall b o. IsGValue b => String -> b -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyIsGValueInstance String
"expression" (Expression -> Maybe Expression
forall a. a -> Maybe a
P.Just Expression
val')
clearStringSorterExpression :: (MonadIO m, IsStringSorter o) => o -> m ()
clearStringSorterExpression :: forall (m :: * -> *) o. (MonadIO m, IsStringSorter o) => o -> m ()
clearStringSorterExpression 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 StringSorterExpressionPropertyInfo
instance AttrInfo StringSorterExpressionPropertyInfo where
type AttrAllowedOps StringSorterExpressionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint StringSorterExpressionPropertyInfo = IsStringSorter
type AttrSetTypeConstraint StringSorterExpressionPropertyInfo = (~) Gtk.Expression.Expression
type AttrTransferTypeConstraint StringSorterExpressionPropertyInfo = (~) Gtk.Expression.Expression
type AttrTransferType StringSorterExpressionPropertyInfo = Gtk.Expression.Expression
type AttrGetType StringSorterExpressionPropertyInfo = (Maybe Gtk.Expression.Expression)
type AttrLabel StringSorterExpressionPropertyInfo = "expression"
type AttrOrigin StringSorterExpressionPropertyInfo = StringSorter
attrGet = getStringSorterExpression
attrSet = setStringSorterExpression
attrTransfer _ v = do
return v
attrConstruct = constructStringSorterExpression
attrClear = clearStringSorterExpression
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.expression"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#g:attr:expression"
})
#endif
getStringSorterIgnoreCase :: (MonadIO m, IsStringSorter o) => o -> m Bool
getStringSorterIgnoreCase :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> m Bool
getStringSorterIgnoreCase o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"ignore-case"
setStringSorterIgnoreCase :: (MonadIO m, IsStringSorter o) => o -> Bool -> m ()
setStringSorterIgnoreCase :: forall (m :: * -> *) o.
(MonadIO m, IsStringSorter o) =>
o -> Bool -> m ()
setStringSorterIgnoreCase o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"ignore-case" Bool
val
constructStringSorterIgnoreCase :: (IsStringSorter o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStringSorterIgnoreCase :: forall o (m :: * -> *).
(IsStringSorter o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStringSorterIgnoreCase Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"ignore-case" Bool
val
#if defined(ENABLE_OVERLOADING)
data StringSorterIgnoreCasePropertyInfo
instance AttrInfo StringSorterIgnoreCasePropertyInfo where
type AttrAllowedOps StringSorterIgnoreCasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint StringSorterIgnoreCasePropertyInfo = IsStringSorter
type AttrSetTypeConstraint StringSorterIgnoreCasePropertyInfo = (~) Bool
type AttrTransferTypeConstraint StringSorterIgnoreCasePropertyInfo = (~) Bool
type AttrTransferType StringSorterIgnoreCasePropertyInfo = Bool
type AttrGetType StringSorterIgnoreCasePropertyInfo = Bool
type AttrLabel StringSorterIgnoreCasePropertyInfo = "ignore-case"
type AttrOrigin StringSorterIgnoreCasePropertyInfo = StringSorter
attrGet = getStringSorterIgnoreCase
attrSet = setStringSorterIgnoreCase
attrTransfer _ v = do
return v
attrConstruct = constructStringSorterIgnoreCase
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.ignoreCase"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#g:attr:ignoreCase"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StringSorter
type instance O.AttributeList StringSorter = StringSorterAttributeList
type StringSorterAttributeList = ('[ '("collation", StringSorterCollationPropertyInfo), '("expression", StringSorterExpressionPropertyInfo), '("ignoreCase", StringSorterIgnoreCasePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
stringSorterCollation :: AttrLabelProxy "collation"
stringSorterCollation = AttrLabelProxy
stringSorterExpression :: AttrLabelProxy "expression"
stringSorterExpression = AttrLabelProxy
stringSorterIgnoreCase :: AttrLabelProxy "ignoreCase"
stringSorterIgnoreCase = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList StringSorter = StringSorterSignalList
type StringSorterSignalList = ('[ '("changed", Gtk.Sorter.SorterChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_string_sorter_new" gtk_string_sorter_new ::
Ptr Gtk.Expression.Expression ->
IO (Ptr StringSorter)
stringSorterNew ::
(B.CallStack.HasCallStack, MonadIO m, Gtk.Expression.IsExpression a) =>
Maybe (a)
-> m StringSorter
stringSorterNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsExpression a) =>
Maybe a -> m StringSorter
stringSorterNew Maybe a
expression = IO StringSorter -> m StringSorter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StringSorter -> m StringSorter)
-> IO StringSorter -> m StringSorter
forall a b. (a -> b) -> a -> b
$ do
Ptr Expression
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
nullPtr
Just a
jExpression -> do
Ptr Expression
jExpression' <- a -> IO (Ptr Expression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
B.ManagedPtr.disownManagedPtr a
jExpression
Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
jExpression'
Ptr StringSorter
result <- Ptr Expression -> IO (Ptr StringSorter)
gtk_string_sorter_new Ptr Expression
maybeExpression
Text -> Ptr StringSorter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringSorterNew" Ptr StringSorter
result
StringSorter
result' <- ((ManagedPtr StringSorter -> StringSorter)
-> Ptr StringSorter -> IO StringSorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StringSorter -> StringSorter
StringSorter) Ptr StringSorter
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
expression a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
StringSorter -> IO StringSorter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StringSorter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_string_sorter_get_collation" gtk_string_sorter_get_collation ::
Ptr StringSorter ->
IO CUInt
stringSorterGetCollation ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
a
-> m Gtk.Enums.Collation
stringSorterGetCollation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringSorter a) =>
a -> m Collation
stringSorterGetCollation a
self = IO Collation -> m Collation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Collation -> m Collation) -> IO Collation -> m Collation
forall a b. (a -> b) -> a -> b
$ do
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CUInt
result <- Ptr StringSorter -> IO CUInt
gtk_string_sorter_get_collation Ptr StringSorter
self'
let result' :: Collation
result' = (Int -> Collation
forall a. Enum a => Int -> a
toEnum (Int -> Collation) -> (CUInt -> Int) -> CUInt -> Collation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Collation -> IO Collation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Collation
result'
#if defined(ENABLE_OVERLOADING)
data StringSorterGetCollationMethodInfo
instance (signature ~ (m Gtk.Enums.Collation), MonadIO m, IsStringSorter a) => O.OverloadedMethod StringSorterGetCollationMethodInfo a signature where
overloadedMethod = stringSorterGetCollation
instance O.OverloadedMethodInfo StringSorterGetCollationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterGetCollation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterGetCollation"
})
#endif
foreign import ccall "gtk_string_sorter_get_expression" gtk_string_sorter_get_expression ::
Ptr StringSorter ->
IO (Ptr Gtk.Expression.Expression)
stringSorterGetExpression ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
a
-> m (Maybe Gtk.Expression.Expression)
stringSorterGetExpression :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringSorter a) =>
a -> m (Maybe Expression)
stringSorterGetExpression 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
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Expression
result <- Ptr StringSorter -> IO (Ptr Expression)
gtk_string_sorter_get_expression Ptr StringSorter
self'
Maybe Expression
maybeResult <- Ptr Expression
-> (Ptr Expression -> IO Expression) -> IO (Maybe Expression)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Expression
result ((Ptr Expression -> IO Expression) -> IO (Maybe Expression))
-> (Ptr Expression -> IO Expression) -> IO (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ \Ptr Expression
result' -> do
Expression
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'
Expression -> IO Expression
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Expression
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Expression -> IO (Maybe Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Expression
maybeResult
#if defined(ENABLE_OVERLOADING)
data StringSorterGetExpressionMethodInfo
instance (signature ~ (m (Maybe Gtk.Expression.Expression)), MonadIO m, IsStringSorter a) => O.OverloadedMethod StringSorterGetExpressionMethodInfo a signature where
overloadedMethod = stringSorterGetExpression
instance O.OverloadedMethodInfo StringSorterGetExpressionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterGetExpression",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterGetExpression"
})
#endif
foreign import ccall "gtk_string_sorter_get_ignore_case" gtk_string_sorter_get_ignore_case ::
Ptr StringSorter ->
IO CInt
stringSorterGetIgnoreCase ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
a
-> m Bool
stringSorterGetIgnoreCase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringSorter a) =>
a -> m Bool
stringSorterGetIgnoreCase a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr StringSorter -> IO CInt
gtk_string_sorter_get_ignore_case Ptr StringSorter
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data StringSorterGetIgnoreCaseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStringSorter a) => O.OverloadedMethod StringSorterGetIgnoreCaseMethodInfo a signature where
overloadedMethod = stringSorterGetIgnoreCase
instance O.OverloadedMethodInfo StringSorterGetIgnoreCaseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterGetIgnoreCase",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterGetIgnoreCase"
})
#endif
foreign import ccall "gtk_string_sorter_set_collation" gtk_string_sorter_set_collation ::
Ptr StringSorter ->
CUInt ->
IO ()
stringSorterSetCollation ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
a
-> Gtk.Enums.Collation
-> m ()
stringSorterSetCollation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringSorter a) =>
a -> Collation -> m ()
stringSorterSetCollation a
self Collation
collation = 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
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let collation' :: CUInt
collation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Collation -> Int) -> Collation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Collation -> Int
forall a. Enum a => a -> Int
fromEnum) Collation
collation
Ptr StringSorter -> CUInt -> IO ()
gtk_string_sorter_set_collation Ptr StringSorter
self' CUInt
collation'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StringSorterSetCollationMethodInfo
instance (signature ~ (Gtk.Enums.Collation -> m ()), MonadIO m, IsStringSorter a) => O.OverloadedMethod StringSorterSetCollationMethodInfo a signature where
overloadedMethod = stringSorterSetCollation
instance O.OverloadedMethodInfo StringSorterSetCollationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterSetCollation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterSetCollation"
})
#endif
foreign import ccall "gtk_string_sorter_set_expression" gtk_string_sorter_set_expression ::
Ptr StringSorter ->
Ptr Gtk.Expression.Expression ->
IO ()
stringSorterSetExpression ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a, Gtk.Expression.IsExpression b) =>
a
-> Maybe (b)
-> m ()
stringSorterSetExpression :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsStringSorter a, IsExpression b) =>
a -> Maybe b -> m ()
stringSorterSetExpression 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
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Expression
maybeExpression <- case Maybe b
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
nullPtr
Just b
jExpression -> do
Ptr Expression
jExpression' <- b -> IO (Ptr Expression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jExpression
Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
jExpression'
Ptr StringSorter -> Ptr Expression -> IO ()
gtk_string_sorter_set_expression Ptr StringSorter
self' Ptr Expression
maybeExpression
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
expression b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StringSorterSetExpressionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsStringSorter a, Gtk.Expression.IsExpression b) => O.OverloadedMethod StringSorterSetExpressionMethodInfo a signature where
overloadedMethod = stringSorterSetExpression
instance O.OverloadedMethodInfo StringSorterSetExpressionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterSetExpression",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterSetExpression"
})
#endif
foreign import ccall "gtk_string_sorter_set_ignore_case" gtk_string_sorter_set_ignore_case ::
Ptr StringSorter ->
CInt ->
IO ()
stringSorterSetIgnoreCase ::
(B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
a
-> Bool
-> m ()
stringSorterSetIgnoreCase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringSorter a) =>
a -> Bool -> m ()
stringSorterSetIgnoreCase a
self Bool
ignoreCase = 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
Ptr StringSorter
self' <- a -> IO (Ptr StringSorter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let ignoreCase' :: CInt
ignoreCase' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
ignoreCase
Ptr StringSorter -> CInt -> IO ()
gtk_string_sorter_set_ignore_case Ptr StringSorter
self' CInt
ignoreCase'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StringSorterSetIgnoreCaseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStringSorter a) => O.OverloadedMethod StringSorterSetIgnoreCaseMethodInfo a signature where
overloadedMethod = stringSorterSetIgnoreCase
instance O.OverloadedMethodInfo StringSorterSetIgnoreCaseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.StringSorter.stringSorterSetIgnoreCase",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterSetIgnoreCase"
})
#endif