{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GtkSource.Interfaces.UndoManager
(
UndoManager(..) ,
IsUndoManager ,
toUndoManager ,
#if defined(ENABLE_OVERLOADING)
ResolveUndoManagerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UndoManagerBeginNotUndoableActionMethodInfo,
#endif
undoManagerBeginNotUndoableAction ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanRedoMethodInfo ,
#endif
undoManagerCanRedo ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanRedoChangedMethodInfo ,
#endif
undoManagerCanRedoChanged ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanUndoMethodInfo ,
#endif
undoManagerCanUndo ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanUndoChangedMethodInfo ,
#endif
undoManagerCanUndoChanged ,
#if defined(ENABLE_OVERLOADING)
UndoManagerEndNotUndoableActionMethodInfo,
#endif
undoManagerEndNotUndoableAction ,
#if defined(ENABLE_OVERLOADING)
UndoManagerRedoMethodInfo ,
#endif
undoManagerRedo ,
#if defined(ENABLE_OVERLOADING)
UndoManagerUndoMethodInfo ,
#endif
undoManagerUndo ,
C_UndoManagerCanRedoChangedCallback ,
UndoManagerCanRedoChangedCallback ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanRedoChangedSignalInfo ,
#endif
afterUndoManagerCanRedoChanged ,
genClosure_UndoManagerCanRedoChanged ,
mk_UndoManagerCanRedoChangedCallback ,
noUndoManagerCanRedoChangedCallback ,
onUndoManagerCanRedoChanged ,
wrap_UndoManagerCanRedoChangedCallback ,
C_UndoManagerCanUndoChangedCallback ,
UndoManagerCanUndoChangedCallback ,
#if defined(ENABLE_OVERLOADING)
UndoManagerCanUndoChangedSignalInfo ,
#endif
afterUndoManagerCanUndoChanged ,
genClosure_UndoManagerCanUndoChanged ,
mk_UndoManagerCanUndoChangedCallback ,
noUndoManagerCanUndoChangedCallback ,
onUndoManagerCanUndoChanged ,
wrap_UndoManagerCanUndoChangedCallback ,
) 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
newtype UndoManager = UndoManager (SP.ManagedPtr UndoManager)
deriving (UndoManager -> UndoManager -> Bool
(UndoManager -> UndoManager -> Bool)
-> (UndoManager -> UndoManager -> Bool) -> Eq UndoManager
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UndoManager -> UndoManager -> Bool
$c/= :: UndoManager -> UndoManager -> Bool
== :: UndoManager -> UndoManager -> Bool
$c== :: UndoManager -> UndoManager -> Bool
Eq)
instance SP.ManagedPtrNewtype UndoManager where
toManagedPtr :: UndoManager -> ManagedPtr UndoManager
toManagedPtr (UndoManager ManagedPtr UndoManager
p) = ManagedPtr UndoManager
p
foreign import ccall "gtk_source_undo_manager_get_type"
c_gtk_source_undo_manager_get_type :: IO B.Types.GType
instance B.Types.TypedObject UndoManager where
glibType :: IO GType
glibType = IO GType
c_gtk_source_undo_manager_get_type
instance B.Types.GObject UndoManager
instance B.GValue.IsGValue UndoManager where
toGValue :: UndoManager -> IO GValue
toGValue UndoManager
o = do
GType
gtype <- IO GType
c_gtk_source_undo_manager_get_type
UndoManager -> (Ptr UndoManager -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UndoManager
o (GType
-> (GValue -> Ptr UndoManager -> IO ())
-> Ptr UndoManager
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr UndoManager -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO UndoManager
fromGValue GValue
gv = do
Ptr UndoManager
ptr <- GValue -> IO (Ptr UndoManager)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr UndoManager)
(ManagedPtr UndoManager -> UndoManager)
-> Ptr UndoManager -> IO UndoManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UndoManager -> UndoManager
UndoManager Ptr UndoManager
ptr
class (SP.GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o
instance (SP.GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o
instance O.HasParentTypes UndoManager
type instance O.ParentTypes UndoManager = '[GObject.Object.Object]
toUndoManager :: (MonadIO m, IsUndoManager o) => o -> m UndoManager
toUndoManager :: o -> m UndoManager
toUndoManager = IO UndoManager -> m UndoManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UndoManager -> m UndoManager)
-> (o -> IO UndoManager) -> o -> m UndoManager
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr UndoManager -> UndoManager) -> o -> IO UndoManager
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr UndoManager -> UndoManager
UndoManager
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UndoManager
type instance O.AttributeList UndoManager = UndoManagerAttributeList
type UndoManagerAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveUndoManagerMethod (t :: Symbol) (o :: *) :: * where
ResolveUndoManagerMethod "beginNotUndoableAction" o = UndoManagerBeginNotUndoableActionMethodInfo
ResolveUndoManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveUndoManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveUndoManagerMethod "canRedo" o = UndoManagerCanRedoMethodInfo
ResolveUndoManagerMethod "canRedoChanged" o = UndoManagerCanRedoChangedMethodInfo
ResolveUndoManagerMethod "canUndo" o = UndoManagerCanUndoMethodInfo
ResolveUndoManagerMethod "canUndoChanged" o = UndoManagerCanUndoChangedMethodInfo
ResolveUndoManagerMethod "endNotUndoableAction" o = UndoManagerEndNotUndoableActionMethodInfo
ResolveUndoManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveUndoManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveUndoManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveUndoManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveUndoManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveUndoManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveUndoManagerMethod "redo" o = UndoManagerRedoMethodInfo
ResolveUndoManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveUndoManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveUndoManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveUndoManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveUndoManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveUndoManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveUndoManagerMethod "undo" o = UndoManagerUndoMethodInfo
ResolveUndoManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveUndoManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveUndoManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveUndoManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveUndoManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveUndoManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveUndoManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveUndoManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveUndoManagerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUndoManagerMethod t UndoManager, O.MethodInfo info UndoManager p) => OL.IsLabel t (UndoManager -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
foreign import ccall "gtk_source_undo_manager_begin_not_undoable_action" gtk_source_undo_manager_begin_not_undoable_action ::
Ptr UndoManager ->
IO ()
undoManagerBeginNotUndoableAction ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerBeginNotUndoableAction :: a -> m ()
undoManagerBeginNotUndoableAction a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_begin_not_undoable_action Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerBeginNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerBeginNotUndoableActionMethodInfo a signature where
overloadedMethod = undoManagerBeginNotUndoableAction
#endif
foreign import ccall "gtk_source_undo_manager_can_redo" gtk_source_undo_manager_can_redo ::
Ptr UndoManager ->
IO CInt
undoManagerCanRedo ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m Bool
undoManagerCanRedo :: a -> m Bool
undoManagerCanRedo a
manager = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
CInt
result <- Ptr UndoManager -> IO CInt
gtk_source_undo_manager_can_redo Ptr UndoManager
manager'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanRedoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoMethodInfo a signature where
overloadedMethod = undoManagerCanRedo
#endif
foreign import ccall "gtk_source_undo_manager_can_redo_changed" gtk_source_undo_manager_can_redo_changed ::
Ptr UndoManager ->
IO ()
undoManagerCanRedoChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerCanRedoChanged :: a -> m ()
undoManagerCanRedoChanged a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_can_redo_changed Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanRedoChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoChangedMethodInfo a signature where
overloadedMethod = undoManagerCanRedoChanged
#endif
foreign import ccall "gtk_source_undo_manager_can_undo" gtk_source_undo_manager_can_undo ::
Ptr UndoManager ->
IO CInt
undoManagerCanUndo ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m Bool
undoManagerCanUndo :: a -> m Bool
undoManagerCanUndo a
manager = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
CInt
result <- Ptr UndoManager -> IO CInt
gtk_source_undo_manager_can_undo Ptr UndoManager
manager'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanUndoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoMethodInfo a signature where
overloadedMethod = undoManagerCanUndo
#endif
foreign import ccall "gtk_source_undo_manager_can_undo_changed" gtk_source_undo_manager_can_undo_changed ::
Ptr UndoManager ->
IO ()
undoManagerCanUndoChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerCanUndoChanged :: a -> m ()
undoManagerCanUndoChanged a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_can_undo_changed Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanUndoChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoChangedMethodInfo a signature where
overloadedMethod = undoManagerCanUndoChanged
#endif
foreign import ccall "gtk_source_undo_manager_end_not_undoable_action" gtk_source_undo_manager_end_not_undoable_action ::
Ptr UndoManager ->
IO ()
undoManagerEndNotUndoableAction ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerEndNotUndoableAction :: a -> m ()
undoManagerEndNotUndoableAction a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_end_not_undoable_action Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerEndNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerEndNotUndoableActionMethodInfo a signature where
overloadedMethod = undoManagerEndNotUndoableAction
#endif
foreign import ccall "gtk_source_undo_manager_redo" gtk_source_undo_manager_redo ::
Ptr UndoManager ->
IO ()
undoManagerRedo ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerRedo :: a -> m ()
undoManagerRedo a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_redo Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerRedoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerRedoMethodInfo a signature where
overloadedMethod = undoManagerRedo
#endif
foreign import ccall "gtk_source_undo_manager_undo" gtk_source_undo_manager_undo ::
Ptr UndoManager ->
IO ()
undoManagerUndo ::
(B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
a
-> m ()
undoManagerUndo :: a -> m ()
undoManagerUndo a
manager = 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 UndoManager
manager' <- a -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr UndoManager -> IO ()
gtk_source_undo_manager_undo Ptr UndoManager
manager'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UndoManagerUndoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerUndoMethodInfo a signature where
overloadedMethod = undoManagerUndo
#endif
type UndoManagerCanRedoChangedCallback =
IO ()
noUndoManagerCanRedoChangedCallback :: Maybe UndoManagerCanRedoChangedCallback
noUndoManagerCanRedoChangedCallback :: Maybe (IO ())
noUndoManagerCanRedoChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_UndoManagerCanRedoChangedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_UndoManagerCanRedoChangedCallback :: C_UndoManagerCanRedoChangedCallback -> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
genClosure_UndoManagerCanRedoChanged :: MonadIO m => UndoManagerCanRedoChangedCallback -> m (GClosure C_UndoManagerCanRedoChangedCallback)
genClosure_UndoManagerCanRedoChanged :: IO () -> m (GClosure C_UndoManagerCanRedoChangedCallback)
genClosure_UndoManagerCanRedoChanged IO ()
cb = IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback))
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanRedoChangedCallback IO ()
cb
C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanRedoChangedCallback C_UndoManagerCanRedoChangedCallback
cb' IO (FunPtr C_UndoManagerCanRedoChangedCallback)
-> (FunPtr C_UndoManagerCanRedoChangedCallback
-> IO (GClosure C_UndoManagerCanRedoChangedCallback))
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_UndoManagerCanRedoChangedCallback
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_UndoManagerCanRedoChangedCallback ::
UndoManagerCanRedoChangedCallback ->
C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanRedoChangedCallback :: IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanRedoChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId
onUndoManagerCanRedoChanged :: a -> IO () -> m SignalHandlerId
onUndoManagerCanRedoChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanRedoChangedCallback IO ()
cb
FunPtr C_UndoManagerCanRedoChangedCallback
cb'' <- C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanRedoChangedCallback C_UndoManagerCanRedoChangedCallback
cb'
a
-> Text
-> FunPtr C_UndoManagerCanRedoChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"can-redo-changed" FunPtr C_UndoManagerCanRedoChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId
afterUndoManagerCanRedoChanged :: a -> IO () -> m SignalHandlerId
afterUndoManagerCanRedoChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanRedoChangedCallback IO ()
cb
FunPtr C_UndoManagerCanRedoChangedCallback
cb'' <- C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanRedoChangedCallback C_UndoManagerCanRedoChangedCallback
cb'
a
-> Text
-> FunPtr C_UndoManagerCanRedoChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"can-redo-changed" FunPtr C_UndoManagerCanRedoChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanRedoChangedSignalInfo
instance SignalInfo UndoManagerCanRedoChangedSignalInfo where
type HaskellCallbackType UndoManagerCanRedoChangedSignalInfo = UndoManagerCanRedoChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_UndoManagerCanRedoChangedCallback cb
cb'' <- mk_UndoManagerCanRedoChangedCallback cb'
connectSignalFunPtr obj "can-redo-changed" cb'' connectMode detail
#endif
type UndoManagerCanUndoChangedCallback =
IO ()
noUndoManagerCanUndoChangedCallback :: Maybe UndoManagerCanUndoChangedCallback
noUndoManagerCanUndoChangedCallback :: Maybe (IO ())
noUndoManagerCanUndoChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_UndoManagerCanUndoChangedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_UndoManagerCanUndoChangedCallback :: C_UndoManagerCanUndoChangedCallback -> IO (FunPtr C_UndoManagerCanUndoChangedCallback)
genClosure_UndoManagerCanUndoChanged :: MonadIO m => UndoManagerCanUndoChangedCallback -> m (GClosure C_UndoManagerCanUndoChangedCallback)
genClosure_UndoManagerCanUndoChanged :: IO () -> m (GClosure C_UndoManagerCanRedoChangedCallback)
genClosure_UndoManagerCanUndoChanged IO ()
cb = IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback))
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
-> m (GClosure C_UndoManagerCanRedoChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanUndoChangedCallback IO ()
cb
C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanUndoChangedCallback C_UndoManagerCanRedoChangedCallback
cb' IO (FunPtr C_UndoManagerCanRedoChangedCallback)
-> (FunPtr C_UndoManagerCanRedoChangedCallback
-> IO (GClosure C_UndoManagerCanRedoChangedCallback))
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_UndoManagerCanRedoChangedCallback
-> IO (GClosure C_UndoManagerCanRedoChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_UndoManagerCanUndoChangedCallback ::
UndoManagerCanUndoChangedCallback ->
C_UndoManagerCanUndoChangedCallback
wrap_UndoManagerCanUndoChangedCallback :: IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanUndoChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId
onUndoManagerCanUndoChanged :: a -> IO () -> m SignalHandlerId
onUndoManagerCanUndoChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanUndoChangedCallback IO ()
cb
FunPtr C_UndoManagerCanRedoChangedCallback
cb'' <- C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanUndoChangedCallback C_UndoManagerCanRedoChangedCallback
cb'
a
-> Text
-> FunPtr C_UndoManagerCanRedoChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"can-undo-changed" FunPtr C_UndoManagerCanRedoChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId
afterUndoManagerCanUndoChanged :: a -> IO () -> m SignalHandlerId
afterUndoManagerCanUndoChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_UndoManagerCanRedoChangedCallback
cb' = IO () -> C_UndoManagerCanRedoChangedCallback
wrap_UndoManagerCanUndoChangedCallback IO ()
cb
FunPtr C_UndoManagerCanRedoChangedCallback
cb'' <- C_UndoManagerCanRedoChangedCallback
-> IO (FunPtr C_UndoManagerCanRedoChangedCallback)
mk_UndoManagerCanUndoChangedCallback C_UndoManagerCanRedoChangedCallback
cb'
a
-> Text
-> FunPtr C_UndoManagerCanRedoChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"can-undo-changed" FunPtr C_UndoManagerCanRedoChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data UndoManagerCanUndoChangedSignalInfo
instance SignalInfo UndoManagerCanUndoChangedSignalInfo where
type HaskellCallbackType UndoManagerCanUndoChangedSignalInfo = UndoManagerCanUndoChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_UndoManagerCanUndoChangedCallback cb
cb'' <- mk_UndoManagerCanUndoChangedCallback cb'
connectSignalFunPtr obj "can-undo-changed" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UndoManager = UndoManagerSignalList
type UndoManagerSignalList = ('[ '("canRedoChanged", UndoManagerCanRedoChangedSignalInfo), '("canUndoChanged", UndoManagerCanUndoChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif