{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gio.Objects.MenuItem.MenuItem' is an opaque structure type.  You must access it using the
-- functions below.
-- 
-- /Since: 2.32/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gio.Objects.MenuItem
    ( 

-- * Exported types
    MenuItem(..)                            ,
    IsMenuItem                              ,
    toMenuItem                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAttributeValue]("GI.Gio.Objects.MenuItem#g:method:getAttributeValue"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getLink]("GI.Gio.Objects.MenuItem#g:method:getLink"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setActionAndTargetValue]("GI.Gio.Objects.MenuItem#g:method:setActionAndTargetValue"), [setAttributeValue]("GI.Gio.Objects.MenuItem#g:method:setAttributeValue"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDetailedAction]("GI.Gio.Objects.MenuItem#g:method:setDetailedAction"), [setIcon]("GI.Gio.Objects.MenuItem#g:method:setIcon"), [setLabel]("GI.Gio.Objects.MenuItem#g:method:setLabel"), [setLink]("GI.Gio.Objects.MenuItem#g:method:setLink"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSection]("GI.Gio.Objects.MenuItem#g:method:setSection"), [setSubmenu]("GI.Gio.Objects.MenuItem#g:method:setSubmenu").

#if defined(ENABLE_OVERLOADING)
    ResolveMenuItemMethod                   ,
#endif

-- ** getAttributeValue #method:getAttributeValue#

#if defined(ENABLE_OVERLOADING)
    MenuItemGetAttributeValueMethodInfo     ,
#endif
    menuItemGetAttributeValue               ,


-- ** getLink #method:getLink#

#if defined(ENABLE_OVERLOADING)
    MenuItemGetLinkMethodInfo               ,
#endif
    menuItemGetLink                         ,


-- ** new #method:new#

    menuItemNew                             ,


-- ** newFromModel #method:newFromModel#

    menuItemNewFromModel                    ,


-- ** newSection #method:newSection#

    menuItemNewSection                      ,


-- ** newSubmenu #method:newSubmenu#

    menuItemNewSubmenu                      ,


-- ** setActionAndTargetValue #method:setActionAndTargetValue#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetActionAndTargetValueMethodInfo,
#endif
    menuItemSetActionAndTargetValue         ,


-- ** setAttributeValue #method:setAttributeValue#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetAttributeValueMethodInfo     ,
#endif
    menuItemSetAttributeValue               ,


-- ** setDetailedAction #method:setDetailedAction#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetDetailedActionMethodInfo     ,
#endif
    menuItemSetDetailedAction               ,


-- ** setIcon #method:setIcon#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetIconMethodInfo               ,
#endif
    menuItemSetIcon                         ,


-- ** setLabel #method:setLabel#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetLabelMethodInfo              ,
#endif
    menuItemSetLabel                        ,


-- ** setLink #method:setLink#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetLinkMethodInfo               ,
#endif
    menuItemSetLink                         ,


-- ** setSection #method:setSection#

#if defined(ENABLE_OVERLOADING)
    MenuItemSetSectionMethodInfo            ,
#endif
    menuItemSetSection                      ,


-- ** setSubmenu #method:setSubmenu#

#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.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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
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.MenuAttributeIter as Gio.MenuAttributeIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuLinkIter as Gio.MenuLinkIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel

#else
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

#endif

-- | Memory-managed wrapper type.
newtype MenuItem = MenuItem (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
$c== :: MenuItem -> MenuItem -> Bool
== :: MenuItem -> MenuItem -> Bool
$c/= :: MenuItem -> MenuItem -> Bool
/= :: 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"
    c_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

-- | Type class for types which can be safely cast to t'MenuItem', for instance with `toMenuItem`.
class (SP.GObject o, O.IsDescendantOf MenuItem o) => IsMenuItem o
instance (SP.GObject o, O.IsDescendantOf MenuItem o) => IsMenuItem o

instance O.HasParentTypes MenuItem
type instance O.ParentTypes MenuItem = '[GObject.Object.Object]

-- | Cast to t'MenuItem', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
toMenuItem :: (MIO.MonadIO m, IsMenuItem o) => o -> m MenuItem
toMenuItem :: forall (m :: * -> *) o.
(MonadIO m, IsMenuItem o) =>
o -> m MenuItem
toMenuItem = IO MenuItem -> m MenuItem
forall a. IO a -> m a
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

-- | Convert t'MenuItem' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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 <- 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 /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject MenuItem ptr
        else return P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveMenuItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 :: MenuItem -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: MenuItem -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: MethodProxy info MenuItem
fromLabel = MethodProxy info MenuItem
forall info obj. MethodProxy info obj
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, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MenuItem = MenuItemSignalList
type MenuItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method MenuItem::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the section label, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_action"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the detailed action string, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuItem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_new" g_menu_item_new :: 
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- detailed_action : TBasicType TUTF8
    IO (Ptr MenuItem)

-- | Creates a new t'GI.Gio.Objects.MenuItem.MenuItem'.
-- 
-- If /@label@/ is non-'P.Nothing' it is used to set the \"label\" attribute of the
-- new item.
-- 
-- If /@detailedAction@/ is non-'P.Nothing' it is used to set the \"action\" and
-- possibly the \"target\" attribute of the new item.  See
-- 'GI.Gio.Objects.MenuItem.menuItemSetDetailedAction' for more information.
-- 
-- /Since: 2.32/
menuItemNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@label@/: the section label, or 'P.Nothing'
    -> Maybe (T.Text)
    -- ^ /@detailedAction@/: the detailed action string, or 'P.Nothing'
    -> m MenuItem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.MenuItem.MenuItem'
menuItemNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> Maybe Text -> m MenuItem
menuItemNew Maybe Text
label Maybe Text
detailedAction = IO MenuItem -> m MenuItem
forall a. IO a -> m a
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
    maybeLabel <- case Maybe Text
label of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jLabel -> do
            jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
            return jLabel'
    maybeDetailedAction <- case detailedAction of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jDetailedAction -> do
            jDetailedAction' <- Text -> IO (Ptr CChar)
textToCString Text
jDetailedAction
            return jDetailedAction'
    result <- g_menu_item_new maybeLabel maybeDetailedAction
    checkUnexpectedReturnNULL "menuItemNew" result
    result' <- (wrapObject MenuItem) result
    freeMem maybeLabel
    freeMem maybeDetailedAction
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MenuItem::new_from_model
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuModel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "item_index"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index of an item in @model"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuItem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_new_from_model" g_menu_item_new_from_model :: 
    Ptr Gio.MenuModel.MenuModel ->          -- model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    Int32 ->                                -- item_index : TBasicType TInt
    IO (Ptr MenuItem)

-- | Creates a t'GI.Gio.Objects.MenuItem.MenuItem' as an exact copy of an existing menu item in a
-- t'GI.Gio.Objects.MenuModel.MenuModel'.
-- 
-- /@itemIndex@/ must be valid (ie: be sure to call
-- 'GI.Gio.Objects.MenuModel.menuModelGetNItems' first).
-- 
-- /Since: 2.34/
menuItemNewFromModel ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
    a
    -- ^ /@model@/: a t'GI.Gio.Objects.MenuModel.MenuModel'
    -> Int32
    -- ^ /@itemIndex@/: the index of an item in /@model@/
    -> m MenuItem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.MenuItem.MenuItem'.
menuItemNewFromModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuModel a) =>
a -> Int32 -> m MenuItem
menuItemNewFromModel a
model Int32
itemIndex = IO MenuItem -> m MenuItem
forall a. IO a -> m a
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
    model' <- a -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
model
    result <- g_menu_item_new_from_model model' itemIndex
    checkUnexpectedReturnNULL "menuItemNewFromModel" result
    result' <- (wrapObject MenuItem) result
    touchManagedPtr model
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MenuItem::new_section
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the section label, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "section"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuModel with the items of the section"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuItem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_new_section" g_menu_item_new_section :: 
    CString ->                              -- label : TBasicType TUTF8
    Ptr Gio.MenuModel.MenuModel ->          -- section : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO (Ptr MenuItem)

-- | Creates a new t'GI.Gio.Objects.MenuItem.MenuItem' representing a section.
-- 
-- This is a convenience API around 'GI.Gio.Objects.MenuItem.menuItemNew' and
-- 'GI.Gio.Objects.MenuItem.menuItemSetSection'.
-- 
-- The effect of having one menu appear as a section of another is
-- exactly as it sounds: the items from /@section@/ become a direct part of
-- the menu that /@menuItem@/ is added to.
-- 
-- Visual separation is typically displayed between two non-empty
-- sections.  If /@label@/ is non-'P.Nothing' then it will be incorporated into
-- this visual indication.  This allows for labeled subsections of a
-- menu.
-- 
-- As a simple example, consider a typical \"Edit\" menu from a simple
-- program.  It probably contains an \"Undo\" and \"Redo\" item, followed by
-- a separator, followed by \"Cut\", \"Copy\" and \"Paste\".
-- 
-- This would be accomplished by creating three t'GI.Gio.Objects.Menu.Menu' instances.  The
-- first would be populated with the \"Undo\" and \"Redo\" items, and the
-- second with the \"Cut\", \"Copy\" and \"Paste\" items.  The first and
-- second menus would then be added as submenus of the third.  In XML
-- format, this would look something like the following:
-- 
-- 	
-- >
-- ><menu id='edit-menu'>
-- >  <section>
-- >    <item label='Undo'/>
-- >    <item label='Redo'/>
-- >  </section>
-- >  <section>
-- >    <item label='Cut'/>
-- >    <item label='Copy'/>
-- >    <item label='Paste'/>
-- >  </section>
-- ></menu>
-- 
-- 
-- The following example is exactly equivalent.  It is more illustrative
-- of the exact relationship between the menus and items (keeping in
-- mind that the \'link\' element defines a new menu that is linked to the
-- containing one).  The style of the second example is more verbose and
-- difficult to read (and therefore not recommended except for the
-- purpose of understanding what is really going on).
-- 
-- 	
-- >
-- ><menu id='edit-menu'>
-- >  <item>
-- >    <link name='section'>
-- >      <item label='Undo'/>
-- >      <item label='Redo'/>
-- >    </link>
-- >  </item>
-- >  <item>
-- >    <link name='section'>
-- >      <item label='Cut'/>
-- >      <item label='Copy'/>
-- >      <item label='Paste'/>
-- >    </link>
-- >  </item>
-- ></menu>
-- 
-- 
-- /Since: 2.32/
menuItemNewSection ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
    Maybe (T.Text)
    -- ^ /@label@/: the section label, or 'P.Nothing'
    -> a
    -- ^ /@section@/: a t'GI.Gio.Objects.MenuModel.MenuModel' with the items of the section
    -> m MenuItem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.MenuItem.MenuItem'
menuItemNewSection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuModel a) =>
Maybe Text -> a -> m MenuItem
menuItemNewSection Maybe Text
label a
section = IO MenuItem -> m MenuItem
forall a. IO a -> m a
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
    maybeLabel <- case Maybe Text
