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

An ATK object which encapsulates a link or set of links (for
instance in the case of client-side image maps) in a hypertext
document.  It may implement the AtkAction interface.  AtkHyperlink
may also be used to refer to inline embedded content, since it
allows specification of a start and end offset within the host
AtkHypertext object.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Atk.Objects.Hyperlink
    ( 

-- * Exported types
    Hyperlink(..)                           ,
    IsHyperlink                             ,
    toHyperlink                             ,
    noHyperlink                             ,


 -- * Methods
-- ** getEndIndex #method:getEndIndex#

#if ENABLE_OVERLOADING
    HyperlinkGetEndIndexMethodInfo          ,
#endif
    hyperlinkGetEndIndex                    ,


-- ** getNAnchors #method:getNAnchors#

#if ENABLE_OVERLOADING
    HyperlinkGetNAnchorsMethodInfo          ,
#endif
    hyperlinkGetNAnchors                    ,


-- ** getObject #method:getObject#

#if ENABLE_OVERLOADING
    HyperlinkGetObjectMethodInfo            ,
#endif
    hyperlinkGetObject                      ,


-- ** getStartIndex #method:getStartIndex#

#if ENABLE_OVERLOADING
    HyperlinkGetStartIndexMethodInfo        ,
#endif
    hyperlinkGetStartIndex                  ,


-- ** getUri #method:getUri#

#if ENABLE_OVERLOADING
    HyperlinkGetUriMethodInfo               ,
#endif
    hyperlinkGetUri                         ,


-- ** isInline #method:isInline#

#if ENABLE_OVERLOADING
    HyperlinkIsInlineMethodInfo             ,
#endif
    hyperlinkIsInline                       ,


-- ** isSelectedLink #method:isSelectedLink#

#if ENABLE_OVERLOADING
    HyperlinkIsSelectedLinkMethodInfo       ,
#endif
    hyperlinkIsSelectedLink                 ,


-- ** isValid #method:isValid#

#if ENABLE_OVERLOADING
    HyperlinkIsValidMethodInfo              ,
#endif
    hyperlinkIsValid                        ,




 -- * Properties
-- ** endIndex #attr:endIndex#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    HyperlinkEndIndexPropertyInfo           ,
#endif
    getHyperlinkEndIndex                    ,
#if ENABLE_OVERLOADING
    hyperlinkEndIndex                       ,
#endif


-- ** numberOfAnchors #attr:numberOfAnchors#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    HyperlinkNumberOfAnchorsPropertyInfo    ,
#endif
    getHyperlinkNumberOfAnchors             ,
#if ENABLE_OVERLOADING
    hyperlinkNumberOfAnchors                ,
#endif


-- ** selectedLink #attr:selectedLink#
{- | Selected link
-}
#if ENABLE_OVERLOADING
    HyperlinkSelectedLinkPropertyInfo       ,
#endif
    getHyperlinkSelectedLink                ,
#if ENABLE_OVERLOADING
    hyperlinkSelectedLink                   ,
#endif


-- ** startIndex #attr:startIndex#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    HyperlinkStartIndexPropertyInfo         ,
#endif
    getHyperlinkStartIndex                  ,
#if ENABLE_OVERLOADING
    hyperlinkStartIndex                     ,
#endif




 -- * Signals
-- ** linkActivated #signal:linkActivated#

    C_HyperlinkLinkActivatedCallback        ,
    HyperlinkLinkActivatedCallback          ,
#if ENABLE_OVERLOADING
    HyperlinkLinkActivatedSignalInfo        ,
#endif
    afterHyperlinkLinkActivated             ,
    genClosure_HyperlinkLinkActivated       ,
    mk_HyperlinkLinkActivatedCallback       ,
    noHyperlinkLinkActivatedCallback        ,
    onHyperlinkLinkActivated                ,
    wrap_HyperlinkLinkActivatedCallback     ,




    ) 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import {-# SOURCE #-} qualified GI.Atk.Interfaces.Action as Atk.Action
import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype Hyperlink = Hyperlink (ManagedPtr Hyperlink)
foreign import ccall "atk_hyperlink_get_type"
    c_atk_hyperlink_get_type :: IO GType

instance GObject Hyperlink where
    gobjectType :: Hyperlink -> IO GType
gobjectType _ = IO GType
c_atk_hyperlink_get_type
    

-- | Type class for types which can be safely cast to `Hyperlink`, for instance with `toHyperlink`.
class GObject o => IsHyperlink o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Hyperlink a) =>
    IsHyperlink a
