{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.WebKit2.Objects.WebInspector
    ( 

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


 -- * Methods
-- ** attach #method:attach#
    WebInspectorAttachMethodInfo            ,
    webInspectorAttach                      ,


-- ** close #method:close#
    WebInspectorCloseMethodInfo             ,
    webInspectorClose                       ,


-- ** detach #method:detach#
    WebInspectorDetachMethodInfo            ,
    webInspectorDetach                      ,


-- ** getAttachedHeight #method:getAttachedHeight#
    WebInspectorGetAttachedHeightMethodInfo ,
    webInspectorGetAttachedHeight           ,


-- ** getCanAttach #method:getCanAttach#
    WebInspectorGetCanAttachMethodInfo      ,
    webInspectorGetCanAttach                ,


-- ** getInspectedUri #method:getInspectedUri#
    WebInspectorGetInspectedUriMethodInfo   ,
    webInspectorGetInspectedUri             ,


-- ** getWebView #method:getWebView#
    WebInspectorGetWebViewMethodInfo        ,
    webInspectorGetWebView                  ,


-- ** isAttached #method:isAttached#
    WebInspectorIsAttachedMethodInfo        ,
    webInspectorIsAttached                  ,


-- ** show #method:show#
    WebInspectorShowMethodInfo              ,
    webInspectorShow                        ,




 -- * Properties
-- ** attachedHeight #attr:attachedHeight#
    WebInspectorAttachedHeightPropertyInfo  ,
    getWebInspectorAttachedHeight           ,
    webInspectorAttachedHeight              ,


-- ** canAttach #attr:canAttach#
    WebInspectorCanAttachPropertyInfo       ,
    getWebInspectorCanAttach                ,
    webInspectorCanAttach                   ,


-- ** inspectedUri #attr:inspectedUri#
    WebInspectorInspectedUriPropertyInfo    ,
    getWebInspectorInspectedUri             ,
    webInspectorInspectedUri                ,




 -- * Signals
-- ** attach #signal:attach#
    C_WebInspectorAttachCallback            ,
    WebInspectorAttachCallback              ,
    WebInspectorAttachSignalInfo            ,
    afterWebInspectorAttach                 ,
    genClosure_WebInspectorAttach           ,
    mk_WebInspectorAttachCallback           ,
    noWebInspectorAttachCallback            ,
    onWebInspectorAttach                    ,
    wrap_WebInspectorAttachCallback         ,


-- ** bringToFront #signal:bringToFront#
    C_WebInspectorBringToFrontCallback      ,
    WebInspectorBringToFrontCallback        ,
    WebInspectorBringToFrontSignalInfo      ,
    afterWebInspectorBringToFront           ,
    genClosure_WebInspectorBringToFront     ,
    mk_WebInspectorBringToFrontCallback     ,
    noWebInspectorBringToFrontCallback      ,
    onWebInspectorBringToFront              ,
    wrap_WebInspectorBringToFrontCallback   ,


-- ** closed #signal:closed#
    C_WebInspectorClosedCallback            ,
    WebInspectorClosedCallback              ,
    WebInspectorClosedSignalInfo            ,
    afterWebInspectorClosed                 ,
    genClosure_WebInspectorClosed           ,
    mk_WebInspectorClosedCallback           ,
    noWebInspectorClosedCallback            ,
    onWebInspectorClosed                    ,
    wrap_WebInspectorClosedCallback         ,


-- ** detach #signal:detach#
    C_WebInspectorDetachCallback            ,
    WebInspectorDetachCallback              ,
    WebInspectorDetachSignalInfo            ,
    afterWebInspectorDetach                 ,
    genClosure_WebInspectorDetach           ,
    mk_WebInspectorDetachCallback           ,
    noWebInspectorDetachCallback            ,
    onWebInspectorDetach                    ,
    wrap_WebInspectorDetachCallback         ,


-- ** openWindow #signal:openWindow#
    C_WebInspectorOpenWindowCallback        ,
    WebInspectorOpenWindowCallback          ,
    WebInspectorOpenWindowSignalInfo        ,
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebViewBase as WebKit2.WebViewBase

newtype WebInspector = WebInspector (ManagedPtr WebInspector)
foreign import ccall "webkit_web_inspector_get_type"
    c_webkit_web_inspector_get_type :: IO GType

instance GObject WebInspector where
    gobjectType _ = c_webkit_web_inspector_get_type
    

class GObject o => IsWebInspector o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError WebInspector a) =>
    IsWebInspector a
#endif
instance IsWebInspector WebInspector
instance GObject.Object.IsObject WebInspector

toWebInspector :: IsWebInspector o => o -> IO WebInspector
toWebInspector = unsafeCastTo WebInspector

noWebInspector :: Maybe WebInspector
noWebInspector = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebInspectorMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebInspectorMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebInspectorMethod t WebInspector, O.MethodInfo info WebInspector p) => O.IsLabelProxy t (WebInspector -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWebInspectorMethod t WebInspector, O.MethodInfo info WebInspector p) => O.IsLabel t (WebInspector -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal WebInspector::attach
type WebInspectorAttachCallback =
    IO Bool

noWebInspectorAttachCallback :: Maybe WebInspectorAttachCallback
noWebInspectorAttachCallback = Nothing

type C_WebInspectorAttachCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebInspectorAttachCallback :: C_WebInspectorAttachCallback -> IO (FunPtr C_WebInspectorAttachCallback)

genClosure_WebInspectorAttach :: WebInspectorAttachCallback -> IO Closure
genClosure_WebInspectorAttach cb = do
    let cb' = wrap_WebInspectorAttachCallback cb
    mk_WebInspectorAttachCallback cb' >>= newCClosure


wrap_WebInspectorAttachCallback ::
    WebInspectorAttachCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WebInspectorAttachCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebInspectorAttach :: (GObject a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId
onWebInspectorAttach obj cb = liftIO $ connectWebInspectorAttach obj cb SignalConnectBefore
afterWebInspectorAttach :: (GObject a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId
afterWebInspectorAttach obj cb = connectWebInspectorAttach obj cb SignalConnectAfter

connectWebInspectorAttach :: (GObject a, MonadIO m) =>
                             a -> WebInspectorAttachCallback -> SignalConnectMode -> m SignalHandlerId
connectWebInspectorAttach obj cb after = liftIO $ do
    let cb' = wrap_WebInspectorAttachCallback cb
    cb'' <- mk_WebInspectorAttachCallback cb'
    connectSignalFunPtr obj "attach" cb'' after

-- signal WebInspector::bring-to-front
type WebInspectorBringToFrontCallback =
    IO Bool

noWebInspectorBringToFrontCallback :: Maybe WebInspectorBringToFrontCallback
noWebInspectorBringToFrontCallback = Nothing

type C_WebInspectorBringToFrontCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebInspectorBringToFrontCallback :: C_WebInspectorBringToFrontCallback -> IO (FunPtr C_WebInspectorBringToFrontCallback)

genClosure_WebInspectorBringToFront :: WebInspectorBringToFrontCallback -> IO Closure
genClosure_WebInspectorBringToFront cb = do
    let cb' = wrap_WebInspectorBringToFrontCallback cb
    mk_WebInspectorBringToFrontCallback cb' >>= newCClosure


wrap_WebInspectorBringToFrontCallback ::
    WebInspectorBringToFrontCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WebInspectorBringToFrontCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebInspectorBringToFront :: (GObject a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId
onWebInspectorBringToFront obj cb = liftIO $ connectWebInspectorBringToFront obj cb SignalConnectBefore
afterWebInspectorBringToFront :: (GObject a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId
afterWebInspectorBringToFront obj cb = connectWebInspectorBringToFront obj cb SignalConnectAfter

connectWebInspectorBringToFront :: (GObject a, MonadIO m) =>
                                   a -> WebInspectorBringToFrontCallback -> SignalConnectMode -> m SignalHandlerId
connectWebInspectorBringToFront obj cb after = liftIO $ do
    let cb' = wrap_WebInspectorBringToFrontCallback cb
    cb'' <- mk_WebInspectorBringToFrontCallback cb'
    connectSignalFunPtr obj "bring-to-front" cb'' after

-- signal WebInspector::closed
type WebInspectorClosedCallback =
    IO ()

noWebInspectorClosedCallback :: Maybe WebInspectorClosedCallback
noWebInspectorClosedCallback = Nothing

type C_WebInspectorClosedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebInspectorClosedCallback :: C_WebInspectorClosedCallback -> IO (FunPtr C_WebInspectorClosedCallback)

genClosure_WebInspectorClosed :: WebInspectorClosedCallback -> IO Closure
genClosure_WebInspectorClosed cb = do
    let cb' = wrap_WebInspectorClosedCallback cb
    mk_WebInspectorClosedCallback cb' >>= newCClosure


wrap_WebInspectorClosedCallback ::
    WebInspectorClosedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebInspectorClosedCallback _cb _ _ = do
    _cb 


onWebInspectorClosed :: (GObject a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId
onWebInspectorClosed obj cb = liftIO $ connectWebInspectorClosed obj cb SignalConnectBefore
afterWebInspectorClosed :: (GObject a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId
afterWebInspectorClosed obj cb = connectWebInspectorClosed obj cb SignalConnectAfter

connectWebInspectorClosed :: (GObject a, MonadIO m) =>
                             a -> WebInspectorClosedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebInspectorClosed obj cb after = liftIO $ do
    let cb' = wrap_WebInspectorClosedCallback cb
    cb'' <- mk_WebInspectorClosedCallback cb'
    connectSignalFunPtr obj "closed" cb'' after

-- signal WebInspector::detach
type WebInspectorDetachCallback =
    IO Bool

noWebInspectorDetachCallback :: Maybe WebInspectorDetachCallback
noWebInspectorDetachCallback = Nothing

type C_WebInspectorDetachCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebInspectorDetachCallback :: C_WebInspectorDetachCallback -> IO (FunPtr C_WebInspectorDetachCallback)

genClosure_WebInspectorDetach :: WebInspectorDetachCallback -> IO Closure
genClosure_WebInspectorDetach cb = do
    let cb' = wrap_WebInspectorDetachCallback cb
    mk_WebInspectorDetachCallback cb' >>= newCClosure


wrap_WebInspectorDetachCallback ::
    WebInspectorDetachCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WebInspectorDetachCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebInspectorDetach :: (GObject a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId
onWebInspectorDetach obj cb = liftIO $ connectWebInspectorDetach obj cb SignalConnectBefore
afterWebInspectorDetach :: (GObject a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId
afterWebInspectorDetach obj cb = connectWebInspectorDetach obj cb SignalConnectAfter

connectWebInspectorDetach :: (GObject a, MonadIO m) =>
                             a -> WebInspectorDetachCallback -> SignalConnectMode -> m SignalHandlerId
connectWebInspectorDetach obj cb after = liftIO $ do
    let cb' = wrap_WebInspectorDetachCallback cb
    cb'' <- mk_WebInspectorDetachCallback cb'
    connectSignalFunPtr obj "detach" cb'' after

-- signal WebInspector::open-window
type WebInspectorOpenWindowCallback =
    IO Bool

noWebInspectorOpenWindowCallback :: Maybe WebInspectorOpenWindowCallback
noWebInspectorOpenWindowCallback = Nothing

type C_WebInspectorOpenWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebInspectorOpenWindowCallback :: C_WebInspectorOpenWindowCallback -> IO (FunPtr C_WebInspectorOpenWindowCallback)

genClosure_WebInspectorOpenWindow :: WebInspectorOpenWindowCallback -> IO Closure
genClosure_WebInspectorOpenWindow cb = do
    let cb' = wrap_WebInspectorOpenWindowCallback cb
    mk_WebInspectorOpenWindowCallback cb' >>= newCClosure


wrap_WebInspectorOpenWindowCallback ::
    WebInspectorOpenWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WebInspectorOpenWindowCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebInspectorOpenWindow :: (GObject a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId
onWebInspectorOpenWindow obj cb = liftIO $ connectWebInspectorOpenWindow obj cb SignalConnectBefore
afterWebInspectorOpenWindow :: (GObject a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId
afterWebInspectorOpenWindow obj cb = connectWebInspectorOpenWindow obj cb SignalConnectAfter

connectWebInspectorOpenWindow :: (GObject a, MonadIO m) =>
                                 a -> WebInspectorOpenWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectWebInspectorOpenWindow obj cb after = liftIO $ do
    let cb' = wrap_WebInspectorOpenWindowCallback cb
    cb'' <- mk_WebInspectorOpenWindowCallback cb'
    connectSignalFunPtr obj "open-window" cb'' after

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

getWebInspectorAttachedHeight :: (MonadIO m, IsWebInspector o) => o -> m Word32
getWebInspectorAttachedHeight obj = liftIO $ getObjectPropertyUInt32 obj "attached-height"

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

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

getWebInspectorCanAttach :: (MonadIO m, IsWebInspector o) => o -> m Bool
getWebInspectorCanAttach obj = liftIO $ getObjectPropertyBool obj "can-attach"

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

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

getWebInspectorInspectedUri :: (MonadIO m, IsWebInspector o) => o -> m T.Text
getWebInspectorInspectedUri obj = liftIO $ checkUnexpectedNothing "getWebInspectorInspectedUri" $ getObjectPropertyString obj "inspected-uri"

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

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

webInspectorAttachedHeight :: AttrLabelProxy "attachedHeight"
webInspectorAttachedHeight = AttrLabelProxy

webInspectorCanAttach :: AttrLabelProxy "canAttach"
webInspectorCanAttach = AttrLabelProxy

webInspectorInspectedUri :: AttrLabelProxy "inspectedUri"
webInspectorInspectedUri = AttrLabelProxy

data WebInspectorAttachSignalInfo
instance SignalInfo WebInspectorAttachSignalInfo where
    type HaskellCallbackType WebInspectorAttachSignalInfo = WebInspectorAttachCallback
    connectSignal _ = connectWebInspectorAttach

data WebInspectorBringToFrontSignalInfo
instance SignalInfo WebInspectorBringToFrontSignalInfo where
    type HaskellCallbackType WebInspectorBringToFrontSignalInfo = WebInspectorBringToFrontCallback
    connectSignal _ = connectWebInspectorBringToFront

data WebInspectorClosedSignalInfo
instance SignalInfo WebInspectorClosedSignalInfo where
    type HaskellCallbackType WebInspectorClosedSignalInfo = WebInspectorClosedCallback
    connectSignal _ = connectWebInspectorClosed

data WebInspectorDetachSignalInfo
instance SignalInfo WebInspectorDetachSignalInfo where
    type HaskellCallbackType WebInspectorDetachSignalInfo = WebInspectorDetachCallback
    connectSignal _ = connectWebInspectorDetach

data WebInspectorOpenWindowSignalInfo
instance SignalInfo WebInspectorOpenWindowSignalInfo where
    type HaskellCallbackType WebInspectorOpenWindowSignalInfo = WebInspectorOpenWindowCallback
    connectSignal _ = connectWebInspectorOpenWindow

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/attach/@
will be emitted. If the inspector is already attached it does nothing.
-}
webInspectorAttach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m ()
webInspectorAttach inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    webkit_web_inspector_attach inspector'
    touchManagedPtr inspector
    return ()

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m ()
webInspectorClose inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    webkit_web_inspector_close inspector'
    touchManagedPtr inspector
    return ()

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/detach/@
will be emitted. If the inspector is already detached it does nothing.
-}
webInspectorDetach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) =>
    a
    {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m ()
webInspectorDetach inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    webkit_web_inspector_detach inspector'
    touchManagedPtr inspector
    return ()

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m Word32
    {- ^ __Returns:__ the height of the inspector view when attached -}
webInspectorGetAttachedHeight inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    result <- webkit_web_inspector_get_attached_height inspector'
    touchManagedPtr inspector
    return result

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there is enough room for the inspector view inside the
    window that contains the inspected view, or 'False' otherwise. -}
webInspectorGetCanAttach inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    result <- webkit_web_inspector_get_can_attach inspector'
    let result' = (/= 0) result
    touchManagedPtr inspector
    return result'

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

-- 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 '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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m T.Text
    {- ^ __Returns:__ the URI that is currently being inspected or 'Nothing' -}
webInspectorGetInspectedUri inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    result <- webkit_web_inspector_get_inspected_uri inspector'
    checkUnexpectedReturnNULL "webInspectorGetInspectedUri" result
    result' <- cstringToText result
    touchManagedPtr inspector
    return result'

data WebInspectorGetInspectedUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetInspectedUriMethodInfo a signature where
    overloadedMethod _ = webInspectorGetInspectedUri

-- 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 'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector.
This might be '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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m WebKit2.WebViewBase.WebViewBase
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector or 'Nothing' -}
webInspectorGetWebView inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    result <- webkit_web_inspector_get_web_view inspector'
    checkUnexpectedReturnNULL "webInspectorGetWebView" result
    result' <- (newObject WebKit2.WebViewBase.WebViewBase) result
    touchManagedPtr inspector
    return result'

data WebInspectorGetWebViewMethodInfo
instance (signature ~ (m WebKit2.WebViewBase.WebViewBase), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetWebViewMethodInfo a signature where
    overloadedMethod _ = webInspectorGetWebView

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@inspector@/ is currently attached or 'False' otherwise -}
webInspectorIsAttached inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    result <- webkit_web_inspector_is_attached inspector'
    let result' = (/= 0) result
    touchManagedPtr inspector
    return result'

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

-- 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 'GI.WebKit2.Objects.WebInspector.WebInspector' -}
    -> m ()
webInspectorShow inspector = liftIO $ do
    inspector' <- unsafeManagedPtrCastPtr inspector
    webkit_web_inspector_show inspector'
    touchManagedPtr inspector
    return ()

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