label of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jLabel -> do
            jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
            return jLabel'
    section' <- unsafeManagedPtrCastPtr section
    result <- g_menu_item_new_section maybeLabel section'
    checkUnexpectedReturnNULL "menuItemNewSection" result
    result' <- (wrapObject MenuItem) result
    touchManagedPtr section
    freeMem maybeLabel
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MenuItem::new_submenu
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the section label, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "submenu"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuModel with the items of the submenu"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuItem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_new_submenu" g_menu_item_new_submenu :: 
    CString ->                              -- label : TBasicType TUTF8
    Ptr Gio.MenuModel.MenuModel ->          -- submenu : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO (Ptr MenuItem)

-- | Creates a new t'GI.Gio.Objects.MenuItem.MenuItem' representing a submenu.
-- 
-- This is a convenience API around 'GI.Gio.Objects.MenuItem.menuItemNew' and
-- 'GI.Gio.Objects.MenuItem.menuItemSetSubmenu'.
-- 
-- /Since: 2.32/
menuItemNewSubmenu ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.MenuModel.IsMenuModel a) =>
    Maybe (T.Text)
    -- ^ /@label@/: the section label, or 'P.Nothing'
    -> a
    -- ^ /@submenu@/: a t'GI.Gio.Objects.MenuModel.MenuModel' with the items of the submenu
    -> m MenuItem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.MenuItem.MenuItem'
menuItemNewSubmenu :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuModel a) =>
Maybe Text -> a -> m MenuItem
menuItemNewSubmenu Maybe Text
label a
submenu = IO MenuItem -> m MenuItem
forall a. IO a -> m a
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
    maybeLabel <- case Maybe Text
label of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jLabel -> do
            jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
            return jLabel'
    submenu' <- unsafeManagedPtrCastPtr submenu
    result <- g_menu_item_new_submenu maybeLabel submenu'
    checkUnexpectedReturnNULL "menuItemNewSubmenu" result
    result' <- (wrapObject MenuItem) result
    touchManagedPtr submenu
    freeMem maybeLabel
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MenuItem::get_attribute_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attribute"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the attribute name to query"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expected_type"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "VariantType" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the expected type of the attribute"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_get_attribute_value" g_menu_item_get_attribute_value :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- attribute : TBasicType TUTF8
    Ptr GLib.VariantType.VariantType ->     -- expected_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    IO (Ptr GVariant)

-- | Queries the named /@attribute@/ on /@menuItem@/.
-- 
-- If /@expectedType@/ is specified and the attribute does not have this
-- type, 'P.Nothing' is returned.  'P.Nothing' is also returned if the attribute
-- simply does not exist.
-- 
-- /Since: 2.34/
menuItemGetAttributeValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> T.Text
    -- ^ /@attribute@/: the attribute name to query
    -> Maybe (GLib.VariantType.VariantType)
    -- ^ /@expectedType@/: the expected type of the attribute
    -> m (Maybe GVariant)
    -- ^ __Returns:__ the attribute value, or 'P.Nothing'
menuItemGetAttributeValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> Maybe VariantType -> m (Maybe GVariant)
menuItemGetAttributeValue a
menuItem Text
attribute Maybe VariantType
expectedType = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
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
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    attribute' <- textToCString attribute
    maybeExpectedType <- case expectedType of
        Maybe VariantType
Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
FP.nullPtr
        Just VariantType
jExpectedType -> do
            jExpectedType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jExpectedType
            return jExpectedType'
    result <- g_menu_item_get_attribute_value menuItem' attribute' maybeExpectedType
    maybeResult <- convertIfNonNull result $ \Ptr GVariant
result' -> do
        result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
        return result''
    touchManagedPtr menuItem
    whenJust expectedType touchManagedPtr
    freeMem attribute'
    return 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 :: a -> signature
overloadedMethod = a -> signature
a -> Text -> Maybe VariantType -> m (Maybe GVariant)
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> Maybe VariantType -> m (Maybe GVariant)
menuItemGetAttributeValue

instance O.OverloadedMethodInfo MenuItemGetAttributeValueMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemGetAttributeValue",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemGetAttributeValue"
        })


#endif

-- method MenuItem::get_link
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "link"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the link name to query"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuModel" })
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_get_link" g_menu_item_get_link :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- link : TBasicType TUTF8
    IO (Ptr Gio.MenuModel.MenuModel)

-- | Queries the named /@link@/ on /@menuItem@/.
-- 
-- /Since: 2.34/
menuItemGetLink ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> T.Text
    -- ^ /@link@/: the link name to query
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the link, or 'P.Nothing'
menuItemGetLink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> m (Maybe MenuModel)
menuItemGetLink a
menuItem Text
link = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a. IO a -> m a
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
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    link' <- textToCString link
    result <- g_menu_item_get_link menuItem' link'
    maybeResult <- convertIfNonNull result $ \Ptr MenuModel
result' -> do
        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'
        return result''
    touchManagedPtr menuItem
    freeMem link'
    return 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 :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m (Maybe MenuModel)
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> m (Maybe MenuModel)
menuItemGetLink

instance O.OverloadedMethodInfo MenuItemGetLinkMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemGetLink",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemGetLink"
        })


#endif

-- method MenuItem::set_action_and_target_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the action for this item"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target_value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVariant to use as the action target"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_action_and_target_value" g_menu_item_set_action_and_target_value :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- action : TBasicType TUTF8
    Ptr GVariant ->                         -- target_value : TVariant
    IO ()

-- | Sets or unsets the \"action\" and \"target\" attributes of /@menuItem@/.
-- 
-- If /@action@/ is 'P.Nothing' then both the \"action\" and \"target\" attributes
-- are unset (and /@targetValue@/ is ignored).
-- 
-- If /@action@/ is non-'P.Nothing' then the \"action\" attribute is set.  The
-- \"target\" attribute is then set to the value of /@targetValue@/ if it is
-- non-'P.Nothing' or unset otherwise.
-- 
-- Normal menu items (ie: not submenu, section or other custom item
-- types) are expected to have the \"action\" attribute set to identify
-- the action that they are associated with.  The state type of the
-- action help to determine the disposition of the menu item.  See
-- t'GI.Gio.Interfaces.Action.Action' and t'GI.Gio.Interfaces.ActionGroup.ActionGroup' for an overview of actions.
-- 
-- In general, clicking on the menu item will result in activation of
-- the named action with the \"target\" attribute given as the parameter
-- to the action invocation.  If the \"target\" attribute is not set then
-- the action is invoked with no parameter.
-- 
-- If the action has no state then the menu item is usually drawn as a
-- plain menu item (ie: with no additional decoration).
-- 
-- If the action has a boolean state then the menu item is usually drawn
-- as a toggle menu item (ie: with a checkmark or equivalent
-- indication).  The item should be marked as \'toggled\' or \'checked\'
-- when the boolean state is 'P.True'.
-- 
-- If the action has a string state then the menu item is usually drawn
-- as a radio menu item (ie: with a radio bullet or equivalent
-- indication).  The item should be marked as \'selected\' when the string
-- state is equal to the value of the /@target@/ property.
-- 
-- See @/g_menu_item_set_action_and_target()/@ or
-- 'GI.Gio.Objects.MenuItem.menuItemSetDetailedAction' for two equivalent calls that are
-- probably more convenient for most uses.
-- 
-- /Since: 2.32/
menuItemSetActionAndTargetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> Maybe (T.Text)
    -- ^ /@action@/: the name of the action for this item
    -> Maybe (GVariant)
    -- ^ /@targetValue@/: a t'GVariant' to use as the action target
    -> 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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    maybeAction <- case action of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jAction -> do
            jAction' <- Text -> IO (Ptr CChar)
textToCString Text
jAction
            return jAction'
    maybeTargetValue <- case targetValue of
        Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
FP.nullPtr
        Just GVariant
jTargetValue -> do
            jTargetValue' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jTargetValue
            return jTargetValue'
    g_menu_item_set_action_and_target_value menuItem' maybeAction maybeTargetValue
    touchManagedPtr menuItem
    whenJust targetValue touchManagedPtr
    freeMem maybeAction
    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 :: a -> signature
overloadedMethod = a -> signature
a -> Maybe Text -> Maybe GVariant -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Maybe Text -> Maybe GVariant -> m ()
menuItemSetActionAndTargetValue

instance O.OverloadedMethodInfo MenuItemSetActionAndTargetValueMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetActionAndTargetValue",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetActionAndTargetValue"
        })


#endif

-- method MenuItem::set_attribute_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attribute"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the attribute to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVariant to use as the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_attribute_value" g_menu_item_set_attribute_value :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- attribute : TBasicType TUTF8
    Ptr GVariant ->                         -- value : TVariant
    IO ()

-- | Sets or unsets an attribute on /@menuItem@/.
-- 
-- The attribute to set or unset is specified by /@attribute@/. This
-- can be one of the standard attribute names 'GI.Gio.Constants.MENU_ATTRIBUTE_LABEL',
-- 'GI.Gio.Constants.MENU_ATTRIBUTE_ACTION', 'GI.Gio.Constants.MENU_ATTRIBUTE_TARGET', or a custom
-- attribute name.
-- Attribute names are restricted to lowercase characters, numbers
-- and \'-\'. Furthermore, the names must begin with a lowercase character,
-- must not end with a \'-\', and must not contain consecutive dashes.
-- 
-- must consist only of lowercase
-- ASCII characters, digits and \'-\'.
-- 
-- If /@value@/ is non-'P.Nothing' then it is used as the new value for the
-- attribute.  If /@value@/ is 'P.Nothing' then the attribute is unset. If
-- the /@value@/ t'GVariant' is floating, it is consumed.
-- 
-- See also @/g_menu_item_set_attribute()/@ for a more convenient way to do
-- the same.
-- 
-- /Since: 2.32/
menuItemSetAttributeValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> T.Text
    -- ^ /@attribute@/: the attribute to set
    -> Maybe (GVariant)
    -- ^ /@value@/: a t'GVariant' to use as the value, or 'P.Nothing'
    -> m ()
menuItemSetAttributeValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> Maybe GVariant -> m ()
menuItemSetAttributeValue a
menuItem Text
attribute Maybe GVariant
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    attribute' <- textToCString attribute
    maybeValue <- case value of
        Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
FP.nullPtr
        Just GVariant
jValue -> do
            jValue' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jValue
            return jValue'
    g_menu_item_set_attribute_value menuItem' attribute' maybeValue
    touchManagedPtr menuItem
    whenJust value touchManagedPtr
    freeMem attribute'
    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 :: a -> signature
overloadedMethod = a -> signature
a -> Text -> Maybe GVariant -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> Maybe GVariant -> m ()
menuItemSetAttributeValue

instance O.OverloadedMethodInfo MenuItemSetAttributeValueMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetAttributeValue",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetAttributeValue"
        })


#endif

-- method MenuItem::set_detailed_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_action"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the \"detailed\" action string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_detailed_action" g_menu_item_set_detailed_action :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- detailed_action : TBasicType TUTF8
    IO ()

-- | Sets the \"action\" and possibly the \"target\" attribute of /@menuItem@/.
-- 
-- The format of /@detailedAction@/ is the same format parsed by
-- 'GI.Gio.Functions.actionParseDetailedName'.
-- 
-- See @/g_menu_item_set_action_and_target()/@ or
-- 'GI.Gio.Objects.MenuItem.menuItemSetActionAndTargetValue' for more flexible (but
-- slightly less convenient) alternatives.
-- 
-- See also 'GI.Gio.Objects.MenuItem.menuItemSetActionAndTargetValue' for a description of
-- the semantics of the action and target attributes.
-- 
-- /Since: 2.32/
menuItemSetDetailedAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> T.Text
    -- ^ /@detailedAction@/: the \"detailed\" action string
    -> m ()
menuItemSetDetailedAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> m ()
menuItemSetDetailedAction a
menuItem Text
detailedAction = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    detailedAction' <- textToCString detailedAction
    g_menu_item_set_detailed_action menuItem' detailedAction'
    touchManagedPtr menuItem
    freeMem detailedAction'
    return ()

#if defined(ENABLE_OVERLOADING)
data MenuItemSetDetailedActionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetDetailedActionMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Text -> m ()
menuItemSetDetailedAction

instance O.OverloadedMethodInfo MenuItemSetDetailedActionMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetDetailedAction",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetDetailedAction"
        })


#endif

-- method MenuItem::set_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GIcon, or %NULL" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_icon" g_menu_item_set_icon :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    Ptr Gio.Icon.Icon ->                    -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO ()

-- | Sets (or unsets) the icon on /@menuItem@/.
-- 
-- This call is the same as calling 'GI.Gio.Interfaces.Icon.iconSerialize' and using the
-- result as the value to 'GI.Gio.Objects.MenuItem.menuItemSetAttributeValue' for
-- 'GI.Gio.Constants.MENU_ATTRIBUTE_ICON'.
-- 
-- This API is only intended for use with \"noun\" menu items; things like
-- bookmarks or applications in an \"Open With\" menu.  Don\'t use it on
-- menu items corresponding to verbs (eg: stock icons for \'Save\' or
-- \'Quit\').
-- 
-- If /@icon@/ is 'P.Nothing' then the icon is unset.
-- 
-- /Since: 2.38/
menuItemSetIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.Icon.IsIcon b) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> b
    -- ^ /@icon@/: a t'GI.Gio.Interfaces.Icon.Icon', or 'P.Nothing'
    -> m ()
menuItemSetIcon :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsIcon b) =>
a -> b -> m ()
menuItemSetIcon a
menuItem b
icon = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    icon' <- unsafeManagedPtrCastPtr icon
    g_menu_item_set_icon menuItem' icon'
    touchManagedPtr menuItem
    touchManagedPtr icon
    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 :: a -> signature
overloadedMethod = a -> signature
a -> b -> m ()
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsIcon b) =>
a -> b -> m ()
menuItemSetIcon

instance O.OverloadedMethodInfo MenuItemSetIconMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetIcon",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetIcon"
        })


#endif

-- method MenuItem::set_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the label to set, or %NULL to unset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_label" g_menu_item_set_label :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

-- | Sets or unsets the \"label\" attribute of /@menuItem@/.
-- 
-- If /@label@/ is non-'P.Nothing' it is used as the label for the menu item.  If
-- it is 'P.Nothing' then the label attribute is unset.
-- 
-- /Since: 2.32/
menuItemSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> Maybe (T.Text)
    -- ^ /@label@/: the label to set, or 'P.Nothing' to unset
    -> m ()
menuItemSetLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Maybe Text -> m ()
menuItemSetLabel a
menuItem Maybe Text
label = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    maybeLabel <- case label of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
        Just Text
jLabel -> do
            jLabel' <- Text -> IO (Ptr CChar)
textToCString Text
jLabel
            return jLabel'
    g_menu_item_set_label menuItem' maybeLabel
    touchManagedPtr menuItem
    freeMem maybeLabel
    return ()

#if defined(ENABLE_OVERLOADING)
data MenuItemSetLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsMenuItem a) => O.OverloadedMethod MenuItemSetLabelMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Maybe Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMenuItem a) =>
a -> Maybe Text -> m ()
menuItemSetLabel

instance O.OverloadedMethodInfo MenuItemSetLabelMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetLabel",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetLabel"
        })


#endif

-- method MenuItem::set_link
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "link"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "type of link to establish or unset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GMenuModel to link to (or %NULL to unset)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_link" g_menu_item_set_link :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    CString ->                              -- link : TBasicType TUTF8
    Ptr Gio.MenuModel.MenuModel ->          -- model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Creates a link from /@menuItem@/ to /@model@/ if non-'P.Nothing', or unsets it.
-- 
-- Links are used to establish a relationship between a particular menu
-- item and another menu.  For example, 'GI.Gio.Constants.MENU_LINK_SUBMENU' is used to
-- associate a submenu with a particular menu item, and 'GI.Gio.Constants.MENU_LINK_SECTION'
-- is used to create a section. Other types of link can be used, but there
-- is no guarantee that clients will be able to make sense of them.
-- Link types are restricted to lowercase characters, numbers
-- and \'-\'. Furthermore, the names must begin with a lowercase character,
-- must not end with a \'-\', and must not contain consecutive dashes.
-- 
-- /Since: 2.32/
menuItemSetLink ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> T.Text
    -- ^ /@link@/: type of link to establish or unset
    -> Maybe (b)
    -- ^ /@model@/: the t'GI.Gio.Objects.MenuModel.MenuModel' to link to (or 'P.Nothing' to unset)
    -> m ()
menuItemSetLink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Text -> Maybe b -> m ()
menuItemSetLink a
menuItem Text
link Maybe b
model = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    link' <- textToCString link
    maybeModel <- case model of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
FP.nullPtr
        Just b
jModel -> do
            jModel' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            return jModel'
    g_menu_item_set_link menuItem' link' maybeModel
    touchManagedPtr menuItem
    whenJust model touchManagedPtr
    freeMem link'
    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 :: a -> signature
overloadedMethod = a -> signature
a -> Text -> Maybe b -> m ()
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Text -> Maybe b -> m ()
menuItemSetLink

instance O.OverloadedMethodInfo MenuItemSetLinkMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetLink",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetLink"
        })


#endif

-- method MenuItem::set_section
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "section"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuModel, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_section" g_menu_item_set_section :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    Ptr Gio.MenuModel.MenuModel ->          -- section : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets or unsets the \"section\" link of /@menuItem@/ to /@section@/.
-- 
-- The effect of having one menu appear as a section of another is
-- exactly as it sounds: the items from /@section@/ become a direct part of
-- the menu that /@menuItem@/ is added to.  See 'GI.Gio.Objects.MenuItem.menuItemNewSection'
-- for more information about what it means for a menu item to be a
-- section.
-- 
-- /Since: 2.32/
menuItemSetSection ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> Maybe (b)
    -- ^ /@section@/: a t'GI.Gio.Objects.MenuModel.MenuModel', or 'P.Nothing'
    -> m ()
menuItemSetSection :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Maybe b -> m ()
menuItemSetSection a
menuItem Maybe b
section = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    maybeSection <- case section of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
FP.nullPtr
        Just b
jSection -> do
            jSection' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSection
            return jSection'
    g_menu_item_set_section menuItem' maybeSection
    touchManagedPtr menuItem
    whenJust section touchManagedPtr
    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 :: a -> signature
overloadedMethod = a -> signature
a -> Maybe b -> m ()
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Maybe b -> m ()
menuItemSetSection

instance O.OverloadedMethodInfo MenuItemSetSectionMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetSection",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetSection"
        })


#endif

-- method MenuItem::set_submenu
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "menu_item"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "submenu"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMenuModel, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_menu_item_set_submenu" g_menu_item_set_submenu :: 
    Ptr MenuItem ->                         -- menu_item : TInterface (Name {namespace = "Gio", name = "MenuItem"})
    Ptr Gio.MenuModel.MenuModel ->          -- submenu : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets or unsets the \"submenu\" link of /@menuItem@/ to /@submenu@/.
-- 
-- If /@submenu@/ is non-'P.Nothing', it is linked to.  If it is 'P.Nothing' then the
-- link is unset.
-- 
-- The effect of having one menu appear as a submenu of another is
-- exactly as it sounds.
-- 
-- /Since: 2.32/
menuItemSetSubmenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsMenuItem a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@menuItem@/: a t'GI.Gio.Objects.MenuItem.MenuItem'
    -> Maybe (b)
    -- ^ /@submenu@/: a t'GI.Gio.Objects.MenuModel.MenuModel', or 'P.Nothing'
    -> m ()
menuItemSetSubmenu :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Maybe b -> m ()
menuItemSetSubmenu a
menuItem Maybe b
submenu = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    menuItem' <- a -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menuItem
    maybeSubmenu <- case submenu of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
FP.nullPtr
        Just b
jSubmenu -> do
            jSubmenu' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSubmenu
            return jSubmenu'
    g_menu_item_set_submenu menuItem' maybeSubmenu
    touchManagedPtr menuItem
    whenJust submenu touchManagedPtr
    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 :: a -> signature
overloadedMethod = a -> signature
a -> Maybe b -> m ()
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMenuItem a, IsMenuModel b) =>
a -> Maybe b -> m ()
menuItemSetSubmenu

instance O.OverloadedMethodInfo MenuItemSetSubmenuMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Objects.MenuItem.menuItemSetSubmenu",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Objects-MenuItem.html#v:menuItemSetSubmenu"
        })


#endif