#endif
instance IsHyperlink Hyperlink
instance GObject.Object.IsObject Hyperlink
instance Atk.Action.IsAction Hyperlink

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

-- | A convenience alias for `Nothing` :: `Maybe` `Hyperlink`.
noHyperlink :: Maybe Hyperlink
noHyperlink :: Maybe Hyperlink
noHyperlink = Maybe Hyperlink
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveHyperlinkMethod (t :: Symbol) (o :: *) :: * where
    ResolveHyperlinkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveHyperlinkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveHyperlinkMethod "doAction" o = Atk.Action.ActionDoActionMethodInfo
    ResolveHyperlinkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveHyperlinkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveHyperlinkMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveHyperlinkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveHyperlinkMethod "isInline" o = HyperlinkIsInlineMethodInfo
    ResolveHyperlinkMethod "isSelectedLink" o = HyperlinkIsSelectedLinkMethodInfo
    ResolveHyperlinkMethod "isValid" o = HyperlinkIsValidMethodInfo
    ResolveHyperlinkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveHyperlinkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveHyperlinkMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveHyperlinkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveHyperlinkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveHyperlinkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveHyperlinkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveHyperlinkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveHyperlinkMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveHyperlinkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveHyperlinkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveHyperlinkMethod "getDescription" o = Atk.Action.ActionGetDescriptionMethodInfo
    ResolveHyperlinkMethod "getEndIndex" o = HyperlinkGetEndIndexMethodInfo
    ResolveHyperlinkMethod "getKeybinding" o = Atk.Action.ActionGetKeybindingMethodInfo
    ResolveHyperlinkMethod "getLocalizedName" o = Atk.Action.ActionGetLocalizedNameMethodInfo
    ResolveHyperlinkMethod "getNActions" o = Atk.Action.ActionGetNActionsMethodInfo
    ResolveHyperlinkMethod "getNAnchors" o = HyperlinkGetNAnchorsMethodInfo
    ResolveHyperlinkMethod "getName" o = Atk.Action.ActionGetNameMethodInfo
    ResolveHyperlinkMethod "getObject" o = HyperlinkGetObjectMethodInfo
    ResolveHyperlinkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveHyperlinkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveHyperlinkMethod "getStartIndex" o = HyperlinkGetStartIndexMethodInfo
    ResolveHyperlinkMethod "getUri" o = HyperlinkGetUriMethodInfo
    ResolveHyperlinkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveHyperlinkMethod "setDescription" o = Atk.Action.ActionSetDescriptionMethodInfo
    ResolveHyperlinkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveHyperlinkMethod l o = O.MethodResolutionFailed l o

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

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

#endif

-- signal Hyperlink::link-activated
{- |
The signal link-activated is emitted when a link is activated.
-}
type HyperlinkLinkActivatedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `HyperlinkLinkActivatedCallback`@.
noHyperlinkLinkActivatedCallback :: Maybe HyperlinkLinkActivatedCallback
noHyperlinkLinkActivatedCallback :: Maybe HyperlinkLinkActivatedCallback
noHyperlinkLinkActivatedCallback = Maybe HyperlinkLinkActivatedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_HyperlinkLinkActivated :: HyperlinkLinkActivatedCallback -> IO Closure
genClosure_HyperlinkLinkActivated :: HyperlinkLinkActivatedCallback -> IO Closure
genClosure_HyperlinkLinkActivated cb :: HyperlinkLinkActivatedCallback
cb = do
    let cb' :: C_HyperlinkLinkActivatedCallback
cb' = HyperlinkLinkActivatedCallback -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback HyperlinkLinkActivatedCallback
cb
    C_HyperlinkLinkActivatedCallback
