{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.MenuItem
(
MenuItem(..) ,
IsMenuItem ,
toMenuItem ,
#if defined(ENABLE_OVERLOADING)
ResolveMenuItemMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MenuItemGetAttributeValueMethodInfo ,
#endif
menuItemGetAttributeValue ,
#if defined(ENABLE_OVERLOADING)
MenuItemGetLinkMethodInfo ,
#endif
menuItemGetLink ,
menuItemNew ,
menuItemNewFromModel ,
menuItemNewSection ,
menuItemNewSubmenu ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetActionAndTargetValueMethodInfo,
#endif
menuItemSetActionAndTargetValue ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetAttributeValueMethodInfo ,
#endif
menuItemSetAttributeValue ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetDetailedActionMethodInfo ,
#endif
menuItemSetDetailedAction ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetIconMethodInfo ,
#endif
menuItemSetIcon ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetLabelMethodInfo ,
#endif
menuItemSetLabel ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetLinkMethodInfo ,
#endif
menuItemSetLink ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetSectionMethodInfo ,
#endif
menuItemSetSection ,
#if defined(ENABLE_OVERLOADING)
MenuItemSetSubmenuMethodInfo ,
#endif
menuItemSetSubmenu ,
) 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.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.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.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
newtype = (SP.ManagedPtr MenuItem)
deriving (MenuItem -> MenuItem -> Bool
(MenuItem -> MenuItem -> Bool)
-> (MenuItem -> MenuItem -> Bool) -> Eq MenuItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MenuItem -> MenuItem -> Bool
$c/= :: MenuItem -> MenuItem -> Bool
== :: MenuItem -> MenuItem -> Bool
$c== :: MenuItem -> MenuItem -> Bool
Eq)
instance SP.ManagedPtrNewtype MenuItem where
toManagedPtr :: MenuItem -> ManagedPtr MenuItem
toManagedPtr (MenuItem ManagedPtr MenuItem
p) = ManagedPtr MenuItem
p
foreign import ccall "g_menu_item_get_type"
:: IO B.Types.GType
instance B.Types.TypedObject MenuItem where
glibType :: IO GType
glibType = IO GType
c_g_menu_item_get_type
instance B.Types.GObject MenuItem
class (SP.GObject o, O.IsDescendantOf MenuItem o) => o
instance (SP.GObject o, O.IsDescendantOf MenuItem o) => IsMenuItem o
instance O.HasParentTypes MenuItem
type instance O.ParentTypes MenuItem = '[GObject.Object.Object]
toMenuItem :: (MIO.MonadIO m, IsMenuItem o) => o -> m MenuItem
= IO MenuItem -> m MenuItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO MenuItem -> m MenuItem)
-> (o -> IO MenuItem) -> o -> m MenuItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr MenuItem -> MenuItem) -> o -> IO MenuItem
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr MenuItem -> MenuItem
MenuItem
instance B.GValue.IsGValue (Maybe MenuItem) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_menu_item_get_type
gvalueSet_ :: Ptr GValue -> Maybe MenuItem -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MenuItem
P.Nothing = Ptr GValue -> Ptr MenuItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr MenuItem
forall a. Ptr a
FP.nullPtr :: FP.Ptr MenuItem)
gvalueSet_ Ptr GValue
gv (P.Just MenuItem
obj) = MenuItem -> (Ptr MenuItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MenuItem
obj (Ptr GValue -> Ptr MenuItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MenuItem)
gvalueGet_ Ptr GValue
gv = do
Ptr MenuItem
ptr <- Ptr GValue -> IO (Ptr MenuItem)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr MenuItem)
if Ptr MenuItem
ptr Ptr MenuItem -> Ptr MenuItem -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MenuItem
forall a. Ptr a
FP.nullPtr
then MenuItem -> Maybe MenuItem
forall a. a -> Maybe a
P.Just (MenuItem -> Maybe MenuItem) -> IO MenuItem -> IO (Maybe MenuItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr MenuItem -> MenuItem) -> Ptr MenuItem -> IO MenuItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr MenuItem -> MenuItem
MenuItem Ptr MenuItem
ptr
else Maybe MenuItem -> IO (Maybe MenuItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuItem
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveMenuItemMethod (t :: Symbol) (o :: *) :: * where
ResolveMenuItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMenuItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMenuItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMenuItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMenuItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMenuItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMenuItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMenuItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMenuItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMenuItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMenuItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMenuItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMenuItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMenuItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMenuItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMenuItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMenuItemMethod "getAttributeValue" o = MenuItemGetAttributeValueMethodInfo
ResolveMenuItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMenuItemMethod "getLink" o = MenuItemGetLinkMethodInfo
ResolveMenuItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMenuItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMenuItemMethod "setActionAndTargetValue" o = MenuItemSetActionAndTargetValueMethodInfo
ResolveMenuItemMethod "setAttributeValue" o = MenuItemSetAttributeValueMethodInfo
ResolveMenuItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMenuItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMenuItemMethod "setDetailedAction" o = MenuItemSetDetailedActionMethodInfo
ResolveMenuItemMethod "setIcon" o = MenuItemSetIconMethodInfo
ResolveMenuItemMethod "setLabel" o = MenuItemSetLabelMethodInfo
ResolveMenuItemMethod "setLink" o = MenuItemSetLinkMethodInfo
ResolveMenuItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMenuItemMethod "setSection" o = MenuItemSetSectionMethodInfo
ResolveMenuItemMethod "setSubmenu" o = MenuItemSetSubmenuMethodInfo
ResolveMenuItemMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMenuItemMethod t MenuItem, O.OverloadedMethod info MenuItem p) => OL.IsLabel t (MenuItem -> 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 ~ ResolveMenuItemMethod t MenuItem, O.OverloadedMethod info MenuItem p, R.HasField t MenuItem p) => R.HasField t MenuItem p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMenuItemMethod t MenuItem, O.OverloadedMethodInfo info MenuItem) => OL.IsLabel t (O.MethodProxy info MenuItem) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MenuItem
type instance O.AttributeList MenuItem = MenuItemAttributeList
type MenuItemAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MenuItem = MenuItemSignalList
type MenuItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_menu_item_new" ::
CString ->
CString ->
IO (Ptr MenuItem)
menuItemNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Maybe (T.Text)
-> m MenuItem
Maybe Text
label Maybe Text
detailedAction = IO MenuItem -> m MenuItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MenuItem -> m MenuItem) -> IO MenuItem -> m MenuItem
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeLabel <- case Maybe Text
label of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jLabel -> do
Ptr CChar
jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jLabel'
Ptr CChar
maybeDetailedAction <- case Maybe Text
detailedAction of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jDetailedAction -> do
Ptr CChar
jDetailedAction' <- Text -> IO (Ptr CChar)
textToCString Text
jDetailedAction
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDetailedAction'
Ptr MenuItem
result <- Ptr CChar -> Ptr CChar -> IO (Ptr MenuItem)
g_menu_item_new Ptr CChar
maybeLabel Ptr CChar
maybeDetailedAction
Text -> Ptr MenuItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuItemNew" Ptr MenuItem
result
MenuItem
result' <- ((ManagedPtr MenuItem -> MenuItem) -> Ptr MenuItem -> IO MenuItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuItem -> MenuItem
MenuItem) Ptr MenuItem
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeLabel
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeDetailedAction
MenuItem -> IO MenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return MenuItem
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_menu_item_new_from_model" ::
Ptr Gio.MenuModel.MenuModel ->
Int32 ->
IO (Ptr MenuItem)
menuItemNewFromModel ::
(B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
a
-> Int32
-> m MenuItem
a
model Int32
itemIndex = IO MenuItem -> m MenuItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MenuItem -> m MenuItem) -> IO MenuItem -> m MenuItem
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuModel
model' <- a -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
model
Ptr MenuItem
result <- Ptr MenuModel -> Int32 -> IO (Ptr MenuItem)
g_menu_item_new_from_model Ptr MenuModel
model' Int32
itemIndex
Text -> Ptr MenuItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuItemNewFromModel" Ptr MenuItem
result
MenuItem
result' <- ((ManagedPtr MenuItem -> MenuItem) -> Ptr MenuItem -> IO MenuItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuItem -> MenuItem
MenuItem) Ptr MenuItem
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
model
MenuItem -> IO MenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return MenuItem
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_menu_item_new_section" ::
CString ->
Ptr Gio.MenuModel.MenuModel ->
IO (Ptr MenuItem)
menuItemNewSection ::
(B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
Maybe (T.Text)
-> a
-> m MenuItem
Maybe Text
label a
section = IO MenuItem -> m MenuItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MenuItem -> m MenuItem) -> IO MenuItem -> m MenuItem
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeLabel <- case Maybe Text
label of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jLabel -> do
Ptr CChar
jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jLabel'
Ptr MenuModel
section' <- a -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
section
Ptr MenuItem
result <- Ptr CChar -> Ptr MenuModel -> IO (Ptr MenuItem)
g_menu_item_new_section Ptr CChar
maybeLabel Ptr MenuModel
section'
Text -> Ptr MenuItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuItemNewSection" Ptr MenuItem
result
MenuItem
result' <- ((ManagedPtr MenuItem -> MenuItem) -> Ptr MenuItem -> IO MenuItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuItem -> MenuItem
MenuItem) Ptr MenuItem
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
section
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeLabel
MenuItem -> IO MenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return MenuItem
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_menu_item_new_submenu" ::
CString ->
Ptr Gio.MenuModel.MenuModel ->
IO (Ptr MenuItem)
menuItemNewSubmenu ::
(B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
Maybe (T.Text)
-> a
-> m MenuItem
Maybe Text
label a
submenu = IO MenuItem -> m MenuItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MenuItem -> m MenuItem) -> IO MenuItem -> m MenuItem
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeLabel <- case Maybe Text
label of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jLabel -> do
Ptr CChar
jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jLabel'
Ptr MenuModel
submenu' <- a -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
submenu
Ptr MenuItem
result <- Ptr CChar -> Ptr MenuModel -> IO (Ptr MenuItem)
g_menu_item_new_submenu Ptr CChar
maybeLabel Ptr MenuModel
submenu'
Text -> Ptr MenuItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuItemNewSubmenu" Ptr MenuItem
result
MenuItem
result' <- ((ManagedPtr MenuItem -> MenuItem) -> Ptr MenuItem -> IO MenuItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuItem -> MenuItem
MenuItem) Ptr MenuItem
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
submenu
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeLabel
MenuItem -> IO MenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return MenuItem
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_menu_item_get_attribute_value" ::
Ptr MenuItem ->
CString ->
Ptr GLib.VariantType.VariantType ->
IO (Ptr GVariant)
menuItemGetAttributeValue ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> T.Text
-> Maybe (GLib.VariantType.VariantType)
-> m (Maybe GVariant)
a
menuItem Text
attribute Maybe VariantType
expectedType = IO (Maybe GVariant) -> m (Maybe GVariant)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
attribute' <- Text -> IO (Ptr CChar)
textToCString Text
attribute
Ptr VariantType
maybeExpectedType <- case Maybe VariantType
expectedType of
Maybe VariantType
Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
Just VariantType
jExpectedType -> do
Ptr VariantType
jExpectedType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jExpectedType
Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jExpectedType'
Ptr GVariant
result <- Ptr MenuItem -> Ptr CChar -> Ptr VariantType -> IO (Ptr GVariant)
g_menu_item_get_attribute_value Ptr MenuItem
menuItem' Ptr CChar
attribute' Ptr VariantType
maybeExpectedType
Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
expectedType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
attribute'
Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
#if defined(ENABLE_OVERLOADING)
data MenuItemGetAttributeValueMethodInfo
instance (signature ~ (T.Text -> Maybe (GLib.VariantType.VariantType) -> m (Maybe GVariant)), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemGetAttributeValueMethodInfo a signature where
overloadedMethod = menuItemGetAttributeValue
instance O.OverloadedMethodInfo MenuItemGetAttributeValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemGetAttributeValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemGetAttributeValue"
})
#endif
foreign import ccall "g_menu_item_get_link" ::
Ptr MenuItem ->
CString ->
IO (Ptr Gio.MenuModel.MenuModel)
menuItemGetLink ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> T.Text
-> m (Maybe Gio.MenuModel.MenuModel)
a
menuItem Text
link = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
link' <- Text -> IO (Ptr CChar)
textToCString Text
link
Ptr MenuModel
result <- Ptr MenuItem -> Ptr CChar -> IO (Ptr MenuModel)
g_menu_item_get_link Ptr MenuItem
menuItem' Ptr CChar
link'
Maybe MenuModel
maybeResult <- Ptr MenuModel
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MenuModel
result ((Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel))
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ \Ptr MenuModel
result' -> do
MenuModel
result'' <- ((ManagedPtr MenuModel -> MenuModel)
-> Ptr MenuModel -> IO MenuModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result'
MenuModel -> IO MenuModel
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
link'
Maybe MenuModel -> IO (Maybe MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuModel
maybeResult
#if defined(ENABLE_OVERLOADING)
data MenuItemGetLinkMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemGetLinkMethodInfo a signature where
overloadedMethod = menuItemGetLink
instance O.OverloadedMethodInfo MenuItemGetLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemGetLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemGetLink"
})
#endif
foreign import ccall "g_menu_item_set_action_and_target_value" g_menu_item_set_action_and_target_value ::
Ptr MenuItem ->
CString ->
Ptr GVariant ->
IO ()
menuItemSetActionAndTargetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> Maybe (T.Text)
-> Maybe (GVariant)
-> m ()
menuItemSetActionAndTargetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Maybe Text -> Maybe GVariant -> m ()
menuItemSetActionAndTargetValue a
menuItem Maybe Text
action Maybe GVariant
targetValue = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
maybeAction <- case Maybe Text
action of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jAction -> do
Ptr CChar
jAction' <- Text -> IO (Ptr CChar)
textToCString Text
jAction
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jAction'
Ptr GVariant
maybeTargetValue <- case Maybe GVariant
targetValue of
Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
Just GVariant
jTargetValue -> do
Ptr GVariant
jTargetValue' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jTargetValue
Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jTargetValue'
Ptr MenuItem -> Ptr CChar -> Ptr GVariant -> IO ()
g_menu_item_set_action_and_target_value Ptr MenuItem
menuItem' Ptr CChar
maybeAction Ptr GVariant
maybeTargetValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
targetValue GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeAction
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetActionAndTargetValueMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (GVariant) -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetActionAndTargetValueMethodInfo a signature where
overloadedMethod = menuItemSetActionAndTargetValue
instance O.OverloadedMethodInfo MenuItemSetActionAndTargetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetActionAndTargetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetActionAndTargetValue"
})
#endif
foreign import ccall "g_menu_item_set_attribute_value" ::
Ptr MenuItem ->
CString ->
Ptr GVariant ->
IO ()
menuItemSetAttributeValue ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> T.Text
-> Maybe (GVariant)
-> m ()
a
menuItem Text
attribute Maybe GVariant
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
attribute' <- Text -> IO (Ptr CChar)
textToCString Text
attribute
Ptr GVariant
maybeValue <- case Maybe GVariant
value of
Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
Just GVariant
jValue -> do
Ptr GVariant
jValue' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jValue
Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jValue'
Ptr MenuItem -> Ptr CChar -> Ptr GVariant -> IO ()
g_menu_item_set_attribute_value Ptr MenuItem
menuItem' Ptr CChar
attribute' Ptr GVariant
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
value GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
attribute'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetAttributeValueMethodInfo
instance (signature ~ (T.Text -> Maybe (GVariant) -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetAttributeValueMethodInfo a signature where
overloadedMethod = menuItemSetAttributeValue
instance O.OverloadedMethodInfo MenuItemSetAttributeValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetAttributeValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetAttributeValue"
})
#endif
foreign import ccall "g_menu_item_set_detailed_action" ::
Ptr MenuItem ->
CString ->
IO ()
menuItemSetDetailedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> T.Text
-> m ()
a
menuItem Text
detailedAction = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
detailedAction' <- Text -> IO (Ptr CChar)
textToCString Text
detailedAction
Ptr MenuItem -> Ptr CChar -> IO ()
g_menu_item_set_detailed_action Ptr MenuItem
menuItem' Ptr CChar
detailedAction'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
detailedAction'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetDetailedActionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetDetailedActionMethodInfo a signature where
overloadedMethod = menuItemSetDetailedAction
instance O.OverloadedMethodInfo MenuItemSetDetailedActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetDetailedAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetDetailedAction"
})
#endif
foreign import ccall "g_menu_item_set_icon" ::
Ptr MenuItem ->
Ptr Gio.Icon.Icon ->
IO ()
menuItemSetIcon ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.Icon.IsIcon b) =>
a
-> b
-> m ()
a
menuItem b
icon = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr Icon
icon' <- b -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
icon
Ptr MenuItem -> Ptr Icon -> IO ()
g_menu_item_set_icon Ptr MenuItem
menuItem' Ptr Icon
icon'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
icon
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetIconMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsMenuItem a, Gio.Icon.IsIcon b) => O.OverloadedMethod MenuItemSetIconMethodInfo a signature where
overloadedMethod = menuItemSetIcon
instance O.OverloadedMethodInfo MenuItemSetIconMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetIcon",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetIcon"
})
#endif
foreign import ccall "g_menu_item_set_label" ::
Ptr MenuItem ->
CString ->
IO ()
menuItemSetLabel ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
a
-> Maybe (T.Text)
-> m ()
a
menuItem Maybe Text
label = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
maybeLabel <- case Maybe Text
label of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jLabel -> do
Ptr CChar
jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jLabel'
Ptr MenuItem -> Ptr CChar -> IO ()
g_menu_item_set_label Ptr MenuItem
menuItem' Ptr CChar
maybeLabel
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeLabel
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetLabelMethodInfo a signature where
overloadedMethod = menuItemSetLabel
instance O.OverloadedMethodInfo MenuItemSetLabelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetLabel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetLabel"
})
#endif
foreign import ccall "g_menu_item_set_link" ::
Ptr MenuItem ->
CString ->
Ptr Gio.MenuModel.MenuModel ->
IO ()
menuItemSetLink ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
a
-> T.Text
-> Maybe (b)
-> m ()
a
menuItem Text
link Maybe b
model = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr CChar
link' <- Text -> IO (Ptr CChar)
textToCString Text
link
Ptr MenuModel
maybeModel <- case Maybe b
model of
Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
nullPtr
Just b
jModel -> do
Ptr MenuModel
jModel' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jModel'
Ptr MenuItem -> Ptr CChar -> Ptr MenuModel -> IO ()
g_menu_item_set_link Ptr MenuItem
menuItem' Ptr CChar
link' Ptr MenuModel
maybeModel
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
link'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetLinkMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod MenuItemSetLinkMethodInfo a signature where
overloadedMethod = menuItemSetLink
instance O.OverloadedMethodInfo MenuItemSetLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetLink"
})
#endif
foreign import ccall "g_menu_item_set_section" ::
Ptr MenuItem ->
Ptr Gio.MenuModel.MenuModel ->
IO ()
menuItemSetSection ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
a
-> Maybe (b)
-> m ()
a
menuItem Maybe b
section = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr MenuModel
maybeSection <- case Maybe b
section of
Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
nullPtr
Just b
jSection -> do
Ptr MenuModel
jSection' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSection
Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jSection'
Ptr MenuItem -> Ptr MenuModel -> IO ()
g_menu_item_set_section Ptr MenuItem
menuItem' Ptr MenuModel
maybeSection
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
section b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetSectionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod MenuItemSetSectionMethodInfo a signature where
overloadedMethod = menuItemSetSection
instance O.OverloadedMethodInfo MenuItemSetSectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetSection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetSection"
})
#endif
foreign import ccall "g_menu_item_set_submenu" ::
Ptr MenuItem ->
Ptr Gio.MenuModel.MenuModel ->
IO ()
menuItemSetSubmenu ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
a
-> Maybe (b)
-> m ()
a
menuItem Maybe b
submenu = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MenuItem
menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
Ptr MenuModel
maybeSubmenu <- case Maybe b
submenu of
Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
nullPtr
Just b
jSubmenu -> do
Ptr MenuModel
jSubmenu' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSubmenu
Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jSubmenu'
Ptr MenuItem -> Ptr MenuModel -> IO ()
g_menu_item_set_submenu Ptr MenuItem
menuItem' Ptr MenuModel
maybeSubmenu
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menuItem
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
submenu b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MenuItemSetSubmenuMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod MenuItemSetSubmenuMethodInfo a signature where
overloadedMethod = menuItemSetSubmenu
instance O.OverloadedMethodInfo MenuItemSetSubmenuMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuItem.menuItemSetSubmenu",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.29/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetSubmenu"
})
#endif