FindController.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.WebKit2.Objects.FindController
    ( 

-- * Exported types
    FindController(..)                      ,
    IsFindController                        ,
    toFindController                        ,
    noFindController                        ,


 -- * Methods
-- ** countMatches #method:countMatches#

#if ENABLE_OVERLOADING
    FindControllerCountMatchesMethodInfo    ,
#endif
    findControllerCountMatches              ,


-- ** getMaxMatchCount #method:getMaxMatchCount#

#if ENABLE_OVERLOADING
    FindControllerGetMaxMatchCountMethodInfo,
#endif
    findControllerGetMaxMatchCount          ,


-- ** getOptions #method:getOptions#

#if ENABLE_OVERLOADING
    FindControllerGetOptionsMethodInfo      ,
#endif
    findControllerGetOptions                ,


-- ** getSearchText #method:getSearchText#

#if ENABLE_OVERLOADING
    FindControllerGetSearchTextMethodInfo   ,
#endif
    findControllerGetSearchText             ,


-- ** getWebView #method:getWebView#

#if ENABLE_OVERLOADING
    FindControllerGetWebViewMethodInfo      ,
#endif
    findControllerGetWebView                ,


-- ** search #method:search#

#if ENABLE_OVERLOADING
    FindControllerSearchMethodInfo          ,
#endif
    findControllerSearch                    ,


-- ** searchFinish #method:searchFinish#

#if ENABLE_OVERLOADING
    FindControllerSearchFinishMethodInfo    ,
#endif
    findControllerSearchFinish              ,


-- ** searchNext #method:searchNext#

#if ENABLE_OVERLOADING
    FindControllerSearchNextMethodInfo      ,
#endif
    findControllerSearchNext                ,


-- ** searchPrevious #method:searchPrevious#

#if ENABLE_OVERLOADING
    FindControllerSearchPreviousMethodInfo  ,
#endif
    findControllerSearchPrevious            ,




 -- * Properties
-- ** maxMatchCount #attr:maxMatchCount#
{- | The maximum number of matches to report for a given search.
-}
#if ENABLE_OVERLOADING
    FindControllerMaxMatchCountPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
    findControllerMaxMatchCount             ,
#endif
    getFindControllerMaxMatchCount          ,


-- ** options #attr:options#
{- | The options to be used in the search operation.
-}
#if ENABLE_OVERLOADING
    FindControllerOptionsPropertyInfo       ,
#endif
#if ENABLE_OVERLOADING
    findControllerOptions                   ,
#endif
    getFindControllerOptions                ,


-- ** text #attr:text#
{- | The current search text for this 'GI.WebKit2.Objects.FindController.FindController'.
-}
#if ENABLE_OVERLOADING
    FindControllerTextPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    findControllerText                      ,
#endif
    getFindControllerText                   ,


-- ** webView #attr:webView#
{- | The 'GI.WebKit2.Objects.WebView.WebView' this controller is associated to.
-}
#if ENABLE_OVERLOADING
    FindControllerWebViewPropertyInfo       ,
#endif
    constructFindControllerWebView          ,
#if ENABLE_OVERLOADING
    findControllerWebView                   ,
#endif
    getFindControllerWebView                ,




 -- * Signals
-- ** countedMatches #signal:countedMatches#

    C_FindControllerCountedMatchesCallback  ,
    FindControllerCountedMatchesCallback    ,
#if ENABLE_OVERLOADING
    FindControllerCountedMatchesSignalInfo  ,
#endif
    afterFindControllerCountedMatches       ,
    genClosure_FindControllerCountedMatches ,
    mk_FindControllerCountedMatchesCallback ,
    noFindControllerCountedMatchesCallback  ,
    onFindControllerCountedMatches          ,
    wrap_FindControllerCountedMatchesCallback,


-- ** failedToFindText #signal:failedToFindText#

    C_FindControllerFailedToFindTextCallback,
    FindControllerFailedToFindTextCallback  ,
#if ENABLE_OVERLOADING
    FindControllerFailedToFindTextSignalInfo,
#endif
    afterFindControllerFailedToFindText     ,
    genClosure_FindControllerFailedToFindText,
    mk_FindControllerFailedToFindTextCallback,
    noFindControllerFailedToFindTextCallback,
    onFindControllerFailedToFindText        ,
    wrap_FindControllerFailedToFindTextCallback,


-- ** foundText #signal:foundText#

    C_FindControllerFoundTextCallback       ,
    FindControllerFoundTextCallback         ,
#if ENABLE_OVERLOADING
    FindControllerFoundTextSignalInfo       ,
#endif
    afterFindControllerFoundText            ,
    genClosure_FindControllerFoundText      ,
    mk_FindControllerFoundTextCallback      ,
    noFindControllerFoundTextCallback       ,
    onFindControllerFoundText               ,
    wrap_FindControllerFoundTextCallback    ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView

-- | Memory-managed wrapper type.
newtype FindController = FindController (ManagedPtr FindController)
foreign import ccall "webkit_find_controller_get_type"
    c_webkit_find_controller_get_type :: IO GType

instance GObject FindController where
    gobjectType = c_webkit_find_controller_get_type
    

-- | Type class for types which can be safely cast to `FindController`, for instance with `toFindController`.
class (GObject o, O.IsDescendantOf FindController o) => IsFindController o
instance (GObject o, O.IsDescendantOf FindController o) => IsFindController o

instance O.HasParentTypes FindController
type instance O.ParentTypes FindController = '[GObject.Object.Object]

-- | Cast to `FindController`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toFindController :: (MonadIO m, IsFindController o) => o -> m FindController
toFindController = liftIO . unsafeCastTo FindController

-- | A convenience alias for `Nothing` :: `Maybe` `FindController`.
noFindController :: Maybe FindController
noFindController = Nothing

#if ENABLE_OVERLOADING
type family ResolveFindControllerMethod (t :: Symbol) (o :: *) :: * where
    ResolveFindControllerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFindControllerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFindControllerMethod "countMatches" o = FindControllerCountMatchesMethodInfo
    ResolveFindControllerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFindControllerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFindControllerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveFindControllerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFindControllerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFindControllerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFindControllerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFindControllerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFindControllerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFindControllerMethod "search" o = FindControllerSearchMethodInfo
    ResolveFindControllerMethod "searchFinish" o = FindControllerSearchFinishMethodInfo
    ResolveFindControllerMethod "searchNext" o = FindControllerSearchNextMethodInfo
    ResolveFindControllerMethod "searchPrevious" o = FindControllerSearchPreviousMethodInfo
    ResolveFindControllerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFindControllerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFindControllerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFindControllerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFindControllerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFindControllerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFindControllerMethod "getMaxMatchCount" o = FindControllerGetMaxMatchCountMethodInfo
    ResolveFindControllerMethod "getOptions" o = FindControllerGetOptionsMethodInfo
    ResolveFindControllerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFindControllerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFindControllerMethod "getSearchText" o = FindControllerGetSearchTextMethodInfo
    ResolveFindControllerMethod "getWebView" o = FindControllerGetWebViewMethodInfo
    ResolveFindControllerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFindControllerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFindControllerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFindControllerMethod t FindController, O.MethodInfo info FindController p) => OL.IsLabel t (FindController -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- signal FindController::counted-matches
{- |
This signal is emitted when the 'GI.WebKit2.Objects.FindController.FindController' has
counted the number of matches for a given text after a call
to 'GI.WebKit2.Objects.FindController.findControllerCountMatches'.
-}
type FindControllerCountedMatchesCallback =
    Word32
    {- ^ /@matchCount@/: the number of matches of the search text -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerCountedMatchesCallback`@.
noFindControllerCountedMatchesCallback :: Maybe FindControllerCountedMatchesCallback
noFindControllerCountedMatchesCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_FindControllerCountedMatchesCallback =
    Ptr () ->                               -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_FindControllerCountedMatchesCallback`.
foreign import ccall "wrapper"
    mk_FindControllerCountedMatchesCallback :: C_FindControllerCountedMatchesCallback -> IO (FunPtr C_FindControllerCountedMatchesCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_FindControllerCountedMatches :: MonadIO m => FindControllerCountedMatchesCallback -> m (GClosure C_FindControllerCountedMatchesCallback)
genClosure_FindControllerCountedMatches cb = liftIO $ do
    let cb' = wrap_FindControllerCountedMatchesCallback cb
    mk_FindControllerCountedMatchesCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `FindControllerCountedMatchesCallback` into a `C_FindControllerCountedMatchesCallback`.
wrap_FindControllerCountedMatchesCallback ::
    FindControllerCountedMatchesCallback ->
    C_FindControllerCountedMatchesCallback
wrap_FindControllerCountedMatchesCallback _cb _ matchCount _ = do
    _cb  matchCount


{- |
Connect a signal handler for the “@counted-matches@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' findController #countedMatches callback
@
-}
onFindControllerCountedMatches :: (IsFindController a, MonadIO m) => a -> FindControllerCountedMatchesCallback -> m SignalHandlerId
onFindControllerCountedMatches obj cb = liftIO $ do
    let cb' = wrap_FindControllerCountedMatchesCallback cb
    cb'' <- mk_FindControllerCountedMatchesCallback cb'
    connectSignalFunPtr obj "counted-matches" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@counted-matches@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' findController #countedMatches callback
@
-}
afterFindControllerCountedMatches :: (IsFindController a, MonadIO m) => a -> FindControllerCountedMatchesCallback -> m SignalHandlerId
afterFindControllerCountedMatches obj cb = liftIO $ do
    let cb' = wrap_FindControllerCountedMatchesCallback cb
    cb'' <- mk_FindControllerCountedMatchesCallback cb'
    connectSignalFunPtr obj "counted-matches" cb'' SignalConnectAfter


-- signal FindController::failed-to-find-text
{- |
This signal is emitted when a search operation does not find
any result for the given text. It will be issued if the text
is not found asynchronously after a call to
'GI.WebKit2.Objects.FindController.findControllerSearch', 'GI.WebKit2.Objects.FindController.findControllerSearchNext'
or 'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'.
-}
type FindControllerFailedToFindTextCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerFailedToFindTextCallback`@.
noFindControllerFailedToFindTextCallback :: Maybe FindControllerFailedToFindTextCallback
noFindControllerFailedToFindTextCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_FindControllerFailedToFindTextCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_FindControllerFailedToFindTextCallback`.
foreign import ccall "wrapper"
    mk_FindControllerFailedToFindTextCallback :: C_FindControllerFailedToFindTextCallback -> IO (FunPtr C_FindControllerFailedToFindTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_FindControllerFailedToFindText :: MonadIO m => FindControllerFailedToFindTextCallback -> m (GClosure C_FindControllerFailedToFindTextCallback)
genClosure_FindControllerFailedToFindText cb = liftIO $ do
    let cb' = wrap_FindControllerFailedToFindTextCallback cb
    mk_FindControllerFailedToFindTextCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `FindControllerFailedToFindTextCallback` into a `C_FindControllerFailedToFindTextCallback`.
wrap_FindControllerFailedToFindTextCallback ::
    FindControllerFailedToFindTextCallback ->
    C_FindControllerFailedToFindTextCallback
wrap_FindControllerFailedToFindTextCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@failed-to-find-text@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' findController #failedToFindText callback
@
-}
onFindControllerFailedToFindText :: (IsFindController a, MonadIO m) => a -> FindControllerFailedToFindTextCallback -> m SignalHandlerId
onFindControllerFailedToFindText obj cb = liftIO $ do
    let cb' = wrap_FindControllerFailedToFindTextCallback cb
    cb'' <- mk_FindControllerFailedToFindTextCallback cb'
    connectSignalFunPtr obj "failed-to-find-text" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@failed-to-find-text@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' findController #failedToFindText callback
@
-}
afterFindControllerFailedToFindText :: (IsFindController a, MonadIO m) => a -> FindControllerFailedToFindTextCallback -> m SignalHandlerId
afterFindControllerFailedToFindText obj cb = liftIO $ do
    let cb' = wrap_FindControllerFailedToFindTextCallback cb
    cb'' <- mk_FindControllerFailedToFindTextCallback cb'
    connectSignalFunPtr obj "failed-to-find-text" cb'' SignalConnectAfter


-- signal FindController::found-text
{- |
This signal is emitted when a given text is found in the web
page text. It will be issued if the text is found
asynchronously after a call to 'GI.WebKit2.Objects.FindController.findControllerSearch',
'GI.WebKit2.Objects.FindController.findControllerSearchNext' or
'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'.
-}
type FindControllerFoundTextCallback =
    Word32
    {- ^ /@matchCount@/: the number of matches found of the search text -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerFoundTextCallback`@.
noFindControllerFoundTextCallback :: Maybe FindControllerFoundTextCallback
noFindControllerFoundTextCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_FindControllerFoundTextCallback =
    Ptr () ->                               -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_FindControllerFoundTextCallback`.
foreign import ccall "wrapper"
    mk_FindControllerFoundTextCallback :: C_FindControllerFoundTextCallback -> IO (FunPtr C_FindControllerFoundTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_FindControllerFoundText :: MonadIO m => FindControllerFoundTextCallback -> m (GClosure C_FindControllerFoundTextCallback)
genClosure_FindControllerFoundText cb = liftIO $ do
    let cb' = wrap_FindControllerFoundTextCallback cb
    mk_FindControllerFoundTextCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `FindControllerFoundTextCallback` into a `C_FindControllerFoundTextCallback`.
wrap_FindControllerFoundTextCallback ::
    FindControllerFoundTextCallback ->
    C_FindControllerFoundTextCallback
wrap_FindControllerFoundTextCallback _cb _ matchCount _ = do
    _cb  matchCount


{- |
Connect a signal handler for the “@found-text@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' findController #foundText callback
@
-}
onFindControllerFoundText :: (IsFindController a, MonadIO m) => a -> FindControllerFoundTextCallback -> m SignalHandlerId
onFindControllerFoundText obj cb = liftIO $ do
    let cb' = wrap_FindControllerFoundTextCallback cb
    cb'' <- mk_FindControllerFoundTextCallback cb'
    connectSignalFunPtr obj "found-text" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@found-text@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' findController #foundText callback
@
-}
afterFindControllerFoundText :: (IsFindController a, MonadIO m) => a -> FindControllerFoundTextCallback -> m SignalHandlerId
afterFindControllerFoundText obj cb = liftIO $ do
    let cb' = wrap_FindControllerFoundTextCallback cb
    cb'' <- mk_FindControllerFoundTextCallback cb'
    connectSignalFunPtr obj "found-text" cb'' SignalConnectAfter


-- VVV Prop "max-match-count"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@max-match-count@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' findController #maxMatchCount
@
-}
getFindControllerMaxMatchCount :: (MonadIO m, IsFindController o) => o -> m Word32
getFindControllerMaxMatchCount obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "max-match-count"

#if ENABLE_OVERLOADING
data FindControllerMaxMatchCountPropertyInfo
instance AttrInfo FindControllerMaxMatchCountPropertyInfo where
    type AttrAllowedOps FindControllerMaxMatchCountPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FindControllerMaxMatchCountPropertyInfo = (~) ()
    type AttrBaseTypeConstraint FindControllerMaxMatchCountPropertyInfo = IsFindController
    type AttrGetType FindControllerMaxMatchCountPropertyInfo = Word32
    type AttrLabel FindControllerMaxMatchCountPropertyInfo = "max-match-count"
    type AttrOrigin FindControllerMaxMatchCountPropertyInfo = FindController
    attrGet _ = getFindControllerMaxMatchCount
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "options"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "FindOptions"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@options@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' findController #options
@
-}
getFindControllerOptions :: (MonadIO m, IsFindController o) => o -> m [WebKit2.Flags.FindOptions]
getFindControllerOptions obj = liftIO $ B.Properties.getObjectPropertyFlags obj "options"

