{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.Tooltip
(
Tooltip(..) ,
IsTooltip ,
toTooltip ,
#if defined(ENABLE_OVERLOADING)
ResolveTooltipMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TooltipSetCustomMethodInfo ,
#endif
tooltipSetCustom ,
#if defined(ENABLE_OVERLOADING)
TooltipSetIconMethodInfo ,
#endif
tooltipSetIcon ,
#if defined(ENABLE_OVERLOADING)
TooltipSetIconFromGiconMethodInfo ,
#endif
tooltipSetIconFromGicon ,
#if defined(ENABLE_OVERLOADING)
TooltipSetIconFromIconNameMethodInfo ,
#endif
tooltipSetIconFromIconName ,
#if defined(ENABLE_OVERLOADING)
TooltipSetIconFromStockMethodInfo ,
#endif
tooltipSetIconFromStock ,
#if defined(ENABLE_OVERLOADING)
TooltipSetMarkupMethodInfo ,
#endif
tooltipSetMarkup ,
#if defined(ENABLE_OVERLOADING)
TooltipSetTextMethodInfo ,
#endif
tooltipSetText ,
#if defined(ENABLE_OVERLOADING)
TooltipSetTipAreaMethodInfo ,
#endif
tooltipSetTipArea ,
tooltipTriggerTooltipQuery ,
) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
newtype Tooltip = Tooltip (SP.ManagedPtr Tooltip)
deriving (Tooltip -> Tooltip -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tooltip -> Tooltip -> Bool
$c/= :: Tooltip -> Tooltip -> Bool
== :: Tooltip -> Tooltip -> Bool
$c== :: Tooltip -> Tooltip -> Bool
Eq)
instance SP.ManagedPtrNewtype Tooltip where
toManagedPtr :: Tooltip -> ManagedPtr Tooltip
toManagedPtr (Tooltip ManagedPtr Tooltip
p) = ManagedPtr Tooltip
p
foreign import ccall "gtk_tooltip_get_type"
c_gtk_tooltip_get_type :: IO B.Types.GType
instance B.Types.TypedObject Tooltip where
glibType :: IO GType
glibType = IO GType
c_gtk_tooltip_get_type
instance B.Types.GObject Tooltip
class (SP.GObject o, O.IsDescendantOf Tooltip o) => IsTooltip o
instance (SP.GObject o, O.IsDescendantOf Tooltip o) => IsTooltip o
instance O.HasParentTypes Tooltip
type instance O.ParentTypes Tooltip = '[GObject.Object.Object]
toTooltip :: (MIO.MonadIO m, IsTooltip o) => o -> m Tooltip
toTooltip :: forall (m :: * -> *) o. (MonadIO m, IsTooltip o) => o -> m Tooltip
toTooltip = 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 Tooltip -> Tooltip
Tooltip
instance B.GValue.IsGValue (Maybe Tooltip) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_tooltip_get_type
gvalueSet_ :: Ptr GValue -> Maybe Tooltip -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Tooltip
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 Tooltip)
gvalueSet_ Ptr GValue
gv (P.Just Tooltip
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Tooltip
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Tooltip)
gvalueGet_ Ptr GValue
gv = do
Ptr Tooltip
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Tooltip)
if Ptr Tooltip
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 Tooltip -> Tooltip
Tooltip Ptr Tooltip
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveTooltipMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTooltipMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTooltipMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTooltipMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTooltipMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTooltipMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTooltipMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTooltipMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTooltipMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTooltipMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTooltipMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTooltipMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTooltipMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTooltipMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTooltipMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTooltipMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTooltipMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTooltipMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTooltipMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTooltipMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTooltipMethod "setCustom" o = TooltipSetCustomMethodInfo
ResolveTooltipMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTooltipMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTooltipMethod "setIcon" o = TooltipSetIconMethodInfo
ResolveTooltipMethod "setIconFromGicon" o = TooltipSetIconFromGiconMethodInfo
ResolveTooltipMethod "setIconFromIconName" o = TooltipSetIconFromIconNameMethodInfo
ResolveTooltipMethod "setIconFromStock" o = TooltipSetIconFromStockMethodInfo
ResolveTooltipMethod "setMarkup" o = TooltipSetMarkupMethodInfo
ResolveTooltipMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTooltipMethod "setText" o = TooltipSetTextMethodInfo
ResolveTooltipMethod "setTipArea" o = TooltipSetTipAreaMethodInfo
ResolveTooltipMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTooltipMethod t Tooltip, O.OverloadedMethod info Tooltip p) => OL.IsLabel t (Tooltip -> 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 ~ ResolveTooltipMethod t Tooltip, O.OverloadedMethod info Tooltip p, R.HasField t Tooltip p) => R.HasField t Tooltip p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTooltipMethod t Tooltip, O.OverloadedMethodInfo info Tooltip) => OL.IsLabel t (O.MethodProxy info Tooltip) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Tooltip
type instance O.AttributeList Tooltip = TooltipAttributeList
type TooltipAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Tooltip = TooltipSignalList
type TooltipSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_tooltip_set_custom" gtk_tooltip_set_custom ::
Ptr Tooltip ->
Ptr Gtk.Widget.Widget ->
IO ()
tooltipSetCustom ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a, Gtk.Widget.IsWidget b) =>
a
-> Maybe (b)
-> m ()
tooltipSetCustom :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTooltip a, IsWidget b) =>
a -> Maybe b -> m ()
tooltipSetCustom a
tooltip Maybe b
customWidget = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr Widget
maybeCustomWidget <- case Maybe b
customWidget of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCustomWidget -> do
Ptr Widget
jCustomWidget' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCustomWidget
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jCustomWidget'
Ptr Tooltip -> Ptr Widget -> IO ()
gtk_tooltip_set_custom Ptr Tooltip
tooltip' Ptr Widget
maybeCustomWidget
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
customWidget forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetCustomMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTooltip a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TooltipSetCustomMethodInfo a signature where
overloadedMethod = tooltipSetCustom
instance O.OverloadedMethodInfo TooltipSetCustomMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetCustom",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetCustom"
})
#endif
foreign import ccall "gtk_tooltip_set_icon" gtk_tooltip_set_icon ::
Ptr Tooltip ->
Ptr GdkPixbuf.Pixbuf.Pixbuf ->
IO ()
tooltipSetIcon ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a, GdkPixbuf.Pixbuf.IsPixbuf b) =>
a
-> Maybe (b)
-> m ()
tooltipSetIcon :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTooltip a, IsPixbuf b) =>
a -> Maybe b -> m ()
tooltipSetIcon a
tooltip Maybe b
pixbuf = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr Pixbuf
maybePixbuf <- case Maybe b
pixbuf of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jPixbuf -> do
Ptr Pixbuf
jPixbuf' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jPixbuf
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pixbuf
jPixbuf'
Ptr Tooltip -> Ptr Pixbuf -> IO ()
gtk_tooltip_set_icon Ptr Tooltip
tooltip' Ptr Pixbuf
maybePixbuf
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
pixbuf forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetIconMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTooltip a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.OverloadedMethod TooltipSetIconMethodInfo a signature where
overloadedMethod = tooltipSetIcon
instance O.OverloadedMethodInfo TooltipSetIconMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetIcon",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetIcon"
})
#endif
foreign import ccall "gtk_tooltip_set_icon_from_gicon" gtk_tooltip_set_icon_from_gicon ::
Ptr Tooltip ->
Ptr Gio.Icon.Icon ->
Int32 ->
IO ()
tooltipSetIconFromGicon ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a, Gio.Icon.IsIcon b) =>
a
-> Maybe (b)
-> Int32
-> m ()
tooltipSetIconFromGicon :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTooltip a, IsIcon b) =>
a -> Maybe b -> Int32 -> m ()
tooltipSetIconFromGicon a
tooltip Maybe b
gicon Int32
size = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr Icon
maybeGicon <- case Maybe b
gicon of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jGicon -> do
Ptr Icon
jGicon' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jGicon
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Icon
jGicon'
Ptr Tooltip -> Ptr Icon -> Int32 -> IO ()
gtk_tooltip_set_icon_from_gicon Ptr Tooltip
tooltip' Ptr Icon
maybeGicon Int32
size
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
gicon forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetIconFromGiconMethodInfo
instance (signature ~ (Maybe (b) -> Int32 -> m ()), MonadIO m, IsTooltip a, Gio.Icon.IsIcon b) => O.OverloadedMethod TooltipSetIconFromGiconMethodInfo a signature where
overloadedMethod = tooltipSetIconFromGicon
instance O.OverloadedMethodInfo TooltipSetIconFromGiconMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetIconFromGicon",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetIconFromGicon"
})
#endif
foreign import ccall "gtk_tooltip_set_icon_from_icon_name" gtk_tooltip_set_icon_from_icon_name ::
Ptr Tooltip ->
CString ->
Int32 ->
IO ()
tooltipSetIconFromIconName ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a) =>
a
-> Maybe (T.Text)
-> Int32
-> m ()
tooltipSetIconFromIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTooltip a) =>
a -> Maybe Text -> Int32 -> m ()
tooltipSetIconFromIconName a
tooltip Maybe Text
iconName Int32
size = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr CChar
maybeIconName <- case Maybe Text
iconName of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jIconName -> do
Ptr CChar
jIconName' <- Text -> IO (Ptr CChar)
textToCString Text
jIconName
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jIconName'
Ptr Tooltip -> Ptr CChar -> Int32 -> IO ()
gtk_tooltip_set_icon_from_icon_name Ptr Tooltip
tooltip' Ptr CChar
maybeIconName Int32
size
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeIconName
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetIconFromIconNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m, IsTooltip a) => O.OverloadedMethod TooltipSetIconFromIconNameMethodInfo a signature where
overloadedMethod = tooltipSetIconFromIconName
instance O.OverloadedMethodInfo TooltipSetIconFromIconNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetIconFromIconName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetIconFromIconName"
})
#endif
foreign import ccall "gtk_tooltip_set_icon_from_stock" gtk_tooltip_set_icon_from_stock ::
Ptr Tooltip ->
CString ->
Int32 ->
IO ()
{-# DEPRECATED tooltipSetIconFromStock ["(Since version 3.10)","Use 'GI.Gtk.Objects.Tooltip.tooltipSetIconFromIconName' instead."] #-}
tooltipSetIconFromStock ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a) =>
a
-> Maybe (T.Text)
-> Int32
-> m ()
tooltipSetIconFromStock :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTooltip a) =>
a -> Maybe Text -> Int32 -> m ()
tooltipSetIconFromStock a
tooltip Maybe Text
stockId Int32
size = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr CChar
maybeStockId <- case Maybe Text
stockId of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jStockId -> do
Ptr CChar
jStockId' <- Text -> IO (Ptr CChar)
textToCString Text
jStockId
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jStockId'
Ptr Tooltip -> Ptr CChar -> Int32 -> IO ()
gtk_tooltip_set_icon_from_stock Ptr Tooltip
tooltip' Ptr CChar
maybeStockId Int32
size
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeStockId
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetIconFromStockMethodInfo
instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m, IsTooltip a) => O.OverloadedMethod TooltipSetIconFromStockMethodInfo a signature where
overloadedMethod = tooltipSetIconFromStock
instance O.OverloadedMethodInfo TooltipSetIconFromStockMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetIconFromStock",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetIconFromStock"
})
#endif
foreign import ccall "gtk_tooltip_set_markup" gtk_tooltip_set_markup ::
Ptr Tooltip ->
CString ->
IO ()
tooltipSetMarkup ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a) =>
a
-> Maybe (T.Text)
-> m ()
tooltipSetMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTooltip a) =>
a -> Maybe Text -> m ()
tooltipSetMarkup a
tooltip Maybe Text
markup = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr CChar
maybeMarkup <- case Maybe Text
markup of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jMarkup -> do
Ptr CChar
jMarkup' <- Text -> IO (Ptr CChar)
textToCString Text
jMarkup
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jMarkup'
Ptr Tooltip -> Ptr CChar -> IO ()
gtk_tooltip_set_markup Ptr Tooltip
tooltip' Ptr CChar
maybeMarkup
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeMarkup
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetMarkupMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTooltip a) => O.OverloadedMethod TooltipSetMarkupMethodInfo a signature where
overloadedMethod = tooltipSetMarkup
instance O.OverloadedMethodInfo TooltipSetMarkupMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetMarkup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetMarkup"
})
#endif
foreign import ccall "gtk_tooltip_set_text" gtk_tooltip_set_text ::
Ptr Tooltip ->
CString ->
IO ()
tooltipSetText ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a) =>
a
-> Maybe (T.Text)
-> m ()
tooltipSetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTooltip a) =>
a -> Maybe Text -> m ()
tooltipSetText a
tooltip Maybe Text
text = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr CChar
maybeText <- case Maybe Text
text of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jText -> do
Ptr CChar
jText' <- Text -> IO (Ptr CChar)
textToCString Text
jText
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jText'
Ptr Tooltip -> Ptr CChar -> IO ()
gtk_tooltip_set_text Ptr Tooltip
tooltip' Ptr CChar
maybeText
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeText
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetTextMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTooltip a) => O.OverloadedMethod TooltipSetTextMethodInfo a signature where
overloadedMethod = tooltipSetText
instance O.OverloadedMethodInfo TooltipSetTextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetText",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetText"
})
#endif
foreign import ccall "gtk_tooltip_set_tip_area" gtk_tooltip_set_tip_area ::
Ptr Tooltip ->
Ptr Gdk.Rectangle.Rectangle ->
IO ()
tooltipSetTipArea ::
(B.CallStack.HasCallStack, MonadIO m, IsTooltip a) =>
a
-> Gdk.Rectangle.Rectangle
-> m ()
tooltipSetTipArea :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTooltip a) =>
a -> Rectangle -> m ()
tooltipSetTipArea a
tooltip Rectangle
rect = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Tooltip
tooltip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
tooltip
Ptr Rectangle
rect' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
rect
Ptr Tooltip -> Ptr Rectangle -> IO ()
gtk_tooltip_set_tip_area Ptr Tooltip
tooltip' Ptr Rectangle
rect'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
tooltip
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
rect
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TooltipSetTipAreaMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> m ()), MonadIO m, IsTooltip a) => O.OverloadedMethod TooltipSetTipAreaMethodInfo a signature where
overloadedMethod = tooltipSetTipArea
instance O.OverloadedMethodInfo TooltipSetTipAreaMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.Tooltip.tooltipSetTipArea",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-Tooltip.html#v:tooltipSetTipArea"
})
#endif
foreign import ccall "gtk_tooltip_trigger_tooltip_query" gtk_tooltip_trigger_tooltip_query ::
Ptr Gdk.Display.Display ->
IO ()
tooltipTriggerTooltipQuery ::
(B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
a
-> m ()
tooltipTriggerTooltipQuery :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplay a) =>
a -> m ()
tooltipTriggerTooltipQuery a
display = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Display
display' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Display -> IO ()
gtk_tooltip_trigger_tooltip_query Ptr Display
display'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif