atk/atktablecell.c

   1 /* ATK -  Accessibility Toolkit
   2  * Copyright 2014 SUSE LLC.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "atktablecell.h"
  23
  24
  25 /**
  26  * SECTION:atktablecell
  27  * @Short_description: The ATK interface implemented for a cell inside
  28  * a two-dimentional #AtkTable
  29  * @Title:AtkTableCell
  30  *
  31  * Being #AtkTable a component which present elements ordered via rows
  32  * and columns, an #AtkTableCell is the interface which each of those
  33  * elements, so "cells" should implement.
  34  *
  35  * See also #AtkTable.
  36  */
  37
  38 typedef AtkTableCellIface AtkTableCellInterface;
  39 G_DEFINE_INTERFACE (AtkTableCell, atk_table_cell, ATK_TYPE_OBJECT)
  40
  41 static gboolean atk_table_cell_real_get_row_column_span (AtkTableCell *cell,
  42                                                          gint         *row,
  43                                                          gint         *column,
  44                                                          gint         *row_span,
  45                                                          gint         *column_span);
  46
  47 static void
  48 atk_table_cell_default_init (AtkTableCellInterface *iface)
  49 {
  50   iface->get_row_column_span = atk_table_cell_real_get_row_column_span;
  51 }
  52
  53 /**
  54  * atk_table_cell_get_column_span:
  55  * @cell: a GObject instance that implements AtkTableCellIface
  56  *
  57  * Returns the number of columns occupied by this cell accessible.
  58  *
  59  * Returns: a gint representing the number of columns occupied by this cell,
  60  * or 0 if the cell does not implement this method.
  61  *
  62  * Since: 2.12
  63  */
  64 gint
  65 atk_table_cell_get_column_span (AtkTableCell *cell)
  66 {
  67   AtkTableCellIface *iface;
  68
  69   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), 0);
  70
  71   iface = ATK_TABLE_CELL_GET_IFACE (cell);
  72
  73   if (iface->get_column_span)
  74     return (iface->get_column_span) (cell);
  75   else
  76     return 0;
  77 }
  78
  79 /**
  80  * atk_table_cell_get_column_header_cells:
  81  * @cell: a GObject instance that implements AtkTableCellIface
  82  *
  83  * Returns the column headers as an array of cell accessibles.
  84  *
  85  * Returns: (element-type AtkObject) (transfer full): a GPtrArray of AtkObjects
  86  * representing the column header cells.
  87  *
  88  * Since: 2.12
  89  */
  90 GPtrArray *
  91 atk_table_cell_get_column_header_cells (AtkTableCell *cell)
  92 {
  93   AtkTableCellIface *iface;
  94
  95   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), NULL);
  96
  97   iface = ATK_TABLE_CELL_GET_IFACE (cell);
  98
  99   if (iface->get_column_header_cells)
 100     return (iface->get_column_header_cells) (cell);
 101   else
 102     return NULL;
 103 }
 104
 105 /**
 106  * atk_table_cell_get_position:
 107  * @cell: a GObject instance that implements AtkTableCellIface
 108  * @row: (out): the row of the given cell.
 109  * @column: (out): the column of the given cell.
 110  *
 111  * Retrieves the tabular position of this cell.
 112  *
 113  * Returns: TRUE if successful; FALSE otherwise.
 114  *
 115  * Since: 2.12
 116  */
 117 gboolean
 118 atk_table_cell_get_position (AtkTableCell *cell,
 119                              gint         *row,
 120                              gint         *column)
 121 {
 122   AtkTableCellIface *iface;
 123   gint tmp_row, tmp_column;
 124   gint *real_row = (row ? row : &tmp_row);
 125   gint *real_column = (column ? column : &tmp_column);
 126
 127   *real_row = -1;
 128   *real_column = -1;
 129
 130   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), FALSE);
 131
 132   iface = ATK_TABLE_CELL_GET_IFACE (cell);
 133
 134   if (iface->get_position)
 135     return (iface->get_position) (cell, real_row, real_column);
 136   else
 137     return FALSE;
 138 }
 139
 140 /**
 141  * atk_table_cell_get_row_span:
 142  * @cell: a GObject instance that implements AtkTableCellIface
 143  *
 144  * Returns the number of rows occupied by this cell accessible.
 145  *
 146  * Returns: a gint representing the number of rows occupied by this cell,
 147  * or 0 if the cell does not implement this method.
 148  *
 149  * Since: 2.12
 150  */
 151 gint
 152 atk_table_cell_get_row_span (AtkTableCell *cell)
 153 {
 154   AtkTableCellIface *iface;
 155
 156   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), 0);
 157
 158   iface = ATK_TABLE_CELL_GET_IFACE (cell);
 159
 160   if (iface->get_row_span)
 161     return (iface->get_row_span) (cell);
 162   else
 163     return 0;
 164 }
 165
 166 /**
 167  * atk_table_cell_get_row_header_cells:
 168  * @cell: a GObject instance that implements AtkTableCellIface
 169  *
 170  * Returns the row headers as an array of cell accessibles.
 171  *
 172  * Returns: (element-type AtkObject) (transfer full): a GPtrArray of AtkObjects
 173  * representing the row header cells.
 174  *
 175  * Since: 2.12
 176  */
 177 GPtrArray *
 178 atk_table_cell_get_row_header_cells (AtkTableCell *cell)
 179 {
 180   AtkTableCellIface *iface;
 181
 182   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), NULL);
 183
 184   iface = ATK_TABLE_CELL_GET_IFACE (cell);
 185
 186   if (iface->get_row_header_cells)
 187     return (iface->get_row_header_cells) (cell);
 188   else
 189     return NULL;
 190 }
 191
 192 /**
 193  * atk_table_cell_get_row_column_span:
 194  * @cell: a GObject instance that implements AtkTableCellIface
 195  * @row: (out): the row index of the given cell.
 196  * @column: (out): the column index of the given cell.
 197  * @row_span: (out): the number of rows occupied by this cell.
 198  * @column_span: (out): the number of columns occupied by this cell.
 199  *
 200  * Gets the row and column indexes and span of this cell accessible.
 201  *
 202  * Note: If the object does not implement this function, then, by default, atk
 203  * will implement this function by calling get_row_span and get_column_span
 204  * on the object.
 205  *
 206  * Returns: TRUE if successful; FALSE otherwise.
 207  *
 208  * Since: 2.12
 209  */
 210 gboolean
 211 atk_table_cell_get_row_column_span (AtkTableCell *cell,
 212                                     gint         *row,
 213                                     gint         *column,
 214                                     gint         *row_span,
 215                                     gint         *column_span)
 216 {
 217   AtkTableCellIface *iface;
 218   gint local_row = 0, local_column = 0;
 219   gint local_row_span = 0, local_column_span = 0;
 220   gint *real_row, *real_column;
 221   gint *real_row_span, *real_column_span;
 222
 223   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), FALSE);
 224
 225   real_row = (row ? row : &local_row);
 226   real_column = (column ? column : &local_column);
 227   real_row_span = (row_span ? row_span : &local_row_span);
 228   real_column_span = (column_span ? column_span : &local_column_span);
 229
 230   iface = ATK_TABLE_CELL_GET_IFACE (cell);
 231
 232   if (iface->get_row_column_span)
 233     return (iface->get_row_column_span) (cell, real_row, real_column,
 234                                            real_row_span,
 235                                            real_column_span);
 236   else
 237     return FALSE;
 238 }
 239
 240 /**
 241  * atk_table_cell_get_table:
 242  * @cell: a GObject instance that implements AtkTableCellIface
 243  *
 244  * Returns a reference to the accessible of the containing table.
 245  *
 246  * Returns: (transfer full): the atk object for the containing table.
 247  *
 248  * Since: 2.12
 249  */
 250 AtkObject *
 251 atk_table_cell_get_table (AtkTableCell *cell)
 252 {
 253   AtkTableCellIface *iface;
 254
 255   g_return_val_if_fail (ATK_IS_TABLE_CELL (cell), FALSE);
 256
 257   iface = ATK_TABLE_CELL_GET_IFACE (cell);
 258
 259   if (iface->get_table)
 260     return (iface->get_table) (cell);
 261   else
 262     return NULL;
 263 }
 264
 265 static gboolean
 266 atk_table_cell_real_get_row_column_span (AtkTableCell *cell,
 267                                          gint         *row,
 268                                          gint         *column,
 269                                          gint         *row_span,
 270                                          gint         *column_span)
 271 {
 272   atk_table_cell_get_position (cell, row, column);
 273   *row_span = atk_table_cell_get_row_span (cell);
 274   *column_span = atk_table_cell_get_column_span (cell);
 275   return (row != 0 && column != 0 && row_span > 0 && column_span > 0);
 276 }