{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Determines whether to include items by comparing strings to a fixed search term.
-- 
-- The strings are obtained from the items by evaluating an expression
-- set with 'GI.Gtk.Objects.StringFilter.stringFilterSetExpression', and they are
-- compared against a search term set with 'GI.Gtk.Objects.StringFilter.stringFilterSetSearch'.
-- 
-- @GtkStringFilter@ has several different modes of comparison - it
-- can match the whole string, just a prefix, or any substring. Use
-- 'GI.Gtk.Objects.StringFilter.stringFilterSetMatchMode' choose a mode.
-- 
-- It is also possible to make case-insensitive comparisons, with
-- 'GI.Gtk.Objects.StringFilter.stringFilterSetIgnoreCase'.

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

module GI.Gtk.Objects.StringFilter
    ( 

-- * Exported types
    StringFilter(..)                        ,
    IsStringFilter                          ,
    toStringFilter                          ,


 -- * 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.Filter#g:method:changed"), [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"), [match]("GI.Gtk.Objects.Filter#g:method:match"), [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.StringFilter#g:method:getExpression"), [getIgnoreCase]("GI.Gtk.Objects.StringFilter#g:method:getIgnoreCase"), [getMatchMode]("GI.Gtk.Objects.StringFilter#g:method:getMatchMode"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSearch]("GI.Gtk.Objects.StringFilter#g:method:getSearch"), [getStrictness]("GI.Gtk.Objects.Filter#g:method:getStrictness").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setExpression]("GI.Gtk.Objects.StringFilter#g:method:setExpression"), [setIgnoreCase]("GI.Gtk.Objects.StringFilter#g:method:setIgnoreCase"), [setMatchMode]("GI.Gtk.Objects.StringFilter#g:method:setMatchMode"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSearch]("GI.Gtk.Objects.StringFilter#g:method:setSearch").

#if defined(ENABLE_OVERLOADING)
    ResolveStringFilterMethod               ,
#endif

-- ** getExpression #method:getExpression#

#if defined(ENABLE_OVERLOADING)
    StringFilterGetExpressionMethodInfo     ,
#endif
    stringFilterGetExpression               ,


-- ** getIgnoreCase #method:getIgnoreCase#

#if defined(ENABLE_OVERLOADING)
    StringFilterGetIgnoreCaseMethodInfo     ,
#endif
    stringFilterGetIgnoreCase               ,


-- ** getMatchMode #method:getMatchMode#

#if defined(ENABLE_OVERLOADING)
    StringFilterGetMatchModeMethodInfo      ,
#endif
    stringFilterGetMatchMode                ,


-- ** getSearch #method:getSearch#

#if defined(ENABLE_OVERLOADING)
    StringFilterGetSearchMethodInfo         ,
#endif
    stringFilterGetSearch                   ,


-- ** new #method:new#

    stringFilterNew                         ,


-- ** setExpression #method:setExpression#

#if defined(ENABLE_OVERLOADING)
    StringFilterSetExpressionMethodInfo     ,
#endif
    stringFilterSetExpression               ,


-- ** setIgnoreCase #method:setIgnoreCase#

#if defined(ENABLE_OVERLOADING)
    StringFilterSetIgnoreCaseMethodInfo     ,
#endif
    stringFilterSetIgnoreCase               ,


-- ** setMatchMode #method:setMatchMode#

#if defined(ENABLE_OVERLOADING)
    StringFilterSetMatchModeMethodInfo      ,
#endif
    stringFilterSetMatchMode                ,


-- ** setSearch #method:setSearch#

#if defined(ENABLE_OVERLOADING)
    StringFilterSetSearchMethodInfo         ,
#endif
    stringFilterSetSearch                   ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    StringFilterExpressionPropertyInfo      ,
#endif
    clearStringFilterExpression             ,
    constructStringFilterExpression         ,
    getStringFilterExpression               ,
    setStringFilterExpression               ,
#if defined(ENABLE_OVERLOADING)
    stringFilterExpression                  ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    StringFilterIgnoreCasePropertyInfo      ,
#endif
    constructStringFilterIgnoreCase         ,
    getStringFilterIgnoreCase               ,
    setStringFilterIgnoreCase               ,
#if defined(ENABLE_OVERLOADING)
    stringFilterIgnoreCase                  ,
#endif


-- ** matchMode #attr:matchMode#
-- | If exact matches are necessary or if substrings are allowed.

#if defined(ENABLE_OVERLOADING)
    StringFilterMatchModePropertyInfo       ,
#endif
    constructStringFilterMatchMode          ,
    getStringFilterMatchMode                ,
    setStringFilterMatchMode                ,
#if defined(ENABLE_OVERLOADING)
    stringFilterMatchMode                   ,
#endif


-- ** search #attr:search#
-- | The search term.

#if defined(ENABLE_OVERLOADING)
    StringFilterSearchPropertyInfo          ,
#endif
    clearStringFilterSearch                 ,
    constructStringFilterSearch             ,
    getStringFilterSearch                   ,
    setStringFilterSearch                   ,
#if defined(ENABLE_OVERLOADING)
    stringFilterSearch                      ,
#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 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.Filter as Gtk.Filter
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.Filter as Gtk.Filter

#endif

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

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

foreign import ccall "gtk_string_filter_get_type"
    c_gtk_string_filter_get_type :: IO B.Types.GType

instance B.Types.TypedObject StringFilter where
    glibType :: IO GType
glibType = IO GType
c_gtk_string_filter_get_type

instance B.Types.GObject StringFilter

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

instance O.HasParentTypes StringFilter
type instance O.ParentTypes StringFilter = '[Gtk.Filter.Filter, GObject.Object.Object]

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

-- | Convert t'StringFilter' 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 StringFilter) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_string_filter_get_type
    gvalueSet_ :: Ptr GValue -> Maybe StringFilter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StringFilter
P.Nothing = Ptr GValue -> Ptr StringFilter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr StringFilter
forall a. Ptr a
FP.nullPtr :: FP.Ptr StringFilter)
    gvalueSet_ Ptr GValue
