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 static CORBA_string
 312 impl_getDefaultAttributes (PortableServer_Servant servant,
 313                            CORBA_Environment *ev)
 314 {
 315   AtkAttributeSet *set;
 316   CORBA_char *rv;
 317   AtkText *text = get_text_from_servant (servant);
 318
 319   g_return_val_if_fail (text != NULL, CORBA_string_dup (""));
 320
 321   set = atk_text_get_default_attributes (text);
 322
 323   rv = _string_from_attribute_set (set);
 324   atk_attribute_set_free (set);
 325   return rv;
 326 }
 327
 328 static void
 329 impl_getCharacterExtents (PortableServer_Servant servant,
 330                           const CORBA_long offset, CORBA_long * x,
 331                           CORBA_long * y, CORBA_long * width,
 332                           CORBA_long * height,
 333                           const CORBA_short coordType,
 334                           CORBA_Environment *ev)
 335 {
 336   AtkText *text = get_text_from_servant (servant);
 337   gint ix, iy, iw, ih;
 338
 339   g_return_if_fail (text != NULL);
 340
 341   atk_text_get_character_extents (
 342           text, offset,
 343           &ix, &iy, &iw, &ih,
 344           (AtkCoordType) coordType);
 345   *x = ix;
 346   *y = iy;
 347   *width = iw;
 348   *height = ih;
 349 }
 350
 351
 352 static CORBA_long
 353 impl__get_characterCount (PortableServer_Servant servant,
 354                           CORBA_Environment    *ev)
 355 {
 356   AtkText *text = get_text_from_servant (servant);
 357
 358   g_return_val_if_fail (text != NULL, 0);
 359
 360   return atk_text_get_character_count (text);
 361 }
 362
 363
 364 static CORBA_long
 365 impl_getOffsetAtPoint (PortableServer_Servant servant,
 366                        const CORBA_long x, const CORBA_long y,
 367                        const CORBA_short coordType,
 368                        CORBA_Environment *ev)
 369 {
 370   AtkText *text = get_text_from_servant (servant);
 371
 372   g_return_val_if_fail (text != NULL, -1);
 373
 374   return atk_text_get_offset_at_point (text,
 375                                   x, y,
 376                                   (AtkCoordType) coordType);
 377 }
 378
 379
 380 static CORBA_long
 381 impl_getNSelections (PortableServer_Servant servant,
 382                      CORBA_Environment *ev)
 383 {
 384   AtkText *text = get_text_from_servant (servant);
 385
 386   g_return_val_if_fail (text != NULL, 0);
 387
 388   return atk_text_get_n_selections (text);
 389 }
 390
 391
 392 static void
 393 impl_getSelection (PortableServer_Servant servant,
 394                    const CORBA_long selectionNum,
 395                    CORBA_long * startOffset, CORBA_long * endOffset,
 396                    CORBA_Environment *ev)
 397 {
 398   AtkText *text = get_text_from_servant (servant);
 399   gint intStartOffset, intEndOffset;
 400
 401   g_return_if_fail (text != NULL);
 402
 403   /* atk_text_get_selection returns gchar* which we discard */
 404   g_free (atk_text_get_selection (text, selectionNum,
 405                                   &intStartOffset, &intEndOffset));
 406
 407   *startOffset = intStartOffset;
 408   *endOffset = intEndOffset;
 409 }
 410
 411
 412 static CORBA_boolean
 413 impl_addSelection (PortableServer_Servant servant,
 414                    const CORBA_long startOffset,
 415                    const CORBA_long endOffset,
 416                    CORBA_Environment *ev)
 417 {
 418   AtkText *text = get_text_from_servant (servant);
 419
 420   g_return_val_if_fail (text != NULL, FALSE);
 421
 422   return atk_text_add_selection (text,
 423                             startOffset, endOffset);
 424 }
 425
 426
 427 static CORBA_boolean
 428 impl_removeSelection (PortableServer_Servant servant,
 429                       const CORBA_long selectionNum,
 430                       CORBA_Environment *ev)
 431 {
 432   AtkText *text = get_text_from_servant (servant);
 433
 434   g_return_val_if_fail (text != NULL, FALSE);
 435
 436   return atk_text_remove_selection (text, selectionNum);
 437 }
 438
 439
 440 static CORBA_boolean
 441 impl_setSelection (PortableServer_Servant servant,
 442                    const CORBA_long selectionNum,
 443                    const CORBA_long startOffset,
 444                    const CORBA_long endOffset,
 445                    CORBA_Environment *ev)
 446 {
 447   AtkText *text = get_text_from_servant (servant);
 448
 449   g_return_val_if_fail (text != NULL, FALSE);
 450
 451   return atk_text_set_selection (text,
 452                             selectionNum, startOffset, endOffset);
 453 }
 454
 455
 456 static CORBA_boolean
 457 impl_setCaretOffset (PortableServer_Servant servant,
 458                      const CORBA_long value,
 459                      CORBA_Environment *ev)
 460 {
 461   AtkText *text = get_text_from_servant (servant);
 462
 463   g_return_val_if_fail (text != NULL, FALSE);
 464
 465   return atk_text_set_caret_offset (text, value);
 466 }
 467
 468 #define SPI_TEXT_MIN_RANGE_FOR_LINE_CHECK 6
 469
 470 static void
 471 impl_getRangeExtents(PortableServer_Servant servant,
 472                      const CORBA_long startOffset,
 473                      const CORBA_long endOffset,
 474                      CORBA_long * x, CORBA_long * y,
 475                      CORBA_long * width,
 476                      CORBA_long * height,
 477                      const CORBA_short coordType,
 478                      CORBA_Environment * ev)
 479 {
 480   AtkText *text = get_text_from_servant (servant);
 481   SpiTextRect cbounds, bounds;
 482   int i;
 483
 484   g_return_if_fail (text != NULL);
 485
 486   atk_text_get_character_extents (text, startOffset,
 487                                   &bounds.x, &bounds.y, &bounds.w, &bounds.h,
 488                                   (AtkCoordType) coordType);
 489   /* no equivalent ATK API yet, must do the hard way. :-( */
 490   for (i = startOffset + 1; i < endOffset; i++)
 491     {
 492       atk_text_get_character_extents (text, i,
 493                                       &cbounds.x, &cbounds.y, &cbounds.w, &cbounds.h,
 494                                       (AtkCoordType) coordType);
 495       _spi_text_rect_union (&bounds, &cbounds);
 496     }
 497
 498   *x = bounds.x;
 499   *y = bounds.y;
 500   *width = bounds.w;
 501   *height = bounds.h;
 502 }
 503
 504 static Accessibility_Text_RangeList *
 505 _spi_text_range_seq_from_gslist (GSList *range_list)
 506 {
 507   Accessibility_Text_RangeList *rangeList =
 508     Accessibility_Text_RangeList__alloc ();
 509   int i, len = g_slist_length (range_list);
 510   GSList *list = range_list;
 511
 512   rangeList->_length = len;
 513   rangeList->_buffer = Accessibility_Text_RangeList_allocbuf (len);
 514   for (i = 0; i < len; ++i)
 515     {
 516       memcpy (&rangeList->_buffer[i], list->data, sizeof (Accessibility_Text_Range));
 517       spi_init_any_nil (&rangeList->_buffer[i].data);
 518       g_free (list->data);
 519       list = g_slist_next (range_list);
 520     }
 521   g_slist_free (range_list);
 522
 523   return rangeList;
 524 }
 525
 526 static gboolean
 527 _spi_bounds_contain (SpiTextRect *clip, SpiTextRect *cbounds,
 528                      Accessibility_TEXT_CLIP_TYPE xClipType,
 529                      Accessibility_TEXT_CLIP_TYPE yClipType)
 530 {
 531   gint clipx2 = clip->x + clip->w;
 532   gint clipy2 = clip->y + clip->h;
 533   gint charx2 = cbounds->x + cbounds->w;
 534   gint chary2 = cbounds->y + cbounds->h;
 535   gboolean x_min_ok, y_min_ok, x_max_ok, y_max_ok;
 536
 537   x_min_ok = (cbounds->x >= clip->x) ||
 538     ((charx2 >= clip->x) &&
 539      ((xClipType == Accessibility_TEXT_CLIP_NONE) ||
 540       (xClipType == Accessibility_TEXT_CLIP_MAX)));
 541   x_max_ok = (charx2 <= clipx2) ||
 542     ((cbounds->x <= clipx2) &&
 543      ((xClipType == Accessibility_TEXT_CLIP_NONE) ||
 544       (xClipType == Accessibility_TEXT_CLIP_MIN)));
 545   y_min_ok = (cbounds->y >= clip->y) ||
 546     ((chary2 >= clip->y) &&
 547      ((yClipType == Accessibility_TEXT_CLIP_NONE) ||
 548       (yClipType == Accessibility_TEXT_CLIP_MAX)));
 549   y_max_ok = (chary2 <= clipy2) ||
 550     ((cbounds->y <= clipy2) &&
 551      ((yClipType == Accessibility_TEXT_CLIP_NONE) ||
 552       (yClipType == Accessibility_TEXT_CLIP_MIN)));
 553
 554   if (x_min_ok && y_min_ok && x_max_ok && y_max_ok)
 555     return TRUE;
 556   else
 557     return FALSE;
 558 }
 559
 560 Accessibility_Text_RangeList *
 561 impl_getBoundedRanges(PortableServer_Servant servant,
 562                       const CORBA_long x,
 563                       const CORBA_long y,
 564                       const CORBA_long width,
 565                       const CORBA_long height,
 566                       const CORBA_short coordType,
 567                       const Accessibility_TEXT_CLIP_TYPE xClipType,
 568                       const Accessibility_TEXT_CLIP_TYPE yClipType,
 569                       CORBA_Environment * ev)
 570 {
 571   AtkText *text = get_text_from_servant (servant);
 572   GSList *range_list = NULL;
 573   SpiTextRect clip;
 574   int startOffset = 0, endOffset = atk_text_get_character_count (text);
 575   int curr_offset;
 576   gint minLineStart, minLineEnd, maxLineStart, maxLineEnd;
 577   long bounds_min_offset;
 578   long bounds_max_offset;
 579
 580   clip.x = x;
 581   clip.y = y;
 582   clip.w = width;
 583   clip.h = height;
 584
 585   /* for horizontal text layouts, at least, the following check helps. */
 586   bounds_min_offset =  atk_text_get_offset_at_point (text, x, y,
 587                                                      (AtkCoordType) coordType);
 588   bounds_max_offset =  atk_text_get_offset_at_point (text, x + width, y + height,
 589                                                      (AtkCoordType) coordType);
 590   atk_text_get_text_at_offset (text, bounds_min_offset,
 591                                ATK_TEXT_BOUNDARY_LINE_START,
 592                                &minLineStart, &minLineEnd);
 593   atk_text_get_text_at_offset (text, bounds_max_offset,
 594                                ATK_TEXT_BOUNDARY_LINE_START,
 595                                &maxLineStart, &maxLineEnd);
 596   startOffset = MIN (minLineStart, maxLineStart);
 597   endOffset  = MAX (minLineEnd, maxLineEnd);
 598
 599   curr_offset = startOffset;
 600
 601   while (curr_offset < endOffset)
 602     {
 603       int offset = startOffset;
 604       SpiTextRect cbounds;
 605       while (curr_offset < endOffset)
 606         {
 607           atk_text_get_character_extents (text, curr_offset,
 608                                           &cbounds.x, &cbounds.y,
 609                                           &cbounds.w, &cbounds.h,
 610                                           (AtkCoordType) coordType);
 611           if (!_spi_bounds_contain (&clip, &cbounds, xClipType, yClipType))
 612             break;
 613           curr_offset++;
 614         }
 615       /* add the range to our list */
 616       if (curr_offset > offset)
 617         {
 618           Accessibility_Text_Range *range = g_malloc (sizeof (Accessibility_Text_Range));
 619           char *s;
 620           range->startOffset = offset;
 621           range->endOffset = curr_offset;
 622           s = atk_text_get_text (text, offset, curr_offset);
 623           range->content = CORBA_string_dup (s ? s : "");
 624           range_list = g_slist_append (range_list, range);
 625           offset = curr_offset;
 626         }
 627       offset++;
 628     }
 629   return _spi_text_range_seq_from_gslist (range_list); /* frees the GSList too */
 630 }
 631
 632
 633 static void
 634 spi_text_class_init (SpiTextClass *klass)
 635 {
 636   POA_Accessibility_Text__epv *epv = &klass->epv;
 637
 638   /* Initialize epv table */
 639
 640   epv->getText = impl_getText;
 641   epv->getTextAfterOffset = impl_getTextAfterOffset;
 642   epv->getCharacterAtOffset = impl_getCharacterAtOffset;
 643   epv->getTextAtOffset = impl_getTextAtOffset;
 644   epv->getTextBeforeOffset = impl_getTextBeforeOffset;
 645   epv->_get_caretOffset = impl__get_caretOffset;
 646   epv->getAttributes = impl_getAttributes;
 647   epv->getDefaultAttributes = impl_getDefaultAttributes;
 648   epv->getCharacterExtents = impl_getCharacterExtents;
 649   epv->_get_characterCount = impl__get_characterCount;
 650   epv->getOffsetAtPoint = impl_getOffsetAtPoint;
 651   epv->getNSelections = impl_getNSelections;
 652   epv->getSelection = impl_getSelection;
 653   epv->addSelection = impl_addSelection;
 654   epv->removeSelection = impl_removeSelection;
 655   epv->setSelection = impl_setSelection;
 656   epv->setCaretOffset = impl_setCaretOffset;
 657   epv->getRangeExtents = impl_getRangeExtents;
 658   epv->getBoundedRanges = impl_getBoundedRanges;
 659 }
 660
 661 static void
 662 spi_text_init (SpiText *text)
 663 {
 664 }
 665
 666 BONOBO_TYPE_FUNC_FULL (SpiText,
 667                        Accessibility_Text,
 668                        PARENT_TYPE,
 669                        spi_text)
 670
 671 void
 672 spi_text_construct (SpiText *text, AtkObject *obj)
 673 {
 674   spi_base_construct (SPI_BASE (text), G_OBJECT(obj));
 675 }
 676
 677
 678 SpiText *
 679 spi_text_interface_new (AtkObject *obj)
 680 {
 681   SpiText *retval;
 682
 683   g_return_val_if_fail (ATK_IS_TEXT (obj), NULL);
 684
 685   retval = g_object_new (SPI_TEXT_TYPE, NULL);
 686
 687   spi_text_construct (retval, obj);
 688
 689   return retval;
 690 }