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_row_span:
 101  * @obj: a GObject instance that implements AtspiTableCellIface
 102  *
 103  * Returns the number of rows occupied by this cell accessible.
 104  *
 105  * Returns: a gint representing the number of rows occupied by this cell,
 106  * or 0 if the cell does not implement this method.
 107  */
 108 gint
 109 atspi_table_cell_get_row_span (AtspiTableCell *obj, GError **error)
 110 {
 111   dbus_int32_t retval = -1;
 112
 113   g_return_val_if_fail (obj != NULL, -1);
 114
 115   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "RowSpan",
 116                             error, "i", &retval);
 117
 118   return retval;
 119 }
 120
 121 /**
 122  * atspi_table_cell_get_row_header_cells:
 123  * @obj: a GObject instance that implements AtspiTableCellIface
 124  *
 125  * Returns the row headers as an array of cell accessibles.
 126  *
 127  * Returns: (element-type AtspiAccessible) (transfer full): a GPtrArray of
 128  * AtspiAccessibles representing the row header cells.
 129  */
 130 GPtrArray *
 131 atspi_table_cell_get_row_header_cells (AtspiTableCell *obj, GError **error)
 132 {
 133   DBusMessage *reply;
 134
 135   g_return_val_if_fail (obj != NULL, NULL);
 136
 137   reply = _atspi_dbus_call_partial (obj, atspi_interface_table_cell, "GetRowHeaderCells", error, "");
 138
 139   return get_object_array_and_unref (reply);
 140 }
 141
 142 /**
 143  * atspi_table_cell_get_position:
 144  * @obj: a GObject instance that implements AtspiTableCellIface
 145  * @row: (out): the row of the given cell.
 146  * @column: (out): the column of the given cell.
 147  *
 148  * Retrieves the tabular position of this cell.
 149  *
 150  * Returns: TRUE if successful, FALSE otherwise.
 151  */
 152 gint
 153 atspi_table_cell_get_position (AtspiTableCell *obj,
 154                                gint *row,
 155                                gint *column,
 156                                GError **error)
 157 {
 158   DBusMessage *reply;
 159   DBusMessageIter iter, iter_struct, iter_variant;
 160   dbus_int32_t d_row = -1, d_column = -1;
 161   char *iter_sig;
 162
 163   g_return_val_if_fail (obj != NULL, -1);
 164
 165   reply = _atspi_dbus_call_partial (obj, "org.freedesktop.DBus.Properties",
 166                                     "Get", NULL, "ss",
 167                                     atspi_interface_table_cell, "Position");
 168
 169   dbus_message_iter_init (reply, &iter);
 170
 171   /* TODO: Return error here */
 172   if (dbus_message_iter_get_arg_type (&iter) != 'v')
 173     return FALSE;
 174
 175   dbus_message_iter_recurse (&iter, &iter_variant);
 176   iter_sig = dbus_message_iter_get_signature (&iter_variant);
 177   /* TODO: Also report error here */
 178   if (strcmp (iter_sig, "(ii)") != 0)
 179   {
 180     dbus_free (iter_sig);
 181     return FALSE;
 182   }
 183   dbus_free (iter_sig);
 184
 185   dbus_message_iter_recurse (&iter_variant, &iter_struct);
 186   dbus_message_iter_get_basic (&iter_struct, &d_row);
 187   if (row)
 188     *row = d_row;
 189   dbus_message_iter_next (&iter_struct);
 190   dbus_message_iter_get_basic (&iter_struct, &d_column);
 191   if (column)
 192     *column = d_column;
 193   dbus_message_unref (reply);
 194   return TRUE;
 195 }
 196
 197 /**
 198  * atspi_table_cell_get_row_column_span:
 199  * @obj: a GObject instance that implements AtspiTableCellIface
 200  * @row: (out): the row index of the given cell.
 201  * @column: (out): the column index of the given cell.
 202  * @row_span: (out): the number of rows occupied by this cell.
 203  * @column_span: (out): the number of columns occupied by this cell.
 204  *
 205  * Gets the row and column indexes and extents of this cell accessible.
 206  */
 207 void
 208 atspi_table_cell_get_row_column_span (AtspiTableCell *obj,
 209                                        gint *row,
 210                                        gint *column,
 211                                        gint *row_span,
 212                                        gint *column_span,
 213                                        GError **error)
 214 {
 215   dbus_int32_t d_row = 0,  d_column = 0, d_row_span = 0, d_column_span = 0;
 216
 217   if (row)
 218     *row = -1;
 219   if (column)
 220     *column = -1;
 221   if (row_span)
 222     *row_span = -1;
 223   if (column_span)
 224     *column_span = -1;
 225
 226   g_return_if_fail (obj != NULL);
 227
 228   _atspi_dbus_call (obj, atspi_interface_table_cell, "GetRowColumnSpan",
 229                     error, "=>iiii", &d_row, &d_column,
 230                     &d_row_span, &d_column_span);
 231
 232   if (row)
 233     *row = d_row;
 234   if (column)
 235     *column = d_column;
 236   if (row_span)
 237     *row_span = d_row_span;
 238   if (column_span)
 239     *column_span = d_column_span;
 240 }
 241
 242 /**
 243  * atspi_table_cell_get_table:
 244  * @obj: a GObject instance that implements AtspiTableCellIface
 245  *
 246  * Returns a reference to the accessible of the containing table.
 247  *
 248  * Returns: (transfer full): the AtspiAccessible for the containing table.
 249  */
 250 AtspiAccessible *
 251 atspi_table_cell_get_table (AtspiTableCell *obj, GError **error)
 252 {
 253   AtspiAccessible *retval = NULL;
 254
 255   g_return_val_if_fail (obj != NULL, NULL);
 256
 257   _atspi_dbus_get_property (obj, atspi_interface_table_cell, "Table",
 258                             error, "(so)", &retval);
 259
 260   return retval;
 261 }
 262
 263 static void
 264 atspi_table_cell_base_init (AtspiTableCell *klass)
 265 {
 266 }
 267
 268 GType
 269 atspi_table_cell_get_type (void)
 270 {
 271   static GType type = 0;
 272
 273   if (!type) {
 274     static const GTypeInfo tinfo =
 275     {
 276       sizeof (AtspiTableCell),
 277       (GBaseInitFunc) atspi_table_cell_base_init,
 278       (GBaseFinalizeFunc) NULL,
 279     };
 280
 281     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiTableCell", &tinfo, 0);
 282
 283   }
 284   return type;
 285 }