-> IO (FunPtr C_HyperlinkLinkActivatedCallback)
mk_HyperlinkLinkActivatedCallback C_HyperlinkLinkActivatedCallback
cb' IO (FunPtr C_HyperlinkLinkActivatedCallback)
-> (FunPtr C_HyperlinkLinkActivatedCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_HyperlinkLinkActivatedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `HyperlinkLinkActivatedCallback` into a `C_HyperlinkLinkActivatedCallback`.
wrap_HyperlinkLinkActivatedCallback ::
    HyperlinkLinkActivatedCallback ->
    C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback :: HyperlinkLinkActivatedCallback -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback _cb :: HyperlinkLinkActivatedCallback
_cb _ _ = do
    HyperlinkLinkActivatedCallback
_cb 


{- |
Connect a signal handler for the “@link-activated@” 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' hyperlink #linkActivated callback
@
-}
onHyperlinkLinkActivated :: (IsHyperlink a, MonadIO m) => a -> HyperlinkLinkActivatedCallback -> m SignalHandlerId
onHyperlinkLinkActivated :: a -> HyperlinkLinkActivatedCallback -> m SignalHandlerId
onHyperlinkLinkActivated obj :: a
obj cb :: HyperlinkLinkActivatedCallback
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_HyperlinkLinkActivatedCallback
cb' = HyperlinkLinkActivatedCallback -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback HyperlinkLinkActivatedCallback
cb
    FunPtr C_HyperlinkLinkActivatedCallback
cb'' <- C_HyperlinkLinkActivatedCallback
-> IO (FunPtr C_HyperlinkLinkActivatedCallback)
mk_HyperlinkLinkActivatedCallback C_HyperlinkLinkActivatedCallback
cb'
    a
-> String
-> FunPtr C_HyperlinkLinkActivatedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "link-activated" FunPtr C_HyperlinkLinkActivatedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@link-activated@” 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' hyperlink #linkActivated callback
@
-}
afterHyperlinkLinkActivated :: (IsHyperlink a, MonadIO m) => a -> HyperlinkLinkActivatedCallback -> m SignalHandlerId
afterHyperlinkLinkActivated :: a -> HyperlinkLinkActivatedCallback -> m SignalHandlerId
afterHyperlinkLinkActivated obj :: a
obj cb :: HyperlinkLinkActivatedCallback
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_HyperlinkLinkActivatedCallback
cb' = HyperlinkLinkActivatedCallback -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback HyperlinkLinkActivatedCallback
cb
    FunPtr C_HyperlinkLinkActivatedCallback
cb'' <- C_HyperlinkLinkActivatedCallback
-> IO (FunPtr C_HyperlinkLinkActivatedCallback)
mk_HyperlinkLinkActivatedCallback C_HyperlinkLinkActivatedCallback
cb'
    a
-> String
-> FunPtr C_HyperlinkLinkActivatedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "link-activated" FunPtr C_HyperlinkLinkActivatedCallback
cb'' SignalConnectMode
SignalConnectAfter


-- VVV Prop "end-index"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' hyperlink #endIndex
@
-}
getHyperlinkEndIndex :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkEndIndex :: o -> m Int32
getHyperlinkEndIndex obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "end-index"

#if ENABLE_OVERLOADING
data HyperlinkEndIndexPropertyInfo
instance AttrInfo HyperlinkEndIndexPropertyInfo where
    type AttrAllowedOps HyperlinkEndIndexPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint HyperlinkEndIndexPropertyInfo = (~) ()
    type AttrBaseTypeConstraint HyperlinkEndIndexPropertyInfo = IsHyperlink
    type AttrGetType HyperlinkEndIndexPropertyInfo = Int32
    type AttrLabel HyperlinkEndIndexPropertyInfo = "end-index"
    type AttrOrigin HyperlinkEndIndexPropertyInfo = Hyperlink
    attrGet _ = getHyperlinkEndIndex
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "number-of-anchors"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' hyperlink #numberOfAnchors
@
-}
getHyperlinkNumberOfAnchors :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkNumberOfAnchors :: o -> m Int32
getHyperlinkNumberOfAnchors obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "number-of-anchors"

