{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GtkSource.Interfaces.UndoManager
    ( 

-- * Exported types
    UndoManager(..)                         ,
    noUndoManager                           ,
    IsUndoManager                           ,
    toUndoManager                           ,


 -- * Methods
-- ** beginNotUndoableAction #method:beginNotUndoableAction#
    UndoManagerBeginNotUndoableActionMethodInfo,
    undoManagerBeginNotUndoableAction       ,


-- ** canRedo #method:canRedo#
    UndoManagerCanRedoMethodInfo            ,
    undoManagerCanRedo                      ,


-- ** canRedoChanged #method:canRedoChanged#
    UndoManagerCanRedoChangedMethodInfo     ,
    undoManagerCanRedoChanged               ,


-- ** canUndo #method:canUndo#
    UndoManagerCanUndoMethodInfo            ,
    undoManagerCanUndo                      ,


-- ** canUndoChanged #method:canUndoChanged#
    UndoManagerCanUndoChangedMethodInfo     ,
    undoManagerCanUndoChanged               ,


-- ** endNotUndoableAction #method:endNotUndoableAction#
    UndoManagerEndNotUndoableActionMethodInfo,
    undoManagerEndNotUndoableAction         ,


-- ** redo #method:redo#
    UndoManagerRedoMethodInfo               ,
    undoManagerRedo                         ,


-- ** undo #method:undo#
    UndoManagerUndoMethodInfo               ,
    undoManagerUndo                         ,




 -- * Signals
-- ** canRedoChanged #signal:canRedoChanged#
    C_UndoManagerCanRedoChangedCallback     ,
    UndoManagerCanRedoChangedCallback       ,
    UndoManagerCanRedoChangedSignalInfo     ,
    afterUndoManagerCanRedoChanged          ,
    genClosure_UndoManagerCanRedoChanged    ,
    mk_UndoManagerCanRedoChangedCallback    ,
    noUndoManagerCanRedoChangedCallback     ,
    onUndoManagerCanRedoChanged             ,
    wrap_UndoManagerCanRedoChangedCallback  ,


-- ** canUndoChanged #signal:canUndoChanged#
    C_UndoManagerCanUndoChangedCallback     ,
    UndoManagerCanUndoChangedCallback       ,
    UndoManagerCanUndoChangedSignalInfo     ,
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object

-- interface UndoManager 
newtype UndoManager = UndoManager (ManagedPtr UndoManager)
noUndoManager :: Maybe UndoManager
noUndoManager = Nothing

-- signal UndoManager::can-redo-changed
type UndoManagerCanRedoChangedCallback =
    IO ()

noUndoManagerCanRedoChangedCallback :: Maybe UndoManagerCanRedoChangedCallback
noUndoManagerCanRedoChangedCallback = Nothing

type C_UndoManagerCanRedoChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_UndoManagerCanRedoChangedCallback :: C_UndoManagerCanRedoChangedCallback -> IO (FunPtr C_UndoManagerCanRedoChangedCallback)

genClosure_UndoManagerCanRedoChanged :: UndoManagerCanRedoChangedCallback -> IO Closure
genClosure_UndoManagerCanRedoChanged cb = do
    let cb' = wrap_UndoManagerCanRedoChangedCallback cb
    mk_UndoManagerCanRedoChangedCallback cb' >>= newCClosure


wrap_UndoManagerCanRedoChangedCallback ::
    UndoManagerCanRedoChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_UndoManagerCanRedoChangedCallback _cb _ _ = do
    _cb 


onUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId
onUndoManagerCanRedoChanged obj cb = liftIO $ do
    let cb' = wrap_UndoManagerCanRedoChangedCallback cb
    cb'' <- mk_UndoManagerCanRedoChangedCallback cb'
    connectSignalFunPtr obj "can-redo-changed" cb'' SignalConnectBefore

afterUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId
afterUndoManagerCanRedoChanged obj cb = liftIO $ do
    let cb' = wrap_UndoManagerCanRedoChangedCallback cb
    cb'' <- mk_UndoManagerCanRedoChangedCallback cb'
    connectSignalFunPtr obj "can-redo-changed" cb'' SignalConnectAfter


-- signal UndoManager::can-undo-changed
type UndoManagerCanUndoChangedCallback =
    IO ()

noUndoManagerCanUndoChangedCallback :: Maybe UndoManagerCanUndoChangedCallback
noUndoManagerCanUndoChangedCallback = Nothing

type C_UndoManagerCanUndoChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_UndoManagerCanUndoChangedCallback :: C_UndoManagerCanUndoChangedCallback -> IO (FunPtr C_UndoManagerCanUndoChangedCallback)

genClosure_UndoManagerCanUndoChanged :: UndoManagerCanUndoChangedCallback -> IO Closure
genClosure_UndoManagerCanUndoChanged cb = do
    let cb' = wrap_UndoManagerCanUndoChangedCallback cb
    mk_UndoManagerCanUndoChangedCallback cb' >>= newCClosure


wrap_UndoManagerCanUndoChangedCallback ::
    UndoManagerCanUndoChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_UndoManagerCanUndoChangedCallback _cb _ _ = do
    _cb 


onUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId
onUndoManagerCanUndoChanged obj cb = liftIO $ do
    let cb' = wrap_UndoManagerCanUndoChangedCallback cb
    cb'' <- mk_UndoManagerCanUndoChangedCallback cb'
    connectSignalFunPtr obj "can-undo-changed" cb'' SignalConnectBefore

afterUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId
afterUndoManagerCanUndoChanged obj cb = liftIO $ do
    let cb' = wrap_UndoManagerCanUndoChangedCallback cb
    cb'' <- mk_UndoManagerCanUndoChangedCallback cb'
    connectSignalFunPtr obj "can-undo-changed" cb'' SignalConnectAfter


data UndoManagerCanRedoChangedSignalInfo
instance SignalInfo UndoManagerCanRedoChangedSignalInfo where
    type HaskellCallbackType UndoManagerCanRedoChangedSignalInfo = UndoManagerCanRedoChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_UndoManagerCanRedoChangedCallback cb
        cb'' <- mk_UndoManagerCanRedoChangedCallback cb'
        connectSignalFunPtr obj "can-redo-changed" cb'' connectMode

data UndoManagerCanUndoChangedSignalInfo
instance SignalInfo UndoManagerCanUndoChangedSignalInfo where
    type HaskellCallbackType UndoManagerCanUndoChangedSignalInfo = UndoManagerCanUndoChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_UndoManagerCanUndoChangedCallback cb
        cb'' <- mk_UndoManagerCanUndoChangedCallback cb'
        connectSignalFunPtr obj "can-undo-changed" cb'' connectMode

type instance O.SignalList UndoManager = UndoManagerSignalList
type UndoManagerSignalList = ('[ '("canRedoChanged", UndoManagerCanRedoChangedSignalInfo), '("canUndoChanged", UndoManagerCanUndoChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

foreign import ccall "gtk_source_undo_manager_get_type"
    c_gtk_source_undo_manager_get_type :: IO GType

instance GObject UndoManager where
    gobjectType _ = c_gtk_source_undo_manager_get_type
    

class GObject o => IsUndoManager o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError UndoManager a) =>
    IsUndoManager a
#endif
instance IsUndoManager UndoManager
instance GObject.Object.IsObject UndoManager

toUndoManager :: IsUndoManager o => o -> IO UndoManager
toUndoManager = unsafeCastTo UndoManager

instance O.HasAttributeList UndoManager
type instance O.AttributeList UndoManager = UndoManagerAttributeList
type UndoManagerAttributeList = ('[ ] :: [(Symbol, *)])

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveUndoManagerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUndoManagerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveUndoManagerMethod t UndoManager, O.MethodInfo info UndoManager p) => O.IsLabelProxy t (UndoManager -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveUndoManagerMethod t UndoManager, O.MethodInfo info UndoManager p) => O.IsLabel t (UndoManager -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- method UndoManager::begin_not_undoable_action
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_begin_not_undoable_action" gtk_source_undo_manager_begin_not_undoable_action :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Begin a not undoable action on the buffer. All changes between this call
and the call to 'GI.GtkSource.Interfaces.UndoManager.undoManagerEndNotUndoableAction' cannot
be undone. This function should be re-entrant.

@since 2.10
-}
undoManagerBeginNotUndoableAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerBeginNotUndoableAction manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_begin_not_undoable_action manager'
    touchManagedPtr manager
    return ()

data UndoManagerBeginNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerBeginNotUndoableActionMethodInfo a signature where
    overloadedMethod _ = undoManagerBeginNotUndoableAction

-- method UndoManager::can_redo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_can_redo" gtk_source_undo_manager_can_redo :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO CInt

{- |
Get whether there are redo operations available.

@since 2.10
-}
undoManagerCanRedo ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there are redo operations available, 'False' otherwise -}
undoManagerCanRedo manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    result <- gtk_source_undo_manager_can_redo manager'
    let result' = (/= 0) result
    touchManagedPtr manager
    return result'

data UndoManagerCanRedoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoMethodInfo a signature where
    overloadedMethod _ = undoManagerCanRedo

-- method UndoManager::can_redo_changed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_can_redo_changed" gtk_source_undo_manager_can_redo_changed :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Emits the 'GI.GtkSource.Interfaces.UndoManager.UndoManager'::@/can-redo-changed/@ signal.

@since 2.10
-}
undoManagerCanRedoChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerCanRedoChanged manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_can_redo_changed manager'
    touchManagedPtr manager
    return ()

data UndoManagerCanRedoChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoChangedMethodInfo a signature where
    overloadedMethod _ = undoManagerCanRedoChanged

-- method UndoManager::can_undo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_can_undo" gtk_source_undo_manager_can_undo :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO CInt

{- |
Get whether there are undo operations available.

@since 2.10
-}
undoManagerCanUndo ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there are undo operations available, 'False' otherwise -}
undoManagerCanUndo manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    result <- gtk_source_undo_manager_can_undo manager'
    let result' = (/= 0) result
    touchManagedPtr manager
    return result'

data UndoManagerCanUndoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoMethodInfo a signature where
    overloadedMethod _ = undoManagerCanUndo

-- method UndoManager::can_undo_changed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_can_undo_changed" gtk_source_undo_manager_can_undo_changed :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Emits the 'GI.GtkSource.Interfaces.UndoManager.UndoManager'::@/can-undo-changed/@ signal.

@since 2.10
-}
undoManagerCanUndoChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerCanUndoChanged manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_can_undo_changed manager'
    touchManagedPtr manager
    return ()

data UndoManagerCanUndoChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoChangedMethodInfo a signature where
    overloadedMethod _ = undoManagerCanUndoChanged

-- method UndoManager::end_not_undoable_action
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_end_not_undoable_action" gtk_source_undo_manager_end_not_undoable_action :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Ends a not undoable action on the buffer.

