atspi/atspi-text.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 2010, 2011 Novell, Inc.
   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 "atspi-private.h"
  26 /**
  27  * atspi_range_copy:
  28  * @src: a pointer to the source #AtspiRange object that will be copied.
  29  *
  30  * Gets a copy of an #AtspiRange object.
  31  *
  32  * Returns: the #AtspiRange copy of an #AtspiRange object.
  33  **/
  34 AtspiRange *
  35 atspi_range_copy (AtspiRange *src)
  36 {
  37   AtspiRange *dst = g_new (AtspiRange, 1);
  38
  39   dst->start_offset = src->start_offset;
  40   dst->end_offset = src->end_offset;
  41   return dst;
  42 }
  43
  44 G_DEFINE_BOXED_TYPE (AtspiRange, atspi_range, atspi_range_copy, g_free)
  45
  46 static AtspiTextRange *
  47 atspi_text_range_copy (AtspiTextRange *src)
  48 {
  49   AtspiTextRange *dst = g_new (AtspiTextRange, 1);
  50
  51   dst->content = g_strdup (src->content);
  52   dst->start_offset = src->start_offset;
  53   dst->end_offset = src->end_offset;
  54   return dst;
  55 }
  56
  57 static void
  58 atspi_text_range_free (AtspiTextRange *range)
  59 {
  60   g_free (range->content);
  61   g_free (range);
  62 }
  63
  64 G_DEFINE_BOXED_TYPE (AtspiTextRange, atspi_text_range, atspi_text_range_copy,
  65                      atspi_text_range_free)
  66
  67 /**
  68  * atspi_text_get_character_count:
  69  * @obj: a pointer to the #AtspiText object to query.
  70  *
  71  * Gets the character count of an #AccessibleText object.
  72  *
  73  * Returns: a #gint indicating the total number of
  74  *              characters in the #AccessibleText object.
  75  **/
  76 gint
  77 atspi_text_get_character_count (AtspiText *obj, GError **error)
  78 {
  79   dbus_int32_t retval = 0;
  80
  81   g_return_val_if_fail (obj != NULL, -1);
  82
  83   _atspi_dbus_get_property (obj, atspi_interface_text, "CharacterCount", error, "i", &retval);
  84
  85   return retval;
  86 }
  87
  88 /**
  89  * atspi_text_get_text:
  90  * @obj: a pointer to the #AtspiText object to query.
  91  * @start_offset: a #gint indicating the start of the desired text range.
  92  * @end_offset: a #gint indicating the first character past the desired range.
  93  *
  94  * Gets a range of text from an #AtspiText object.  The number of bytes
  95  *          in the returned string may exceed either end_offset or start_offset, since
  96  *          UTF-8 is a variable-width encoding.
  97  *
  98  * Returns: a text string containing characters from @start_offset
  99  *          to @end_offset-1, inclusive, encoded as UTF-8.
 100  **/
 101 gchar *
 102 atspi_text_get_text (AtspiText *obj,
 103                         gint start_offset,
 104                         gint end_offset,
 105                         GError **error)
 106 {
 107   gchar *retval = NULL;
 108   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 109
 110   g_return_val_if_fail (obj != NULL, g_strdup (""));
 111
 112   _atspi_dbus_call (obj, atspi_interface_text, "GetText", error, "ii=>s", d_start_offset, d_end_offset, &retval);
 113
 114   if (!retval)
 115     retval = g_strdup ("");
 116
 117   return retval;
 118 }
 119
 120 /**
 121  * atspi_text_get_caret_offset:
 122  * @obj: a pointer to the #AtspiText object to query.
 123  *
 124  * Gets the current offset of the text caret in an #AtspiText object.
 125  *
 126  * Returns: a #gint indicating the current position of the text caret.
 127  **/
 128 gint
 129 atspi_text_get_caret_offset (AtspiText *obj, GError **error)
 130 {
 131   dbus_int32_t retval = -1;
 132
 133   g_return_val_if_fail (obj != NULL, -1);
 134
 135   _atspi_dbus_get_property (obj, atspi_interface_text, "CaretOffset", error, "i", &retval);
 136
 137   return retval;
 138 }
 139
 140 /**
 141  * atspi_text_get_attributes:
 142  * @obj: a pointer to the #AtspiText object to query.
 143  * @offset: a #gint indicating the offset from which the attribute
 144  *        search is based.
 145  * @start_offset: (out): a #gint pointer indicating the start of the desired text
 146  *                range.
 147  * @end_offset: (out): a #gint pointer indicating the first character past the desired
 148  *              range.
 149  *
 150  * Gets the attributes applied to a range of text from an #AtspiText
 151  * object. The text attributes correspond to CSS attributes
 152  * where possible.
 153  * <em>DEPRECATED</em>
 154  *
 155  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable
 156  * describing the attributes at the given character offset.
 157  *
 158  * Deprecated: 2.10: Use atspi_text_get_text_attributes instead.
 159  * Rename to: atspi_text_get_text_attributes
 160  **/
 161 GHashTable *
 162 atspi_text_get_attributes (AtspiText *obj,
 163                            gint offset,
 164                            gint *start_offset,
 165                            gint *end_offset,
 166                            GError **error)
 167 {
 168   return atspi_text_get_text_attributes (obj, offset, start_offset, end_offset, error);
 169 }
 170
 171 /**
 172  * atspi_text_get_text_attributes:
 173  * @obj: a pointer to the #AtspiText object to query.
 174  * @offset: a #gint indicating the offset from which the attribute
 175  *        search is based.
 176  * @start_offset: (out): a #gint pointer indicating the start of the desired text
 177  *                range.
 178  * @end_offset: (out): a #gint pointer indicating the first character past the desired
 179  *              range.
 180  *
 181  * Gets the attributes applied to a range of text from an #AtspiText
 182  * object. The text attributes correspond to CSS attributes
 183  * where possible.
 184  * <em>DEPRECATED</em>
 185  *
 186  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable
 187  * describing the attributes at the given character offset.
 188  **/
 189 GHashTable *
 190 atspi_text_get_text_attributes (AtspiText *obj,
 191                            gint offset,
 192                            gint *start_offset,
 193                            gint *end_offset,
 194                            GError **error)
 195 {
 196   dbus_int32_t d_offset = offset;
 197   dbus_int32_t d_start_offset, d_end_offset;
 198   DBusMessage *reply;
 199   DBusMessageIter iter;
 200   GHashTable *ret = NULL;
 201
 202   if (obj == NULL)
 203    return NULL;
 204
 205   reply = _atspi_dbus_call_partial (obj, atspi_interface_text, "GetAttributes", error, "i", d_offset);
 206   _ATSPI_DBUS_CHECK_SIG (reply, "a{ss}ii", error, ret)
 207
 208   dbus_message_iter_init (reply, &iter);
 209   ret = _atspi_dbus_hash_from_iter (&iter);
 210   dbus_message_iter_next (&iter);
 211
 212   dbus_message_iter_get_basic (&iter, &d_start_offset);
 213   if (start_offset)
 214     *start_offset = d_start_offset;
 215   dbus_message_iter_next (&iter);
 216   dbus_message_iter_get_basic (&iter, &d_end_offset);
 217   if (end_offset)
 218     *end_offset = d_end_offset;
 219
 220   dbus_message_unref (reply);
 221   return ret;
 222 }
 223
 224 /**
 225  * atspi_text_get_attribute_run:
 226  * @obj: a pointer to the #AtspiText object to query.
 227  * @offset: a #gint indicating the offset from which the attribute
 228  *        search is based.
 229  * @include_defaults: a #bool that, when set as #FALSE, indicates the call
 230  * should only return those attributes which are explicitly set on the current
 231  * attribute run, omitting any attributes which are inherited from the
 232  * default values.
 233  * @start_offset: (out): a #gint pointer indicating the start of the desired text
 234  *                range.
 235  * @end_offset: (out): a #gint pointer indicating the first character past the desired
 236  *              range.
 237  *
 238  * Gets a set of attributes applied to a range of text from an #AtspiText object, optionally
 239  * including its 'default' attributes.
 240  *
 241  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable with attributes
 242  *          defined at the indicated offset, optionally including the 'default' ones.
 243  **/
 244 GHashTable *
 245 atspi_text_get_attribute_run (AtspiText *obj,
 246                               gint offset,
 247                               gboolean include_defaults,
 248                               gint *start_offset,
 249                               gint *end_offset,
 250                               GError **error)
 251 {
 252   dbus_int32_t d_offset = offset;
 253   dbus_int32_t d_start_offset, d_end_offset;
 254   DBusMessage *reply;
 255   DBusMessageIter iter;
 256   GHashTable *ret = NULL;
 257
 258   if (obj == NULL)
 259    return NULL;
 260
 261   reply = _atspi_dbus_call_partial (obj, atspi_interface_text,
 262                                     "GetAttributeRun", error, "ib", d_offset,
 263                                     include_defaults);
 264   _ATSPI_DBUS_CHECK_SIG (reply, "a{ss}ii", error, ret)
 265
 266   dbus_message_iter_init (reply, &iter);
 267   ret = _atspi_dbus_hash_from_iter (&iter);
 268   dbus_message_iter_next (&iter);
 269
 270   dbus_message_iter_get_basic (&iter, &d_start_offset);
 271   if (start_offset)
 272     *start_offset = d_start_offset;
 273   dbus_message_iter_next (&iter);
 274   dbus_message_iter_get_basic (&iter, &d_end_offset);
 275   if (end_offset)
 276     *end_offset = d_end_offset;
 277
 278   dbus_message_unref (reply);
 279   return ret;
 280 }
 281
 282 /**
 283  * atspi_text_get_attribute_value:
 284  * @obj: a pointer to the #AtspiText object to query.
 285  * @offset: The character offset at which to query the attribute.
 286  * @attribute_name: The attribute to query.
 287  *
 288  * Gets the value of a named attribute at a given offset.
 289  *
 290  * Returns: the value of a given attribute at the given offset, or NULL if
 291  * not present.
 292  *
 293  * Deprecated: 2.10: Use atspi_text_get_text_attribute_value instead.
 294  * Rename to: atspi_text_get_text_attribute_value
 295  **/
 296 gchar *
 297 atspi_text_get_attribute_value (AtspiText *obj,
 298                                 gint offset,
 299                                 gchar *attribute_value,
 300                                 GError **error)
 301 {
 302   return atspi_text_get_text_attribute_value (obj, offset, attribute_value,
 303                                               error);
 304 }
 305
 306 /**
 307  * atspi_text_get_text_attribute_value:
 308  * @obj: a pointer to the #AtspiText object to query.
 309  * @offset: The character offset at which to query the attribute.
 310  * @attribute_name: The attribute to query.
 311  *
 312  * Gets the value of a named attribute at a given offset.
 313  *
 314  * Returns: the value of a given attribute at the given offset, or NULL if
 315  * not present.
 316  **/
 317 gchar *
 318 atspi_text_get_text_attribute_value (AtspiText *obj,
 319                                      gint offset,
 320                                      gchar *attribute_value,
 321                                      GError **error)
 322 {
 323   gchar *retval = NULL;
 324
 325   g_return_val_if_fail (obj != NULL, NULL);
 326
 327   _atspi_dbus_call (obj, atspi_interface_text, "GetAttributeValue", error, "i=>s", offset, &retval);
 328
 329   return retval;
 330 }
 331
 332 /**
 333  * atspi_text_get_default_attributes:
 334  * @obj: a pointer to the #AtspiText object to query.
 335  *
 336  * Gets the default attributes applied to an #AtspiText
 337  * object. The text attributes correspond to CSS attributes
 338  * where possible. The combination of this attribute set and
 339  * the attributes reported by #atspi_text_get_attributes
 340  * describes the entire set of text attributes over a range.
 341  *
 342  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable
 343  *          containing the default attributes applied to a text object,
 344  *          (exclusive of explicitly-set attributes), encoded as UTF-8.
 345  **/
 346 GHashTable *
 347 atspi_text_get_default_attributes (AtspiText *obj, GError **error)
 348 {
 349   DBusMessage *reply;
 350
 351     g_return_val_if_fail (obj != NULL, NULL);
 352
 353   reply = _atspi_dbus_call_partial (obj, atspi_interface_text, "GetDefaultAttributes", error, "");
 354   return _atspi_dbus_return_hash_from_message (reply);
 355 }
 356
 357
 358 /**
 359  * atspi_text_set_caret_offset:
 360  * @obj: a pointer to the #AtspiText object on which to operate.
 361  * @new_offset: the offset to which the text caret is to be moved.
 362  *
 363  * Moves the text caret to a given position.
 364  *
 365  * Returns: #TRUE if successful, #FALSE otherwise.
 366  **/
 367 gboolean
 368 atspi_text_set_caret_offset (AtspiText *obj,
 369                                gint new_offset,
 370                                GError **error)
 371 {
 372   dbus_int32_t d_new_offset = new_offset;
 373   dbus_bool_t retval = FALSE;
 374
 375   g_return_val_if_fail (obj != NULL, FALSE);
 376
 377   _atspi_dbus_call (obj, atspi_interface_text, "SetCaretOffset", error, "i=>b", d_new_offset, &retval);
 378
 379   return retval;
 380 }
 381
 382 /**
 383  * atspi_text_get_text_before_offset:
 384  * @obj: a pointer to the #AtspiText object on which to operate.
 385  * @offset: a #gint indicating the offset from which the delimiter
 386  *        search is based.
 387  * @type: an #AtspiTextBoundaryType indicating whether the desired
 388  *       text string is a word, sentence, line, or attribute run.
 389  *
 390  * Gets delimited text from an #AtspiText object which precedes a given
 391  *          text offset.
 392  *
 393  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 394  *          delimited text, both of whose delimiting boundaries are before the
 395  *          current offset, or an empty string if no such text exists.
 396  **/
 397 AtspiTextRange *
 398 atspi_text_get_text_before_offset (AtspiText *obj,
 399                                     gint offset,
 400                                     AtspiTextBoundaryType type,
 401                                     GError **error)
 402 {
 403   dbus_int32_t d_offset = offset;
 404   dbus_uint32_t d_type = type;
 405   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 406   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 407
 408   range->start_offset = range->end_offset = -1;
 409   if (!obj)
 410     return range;
 411
 412   _atspi_dbus_call (obj, atspi_interface_text, "GetTextBeforeOffset", error,
 413                     "iu=>sii", d_offset, d_type, &range->content,
 414                     &d_start_offset, &d_end_offset);
 415
 416   range->start_offset = d_start_offset;
 417   range->end_offset = d_end_offset;
 418   if (!range->content)
 419     range->content = g_strdup ("");
 420
 421   return range;
 422 }
 423
 424 /**
 425  * atspi_text_get_text_at_offset:
 426  * @obj: a pointer to the #AtspiText object on which to operate.
 427  * @offset: a #gint indicating the offset from which the delimiter
 428  *        search is based.
 429  * @type: an #AtspiTextBoundaryType indicating whether the desired
 430  *       text string is a word, sentence, line, or attribute run.
 431  *
 432  * Gets delimited text from an #AtspiText object which includes a given
 433  *          text offset.
 434  *
 435  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 436  *          delimited text, whose delimiting boundaries bracket the
 437  *          current offset, or an empty string if no such text exists.
 438  **/
 439 AtspiTextRange *
 440 atspi_text_get_text_at_offset (AtspiText *obj,
 441                                     gint offset,
 442                                     AtspiTextBoundaryType type,
 443                                     GError **error)
 444 {
 445   dbus_int32_t d_offset = offset;
 446   dbus_uint32_t d_type = type;
 447   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 448   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 449
 450   range->start_offset = range->end_offset = -1;
 451   if (!obj)
 452     return range;
 453
 454   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAtOffset", error,
 455                     "iu=>sii", d_offset, d_type, &range->content,
 456                     &d_start_offset, &d_end_offset);
 457
 458   range->start_offset = d_start_offset;
 459   range->end_offset = d_end_offset;
 460   if (!range->content)
 461     range->content = g_strdup ("");
 462
 463   return range;
 464 }
 465
 466 /**
 467  * atspi_text_get_text_after_offset:
 468  * @obj: a pointer to the #AtspiText object on which to operate.
 469  * @offset: a #gint indicating the offset from which the delimiter
 470  *        search is based.
 471  * @type: an #AtspiTextBoundaryType indicating whether the desired
 472  *       text string is a word, sentence, line, or attribute run.
 473  *
 474  * Gets delimited text from an #AtspiText object which follows a given
 475  *          text offset.
 476  *
 477  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 478  *          delimited text, both of whose delimiting boundaries are after or
 479  *          inclusive of the current offset, or an empty string if no such
 480  *          text exists.
 481  **/
 482 AtspiTextRange *
 483 atspi_text_get_text_after_offset (AtspiText *obj,
 484                                     gint offset,
 485                                     AtspiTextBoundaryType type,
 486                                     GError **error)
 487 {
 488   dbus_int32_t d_offset = offset;
 489   dbus_uint32_t d_type = type;
 490   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 491   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 492
 493   range->start_offset = range->end_offset = -1;
 494   if (!obj)
 495     return range;
 496
 497   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAfterOffset", error,
 498                     "iu=>sii", d_offset, d_type, &range->content,
 499                     &d_start_offset, &d_end_offset);
 500
 501   range->start_offset = d_start_offset;
 502   range->end_offset = d_end_offset;
 503   if (!range->content)
 504     range->content = g_strdup ("");
 505
 506   return range;
 507 }
 508
 509 /**
 510  * atspi_text_get_character_at_offset:
 511  * @obj: a pointer to the #AtspiText object on which to operate.
 512  * @offset: a #gint indicating the text offset where the desired
 513  *          character is located.
 514  *
 515  * Gets the character at a given offset for an #AtspiText object.
 516  *
 517  * Returns: a #guint  representing the
 518  *        UCS-4 unicode code point of the given character, or
 519  *        0xFFFFFFFF if the character in question cannot be represented
 520  *        in the UCS-4 encoding.
 521  **/
 522 guint
 523 atspi_text_get_character_at_offset (AtspiText *obj,
 524                                      gint offset,
 525                                      GError **error)
 526 {
 527   dbus_int32_t d_offset = offset;
 528   dbus_int32_t retval = -1;
 529
 530   g_return_val_if_fail (obj != NULL, -1);
 531
 532   _atspi_dbus_call (obj, atspi_interface_text, "GetCharacterAtOffset", error, "i=>i", d_offset, &retval);
 533
 534   return retval;
 535 }
 536
 537 /**
 538  * atspi_text_get_character_extents:
 539  * @obj: a pointer to the #AtspiText object on which to operate.
 540  * @offset: a #gint indicating the offset of the text character for
 541  *        whom boundary information is requested.
 542  * @type: an #AccessibleCoordType indicating the coordinate system to use
 543  *        for the returned values.
 544  *
 545  * Gets a bounding box containing the glyph representing
 546  *        the character at a particular text offset.
 547  *
 548  * Returns: An #AtspiRect specifying the position and size of the character.
 549  *
 550  **/
 551 AtspiRect *
 552 atspi_text_get_character_extents (AtspiText *obj,
 553                                     gint offset,
 554                                     AtspiCoordType type,
 555                                     GError **error)
 556 {
 557   dbus_int32_t d_offset = offset;
 558   dbus_uint32_t d_type = type;
 559   dbus_int32_t d_x, d_y, d_width, d_height;
 560   AtspiRect ret;
 561
 562   ret.x = ret.y = ret.width = ret.height = -1;
 563
 564   if (obj == NULL)
 565     return atspi_rect_copy (&ret);
 566
 567   _atspi_dbus_call (obj, atspi_interface_text, "GetCharacterExtents", error, "iu=>iiii", d_offset, d_type, &d_x, &d_y, &d_width, &d_height);
 568
 569   ret.x = d_x;
 570   ret.y = d_y;
 571   ret.width = d_width;
 572   ret.height = d_height;
 573   return atspi_rect_copy (&ret);
 574 }
 575
 576 /**
 577  * atspi_text_get_offset_at_point:
 578  * @obj: a pointer to the #AtspiText object on which to operate.
 579  * @x: the x coordinate of the point to be queried.
 580  * @y: the y coordinate of the point to be queried.
 581  * @type: an #AtspiCoordType indicating the coordinate system in which
 582  *       the values should be returned.
 583  *
 584  * Gets the character offset into the text at a given point.
 585  *
 586  * Returns: the offset (as a #gint) at the point (@x, @y)
 587  *       in the specified coordinate system.
 588  *
 589  **/
 590 gint
 591 atspi_text_get_offset_at_point (AtspiText *obj,
 592                                  gint x,
 593                                  gint y,
 594                                  AtspiCoordType type,
 595                                  GError **error)
 596 {
 597   dbus_int32_t d_x = x, d_y = y;
 598   dbus_uint32_t d_type = type;
 599   dbus_int32_t retval = -1;
 600
 601   g_return_val_if_fail (obj != NULL, -1);
 602
 603   _atspi_dbus_call (obj, atspi_interface_text, "GetOffsetAtPoint", error, "iiu=>i", d_x, d_y, d_type, &retval);
 604
 605   return retval;
 606 }
 607
 608 /**
 609  * atspi_text_get_range_extents:
 610  * @obj: a pointer to the #AtspiText object on which to operate.
 611  * @start_offset: a #gint indicating the offset of the first text character for
 612  *        whom boundary information is requested.
 613  * @end_offset: a #gint indicating the offset of the text character
 614  *        after the last character for whom boundary information is requested.
 615  * @type: an #AtspiCoordType indicating the coordinate system to use
 616  *        for the returned values.
 617  *
 618  * Gets the bounding box for text within a range in an  #AtspiText object.
 619  *
 620  * Returns: An #AtspiRect giving the position and size of the specified range
 621  *          of text.
 622  *
 623  **/
 624 AtspiRect *
 625 atspi_text_get_range_extents (AtspiText *obj,
 626                                 gint start_offset,
 627                                 gint end_offset,
 628                                 AtspiCoordType type,
 629                                 GError **error)
 630 {
 631   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 632   dbus_uint32_t d_type = type;
 633   dbus_int32_t d_x, d_y, d_width, d_height;
 634   AtspiRect ret;
 635
 636   ret.x = ret.y = ret.width = ret.height = -1;
 637
 638   if (obj == NULL)
 639     return atspi_rect_copy (&ret);
 640
 641   _atspi_dbus_call (obj, atspi_interface_text, "GetRangeExtents", error, "iiu=>iiii", d_start_offset, d_end_offset, d_type, &d_x, &d_y, &d_width, &d_height);
 642
 643   ret.x = d_x;
 644   ret.y = d_y;
 645   ret.width = d_width;
 646   ret.height = d_height;
 647   return atspi_rect_copy (&ret);
 648 }
 649
 650 /**
 651  * atspi_text_get_bounded_ranges:
 652  * @obj: a pointer to the #AtspiText object on which to operate.
 653  * @x: the 'starting' x coordinate of the bounding box.
 654  * @y: the 'starting' y coordinate of the bounding box.
 655  * @width: the x extent of the bounding box.
 656  * @height: the y extent of the bounding box.
 657  * @type: an #AccessibleCoordType indicating the coordinate system to use
 658  *        for the returned values.
 659  * @clipTypeX: an #AtspiTextClipType indicating how to treat characters that
 660  *        intersect the bounding box's x extents.
 661  * @clipTypeY: an #AtspiTextClipType indicating how to treat characters that
 662  *        intersect the bounding box's y extents.
 663  *
 664  * Gets the ranges of text from an #AtspiText object which lie within the
 665  *          bounds defined by (@x, @y) and (@x+@width, @y+@height).
 666  *
 667  * Returns: (transfer full) (element-type AtspiTextRange*): a null-terminated list of
 668  *          pointers to #AtspiTextRange structs detailing the bounded text.
 669  **/
 670 GArray *
 671 atspi_text_get_bounded_ranges (AtspiText *obj,
 672                                  gint x,
 673                                  gint y,
 674                                  gint width,
 675                                  gint height,
 676                                  AtspiCoordType type,
 677                                  AtspiTextClipType clipTypeX,
 678                                  AtspiTextClipType clipTypeY,
 679                                  GError **error)
 680 {
 681   dbus_int32_t d_x = x, d_y = y, d_width = width, d_height = height;
 682   dbus_uint32_t d_type = type;
 683   dbus_uint32_t d_clipTypeX = clipTypeX, d_clipTypeY = clipTypeY;
 684   GArray *range_seq;
 685
 686   g_return_val_if_fail (obj != NULL, NULL);
 687
 688   _atspi_dbus_call (obj, atspi_interface_text, "GetBoundedRanges", error, "iiiiuuu=>a(iisv)", d_x, d_y, d_width, d_height, d_type, d_clipTypeX, d_clipTypeY, &range_seq);
 689
 690   return range_seq;
 691 }
 692
 693 /**
 694  * atspi_text_get_n_selections:
 695  * @obj: a pointer to the #AtspiText object on which to operate.
 696  *
 697  * Gets the number of active non-contiguous selections for an
 698  *          #AtspiText object.
 699  *
 700  * Returns: a #gint indicating the current
 701  *          number of non-contiguous text selections active
 702  *          within an #AtspiText object.
 703  **/
 704 gint
 705 atspi_text_get_n_selections (AtspiText *obj, GError **error)
 706 {
 707   dbus_int32_t retval = 0;
 708
 709   g_return_val_if_fail (obj != NULL, -1);
 710
 711   _atspi_dbus_call (obj, atspi_interface_text, "GetNSelections", error, "=>i", &retval);
 712
 713   return retval;
 714 }
 715
 716 /**
 717  * atspi_text_get_selection:
 718  * @obj: a pointer to the #AtspiText object on which to operate.
 719  * @selection_num: a #gint indicating which selection to query.
 720  *
 721  * Gets the bounds of the @selection_num-th active text selection for an
 722  *         #AtspiText object.
 723  **/
 724 AtspiRange *
 725 atspi_text_get_selection (AtspiText *obj,
 726                              gint selection_num,
 727                              GError **error)
 728 {
 729   dbus_int32_t d_selection_num = selection_num;
 730   dbus_int32_t d_start_offset, d_end_offset;
 731   AtspiRange *ret = g_new (AtspiRange, 1);
 732
 733   ret->start_offset = ret->end_offset = -1;
 734
 735   if (!obj)
 736     return ret;
 737
 738   _atspi_dbus_call (obj, atspi_interface_text, "GetSelection", error, "i=>ii", d_selection_num, &d_start_offset, &d_end_offset);
 739
 740   ret->start_offset = d_start_offset;
 741   ret->end_offset = d_end_offset;
 742   return ret;
 743 }
 744
 745 /**
 746  * atspi_text_add_selection:
 747  * @obj: a pointer to the #AtspiText object on which to operate.
 748  * @start_offset: the starting offset of the desired new selection.
 749  * @end_offset: the offset of the first character after the new selection.
 750  *
 751  * Selects some text (adds a text selection) in an #AtspiText object.
 752  *
 753  * Returns: #TRUE if successful, #FALSE otherwise.
 754  **/
 755 gboolean
 756 atspi_text_add_selection (AtspiText *obj,
 757                              gint start_offset, gint end_offset,
 758                              GError **error)
 759 {
 760   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 761   dbus_bool_t retval = FALSE;
 762
 763   _atspi_dbus_call (obj, atspi_interface_text, "AddSelection", error, "ii=>b", d_start_offset, d_end_offset, &retval);
 764
 765   return retval;
 766 }
 767
 768 /**
 769  * atspi_text_remove_selection:
 770  * @obj: a pointer to the #AtspiText object on which to operate.
 771  * @selection_num: a #gint indicating which text selection to remove.
 772  *
 773  * De-selects a text selection.
 774  *
 775  * Returns: #TRUE if successful, #FALSE otherwise.
 776  **/
 777 gboolean
 778 atspi_text_remove_selection (AtspiText *obj,
 779                                 gint selection_num,
 780                                 GError **error)
 781 {
 782   dbus_int32_t d_selection_num = selection_num;
 783   dbus_bool_t retval = FALSE;
 784
 785   g_return_val_if_fail (obj != NULL, FALSE);
 786
 787   _atspi_dbus_call (obj, atspi_interface_text, "RemoveSelection", error, "i=>b", d_selection_num, &retval);
 788
 789   return retval;
 790 }
 791
 792 /**
 793  * atspi_text_set_selection:
 794  * @obj: a pointer to the #AtspiText object on which to operate.
 795  * @selection_num: a zero-offset index indicating which text selection to modify.
 796  * @start_offset: a #gint indicating the new starting offset for the selection.
 797  * @end_offset: a #gint indicating the desired new offset of the first character
 798  *             after the selection.
 799  *
 800  * Changes the bounds of an existing #AtspiText text selection.
 801  *
 802  * Returns: #TRUE if successful, #FALSE otherwise.
 803  **/
 804 gboolean
 805 atspi_text_set_selection (AtspiText *obj,
 806                              gint selection_num,
 807                              gint start_offset,
 808                              gint end_offset,
 809                              GError **error)
 810 {
 811   dbus_int32_t d_selection_num = selection_num, d_start_offset = start_offset, d_end_offset = end_offset;
 812   dbus_bool_t retval = FALSE;
 813
 814   g_return_val_if_fail (obj != NULL, FALSE);
 815
 816   _atspi_dbus_call (obj, atspi_interface_text, "SetSelection", error, "iii=>b", d_selection_num, d_start_offset, d_end_offset, &retval);
 817
 818   return retval;
 819 }
 820
 821 static void
 822 atspi_text_base_init (AtspiText *klass)
 823 {
 824 }
 825
 826 GType
 827 atspi_text_get_type (void)
 828 {
 829   static GType type = 0;
 830
 831   if (!type) {
 832     static const GTypeInfo tinfo =
 833     {
 834       sizeof (AtspiText),
 835       (GBaseInitFunc) atspi_text_base_init,
 836       (GBaseFinalizeFunc) NULL,
 837     };
 838
 839     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiText", &tinfo, 0);
 840
 841   }
 842   return type;
 843 }