#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.GtkSource.Interfaces.UndoManager
(
UndoManager(..) ,
noUndoManager ,
IsUndoManager ,
toUndoManager ,
#if ENABLE_OVERLOADING
UndoManagerBeginNotUndoableActionMethodInfo,
#endif
undoManagerBeginNotUndoableAction ,
#if ENABLE_OVERLOADING
UndoManagerCanRedoMethodInfo ,
#endif
undoManagerCanRedo ,
#if ENABLE_OVERLOADING
UndoManagerCanRedoChangedMethodInfo ,
#endif
undoManagerCanRedoChanged ,
#if ENABLE_OVERLOADING
UndoManagerCanUndoMethodInfo ,
#endif
undoManagerCanUndo ,
#if ENABLE_OVERLOADING
UndoManagerCanUndoChangedMethodInfo ,
#endif
undoManagerCanUndoChanged ,
#if ENABLE_OVERLOADING
UndoManagerEndNotUndoableActionMethodInfo,
#endif
undoManagerEndNotUndoableAction ,
#if ENABLE_OVERLOADING
UndoManagerRedoMethodInfo ,
#endif
undoManagerRedo ,
#if ENABLE_OVERLOADING
UndoManagerUndoMethodInfo ,
#endif
undoManagerUndo ,
C_UndoManagerCanRedoChangedCallback ,
UndoManagerCanRedoChangedCallback ,
#if ENABLE_OVERLOADING
UndoManagerCanRedoChangedSignalInfo ,
#endif
afterUndoManagerCanRedoChanged ,
genClosure_UndoManagerCanRedoChanged ,
mk_UndoManagerCanRedoChangedCallback ,
noUndoManagerCanRedoChangedCallback ,
onUndoManagerCanRedoChanged ,
wrap_UndoManagerCanRedoChangedCallback ,
C_UndoManagerCanUndoChangedCallback ,
UndoManagerCanUndoChangedCallback ,
#if 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.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.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 (ManagedPtr UndoManager)
noUndoManager :: Maybe UndoManager
noUndoManager = Nothing
type UndoManagerCanRedoChangedCallback =
IO ()
noUndoManagerCanRedoChangedCallback :: Maybe UndoManagerCanRedoChangedCallback
noUndoManagerCanRedoChangedCallback = 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 cb = liftIO $ do
let cb' = wrap_UndoManagerCanRedoChangedCallback cb
mk_UndoManagerCanRedoChangedCallback cb' >>= B.GClosure.newGClosure
wrap_UndoManagerCanRedoChangedCallback ::
UndoManagerCanRedoChangedCallback ->
C_UndoManagerCanRedoChangedCallback
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
type UndoManagerCanUndoChangedCallback =
IO ()
noUndoManagerCanUndoChangedCallback :: Maybe UndoManagerCanUndoChangedCallback
noUndoManagerCanUndoChangedCallback = 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 cb = liftIO $ do
let cb' = wrap_UndoManagerCanUndoChangedCallback cb
mk_UndoManagerCanUndoChangedCallback cb' >>= B.GClosure.newGClosure
wrap_UndoManagerCanUndoChangedCallback ::
UndoManagerCanUndoChangedCallback ->
C_UndoManagerCanUndoChangedCallback
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
#if ENABLE_OVERLOADING
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, *)])
#endif
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, O.IsDescendantOf UndoManager o) => IsUndoManager o
instance (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 = liftIO . unsafeCastTo UndoManager
#if ENABLE_OVERLOADING
instance O.HasAttributeList UndoManager
type instance O.AttributeList UndoManager = UndoManagerAttributeList
type UndoManagerAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if 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 "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 (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_begin_not_undoable_action manager'
touchManagedPtr manager
return ()
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
result <- gtk_source_undo_manager_can_redo manager'
let result' = (/= 0) result
touchManagedPtr manager
return result'
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_can_redo_changed manager'
touchManagedPtr manager
return ()
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
result <- gtk_source_undo_manager_can_undo manager'
let result' = (/= 0) result
touchManagedPtr manager
return result'
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_can_undo_changed manager'
touchManagedPtr manager
return ()
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_end_not_undoable_action manager'
touchManagedPtr manager
return ()
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_redo manager'
touchManagedPtr manager
return ()
#if 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
gtk_source_undo_manager_undo manager'
touchManagedPtr manager
return ()
#if ENABLE_OVERLOADING
data UndoManagerUndoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerUndoMethodInfo a signature where
overloadedMethod _ = undoManagerUndo
#endif