@since 2.10
-}
undoManagerEndNotUndoableAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerEndNotUndoableAction manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_end_not_undoable_action manager'
    touchManagedPtr manager
    return ()

data UndoManagerEndNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerEndNotUndoableActionMethodInfo a signature where
    overloadedMethod _ = undoManagerEndNotUndoableAction

-- method UndoManager::redo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_redo" gtk_source_undo_manager_redo :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Perform a single redo. Calling this function when there are no redo operations
available is an error. Use 'GI.GtkSource.Interfaces.UndoManager.undoManagerCanRedo' to find out
if there are redo operations available.

@since 2.10
-}
undoManagerRedo ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerRedo manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_redo manager'
    touchManagedPtr manager
    return ()

data UndoManagerRedoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerRedoMethodInfo a signature where
    overloadedMethod _ = undoManagerRedo

-- method UndoManager::undo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_undo_manager_undo" gtk_source_undo_manager_undo :: 
    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

{- |
Perform a single undo. Calling this function when there are no undo operations
available is an error. Use 'GI.GtkSource.Interfaces.UndoManager.undoManagerCanUndo' to find out
if there are undo operations available.

@since 2.10
-}
undoManagerUndo ::
    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>
    a
    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}
    -> m ()
undoManagerUndo manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    gtk_source_undo_manager_undo manager'
    touchManagedPtr manager
    return ()

data UndoManagerUndoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerUndoMethodInfo a signature where
    overloadedMethod _ = undoManagerUndo