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_string_at_offset:
 426  * @text: an #AtspiText
 427  * @offset: position
 428  * @granularity: An #AtspiTextGranularity
 429  * @start_offset: (out): the start offset of the returned string, or -1
 430  *                if an error has occurred (e.g. invalid offset, not implemented)
 431  * @end_offset: (out): the offset of the first character after the returned string,
 432  *              or -1 if an error has occurred (e.g. invalid offset, not implemented)
 433  *
 434  * Gets a portion of the text exposed through an #AtspiText according to a given @offset
 435  * and a specific @granularity, along with the start and end offsets defining the
 436  * boundaries of such a portion of text.
 437  *
 438  * If @granularity is ATSPI_TEXT_GRANULARITY_CHAR the character at the
 439  * offset is returned.
 440  *
 441  * If @granularity is ATSPI_TEXT_GRANULARITY_WORD the returned string
 442  * is from the word start at or before the offset to the word start after
 443  * the offset.
 444  *
 445  * The returned string will contain the word at the offset if the offset
 446  * is inside a word and will contain the word before the offset if the
 447  * offset is not inside a word.
 448  *
 449  * If @granularity is ATSPI_TEXT_GRANULARITY_SENTENCE the returned string
 450  * is from the sentence start at or before the offset to the sentence
 451  * start after the offset.
 452  *
 453  * The returned string will contain the sentence at the offset if the offset
 454  * is inside a sentence and will contain the sentence before the offset
 455  * if the offset is not inside a sentence.
 456  *
 457  * If @granularity is ATSPI_TEXT_GRANULARITY_LINE the returned string
 458  * is from the line start at or before the offset to the line
 459  * start after the offset.
 460  *
 461  * If @granularity is ATSPI_TEXT_GRANULARITY_PARAGRAPH the returned string
 462  * is from the start of the paragraph at or before the offset to the start
 463  * of the following paragraph after the offset.
 464  *
 465  * Since: 2.9.90
 466  *
 467  * Returns: a newly allocated string containing the text at the @offset bounded
 468  *   by the specified @granularity. Use g_free() to free the returned string.
 469  *   Returns %NULL if the offset is invalid or no implementation is available.
 470  **/
 471 AtspiTextRange *
 472 atspi_text_get_string_at_offset (AtspiText *obj,
 473                                  gint offset,
 474                                  AtspiTextGranularity granularity,
 475                                  GError **error)
 476 {
 477   dbus_int32_t d_offset = offset;
 478   dbus_uint32_t d_granularity = granularity;
 479   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 480   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 481
 482   range->start_offset = range->end_offset = -1;
 483   if (!obj)
 484     return range;
 485
 486   _atspi_dbus_call (obj, atspi_interface_text, "GetStringAtOffset", error,
 487                     "iu=>sii", d_offset, d_granularity, &range->content,
 488                     &d_start_offset, &d_end_offset);
 489
 490   range->start_offset = d_start_offset;
 491   range->end_offset = d_end_offset;
 492   if (!range->content)
 493     range->content = g_strdup ("");
 494
 495   return range;
 496 }
 497
 498 /**
 499  * atspi_text_get_text_at_offset:
 500  * @obj: a pointer to the #AtspiText object on which to operate.
 501  * @offset: a #gint indicating the offset from which the delimiter
 502  *        search is based.
 503  * @type: an #AtspiTextBoundaryType indicating whether the desired
 504  *       text string is a word, sentence, line, or attribute run.
 505  *
 506  * Gets delimited text from an #AtspiText object which includes a given
 507  *          text offset.
 508  *
 509  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 510  *          delimited text, whose delimiting boundaries bracket the
 511  *          current offset, or an empty string if no such text exists.
 512  *
 513  * Deprecated: 2.10: Use atspi_text_get_string_at_offset.
 514  **/
 515 AtspiTextRange *
 516 atspi_text_get_text_at_offset (AtspiText *obj,
 517                                     gint offset,
 518                                     AtspiTextBoundaryType type,
 519                                     GError **error)
 520 {
 521   dbus_int32_t d_offset = offset;
 522   dbus_uint32_t d_type = type;
 523   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 524   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 525
 526   range->start_offset = range->end_offset = -1;
 527   if (!obj)
 528     return range;
 529
 530   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAtOffset", error,
 531                     "iu=>sii", d_offset, d_type, &range->content,
 532                     &d_start_offset, &d_end_offset);
 533
 534   range->start_offset = d_start_offset;
 535   range->end_offset = d_end_offset;
 536   if (!range->content)
 537     range->content = g_strdup ("");
 538
 539   return range;
 540 }
 541
 542 /**
 543  * atspi_text_get_text_after_offset:
 544  * @obj: a pointer to the #AtspiText object on which to operate.
 545  * @offset: a #gint indicating the offset from which the delimiter
 546  *        search is based.
 547  * @type: an #AtspiTextBoundaryType indicating whether the desired
 548  *       text string is a word, sentence, line, or attribute run.
 549  *
 550  * Gets delimited text from an #AtspiText object which follows a given
 551  *          text offset.
 552  *
 553  * Returns: an #AtspiTextRange containing a UTF-8 string representing the
 554  *          delimited text, both of whose delimiting boundaries are after or
 555  *          inclusive of the current offset, or an empty string if no such
 556  *          text exists.
 557  **/
 558 AtspiTextRange *
 559 atspi_text_get_text_after_offset (AtspiText *obj,
 560                                     gint offset,
 561                                     AtspiTextBoundaryType type,
 562                                     GError **error)
 563 {
 564   dbus_int32_t d_offset = offset;
 565   dbus_uint32_t d_type = type;
 566   dbus_int32_t d_start_offset = -1, d_end_offset = -1;
 567   AtspiTextRange *range = g_new0 (AtspiTextRange, 1);
 568
 569   range->start_offset = range->end_offset = -1;
 570   if (!obj)
 571     return range;
 572
 573   _atspi_dbus_call (obj, atspi_interface_text, "GetTextAfterOffset", error,
 574                     "iu=>sii", d_offset, d_type, &range->content,
 575                     &d_start_offset, &d_end_offset);
 576
 577   range->start_offset = d_start_offset;
 578   range->end_offset = d_end_offset;
 579   if (!range->content)
 580     range->content = g_strdup ("");
 581
 582   return range;
 583 }
 584
 585 /**
 586  * atspi_text_get_character_at_offset:
 587  * @obj: a pointer to the #AtspiText object on which to operate.
 588  * @offset: a #gint indicating the text offset where the desired
 589  *          character is located.
 590  *
 591  * Gets the character at a given offset for an #AtspiText object.
 592  *
 593  * Returns: a #guint  representing the
 594  *        UCS-4 unicode code point of the given character, or
 595  *        0xFFFFFFFF if the character in question cannot be represented
 596  *        in the UCS-4 encoding.
 597  **/
 598 guint
 599 atspi_text_get_character_at_offset (AtspiText *obj,
 600                                      gint offset,
 601                                      GError **error)
 602 {
 603   dbus_int32_t d_offset = offset;
 604   dbus_int32_t retval = -1;
 605
 606   g_return_val_if_fail (obj != NULL, -1);
 607
 608   _atspi_dbus_call (obj, atspi_interface_text, "GetCharacterAtOffset", error, "i=>i", d_offset, &retval);
 609
 610   return retval;
 611 }
 612
 613 /**
 614  * atspi_text_get_character_extents:
 615  * @obj: a pointer to the #AtspiText object on which to operate.
 616  * @offset: a #gint indicating the offset of the text character for
 617  *        whom boundary information is requested.
 618  * @type: an #AccessibleCoordType indicating the coordinate system to use
 619  *        for the returned values.
 620  *
 621  * Gets a bounding box containing the glyph representing
 622  *        the character at a particular text offset.
 623  *
 624  * Returns: An #AtspiRect specifying the position and size of the character.
 625  *
 626  **/
 627 AtspiRect *
 628 atspi_text_get_character_extents (AtspiText *obj,
 629                                     gint offset,
 630                                     AtspiCoordType type,
 631                                     GError **error)
 632 {
 633   dbus_int32_t d_offset = offset;
 634   dbus_uint32_t d_type = type;
 635   dbus_int32_t d_x, d_y, d_width, d_height;
 636   AtspiRect ret;
 637
 638   ret.x = ret.y = ret.width = ret.height = -1;
 639
 640   if (obj == NULL)
 641     return atspi_rect_copy (&ret);
 642
 643   _atspi_dbus_call (obj, atspi_interface_text, "GetCharacterExtents", error, "iu=>iiii", d_offset, d_type, &d_x, &d_y, &d_width, &d_height);
 644
 645   ret.x = d_x;
 646   ret.y = d_y;
 647   ret.width = d_width;
 648   ret.height = d_height;
 649   return atspi_rect_copy (&ret);
 650 }
 651
 652 /**
 653  * atspi_text_get_offset_at_point:
 654  * @obj: a pointer to the #AtspiText object on which to operate.
 655  * @x: the x coordinate of the point to be queried.
 656  * @y: the y coordinate of the point to be queried.
 657  * @type: an #AtspiCoordType indicating the coordinate system in which
 658  *       the values should be returned.
 659  *
 660  * Gets the character offset into the text at a given point.
 661  *
 662  * Returns: the offset (as a #gint) at the point (@x, @y)
 663  *       in the specified coordinate system.
 664  *
 665  **/
 666 gint
 667 atspi_text_get_offset_at_point (AtspiText *obj,
 668                                  gint x,
 669                                  gint y,
 670                                  AtspiCoordType type,
 671                                  GError **error)
 672 {
 673   dbus_int32_t d_x = x, d_y = y;
 674   dbus_uint32_t d_type = type;
 675   dbus_int32_t retval = -1;
 676
 677   g_return_val_if_fail (obj != NULL, -1);
 678
 679   _atspi_dbus_call (obj, atspi_interface_text, "GetOffsetAtPoint", error, "iiu=>i", d_x, d_y, d_type, &retval);
 680
 681   return retval;
 682 }
 683
 684 /**
 685  * atspi_text_get_range_extents:
 686  * @obj: a pointer to the #AtspiText object on which to operate.
 687  * @start_offset: a #gint indicating the offset of the first text character for
 688  *        whom boundary information is requested.
 689  * @end_offset: a #gint indicating the offset of the text character
 690  *        after the last character for whom boundary information is requested.
 691  * @type: an #AtspiCoordType indicating the coordinate system to use
 692  *        for the returned values.
 693  *
 694  * Gets the bounding box for text within a range in an  #AtspiText object.
 695  *
 696  * Returns: An #AtspiRect giving the position and size of the specified range
 697  *          of text.
 698  *
 699  **/
 700 AtspiRect *
 701 atspi_text_get_range_extents (AtspiText *obj,
 702                                 gint start_offset,
 703                                 gint end_offset,
 704                                 AtspiCoordType type,
 705                                 GError **error)
 706 {
 707   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 708   dbus_uint32_t d_type = type;
 709   dbus_int32_t d_x, d_y, d_width, d_height;
 710   AtspiRect ret;
 711
 712   ret.x = ret.y = ret.width = ret.height = -1;
 713
 714   if (obj == NULL)
 715     return atspi_rect_copy (&ret);
 716
 717   _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);
 718
 719   ret.x = d_x;
 720   ret.y = d_y;
 721   ret.width = d_width;
 722   ret.height = d_height;
 723   return atspi_rect_copy (&ret);
 724 }
 725
 726 /**
 727  * atspi_text_get_bounded_ranges:
 728  * @obj: a pointer to the #AtspiText object on which to operate.
 729  * @x: the 'starting' x coordinate of the bounding box.
 730  * @y: the 'starting' y coordinate of the bounding box.
 731  * @width: the x extent of the bounding box.
 732  * @height: the y extent of the bounding box.
 733  * @type: an #AccessibleCoordType indicating the coordinate system to use
 734  *        for the returned values.
 735  * @clipTypeX: an #AtspiTextClipType indicating how to treat characters that
 736  *        intersect the bounding box's x extents.
 737  * @clipTypeY: an #AtspiTextClipType indicating how to treat characters that
 738  *        intersect the bounding box's y extents.
 739  *
 740  * Gets the ranges of text from an #AtspiText object which lie within the
 741  *          bounds defined by (@x, @y) and (@x+@width, @y+@height).
 742  *
 743  * Returns: (transfer full) (element-type AtspiTextRange*): a null-terminated list of
 744  *          pointers to #AtspiTextRange structs detailing the bounded text.
 745  **/
 746 GArray *
 747 atspi_text_get_bounded_ranges (AtspiText *obj,
 748                                  gint x,
 749                                  gint y,
 750                                  gint width,
 751                                  gint height,
 752                                  AtspiCoordType type,
 753                                  AtspiTextClipType clipTypeX,
 754                                  AtspiTextClipType clipTypeY,
 755                                  GError **error)
 756 {
 757   dbus_int32_t d_x = x, d_y = y, d_width = width, d_height = height;
 758   dbus_uint32_t d_type = type;
 759   dbus_uint32_t d_clipTypeX = clipTypeX, d_clipTypeY = clipTypeY;
 760   GArray *range_seq;
 761
 762   g_return_val_if_fail (obj != NULL, NULL);
 763
 764   _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);
 765
 766   return range_seq;
 767 }
 768
 769 /**
 770  * atspi_text_get_n_selections:
 771  * @obj: a pointer to the #AtspiText object on which to operate.
 772  *
 773  * Gets the number of active non-contiguous selections for an
 774  *          #AtspiText object.
 775  *
 776  * Returns: a #gint indicating the current
 777  *          number of non-contiguous text selections active
 778  *          within an #AtspiText object.
 779  **/
 780 gint
 781 atspi_text_get_n_selections (AtspiText *obj, GError **error)
 782 {
 783   dbus_int32_t retval = 0;
 784
 785   g_return_val_if_fail (obj != NULL, -1);
 786
 787   _atspi_dbus_call (obj, atspi_interface_text, "GetNSelections", error, "=>i", &retval);
 788
 789   return retval;
 790 }
 791
 792 /**
 793  * atspi_text_get_selection:
 794  * @obj: a pointer to the #AtspiText object on which to operate.
 795  * @selection_num: a #gint indicating which selection to query.
 796  *
 797  * Gets the bounds of the @selection_num-th active text selection for an
 798  *         #AtspiText object.
 799  **/
 800 AtspiRange *
 801 atspi_text_get_selection (AtspiText *obj,
 802                              gint selection_num,
 803                              GError **error)
 804 {
 805   dbus_int32_t d_selection_num = selection_num;
 806   dbus_int32_t d_start_offset, d_end_offset;
 807   AtspiRange *ret = g_new (AtspiRange, 1);
 808
 809   ret->start_offset = ret->end_offset = -1;
 810
 811   if (!obj)
 812     return ret;
 813
 814   _atspi_dbus_call (obj, atspi_interface_text, "GetSelection", error, "i=>ii", d_selection_num, &d_start_offset, &d_end_offset);
 815
 816   ret->start_offset = d_start_offset;
 817   ret->end_offset = d_end_offset;
 818   return ret;
 819 }
 820
 821 /**
 822  * atspi_text_add_selection:
 823  * @obj: a pointer to the #AtspiText object on which to operate.
 824  * @start_offset: the starting offset of the desired new selection.
 825  * @end_offset: the offset of the first character after the new selection.
 826  *
 827  * Selects some text (adds a text selection) in an #AtspiText object.
 828  *
 829  * Returns: #TRUE if successful, #FALSE otherwise.
 830  **/
 831 gboolean
 832 atspi_text_add_selection (AtspiText *obj,
 833                              gint start_offset, gint end_offset,
 834                              GError **error)
 835 {
 836   dbus_int32_t d_start_offset = start_offset, d_end_offset = end_offset;
 837   dbus_bool_t retval = FALSE;
 838
 839   _atspi_dbus_call (obj, atspi_interface_text, "AddSelection", error, "ii=>b", d_start_offset, d_end_offset, &retval);
 840
 841   return retval;
 842 }
 843
 844 /**
 845  * atspi_text_remove_selection:
 846  * @obj: a pointer to the #AtspiText object on which to operate.
 847  * @selection_num: a #gint indicating which text selection to remove.
 848  *
 849  * De-selects a text selection.
 850  *
 851  * Returns: #TRUE if successful, #FALSE otherwise.
 852  **/
 853 gboolean
 854 atspi_text_remove_selection (AtspiText *obj,
 855                                 gint selection_num,
 856                                 GError **error)
 857 {
 858   dbus_int32_t d_selection_num = selection_num;
 859   dbus_bool_t retval = FALSE;
 860
 861   g_return_val_if_fail (obj != NULL, FALSE);
 862
 863   _atspi_dbus_call (obj, atspi_interface_text, "RemoveSelection", error, "i=>b", d_selection_num, &retval);
 864
 865   return retval;
 866 }
 867
 868 /**
 869  * atspi_text_set_selection:
 870  * @obj: a pointer to the #AtspiText object on which to operate.
 871  * @selection_num: a zero-offset index indicating which text selection to modify.
 872  * @start_offset: a #gint indicating the new starting offset for the selection.
 873  * @end_offset: a #gint indicating the desired new offset of the first character
 874  *             after the selection.
 875  *
 876  * Changes the bounds of an existing #AtspiText text selection.
 877  *
 878  * Returns: #TRUE if successful, #FALSE otherwise.
 879  **/
 880 gboolean
 881 atspi_text_set_selection (AtspiText *obj,
 882                              gint selection_num,
 883                              gint start_offset,
 884                              gint end_offset,
 885                              GError **error)
 886 {
 887   dbus_int32_t d_selection_num = selection_num, d_start_offset = start_offset, d_end_offset = end_offset;
 888   dbus_bool_t retval = FALSE;
 889
 890   g_return_val_if_fail (obj != NULL, FALSE);
 891
 892   _atspi_dbus_call (obj, atspi_interface_text, "SetSelection", error, "iii=>b", d_selection_num, d_start_offset, d_end_offset, &retval);
 893
 894   return retval;
 895 }
 896
 897 static void
 898 atspi_text_base_init (AtspiText *klass)
 899 {
 900 }
 901
 902 GType
 903 atspi_text_get_type (void)
 904 {
 905   static GType type = 0;
 906
 907   if (!type) {
 908     static const GTypeInfo tinfo =
 909     {
 910       sizeof (AtspiText),
 911       (GBaseInitFunc) atspi_text_base_init,
 912       (GBaseFinalizeFunc) NULL,
 913     };
 914
 915     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiText", &tinfo, 0);
 916
 917   }
 918   return type;
 919 }