libspi/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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* text.c : implements the Text interface */
  25
  26 #include <config.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <atk/atktext.h>
  31 #include <libspi/text.h>
  32 #include <libspi/spi-private.h>
  33
  34 /* Our parent Gtk object type */
  35 #define PARENT_TYPE SPI_TYPE_BASE
  36
  37 typedef struct {
  38   gint x;
  39   gint y;
  40   gint w;
  41   gint h;
  42 } SpiTextRect;
  43
  44 static SpiTextRect *
  45 _spi_text_rect_union (SpiTextRect *aggregate, SpiTextRect *subrect)
  46 {
  47   if (subrect != NULL)
  48     {
  49       /* 'normalize' subrect */
  50       if (subrect->w < 0)
  51         {
  52           subrect->x += subrect->w;
  53           subrect->w *= -1;
  54         }
  55       if (subrect->h < 0)
  56         {
  57           subrect->y += subrect->h;
  58           subrect->h *= -1;
  59         }
  60       if (aggregate == NULL)
  61         {
  62           aggregate = g_new (SpiTextRect, 1);
  63           memcpy (aggregate, subrect, sizeof (SpiTextRect));
  64         }
  65       else
  66         {
  67           gint ax2 = aggregate->x + aggregate->w;
  68           gint ay2 = aggregate->y + aggregate->h;
  69           gint sx2 = subrect->x + subrect->w;
  70           gint sy2 = subrect->y + subrect->h;
  71           if (subrect->x < aggregate->x)
  72             {
  73               aggregate->w += (aggregate->x - subrect->x);
  74               aggregate->x = subrect->x;
  75             }
  76           if (sx2 > ax2)
  77             {
  78               aggregate->w += (sx2 - ax2);
  79             }
  80           if (subrect->y < aggregate->y)
  81             {
  82               aggregate->h += (aggregate->y - subrect->y);
  83               aggregate->y = subrect->y;
  84             }
  85           if (sy2 > ay2)
  86             {
  87               aggregate->h += (sy2 - ay2);
  88             }
  89         }
  90     }
  91   return aggregate;
  92 }
  93
  94 static AtkText *
  95 get_text_from_servant (PortableServer_Servant servant)
  96 {
  97   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
  98
  99   g_return_val_if_fail (object, NULL);
 100   g_return_val_if_fail (ATK_IS_OBJECT(object->gobj), NULL);
 101   return ATK_TEXT (object->gobj);
 102 }
 103
 104 static CORBA_string
 105 impl_getText (PortableServer_Servant servant,
 106               const CORBA_long       startOffset,
 107               const CORBA_long       endOffset,
 108               CORBA_Environment     *ev)
 109 {
 110   gchar *txt;
 111   CORBA_string rv;
 112   AtkText *text = get_text_from_servant (servant);
 113
 114   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 115
 116   txt = atk_text_get_text (text, startOffset, endOffset);
 117   if (txt)
 118     {
 119       rv = CORBA_string_dup (txt);
 120       g_free (txt);
 121     }
 122   else
 123     rv = CORBA_string_dup ("");
 124
 125   return rv;
 126 }
 127
 128
 129 CORBA_string
 130 impl_getTextAfterOffset (PortableServer_Servant servant,
 131                          const CORBA_long offset,
 132                          const
 133                          Accessibility_TEXT_BOUNDARY_TYPE
 134                          type, CORBA_long * startOffset,
 135                          CORBA_long * endOffset,
 136                          CORBA_Environment *ev)
 137 {
 138   gchar *txt;
 139   CORBA_char *rv;
 140   gint intStartOffset, intEndOffset;
 141   AtkText *text = get_text_from_servant (servant);
 142
 143   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 144
 145   txt = atk_text_get_text_after_offset (text,
 146                                         offset, (AtkTextBoundary) type,
 147                                         &intStartOffset, &intEndOffset);
 148   *startOffset = intStartOffset;
 149   *endOffset = intEndOffset;
 150
 151   if (txt)
 152     {
 153       rv = CORBA_string_dup (txt);
 154       g_free (txt);
 155     }
 156   else
 157     rv = CORBA_string_dup ("");
 158
 159   return rv;
 160 }
 161
 162
 163 static CORBA_string
 164 impl_getTextAtOffset (PortableServer_Servant servant,
 165                       const CORBA_long offset,
 166                       const Accessibility_TEXT_BOUNDARY_TYPE type,
 167                       CORBA_long * startOffset,
 168                       CORBA_long * endOffset,
 169                       CORBA_Environment *ev)
 170 {
 171   gchar *txt;
 172   CORBA_char *rv;
 173   gint intStartOffset, intEndOffset;
 174   AtkText *text = get_text_from_servant (servant);
 175
 176   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 177
 178   txt = atk_text_get_text_at_offset (
 179           text,
 180           offset, (AtkTextBoundary) type,
 181           &intStartOffset, &intEndOffset);
 182
 183   *startOffset = intStartOffset;
 184   *endOffset = intEndOffset;
 185
 186   if (txt)
 187     {
 188       rv = CORBA_string_dup (txt);
 189       g_free (txt);
 190     }
 191   else
 192     rv = CORBA_string_dup ("");
 193
 194   return rv;
 195 }
 196
 197
 198 static CORBA_unsigned_long
 199 impl_getCharacterAtOffset (PortableServer_Servant servant,
 200                            const CORBA_long offset,
 201                            CORBA_Environment *ev)
 202 {
 203   AtkText *text = get_text_from_servant (servant);
 204
 205   g_return_val_if_fail (text != NULL, 0);
 206
 207   return atk_text_get_character_at_offset (text, offset);
 208 }
 209
 210
 211 static CORBA_string
 212 impl_getTextBeforeOffset (PortableServer_Servant servant,
 213                           const CORBA_long offset,
 214                           const
 215                           Accessibility_TEXT_BOUNDARY_TYPE
 216                           type, CORBA_long * startOffset,
 217                           CORBA_long * endOffset,
 218                           CORBA_Environment *ev)
 219 {
 220   gchar *txt;
 221   CORBA_char *rv;
 222   gint intStartOffset, intEndOffset;
 223   AtkText *text = get_text_from_servant (servant);
 224
 225   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 226
 227   txt = atk_text_get_text_before_offset (text,
 228                                          offset, (AtkTextBoundary) type,
 229                                          &intStartOffset, &intEndOffset);
 230
 231   *startOffset = intStartOffset;
 232   *endOffset = intEndOffset;
 233
 234   if (txt)
 235     {
 236       rv = CORBA_string_dup (txt);
 237       g_free (txt);
 238     }
 239   else
 240     rv = CORBA_string_dup ("");
 241
 242   return rv;
 243 }
 244
 245
 246 static CORBA_long
 247 impl__get_caretOffset (PortableServer_Servant servant,
 248                      CORBA_Environment *ev)
 249 {
 250   AtkText *text = get_text_from_servant (servant);
 251
 252   g_return_val_if_fail (text != NULL, -1);
 253
 254   return atk_text_get_caret_offset (text);
 255 }
 256
 257
 258 static CORBA_char *
 259 _string_from_attribute_set (AtkAttributeSet *set)
 260 {
 261   gchar *attributes, *tmp, *tmp2;
 262   CORBA_char *rv;
 263   GSList *cur_attr;
 264   AtkAttribute *at;
 265
 266   attributes = g_strdup ("");
 267   cur_attr = (GSList *) set;
 268   while (cur_attr)
 269     {
 270       at = (AtkAttribute *) cur_attr->data;
 271       tmp = g_strdup_printf ("%s%s:%s%s",
 272                              ((GSList *)(set) == cur_attr) ? "" : " ",
 273                              at->name, at->value,
 274                              (cur_attr->next) ? ";" : "");
 275       tmp2 = g_strconcat (attributes, tmp, NULL);
 276       g_free (tmp);
 277       g_free (attributes);
 278       attributes = tmp2;
 279       cur_attr = cur_attr->next;
 280     }
 281   rv = CORBA_string_dup (attributes);
 282   g_free (attributes);
 283   return rv;
 284 }
 285
 286
 287
 288 static CORBA_string
 289 impl_getAttributes (PortableServer_Servant servant,
 290                     const CORBA_long offset,
 291                     CORBA_long * startOffset,
 292                     CORBA_long * endOffset,
 293                     CORBA_Environment *ev)
 294 {
 295   AtkAttributeSet *set;
 296   gint intstart_offset, intend_offset;
 297   CORBA_char *rv;
 298   AtkText *text = get_text_from_servant (servant);
 299
 300   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 301
 302   set = atk_text_get_run_attributes (text, offset,
 303                                      &intstart_offset, &intend_offset);
 304   *startOffset = intstart_offset;
 305   *endOffset = intend_offset;
 306   rv = _string_from_attribute_set (set);
 307   atk_attribute_set_free (set);
 308   return rv;
 309 }
 310
 311
 312 static void
 313 impl_getCharacterExtents (PortableServer_Servant servant,
 314                           const CORBA_long offset, CORBA_long * x,
 315                           CORBA_long * y, CORBA_long * width,
 316                           CORBA_long * height,
 317                           const CORBA_short coordType,
 318                           CORBA_Environment *ev)
 319 {
 320   AtkText *text = get_text_from_servant (servant);
 321   gint ix, iy, iw, ih;
 322
 323   g_return_if_fail (text != NULL);
 324
 325   atk_text_get_character_extents (
 326           text, offset,
 327           &ix, &iy, &iw, &ih,
 328           (AtkCoordType) coordType);
 329   *x = ix;
 330   *y = iy;
 331   *width = iw;
 332   *height = ih;
 333 }
 334
 335
 336 static CORBA_long
 337 impl__get_characterCount (PortableServer_Servant servant,
 338                           CORBA_Environment    *ev)
 339 {
 340   AtkText *text = get_text_from_servant (servant);
 341
 342   g_return_val_if_fail (text != NULL, 0);
 343
 344   return atk_text_get_character_count (text);
 345 }
 346
 347
 348 static CORBA_long
 349 impl_getOffsetAtPoint (PortableServer_Servant servant,
 350                        const CORBA_long x, const CORBA_long y,
 351                        const CORBA_short coordType,
 352                        CORBA_Environment *ev)
 353 {
 354   AtkText *text = get_text_from_servant (servant);
 355
 356   g_return_val_if_fail (text != NULL, -1);
 357
 358   return atk_text_get_offset_at_point (text,
 359                                   x, y,
 360                                   (AtkCoordType) coordType);
 361 }
 362
 363
 364 static CORBA_long
 365 impl_getNSelections (PortableServer_Servant servant,
 366                      CORBA_Environment *ev)
 367 {
 368   AtkText *text = get_text_from_servant (servant);
 369
 370   g_return_val_if_fail (text != NULL, 0);
 371
 372   return atk_text_get_n_selections (text);
 373 }
 374
 375
 376 static void
 377 impl_getSelection (PortableServer_Servant servant,
 378                    const CORBA_long selectionNum,
 379                    CORBA_long * startOffset, CORBA_long * endOffset,
 380                    CORBA_Environment *ev)
 381 {
 382   AtkText *text = get_text_from_servant (servant);
 383   gint intStartOffset, intEndOffset;
 384
 385   g_return_if_fail (text != NULL);
 386
 387   /* atk_text_get_selection returns gchar* which we discard */
 388   g_free (atk_text_get_selection (text, selectionNum,
 389                                   &intStartOffset, &intEndOffset));
 390
 391   *startOffset = intStartOffset;
 392   *endOffset = intEndOffset;
 393 }
 394
 395
 396 static CORBA_boolean
 397 impl_addSelection (PortableServer_Servant servant,
 398                    const CORBA_long startOffset,
 399                    const CORBA_long endOffset,
 400                    CORBA_Environment *ev)
 401 {
 402   AtkText *text = get_text_from_servant (servant);
 403
 404   g_return_val_if_fail (text != NULL, FALSE);
 405
 406   return atk_text_add_selection (text,
 407                             startOffset, endOffset);
 408 }
 409
 410
 411 static CORBA_boolean
 412 impl_removeSelection (PortableServer_Servant servant,
 413                       const CORBA_long selectionNum,
 414                       CORBA_Environment *ev)
 415 {
 416   AtkText *text = get_text_from_servant (servant);
 417
 418   g_return_val_if_fail (text != NULL, FALSE);
 419
 420   return atk_text_remove_selection (text, selectionNum);
 421 }
 422
 423
 424 static CORBA_boolean
 425 impl_setSelection (PortableServer_Servant servant,
 426                    const CORBA_long selectionNum,
 427                    const CORBA_long startOffset,
 428                    const CORBA_long endOffset,
 429                    CORBA_Environment *ev)
 430 {
 431   AtkText *text = get_text_from_servant (servant);
 432
 433   g_return_val_if_fail (text != NULL, FALSE);
 434
 435   return atk_text_set_selection (text,
 436                             selectionNum, startOffset, endOffset);
 437 }
 438
 439
 440 static CORBA_boolean
 441 impl_setCaretOffset (PortableServer_Servant servant,
 442                      const CORBA_long value,
 443                      CORBA_Environment *ev)
 444 {
 445   AtkText *text = get_text_from_servant (servant);
 446
 447   g_return_val_if_fail (text != NULL, FALSE);
 448
 449   return atk_text_set_caret_offset (text, value);
 450 }
 451
 452 #define SPI_TEXT_MIN_RANGE_FOR_LINE_CHECK 6
 453
 454 static void
 455 impl_getRangeExtents(PortableServer_Servant servant,
 456                      const CORBA_long startOffset,
 457                      const CORBA_long endOffset,
 458                      CORBA_long * x, CORBA_long * y,
 459                      CORBA_long * width,
 460                      CORBA_long * height,
 461                      const CORBA_short coordType,
 462                      CORBA_Environment * ev)
 463 {
 464   AtkText *text = get_text_from_servant (servant);
 465   SpiTextRect cbounds, bounds;
 466   int i;
 467
 468   g_return_if_fail (text != NULL);
 469
 470   atk_text_get_character_extents (text, startOffset,
 471                                   &bounds.x, &bounds.y, &bounds.w, &bounds.h,
 472                                   (AtkCoordType) coordType);
 473   /* no equivalent ATK API yet, must do the hard way. :-( */
 474   for (i = startOffset + 1; i < endOffset; i++)
 475     {
 476       atk_text_get_character_extents (text, i,
 477                                       &cbounds.x, &cbounds.y, &cbounds.w, &cbounds.h,
 478                                       (AtkCoordType) coordType);
 479       _spi_text_rect_union (&bounds, &cbounds);
 480     }
 481
 482   *x = bounds.x;
 483   *y = bounds.y;
 484   *width = bounds.w;
 485   *height = bounds.h;
 486 }
 487
 488 static Accessibility_Text_RangeList *
 489 _spi_text_range_seq_from_gslist (GSList *range_list)
 490 {
 491   Accessibility_Text_RangeList *rangeList =
 492     Accessibility_Text_RangeList__alloc ();
 493   int i, len = g_slist_length (range_list);
 494   GSList *list = range_list;
 495
 496   rangeList->_length = len;
 497   rangeList->_buffer = Accessibility_Text_RangeList_allocbuf (len);
 498   for (i = 0; i < len; ++i)
 499     {
 500       memcpy (&rangeList->_buffer[i], list->data, sizeof (Accessibility_Text_Range));
 501       spi_init_any_nil (&rangeList->_buffer[i].data);
 502       g_free (list->data);
 503       list = g_slist_next (range_list);
 504     }
 505   g_slist_free (range_list);
 506
 507   return rangeList;
 508 }
 509
 510 static gboolean
 511 _spi_bounds_contain (SpiTextRect *clip, SpiTextRect *cbounds,
 512                      Accessibility_TEXT_CLIP_TYPE xClipType,
 513                      Accessibility_TEXT_CLIP_TYPE yClipType)
 514 {
 515   gint clipx2 = clip->x + clip->w;
 516   gint clipy2 = clip->y + clip->h;
 517   gint charx2 = cbounds->x + cbounds->w;
 518   gint chary2 = cbounds->y + cbounds->h;
 519   gboolean x_min_ok, y_min_ok, x_max_ok, y_max_ok;
 520
 521   x_min_ok = (cbounds->x >= clip->x) ||
 522     ((charx2 >= clip->x) &&
 523      ((xClipType == Accessibility_TEXT_CLIP_NONE) ||
 524       (xClipType == Accessibility_TEXT_CLIP_MAX)));
 525   x_max_ok = (charx2 <= clipx2) ||
 526     ((cbounds->x <= clipx2) &&
 527      ((xClipType == Accessibility_TEXT_CLIP_NONE) ||
 528       (xClipType == Accessibility_TEXT_CLIP_MIN)));
 529   y_min_ok = (cbounds->y >= clip->y) ||
 530     ((chary2 >= clip->y) &&
 531      ((yClipType == Accessibility_TEXT_CLIP_NONE) ||
 532       (yClipType == Accessibility_TEXT_CLIP_MAX)));
 533   y_max_ok = (chary2 <= clipy2) ||
 534     ((cbounds->y <= clipy2) &&
 535      ((yClipType == Accessibility_TEXT_CLIP_NONE) ||
 536       (yClipType == Accessibility_TEXT_CLIP_MIN)));
 537
 538   if (x_min_ok && y_min_ok && x_max_ok && y_max_ok)
 539     return TRUE;
 540   else
 541     return FALSE;
 542 }
 543
 544 Accessibility_Text_RangeList *
 545 impl_getBoundedRanges(PortableServer_Servant servant,
 546                       const CORBA_long x,
 547                       const CORBA_long y,
 548                       const CORBA_long width,
 549                       const CORBA_long height,
 550                       const CORBA_short coordType,
 551                       const Accessibility_TEXT_CLIP_TYPE xClipType,
 552                       const Accessibility_TEXT_CLIP_TYPE yClipType,
 553                       CORBA_Environment * ev)
 554 {
 555   AtkText *text = get_text_from_servant (servant);
 556   GSList *range_list = NULL;
 557   SpiTextRect clip;
 558   int startOffset = 0, endOffset = atk_text_get_character_count (text);
 559   int curr_offset;
 560   gint minLineStart, minLineEnd, maxLineStart, maxLineEnd;
 561   long bounds_min_offset;
 562   long bounds_max_offset;
 563
 564   clip.x = x;
 565   clip.y = y;
 566   clip.w = width;
 567   clip.h = height;
 568
 569   /* for horizontal text layouts, at least, the following check helps. */
 570   bounds_min_offset =  atk_text_get_offset_at_point (text, x, y,
 571                                                      (AtkCoordType) coordType);
 572   bounds_max_offset =  atk_text_get_offset_at_point (text, x + width, y + height,
 573                                                      (AtkCoordType) coordType);
 574   atk_text_get_text_at_offset (text, bounds_min_offset,
 575                                ATK_TEXT_BOUNDARY_LINE_START,
 576                                &minLineStart, &minLineEnd);
 577   atk_text_get_text_at_offset (text, bounds_max_offset,
 578                                ATK_TEXT_BOUNDARY_LINE_START,
 579                                &maxLineStart, &maxLineEnd);
 580   startOffset = MIN (minLineStart, maxLineStart);
 581   endOffset  = MAX (minLineEnd, maxLineEnd);
 582
 583   curr_offset = startOffset;
 584
 585   while (curr_offset < endOffset)
 586     {
 587       int offset = startOffset;
 588       SpiTextRect cbounds;
 589       while (curr_offset < endOffset)
 590         {
 591           atk_text_get_character_extents (text, curr_offset,
 592                                           &cbounds.x, &cbounds.y,
 593                                           &cbounds.w, &cbounds.h,
 594                                           (AtkCoordType) coordType);
 595           if (!_spi_bounds_contain (&clip, &cbounds, xClipType, yClipType))
 596             break;
 597           curr_offset++;
 598         }
 599       /* add the range to our list */
 600       if (curr_offset > offset)
 601         {
 602           Accessibility_Text_Range *range = g_malloc (sizeof (Accessibility_Text_Range));
 603           char *s;
 604           range->startOffset = offset;
 605           range->endOffset = curr_offset;
 606           s = atk_text_get_text (text, offset, curr_offset);
 607           range->content = CORBA_string_dup (s ? s : "");
 608           range_list = g_slist_append (range_list, range);
 609           offset = curr_offset;
 610         }
 611       offset++;
 612     }
 613   return _spi_text_range_seq_from_gslist (range_list); /* frees the GSList too */
 614 }
 615
 616
 617 static void
 618 spi_text_class_init (SpiTextClass *klass)
 619 {
 620   POA_Accessibility_Text__epv *epv = &klass->epv;
 621
 622   /* Initialize epv table */
 623
 624   epv->getText = impl_getText;
 625   epv->getTextAfterOffset = impl_getTextAfterOffset;
 626   epv->getCharacterAtOffset = impl_getCharacterAtOffset;
 627   epv->getTextAtOffset = impl_getTextAtOffset;
 628   epv->getTextBeforeOffset = impl_getTextBeforeOffset;
 629   epv->_get_caretOffset = impl__get_caretOffset;
 630   epv->getAttributes = impl_getAttributes;
 631   epv->getCharacterExtents = impl_getCharacterExtents;
 632   epv->_get_characterCount = impl__get_characterCount;
 633   epv->getOffsetAtPoint = impl_getOffsetAtPoint;
 634   epv->getNSelections = impl_getNSelections;
 635   epv->getSelection = impl_getSelection;
 636   epv->addSelection = impl_addSelection;
 637   epv->removeSelection = impl_removeSelection;
 638   epv->setSelection = impl_setSelection;
 639   epv->setCaretOffset = impl_setCaretOffset;
 640   epv->getRangeExtents = impl_getRangeExtents;
 641   epv->getBoundedRanges = impl_getBoundedRanges;
 642 }
 643
 644 static void
 645 spi_text_init (SpiText *text)
 646 {
 647 }
 648
 649 BONOBO_TYPE_FUNC_FULL (SpiText,
 650                        Accessibility_Text,
 651                        PARENT_TYPE,
 652                        spi_text);
 653
 654 void
 655 spi_text_construct (SpiText *text, AtkObject *obj)
 656 {
 657   spi_base_construct (SPI_BASE (text), G_OBJECT(obj));
 658 }
 659
 660
 661 SpiText *
 662 spi_text_interface_new (AtkObject *obj)
 663 {
 664   SpiText *retval;
 665
 666   g_return_val_if_fail (ATK_IS_TEXT (obj), NULL);
 667
 668   retval = g_object_new (SPI_TEXT_TYPE, NULL);
 669
 670   spi_text_construct (retval, obj);
 671
 672   return retval;
 673 }