#if ENABLE_OVERLOADING
data HyperlinkNumberOfAnchorsPropertyInfo
instance AttrInfo HyperlinkNumberOfAnchorsPropertyInfo where
    type AttrAllowedOps HyperlinkNumberOfAnchorsPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint HyperlinkNumberOfAnchorsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint HyperlinkNumberOfAnchorsPropertyInfo = IsHyperlink
    type AttrGetType HyperlinkNumberOfAnchorsPropertyInfo = Int32
    type AttrLabel HyperlinkNumberOfAnchorsPropertyInfo = "number-of-anchors"
    type AttrOrigin HyperlinkNumberOfAnchorsPropertyInfo = Hyperlink
    attrGet _ = getHyperlinkNumberOfAnchors
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "selected-link"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' hyperlink #selectedLink
@
-}
getHyperlinkSelectedLink :: (MonadIO m, IsHyperlink o) => o -> m Bool
getHyperlinkSelectedLink :: o -> m Bool
getHyperlinkSelectedLink obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "selected-link"

#if ENABLE_OVERLOADING
data HyperlinkSelectedLinkPropertyInfo
instance AttrInfo HyperlinkSelectedLinkPropertyInfo where
    type AttrAllowedOps HyperlinkSelectedLinkPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint HyperlinkSelectedLinkPropertyInfo = (~) ()
    type AttrBaseTypeConstraint HyperlinkSelectedLinkPropertyInfo = IsHyperlink
    type AttrGetType HyperlinkSelectedLinkPropertyInfo = Bool
    type AttrLabel HyperlinkSelectedLinkPropertyInfo = "selected-link"
    type AttrOrigin HyperlinkSelectedLinkPropertyInfo = Hyperlink
    attrGet _ = getHyperlinkSelectedLink
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "start-index"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' hyperlink #startIndex
@
-}
getHyperlinkStartIndex :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkStartIndex :: o -> m Int32
getHyperlinkStartIndex obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "start-index"

