{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Interfaces.TableCell
(
TableCell(..) ,
IsTableCell ,
toTableCell ,
#if defined(ENABLE_OVERLOADING)
ResolveTableCellMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TableCellGetColumnHeaderCellsMethodInfo ,
#endif
tableCellGetColumnHeaderCells ,
#if defined(ENABLE_OVERLOADING)
TableCellGetColumnSpanMethodInfo ,
#endif
tableCellGetColumnSpan ,
#if defined(ENABLE_OVERLOADING)
TableCellGetPositionMethodInfo ,
#endif
tableCellGetPosition ,
#if defined(ENABLE_OVERLOADING)
TableCellGetRowColumnSpanMethodInfo ,
#endif
tableCellGetRowColumnSpan ,
#if defined(ENABLE_OVERLOADING)
TableCellGetRowHeaderCellsMethodInfo ,
#endif
tableCellGetRowHeaderCells ,
#if defined(ENABLE_OVERLOADING)
TableCellGetRowSpanMethodInfo ,
#endif
tableCellGetRowSpan ,
#if defined(ENABLE_OVERLOADING)
TableCellGetTableMethodInfo ,
#endif
tableCellGetTable ,
) 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.GHashTable as B.GHT
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.Kind as DK
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 TableCell = TableCell (SP.ManagedPtr TableCell)
deriving (TableCell -> TableCell -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableCell -> TableCell -> Bool
$c/= :: TableCell -> TableCell -> Bool
== :: TableCell -> TableCell -> Bool
$c== :: TableCell -> TableCell -> Bool
Eq)
instance SP.ManagedPtrNewtype TableCell where
toManagedPtr :: TableCell -> ManagedPtr TableCell
toManagedPtr (TableCell ManagedPtr TableCell
p) = ManagedPtr TableCell
p
foreign import ccall "atk_table_cell_get_type"
c_atk_table_cell_get_type :: IO B.Types.GType
instance B.Types.TypedObject TableCell where
glibType :: IO GType
glibType = IO GType
c_atk_table_cell_get_type
instance B.Types.GObject TableCell
class (SP.GObject o, O.IsDescendantOf TableCell o) => IsTableCell o
instance (SP.GObject o, O.IsDescendantOf TableCell o) => IsTableCell o
instance O.HasParentTypes TableCell
type instance O.ParentTypes TableCell = '[Atk.Object.Object, GObject.Object.Object]
toTableCell :: (MIO.MonadIO m, IsTableCell o) => o -> m TableCell
toTableCell :: forall (m :: * -> *) o.
(MonadIO m, IsTableCell o) =>
o -> m TableCell
toTableCell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TableCell -> TableCell
TableCell
instance B.GValue.IsGValue (Maybe TableCell) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_table_cell_get_type
gvalueSet_ :: Ptr GValue -> Maybe TableCell -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TableCell
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr TableCell)
gvalueSet_ Ptr GValue
gv (P.Just TableCell
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TableCell
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TableCell)
gvalueGet_ Ptr GValue
gv = do
Ptr TableCell
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TableCell)
if Ptr TableCell
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TableCell -> TableCell
TableCell Ptr TableCell
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TableCell
type instance O.AttributeList TableCell = TableCellAttributeList
type TableCellAttributeList = ('[ '("accessibleComponentLayer", Atk.Object.ObjectAccessibleComponentLayerPropertyInfo), '("accessibleComponentMdiZorder", Atk.Object.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessibleDescription", Atk.Object.ObjectAccessibleDescriptionPropertyInfo), '("accessibleHypertextNlinks", Atk.Object.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessibleName", Atk.Object.ObjectAccessibleNamePropertyInfo), '("accessibleParent", Atk.Object.ObjectAccessibleParentPropertyInfo), '("accessibleRole", Atk.Object.ObjectAccessibleRolePropertyInfo), '("accessibleTableCaption", Atk.Object.ObjectAccessibleTableCaptionPropertyInfo), '("accessibleTableCaptionObject", Atk.Object.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessibleTableColumnDescription", Atk.Object.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessibleTableColumnHeader", Atk.Object.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessibleTableRowDescription", Atk.Object.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessibleTableRowHeader", Atk.Object.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessibleTableSummary", Atk.Object.ObjectAccessibleTableSummaryPropertyInfo), '("accessibleValue", Atk.Object.ObjectAccessibleValuePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTableCellMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTableCellMethod "addRelationship" o = Atk.Object.ObjectAddRelationshipMethodInfo
ResolveTableCellMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTableCellMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTableCellMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTableCellMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTableCellMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTableCellMethod "initialize" o = Atk.Object.ObjectInitializeMethodInfo
ResolveTableCellMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTableCellMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTableCellMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTableCellMethod "notifyStateChange" o = Atk.Object.ObjectNotifyStateChangeMethodInfo
ResolveTableCellMethod "peekParent" o = Atk.Object.ObjectPeekParentMethodInfo
ResolveTableCellMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTableCellMethod "refAccessibleChild" o = Atk.Object.ObjectRefAccessibleChildMethodInfo
ResolveTableCellMethod "refRelationSet" o = Atk.Object.ObjectRefRelationSetMethodInfo
ResolveTableCellMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTableCellMethod "refStateSet" o = Atk.Object.ObjectRefStateSetMethodInfo
ResolveTableCellMethod "removePropertyChangeHandler" o = Atk.Object.ObjectRemovePropertyChangeHandlerMethodInfo
ResolveTableCellMethod "removeRelationship" o = Atk.Object.ObjectRemoveRelationshipMethodInfo
ResolveTableCellMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTableCellMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTableCellMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTableCellMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTableCellMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTableCellMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTableCellMethod "getAccessibleId" o = Atk.Object.ObjectGetAccessibleIdMethodInfo
ResolveTableCellMethod "getAttributes" o = Atk.Object.ObjectGetAttributesMethodInfo
ResolveTableCellMethod "getColumnHeaderCells" o = TableCellGetColumnHeaderCellsMethodInfo
ResolveTableCellMethod "getColumnSpan" o = TableCellGetColumnSpanMethodInfo
ResolveTableCellMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTableCellMethod "getDescription" o = Atk.Object.ObjectGetDescriptionMethodInfo
ResolveTableCellMethod "getIndexInParent" o = Atk.Object.ObjectGetIndexInParentMethodInfo
ResolveTableCellMethod "getLayer" o = Atk.Object.ObjectGetLayerMethodInfo
ResolveTableCellMethod "getMdiZorder" o = Atk.Object.ObjectGetMdiZorderMethodInfo
ResolveTableCellMethod "getNAccessibleChildren" o = Atk.Object.ObjectGetNAccessibleChildrenMethodInfo
ResolveTableCellMethod "getName" o = Atk.Object.ObjectGetNameMethodInfo
ResolveTableCellMethod "getObjectLocale" o = Atk.Object.ObjectGetObjectLocaleMethodInfo
ResolveTableCellMethod "getParent" o = Atk.Object.ObjectGetParentMethodInfo
ResolveTableCellMethod "getPosition" o = TableCellGetPositionMethodInfo
ResolveTableCellMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTableCellMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTableCellMethod "getRole" o = Atk.Object.ObjectGetRoleMethodInfo
ResolveTableCellMethod "getRowColumnSpan" o = TableCellGetRowColumnSpanMethodInfo
ResolveTableCellMethod "getRowHeaderCells" o = TableCellGetRowHeaderCellsMethodInfo
ResolveTableCellMethod "getRowSpan" o = TableCellGetRowSpanMethodInfo
ResolveTableCellMethod "getTable" o = TableCellGetTableMethodInfo
ResolveTableCellMethod "setAccessibleId" o = Atk.Object.ObjectSetAccessibleIdMethodInfo
ResolveTableCellMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTableCellMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTableCellMethod "setDescription" o = Atk.Object.ObjectSetDescriptionMethodInfo
ResolveTableCellMethod "setName" o = Atk.Object.ObjectSetNameMethodInfo
ResolveTableCellMethod "setParent" o = Atk.Object.ObjectSetParentMethodInfo
ResolveTableCellMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTableCellMethod "setRole" o = Atk.Object.ObjectSetRoleMethodInfo
ResolveTableCellMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTableCellMethod t TableCell, O.OverloadedMethod info TableCell p) => OL.IsLabel t (TableCell -> 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 ~ ResolveTableCellMethod t TableCell, O.OverloadedMethod info TableCell p, R.HasField t TableCell p) => R.HasField t TableCell p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTableCellMethod t TableCell, O.OverloadedMethodInfo info TableCell) => OL.IsLabel t (O.MethodProxy info TableCell) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "atk_table_cell_get_column_header_cells" atk_table_cell_get_column_header_cells ::
Ptr TableCell ->
IO (Ptr (GPtrArray (Ptr Atk.Object.Object)))
tableCellGetColumnHeaderCells ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m [Atk.Object.Object]
tableCellGetColumnHeaderCells :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m [Object]
tableCellGetColumnHeaderCells a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Ptr (GPtrArray (Ptr Object))
result <- Ptr TableCell -> IO (Ptr (GPtrArray (Ptr Object)))
atk_table_cell_get_column_header_cells Ptr TableCell
cell'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableCellGetColumnHeaderCells" Ptr (GPtrArray (Ptr Object))
result
[Ptr Object]
result' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr Object))
result
[Object]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (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'
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr Object))
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall (m :: * -> *) a. Monad m => a -> m a
return [Object]
result''
#if defined(ENABLE_OVERLOADING)
data TableCellGetColumnHeaderCellsMethodInfo
instance (signature ~ (m [Atk.Object.Object]), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetColumnHeaderCellsMethodInfo a signature where
overloadedMethod = tableCellGetColumnHeaderCells
instance O.OverloadedMethodInfo TableCellGetColumnHeaderCellsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetColumnHeaderCells",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetColumnHeaderCells"
})
#endif
foreign import ccall "atk_table_cell_get_column_span" atk_table_cell_get_column_span ::
Ptr TableCell ->
IO Int32
tableCellGetColumnSpan ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m Int32
tableCellGetColumnSpan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m Int32
tableCellGetColumnSpan a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Int32
result <- Ptr TableCell -> IO Int32
atk_table_cell_get_column_span Ptr TableCell
cell'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableCellGetColumnSpanMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetColumnSpanMethodInfo a signature where
overloadedMethod = tableCellGetColumnSpan
instance O.OverloadedMethodInfo TableCellGetColumnSpanMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetColumnSpan",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetColumnSpan"
})
#endif
foreign import ccall "atk_table_cell_get_position" atk_table_cell_get_position ::
Ptr TableCell ->
Ptr Int32 ->
Ptr Int32 ->
IO CInt
tableCellGetPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m ((Bool, Int32, Int32))
tableCellGetPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m (Bool, Int32, Int32)
tableCellGetPosition a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Ptr Int32
row <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
column <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr TableCell -> Ptr Int32 -> Ptr Int32 -> IO CInt
atk_table_cell_get_position Ptr TableCell
cell' Ptr Int32
row Ptr Int32
column
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
row' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
row
Int32
column' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
column
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall a. Ptr a -> IO ()
freeMem Ptr Int32
row
forall a. Ptr a -> IO ()
freeMem Ptr Int32
column
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
row', Int32
column')
#if defined(ENABLE_OVERLOADING)
data TableCellGetPositionMethodInfo
instance (signature ~ (m ((Bool, Int32, Int32))), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetPositionMethodInfo a signature where
overloadedMethod = tableCellGetPosition
instance O.OverloadedMethodInfo TableCellGetPositionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetPosition"
})
#endif
foreign import ccall "atk_table_cell_get_row_column_span" atk_table_cell_get_row_column_span ::
Ptr TableCell ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
IO CInt
tableCellGetRowColumnSpan ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m ((Bool, Int32, Int32, Int32, Int32))
tableCellGetRowColumnSpan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m (Bool, Int32, Int32, Int32, Int32)
tableCellGetRowColumnSpan a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Ptr Int32
row <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
column <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
rowSpan <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
columnSpan <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr TableCell
-> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO CInt
atk_table_cell_get_row_column_span Ptr TableCell
cell' Ptr Int32
row Ptr Int32
column Ptr Int32
rowSpan Ptr Int32
columnSpan
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
row' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
row
Int32
column' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
column
Int32
rowSpan' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
rowSpan
Int32
columnSpan' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
columnSpan
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall a. Ptr a -> IO ()
freeMem Ptr Int32
row
forall a. Ptr a -> IO ()
freeMem Ptr Int32
column
forall a. Ptr a -> IO ()
freeMem Ptr Int32
rowSpan
forall a. Ptr a -> IO ()
freeMem Ptr Int32
columnSpan
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
row', Int32
column', Int32
rowSpan', Int32
columnSpan')
#if defined(ENABLE_OVERLOADING)
data TableCellGetRowColumnSpanMethodInfo
instance (signature ~ (m ((Bool, Int32, Int32, Int32, Int32))), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetRowColumnSpanMethodInfo a signature where
overloadedMethod = tableCellGetRowColumnSpan
instance O.OverloadedMethodInfo TableCellGetRowColumnSpanMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetRowColumnSpan",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetRowColumnSpan"
})
#endif
foreign import ccall "atk_table_cell_get_row_header_cells" ::
Ptr TableCell ->
IO (Ptr (GPtrArray (Ptr Atk.Object.Object)))
tableCellGetRowHeaderCells ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m [Atk.Object.Object]
a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Ptr (GPtrArray (Ptr Object))
result <- Ptr TableCell -> IO (Ptr (GPtrArray (Ptr Object)))
atk_table_cell_get_row_header_cells Ptr TableCell
cell'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableCellGetRowHeaderCells" Ptr (GPtrArray (Ptr Object))
result
[Ptr Object]
result' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr Object))
result
[Object]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (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'
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr Object))
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall (m :: * -> *) a. Monad m => a -> m a
return [Object]
result''
#if defined(ENABLE_OVERLOADING)
data TableCellGetRowHeaderCellsMethodInfo
instance (signature ~ (m [Atk.Object.Object]), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetRowHeaderCellsMethodInfo a signature where
overloadedMethod = tableCellGetRowHeaderCells
instance O.OverloadedMethodInfo TableCellGetRowHeaderCellsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetRowHeaderCells",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetRowHeaderCells"
})
#endif
foreign import ccall "atk_table_cell_get_row_span" atk_table_cell_get_row_span ::
Ptr TableCell ->
IO Int32
tableCellGetRowSpan ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m Int32
tableCellGetRowSpan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m Int32
tableCellGetRowSpan a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Int32
result <- Ptr TableCell -> IO Int32
atk_table_cell_get_row_span Ptr TableCell
cell'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TableCellGetRowSpanMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetRowSpanMethodInfo a signature where
overloadedMethod = tableCellGetRowSpan
instance O.OverloadedMethodInfo TableCellGetRowSpanMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetRowSpan",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetRowSpan"
})
#endif
foreign import ccall "atk_table_cell_get_table" atk_table_cell_get_table ::
Ptr TableCell ->
IO (Ptr Atk.Object.Object)
tableCellGetTable ::
(B.CallStack.HasCallStack, MonadIO m, IsTableCell a) =>
a
-> m Atk.Object.Object
tableCellGetTable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTableCell a) =>
a -> m Object
tableCellGetTable a
cell = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TableCell
cell' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
Ptr Object
result <- Ptr TableCell -> IO (Ptr Object)
atk_table_cell_get_table Ptr TableCell
cell'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tableCellGetTable" Ptr Object
result
Object
result' <- (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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'
#if defined(ENABLE_OVERLOADING)
data TableCellGetTableMethodInfo
instance (signature ~ (m Atk.Object.Object), MonadIO m, IsTableCell a) => O.OverloadedMethod TableCellGetTableMethodInfo a signature where
overloadedMethod = tableCellGetTable
instance O.OverloadedMethodInfo TableCellGetTableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.TableCell.tableCellGetTable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-TableCell.html#v:tableCellGetTable"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TableCell = TableCellSignalList
type TableCellSignalList = ('[ '("activeDescendantChanged", Atk.Object.ObjectActiveDescendantChangedSignalInfo), '("announcement", Atk.Object.ObjectAnnouncementSignalInfo), '("childrenChanged", Atk.Object.ObjectChildrenChangedSignalInfo), '("focusEvent", Atk.Object.ObjectFocusEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", Atk.Object.ObjectPropertyChangeSignalInfo), '("stateChange", Atk.Object.ObjectStateChangeSignalInfo), '("visibleDataChanged", Atk.Object.ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, DK.Type)])
#endif