atspi/atspi-table-cell.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  * Copyright 2013 SUSE LLC.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include <stdlib.h> /* for malloc */
  26 #include "atspi-private.h"
  27
  28 static GPtrArray *
  29 get_object_array_and_unref (DBusMessage *reply)
  30 {
  31   DBusMessageIter iter, iter_array;
  32   GPtrArray *array;
  33
  34   if (!reply)
  35     return NULL;
  36
  37   if (strcmp (dbus_message_get_signature (reply), "(so)") != 0)
  38   {
  39     dbus_message_unref (reply);
  40     return NULL;
  41   }
  42
  43   array = g_ptr_array_new ();
  44
  45   dbus_message_iter_init (reply, &iter);
  46   dbus_message_iter_recurse (&iter, &iter_array);
  47   while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
  48   {
  49     AtspiAccessible *accessible = _atspi_dbus_return_accessible_from_iter (&iter_array);
  50     g_ptr_array_add (array, accessible);
  51   }
  52   dbus_message_unref (reply);
  53   return array;
  54 }
  55
  56 /**
  57  * atspi_table_cell_get_column_span:
  58  * @obj: a GObject instance that implements AtspiTableCellIface
  59  *
  60  * Returns the number of columns occupied by this cell accessible.
  61  *
  62  * Returns: a gint representing the number of columns occupied by this cell,
  63  * or 0 if the cell does not implement this method.
  64  */
  65 gint
  66 atspi_table_cell_get_column_span (AtspiTableCell *obj, GError *error)
  67 {
  68   dbus_int32_t retval = -1;
  69
  70   g_return_val_if_fail (obj != NULL, -1);
  71
  72   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "ColumnSpan",
  73                             error, "i", &retval);
  74
  75   return retval;
  76 }
  77
  78 /**
  79  * atspi_table_cell_get_column_header_cells:
  80  * @obj: a GObject instance that implements AtspiTableCellIface
  81  *
  82  * Returns the column headers as an array of cell accessibles.
  83  *
  84  * Returns: (element-type AtspiAccessible) (transfer full): a GPtrArray of
  85  * AtspiAccessibles representing the column header cells.
  86   */
  87 GPtrArray *
  88 atspi_table_cell_get_column_header_cells (AtspiTableCell *obj, GError **error)
  89 {
  90   DBusMessage *reply;
  91
  92   g_return_val_if_fail (obj != NULL, NULL);
  93
  94   reply = _atspi_dbus_call_partial (obj, atspi_interface_table_cell, "GetColumnHeaderCells", error, "");
  95
  96   return get_object_array_and_unref (reply);
  97 }
  98
  99 /**
 100  * atspi_table_cell_get_column_index:
 101  * @obj: a GObject instance that implements AtspiTableCellIface
 102  *
 103  * Translates this cell accessible into the corresponding column index.
 104  *
 105  * Returns: the column index for this cell, or -1 if unimplemented.
 106  */
 107 gint
 108 atspi_table_cell_get_column_index (AtspiTableCell *obj, GError **error)
 109 {
 110   dbus_int32_t retval = -1;
 111
 112   g_return_val_if_fail (obj != NULL, -1);
 113
 114   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "ColumnIndex",
 115                             error, "i", &retval);
 116
 117   return retval;
 118 }
 119
 120 /**
 121  * atspi_table_cell_get_row_span:
 122  * @obj: a GObject instance that implements AtspiTableCellIface
 123  *
 124  * Returns the number of rows occupied by this cell accessible.
 125  *
 126  * Returns: a gint representing the number of rows occupied by this cell,
 127  * or 0 if the cell does not implement this method.
 128  */
 129 gint
 130 atspi_table_cell_get_row_span (AtspiTableCell *obj, GError **error)
 131 {
 132   dbus_int32_t retval = -1;
 133
 134   g_return_val_if_fail (obj != NULL, -1);
 135
 136   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "RowSpan",
 137                             error, "i", &retval);
 138
 139   return retval;
 140 }
 141
 142 /**
 143  * atspi_table_cell_get_row_header_cells:
 144  * @obj: a GObject instance that implements AtspiTableCellIface
 145  *
 146  * Returns the row headers as an array of cell accessibles.
 147  *
 148  * Returns: (element-type AtspiAccessible) (transfer full): a GPtrArray of
 149  * AtspiAccessibles representing the row header cells.
 150  *  */
 151 GPtrArray *
 152 atspi_table_cell_get_row_header_cells (AtspiTableCell *obj, GError **error)
 153 {
 154   DBusMessage *reply;
 155
 156   g_return_val_if_fail (obj != NULL, NULL);
 157
 158   reply = _atspi_dbus_call_partial (obj, atspi_interface_table_cell, "GetRowHeaderCells", error, "");
 159
 160   return get_object_array_and_unref (reply);
 161 }
 162
 163 /**
 164  * atspi_table_cell_get_position:
 165  * @obj: a GObject instance that implements AtspiTableCellIface
 166  * @row: (out): the row of the given cell.
 167  * @column: (out): the column of the given cell.
 168  *
 169  * Retrieves the tabular position of this cell.
 170  *
 171  * Returns: TRUE if successful, FALSE otherwise.
 172  */
 173 gint
 174 atspi_table_cell_get_position (AtspiTableCell *obj,
 175                                gint *row,
 176                                gint *column,
 177                                GError *error)
 178 {
 179   DBusMessage *reply;
 180   DBusMessageIter iter, iter_struct, iter_variant;
 181   dbus_int32_t d_row = -1, d_column = -1;
 182
 183   g_return_val_if_fail (obj != NULL, -1);
 184
 185   reply = _atspi_dbus_call_partial (obj, "org.freedesktop.DBuss.Properties",
 186                                     "Get", atspi_interface_table_cell,
 187                                     "Position");
 188
 189   dbus_message_iter_init (reply, &iter);
 190
 191   /* TODO: Return error here */
 192   if (dbus_message_iter_get_arg_type (&iter) != 'v')
 193     return FALSE;
 194
 195   dbus_message_iter_recurse (&iter, &iter_variant);
 196   /* TODO: Also report error here */
 197   if (strcmp (dbus_message_iter_get_signature (&iter_variant), "(ii)") != 0)
 198     return FALSE;
 199
 200   dbus_message_iter_recurse (&iter_variant, &iter_struct);
 201   dbus_message_iter_get_basic (&iter_struct, &d_row);
 202   if (row)
 203     *row = d_row;
 204   dbus_message_iter_next (&iter_struct);
 205   dbus_message_iter_get_basic (&iter_struct, &d_column);
 206   if (column)
 207     *column = d_column;
 208   dbus_message_unref (reply);
 209   return TRUE;
 210 }
 211
 212 /**
 213  * atspi_table_cell_get_row_column_span:
 214  * @obj: a GObject instance that implements AtspiTableCellIface
 215  * @row: (out): the row index of the given cell.
 216  * @column: (out): the column index of the given cell.
 217  * @row_span: (out): the number of rows occupied by this cell.
 218  * @column_span: (out): the number of columns occupied by this cell.
 219  *
 220  * Gets the row and column indexes and extents of this cell accessible.
 221  */
 222 void
 223 atspi_table_cell_get_row_column_span (AtspiTableCell *obj,
 224                                        gint *row,
 225                                        gint *column,
 226                                        gint *row_span,
 227                                        gint *column_span,
 228                                        GError **error)
 229 {
 230   dbus_int32_t d_row = 0,  d_column = 0, d_row_span = 0, d_column_span = 0;
 231
 232   if (row)
 233     *row = -1;
 234   if (column)
 235     *column = -1;
 236   if (row_span)
 237     *row_span = -1;
 238   if (column_span)
 239     *column_span = -1;
 240
 241   g_return_if_fail (obj != NULL);
 242
 243   _atspi_dbus_call (obj, atspi_interface_table_cell, "GetRowColumnSpan",
 244                     error, "=>iiii", &d_row, &d_column,
 245                     &d_row_span, &d_column_span);
 246
 247   if (row)
 248     *row = d_row;
 249   if (column)
 250     *column = d_column;
 251   if (row_span)
 252     *row_span = d_row_span;
 253   if (column_span)
 254     *column_span = d_column_span;
 255 }
 256
 257 /**
 258  * atspi_table_cell_get_table:
 259  * @obj: a GObject instance that implements AtspiTableCellIface
 260  *
 261  * Returns a reference to the accessible of the containing table.
 262  *
 263  * Returns: (transfer full): the AtspiAccessible for the containing table.
 264  */
 265 AtspiAccessible *
 266 atspi_table_cell_get_table (AtspiTableCell *obj, GError **error)
 267 {
 268   AtspiAccessible *retval = NULL;
 269
 270   g_return_val_if_fail (obj != NULL, NULL);
 271
 272   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "Table",
 273                             error, "(so)", &retval);
 274
 275   return retval;
 276 }
 277
 278 static void
 279 atspi_table_cell_base_init (AtspiTableCell *klass)
 280 {
 281 }
 282
 283 GType
 284 atspi_table_cell_get_type (void)
 285 {
 286   static GType type = 0;
 287
 288   if (!type) {
 289     static const GTypeInfo tinfo =
 290     {
 291       sizeof (AtspiTableCell),
 292       (GBaseInitFunc) atspi_table_cell_base_init,
 293       (GBaseFinalizeFunc) NULL,
 294     };
 295
 296     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiTableCell", &tinfo, 0);
 297
 298   }
 299   return type;
 300 }