{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Interfaces.Table
(
Table(..) ,
IsTable ,
toTable ,
#if defined(ENABLE_OVERLOADING)
ResolveTableMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TableAddColumnSelectionMethodInfo ,
#endif
tableAddColumnSelection ,
#if defined(ENABLE_OVERLOADING)
TableAddRowSelectionMethodInfo ,
#endif
tableAddRowSelection ,
#if defined(ENABLE_OVERLOADING)
TableGetCaptionMethodInfo ,
#endif
tableGetCaption ,
#if defined(ENABLE_OVERLOADING)
TableGetColumnAtIndexMethodInfo ,
#endif
tableGetColumnAtIndex ,
#if defined(ENABLE_OVERLOADING)
TableGetColumnDescriptionMethodInfo ,
#endif
tableGetColumnDescription ,
#if defined(ENABLE_OVERLOADING)
TableGetColumnExtentAtMethodInfo ,
#endif
tableGetColumnExtentAt ,
#if defined(ENABLE_OVERLOADING)
TableGetColumnHeaderMethodInfo ,
#endif
tableGetColumnHeader ,
#if defined(ENABLE_OVERLOADING)
TableGetIndexAtMethodInfo ,
#endif
tableGetIndexAt ,
#if defined(ENABLE_OVERLOADING)
TableGetNColumnsMethodInfo ,
#endif
tableGetNColumns ,
#if defined(ENABLE_OVERLOADING)
TableGetNRowsMethodInfo ,
#endif
tableGetNRows ,
#if defined(ENABLE_OVERLOADING)
TableGetRowAtIndexMethodInfo ,
#endif
tableGetRowAtIndex ,
#if defined(ENABLE_OVERLOADING)
TableGetRowDescriptionMethodInfo ,
#endif
tableGetRowDescription ,
#if defined(ENABLE_OVERLOADING)
TableGetRowExtentAtMethodInfo ,
#endif
tableGetRowExtentAt ,
#if defined(ENABLE_OVERLOADING)
TableGetRowHeaderMethodInfo ,
#endif
tableGetRowHeader ,
#if defined(ENABLE_OVERLOADING)
TableGetSelectedColumnsMethodInfo ,
#endif
tableGetSelectedColumns ,
#if defined(ENABLE_OVERLOADING)
TableGetSelectedRowsMethodInfo ,
#endif
tableGetSelectedRows ,
#if defined(ENABLE_OVERLOADING)
TableGetSummaryMethodInfo ,
#endif
tableGetSummary ,
#if defined(ENABLE_OVERLOADING)
TableIsColumnSelectedMethodInfo ,
#endif
tableIsColumnSelected ,
#if defined(ENABLE_OVERLOADING)
TableIsRowSelectedMethodInfo ,
#endif
tableIsRowSelected ,
#if defined(ENABLE_OVERLOADING)
TableIsSelectedMethodInfo ,
#endif
tableIsSelected ,
#if defined(ENABLE_OVERLOADING)
TableRefAtMethodInfo ,
#endif
tableRefAt ,
#if defined(ENABLE_OVERLOADING)
TableRemoveColumnSelectionMethodInfo ,
#endif
tableRemoveColumnSelection ,
#if defined(ENABLE_OVERLOADING)
TableRemoveRowSelectionMethodInfo ,
#endif
tableRemoveRowSelection ,
#if defined(ENABLE_OVERLOADING)
TableSetCaptionMethodInfo ,
#endif
tableSetCaption ,
#if defined(ENABLE_OVERLOADING)
TableSetColumnDescriptionMethodInfo ,
#endif
tableSetColumnDescription ,
#if defined(ENABLE_OVERLOADING)
TableSetColumnHeaderMethodInfo ,
#endif
tableSetColumnHeader ,
#if defined(ENABLE_OVERLOADING)
TableSetRowDescriptionMethodInfo ,
#endif
tableSetRowDescription ,
#if defined(ENABLE_OVERLOADING)
TableSetRowHeaderMethodInfo ,
#endif
tableSetRowHeader ,
#if defined(ENABLE_OVERLOADING)
TableSetSummaryMethodInfo ,
#endif
tableSetSummary ,
TableColumnDeletedCallback ,
#if defined(ENABLE_OVERLOADING)
TableColumnDeletedSignalInfo ,
#endif
afterTableColumnDeleted ,
onTableColumnDeleted ,
TableColumnInsertedCallback ,
#if defined(ENABLE_OVERLOADING)
TableColumnInsertedSignalInfo ,
#endif
afterTableColumnInserted ,
onTableColumnInserted ,
TableColumnReorderedCallback ,
#if defined(ENABLE_OVERLOADING)
TableColumnReorderedSignalInfo ,
#endif
afterTableColumnReordered ,
onTableColumnReordered ,
TableModelChangedCallback ,
#if defined(ENABLE_OVERLOADING)
TableModelChangedSignalInfo ,
#endif
afterTableModelChanged ,
onTableModelChanged ,
TableRowDeletedCallback ,
#if defined(ENABLE_OVERLOADING)
TableRowDeletedSignalInfo ,
#endif
afterTableRowDeleted ,
onTableRowDeleted ,
TableRowInsertedCallback ,
#if defined(ENABLE_OVERLOADING)
TableRowInsertedSignalInfo ,
#endif
afterTableRowInserted ,
onTableRowInserted ,
TableRowReorderedCallback ,
#if defined(ENABLE_OVERLOADING)
TableRowReorderedSignalInfo ,
#endif
afterTableRowReordered ,
onTableRowReordered ,
) 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.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.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 {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object
newtype Table = Table (SP.ManagedPtr Table)
deriving (Table -> Table -> Bool
(Table -> Table -> Bool) -> (Table -> Table -> Bool) -> Eq Table
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Table -> Table -> Bool
$c/= :: Table -> Table -> Bool
== :: Table -> Table -> Bool
$c== :: Table -> Table -> Bool
Eq)
instance SP.ManagedPtrNewtype Table where
toManagedPtr :: Table -> ManagedPtr Table
toManagedPtr (Table ManagedPtr Table
p) = ManagedPtr Table
p
foreign import ccall "atk_table_get_type"
c_atk_table_get_type :: IO B.Types.GType
instance B.Types.TypedObject Table where
glibType :: IO GType
glibType = IO GType
c_atk_table_get_type
instance B.Types.GObject Table
class (SP.GObject o, O.IsDescendantOf Table o) => IsTable o
instance (SP.GObject o, O.IsDescendantOf Table o) => IsTable o
instance O.HasParentTypes Table
type instance O.ParentTypes Table = '[GObject.Object.Object]
toTable :: (MIO.MonadIO m, IsTable o) => o -> m Table
toTable :: forall (m :: * -> *) o. (MonadIO m, IsTable o) => o -> m Table
toTable = IO Table -> m Table
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Table -> m Table) -> (o -> IO Table) -> o -> m Table
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Table -> Table) -> o -> IO Table
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Table -> Table
Table
instance B.GValue.IsGValue (Maybe Table) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_table_get_type
gvalueSet_ :: Ptr GValue -> Maybe Table -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Table
P.Nothing = Ptr GValue -> Ptr Table -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Table
forall a. Ptr a
FP.nullPtr :: FP.Ptr Table)
gvalueSet_ Ptr GValue
gv (P.Just Table
obj) = Table -> (Ptr Table -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Table
obj (Ptr GValue -> Ptr Table -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Table)
gvalueGet_ Ptr GValue
gv = do
Ptr Table
ptr <- Ptr GValue -> IO (Ptr Table)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Table)
if Ptr Table
ptr Ptr Table -> Ptr Table -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Table
forall a. Ptr a
FP.nullPtr
then Table -> Maybe Table
forall a. a -> Maybe a
P.Just (Table -> Maybe Table) -> IO Table -> IO (Maybe Table)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Table -> Table) -> Ptr Table -> IO Table
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Table -> Table
Table Ptr Table
ptr
else Maybe Table -> IO (Maybe Table)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Table
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Table
type instance O.AttributeList Table = TableAttributeList
type TableAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTableMethod (t :: Symbol) (o :: *) :: * where
ResolveTableMethod "addColumnSelection" o = TableAddColumnSelectionMethodInfo
ResolveTableMethod "addRowSelection" o = TableAddRowSelectionMethodInfo
ResolveTableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTableMethod "isColumnSelected" o = TableIsColumnSelectedMethodInfo
ResolveTableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTableMethod "isRowSelected" o = TableIsRowSelectedMethodInfo
ResolveTableMethod "isSelected" o = TableIsSelectedMethodInfo
ResolveTableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTableMethod "refAt" o = TableRefAtMethodInfo
ResolveTableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTableMethod "removeColumnSelection" o = TableRemoveColumnSelectionMethodInfo
ResolveTableMethod "removeRowSelection" o = TableRemoveRowSelectionMethodInfo
ResolveTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTableMethod "getCaption" o = TableGetCaptionMethodInfo
ResolveTableMethod "getColumnAtIndex" o = TableGetColumnAtIndexMethodInfo
ResolveTableMethod "getColumnDescription" o = TableGetColumnDescriptionMethodInfo
ResolveTableMethod "getColumnExtentAt" o = TableGetColumnExtentAtMethodInfo
ResolveTableMethod "getColumnHeader" o = TableGetColumnHeaderMethodInfo
ResolveTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTableMethod "getIndexAt" o = TableGetIndexAtMethodInfo
ResolveTableMethod "getNColumns" o = TableGetNColumnsMethodInfo
ResolveTableMethod "getNRows" o = TableGetNRowsMethodInfo
ResolveTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTableMethod "getRowAtIndex" o = TableGetRowAtIndexMethodInfo
ResolveTableMethod "getRowDescription" o = TableGetRowDescriptionMethodInfo
ResolveTableMethod "getRowExtentAt" o = TableGetRowExtentAtMethodInfo
ResolveTableMethod "getRowHeader" o = TableGetRowHeaderMethodInfo
ResolveTableMethod "getSelectedColumns" o = TableGetSelectedColumnsMethodInfo
ResolveTableMethod "getSelectedRows" o = TableGetSelectedRowsMethodInfo
ResolveTableMethod "getSummary" o = TableGetSummaryMethodInfo
ResolveTableMethod "setCaption" o = TableSetCaptionMethodInfo
ResolveTableMethod "setColumnDescription" o = TableSetColumnDescriptionMethodInfo
ResolveTableMethod "setColumnHeader" o = TableSetColumnHeaderMethodInfo
ResolveTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTableMethod "setRowDescription" o = TableSetRowDescriptionMethodInfo
ResolveTableMethod "setRowHeader" o = TableSetRowHeaderMethodInfo
ResolveTableMethod "setSummary" o = TableSetSummaryMethodInfo
ResolveTableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTableMethod t Table, O.OverloadedMethod info Table p) => OL.IsLabel t (Table -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTableMethod t Table, O.OverloadedMethod info Table p, R.HasField t Table p) => R.HasField t Table p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTableMethod t Table, O.OverloadedMethodInfo info Table) => OL.IsLabel t (O.MethodProxy info Table) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "atk_table_add_column_selection" atk_table_add_column_selection ::
Ptr Table ->
Int32 ->
IO CInt
tableAddColumnSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableAddColumnSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableAddColumnSelection a
table Int32
column = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_add_column_selection Ptr Table
table' Int32
column
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableAddColumnSelectionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableAddColumnSelectionMethodInfo a signature where
overloadedMethod = tableAddColumnSelection
instance O.OverloadedMethodInfo TableAddColumnSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableAddColumnSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableAddColumnSelection"
})
#endif
foreign import ccall "atk_table_add_row_selection" atk_table_add_row_selection ::
Ptr Table ->
Int32 ->
IO CInt
tableAddRowSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableAddRowSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableAddRowSelection a
table Int32
row = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_add_row_selection Ptr Table
table' Int32
row
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableAddRowSelectionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableAddRowSelectionMethodInfo a signature where
overloadedMethod = tableAddRowSelection
instance O.OverloadedMethodInfo TableAddRowSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableAddRowSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableAddRowSelection"
})
#endif
foreign import ccall "atk_table_get_caption" atk_table_get_caption ::
Ptr Table ->
IO (Ptr Atk.Object.Object)
tableGetCaption ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> m (Maybe Atk.Object.Object)
tableGetCaption :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> m (Maybe Object)
tableGetCaption a
table = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
result <- Ptr Table -> IO (Ptr Object)
atk_table_get_caption Ptr Table
table'
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data TableGetCaptionMethodInfo
instance (signature ~ (m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.OverloadedMethod TableGetCaptionMethodInfo a signature where
overloadedMethod = tableGetCaption
instance O.OverloadedMethodInfo TableGetCaptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetCaption",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetCaption"
})
#endif
foreign import ccall "atk_table_get_column_at_index" atk_table_get_column_at_index ::
Ptr Table ->
Int32 ->
IO Int32
{-# DEPRECATED tableGetColumnAtIndex ["Since 2.12."] #-}
tableGetColumnAtIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Int32
tableGetColumnAtIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Int32
tableGetColumnAtIndex a
table Int32
index_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> IO Int32
atk_table_get_column_at_index Ptr Table
table' Int32
index_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetColumnAtIndexMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetColumnAtIndexMethodInfo a signature where
overloadedMethod = tableGetColumnAtIndex
instance O.OverloadedMethodInfo TableGetColumnAtIndexMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetColumnAtIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetColumnAtIndex"
})
#endif
foreign import ccall "atk_table_get_column_description" atk_table_get_column_description ::
Ptr Table ->
Int32 ->
IO CString
tableGetColumnDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m T.Text
tableGetColumnDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Text
tableGetColumnDescription a
table Int32
column = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CString
result <- Ptr Table -> Int32 -> IO CString
atk_table_get_column_description Ptr Table
table' Int32
column
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableGetColumnDescription" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data TableGetColumnDescriptionMethodInfo
instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsTable a) => O.OverloadedMethod TableGetColumnDescriptionMethodInfo a signature where
overloadedMethod = tableGetColumnDescription
instance O.OverloadedMethodInfo TableGetColumnDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetColumnDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetColumnDescription"
})
#endif
foreign import ccall "atk_table_get_column_extent_at" atk_table_get_column_extent_at ::
Ptr Table ->
Int32 ->
Int32 ->
IO Int32
tableGetColumnExtentAt ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> Int32
-> m Int32
tableGetColumnExtentAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Int32 -> m Int32
tableGetColumnExtentAt a
table Int32
row Int32
column = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> Int32 -> IO Int32
atk_table_get_column_extent_at Ptr Table
table' Int32
row Int32
column
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetColumnExtentAtMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetColumnExtentAtMethodInfo a signature where
overloadedMethod = tableGetColumnExtentAt
instance O.OverloadedMethodInfo TableGetColumnExtentAtMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetColumnExtentAt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetColumnExtentAt"
})
#endif
foreign import ccall "atk_table_get_column_header" atk_table_get_column_header ::
Ptr Table ->
Int32 ->
IO (Ptr Atk.Object.Object)
tableGetColumnHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m (Maybe Atk.Object.Object)
tableGetColumnHeader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m (Maybe Object)
tableGetColumnHeader a
table Int32
column = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
result <- Ptr Table -> Int32 -> IO (Ptr Object)
atk_table_get_column_header Ptr Table
table' Int32
column
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data TableGetColumnHeaderMethodInfo
instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.OverloadedMethod TableGetColumnHeaderMethodInfo a signature where
overloadedMethod = tableGetColumnHeader
instance O.OverloadedMethodInfo TableGetColumnHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetColumnHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetColumnHeader"
})
#endif
foreign import ccall "atk_table_get_index_at" atk_table_get_index_at ::
Ptr Table ->
Int32 ->
Int32 ->
IO Int32
{-# DEPRECATED tableGetIndexAt ["Since 2.12. Use 'GI.Atk.Interfaces.Table.tableRefAt' in order to get the","accessible that represents the cell at (/@row@/, /@column@/)"] #-}
tableGetIndexAt ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> Int32
-> m Int32
tableGetIndexAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Int32 -> m Int32
tableGetIndexAt a
table Int32
row Int32
column = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> Int32 -> IO Int32
atk_table_get_index_at Ptr Table
table' Int32
row Int32
column
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetIndexAtMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetIndexAtMethodInfo a signature where
overloadedMethod = tableGetIndexAt
instance O.OverloadedMethodInfo TableGetIndexAtMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetIndexAt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetIndexAt"
})
#endif
foreign import ccall "atk_table_get_n_columns" atk_table_get_n_columns ::
Ptr Table ->
IO Int32
tableGetNColumns ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> m Int32
tableGetNColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> m Int32
tableGetNColumns a
table = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> IO Int32
atk_table_get_n_columns Ptr Table
table'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetNColumnsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetNColumnsMethodInfo a signature where
overloadedMethod = tableGetNColumns
instance O.OverloadedMethodInfo TableGetNColumnsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetNColumns",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetNColumns"
})
#endif
foreign import ccall "atk_table_get_n_rows" atk_table_get_n_rows ::
Ptr Table ->
IO Int32
tableGetNRows ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> m Int32
tableGetNRows :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> m Int32
tableGetNRows a
table = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> IO Int32
atk_table_get_n_rows Ptr Table
table'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetNRowsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetNRowsMethodInfo a signature where
overloadedMethod = tableGetNRows
instance O.OverloadedMethodInfo TableGetNRowsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetNRows",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetNRows"
})
#endif
foreign import ccall "atk_table_get_row_at_index" atk_table_get_row_at_index ::
Ptr Table ->
Int32 ->
IO Int32
{-# DEPRECATED tableGetRowAtIndex ["since 2.12."] #-}
tableGetRowAtIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Int32
tableGetRowAtIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Int32
tableGetRowAtIndex a
table Int32
index_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> IO Int32
atk_table_get_row_at_index Ptr Table
table' Int32
index_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetRowAtIndexMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetRowAtIndexMethodInfo a signature where
overloadedMethod = tableGetRowAtIndex
instance O.OverloadedMethodInfo TableGetRowAtIndexMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetRowAtIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetRowAtIndex"
})
#endif
foreign import ccall "atk_table_get_row_description" atk_table_get_row_description ::
Ptr Table ->
Int32 ->
IO CString
tableGetRowDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m (Maybe T.Text)
tableGetRowDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m (Maybe Text)
tableGetRowDescription a
table Int32
row = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CString
result <- Ptr Table -> Int32 -> IO CString
atk_table_get_row_description Ptr Table
table' Int32
row
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data TableGetRowDescriptionMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsTable a) => O.OverloadedMethod TableGetRowDescriptionMethodInfo a signature where
overloadedMethod = tableGetRowDescription
instance O.OverloadedMethodInfo TableGetRowDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetRowDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetRowDescription"
})
#endif
foreign import ccall "atk_table_get_row_extent_at" atk_table_get_row_extent_at ::
Ptr Table ->
Int32 ->
Int32 ->
IO Int32
tableGetRowExtentAt ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> Int32
-> m Int32
tableGetRowExtentAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Int32 -> m Int32
tableGetRowExtentAt a
table Int32
row Int32
column = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> Int32 -> IO Int32
atk_table_get_row_extent_at Ptr Table
table' Int32
row Int32
column
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetRowExtentAtMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetRowExtentAtMethodInfo a signature where
overloadedMethod = tableGetRowExtentAt
instance O.OverloadedMethodInfo TableGetRowExtentAtMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetRowExtentAt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetRowExtentAt"
})
#endif
foreign import ccall "atk_table_get_row_header" ::
Ptr Table ->
Int32 ->
IO (Ptr Atk.Object.Object)
tableGetRowHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m (Maybe Atk.Object.Object)
a
table Int32
row = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
result <- Ptr Table -> Int32 -> IO (Ptr Object)
atk_table_get_row_header Ptr Table
table' Int32
row
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data TableGetRowHeaderMethodInfo
instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.OverloadedMethod TableGetRowHeaderMethodInfo a signature where
overloadedMethod = tableGetRowHeader
instance O.OverloadedMethodInfo TableGetRowHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetRowHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetRowHeader"
})
#endif
foreign import ccall "atk_table_get_selected_columns" atk_table_get_selected_columns ::
Ptr Table ->
Int32 ->
IO Int32
tableGetSelectedColumns ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Int32
tableGetSelectedColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Int32
tableGetSelectedColumns a
table Int32
selected = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> IO Int32
atk_table_get_selected_columns Ptr Table
table' Int32
selected
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetSelectedColumnsMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetSelectedColumnsMethodInfo a signature where
overloadedMethod = tableGetSelectedColumns
instance O.OverloadedMethodInfo TableGetSelectedColumnsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetSelectedColumns",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetSelectedColumns"
})
#endif
foreign import ccall "atk_table_get_selected_rows" atk_table_get_selected_rows ::
Ptr Table ->
Int32 ->
IO Int32
tableGetSelectedRows ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Int32
tableGetSelectedRows :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Int32
tableGetSelectedRows a
table Int32
selected = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Int32
result <- Ptr Table -> Int32 -> IO Int32
atk_table_get_selected_rows Ptr Table
table' Int32
selected
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableGetSelectedRowsMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.OverloadedMethod TableGetSelectedRowsMethodInfo a signature where
overloadedMethod = tableGetSelectedRows
instance O.OverloadedMethodInfo TableGetSelectedRowsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetSelectedRows",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetSelectedRows"
})
#endif
foreign import ccall "atk_table_get_summary" atk_table_get_summary ::
Ptr Table ->
IO (Ptr Atk.Object.Object)
tableGetSummary ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> m Atk.Object.Object
tableGetSummary :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> m Object
tableGetSummary a
table = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
result <- Ptr Table -> IO (Ptr Object)
atk_table_get_summary Ptr Table
table'
Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableGetSummary" Ptr Object
result
Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'
#if defined(ENABLE_OVERLOADING)
data TableGetSummaryMethodInfo
instance (signature ~ (m Atk.Object.Object), MonadIO m, IsTable a) => O.OverloadedMethod TableGetSummaryMethodInfo a signature where
overloadedMethod = tableGetSummary
instance O.OverloadedMethodInfo TableGetSummaryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableGetSummary",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableGetSummary"
})
#endif
foreign import ccall "atk_table_is_column_selected" atk_table_is_column_selected ::
Ptr Table ->
Int32 ->
IO CInt
tableIsColumnSelected ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableIsColumnSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableIsColumnSelected a
table Int32
column = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_is_column_selected Ptr Table
table' Int32
column
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableIsColumnSelectedMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableIsColumnSelectedMethodInfo a signature where
overloadedMethod = tableIsColumnSelected
instance O.OverloadedMethodInfo TableIsColumnSelectedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableIsColumnSelected",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableIsColumnSelected"
})
#endif
foreign import ccall "atk_table_is_row_selected" atk_table_is_row_selected ::
Ptr Table ->
Int32 ->
IO CInt
tableIsRowSelected ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableIsRowSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableIsRowSelected a
table Int32
row = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_is_row_selected Ptr Table
table' Int32
row
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableIsRowSelectedMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableIsRowSelectedMethodInfo a signature where
overloadedMethod = tableIsRowSelected
instance O.OverloadedMethodInfo TableIsRowSelectedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableIsRowSelected",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableIsRowSelected"
})
#endif
foreign import ccall "atk_table_is_selected" atk_table_is_selected ::
Ptr Table ->
Int32 ->
Int32 ->
IO CInt
tableIsSelected ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> Int32
-> m Bool
tableIsSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Int32 -> m Bool
tableIsSelected a
table Int32
row Int32
column = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> Int32 -> IO CInt
atk_table_is_selected Ptr Table
table' Int32
row Int32
column
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableIsSelectedMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableIsSelectedMethodInfo a signature where
overloadedMethod = tableIsSelected
instance O.OverloadedMethodInfo TableIsSelectedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableIsSelected",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableIsSelected"
})
#endif
foreign import ccall "atk_table_ref_at" atk_table_ref_at ::
Ptr Table ->
Int32 ->
Int32 ->
IO (Ptr Atk.Object.Object)
tableRefAt ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> Int32
-> m Atk.Object.Object
tableRefAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Int32 -> m Object
tableRefAt a
table Int32
row Int32
column = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
result <- Ptr Table -> Int32 -> Int32 -> IO (Ptr Object)
atk_table_ref_at Ptr Table
table' Int32
row Int32
column
Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableRefAt" Ptr Object
result
Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'
#if defined(ENABLE_OVERLOADING)
data TableRefAtMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Atk.Object.Object), MonadIO m, IsTable a) => O.OverloadedMethod TableRefAtMethodInfo a signature where
overloadedMethod = tableRefAt
instance O.OverloadedMethodInfo TableRefAtMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableRefAt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableRefAt"
})
#endif
foreign import ccall "atk_table_remove_column_selection" atk_table_remove_column_selection ::
Ptr Table ->
Int32 ->
IO CInt
tableRemoveColumnSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableRemoveColumnSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableRemoveColumnSelection a
table Int32
column = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_remove_column_selection Ptr Table
table' Int32
column
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableRemoveColumnSelectionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableRemoveColumnSelectionMethodInfo a signature where
overloadedMethod = tableRemoveColumnSelection
instance O.OverloadedMethodInfo TableRemoveColumnSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableRemoveColumnSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableRemoveColumnSelection"
})
#endif
foreign import ccall "atk_table_remove_row_selection" atk_table_remove_row_selection ::
Ptr Table ->
Int32 ->
IO CInt
tableRemoveRowSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> m Bool
tableRemoveRowSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> m Bool
tableRemoveRowSelection a
table Int32
row = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CInt
result <- Ptr Table -> Int32 -> IO CInt
atk_table_remove_row_selection Ptr Table
table' Int32
row
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
table
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TableRemoveRowSelectionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.OverloadedMethod TableRemoveRowSelectionMethodInfo a signature where
overloadedMethod = tableRemoveRowSelection
instance O.OverloadedMethodInfo TableRemoveRowSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableRemoveRowSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableRemoveRowSelection"
})
#endif
foreign import ccall "atk_table_set_caption" atk_table_set_caption ::
Ptr Table ->
Ptr Atk.Object.Object ->
IO ()
tableSetCaption ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
a
-> b
-> m ()
tableSetCaption :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTable a, IsObject b) =>
a -> b -> m ()
tableSetCaption a
table b
caption = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
caption' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
caption
Ptr Table -> Ptr Object -> IO ()
atk_table_set_caption Ptr Table
table' Ptr Object
caption'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
caption
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetCaptionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.OverloadedMethod TableSetCaptionMethodInfo a signature where
overloadedMethod = tableSetCaption
instance O.OverloadedMethodInfo TableSetCaptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetCaption",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetCaption"
})
#endif
foreign import ccall "atk_table_set_column_description" atk_table_set_column_description ::
Ptr Table ->
Int32 ->
CString ->
IO ()
tableSetColumnDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> T.Text
-> m ()
tableSetColumnDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Text -> m ()
tableSetColumnDescription a
table Int32
column Text
description = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CString
description' <- Text -> IO CString
textToCString Text
description
Ptr Table -> Int32 -> CString -> IO ()
atk_table_set_column_description Ptr Table
table' Int32
column CString
description'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetColumnDescriptionMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.OverloadedMethod TableSetColumnDescriptionMethodInfo a signature where
overloadedMethod = tableSetColumnDescription
instance O.OverloadedMethodInfo TableSetColumnDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetColumnDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetColumnDescription"
})
#endif
foreign import ccall "atk_table_set_column_header" atk_table_set_column_header ::
Ptr Table ->
Int32 ->
Ptr Atk.Object.Object ->
IO ()
tableSetColumnHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
a
-> Int32
-> b
-> m ()
tableSetColumnHeader :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTable a, IsObject b) =>
a -> Int32 -> b -> m ()
tableSetColumnHeader a
table Int32
column b
header = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
header' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
header
Ptr Table -> Int32 -> Ptr Object -> IO ()
atk_table_set_column_header Ptr Table
table' Int32
column Ptr Object
header'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
header
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetColumnHeaderMethodInfo
instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.OverloadedMethod TableSetColumnHeaderMethodInfo a signature where
overloadedMethod = tableSetColumnHeader
instance O.OverloadedMethodInfo TableSetColumnHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetColumnHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetColumnHeader"
})
#endif
foreign import ccall "atk_table_set_row_description" atk_table_set_row_description ::
Ptr Table ->
Int32 ->
CString ->
IO ()
tableSetRowDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
a
-> Int32
-> T.Text
-> m ()
tableSetRowDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTable a) =>
a -> Int32 -> Text -> m ()
tableSetRowDescription a
table Int32
row Text
description = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
CString
description' <- Text -> IO CString
textToCString Text
description
Ptr Table -> Int32 -> CString -> IO ()
atk_table_set_row_description Ptr Table
table' Int32
row CString
description'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetRowDescriptionMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.OverloadedMethod TableSetRowDescriptionMethodInfo a signature where
overloadedMethod = tableSetRowDescription
instance O.OverloadedMethodInfo TableSetRowDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetRowDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetRowDescription"
})
#endif
foreign import ccall "atk_table_set_row_header" ::
Ptr Table ->
Int32 ->
Ptr Atk.Object.Object ->
IO ()
tableSetRowHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
a
-> Int32
-> b
-> m ()
a
table Int32
row b
header = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
header' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
header
Ptr Table -> Int32 -> Ptr Object -> IO ()
atk_table_set_row_header Ptr Table
table' Int32
row Ptr Object
header'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
header
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetRowHeaderMethodInfo
instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.OverloadedMethod TableSetRowHeaderMethodInfo a signature where
overloadedMethod = tableSetRowHeader
instance O.OverloadedMethodInfo TableSetRowHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetRowHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetRowHeader"
})
#endif
foreign import ccall "atk_table_set_summary" atk_table_set_summary ::
Ptr Table ->
Ptr Atk.Object.Object ->
IO ()
tableSetSummary ::
(B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
a
-> b
-> m ()
tableSetSummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTable a, IsObject b) =>
a -> b -> m ()
tableSetSummary a
table b
accessible = 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 Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
Ptr Object
accessible' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
accessible
Ptr Table -> Ptr Object -> IO ()
atk_table_set_summary Ptr Table
table' Ptr Object
accessible'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
accessible
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TableSetSummaryMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.OverloadedMethod TableSetSummaryMethodInfo a signature where
overloadedMethod = tableSetSummary
instance O.OverloadedMethodInfo TableSetSummaryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table.tableSetSummary",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#v:tableSetSummary"
})
#endif
type TableColumnDeletedCallback =
Int32
-> Int32
-> IO ()
type C_TableColumnDeletedCallback =
Ptr Table ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableColumnDeletedCallback :: C_TableColumnDeletedCallback -> IO (FunPtr C_TableColumnDeletedCallback)
wrap_TableColumnDeletedCallback ::
GObject a => (a -> TableColumnDeletedCallback) ->
C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback :: forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback a -> TableColumnDeletedCallback
gi'cb Ptr Table
gi'selfPtr Int32
arg1 Int32
arg2 Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> TableColumnDeletedCallback
gi'cb (Table -> a
Coerce.coerce Table
gi'self) Int32
arg1 Int32
arg2
onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnDeletedCallback) -> m SignalHandlerId
onTableColumnDeleted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
onTableColumnDeleted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-deleted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnDeletedCallback) -> m SignalHandlerId
afterTableColumnDeleted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
afterTableColumnDeleted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-deleted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableColumnDeletedSignalInfo
instance SignalInfo TableColumnDeletedSignalInfo where
type HaskellCallbackType TableColumnDeletedSignalInfo = TableColumnDeletedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableColumnDeletedCallback cb
cb'' <- mk_TableColumnDeletedCallback cb'
connectSignalFunPtr obj "column-deleted" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::column-deleted"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:columnDeleted"})
#endif
type TableColumnInsertedCallback =
Int32
-> Int32
-> IO ()
type C_TableColumnInsertedCallback =
Ptr Table ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableColumnInsertedCallback :: C_TableColumnInsertedCallback -> IO (FunPtr C_TableColumnInsertedCallback)
wrap_TableColumnInsertedCallback ::
GObject a => (a -> TableColumnInsertedCallback) ->
C_TableColumnInsertedCallback
wrap_TableColumnInsertedCallback :: forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback a -> TableColumnDeletedCallback
gi'cb Ptr Table
gi'selfPtr Int32
arg1 Int32
arg2 Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> TableColumnDeletedCallback
gi'cb (Table -> a
Coerce.coerce Table
gi'self) Int32
arg1 Int32
arg2
onTableColumnInserted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnInsertedCallback) -> m SignalHandlerId
onTableColumnInserted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
onTableColumnInserted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-inserted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnInsertedCallback) -> m SignalHandlerId
afterTableColumnInserted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
afterTableColumnInserted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-inserted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableColumnInsertedSignalInfo
instance SignalInfo TableColumnInsertedSignalInfo where
type HaskellCallbackType TableColumnInsertedSignalInfo = TableColumnInsertedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableColumnInsertedCallback cb
cb'' <- mk_TableColumnInsertedCallback cb'
connectSignalFunPtr obj "column-inserted" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::column-inserted"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:columnInserted"})
#endif
type TableColumnReorderedCallback =
IO ()
type C_TableColumnReorderedCallback =
Ptr Table ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableColumnReorderedCallback :: C_TableColumnReorderedCallback -> IO (FunPtr C_TableColumnReorderedCallback)
wrap_TableColumnReorderedCallback ::
GObject a => (a -> TableColumnReorderedCallback) ->
C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback a -> IO ()
gi'cb Ptr Table
gi'selfPtr Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> IO ()
gi'cb (Table -> a
Coerce.coerce Table
gi'self)
onTableColumnReordered :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnReorderedCallback) -> m SignalHandlerId
onTableColumnReordered :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTableColumnReordered a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-reordered" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableColumnReorderedCallback) -> m SignalHandlerId
afterTableColumnReordered :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTableColumnReordered a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"column-reordered" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableColumnReorderedSignalInfo
instance SignalInfo TableColumnReorderedSignalInfo where
type HaskellCallbackType TableColumnReorderedSignalInfo = TableColumnReorderedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableColumnReorderedCallback cb
cb'' <- mk_TableColumnReorderedCallback cb'
connectSignalFunPtr obj "column-reordered" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::column-reordered"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:columnReordered"})
#endif
type TableModelChangedCallback =
IO ()
type C_TableModelChangedCallback =
Ptr Table ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableModelChangedCallback :: C_TableModelChangedCallback -> IO (FunPtr C_TableModelChangedCallback)
wrap_TableModelChangedCallback ::
GObject a => (a -> TableModelChangedCallback) ->
C_TableModelChangedCallback
wrap_TableModelChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback a -> IO ()
gi'cb Ptr Table
gi'selfPtr Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> IO ()
gi'cb (Table -> a
Coerce.coerce Table
gi'self)
onTableModelChanged :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableModelChangedCallback) -> m SignalHandlerId
onTableModelChanged :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTableModelChanged a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableModelChangedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"model-changed" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableModelChanged :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableModelChangedCallback) -> m SignalHandlerId
afterTableModelChanged :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTableModelChanged a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableModelChangedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"model-changed" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableModelChangedSignalInfo
instance SignalInfo TableModelChangedSignalInfo where
type HaskellCallbackType TableModelChangedSignalInfo = TableModelChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableModelChangedCallback cb
cb'' <- mk_TableModelChangedCallback cb'
connectSignalFunPtr obj "model-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::model-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:modelChanged"})
#endif
type TableRowDeletedCallback =
Int32
-> Int32
-> IO ()
type C_TableRowDeletedCallback =
Ptr Table ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableRowDeletedCallback :: C_TableRowDeletedCallback -> IO (FunPtr C_TableRowDeletedCallback)
wrap_TableRowDeletedCallback ::
GObject a => (a -> TableRowDeletedCallback) ->
C_TableRowDeletedCallback
wrap_TableRowDeletedCallback :: forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback a -> TableColumnDeletedCallback
gi'cb Ptr Table
gi'selfPtr Int32
arg1 Int32
arg2 Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> TableColumnDeletedCallback
gi'cb (Table -> a
Coerce.coerce Table
gi'self) Int32
arg1 Int32
arg2
onTableRowDeleted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowDeletedCallback) -> m SignalHandlerId
onTableRowDeleted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
onTableRowDeleted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowDeletedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-deleted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowDeletedCallback) -> m SignalHandlerId
afterTableRowDeleted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
afterTableRowDeleted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowDeletedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-deleted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableRowDeletedSignalInfo
instance SignalInfo TableRowDeletedSignalInfo where
type HaskellCallbackType TableRowDeletedSignalInfo = TableRowDeletedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableRowDeletedCallback cb
cb'' <- mk_TableRowDeletedCallback cb'
connectSignalFunPtr obj "row-deleted" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::row-deleted"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:rowDeleted"})
#endif
type TableRowInsertedCallback =
Int32
-> Int32
-> IO ()
type C_TableRowInsertedCallback =
Ptr Table ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableRowInsertedCallback :: C_TableRowInsertedCallback -> IO (FunPtr C_TableRowInsertedCallback)
wrap_TableRowInsertedCallback ::
GObject a => (a -> TableRowInsertedCallback) ->
C_TableRowInsertedCallback
wrap_TableRowInsertedCallback :: forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback a -> TableColumnDeletedCallback
gi'cb Ptr Table
gi'selfPtr Int32
arg1 Int32
arg2 Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> TableColumnDeletedCallback
gi'cb (Table -> a
Coerce.coerce Table
gi'self) Int32
arg1 Int32
arg2
onTableRowInserted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowInsertedCallback) -> m SignalHandlerId
onTableRowInserted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
onTableRowInserted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowInsertedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-inserted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableRowInserted :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowInsertedCallback) -> m SignalHandlerId
afterTableRowInserted :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a
-> ((?self::a) => TableColumnDeletedCallback) -> m SignalHandlerId
afterTableRowInserted a
obj (?self::a) => TableColumnDeletedCallback
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 wrapped :: a -> TableColumnDeletedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TableColumnDeletedCallback
TableColumnDeletedCallback
cb
let wrapped' :: C_TableColumnDeletedCallback
wrapped' = (a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
forall a.
GObject a =>
(a -> TableColumnDeletedCallback) -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback a -> TableColumnDeletedCallback
wrapped
FunPtr C_TableColumnDeletedCallback
wrapped'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowInsertedCallback C_TableColumnDeletedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-inserted" FunPtr C_TableColumnDeletedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableRowInsertedSignalInfo
instance SignalInfo TableRowInsertedSignalInfo where
type HaskellCallbackType TableRowInsertedSignalInfo = TableRowInsertedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableRowInsertedCallback cb
cb'' <- mk_TableRowInsertedCallback cb'
connectSignalFunPtr obj "row-inserted" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::row-inserted"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:rowInserted"})
#endif
type TableRowReorderedCallback =
IO ()
type C_TableRowReorderedCallback =
Ptr Table ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TableRowReorderedCallback :: C_TableRowReorderedCallback -> IO (FunPtr C_TableRowReorderedCallback)
wrap_TableRowReorderedCallback ::
GObject a => (a -> TableRowReorderedCallback) ->
C_TableRowReorderedCallback
wrap_TableRowReorderedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback a -> IO ()
gi'cb Ptr Table
gi'selfPtr Ptr ()
_ = do
Ptr Table -> (Table -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Table
gi'selfPtr ((Table -> IO ()) -> IO ()) -> (Table -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Table
gi'self -> a -> IO ()
gi'cb (Table -> a
Coerce.coerce Table
gi'self)
onTableRowReordered :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowReorderedCallback) -> m SignalHandlerId
onTableRowReordered :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTableRowReordered a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableRowReorderedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-reordered" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTableRowReordered :: (IsTable a, MonadIO m) => a -> ((?self :: a) => TableRowReorderedCallback) -> m SignalHandlerId
afterTableRowReordered :: forall a (m :: * -> *).
(IsTable a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTableRowReordered a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TableColumnReorderedCallback
wrapped' = (a -> IO ()) -> C_TableColumnReorderedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback a -> IO ()
wrapped
FunPtr C_TableColumnReorderedCallback
wrapped'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableRowReorderedCallback C_TableColumnReorderedCallback
wrapped'
a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"row-reordered" FunPtr C_TableColumnReorderedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TableRowReorderedSignalInfo
instance SignalInfo TableRowReorderedSignalInfo where
type HaskellCallbackType TableRowReorderedSignalInfo = TableRowReorderedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TableRowReorderedCallback cb
cb'' <- mk_TableRowReorderedCallback cb'
connectSignalFunPtr obj "row-reordered" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Table::row-reordered"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Table.html#g:signal:rowReordered"})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Table = TableSignalList
type TableSignalList = ('[ '("columnDeleted", TableColumnDeletedSignalInfo), '("columnInserted", TableColumnInsertedSignalInfo), '("columnReordered", TableColumnReorderedSignalInfo), '("modelChanged", TableModelChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowDeleted", TableRowDeletedSignalInfo), '("rowInserted", TableRowInsertedSignalInfo), '("rowReordered", TableRowReorderedSignalInfo)] :: [(Symbol, *)])
#endif