{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.WebKit2.Objects.WebInspector
    ( 

-- * Exported types
    WebInspector(..)                        ,
    IsWebInspector                          ,
    toWebInspector                          ,
    noWebInspector                          ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveWebInspectorMethod               ,
#endif


-- ** attach #method:attach#

#if defined(ENABLE_OVERLOADING)
    WebInspectorAttachMethodInfo            ,
#endif
    webInspectorAttach                      ,


-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    WebInspectorCloseMethodInfo             ,
#endif
    webInspectorClose                       ,


-- ** detach #method:detach#

#if defined(ENABLE_OVERLOADING)
    WebInspectorDetachMethodInfo            ,
#endif
    webInspectorDetach                      ,


-- ** getAttachedHeight #method:getAttachedHeight#

#if defined(ENABLE_OVERLOADING)
    WebInspectorGetAttachedHeightMethodInfo ,
#endif
    webInspectorGetAttachedHeight           ,


-- ** getCanAttach #method:getCanAttach#

#if defined(ENABLE_OVERLOADING)
    WebInspectorGetCanAttachMethodInfo      ,
#endif
    webInspectorGetCanAttach                ,


-- ** getInspectedUri #method:getInspectedUri#

#if defined(ENABLE_OVERLOADING)
    WebInspectorGetInspectedUriMethodInfo   ,
#endif
    webInspectorGetInspectedUri             ,


-- ** getWebView #method:getWebView#

#if defined(ENABLE_OVERLOADING)
    WebInspectorGetWebViewMethodInfo        ,
#endif
    webInspectorGetWebView                  ,


-- ** isAttached #method:isAttached#

#if defined(ENABLE_OVERLOADING)
    WebInspectorIsAttachedMethodInfo        ,
#endif
    webInspectorIsAttached                  ,


-- ** show #method:show#

#if defined(ENABLE_OVERLOADING)
    WebInspectorShowMethodInfo              ,
#endif
    webInspectorShow                        ,




 -- * Properties
-- ** attachedHeight #attr:attachedHeight#
-- | The height that the inspector view should have when it is attached.

#if defined(ENABLE_OVERLOADING)
    WebInspectorAttachedHeightPropertyInfo  ,
#endif
    getWebInspectorAttachedHeight           ,
#if defined(ENABLE_OVERLOADING)
    webInspectorAttachedHeight              ,
#endif


-- ** canAttach #attr:canAttach#
-- | Whether the /@inspector@/ can be attached to the same window that contains
-- the inspected view.
-- 
-- /Since: 2.8/

#if defined(ENABLE_OVERLOADING)
    WebInspectorCanAttachPropertyInfo       ,
#endif
    getWebInspectorCanAttach                ,
#if defined(ENABLE_OVERLOADING)
    webInspectorCanAttach                   ,
#endif


-- ** inspectedUri #attr:inspectedUri#
-- | The URI that is currently being inspected.

#if defined(ENABLE_OVERLOADING)
    WebInspectorInspectedUriPropertyInfo    ,
#endif
    getWebInspectorInspectedUri             ,
#if defined(ENABLE_OVERLOADING)
    webInspectorInspectedUri                ,
#endif




 -- * Signals
-- ** attach #signal:attach#

    C_WebInspectorAttachCallback            ,
    WebInspectorAttachCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebInspectorAttachSignalInfo            ,
#endif
    afterWebInspectorAttach                 ,
    genClosure_WebInspectorAttach           ,
    mk_WebInspectorAttachCallback           ,
    noWebInspectorAttachCallback            ,
    onWebInspectorAttach                    ,
    wrap_WebInspectorAttachCallback         ,


-- ** bringToFront #signal:bringToFront#

    C_WebInspectorBringToFrontCallback      ,
    WebInspectorBringToFrontCallback        ,
#if defined(ENABLE_OVERLOADING)
    WebInspectorBringToFrontSignalInfo      ,
#endif
    afterWebInspectorBringToFront           ,
    genClosure_WebInspectorBringToFront     ,
    mk_WebInspectorBringToFrontCallback     ,
    noWebInspectorBringToFrontCallback      ,
    onWebInspectorBringToFront              ,
    wrap_WebInspectorBringToFrontCallback   ,


-- ** closed #signal:closed#

    C_WebInspectorClosedCallback            ,
    WebInspectorClosedCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebInspectorClosedSignalInfo            ,
#endif
    afterWebInspectorClosed                 ,
    genClosure_WebInspectorClosed           ,
    mk_WebInspectorClosedCallback           ,
    noWebInspectorClosedCallback            ,
    onWebInspectorClosed                    ,
    wrap_WebInspectorClosedCallback         ,


-- ** detach #signal:detach#

    C_WebInspectorDetachCallback            ,
    WebInspectorDetachCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebInspectorDetachSignalInfo            ,
#endif
    afterWebInspectorDetach                 ,
    genClosure_WebInspectorDetach           ,
    mk_WebInspectorDetachCallback           ,
    noWebInspectorDetachCallback            ,
    onWebInspectorDetach                    ,
    wrap_WebInspectorDetachCallback         ,


-- ** openWindow #signal:openWindow#

    C_WebInspectorOpenWindowCallback        ,
    WebInspectorOpenWindowCallback          ,
#if defined(ENABLE_OVERLOADING)
    WebInspectorOpenWindowSignalInfo        ,
#endif
    afterWebInspectorOpenWindow             ,
    genClosure_WebInspectorOpenWindow       ,
    mk_WebInspectorOpenWindowCallback       ,
    noWebInspectorOpenWindowCallback        ,
    onWebInspectorOpenWindow                ,
    wrap_WebInspectorOpenWindowCallback     ,




    ) 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.GI.Base.Signals as B.Signals
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.Objects.WebViewBase as WebKit2.WebViewBase

-- | Memory-managed wrapper type.
newtype WebInspector = WebInspector (ManagedPtr WebInspector)
    deriving (WebInspector -> WebInspector -> Bool
(WebInspector -> WebInspector -> Bool)
-> (WebInspector -> WebInspector -> Bool) -> Eq WebInspector
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WebInspector -> WebInspector -> Bool
$c/= :: WebInspector -> WebInspector -> Bool
== :: WebInspector -> WebInspector -> Bool
$c== :: WebInspector -> WebInspector -> Bool
Eq)
foreign import ccall "webkit_web_inspector_get_type"
    c_webkit_web_inspector_get_type :: IO GType

instance GObject WebInspector where
    gobjectType :: IO GType
gobjectType = IO GType
c_webkit_web_inspector_get_type
    

-- | Convert 'WebInspector' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue WebInspector where
    toGValue :: WebInspector -> IO GValue
toGValue o :: WebInspector
o = do
        GType
gtype <- IO GType
c_webkit_web_inspector_get_type
        WebInspector -> (Ptr WebInspector -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WebInspector
o (GType
-> (GValue -> Ptr WebInspector -> IO ())
-> Ptr WebInspector
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr WebInspector -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO WebInspector
fromGValue gv :: GValue
gv = do
        Ptr WebInspector
ptr <- GValue -> IO (Ptr WebInspector)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr WebInspector)
        (ManagedPtr WebInspector -> WebInspector)
-> Ptr WebInspector -> IO WebInspector
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr WebInspector -> WebInspector
WebInspector Ptr WebInspector
ptr
        
    

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

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

-- | Cast to `WebInspector`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toWebInspector :: (MonadIO m, IsWebInspector o) => o -> m WebInspector
toWebInspector :: o -> m WebInspector
toWebInspector = IO WebInspector -> m WebInspector
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WebInspector -> m WebInspector)
-> (o -> IO WebInspector) -> o -> m WebInspector
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr WebInspector -> WebInspector) -> o -> IO WebInspector
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr WebInspector -> WebInspector
WebInspector

