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: (rename-to atspi_text_get_text_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  **/
 160 GHashTable *
 161 atspi_text_get_attributes (AtspiText *obj,
 162                            gint offset,
 163                            gint *start_offset,
 164                            gint *end_offset,
 165                            GError **error)
 166 {
 167   return atspi_text_get_text_attributes (obj, offset, start_offset, end_offset, error);
 168 }
 169
 170 /**
 171  * atspi_text_get_text_attributes:
 172  * @obj: a pointer to the #AtspiText object to query.
 173  * @offset: a #gint indicating the offset from which the attribute
 174  *        search is based.
 175  * @start_offset: (out): a #gint pointer indicating the start of the desired text
 176  *                range.
 177  * @end_offset: (out): a #gint pointer indicating the first character past the desired
 178  *              range.
 179  *
 180  * Gets the attributes applied to a range of text from an #AtspiText
 181  * object. The text attributes correspond to CSS attributes
 182  * where possible.
 183  * <em>DEPRECATED</em>
 184  *
 185  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable
 186  * describing the attributes at the given character offset.
 187  **/
 188 GHashTable *
 189 atspi_text_get_text_attributes (AtspiText *obj,
 190                            gint offset,
 191                            gint *start_offset,
 192                            gint *end_offset,
 193                            GError **error)
 194 {
 195   dbus_int32_t d_offset = offset;
 196   dbus_int32_t d_start_offset, d_end_offset;
 197   DBusMessage *reply;
 198   DBusMessageIter iter;
 199   GHashTable *ret = NULL;
 200
 201   if (obj == NULL)
 202    return NULL;
 203
 204   reply = _atspi_dbus_call_partial (obj, atspi_interface_text, "GetAttributes", error, "i", d_offset);
 205   _ATSPI_DBUS_CHECK_SIG (reply, "a{ss}ii", error, ret)
 206
 207   dbus_message_iter_init (reply, &iter);
 208   ret = _atspi_dbus_hash_from_iter (&iter);
 209   dbus_message_iter_next (&iter);
 210
 211   dbus_message_iter_get_basic (&iter, &d_start_offset);
 212   if (start_offset)
 213     *start_offset = d_start_offset;
 214   dbus_message_iter_next (&iter);
 215   dbus_message_iter_get_basic (&iter, &d_end_offset);
 216   if (end_offset)
 217     *end_offset = d_end_offset;
 218
 219   dbus_message_unref (reply);
 220   return ret;
 221 }
 222
 223 /**
 224  * atspi_text_get_attribute_run:
 225  * @obj: a pointer to the #AtspiText object to query.
 226  * @offset: a #gint indicating the offset from which the attribute
 227  *        search is based.
 228  * @include_defaults: a #bool that, when set as #FALSE, indicates the call
 229  * should only return those attributes which are explicitly set on the current
 230  * attribute run, omitting any attributes which are inherited from the
 231  * default values.
 232  * @start_offset: (out): a #gint pointer indicating the start of the desired text
 233  *                range.
 234  * @end_offset: (out): a #gint pointer indicating the first character past the desired
 235  *              range.
 236  *
 237  * Gets a set of attributes applied to a range of text from an #AtspiText object, optionally
 238  * including its 'default' attributes.
 239  *
 240  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable with attributes
 241  *          defined at the indicated offset, optionally including the 'default' ones.
 242  **/
 243 GHashTable *
 244 atspi_text_get_attribute_run (AtspiText *obj,
 245                               gint offset,
 246                               gboolean include_defaults,
 247                               gint *start_offset,
 248                               gint *end_offset,
 249                               GError **error)
 250 {
 251   dbus_int32_t d_offset = offset;
 252   dbus_int32_t d_start_offset, d_end_offset;
 253   DBusMessage *reply;
 254   DBusMessageIter iter;
 255   GHashTable *ret = NULL;
 256
 257   if (obj == NULL)
 258    return NULL;
 259
 260   reply = _atspi_dbus_call_partial (obj, atspi_interface_text,
 261                                     "GetAttributeRun", error, "ib", d_offset,
 262                                     include_defaults);
 263   _ATSPI_DBUS_CHECK_SIG (reply, "a{ss}ii", error, ret)
 264
 265   dbus_message_iter_init (reply, &iter);
 266   ret = _atspi_dbus_hash_from_iter (&iter);
 267   dbus_message_iter_next (&iter);
 268
 269   dbus_message_iter_get_basic (&iter, &d_start_offset);
 270   if (start_offset)
 271     *start_offset = d_start_offset;
 272   dbus_message_iter_next (&iter);
 273   dbus_message_iter_get_basic (&iter, &d_end_offset);
 274   if (end_offset)
 275     *end_offset = d_end_offset;
 276
 277   dbus_message_unref (reply);
 278   return ret;
 279 }
 280
 281 /**
 282  * atspi_text_get_attribute_value: (rename-to atspi_text_get_text_attribute_value)
 283  * @obj: a pointer to the #AtspiText object to query.
 284  * @offset: The character offset at which to query the attribute.
 285  * @attribute_name: The attribute to query.
 286  *
 287  * Gets the value of a named attribute at a given offset.
 288  *
 289  * Returns: (nullable): the value of a given attribute at the given
 290  * offset, or %NULL if not present.
 291  *
 292  * Deprecated: 2.10: Use atspi_text_get_text_attribute_value instead.
 293  **/
 294 gchar *
 295 atspi_text_get_attribute_value (AtspiText *obj,
 296                                 gint offset,
 297                                 gchar *attribute_value,
 298                                 GError **error)
 299 {
 300   return atspi_text_get_text_attribute_value (obj, offset, attribute_value,
 301                                               error);
 302 }
 303
 304 /**
 305  * atspi_text_get_text_attribute_value:
 306  * @obj: a pointer to the #AtspiText object to query.
 307  * @offset: The character offset at which to query the attribute.
 308  * @attribute_name: The attribute to query.
 309  *
 310  * Gets the value of a named attribute at a given offset.
 311  *
 312  * Returns: (nullable): the value of a given attribute at the given offset, or %NULL if
 313  * not present.
 314  **/
 315 gchar *
 316 atspi_text_get_text_attribute_value (AtspiText *obj,
 317                                      gint offset,
 318                                      gchar *attribute_value,
 319                                      GError **error)
 320 {
 321   gchar *retval = NULL;
 322   dbus_int32_t d_i = offset;
 323
 324   g_return_val_if_fail (obj != NULL, NULL);
 325
 326   _atspi_dbus_call (obj, atspi_interface_text, "GetAttributeValue", error, "is=>s", d_i, (const gchar *)attribute_value, &retval);
 327
 328   if (!retval)
 329     retval = g_strdup ("");
 330
 331   return retval;
 332 }
 333
 334 /**
 335  * atspi_text_get_default_attributes:
 336  * @obj: a pointer to the #AtspiText object to query.
 337  *
 338  * Gets the default attributes applied to an #AtspiText
 339  * object. The text attributes correspond to CSS attributes
 340  * where possible. The combination of this attribute set and
 341  * the attributes reported by #atspi_text_get_attributes
 342  * describes the entire set of text attributes over a range.
 343  *
 344  * Returns: (element-type gchar* gchar*) (transfer full): a #GHashTable
 345  *          containing the default attributes applied to a text object,
 346  *          (exclusive of explicitly-set attributes), encoded as UTF-8.
 347  **/
 348 GHashTable *
 349 atspi_text_get_default_attributes (AtspiText *obj, GError **error)
 350 {
 351   DBusMessage *reply;
 352
 353     g_return_val_if_fail (obj != NULL, NULL);
 354
 355   reply = _atspi_dbus_call_partial (obj, atspi_interface_text, "GetDefaultAttributes", error, "");
 356   return _atspi_dbus_return_hash_from_message (reply);
 357 }
 358
 359
 360 /**
 361  * atspi_text_set_caret_offset:
 362  * @obj: a pointer to the #AtspiText object on which to operate.
 363  * @new_offset: the offset to which the text caret is to be moved.
 364  *
 365  * Moves the text caret to a given position.
 366  *
 367  * Returns: #TRUE if successful, #FALSE otherwise.
 368  **/
 369 gboolean
 370 atspi_text_set_caret_offset (AtspiText *obj,
 371                                gint new_offset,
 372                                GError **error)
 373 {
 374   dbus_int32_t d_new_offset = new_offset;
 375   dbus_bool_t retval = FALSE;
 376
 377   g_return_val_if_fail (obj != NULL, FALSE);
 378
 379   _atspi_dbus_call (obj, atspi_interface_text, "SetCaretOffset", error, "i=>b", d_new_offset, &retval);
 380
 381   return retval;
 382 }
 383
 384 /**
 385  * atspi_text_get_text_before_offset:
 386  * @obj: a pointer to the #AtspiText object on which to operate.
 387  * @offset: a #gint indicating the offset from which the delimiter
 388  *        search is based.
 389  * @type: an #AtspiTextBoundaryType indicating whether the desired
 390  *       text string is a word, sentence, line, or attribute run.
 391  *
 392  * Gets delimited text from an #AtspiText object which precedes a given
 393  *          text offset.
 394  *
 395  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 396  *          delimited text, both of whose delimiting boundaries are before the
 397  *          current offset, or an empty string if no such text exists.
 398  **/
 399 AtspiTextRange *
 400 atspi_text_get_text_before_offset (AtspiText *obj,
 401                                     gint offset,
 402                                     AtspiTextBoundaryType type,
 403                                     GError **error)
 404 {
 405   dbus_int32_t d_offset = offset;
 406   dbus_uint32_t d_type = type;
 407   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 408   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 409
 410   range->start_offset = range->end_offset = -1;
 411   if (!obj)
 412     return range;
 413
 414   _atspi_dbus_call (obj, atspi_interface_text, "GetTextBeforeOffset", error,
 415                     "iu=>sii", d_offset, d_type, &range->content,
 416                     &d_start_offset, &d_end_offset);
 417
 418   range->start_offset = d_start_offset;
 419   range->end_offset = d_end_offset;
 420   if (!range->content)
 421     range->content = g_strdup ("");
 422
 423   return range;
 424 }
 425
 426 /**
 427  * atspi_text_get_string_at_offset:
 428  * @obj: an #AtspiText
 429  * @offset: position
 430  * @granularity: An #AtspiTextGranularity
 431  *
 432  * Gets a portion of the text exposed through an #AtspiText according to a given @offset
 433  * and a specific @granularity, along with the start and end offsets defining the
 434  * boundaries of such a portion of text.
 435  *
 436  * If @granularity is ATSPI_TEXT_GRANULARITY_CHAR the character at the
 437  * offset is returned.
 438  *
 439  * If @granularity is ATSPI_TEXT_GRANULARITY_WORD the returned string
 440  * is from the word start at or before the offset to the word start after
 441  * the offset.
 442  *
 443  * The returned string will contain the word at the offset if the offset
 444  * is inside a word and will contain the word before the offset if the
 445  * offset is not inside a word.
 446  *
 447  * If @granularity is ATSPI_TEXT_GRANULARITY_SENTENCE the returned string
 448  * is from the sentence start at or before the offset to the sentence
 449  * start after the offset.
 450  *
 451  * The returned string will contain the sentence at the offset if the offset
 452  * is inside a sentence and will contain the sentence before the offset
 453  * if the offset is not inside a sentence.
 454  *
 455  * If @granularity is ATSPI_TEXT_GRANULARITY_LINE the returned string
 456  * is from the line start at or before the offset to the line
 457  * start after the offset.
 458  *
 459  * If @granularity is ATSPI_TEXT_GRANULARITY_PARAGRAPH the returned string
 460  * is from the start of the paragraph at or before the offset to the start
 461  * of the following paragraph after the offset.
 462  *
 463  * Since: 2.9.90
 464  *
 465  * Returns: a newly allocated string containing the text at the @offset bounded
 466  *   by the specified @granularity. Use g_free() to free the returned string.
 467  *   Returns %NULL if the offset is invalid or no implementation is available.
 468  **/
 469 AtspiTextRange *
 470 atspi_text_get_string_at_offset (AtspiText *obj,
 471                                  gint offset,
 472                                  AtspiTextGranularity granularity,
 473                                  GError **error)
 474 {
 475   dbus_int32_t d_offset = offset;
 476   dbus_uint32_t d_granularity = granularity;
 477   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 478   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 479
 480   range->start_offset = range->end_offset = -1;
 481   if (!obj)
 482     return range;
 483
 484   _atspi_dbus_call (obj, atspi_interface_text, "GetStringAtOffset", error,
 485                     "iu=>sii", d_offset, d_granularity, &range->content,
 486                     &d_start_offset, &d_end_offset);
 487
 488   range->start_offset = d_start_offset;
 489   range->end_offset = d_end_offset;
 490   if (!range->content)
 491     range->content = g_strdup ("");
 492
 493   return range;
 494 }
 495
 496 /**
 497  * atspi_text_get_text_at_offset:
 498  * @obj: a pointer to the #AtspiText object on which to operate.
 499  * @offset: a #gint indicating the offset from which the delimiter
 500  *        search is based.
 501  * @type: an #AtspiTextBoundaryType indicating whether the desired
 502  *       text string is a word, sentence, line, or attribute run.
 503  *
 504  * Gets delimited text from an #AtspiText object which includes a given
 505  *          text offset.
 506  *
 507  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 508  *          delimited text, whose delimiting boundaries bracket the
 509  *          current offset, or an empty string if no such text exists.
 510  *
 511  * Deprecated: 2.10: Use atspi_text_get_string_at_offset.
 512  **/
 513 AtspiTextRange *
 514 atspi_text_get_text_at_offset (AtspiText *obj,
 515                                     gint offset,
 516                                     AtspiTextBoundaryType type,
 517                                     GError **error)
 518 {
 519   dbus_int32_t d_offset = offset;
 520   dbus_uint32_t d_type = type;
 521   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 522   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 523
 524   range->start_offset = range->end_offset = -1;
 525   if (!obj)
 526     return range;
 527
 528   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAtOffset", error,
 529                     "iu=>sii", d_offset, d_type, &range->content,
 530                     &d_start_offset, &d_end_offset);
 531
 532   range->start_offset = d_start_offset;
 533   range->end_offset = d_end_offset;
 534   if (!range->content)
 535     range->content = g_strdup ("");
 536
 537   return range;
 538 }
 539
 540 /**
 541  * atspi_text_get_text_after_offset:
 542  * @obj: a pointer to the #AtspiText object on which to operate.
 543  * @offset: a #gint indicating the offset from which the delimiter
 544  *        search is based.
 545  * @type: an #AtspiTextBoundaryType indicating whether the desired
 546  *       text string is a word, sentence, line, or attribute run.
 547  *
 548  * Gets delimited text from an #AtspiText object which follows a given
 549  *          text offset.
 550  *
 551  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 552  *          delimited text, both of whose delimiting boundaries are after or
 553  *          inclusive of the current offset, or an empty string if no such
 554  *          text exists.
 555  **/
 556 AtspiTextRange *
 557 atspi_text_get_text_after_offset (AtspiText *obj,
 558                                     gint offset,
 559                                     AtspiTextBoundaryType type,
 560                                     GError **error)
 561 {
 562   dbus_int32_t d_offset = offset;
 563   dbus_uint32_t d_type = type;
 564   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 565   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 566
 567   range->start_offset = range->end_offset = -1;
 568   if (!obj)
 569     return range;
 570
 571   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAfterOffset", error,
 572                     "iu=>sii", d_offset, d_type, &range->content,
 573                     &d_start_offset, &d_end_offset);
 574
 575   range->start_offset = d_start_offset;
 576   range->end_offset = d_end_offset;
 577   if (!range->content)
 578     range->content = g_strdup ("");
 579
 580   return range;
 581 }
 582
 583 /**
 584  * atspi_text_get_character_at_offset:
 585  * @obj: a pointer to the #AtspiText object on which to operate.
 586  * @offset: a #gint indicating the text offset where the desired
 587  *          character is located.
 588  *
 589  * Gets the character at a given offset for an #AtspiText object.
 590  *
 591  * Returns: a #guint  representing the
 592  *        UCS-4 unicode code point of the given character, or
 593  *        0xFFFFFFFF if the character in question cannot be represented
 594  *        in the UCS-4 encoding.
 595  **/
 596 guint
 597 atspi_text_get_character_at_offset (AtspiText *obj,
 598                                      gint offset,
 599                                      GError **error)
 600 {
 601   dbus_int32_t d_offset = offset;
 602   dbus_int32_t retval = -1;
 603
 604   g_return_val_if_fail (obj != NULL, -1);
 605
 606   _atspi_dbus_call (obj, atspi_interface_text, "GetCharacterAtOffset", error, "i=>i", d_offset, &retval);
 607
 608   return retval;
 609 }
 610
 611 /**
 612  * atspi_text_get_character_extents:
 613  * @obj: a pointer to the #AtspiText object on which to operate.
 614  * @offset: a #gint indicating the offset of the text character for
 615  *        whom boundary information is requested.
 616  * @type: an #AccessibleCoordType indicating the coordinate system to use
 617  *        for the returned values.
 618  *
 619  * Gets a bounding box containing the glyph representing
 620  *        the character at a particular text offset.
 621  *
 622  * Returns: An #AtspiRect specifying the position and size of the character.
 623  *
 624  **/
 625 AtspiRect *
 626 atspi_text_get_character_extents (AtspiText *obj,
 627                                     gint offset,
 628                                     AtspiCoordType type,
 629                                     GError **error)
 630 {
 631   dbus_int32_t d_offset = 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, "GetCharacterExtents", error, "iu=>iiii", d_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_offset_at_point:
 652  * @obj: a pointer to the #AtspiText object on which to operate.
 653  * @x: the x coordinate of the point to be queried.
 654  * @y: the y coordinate of the point to be queried.
 655  * @type: an #AtspiCoordType indicating the coordinate system in which
 656  *       the values should be returned.
 657  *
 658  * Gets the character offset into the text at a given point.
 659  *
 660  * Returns: the offset (as a #gint) at the point (@x, @y)
 661  *       in the specified coordinate system.
 662  *
 663  **/
 664 gint
 665 atspi_text_get_offset_at_point (AtspiText *obj,
 666                                  gint x,
 667                                  gint y,
 668                                  AtspiCoordType type,
 669                                  GError **error)
 670 {
 671   dbus_int32_t d_x = x, d_y = y;
 672   dbus_uint32_t d_type = type;
 673   dbus_int32_t retval = -1;
 674
 675   g_return_val_if_fail (obj != NULL, -1);
 676
 677   _atspi_dbus_call (obj, atspi_interface_text, "GetOffsetAtPoint", error, "iiu=>i", d_x, d_y, d_type, &retval);
 678
 679   return retval;
 680 }
 681
 682 /**
 683  * atspi_text_get_range_extents:
 684  * @obj: a pointer to the #AtspiText object on which to operate.
 685  * @start_offset: a #gint indicating the offset of the first text character for
 686  *        whom boundary information is requested.
 687  * @end_offset: a #gint indicating the offset of the text character
 688  *        after the last character for whom boundary information is requested.
 689  * @type: an #AtspiCoordType indicating the coordinate system to use
 690  *        for the returned values.
 691  *
 692  * Gets the bounding box for text within a range in an  #AtspiText object.
 693  *
 694  * Returns: An #AtspiRect giving the position and size of the specified range
 695  *          of text.
 696  *
 697  **/
 698 AtspiRect *
 699 atspi_text_get_range_extents (AtspiText *obj,
 700                                 gint start_offset,
 701                                 gint end_offset,
 702                                 AtspiCoordType type,
 703                                 GError **error)
 704 {
 705   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 706   dbus_uint32_t d_type = type;
 707   dbus_int32_t d_x, d_y, d_width, d_height;
 708   AtspiRect ret;
 709
 710   ret.x = ret.y = ret.width = ret.height = -1;
 711
 712   if (obj == NULL)
 713     return atspi_rect_copy (&ret);
 714
 715   _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);
 716
 717   ret.x = d_x;
 718   ret.y = d_y;
 719   ret.width = d_width;
 720   ret.height = d_height;
 721   return atspi_rect_copy (&ret);
 722 }
 723
 724 /**
 725  * atspi_text_get_bounded_ranges:
 726  * @obj: a pointer to the #AtspiText object on which to operate.
 727  * @x: the 'starting' x coordinate of the bounding box.
 728  * @y: the 'starting' y coordinate of the bounding box.
 729  * @width: the x extent of the bounding box.
 730  * @height: the y extent of the bounding box.
 731  * @type: an #AccessibleCoordType indicating the coordinate system to use
 732  *        for the returned values.
 733  * @clipTypeX: an #AtspiTextClipType indicating how to treat characters that
 734  *        intersect the bounding box's x extents.
 735  * @clipTypeY: an #AtspiTextClipType indicating how to treat characters that
 736  *        intersect the bounding box's y extents.
 737  *
 738  * Gets the ranges of text from an #AtspiText object which lie within the
 739  *          bounds defined by (@x, @y) and (@x+@width, @y+@height).
 740  *
 741  * Returns: (transfer full) (element-type AtspiTextRange*): a null-terminated list of
 742  *          pointers to #AtspiTextRange structs detailing the bounded text.
 743  **/
 744 GArray *
 745 atspi_text_get_bounded_ranges (AtspiText *obj,
 746                                  gint x,
 747                                  gint y,
 748                                  gint width,
 749                                  gint height,
 750                                  AtspiCoordType type,
 751                                  AtspiTextClipType clipTypeX,
 752                                  AtspiTextClipType clipTypeY,
 753                                  GError **error)
 754 {
 755   dbus_int32_t d_x = x, d_y = y, d_width = width, d_height = height;
 756   dbus_uint32_t d_type = type;
 757   dbus_uint32_t d_clipTypeX = clipTypeX, d_clipTypeY = clipTypeY;
 758   GArray *range_seq = NULL;
 759
 760   g_return_val_if_fail (obj != NULL, NULL);
 761
 762   _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);
 763
 764   return range_seq;
 765 }
 766
 767 /**
 768  * atspi_text_get_n_selections:
 769  * @obj: a pointer to the #AtspiText object on which to operate.
 770  *
 771  * Gets the number of active non-contiguous selections for an
 772  *          #AtspiText object.
 773  *
 774  * Returns: a #gint indicating the current
 775  *          number of non-contiguous text selections active
 776  *          within an #AtspiText object.
 777  **/
 778 gint
 779 atspi_text_get_n_selections (AtspiText *obj, GError **error)
 780 {
 781   dbus_int32_t retval = 0;
 782
 783   g_return_val_if_fail (obj != NULL, -1);
 784
 785   _atspi_dbus_call (obj, atspi_interface_text, "GetNSelections", error, "=>i", &retval);
 786
 787   return retval;
 788 }
 789
 790 /**
 791  * atspi_text_get_selection:
 792  * @obj: a pointer to the #AtspiText object on which to operate.
 793  * @selection_num: a #gint indicating which selection to query.
 794  *
 795  * Gets the bounds of the @selection_num-th active text selection for an
 796  *         #AtspiText object.
 797  **/
 798 AtspiRange *
 799 atspi_text_get_selection (AtspiText *obj,
 800                              gint selection_num,
 801                              GError **error)
 802 {
 803   dbus_int32_t d_selection_num = selection_num;
 804   dbus_int32_t d_start_offset, d_end_offset;
 805   AtspiRange *ret = g_new (AtspiRange, 1);
 806
 807   ret->start_offset = ret->end_offset = -1;
 808
 809   if (!obj)
 810     return ret;
 811
 812   _atspi_dbus_call (obj, atspi_interface_text, "GetSelection", error, "i=>ii", d_selection_num, &d_start_offset, &d_end_offset);
 813
 814   ret->start_offset = d_start_offset;
 815   ret->end_offset = d_end_offset;
 816   return ret;
 817 }
 818
 819 /**
 820  * atspi_text_add_selection:
 821  * @obj: a pointer to the #AtspiText object on which to operate.
 822  * @start_offset: the starting offset of the desired new selection.
 823  * @end_offset: the offset of the first character after the new selection.
 824  *
 825  * Selects some text (adds a text selection) in an #AtspiText object.
 826  *
 827  * Returns: #TRUE if successful, #FALSE otherwise.
 828  **/
 829 gboolean
 830 atspi_text_add_selection (AtspiText *obj,
 831                              gint start_offset, gint end_offset,
 832                              GError **error)
 833 {
 834   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 835   dbus_bool_t retval = FALSE;
 836
 837   _atspi_dbus_call (obj, atspi_interface_text, "AddSelection", error, "ii=>b", d_start_offset, d_end_offset, &retval);
 838
 839   return retval;
 840 }
 841
 842 /**
 843  * atspi_text_remove_selection:
 844  * @obj: a pointer to the #AtspiText object on which to operate.
 845  * @selection_num: a #gint indicating which text selection to remove.
 846  *
 847  * De-selects a text selection.
 848  *
 849  * Returns: #TRUE if successful, #FALSE otherwise.
 850  **/
 851 gboolean
 852 atspi_text_remove_selection (AtspiText *obj,
 853                                 gint selection_num,
 854                                 GError **error)
 855 {
 856   dbus_int32_t d_selection_num = selection_num;
 857   dbus_bool_t retval = FALSE;
 858
 859   g_return_val_if_fail (obj != NULL, FALSE);
 860
 861   _atspi_dbus_call (obj, atspi_interface_text, "RemoveSelection", error, "i=>b", d_selection_num, &retval);
 862
 863   return retval;
 864 }
 865
 866 /**
 867  * atspi_text_set_selection:
 868  * @obj: a pointer to the #AtspiText object on which to operate.
 869  * @selection_num: a zero-offset index indicating which text selection to modify.
 870  * @start_offset: a #gint indicating the new starting offset for the selection.
 871  * @end_offset: a #gint indicating the desired new offset of the first character
 872  *             after the selection.
 873  *
 874  * Changes the bounds of an existing #AtspiText text selection.
 875  *
 876  * Returns: #TRUE if successful, #FALSE otherwise.
 877  **/
 878 gboolean
 879 atspi_text_set_selection (AtspiText *obj,
 880                              gint selection_num,
 881                              gint start_offset,
 882                              gint end_offset,
 883                              GError **error)
 884 {
 885   dbus_int32_t d_selection_num = selection_num, d_start_offset = start_offset, d_end_offset = end_offset;
 886   dbus_bool_t retval = FALSE;
 887
 888   g_return_val_if_fail (obj != NULL, FALSE);
 889
 890   _atspi_dbus_call (obj, atspi_interface_text, "SetSelection", error, "iii=>b", d_selection_num, d_start_offset, d_end_offset, &retval);
 891
 892   return retval;
 893 }
 894
 895 static void
 896 atspi_text_base_init (AtspiText *klass)
 897 {
 898 }
 899
 900 GType
 901 atspi_text_get_type (void)
 902 {
 903   static GType type = 0;
 904
 905   if (!type) {
 906     static const GTypeInfo tinfo =
 907     {
 908       sizeof (AtspiText),
 909       (GBaseInitFunc) atspi_text_base_init,
 910       (GBaseFinalizeFunc) NULL,
 911     };
 912
 913     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiText", &tinfo, 0);
 914
 915   }
 916   return type;
 917 }