{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkStringSorter@ is a @GtkSorter@ that compares strings.
-- 
-- It does the comparison in a linguistically correct way using the
-- current locale by normalizing Unicode strings and possibly case-folding
-- them before performing the comparison.
-- 
-- To obtain the strings 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.StringSorter
    ( 

-- * Exported types
    StringSorter(..)                        ,
    IsStringSorter                          ,
    toStringSorter                          ,


 -- * 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.StringSorter#g:method:getExpression"), [getIgnoreCase]("GI.Gtk.Objects.StringSorter#g:method:getIgnoreCase"), [getOrder]("GI.Gtk.Objects.Sorter#g:method:getOrder"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setExpression]("GI.Gtk.Objects.StringSorter#g:method:setExpression"), [setIgnoreCase]("GI.Gtk.Objects.StringSorter#g:method:setIgnoreCase"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveStringSorterMethod               ,
#endif

-- ** getExpression #method:getExpression#

#if defined(ENABLE_OVERLOADING)
    StringSorterGetExpressionMethodInfo     ,
#endif
    stringSorterGetExpression               ,


-- ** getIgnoreCase #method:getIgnoreCase#

#if defined(ENABLE_OVERLOADING)
    StringSorterGetIgnoreCaseMethodInfo     ,
#endif
    stringSorterGetIgnoreCase               ,


-- ** new #method:new#

    stringSorterNew                         ,


-- ** setExpression #method:setExpression#

#if defined(ENABLE_OVERLOADING)
    StringSorterSetExpressionMethodInfo     ,
#endif
    stringSorterSetExpression               ,


-- ** setIgnoreCase #method:setIgnoreCase#

#if defined(ENABLE_OVERLOADING)
    StringSorterSetIgnoreCaseMethodInfo     ,
#endif
    stringSorterSetIgnoreCase               ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    StringSorterExpressionPropertyInfo      ,
#endif
    clearStringSorterExpression             ,
    constructStringSorterExpression         ,
    getStringSorterExpression               ,
    setStringSorterExpression               ,
#if defined(ENABLE_OVERLOADING)
    stringSorterExpression                  ,
#endif


-- ** ignoreCase #attr:ignoreCase#
-- | If matching is case sensitive.

#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.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.Objects.Expression as Gtk.Expression
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter

-- | Memory-managed wrapper type.
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

-- | Type class for types which can be safely cast to `StringSorter`, for instance with `toStringSorter`.
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]

-- | Cast to `StringSorter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | Convert 'StringSorter' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe 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 :: *) :: * 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 "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 "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

-- 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' stringSorter #expression
-- @
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"

-- | 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' stringSorter [ #expression 'Data.GI.Base.Attributes.:=' value ]
-- @
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')

-- | Construct a `GValueConstruct` with valid value for the “@expression@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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')

-- | 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
-- @
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.6/docs/GI-Gtk-Objects-StringSorter.html#g:attr:expression"
        })
#endif

-- VVV Prop "ignore-case"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@ignore-case@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stringSorter #ignoreCase
-- @
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"

-- | Set the value of the “@ignore-case@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stringSorter [ #ignoreCase 'Data.GI.Base.Attributes.:=' value ]
-- @
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

-- | Construct a `GValueConstruct` with valid value for the “@ignore-case@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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.6/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 = ('[ '("expression", StringSorterExpressionPropertyInfo), '("ignoreCase", StringSorterIgnoreCasePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
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, *)])

#endif

-- method StringSorter::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
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "StringSorter" })
-- throws : False
-- Skip return : False

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

-- | Creates a new string sorter that compares items using the given
-- /@expression@/.
-- 
-- Unless an expression is set on it, this sorter will always
-- compare items as invalid.
stringSorterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Expression.IsExpression a) =>
    Maybe (a)
    -- ^ /@expression@/: The expression to evaluate
    -> m StringSorter
    -- ^ __Returns:__ a new @GtkStringSorter@
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

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

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

-- | Gets the expression that is evaluated to obtain strings from items.
stringSorterGetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
    a
    -- ^ /@self@/: a @GtkStringSorter@
    -> m (Maybe Gtk.Expression.Expression)
    -- ^ __Returns:__ a @GtkExpression@
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.6/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterGetExpression"
        })


#endif

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

foreign import ccall "gtk_string_sorter_get_ignore_case" gtk_string_sorter_get_ignore_case :: 
    Ptr StringSorter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringSorter"})
    IO CInt

-- | Gets whether the sorter ignores case differences.
stringSorterGetIgnoreCase ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
    a
    -- ^ /@self@/: a @GtkStringSorter@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ is ignoring case differences
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.6/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterGetIgnoreCase"
        })


#endif

-- method StringSorter::set_expression
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkStringSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the expression that is evaluated to obtain strings from items.
-- 
-- The expression must have the type @/G_TYPE_STRING/@.
stringSorterSetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringSorter a, Gtk.Expression.IsExpression b) =>
    a
    -- ^ /@self@/: a @GtkStringSorter@
    -> Maybe (b)
    -- ^ /@expression@/: a @GtkExpression@
    -> 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.6/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterSetExpression"
        })


#endif

-- method StringSorter::set_ignore_case
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringSorter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkStringSorter`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ignore_case"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to ignore case differences"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_string_sorter_set_ignore_case" gtk_string_sorter_set_ignore_case :: 
    Ptr StringSorter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringSorter"})
    CInt ->                                 -- ignore_case : TBasicType TBoolean
    IO ()

-- | Sets whether the sorter will ignore case differences.
stringSorterSetIgnoreCase ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringSorter a) =>
    a
    -- ^ /@self@/: a @GtkStringSorter@
    -> Bool
    -- ^ /@ignoreCase@/: 'P.True' to ignore case differences
    -> 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
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
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.6/docs/GI-Gtk-Objects-StringSorter.html#v:stringSorterSetIgnoreCase"
        })


#endif