#if ENABLE_OVERLOADING
data HyperlinkStartIndexPropertyInfo
instance AttrInfo HyperlinkStartIndexPropertyInfo where
    type AttrAllowedOps HyperlinkStartIndexPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint HyperlinkStartIndexPropertyInfo = (~) ()
    type AttrBaseTypeConstraint HyperlinkStartIndexPropertyInfo = IsHyperlink
    type AttrGetType HyperlinkStartIndexPropertyInfo = Int32
    type AttrLabel HyperlinkStartIndexPropertyInfo = "start-index"
    type AttrOrigin HyperlinkStartIndexPropertyInfo = Hyperlink
    attrGet _ = getHyperlinkStartIndex
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Hyperlink
type instance O.AttributeList Hyperlink = HyperlinkAttributeList
type HyperlinkAttributeList = ('[ '("endIndex", HyperlinkEndIndexPropertyInfo), '("numberOfAnchors", HyperlinkNumberOfAnchorsPropertyInfo), '("selectedLink", HyperlinkSelectedLinkPropertyInfo), '("startIndex", HyperlinkStartIndexPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
hyperlinkEndIndex :: AttrLabelProxy "endIndex"
hyperlinkEndIndex = AttrLabelProxy

hyperlinkNumberOfAnchors :: AttrLabelProxy "numberOfAnchors"
hyperlinkNumberOfAnchors = AttrLabelProxy

hyperlinkSelectedLink :: AttrLabelProxy "selectedLink"
hyperlinkSelectedLink = AttrLabelProxy

hyperlinkStartIndex :: AttrLabelProxy "startIndex"
hyperlinkStartIndex = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data HyperlinkLinkActivatedSignalInfo
instance SignalInfo HyperlinkLinkActivatedSignalInfo where
    type HaskellCallbackType HyperlinkLinkActivatedSignalInfo = HyperlinkLinkActivatedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_HyperlinkLinkActivatedCallback cb
        cb'' <- mk_HyperlinkLinkActivatedCallback cb'
        connectSignalFunPtr obj "link-activated" cb'' connectMode

type instance O.SignalList Hyperlink = HyperlinkSignalList
type HyperlinkSignalList = ('[ '("linkActivated", HyperlinkLinkActivatedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Hyperlink::get_end_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_hyperlink_get_end_index" atk_hyperlink_get_end_index :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO Int32

{- |
Gets the index with the hypertext document at which this link ends.
-}
hyperlinkGetEndIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Int32
    {- ^ __Returns:__ the index with the hypertext document at which this link ends -}
hyperlinkGetEndIndex :: a -> m Int32
hyperlinkGetEndIndex link_ :: a
link_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    Int32
result <- Ptr Hyperlink -> IO Int32
atk_hyperlink_get_end_index Ptr Hyperlink
link_'
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if ENABLE_OVERLOADING
data HyperlinkGetEndIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkGetEndIndexMethodInfo a signature where
    overloadedMethod _ = hyperlinkGetEndIndex

#endif

-- method Hyperlink::get_n_anchors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_hyperlink_get_n_anchors" atk_hyperlink_get_n_anchors :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO Int32

{- |
Gets the number of anchors associated with this hyperlink.
-}
hyperlinkGetNAnchors ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Int32
    {- ^ __Returns:__ the number of anchors associated with this hyperlink -}
hyperlinkGetNAnchors :: a -> m Int32
hyperlinkGetNAnchors link_ :: a
link_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    Int32
result <- Ptr Hyperlink -> IO Int32
atk_hyperlink_get_n_anchors Ptr Hyperlink
link_'
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if ENABLE_OVERLOADING
data HyperlinkGetNAnchorsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkGetNAnchorsMethodInfo a signature where
    overloadedMethod _ = hyperlinkGetNAnchors

#endif

-- method Hyperlink::get_object
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a (zero-index) integer specifying the desired anchor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))
-- throws : False
-- Skip return : False

foreign import ccall "atk_hyperlink_get_object" atk_hyperlink_get_object :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    Int32 ->                                -- i : TBasicType TInt
    IO (Ptr Atk.Object.Object)

{- |
Returns the item associated with this hyperlinks nth anchor.
For instance, the returned 'GI.Atk.Objects.Object.Object' will implement 'GI.Atk.Interfaces.Text.Text'
if /@link_@/ is a text hyperlink, 'GI.Atk.Interfaces.Image.Image' if /@link_@/ is an image
hyperlink etc.

Multiple anchors are primarily used by client-side image maps.
-}
hyperlinkGetObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> Int32
    {- ^ /@i@/: a (zero-index) integer specifying the desired anchor -}
    -> m Atk.Object.Object
    {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' associated with this hyperlinks
i-th anchor -}
hyperlinkGetObject :: a -> Int32 -> m Object
hyperlinkGetObject link_ :: a
link_ i :: Int32
i = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    Ptr Object
result <- Ptr Hyperlink -> Int32 -> IO (Ptr Object)
atk_hyperlink_get_object Ptr Hyperlink
link_' Int32
i
    Text -> Ptr Object -> HyperlinkLinkActivatedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> HyperlinkLinkActivatedCallback
checkUnexpectedReturnNULL "hyperlinkGetObject" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

#if ENABLE_OVERLOADING
data HyperlinkGetObjectMethodInfo
instance (signature ~ (Int32 -> m Atk.Object.Object), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkGetObjectMethodInfo a signature where
    overloadedMethod _ = hyperlinkGetObject

#endif

-- method Hyperlink::get_start_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_hyperlink_get_start_index" atk_hyperlink_get_start_index :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO Int32

{- |
Gets the index with the hypertext document at which this link begins.
-}
hyperlinkGetStartIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Int32
    {- ^ __Returns:__ the index with the hypertext document at which this link begins -}
hyperlinkGetStartIndex :: a -> m Int32
hyperlinkGetStartIndex link_ :: a
link_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    Int32
result <- Ptr Hyperlink -> IO Int32
atk_hyperlink_get_start_index Ptr Hyperlink
link_'
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if ENABLE_OVERLOADING
data HyperlinkGetStartIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkGetStartIndexMethodInfo a signature where
    overloadedMethod _ = hyperlinkGetStartIndex

#endif

-- method Hyperlink::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a (zero-index) integer specifying the desired anchor", 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 "atk_hyperlink_get_uri" atk_hyperlink_get_uri :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    Int32 ->                                -- i : TBasicType TInt
    IO CString

{- |
Get a the URI associated with the anchor specified
by /@i@/ of /@link_@/.

Multiple anchors are primarily used by client-side image maps.
-}
hyperlinkGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> Int32
    {- ^ /@i@/: a (zero-index) integer specifying the desired anchor -}
    -> m T.Text
    {- ^ __Returns:__ a string specifying the URI -}
hyperlinkGetUri :: a -> Int32 -> m Text
hyperlinkGetUri link_ :: a
link_ i :: Int32
i = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    CString
result <- Ptr Hyperlink -> Int32 -> IO CString
atk_hyperlink_get_uri Ptr Hyperlink
link_' Int32
i
    Text -> CString -> HyperlinkLinkActivatedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> HyperlinkLinkActivatedCallback
checkUnexpectedReturnNULL "hyperlinkGetUri" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> HyperlinkLinkActivatedCallback
forall a. Ptr a -> HyperlinkLinkActivatedCallback
freeMem CString
result
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data HyperlinkGetUriMethodInfo
instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkGetUriMethodInfo a signature where
    overloadedMethod _ = hyperlinkGetUri

#endif

-- method Hyperlink::is_inline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", 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 "atk_hyperlink_is_inline" atk_hyperlink_is_inline :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO CInt

{- |
Indicates whether the link currently displays some or all of its
          content inline.  Ordinary HTML links will usually return
          'False', but an inline &lt;src&gt; HTML element will return
          'True'.
-}
hyperlinkIsInline ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Bool
    {- ^ __Returns:__ whether or not this link displays its content inline. -}
hyperlinkIsInline :: a -> m Bool
hyperlinkIsInline link_ :: a
link_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    CInt
result <- Ptr Hyperlink -> IO CInt
atk_hyperlink_is_inline Ptr Hyperlink
link_'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data HyperlinkIsInlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkIsInlineMethodInfo a signature where
    overloadedMethod _ = hyperlinkIsInline

#endif

-- method Hyperlink::is_selected_link
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", 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 "atk_hyperlink_is_selected_link" atk_hyperlink_is_selected_link :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO CInt

{-# DEPRECATED hyperlinkIsSelectedLink ["(Since version 1.8)","Please use ATK_STATE_FOCUSABLE for all links,","and ATK_STATE_FOCUSED for focused links."] #-}
{- |
Determines whether this AtkHyperlink is selected

/Since: 1.4/
-}
hyperlinkIsSelectedLink ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Bool
    {- ^ __Returns:__ True if the AtkHyperlink is selected, False otherwise -}
hyperlinkIsSelectedLink :: a -> m Bool
hyperlinkIsSelectedLink link_ :: a
link_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    CInt
result <- Ptr Hyperlink -> IO CInt
atk_hyperlink_is_selected_link Ptr Hyperlink
link_'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data HyperlinkIsSelectedLinkMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkIsSelectedLinkMethodInfo a signature where
    overloadedMethod _ = hyperlinkIsSelectedLink

#endif

-- method Hyperlink::is_valid
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "link_", argType = TInterface (Name {namespace = "Atk", name = "Hyperlink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkHyperlink", 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 "atk_hyperlink_is_valid" atk_hyperlink_is_valid :: 
    Ptr Hyperlink ->                        -- link_ : TInterface (Name {namespace = "Atk", name = "Hyperlink"})
    IO CInt

{- |
Since the document that a link is associated with may have changed
this method returns 'True' if the link is still valid (with
respect to the document it references) and 'False' otherwise.
-}
hyperlinkIsValid ::
    (B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
    a
    {- ^ /@link_@/: an 'GI.Atk.Objects.Hyperlink.Hyperlink' -}
    -> m Bool
    {- ^ __Returns:__ whether or not this link is still valid -}
hyperlinkIsValid :: a -> m Bool
hyperlinkIsValid link_ :: a
link_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Hyperlink
link_' <- a -> IO (Ptr Hyperlink)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
link_
    CInt
result <- Ptr Hyperlink -> IO CInt
atk_hyperlink_is_valid Ptr Hyperlink
link_'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> HyperlinkLinkActivatedCallback
forall a.
ManagedPtrNewtype a =>
a -> HyperlinkLinkActivatedCallback
touchManagedPtr a
link_
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data HyperlinkIsValidMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.MethodInfo HyperlinkIsValidMethodInfo a signature where
    overloadedMethod _ = hyperlinkIsValid

#endif