gv (P.Just StringFilter
obj) = StringFilter -> (Ptr StringFilter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StringFilter
obj (Ptr GValue -> Ptr StringFilter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe StringFilter)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr StringFilter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr StringFilter)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject StringFilter ptr
        else return P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveStringFilterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveStringFilterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveStringFilterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveStringFilterMethod "changed" o = Gtk.Filter.FilterChangedMethodInfo
    ResolveStringFilterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveStringFilterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveStringFilterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveStringFilterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveStringFilterMethod "match" o = Gtk.Filter.FilterMatchMethodInfo
    ResolveStringFilterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveStringFilterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveStringFilterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveStringFilterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveStringFilterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveStringFilterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveStringFilterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveStringFilterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveStringFilterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveStringFilterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveStringFilterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveStringFilterMethod "getExpression" o = StringFilterGetExpressionMethodInfo
    ResolveStringFilterMethod "getIgnoreCase" o = StringFilterGetIgnoreCaseMethodInfo
    ResolveStringFilterMethod "getMatchMode" o = StringFilterGetMatchModeMethodInfo
    ResolveStringFilterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveStringFilterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveStringFilterMethod "getSearch" o = StringFilterGetSearchMethodInfo
    ResolveStringFilterMethod "getStrictness" o = Gtk.Filter.FilterGetStrictnessMethodInfo
    ResolveStringFilterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveStringFilterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveStringFilterMethod "setExpression" o = StringFilterSetExpressionMethodInfo
    ResolveStringFilterMethod "setIgnoreCase" o = StringFilterSetIgnoreCaseMethodInfo
    ResolveStringFilterMethod "setMatchMode" o = StringFilterSetMatchModeMethodInfo
    ResolveStringFilterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveStringFilterMethod "setSearch" o = StringFilterSetSearchMethodInfo
    ResolveStringFilterMethod l o = O.MethodResolutionFailed l o

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

#endif

