{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Objects.Hyperlink
(
Hyperlink(..) ,
IsHyperlink ,
toHyperlink ,
#if defined(ENABLE_OVERLOADING)
ResolveHyperlinkMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
HyperlinkGetEndIndexMethodInfo ,
#endif
hyperlinkGetEndIndex ,
#if defined(ENABLE_OVERLOADING)
HyperlinkGetNAnchorsMethodInfo ,
#endif
hyperlinkGetNAnchors ,
#if defined(ENABLE_OVERLOADING)
HyperlinkGetObjectMethodInfo ,
#endif
hyperlinkGetObject ,
#if defined(ENABLE_OVERLOADING)
HyperlinkGetStartIndexMethodInfo ,
#endif
hyperlinkGetStartIndex ,
#if defined(ENABLE_OVERLOADING)
HyperlinkGetUriMethodInfo ,
#endif
hyperlinkGetUri ,
#if defined(ENABLE_OVERLOADING)
HyperlinkIsInlineMethodInfo ,
#endif
hyperlinkIsInline ,
#if defined(ENABLE_OVERLOADING)
HyperlinkIsSelectedLinkMethodInfo ,
#endif
hyperlinkIsSelectedLink ,
#if defined(ENABLE_OVERLOADING)
HyperlinkIsValidMethodInfo ,
#endif
hyperlinkIsValid ,
#if defined(ENABLE_OVERLOADING)
HyperlinkEndIndexPropertyInfo ,
#endif
getHyperlinkEndIndex ,
#if defined(ENABLE_OVERLOADING)
hyperlinkEndIndex ,
#endif
#if defined(ENABLE_OVERLOADING)
HyperlinkNumberOfAnchorsPropertyInfo ,
#endif
getHyperlinkNumberOfAnchors ,
#if defined(ENABLE_OVERLOADING)
hyperlinkNumberOfAnchors ,
#endif
#if defined(ENABLE_OVERLOADING)
HyperlinkSelectedLinkPropertyInfo ,
#endif
getHyperlinkSelectedLink ,
#if defined(ENABLE_OVERLOADING)
hyperlinkSelectedLink ,
#endif
#if defined(ENABLE_OVERLOADING)
HyperlinkStartIndexPropertyInfo ,
#endif
getHyperlinkStartIndex ,
#if defined(ENABLE_OVERLOADING)
hyperlinkStartIndex ,
#endif
HyperlinkLinkActivatedCallback ,
#if defined(ENABLE_OVERLOADING)
HyperlinkLinkActivatedSignalInfo ,
#endif
afterHyperlinkLinkActivated ,
onHyperlinkLinkActivated ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# 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
newtype Hyperlink = Hyperlink (SP.ManagedPtr Hyperlink)
deriving (Hyperlink -> Hyperlink -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hyperlink -> Hyperlink -> Bool
$c/= :: Hyperlink -> Hyperlink -> Bool
== :: Hyperlink -> Hyperlink -> Bool
$c== :: Hyperlink -> Hyperlink -> Bool
Eq)
instance SP.ManagedPtrNewtype Hyperlink where
toManagedPtr :: Hyperlink -> ManagedPtr Hyperlink
toManagedPtr (Hyperlink ManagedPtr Hyperlink
p) = ManagedPtr Hyperlink
p
foreign import ccall "atk_hyperlink_get_type"
c_atk_hyperlink_get_type :: IO B.Types.GType
instance B.Types.TypedObject Hyperlink where
glibType :: IO GType
glibType = IO GType
c_atk_hyperlink_get_type
instance B.Types.GObject Hyperlink
class (SP.GObject o, O.IsDescendantOf Hyperlink o) => IsHyperlink o
instance (SP.GObject o, O.IsDescendantOf Hyperlink o) => IsHyperlink o
instance O.HasParentTypes Hyperlink
type instance O.ParentTypes Hyperlink = '[GObject.Object.Object, Atk.Action.Action]
toHyperlink :: (MIO.MonadIO m, IsHyperlink o) => o -> m Hyperlink
toHyperlink :: forall (m :: * -> *) o.
(MonadIO m, IsHyperlink o) =>
o -> m Hyperlink
toHyperlink = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Hyperlink -> Hyperlink
Hyperlink
instance B.GValue.IsGValue (Maybe Hyperlink) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_hyperlink_get_type
gvalueSet_ :: Ptr GValue -> Maybe Hyperlink -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Hyperlink
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Hyperlink)
gvalueSet_ Ptr GValue
gv (P.Just Hyperlink
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Hyperlink
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Hyperlink)
gvalueGet_ Ptr GValue
gv = do
Ptr Hyperlink
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Hyperlink)
if Ptr Hyperlink
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Hyperlink -> Hyperlink
Hyperlink Ptr Hyperlink
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveHyperlinkMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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.OverloadedMethod info Hyperlink p) => OL.IsLabel t (Hyperlink -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveHyperlinkMethod t Hyperlink, O.OverloadedMethod info Hyperlink p, R.HasField t Hyperlink p) => R.HasField t Hyperlink p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHyperlinkMethod t Hyperlink, O.OverloadedMethodInfo info Hyperlink) => OL.IsLabel t (O.MethodProxy info Hyperlink) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type HyperlinkLinkActivatedCallback =
IO ()
type C_HyperlinkLinkActivatedCallback =
Ptr Hyperlink ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_HyperlinkLinkActivatedCallback :: C_HyperlinkLinkActivatedCallback -> IO (FunPtr C_HyperlinkLinkActivatedCallback)
wrap_HyperlinkLinkActivatedCallback ::
GObject a => (a -> HyperlinkLinkActivatedCallback) ->
C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback a -> IO ()
gi'cb Ptr Hyperlink
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Hyperlink
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Hyperlink
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Hyperlink
gi'self)
onHyperlinkLinkActivated :: (IsHyperlink a, MonadIO m) => a -> ((?self :: a) => HyperlinkLinkActivatedCallback) -> m SignalHandlerId
onHyperlinkLinkActivated :: forall a (m :: * -> *).
(IsHyperlink a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onHyperlinkLinkActivated a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_HyperlinkLinkActivatedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback a -> IO ()
wrapped
FunPtr C_HyperlinkLinkActivatedCallback
wrapped'' <- C_HyperlinkLinkActivatedCallback
-> IO (FunPtr C_HyperlinkLinkActivatedCallback)
mk_HyperlinkLinkActivatedCallback C_HyperlinkLinkActivatedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"link-activated" FunPtr C_HyperlinkLinkActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterHyperlinkLinkActivated :: (IsHyperlink a, MonadIO m) => a -> ((?self :: a) => HyperlinkLinkActivatedCallback) -> m SignalHandlerId
afterHyperlinkLinkActivated :: forall a (m :: * -> *).
(IsHyperlink a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterHyperlinkLinkActivated a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_HyperlinkLinkActivatedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_HyperlinkLinkActivatedCallback
wrap_HyperlinkLinkActivatedCallback a -> IO ()
wrapped
FunPtr C_HyperlinkLinkActivatedCallback
wrapped'' <- C_HyperlinkLinkActivatedCallback
-> IO (FunPtr C_HyperlinkLinkActivatedCallback)
mk_HyperlinkLinkActivatedCallback C_HyperlinkLinkActivatedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"link-activated" FunPtr C_HyperlinkLinkActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data HyperlinkLinkActivatedSignalInfo
instance SignalInfo HyperlinkLinkActivatedSignalInfo where
type HaskellCallbackType HyperlinkLinkActivatedSignalInfo = HyperlinkLinkActivatedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_HyperlinkLinkActivatedCallback cb
cb'' <- mk_HyperlinkLinkActivatedCallback cb'
connectSignalFunPtr obj "link-activated" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink::link-activated"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#g:signal:linkActivated"})
#endif
getHyperlinkEndIndex :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkEndIndex :: forall (m :: * -> *) o. (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkEndIndex o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"end-index"
#if defined(ENABLE_OVERLOADING)
data HyperlinkEndIndexPropertyInfo
instance AttrInfo HyperlinkEndIndexPropertyInfo where
type AttrAllowedOps HyperlinkEndIndexPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint HyperlinkEndIndexPropertyInfo = IsHyperlink
type AttrSetTypeConstraint HyperlinkEndIndexPropertyInfo = (~) ()
type AttrTransferTypeConstraint HyperlinkEndIndexPropertyInfo = (~) ()
type AttrTransferType HyperlinkEndIndexPropertyInfo = ()
type AttrGetType HyperlinkEndIndexPropertyInfo = Int32
type AttrLabel HyperlinkEndIndexPropertyInfo = "end-index"
type AttrOrigin HyperlinkEndIndexPropertyInfo = Hyperlink
attrGet = getHyperlinkEndIndex
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.endIndex"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#g:attr:endIndex"
})
#endif
getHyperlinkNumberOfAnchors :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkNumberOfAnchors :: forall (m :: * -> *) o. (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkNumberOfAnchors o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"number-of-anchors"
#if defined(ENABLE_OVERLOADING)
data HyperlinkNumberOfAnchorsPropertyInfo
instance AttrInfo HyperlinkNumberOfAnchorsPropertyInfo where
type AttrAllowedOps HyperlinkNumberOfAnchorsPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint HyperlinkNumberOfAnchorsPropertyInfo = IsHyperlink
type AttrSetTypeConstraint HyperlinkNumberOfAnchorsPropertyInfo = (~) ()
type AttrTransferTypeConstraint HyperlinkNumberOfAnchorsPropertyInfo = (~) ()
type AttrTransferType HyperlinkNumberOfAnchorsPropertyInfo = ()
type AttrGetType HyperlinkNumberOfAnchorsPropertyInfo = Int32
type AttrLabel HyperlinkNumberOfAnchorsPropertyInfo = "number-of-anchors"
type AttrOrigin HyperlinkNumberOfAnchorsPropertyInfo = Hyperlink
attrGet = getHyperlinkNumberOfAnchors
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.numberOfAnchors"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#g:attr:numberOfAnchors"
})
#endif
getHyperlinkSelectedLink :: (MonadIO m, IsHyperlink o) => o -> m Bool
getHyperlinkSelectedLink :: forall (m :: * -> *) o. (MonadIO m, IsHyperlink o) => o -> m Bool
getHyperlinkSelectedLink o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"selected-link"
#if defined(ENABLE_OVERLOADING)
data HyperlinkSelectedLinkPropertyInfo
instance AttrInfo HyperlinkSelectedLinkPropertyInfo where
type AttrAllowedOps HyperlinkSelectedLinkPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint HyperlinkSelectedLinkPropertyInfo = IsHyperlink
type AttrSetTypeConstraint HyperlinkSelectedLinkPropertyInfo = (~) ()
type AttrTransferTypeConstraint HyperlinkSelectedLinkPropertyInfo = (~) ()
type AttrTransferType HyperlinkSelectedLinkPropertyInfo = ()
type AttrGetType HyperlinkSelectedLinkPropertyInfo = Bool
type AttrLabel HyperlinkSelectedLinkPropertyInfo = "selected-link"
type AttrOrigin HyperlinkSelectedLinkPropertyInfo = Hyperlink
attrGet = getHyperlinkSelectedLink
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.selectedLink"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#g:attr:selectedLink"
})
#endif
getHyperlinkStartIndex :: (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkStartIndex :: forall (m :: * -> *) o. (MonadIO m, IsHyperlink o) => o -> m Int32
getHyperlinkStartIndex o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"start-index"
#if defined(ENABLE_OVERLOADING)
data HyperlinkStartIndexPropertyInfo
instance AttrInfo HyperlinkStartIndexPropertyInfo where
type AttrAllowedOps HyperlinkStartIndexPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint HyperlinkStartIndexPropertyInfo = IsHyperlink
type AttrSetTypeConstraint HyperlinkStartIndexPropertyInfo = (~) ()
type AttrTransferTypeConstraint HyperlinkStartIndexPropertyInfo = (~) ()
type AttrTransferType HyperlinkStartIndexPropertyInfo = ()
type AttrGetType HyperlinkStartIndexPropertyInfo = Int32
type AttrLabel HyperlinkStartIndexPropertyInfo = "start-index"
type AttrOrigin HyperlinkStartIndexPropertyInfo = Hyperlink
attrGet = getHyperlinkStartIndex
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.startIndex"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#g:attr:startIndex"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Hyperlink
type instance O.AttributeList Hyperlink = HyperlinkAttributeList
type HyperlinkAttributeList = ('[ '("endIndex", HyperlinkEndIndexPropertyInfo), '("numberOfAnchors", HyperlinkNumberOfAnchorsPropertyInfo), '("selectedLink", HyperlinkSelectedLinkPropertyInfo), '("startIndex", HyperlinkStartIndexPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
hyperlinkEndIndex :: AttrLabelProxy "endIndex"
hyperlinkEndIndex = AttrLabelProxy
hyperlinkNumberOfAnchors :: AttrLabelProxy "numberOfAnchors"
hyperlinkNumberOfAnchors = AttrLabelProxy
hyperlinkSelectedLink :: AttrLabelProxy "selectedLink"
hyperlinkSelectedLink = AttrLabelProxy
hyperlinkStartIndex :: AttrLabelProxy "startIndex"
hyperlinkStartIndex = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Hyperlink = HyperlinkSignalList
type HyperlinkSignalList = ('[ '("linkActivated", HyperlinkLinkActivatedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "atk_hyperlink_get_end_index" atk_hyperlink_get_end_index ::
Ptr Hyperlink ->
IO Int32
hyperlinkGetEndIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Int32
hyperlinkGetEndIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Int32
hyperlinkGetEndIndex a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data HyperlinkGetEndIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkGetEndIndexMethodInfo a signature where
overloadedMethod = hyperlinkGetEndIndex
instance O.OverloadedMethodInfo HyperlinkGetEndIndexMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkGetEndIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkGetEndIndex"
})
#endif
foreign import ccall "atk_hyperlink_get_n_anchors" atk_hyperlink_get_n_anchors ::
Ptr Hyperlink ->
IO Int32
hyperlinkGetNAnchors ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Int32
hyperlinkGetNAnchors :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Int32
hyperlinkGetNAnchors a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data HyperlinkGetNAnchorsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkGetNAnchorsMethodInfo a signature where
overloadedMethod = hyperlinkGetNAnchors
instance O.OverloadedMethodInfo HyperlinkGetNAnchorsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkGetNAnchors",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkGetNAnchors"
})
#endif
foreign import ccall "atk_hyperlink_get_object" atk_hyperlink_get_object ::
Ptr Hyperlink ->
Int32 ->
IO (Ptr Atk.Object.Object)
hyperlinkGetObject ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> Int32
-> m Atk.Object.Object
hyperlinkGetObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> Int32 -> m Object
hyperlinkGetObject a
link_ Int32
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hyperlinkGetObject" Ptr Object
result
Object
result' <- (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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'
#if defined(ENABLE_OVERLOADING)
data HyperlinkGetObjectMethodInfo
instance (signature ~ (Int32 -> m Atk.Object.Object), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkGetObjectMethodInfo a signature where
overloadedMethod = hyperlinkGetObject
instance O.OverloadedMethodInfo HyperlinkGetObjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkGetObject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkGetObject"
})
#endif
foreign import ccall "atk_hyperlink_get_start_index" atk_hyperlink_get_start_index ::
Ptr Hyperlink ->
IO Int32
hyperlinkGetStartIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Int32
hyperlinkGetStartIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Int32
hyperlinkGetStartIndex a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data HyperlinkGetStartIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkGetStartIndexMethodInfo a signature where
overloadedMethod = hyperlinkGetStartIndex
instance O.OverloadedMethodInfo HyperlinkGetStartIndexMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkGetStartIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkGetStartIndex"
})
#endif
foreign import ccall "atk_hyperlink_get_uri" atk_hyperlink_get_uri ::
Ptr Hyperlink ->
Int32 ->
IO CString
hyperlinkGetUri ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> Int32
-> m T.Text
hyperlinkGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> Int32 -> m Text
hyperlinkGetUri a
link_ Int32
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hyperlinkGetUri" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data HyperlinkGetUriMethodInfo
instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkGetUriMethodInfo a signature where
overloadedMethod = hyperlinkGetUri
instance O.OverloadedMethodInfo HyperlinkGetUriMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkGetUri",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkGetUri"
})
#endif
foreign import ccall "atk_hyperlink_is_inline" atk_hyperlink_is_inline ::
Ptr Hyperlink ->
IO CInt
hyperlinkIsInline ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Bool
hyperlinkIsInline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Bool
hyperlinkIsInline a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data HyperlinkIsInlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkIsInlineMethodInfo a signature where
overloadedMethod = hyperlinkIsInline
instance O.OverloadedMethodInfo HyperlinkIsInlineMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkIsInline",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkIsInline"
})
#endif
foreign import ccall "atk_hyperlink_is_selected_link" atk_hyperlink_is_selected_link ::
Ptr Hyperlink ->
IO CInt
{-# DEPRECATED hyperlinkIsSelectedLink ["(Since version 1.8)","Please use ATK_STATE_FOCUSABLE for all links,","and ATK_STATE_FOCUSED for focused links."] #-}
hyperlinkIsSelectedLink ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Bool
hyperlinkIsSelectedLink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Bool
hyperlinkIsSelectedLink a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data HyperlinkIsSelectedLinkMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkIsSelectedLinkMethodInfo a signature where
overloadedMethod = hyperlinkIsSelectedLink
instance O.OverloadedMethodInfo HyperlinkIsSelectedLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkIsSelectedLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkIsSelectedLink"
})
#endif
foreign import ccall "atk_hyperlink_is_valid" atk_hyperlink_is_valid ::
Ptr Hyperlink ->
IO CInt
hyperlinkIsValid ::
(B.CallStack.HasCallStack, MonadIO m, IsHyperlink a) =>
a
-> m Bool
hyperlinkIsValid :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsHyperlink a) =>
a -> m Bool
hyperlinkIsValid a
link_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hyperlink
link_' <- 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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
link_
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data HyperlinkIsValidMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsHyperlink a) => O.OverloadedMethod HyperlinkIsValidMethodInfo a signature where
overloadedMethod = hyperlinkIsValid
instance O.OverloadedMethodInfo HyperlinkIsValidMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Hyperlink.hyperlinkIsValid",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Hyperlink.html#v:hyperlinkIsValid"
})
#endif