-- | A convenience alias for `Nothing` :: `Maybe` `WebInspector`.
noWebInspector :: Maybe WebInspector
noWebInspector :: Maybe WebInspector
noWebInspector = Maybe WebInspector
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveWebInspectorMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebInspectorMethod "attach" o = WebInspectorAttachMethodInfo
    ResolveWebInspectorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebInspectorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebInspectorMethod "close" o = WebInspectorCloseMethodInfo
    ResolveWebInspectorMethod "detach" o = WebInspectorDetachMethodInfo
    ResolveWebInspectorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebInspectorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebInspectorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWebInspectorMethod "isAttached" o = WebInspectorIsAttachedMethodInfo
    ResolveWebInspectorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebInspectorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebInspectorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebInspectorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebInspectorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebInspectorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebInspectorMethod "show" o = WebInspectorShowMethodInfo
    ResolveWebInspectorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebInspectorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebInspectorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebInspectorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebInspectorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebInspectorMethod "getAttachedHeight" o = WebInspectorGetAttachedHeightMethodInfo
    ResolveWebInspectorMethod "getCanAttach" o = WebInspectorGetCanAttachMethodInfo
    ResolveWebInspectorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebInspectorMethod "getInspectedUri" o = WebInspectorGetInspectedUriMethodInfo
    ResolveWebInspectorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebInspectorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebInspectorMethod "getWebView" o = WebInspectorGetWebViewMethodInfo
    ResolveWebInspectorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebInspectorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveWebInspectorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebInspectorMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal WebInspector::attach
-- | Emitted when the inspector is requested to be attached to the window
-- where the inspected web view is.
-- If this signal is not handled the inspector view will be automatically
-- attached to the inspected view, so you only need to handle this signal
-- if you want to attach the inspector view yourself (for example, to add
-- the inspector view to a browser tab).
-- 
-- To prevent the inspector view from being attached you can connect to this
-- signal and simply return 'P.True'.
type WebInspectorAttachCallback =
    IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the event.
    --    'P.False' to propagate the event further.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorAttachCallback`@.
noWebInspectorAttachCallback :: Maybe WebInspectorAttachCallback
noWebInspectorAttachCallback :: Maybe WebInspectorAttachCallback
noWebInspectorAttachCallback = Maybe WebInspectorAttachCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebInspectorAttach :: MonadIO m => WebInspectorAttachCallback -> m (GClosure C_WebInspectorAttachCallback)
genClosure_WebInspectorAttach :: WebInspectorAttachCallback
-> m (GClosure C_WebInspectorAttachCallback)
genClosure_WebInspectorAttach cb :: WebInspectorAttachCallback
cb = IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebInspectorAttachCallback)
 -> m (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorAttachCallback WebInspectorAttachCallback
cb
    C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorAttachCallback C_WebInspectorAttachCallback
cb' IO (FunPtr C_WebInspectorAttachCallback)
-> (FunPtr C_WebInspectorAttachCallback
    -> IO (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebInspectorAttachCallback
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebInspectorAttachCallback` into a `C_WebInspectorAttachCallback`.
wrap_WebInspectorAttachCallback ::
    WebInspectorAttachCallback ->
    C_WebInspectorAttachCallback
wrap_WebInspectorAttachCallback :: WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorAttachCallback _cb :: WebInspectorAttachCallback
_cb _ _ = do
    Bool
