{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.MnemonicAction
(
MnemonicAction(..) ,
IsMnemonicAction ,
toMnemonicAction ,
#if defined(ENABLE_OVERLOADING)
ResolveMnemonicActionMethod ,
#endif
mnemonicActionGet ,
) 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.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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.ShortcutAction as Gtk.ShortcutAction
newtype MnemonicAction = MnemonicAction (SP.ManagedPtr MnemonicAction)
deriving (MnemonicAction -> MnemonicAction -> Bool
(MnemonicAction -> MnemonicAction -> Bool)
-> (MnemonicAction -> MnemonicAction -> Bool) -> Eq MnemonicAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MnemonicAction -> MnemonicAction -> Bool
$c/= :: MnemonicAction -> MnemonicAction -> Bool
== :: MnemonicAction -> MnemonicAction -> Bool
$c== :: MnemonicAction -> MnemonicAction -> Bool
Eq)
instance SP.ManagedPtrNewtype MnemonicAction where
toManagedPtr :: MnemonicAction -> ManagedPtr MnemonicAction
toManagedPtr (MnemonicAction ManagedPtr MnemonicAction
p) = ManagedPtr MnemonicAction
p
foreign import ccall "gtk_mnemonic_action_get_type"
c_gtk_mnemonic_action_get_type :: IO B.Types.GType
instance B.Types.TypedObject MnemonicAction where
glibType :: IO GType
glibType = IO GType
c_gtk_mnemonic_action_get_type
instance B.Types.GObject MnemonicAction
instance B.GValue.IsGValue MnemonicAction where
toGValue :: MnemonicAction -> IO GValue
toGValue MnemonicAction
o = do
GType
gtype <- IO GType
c_gtk_mnemonic_action_get_type
MnemonicAction -> (Ptr MnemonicAction -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MnemonicAction
o (GType
-> (GValue -> Ptr MnemonicAction -> IO ())
-> Ptr MnemonicAction
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr MnemonicAction -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO MnemonicAction
fromGValue GValue
gv = do
Ptr MnemonicAction
ptr <- GValue -> IO (Ptr MnemonicAction)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr MnemonicAction)
(ManagedPtr MnemonicAction -> MnemonicAction)
-> Ptr MnemonicAction -> IO MnemonicAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr MnemonicAction -> MnemonicAction
MnemonicAction Ptr MnemonicAction
ptr
class (SP.GObject o, O.IsDescendantOf MnemonicAction o) => IsMnemonicAction o
instance (SP.GObject o, O.IsDescendantOf MnemonicAction o) => IsMnemonicAction o
instance O.HasParentTypes MnemonicAction
type instance O.ParentTypes MnemonicAction = '[Gtk.ShortcutAction.ShortcutAction, GObject.Object.Object]
toMnemonicAction :: (MonadIO m, IsMnemonicAction o) => o -> m MnemonicAction
toMnemonicAction :: o -> m MnemonicAction
toMnemonicAction = IO MnemonicAction -> m MnemonicAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MnemonicAction -> m MnemonicAction)
-> (o -> IO MnemonicAction) -> o -> m MnemonicAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr MnemonicAction -> MnemonicAction)
-> o -> IO MnemonicAction
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr MnemonicAction -> MnemonicAction
MnemonicAction
#if defined(ENABLE_OVERLOADING)
type family ResolveMnemonicActionMethod (t :: Symbol) (o :: *) :: * where
ResolveMnemonicActionMethod "activate" o = Gtk.ShortcutAction.ShortcutActionActivateMethodInfo
ResolveMnemonicActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMnemonicActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMnemonicActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMnemonicActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMnemonicActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMnemonicActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMnemonicActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMnemonicActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMnemonicActionMethod "print" o = Gtk.ShortcutAction.ShortcutActionPrintMethodInfo
ResolveMnemonicActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMnemonicActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMnemonicActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMnemonicActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMnemonicActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMnemonicActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMnemonicActionMethod "toString" o = Gtk.ShortcutAction.ShortcutActionToStringMethodInfo
ResolveMnemonicActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMnemonicActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMnemonicActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMnemonicActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMnemonicActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMnemonicActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMnemonicActionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMnemonicActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMnemonicActionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMnemonicActionMethod t MnemonicAction, O.MethodInfo info MnemonicAction p) => OL.IsLabel t (MnemonicAction -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MnemonicAction
type instance O.AttributeList MnemonicAction = MnemonicActionAttributeList
type MnemonicActionAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MnemonicAction = MnemonicActionSignalList
type MnemonicActionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_mnemonic_action_get" gtk_mnemonic_action_get ::
IO (Ptr Gtk.ShortcutAction.ShortcutAction)
mnemonicActionGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gtk.ShortcutAction.ShortcutAction
mnemonicActionGet :: m ShortcutAction
mnemonicActionGet = IO ShortcutAction -> m ShortcutAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ShortcutAction -> m ShortcutAction)
-> IO ShortcutAction -> m ShortcutAction
forall a b. (a -> b) -> a -> b
$ do
Ptr ShortcutAction
result <- IO (Ptr ShortcutAction)
gtk_mnemonic_action_get
Text -> Ptr ShortcutAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mnemonicActionGet" Ptr ShortcutAction
result
ShortcutAction
result' <- ((ManagedPtr ShortcutAction -> ShortcutAction)
-> Ptr ShortcutAction -> IO ShortcutAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ShortcutAction -> ShortcutAction
Gtk.ShortcutAction.ShortcutAction) Ptr ShortcutAction
result
ShortcutAction -> IO ShortcutAction
forall (m :: * -> *) a. Monad m => a -> m a
return ShortcutAction
result'
#if defined(ENABLE_OVERLOADING)
#endif