#if ENABLE_OVERLOADING
data FindControllerOptionsPropertyInfo
instance AttrInfo FindControllerOptionsPropertyInfo where
    type AttrAllowedOps FindControllerOptionsPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FindControllerOptionsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint FindControllerOptionsPropertyInfo = IsFindController
    type AttrGetType FindControllerOptionsPropertyInfo = [WebKit2.Flags.FindOptions]
    type AttrLabel FindControllerOptionsPropertyInfo = "options"
    type AttrOrigin FindControllerOptionsPropertyInfo = FindController
    attrGet _ = getFindControllerOptions
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@text@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' findController #text
@
-}
getFindControllerText :: (MonadIO m, IsFindController o) => o -> m (Maybe T.Text)
getFindControllerText obj = liftIO $ B.Properties.getObjectPropertyString obj "text"

#if ENABLE_OVERLOADING
data FindControllerTextPropertyInfo
instance AttrInfo FindControllerTextPropertyInfo where
    type AttrAllowedOps FindControllerTextPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FindControllerTextPropertyInfo = (~) ()
    type AttrBaseTypeConstraint FindControllerTextPropertyInfo = IsFindController
    type AttrGetType FindControllerTextPropertyInfo = (Maybe T.Text)
    type AttrLabel FindControllerTextPropertyInfo = "text"
    type AttrOrigin FindControllerTextPropertyInfo = FindController
    attrGet _ = getFindControllerText
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "web-view"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "WebView"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@web-view@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' findController #webView
@
-}
getFindControllerWebView :: (MonadIO m, IsFindController o) => o -> m WebKit2.WebView.WebView
getFindControllerWebView obj = liftIO $ checkUnexpectedNothing "getFindControllerWebView" $ B.Properties.getObjectPropertyObject obj "web-view" WebKit2.WebView.WebView