instance (info ~ ResolveStringFilterMethod t StringFilter, O.OverloadedMethodInfo info StringFilter) => OL.IsLabel t (O.MethodProxy info StringFilter) 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' stringFilter #expression
-- @
getStringFilterExpression :: (MonadIO m, IsStringFilter o) => o -> m (Maybe Gtk.Expression.Expression)
getStringFilterExpression :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> m (Maybe Expression)
getStringFilterExpression 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' stringFilter [ #expression 'Data.GI.Base.Attributes.:=' value ]
-- @
setStringFilterExpression :: (MonadIO m, IsStringFilter o, Gtk.Expression.IsExpression a) => o -> a -> m ()
setStringFilterExpression :: forall (m :: * -> *) o a.
(MonadIO m, IsStringFilter o, IsExpression a) =>
o -> a -> m ()
setStringFilterExpression 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`.
constructStringFilterExpression :: (IsStringFilter o, MIO.MonadIO m, Gtk.Expression.IsExpression a) => a -> m (GValueConstruct o)
constructStringFilterExpression :: forall o (m :: * -> *) a.
(IsStringFilter o, MonadIO m, IsExpression a) =>
a -> m (GValueConstruct o)
constructStringFilterExpression 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
-- @
clearStringFilterExpression :: (MonadIO m, IsStringFilter o) => o -> m ()
clearStringFilterExpression :: forall (m :: * -> *) o. (MonadIO m, IsStringFilter o) => o -> m ()
clearStringFilterExpression 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 StringFilterExpressionPropertyInfo
instance AttrInfo StringFilterExpressionPropertyInfo where
    type AttrAllowedOps StringFilterExpressionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StringFilterExpressionPropertyInfo = IsStringFilter
    type AttrSetTypeConstraint StringFilterExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferTypeConstraint StringFilterExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferType StringFilterExpressionPropertyInfo = Gtk.Expression.Expression
    type AttrGetType StringFilterExpressionPropertyInfo = (Maybe Gtk.Expression.Expression)
    type AttrLabel StringFilterExpressionPropertyInfo = "expression"
    type AttrOrigin StringFilterExpressionPropertyInfo = StringFilter
    attrGet = getStringFilterExpression
    attrSet = setStringFilterExpression
    attrTransfer _ v = do
        return v
    attrConstruct = constructStringFilterExpression
    attrClear = clearStringFilterExpression
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.StringFilter.expression"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-StringFilter.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' stringFilter #ignoreCase
-- @
getStringFilterIgnoreCase :: (MonadIO m, IsStringFilter o) => o -> m Bool
getStringFilterIgnoreCase :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> m Bool
getStringFilterIgnoreCase 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' stringFilter [ #ignoreCase 'Data.GI.Base.Attributes.:=' value ]
-- @
setStringFilterIgnoreCase :: (MonadIO m, IsStringFilter o) => o -> Bool -> m ()
setStringFilterIgnoreCase :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> Bool -> m ()
setStringFilterIgnoreCase 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 t'GValueConstruct' with valid value for the “@ignore-case@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStringFilterIgnoreCase :: (IsStringFilter o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStringFilterIgnoreCase :: forall o (m :: * -> *).
(IsStringFilter o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructStringFilterIgnoreCase 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 StringFilterIgnoreCasePropertyInfo
instance AttrInfo StringFilterIgnoreCasePropertyInfo where
    type AttrAllowedOps StringFilterIgnoreCasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StringFilterIgnoreCasePropertyInfo = IsStringFilter
    type AttrSetTypeConstraint StringFilterIgnoreCasePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StringFilterIgnoreCasePropertyInfo = (~) Bool
    type AttrTransferType StringFilterIgnoreCasePropertyInfo = Bool
    type AttrGetType StringFilterIgnoreCasePropertyInfo = Bool
    type AttrLabel StringFilterIgnoreCasePropertyInfo = "ignore-case"
    type AttrOrigin StringFilterIgnoreCasePropertyInfo = StringFilter
    attrGet = getStringFilterIgnoreCase
    attrSet = setStringFilterIgnoreCase
    attrTransfer _ v = do
        return v
    attrConstruct = constructStringFilterIgnoreCase
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.StringFilter.ignoreCase"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-StringFilter.html#g:attr:ignoreCase"
        })
#endif

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

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

-- | Set the value of the “@match-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stringFilter [ #matchMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setStringFilterMatchMode :: (MonadIO m, IsStringFilter o) => o -> Gtk.Enums.StringFilterMatchMode -> m ()
setStringFilterMatchMode :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> StringFilterMatchMode -> m ()
setStringFilterMatchMode o
obj StringFilterMatchMode
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 -> StringFilterMatchMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"match-mode" StringFilterMatchMode
val

-- | Construct a t'GValueConstruct' with valid value for the “@match-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStringFilterMatchMode :: (IsStringFilter o, MIO.MonadIO m) => Gtk.Enums.StringFilterMatchMode -> m (GValueConstruct o)
constructStringFilterMatchMode :: forall o (m :: * -> *).
(IsStringFilter o, MonadIO m) =>
StringFilterMatchMode -> m (GValueConstruct o)
constructStringFilterMatchMode StringFilterMatchMode
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 -> StringFilterMatchMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"match-mode" StringFilterMatchMode
val

#if defined(ENABLE_OVERLOADING)
data StringFilterMatchModePropertyInfo
instance AttrInfo StringFilterMatchModePropertyInfo where
    type AttrAllowedOps StringFilterMatchModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StringFilterMatchModePropertyInfo = IsStringFilter
    type AttrSetTypeConstraint StringFilterMatchModePropertyInfo = (~) Gtk.Enums.StringFilterMatchMode
    type AttrTransferTypeConstraint StringFilterMatchModePropertyInfo = (~) Gtk.Enums.StringFilterMatchMode
    type AttrTransferType StringFilterMatchModePropertyInfo = Gtk.Enums.StringFilterMatchMode
    type AttrGetType StringFilterMatchModePropertyInfo = Gtk.Enums.StringFilterMatchMode
    type AttrLabel StringFilterMatchModePropertyInfo = "match-mode"
    type AttrOrigin StringFilterMatchModePropertyInfo = StringFilter
    attrGet = getStringFilterMatchMode
    attrSet = setStringFilterMatchMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructStringFilterMatchMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.StringFilter.matchMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-StringFilter.html#g:attr:matchMode"
        })
#endif

-- VVV Prop "search"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@search@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stringFilter #search
-- @
getStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> m (Maybe T.Text)
getStringFilterSearch :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> m (Maybe Text)
getStringFilterSearch o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"search"

-- | Set the value of the “@search@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stringFilter [ #search 'Data.GI.Base.Attributes.:=' value ]
-- @
setStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> T.Text -> m ()
setStringFilterSearch :: forall (m :: * -> *) o.
(MonadIO m, IsStringFilter o) =>
o -> Text -> m ()
setStringFilterSearch o
obj Text
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 -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"search" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@search@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStringFilterSearch :: (IsStringFilter o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStringFilterSearch :: forall o (m :: * -> *).
(IsStringFilter o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStringFilterSearch Text
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 -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"search" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@search@” 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' #search
-- @
clearStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> m ()
clearStringFilterSearch :: forall (m :: * -> *) o. (MonadIO m, IsStringFilter o) => o -> m ()
clearStringFilterSearch 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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"search" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data StringFilterSearchPropertyInfo
instance AttrInfo StringFilterSearchPropertyInfo where
    type AttrAllowedOps StringFilterSearchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StringFilterSearchPropertyInfo = IsStringFilter
    type AttrSetTypeConstraint StringFilterSearchPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StringFilterSearchPropertyInfo = (~) T.Text
    type AttrTransferType StringFilterSearchPropertyInfo = T.Text
    type AttrGetType StringFilterSearchPropertyInfo = (Maybe T.Text)
    type AttrLabel StringFilterSearchPropertyInfo = "search"
    type AttrOrigin StringFilterSearchPropertyInfo = StringFilter
    attrGet = getStringFilterSearch
    attrSet = setStringFilterSearch
    attrTransfer _ v = do
        return v
    attrConstruct = constructStringFilterSearch
    attrClear = clearStringFilterSearch
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.StringFilter.search"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-StringFilter.html#g:attr:search"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StringFilter
type instance O.AttributeList StringFilter = StringFilterAttributeList
type StringFilterAttributeList = ('[ '("expression", StringFilterExpressionPropertyInfo), '("ignoreCase", StringFilterIgnoreCasePropertyInfo), '("matchMode", StringFilterMatchModePropertyInfo), '("search", StringFilterSearchPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

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

stringFilterIgnoreCase :: AttrLabelProxy "ignoreCase"
stringFilterIgnoreCase = AttrLabelProxy

stringFilterMatchMode :: AttrLabelProxy "matchMode"
stringFilterMatchMode = AttrLabelProxy

stringFilterSearch :: AttrLabelProxy "search"
stringFilterSearch = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList StringFilter = StringFilterSignalList
type StringFilterSignalList = ('[ '("changed", Gtk.Filter.FilterChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method StringFilter::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 = "StringFilter" })
-- throws : False
-- Skip return : False

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

-- | Creates a new string filter.
-- 
-- You will want to set up the filter by providing a string to search for
-- and by providing a property to look up on the item.
stringFilterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Expression.IsExpression a) =>
    Maybe (a)
    -- ^ /@expression@/: the expression to evaluate
    -> m StringFilter
    -- ^ __Returns:__ a new @GtkStringFilter@
stringFilterNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsExpression a) =>
Maybe a -> m StringFilter
stringFilterNew Maybe a
expression = IO StringFilter -> m StringFilter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StringFilter -> m StringFilter)
-> IO StringFilter -> m StringFilter
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_string_filter_new maybeExpression
    checkUnexpectedReturnNULL "stringFilterNew" result
    result' <- (wrapObject StringFilter) result
    whenJust expression touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method StringFilter::get_expression
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string filter" , 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_string_filter_get_expression" gtk_string_filter_get_expression :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    IO (Ptr Gtk.Expression.Expression)

-- | Gets the expression that the string filter uses to
-- obtain strings from items.
stringFilterGetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> m (Maybe Gtk.Expression.Expression)
    -- ^ __Returns:__ the expression
stringFilterGetExpression :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> m (Maybe Expression)
stringFilterGetExpression 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 StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_string_filter_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 StringFilterGetExpressionMethodInfo
instance (signature ~ (m (Maybe Gtk.Expression.Expression)), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterGetExpressionMethodInfo a signature where
    overloadedMethod = stringFilterGetExpression

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


#endif

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

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

-- | Returns whether the filter ignores case differences.
stringFilterGetIgnoreCase ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> m Bool
    -- ^ __Returns:__ true if the filter ignores case
stringFilterGetIgnoreCase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> m Bool
stringFilterGetIgnoreCase 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
    self' <- a -> IO (Ptr StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_string_filter_get_ignore_case self'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StringFilterGetIgnoreCaseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterGetIgnoreCaseMethodInfo a signature where
    overloadedMethod = stringFilterGetIgnoreCase

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


#endif

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

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

-- | Returns the match mode that the filter is using.
stringFilterGetMatchMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> m Gtk.Enums.StringFilterMatchMode
    -- ^ __Returns:__ the match mode of the filter
stringFilterGetMatchMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> m StringFilterMatchMode
stringFilterGetMatchMode a
self = IO StringFilterMatchMode -> m StringFilterMatchMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StringFilterMatchMode -> m StringFilterMatchMode)
-> IO StringFilterMatchMode -> m StringFilterMatchMode
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_string_filter_get_match_mode self'
    let result' = (Int -> StringFilterMatchMode
forall a. Enum a => Int -> a
toEnum (Int -> StringFilterMatchMode)
-> (CUInt -> Int) -> CUInt -> StringFilterMatchMode
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 StringFilterGetMatchModeMethodInfo
instance (signature ~ (m Gtk.Enums.StringFilterMatchMode), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterGetMatchModeMethodInfo a signature where
    overloadedMethod = stringFilterGetMatchMode

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


#endif

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

foreign import ccall "gtk_string_filter_get_search" gtk_string_filter_get_search :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    IO CString

-- | Gets the search term.
stringFilterGetSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the search term
stringFilterGetSearch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> m (Maybe Text)
stringFilterGetSearch a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_string_filter_get_search self'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        return result''
    touchManagedPtr self
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data StringFilterGetSearchMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterGetSearchMethodInfo a signature where
    overloadedMethod = stringFilterGetSearch

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


#endif

-- method StringFilter::set_expression
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string filter" , 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 "the expression" , 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_string_filter_set_expression" gtk_string_filter_set_expression :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    Ptr Gtk.Expression.Expression ->        -- expression : TInterface (Name {namespace = "Gtk", name = "Expression"})
    IO ()

-- | Sets the expression that the string filter uses to
-- obtain strings from items.
-- 
-- The expression must have a value type of @G_TYPE_STRING@.
stringFilterSetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a, Gtk.Expression.IsExpression b) =>
    a
    -- ^ /@self@/: a string filter
    -> Maybe (b)
    -- ^ /@expression@/: the expression
    -> m ()
stringFilterSetExpression :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsStringFilter a, IsExpression b) =>
a -> Maybe b -> m ()
stringFilterSetExpression 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 StringFilter)
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_string_filter_set_expression self' maybeExpression
    touchManagedPtr self
    whenJust expression touchManagedPtr
    return ()

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

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


#endif

-- method StringFilter::set_ignore_case
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string filter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ignore_case"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "true to ignore case"
--                 , 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_string_filter_set_ignore_case" gtk_string_filter_set_ignore_case :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    CInt ->                                 -- ignore_case : TBasicType TBoolean
    IO ()

-- | Sets whether the filter ignores case differences.
stringFilterSetIgnoreCase ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> Bool
    -- ^ /@ignoreCase@/: true to ignore case
    -> m ()
stringFilterSetIgnoreCase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> Bool -> m ()
stringFilterSetIgnoreCase 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
    self' <- a -> IO (Ptr StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let 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
    gtk_string_filter_set_ignore_case self' ignoreCase'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StringFilterSetIgnoreCaseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterSetIgnoreCaseMethodInfo a signature where
    overloadedMethod = stringFilterSetIgnoreCase

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


#endif

-- method StringFilter::set_match_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string filter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "StringFilterMatchMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new match mode" , 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_string_filter_set_match_mode" gtk_string_filter_set_match_mode :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gtk", name = "StringFilterMatchMode"})
    IO ()

-- | Sets the match mode for the filter.
stringFilterSetMatchMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> Gtk.Enums.StringFilterMatchMode
    -- ^ /@mode@/: the new match mode
    -> m ()
stringFilterSetMatchMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> StringFilterMatchMode -> m ()
stringFilterSetMatchMode a
self StringFilterMatchMode
mode = 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 StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (StringFilterMatchMode -> Int) -> StringFilterMatchMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringFilterMatchMode -> Int
forall a. Enum a => a -> Int
fromEnum) StringFilterMatchMode
mode
    gtk_string_filter_set_match_mode self' mode'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StringFilterSetMatchModeMethodInfo
instance (signature ~ (Gtk.Enums.StringFilterMatchMode -> m ()), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterSetMatchModeMethodInfo a signature where
    overloadedMethod = stringFilterSetMatchMode

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


#endif

-- method StringFilter::set_search
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string filter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "search"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to search for"
--                 , 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_string_filter_set_search" gtk_string_filter_set_search :: 
    Ptr StringFilter ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringFilter"})
    CString ->                              -- search : TBasicType TUTF8
    IO ()

-- | Sets the string to search for.
stringFilterSetSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringFilter a) =>
    a
    -- ^ /@self@/: a string filter
    -> Maybe (T.Text)
    -- ^ /@search@/: the string to search for
    -> m ()
stringFilterSetSearch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringFilter a) =>
a -> Maybe Text -> m ()
stringFilterSetSearch a
self Maybe Text
search = 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 StringFilter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    maybeSearch <- case search of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jSearch -> do
            jSearch' <- Text -> IO CString
textToCString Text
jSearch
            return jSearch'
    gtk_string_filter_set_search self' maybeSearch
    touchManagedPtr self
    freeMem maybeSearch
    return ()

#if defined(ENABLE_OVERLOADING)
data StringFilterSetSearchMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsStringFilter a) => O.OverloadedMethod StringFilterSetSearchMethodInfo a signature where
    overloadedMethod = stringFilterSetSearch

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


#endif