result <- WebInspectorAttachCallback
_cb 
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [attach](#signal:attach) 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' webInspector #attach callback
-- @
-- 
-- 
onWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorAttach :: a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorAttach obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorAttachCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorAttachCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "attach" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [attach](#signal:attach) 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' webInspector #attach callback
-- @
-- 
-- 
afterWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorAttach :: a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorAttach obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorAttachCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorAttachCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "attach" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebInspectorAttachSignalInfo
instance SignalInfo WebInspectorAttachSignalInfo where
    type HaskellCallbackType WebInspectorAttachSignalInfo = WebInspectorAttachCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebInspectorAttachCallback cb
        cb'' <- mk_WebInspectorAttachCallback cb'
        connectSignalFunPtr obj "attach" cb'' connectMode detail

#endif

-- signal WebInspector::bring-to-front
-- | Emitted when the inspector should be shown.
-- 
-- If the inspector is not attached the inspector window should be shown
-- on top of any other windows.
-- If the inspector is attached the inspector view should be made visible.
-- For example, if the inspector view is attached using a tab in a browser
-- window, the browser window should be raised and the tab containing the
-- inspector view should be the active one.
-- In both cases, if this signal is not handled, the default implementation
-- calls 'GI.Gtk.Objects.Window.windowPresent' on the current toplevel t'GI.Gtk.Objects.Window.Window' of the
-- inspector view.
type WebInspectorBringToFrontCallback =
    IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the event.
    --    'P.False' to propagate the event further.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorBringToFrontCallback`@.
noWebInspectorBringToFrontCallback :: Maybe WebInspectorBringToFrontCallback
noWebInspectorBringToFrontCallback :: Maybe WebInspectorAttachCallback
noWebInspectorBringToFrontCallback = Maybe WebInspectorAttachCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebInspectorBringToFront :: MonadIO m => WebInspectorBringToFrontCallback -> m (GClosure C_WebInspectorBringToFrontCallback)
genClosure_WebInspectorBringToFront :: WebInspectorAttachCallback
-> m (GClosure C_WebInspectorAttachCallback)
genClosure_WebInspectorBringToFront cb :: WebInspectorAttachCallback
cb = IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebInspectorAttachCallback)
 -> m (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorBringToFrontCallback WebInspectorAttachCallback
cb
    C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorBringToFrontCallback C_WebInspectorAttachCallback
cb' IO (FunPtr C_WebInspectorAttachCallback)
-> (FunPtr C_WebInspectorAttachCallback
    -> IO (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebInspectorAttachCallback
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebInspectorBringToFrontCallback` into a `C_WebInspectorBringToFrontCallback`.
wrap_WebInspectorBringToFrontCallback ::
    WebInspectorBringToFrontCallback ->
    C_WebInspectorBringToFrontCallback
wrap_WebInspectorBringToFrontCallback :: WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorBringToFrontCallback _cb :: WebInspectorAttachCallback
_cb _ _ = do
    Bool
result <- WebInspectorAttachCallback
_cb 
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [bringToFront](#signal:bringToFront) 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' webInspector #bringToFront callback
-- @
-- 
-- 
onWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId
onWebInspectorBringToFront :: a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorBringToFront obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorBringToFrontCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorBringToFrontCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bring-to-front" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [bringToFront](#signal:bringToFront) 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' webInspector #bringToFront callback
-- @
-- 
-- 
afterWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId
afterWebInspectorBringToFront :: a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorBringToFront obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorBringToFrontCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorBringToFrontCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bring-to-front" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebInspectorBringToFrontSignalInfo
instance SignalInfo WebInspectorBringToFrontSignalInfo where
    type HaskellCallbackType WebInspectorBringToFrontSignalInfo = WebInspectorBringToFrontCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebInspectorBringToFrontCallback cb
        cb'' <- mk_WebInspectorBringToFrontCallback cb'
        connectSignalFunPtr obj "bring-to-front" cb'' connectMode detail

#endif

-- signal WebInspector::closed
-- | Emitted when the inspector page is closed. If you are using your own
-- inspector window, you should connect to this signal and destroy your
-- window.
type WebInspectorClosedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorClosedCallback`@.
noWebInspectorClosedCallback :: Maybe WebInspectorClosedCallback
noWebInspectorClosedCallback :: Maybe (IO ())
noWebInspectorClosedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebInspectorClosed :: MonadIO m => WebInspectorClosedCallback -> m (GClosure C_WebInspectorClosedCallback)
genClosure_WebInspectorClosed :: IO () -> m (GClosure C_WebInspectorClosedCallback)
genClosure_WebInspectorClosed cb :: IO ()
cb = IO (GClosure C_WebInspectorClosedCallback)
-> m (GClosure C_WebInspectorClosedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebInspectorClosedCallback)
 -> m (GClosure C_WebInspectorClosedCallback))
-> IO (GClosure C_WebInspectorClosedCallback)
-> m (GClosure C_WebInspectorClosedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorClosedCallback
cb' = IO () -> C_WebInspectorClosedCallback
wrap_WebInspectorClosedCallback IO ()
cb
    C_WebInspectorClosedCallback
-> IO (FunPtr C_WebInspectorClosedCallback)
mk_WebInspectorClosedCallback C_WebInspectorClosedCallback
cb' IO (FunPtr C_WebInspectorClosedCallback)
-> (FunPtr C_WebInspectorClosedCallback
    -> IO (GClosure C_WebInspectorClosedCallback))
-> IO (GClosure C_WebInspectorClosedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebInspectorClosedCallback
-> IO (GClosure C_WebInspectorClosedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebInspectorClosedCallback` into a `C_WebInspectorClosedCallback`.
wrap_WebInspectorClosedCallback ::
    WebInspectorClosedCallback ->
    C_WebInspectorClosedCallback
wrap_WebInspectorClosedCallback :: IO () -> C_WebInspectorClosedCallback
wrap_WebInspectorClosedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [closed](#signal:closed) 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' webInspector #closed callback
-- @
-- 
-- 
onWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId
onWebInspectorClosed :: a -> IO () -> m SignalHandlerId
onWebInspectorClosed obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorClosedCallback
cb' = IO () -> C_WebInspectorClosedCallback
wrap_WebInspectorClosedCallback IO ()
cb
    FunPtr C_WebInspectorClosedCallback
cb'' <- C_WebInspectorClosedCallback
-> IO (FunPtr C_WebInspectorClosedCallback)
mk_WebInspectorClosedCallback C_WebInspectorClosedCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorClosedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "closed" FunPtr C_WebInspectorClosedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [closed](#signal:closed) 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' webInspector #closed callback
-- @
-- 
-- 
afterWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId
afterWebInspectorClosed :: a -> IO () -> m SignalHandlerId
afterWebInspectorClosed obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorClosedCallback
cb' = IO () -> C_WebInspectorClosedCallback
wrap_WebInspectorClosedCallback IO ()
cb
    FunPtr C_WebInspectorClosedCallback
cb'' <- C_WebInspectorClosedCallback
-> IO (FunPtr C_WebInspectorClosedCallback)
mk_WebInspectorClosedCallback C_WebInspectorClosedCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorClosedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "closed" FunPtr C_WebInspectorClosedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebInspectorClosedSignalInfo
instance SignalInfo WebInspectorClosedSignalInfo where
    type HaskellCallbackType WebInspectorClosedSignalInfo = WebInspectorClosedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebInspectorClosedCallback cb
        cb'' <- mk_WebInspectorClosedCallback cb'
        connectSignalFunPtr obj "closed" cb'' connectMode detail

#endif

-- signal WebInspector::detach
-- | Emitted when the inspector is requested to be detached from the window
-- it is currently attached to. The inspector is detached when the inspector page
-- is about to be closed, and this signal is emitted right before
-- [closed]("GI.WebKit2.Objects.WebInspector#signal:closed"), or when the user clicks on the detach button
-- in the inspector view to show the inspector in a separate window. In this case
-- the signal [openWindow]("GI.WebKit2.Objects.WebInspector#signal:openWindow") is emitted after this one.
-- 
-- To prevent the inspector view from being detached you can connect to this
-- signal and simply return 'P.True'.
type WebInspectorDetachCallback =
    IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the event.
    --    'P.False' to propagate the event further.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorDetachCallback`@.
noWebInspectorDetachCallback :: Maybe WebInspectorDetachCallback
noWebInspectorDetachCallback :: Maybe WebInspectorAttachCallback
noWebInspectorDetachCallback = Maybe WebInspectorAttachCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebInspectorDetach :: MonadIO m => WebInspectorDetachCallback -> m (GClosure C_WebInspectorDetachCallback)
genClosure_WebInspectorDetach :: WebInspectorAttachCallback
-> m (GClosure C_WebInspectorAttachCallback)
genClosure_WebInspectorDetach cb :: WebInspectorAttachCallback
cb = IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebInspectorAttachCallback)
 -> m (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorDetachCallback WebInspectorAttachCallback
cb
    C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorDetachCallback C_WebInspectorAttachCallback
cb' IO (FunPtr C_WebInspectorAttachCallback)
-> (FunPtr C_WebInspectorAttachCallback
    -> IO (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebInspectorAttachCallback
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebInspectorDetachCallback` into a `C_WebInspectorDetachCallback`.
wrap_WebInspectorDetachCallback ::
    WebInspectorDetachCallback ->
    C_WebInspectorDetachCallback
wrap_WebInspectorDetachCallback :: WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorDetachCallback _cb :: WebInspectorAttachCallback
_cb _ _ = do
    Bool
result <- WebInspectorAttachCallback
_cb 
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [detach](#signal:detach) 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' webInspector #detach callback
-- @
-- 
-- 
onWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId
onWebInspectorDetach :: a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorDetach obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorDetachCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorDetachCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "detach" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [detach](#signal:detach) 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' webInspector #detach callback
-- @
-- 
-- 
afterWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId
afterWebInspectorDetach :: a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorDetach obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorDetachCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorDetachCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "detach" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebInspectorDetachSignalInfo
instance SignalInfo WebInspectorDetachSignalInfo where
    type HaskellCallbackType WebInspectorDetachSignalInfo = WebInspectorDetachCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebInspectorDetachCallback cb
        cb'' <- mk_WebInspectorDetachCallback cb'
        connectSignalFunPtr obj "detach" cb'' connectMode detail

#endif

-- signal WebInspector::open-window
-- | Emitted when the inspector is requested to open in a separate window.
-- If this signal is not handled, a t'GI.Gtk.Objects.Window.Window' with the inspector will be
-- created and shown, so you only need to handle this signal if you want
-- to use your own window.
-- This signal is emitted after [detach]("GI.WebKit2.Objects.WebInspector#signal:detach") to show
-- the inspector in a separate window after being detached.
-- 
-- To prevent the inspector from being shown you can connect to this
-- signal and simply return 'P.True'
type WebInspectorOpenWindowCallback =
    IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the event.
    --    'P.False' to propagate the event further.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorOpenWindowCallback`@.
noWebInspectorOpenWindowCallback :: Maybe WebInspectorOpenWindowCallback
noWebInspectorOpenWindowCallback :: Maybe WebInspectorAttachCallback
noWebInspectorOpenWindowCallback = Maybe WebInspectorAttachCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebInspectorOpenWindow :: MonadIO m => WebInspectorOpenWindowCallback -> m (GClosure C_WebInspectorOpenWindowCallback)
genClosure_WebInspectorOpenWindow :: WebInspectorAttachCallback
-> m (GClosure C_WebInspectorAttachCallback)
genClosure_WebInspectorOpenWindow cb :: WebInspectorAttachCallback
cb = IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebInspectorAttachCallback)
 -> m (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
-> m (GClosure C_WebInspectorAttachCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorOpenWindowCallback WebInspectorAttachCallback
cb
    C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorOpenWindowCallback C_WebInspectorAttachCallback
cb' IO (FunPtr C_WebInspectorAttachCallback)
-> (FunPtr C_WebInspectorAttachCallback
    -> IO (GClosure C_WebInspectorAttachCallback))
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebInspectorAttachCallback
-> IO (GClosure C_WebInspectorAttachCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebInspectorOpenWindowCallback` into a `C_WebInspectorOpenWindowCallback`.
wrap_WebInspectorOpenWindowCallback ::
    WebInspectorOpenWindowCallback ->
    C_WebInspectorOpenWindowCallback
wrap_WebInspectorOpenWindowCallback :: WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorOpenWindowCallback _cb :: WebInspectorAttachCallback
_cb _ _ = do
    Bool
result <- WebInspectorAttachCallback
_cb 
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [openWindow](#signal:openWindow) 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' webInspector #openWindow callback
-- @
-- 
-- 
onWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId
onWebInspectorOpenWindow :: a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorOpenWindow obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorOpenWindowCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorOpenWindowCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "open-window" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [openWindow](#signal:openWindow) 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' webInspector #openWindow callback
-- @
-- 
-- 
afterWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId
afterWebInspectorOpenWindow :: a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorOpenWindow obj :: a
obj cb :: WebInspectorAttachCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebInspectorAttachCallback
cb' = WebInspectorAttachCallback -> C_WebInspectorAttachCallback
wrap_WebInspectorOpenWindowCallback WebInspectorAttachCallback
cb
    FunPtr C_WebInspectorAttachCallback
cb'' <- C_WebInspectorAttachCallback
-> IO (FunPtr C_WebInspectorAttachCallback)
mk_WebInspectorOpenWindowCallback C_WebInspectorAttachCallback
cb'
    a
-> Text
-> FunPtr C_WebInspectorAttachCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "open-window" FunPtr C_WebInspectorAttachCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebInspectorOpenWindowSignalInfo
instance SignalInfo WebInspectorOpenWindowSignalInfo where
    type HaskellCallbackType WebInspectorOpenWindowSignalInfo = WebInspectorOpenWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebInspectorOpenWindowCallback cb
        cb'' <- mk_WebInspectorOpenWindowCallback cb'
        connectSignalFunPtr obj "open-window" cb'' connectMode detail

#endif

-- VVV Prop "attached-height"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@attached-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' webInspector #attachedHeight
-- @
getWebInspectorAttachedHeight :: (MonadIO m, IsWebInspector o) => o -> m Word32
getWebInspectorAttachedHeight :: o -> m Word32
getWebInspectorAttachedHeight obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj "attached-height"

#if defined(ENABLE_OVERLOADING)
data WebInspectorAttachedHeightPropertyInfo
instance AttrInfo WebInspectorAttachedHeightPropertyInfo where
    type AttrAllowedOps WebInspectorAttachedHeightPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint WebInspectorAttachedHeightPropertyInfo = IsWebInspector
    type AttrSetTypeConstraint WebInspectorAttachedHeightPropertyInfo = (~) ()
    type AttrTransferTypeConstraint WebInspectorAttachedHeightPropertyInfo = (~) ()
    type AttrTransferType WebInspectorAttachedHeightPropertyInfo = ()
    type AttrGetType WebInspectorAttachedHeightPropertyInfo = Word32
    type AttrLabel WebInspectorAttachedHeightPropertyInfo = "attached-height"
    type AttrOrigin WebInspectorAttachedHeightPropertyInfo = WebInspector
    attrGet = getWebInspectorAttachedHeight
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "can-attach"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@can-attach@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' webInspector #canAttach
-- @
getWebInspectorCanAttach :: (MonadIO m, IsWebInspector o) => o -> m Bool
getWebInspectorCanAttach :: o -> m Bool
getWebInspectorCanAttach obj :: o
obj = WebInspectorAttachCallback -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WebInspectorAttachCallback -> m Bool)
-> WebInspectorAttachCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> WebInspectorAttachCallback
forall a. GObject a => a -> String -> WebInspectorAttachCallback
B.Properties.getObjectPropertyBool o
obj "can-attach"

#if defined(ENABLE_OVERLOADING)
data WebInspectorCanAttachPropertyInfo
instance AttrInfo WebInspectorCanAttachPropertyInfo where
    type AttrAllowedOps WebInspectorCanAttachPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint WebInspectorCanAttachPropertyInfo = IsWebInspector
    type AttrSetTypeConstraint WebInspectorCanAttachPropertyInfo = (~) ()
    type AttrTransferTypeConstraint WebInspectorCanAttachPropertyInfo = (~) ()
    type AttrTransferType WebInspectorCanAttachPropertyInfo = ()
    type AttrGetType WebInspectorCanAttachPropertyInfo = Bool
    type AttrLabel WebInspectorCanAttachPropertyInfo = "can-attach"
    type AttrOrigin WebInspectorCanAttachPropertyInfo = WebInspector
    attrGet = getWebInspectorCanAttach
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "inspected-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@inspected-uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' webInspector #inspectedUri
-- @
getWebInspectorInspectedUri :: (MonadIO m, IsWebInspector o) => o -> m (Maybe T.Text)
getWebInspectorInspectedUri :: o -> m (Maybe Text)
getWebInspectorInspectedUri obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
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
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "inspected-uri"

#if defined(ENABLE_OVERLOADING)
data WebInspectorInspectedUriPropertyInfo
instance AttrInfo WebInspectorInspectedUriPropertyInfo where
    type AttrAllowedOps WebInspectorInspectedUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebInspectorInspectedUriPropertyInfo = IsWebInspector
    type AttrSetTypeConstraint WebInspectorInspectedUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint WebInspectorInspectedUriPropertyInfo = (~) ()
    type AttrTransferType WebInspectorInspectedUriPropertyInfo = ()
    type AttrGetType WebInspectorInspectedUriPropertyInfo = (Maybe T.Text)
    type AttrLabel WebInspectorInspectedUriPropertyInfo = "inspected-uri"
    type AttrOrigin WebInspectorInspectedUriPropertyInfo = WebInspector
    attrGet = getWebInspectorInspectedUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WebInspector
type instance O.AttributeList WebInspector = WebInspectorAttributeList
type WebInspectorAttributeList = ('[ '("attachedHeight", WebInspectorAttachedHeightPropertyInfo), '("canAttach", WebInspectorCanAttachPropertyInfo), '("inspectedUri", WebInspectorInspectedUriPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
webInspectorAttachedHeight :: AttrLabelProxy "attachedHeight"
webInspectorAttachedHeight = AttrLabelProxy

webInspectorCanAttach :: AttrLabelProxy "canAttach"
webInspectorCanAttach = AttrLabelProxy

webInspectorInspectedUri :: AttrLabelProxy "inspectedUri"
webInspectorInspectedUri = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WebInspector = WebInspectorSignalList
type WebInspectorSignalList = ('[ '("attach", WebInspectorAttachSignalInfo), '("bringToFront", WebInspectorBringToFrontSignalInfo), '("closed", WebInspectorClosedSignalInfo), '("detach", WebInspectorDetachSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("openWindow", WebInspectorOpenWindowSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_web_inspector_attach" webkit_web_inspector_attach :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO ()

-- | Request /@inspector@/ to be attached. The signal [attach]("GI.WebKit2.Objects.WebInspector#signal:attach")
-- will be emitted. If the inspector is already attached it does nothing.
webInspectorAttach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m ()
webInspectorAttach :: a -> m ()
webInspectorAttach inspector :: a
inspector = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Ptr WebInspector -> IO ()
webkit_web_inspector_attach Ptr WebInspector
inspector'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebInspectorAttachMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorAttachMethodInfo a signature where
    overloadedMethod = webInspectorAttach

#endif

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

foreign import ccall "webkit_web_inspector_close" webkit_web_inspector_close :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO ()

-- | Request /@inspector@/ to be closed.
webInspectorClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m ()
webInspectorClose :: a -> m ()
webInspectorClose inspector :: a
inspector = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Ptr WebInspector -> IO ()
webkit_web_inspector_close Ptr WebInspector
inspector'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebInspectorCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorCloseMethodInfo a signature where
    overloadedMethod = webInspectorClose

#endif

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

foreign import ccall "webkit_web_inspector_detach" webkit_web_inspector_detach :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO ()

-- | Request /@inspector@/ to be detached. The signal [detach]("GI.WebKit2.Objects.WebInspector#signal:detach")
-- will be emitted. If the inspector is already detached it does nothing.
webInspectorDetach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m ()
webInspectorDetach :: a -> m ()
webInspectorDetach inspector :: a
inspector = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Ptr WebInspector -> IO ()
webkit_web_inspector_detach Ptr WebInspector
inspector'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebInspectorDetachMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorDetachMethodInfo a signature where
    overloadedMethod = webInspectorDetach

#endif

-- method WebInspector::get_attached_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "inspector"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "WebInspector" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebInspector"
--                 , 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_web_inspector_get_attached_height" webkit_web_inspector_get_attached_height :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO Word32

-- | Get the height that the inspector view should have when
-- it\'s attached. If the inspector view is not attached this
-- returns 0.
webInspectorGetAttachedHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m Word32
    -- ^ __Returns:__ the height of the inspector view when attached
webInspectorGetAttachedHeight :: a -> m Word32
webInspectorGetAttachedHeight inspector :: a
inspector = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Word32
result <- Ptr WebInspector -> IO Word32
webkit_web_inspector_get_attached_height Ptr WebInspector
inspector'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data WebInspectorGetAttachedHeightMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetAttachedHeightMethodInfo a signature where
    overloadedMethod = webInspectorGetAttachedHeight

#endif

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

foreign import ccall "webkit_web_inspector_get_can_attach" webkit_web_inspector_get_can_attach :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO CInt

-- | Whether the /@inspector@/ can be attached to the same window that contains
-- the inspected view.
-- 
-- /Since: 2.8/
webInspectorGetCanAttach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if there is enough room for the inspector view inside the
    --     window that contains the inspected view, or 'P.False' otherwise.
webInspectorGetCanAttach :: a -> m Bool
webInspectorGetCanAttach inspector :: a
inspector = WebInspectorAttachCallback -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WebInspectorAttachCallback -> m Bool)
-> WebInspectorAttachCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    CInt
result <- Ptr WebInspector -> IO CInt
webkit_web_inspector_get_can_attach Ptr WebInspector
inspector'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    Bool -> WebInspectorAttachCallback
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WebInspectorGetCanAttachMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetCanAttachMethodInfo a signature where
    overloadedMethod = webInspectorGetCanAttach

#endif

-- method WebInspector::get_inspected_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "inspector"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "WebInspector" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebInspector"
--                 , 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_web_inspector_get_inspected_uri" webkit_web_inspector_get_inspected_uri :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO CString

-- | Get the URI that is currently being inspected. This can be 'P.Nothing' if
-- nothing has been loaded yet in the inspected view, if the inspector
-- has been closed or when inspected view was loaded from a HTML string
-- instead of a URI.
webInspectorGetInspectedUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the URI that is currently being inspected or 'P.Nothing'
webInspectorGetInspectedUri :: a -> m (Maybe Text)
webInspectorGetInspectedUri inspector :: a
inspector = IO (Maybe Text) -> m (Maybe Text)
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
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    CString
result <- Ptr WebInspector -> IO CString
webkit_web_inspector_get_inspected_uri Ptr WebInspector
inspector'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data WebInspectorGetInspectedUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetInspectedUriMethodInfo a signature where
    overloadedMethod = webInspectorGetInspectedUri

#endif

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

foreign import ccall "webkit_web_inspector_get_web_view" webkit_web_inspector_get_web_view :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO (Ptr WebKit2.WebViewBase.WebViewBase)

-- | Get the t'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector.
-- This might be 'P.Nothing' if the inspector hasn\'t been loaded yet,
-- or it has been closed.
webInspectorGetWebView ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m (Maybe WebKit2.WebViewBase.WebViewBase)
    -- ^ __Returns:__ the t'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector or 'P.Nothing'
webInspectorGetWebView :: a -> m (Maybe WebViewBase)
webInspectorGetWebView inspector :: a
inspector = IO (Maybe WebViewBase) -> m (Maybe WebViewBase)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WebViewBase) -> m (Maybe WebViewBase))
-> IO (Maybe WebViewBase) -> m (Maybe WebViewBase)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Ptr WebViewBase
result <- Ptr WebInspector -> IO (Ptr WebViewBase)
webkit_web_inspector_get_web_view Ptr WebInspector
inspector'
    Maybe WebViewBase
maybeResult <- Ptr WebViewBase
-> (Ptr WebViewBase -> IO WebViewBase) -> IO (Maybe WebViewBase)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr WebViewBase
result ((Ptr WebViewBase -> IO WebViewBase) -> IO (Maybe WebViewBase))
-> (Ptr WebViewBase -> IO WebViewBase) -> IO (Maybe WebViewBase)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr WebViewBase
result' -> do
        WebViewBase
result'' <- ((ManagedPtr WebViewBase -> WebViewBase)
-> Ptr WebViewBase -> IO WebViewBase
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebViewBase -> WebViewBase
WebKit2.WebViewBase.WebViewBase) Ptr WebViewBase
result'
        WebViewBase -> IO WebViewBase
forall (m :: * -> *) a. Monad m => a -> m a
return WebViewBase
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    Maybe WebViewBase -> IO (Maybe WebViewBase)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WebViewBase
maybeResult

#if defined(ENABLE_OVERLOADING)
data WebInspectorGetWebViewMethodInfo
instance (signature ~ (m (Maybe WebKit2.WebViewBase.WebViewBase)), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetWebViewMethodInfo a signature where
    overloadedMethod = webInspectorGetWebView

#endif

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

foreign import ccall "webkit_web_inspector_is_attached" webkit_web_inspector_is_attached :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO CInt

-- | Whether the /@inspector@/ view is currently attached to the same window that contains
-- the inspected view.
webInspectorIsAttached ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@inspector@/ is currently attached or 'P.False' otherwise
webInspectorIsAttached :: a -> m Bool
webInspectorIsAttached inspector :: a
inspector = WebInspectorAttachCallback -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WebInspectorAttachCallback -> m Bool)
-> WebInspectorAttachCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    CInt
result <- Ptr WebInspector -> IO CInt
webkit_web_inspector_is_attached Ptr WebInspector
inspector'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    Bool -> WebInspectorAttachCallback
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WebInspectorIsAttachedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorIsAttachedMethodInfo a signature where
    overloadedMethod = webInspectorIsAttached

#endif

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

foreign import ccall "webkit_web_inspector_show" webkit_web_inspector_show :: 
    Ptr WebInspector ->                     -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"})
    IO ()

-- | Request /@inspector@/ to be shown.
webInspectorShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    -- ^ /@inspector@/: a t'GI.WebKit2.Objects.WebInspector.WebInspector'
    -> m ()
webInspectorShow :: a -> m ()
webInspectorShow inspector :: a
inspector = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebInspector
inspector' <- a -> IO (Ptr WebInspector)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
inspector
    Ptr WebInspector -> IO ()
webkit_web_inspector_show Ptr WebInspector
inspector'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
inspector
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebInspectorShowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorShowMethodInfo a signature where
    overloadedMethod = webInspectorShow

#endif