{- |
Construct a `GValueConstruct` with valid value for the “@web-view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructFindControllerWebView :: (IsFindController o, WebKit2.WebView.IsWebView a) => a -> IO (GValueConstruct o)
constructFindControllerWebView val = B.Properties.constructObjectPropertyObject "web-view" (Just val)

#if ENABLE_OVERLOADING
data FindControllerWebViewPropertyInfo
instance AttrInfo FindControllerWebViewPropertyInfo where
    type AttrAllowedOps FindControllerWebViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FindControllerWebViewPropertyInfo = WebKit2.WebView.IsWebView
    type AttrBaseTypeConstraint FindControllerWebViewPropertyInfo = IsFindController
    type AttrGetType FindControllerWebViewPropertyInfo = WebKit2.WebView.WebView
    type AttrLabel FindControllerWebViewPropertyInfo = "web-view"
    type AttrOrigin FindControllerWebViewPropertyInfo = FindController
    attrGet _ = getFindControllerWebView
    attrSet _ = undefined
    attrConstruct _ = constructFindControllerWebView
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList FindController
type instance O.AttributeList FindController = FindControllerAttributeList
type FindControllerAttributeList = ('[ '("maxMatchCount", FindControllerMaxMatchCountPropertyInfo), '("options", FindControllerOptionsPropertyInfo), '("text", FindControllerTextPropertyInfo), '("webView", FindControllerWebViewPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
findControllerMaxMatchCount :: AttrLabelProxy "maxMatchCount"
findControllerMaxMatchCount = AttrLabelProxy

findControllerOptions :: AttrLabelProxy "options"
findControllerOptions = AttrLabelProxy

findControllerText :: AttrLabelProxy "text"
findControllerText = AttrLabelProxy

findControllerWebView :: AttrLabelProxy "webView"
findControllerWebView = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data FindControllerCountedMatchesSignalInfo
instance SignalInfo FindControllerCountedMatchesSignalInfo where
    type HaskellCallbackType FindControllerCountedMatchesSignalInfo = FindControllerCountedMatchesCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_FindControllerCountedMatchesCallback cb
        cb'' <- mk_FindControllerCountedMatchesCallback cb'
        connectSignalFunPtr obj "counted-matches" cb'' connectMode

data FindControllerFailedToFindTextSignalInfo
instance SignalInfo FindControllerFailedToFindTextSignalInfo where
    type HaskellCallbackType FindControllerFailedToFindTextSignalInfo = FindControllerFailedToFindTextCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_FindControllerFailedToFindTextCallback cb
        cb'' <- mk_FindControllerFailedToFindTextCallback cb'
        connectSignalFunPtr obj "failed-to-find-text" cb'' connectMode

data FindControllerFoundTextSignalInfo
instance SignalInfo FindControllerFoundTextSignalInfo where
    type HaskellCallbackType FindControllerFoundTextSignalInfo = FindControllerFoundTextCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_FindControllerFoundTextCallback cb
        cb'' <- mk_FindControllerFoundTextCallback cb'
        connectSignalFunPtr obj "found-text" cb'' connectMode

type instance O.SignalList FindController = FindControllerSignalList
type FindControllerSignalList = ('[ '("countedMatches", FindControllerCountedMatchesSignalInfo), '("failedToFindText", FindControllerFailedToFindTextSignalInfo), '("foundText", FindControllerFoundTextSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method FindController::count_matches
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to look for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find_options", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask with the #WebKitFindOptions used in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_match_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum number of matches allowed in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_count_matches" webkit_find_controller_count_matches :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    CString ->                              -- search_text : TBasicType TUTF8
    Word32 ->                               -- find_options : TBasicType TUInt32
    Word32 ->                               -- max_match_count : TBasicType TUInt
    IO ()

{- |
Counts the number of matches for /@searchText@/ found in the
'GI.WebKit2.Objects.WebView.WebView' with the provided /@findOptions@/. The number of
matches will be provided by the
'GI.WebKit2.Objects.FindController.FindController'::@/counted-matches/@ signal.
-}
findControllerCountMatches ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> T.Text
    {- ^ /@searchText@/: the text to look for -}
    -> Word32
    {- ^ /@findOptions@/: a bitmask with the 'GI.WebKit2.Flags.FindOptions' used in the search -}
    -> Word32
    {- ^ /@maxMatchCount@/: the maximum number of matches allowed in the search -}
    -> m ()
findControllerCountMatches findController searchText findOptions maxMatchCount = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    searchText' <- textToCString searchText
    webkit_find_controller_count_matches findController' searchText' findOptions maxMatchCount
    touchManagedPtr findController
    freeMem searchText'
    return ()

#if ENABLE_OVERLOADING
data FindControllerCountMatchesMethodInfo
instance (signature ~ (T.Text -> Word32 -> Word32 -> m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerCountMatchesMethodInfo a signature where
    overloadedMethod _ = findControllerCountMatches

#endif

-- method FindController::get_max_match_count
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_get_max_match_count" webkit_find_controller_get_max_match_count :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO Word32

{- |
Gets the maximum number of matches to report during a text
lookup. This number is passed as the last argument of
'GI.WebKit2.Objects.FindController.findControllerSearch' or
'GI.WebKit2.Objects.FindController.findControllerCountMatches'.
-}
findControllerGetMaxMatchCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m Word32
    {- ^ __Returns:__ the maximum number of matches to report. -}
findControllerGetMaxMatchCount findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    result <- webkit_find_controller_get_max_match_count findController'
    touchManagedPtr findController
    return result

#if ENABLE_OVERLOADING
data FindControllerGetMaxMatchCountMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetMaxMatchCountMethodInfo a signature where
    overloadedMethod _ = findControllerGetMaxMatchCount

#endif

-- method FindController::get_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_get_options" webkit_find_controller_get_options :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO Word32

{- |
Gets a bitmask containing the 'GI.WebKit2.Flags.FindOptions' associated with
the current search.
-}
findControllerGetOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m Word32
    {- ^ __Returns:__ a bitmask containing the 'GI.WebKit2.Flags.FindOptions' associated
with the current search. -}
findControllerGetOptions findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    result <- webkit_find_controller_get_options findController'
    touchManagedPtr findController
    return result

#if ENABLE_OVERLOADING
data FindControllerGetOptionsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetOptionsMethodInfo a signature where
    overloadedMethod _ = findControllerGetOptions

#endif

-- method FindController::get_search_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_get_search_text" webkit_find_controller_get_search_text :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO CString

{- |
Gets the text that /@findController@/ is currently searching
for. This text is passed to either
'GI.WebKit2.Objects.FindController.findControllerSearch' or
'GI.WebKit2.Objects.FindController.findControllerCountMatches'.
-}
findControllerGetSearchText ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m T.Text
    {- ^ __Returns:__ the text to look for in the 'GI.WebKit2.Objects.WebView.WebView'. -}
findControllerGetSearchText findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    result <- webkit_find_controller_get_search_text findController'
    checkUnexpectedReturnNULL "findControllerGetSearchText" result
    result' <- cstringToText result
    touchManagedPtr findController
    return result'

#if ENABLE_OVERLOADING
data FindControllerGetSearchTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetSearchTextMethodInfo a signature where
    overloadedMethod _ = findControllerGetSearchText

#endif

-- method FindController::get_web_view
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_get_web_view" webkit_find_controller_get_web_view :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO (Ptr WebKit2.WebView.WebView)

{- |
Gets the 'GI.WebKit2.Objects.WebView.WebView' this find controller is associated to. Do
not dereference the returned instance as it belongs to the
'GI.WebKit2.Objects.FindController.FindController'.
-}
findControllerGetWebView ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m WebKit2.WebView.WebView
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebView.WebView'. -}
findControllerGetWebView findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    result <- webkit_find_controller_get_web_view findController'
    checkUnexpectedReturnNULL "findControllerGetWebView" result
    result' <- (newObject WebKit2.WebView.WebView) result
    touchManagedPtr findController
    return result'

#if ENABLE_OVERLOADING
data FindControllerGetWebViewMethodInfo
instance (signature ~ (m WebKit2.WebView.WebView), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetWebViewMethodInfo a signature where
    overloadedMethod _ = findControllerGetWebView

#endif

-- method FindController::search
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to look for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find_options", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask with the #WebKitFindOptions used in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_match_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum number of matches allowed in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_search" webkit_find_controller_search :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    CString ->                              -- search_text : TBasicType TUTF8
    Word32 ->                               -- find_options : TBasicType TUInt32
    Word32 ->                               -- max_match_count : TBasicType TUInt
    IO ()

{- |
Looks for /@searchText@/ in the 'GI.WebKit2.Objects.WebView.WebView' associated with
/@findController@/ since the beginning of the document highlighting
up to /@maxMatchCount@/ matches. The outcome of the search will be
asynchronously provided by the 'GI.WebKit2.Objects.FindController.FindController'::@/found-text/@
and 'GI.WebKit2.Objects.FindController.FindController'::@/failed-to-find-text/@ signals.

To look for the next or previous occurrences of the same text
with the same find options use 'GI.WebKit2.Objects.FindController.findControllerSearchNext'
and\/or 'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'. The
'GI.WebKit2.Objects.FindController.FindController' will use the same text and options for the
following searches unless they are modified by another call to this
method.

Note that if the number of matches is higher than /@maxMatchCount@/
then 'GI.WebKit2.Objects.FindController.FindController'::@/found-text/@ will report @/G_MAXUINT/@ matches
instead of the actual number.

Callers should call 'GI.WebKit2.Objects.FindController.findControllerSearchFinish' to
finish the current search operation.
-}
findControllerSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> T.Text
    {- ^ /@searchText@/: the text to look for -}
    -> Word32
    {- ^ /@findOptions@/: a bitmask with the 'GI.WebKit2.Flags.FindOptions' used in the search -}
    -> Word32
    {- ^ /@maxMatchCount@/: the maximum number of matches allowed in the search -}
    -> m ()
findControllerSearch findController searchText findOptions maxMatchCount = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    searchText' <- textToCString searchText
    webkit_find_controller_search findController' searchText' findOptions maxMatchCount
    touchManagedPtr findController
    freeMem searchText'
    return ()

#if ENABLE_OVERLOADING
data FindControllerSearchMethodInfo
instance (signature ~ (T.Text -> Word32 -> Word32 -> m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchMethodInfo a signature where
    overloadedMethod _ = findControllerSearch

#endif

-- method FindController::search_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_search_finish" webkit_find_controller_search_finish :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO ()

{- |
Finishes a find operation started by
'GI.WebKit2.Objects.FindController.findControllerSearch'. It will basically unhighlight
every text match found.

This method will be typically called when the search UI is
closed\/hidden by the client application.
-}
findControllerSearchFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: a 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m ()
findControllerSearchFinish findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    webkit_find_controller_search_finish findController'
    touchManagedPtr findController
    return ()

#if ENABLE_OVERLOADING
data FindControllerSearchFinishMethodInfo
instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchFinishMethodInfo a signature where
    overloadedMethod _ = findControllerSearchFinish

#endif

-- method FindController::search_next
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_search_next" webkit_find_controller_search_next :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO ()

{- |
Looks for the next occurrence of the search text.

Calling this method before 'GI.WebKit2.Objects.FindController.findControllerSearch' or
'GI.WebKit2.Objects.FindController.findControllerCountMatches' is a programming error.
-}
findControllerSearchNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m ()
findControllerSearchNext findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    webkit_find_controller_search_next findController'
    touchManagedPtr findController
    return ()

#if ENABLE_OVERLOADING
data FindControllerSearchNextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchNextMethodInfo a signature where
    overloadedMethod _ = findControllerSearchNext

#endif

-- method FindController::search_previous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_find_controller_search_previous" webkit_find_controller_search_previous :: 
    Ptr FindController ->                   -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"})
    IO ()

{- |
Looks for the previous occurrence of the search text.

Calling this method before 'GI.WebKit2.Objects.FindController.findControllerSearch' or
'GI.WebKit2.Objects.FindController.findControllerCountMatches' is a programming error.
-}
findControllerSearchPrevious ::
    (B.CallStack.HasCallStack, MonadIO m, IsFindController a) =>
    a
    {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -}
    -> m ()
findControllerSearchPrevious findController = liftIO $ do
    findController' <- unsafeManagedPtrCastPtr findController
    webkit_find_controller_search_previous findController'
    touchManagedPtr findController
    return ()

#if ENABLE_OVERLOADING
data FindControllerSearchPreviousMethodInfo
instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchPreviousMethodInfo a signature where
    overloadedMethod _ = findControllerSearchPrevious

#endif