vcl/unx/gtk3/a11y/atktextattributes.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "atktextattributes.hxx"
  21
  22 #include <com/sun/star/awt/FontSlant.hpp>
  23 #include <com/sun/star/awt/FontStrikeout.hpp>
  24 #include <com/sun/star/awt/FontUnderline.hpp>
  25
  26 #include <com/sun/star/style/CaseMap.hpp>
  27 #include <com/sun/star/style/LineSpacing.hpp>
  28 #include <com/sun/star/style/LineSpacingMode.hpp>
  29 #include <com/sun/star/style/ParagraphAdjust.hpp>
  30 #include <com/sun/star/style/TabAlign.hpp>
  31 #include <com/sun/star/style/TabStop.hpp>
  32
  33 #include <com/sun/star/text/WritingMode2.hpp>
  34
  35 #include "atkwrapper.hxx"
  36
  37 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  38
  39 #include <i18nlangtag/languagetag.hxx>
  40 #include <tools/UnitConversion.hxx>
  41 #include <o3tl/safeint.hxx>
  42 #include <o3tl/string_view.hxx>
  43
  44 #include <stdio.h>
  45 #include <string.h>
  46
  47 using namespace ::com::sun::star;
  48
  49 typedef gchar* (* AtkTextAttrFunc)       ( const uno::Any& rAny );
  50 typedef bool   (* TextPropertyValueFunc) ( uno::Any& rAny, const gchar * value );
  51
  52 #define STRNCMP_PARAM( s )  s,sizeof( s )-1
  53
  54 /*****************************************************************************/
  55
  56 static AtkTextAttribute atk_text_attribute_paragraph_style = ATK_TEXT_ATTR_INVALID;
  57 static AtkTextAttribute atk_text_attribute_font_effect = ATK_TEXT_ATTR_INVALID;
  58 static AtkTextAttribute atk_text_attribute_decoration = ATK_TEXT_ATTR_INVALID;
  59 static AtkTextAttribute atk_text_attribute_line_height = ATK_TEXT_ATTR_INVALID;
  60 static AtkTextAttribute atk_text_attribute_rotation = ATK_TEXT_ATTR_INVALID;
  61 static AtkTextAttribute atk_text_attribute_shadow = ATK_TEXT_ATTR_INVALID;
  62 static AtkTextAttribute atk_text_attribute_tab_interval = ATK_TEXT_ATTR_INVALID;
  63 static AtkTextAttribute atk_text_attribute_tab_stops = ATK_TEXT_ATTR_INVALID;
  64 static AtkTextAttribute atk_text_attribute_writing_mode = ATK_TEXT_ATTR_INVALID;
  65 static AtkTextAttribute atk_text_attribute_vertical_align = ATK_TEXT_ATTR_INVALID;
  66 static AtkTextAttribute atk_text_attribute_misspelled = ATK_TEXT_ATTR_INVALID;
  67 // #i92232#
  68 static AtkTextAttribute atk_text_attribute_tracked_change = ATK_TEXT_ATTR_INVALID;
  69 // #i92233#
  70 static AtkTextAttribute atk_text_attribute_mm_to_pixel_ratio = ATK_TEXT_ATTR_INVALID;
  71
  72 /*****************************************************************************/
  73
  74 /**
  75   * !! IMPORTANT NOTE !! : when adding items to this list, KEEP THE LIST SORTED
  76   *                        and re-arrange the enum values accordingly.
  77   */
  78
  79 namespace {
  80
  81 enum ExportedAttribute
  82 {
  83     TEXT_ATTRIBUTE_BACKGROUND_COLOR = 0,
  84     TEXT_ATTRIBUTE_CASEMAP,
  85     TEXT_ATTRIBUTE_FOREGROUND_COLOR,
  86     TEXT_ATTRIBUTE_CONTOURED,
  87     TEXT_ATTRIBUTE_CHAR_ESCAPEMENT,
  88     TEXT_ATTRIBUTE_BLINKING,
  89     TEXT_ATTRIBUTE_FONT_NAME,
  90     TEXT_ATTRIBUTE_HEIGHT,
  91     TEXT_ATTRIBUTE_HIDDEN,
  92     TEXT_ATTRIBUTE_KERNING,
  93     TEXT_ATTRIBUTE_LOCALE,
  94     TEXT_ATTRIBUTE_POSTURE,
  95     TEXT_ATTRIBUTE_RELIEF,
  96     TEXT_ATTRIBUTE_ROTATION,
  97     TEXT_ATTRIBUTE_SCALE,
  98     TEXT_ATTRIBUTE_SHADOWED,
  99     TEXT_ATTRIBUTE_STRIKETHROUGH,
 100     TEXT_ATTRIBUTE_UNDERLINE,
 101     TEXT_ATTRIBUTE_WEIGHT,
 102     // #i92233#
 103     TEXT_ATTRIBUTE_MM_TO_PIXEL_RATIO,
 104     TEXT_ATTRIBUTE_JUSTIFICATION,
 105     TEXT_ATTRIBUTE_BOTTOM_MARGIN,
 106     TEXT_ATTRIBUTE_FIRST_LINE_INDENT,
 107     TEXT_ATTRIBUTE_LEFT_MARGIN,
 108     TEXT_ATTRIBUTE_LINE_SPACING,
 109     TEXT_ATTRIBUTE_RIGHT_MARGIN,
 110     TEXT_ATTRIBUTE_STYLE_NAME,
 111     TEXT_ATTRIBUTE_TAB_STOPS,
 112     TEXT_ATTRIBUTE_TOP_MARGIN,
 113     TEXT_ATTRIBUTE_WRITING_MODE,
 114     TEXT_ATTRIBUTE_LAST
 115 };
 116
 117 }
 118
 119 static const char * ExportedTextAttributes[TEXT_ATTRIBUTE_LAST] =
 120 {
 121     "CharBackColor",        // TEXT_ATTRIBUTE_BACKGROUND_COLOR
 122     "CharCaseMap",          // TEXT_ATTRIBUTE_CASEMAP
 123     "CharColor",            // TEXT_ATTRIBUTE_FOREGROUND_COLOR
 124     "CharContoured",        // TEXT_ATTRIBUTE_CONTOURED
 125     "CharEscapement",       // TEXT_ATTRIBUTE_CHAR_ESCAPEMENT
 126     "CharFlash",            // TEXT_ATTRIBUTE_BLINKING
 127     "CharFontName",         // TEXT_ATTRIBUTE_FONT_NAME
 128     "CharHeight",           // TEXT_ATTRIBUTE_HEIGHT
 129     "CharHidden",           // TEXT_ATTRIBUTE_HIDDEN
 130     "CharKerning",          // TEXT_ATTRIBUTE_KERNING
 131     "CharLocale",           // TEXT_ATTRIBUTE_LOCALE
 132     "CharPosture",          // TEXT_ATTRIBUTE_POSTURE
 133     "CharRelief",           // TEXT_ATTRIBUTE_RELIEF
 134     "CharRotation",         // TEXT_ATTRIBUTE_ROTATION
 135     "CharScaleWidth",       // TEXT_ATTRIBUTE_SCALE
 136     "CharShadowed",         // TEXT_ATTRIBUTE_SHADOWED
 137     "CharStrikeout",        // TEXT_ATTRIBUTE_STRIKETHROUGH
 138     "CharUnderline",        // TEXT_ATTRIBUTE_UNDERLINE
 139     "CharWeight",           // TEXT_ATTRIBUTE_WEIGHT
 140     // #i92233#
 141     "MMToPixelRatio",       // TEXT_ATTRIBUTE_MM_TO_PIXEL_RATIO
 142     "ParaAdjust",           // TEXT_ATTRIBUTE_JUSTIFICATION
 143     "ParaBottomMargin",     // TEXT_ATTRIBUTE_BOTTOM_MARGIN
 144     "ParaFirstLineIndent",  // TEXT_ATTRIBUTE_FIRST_LINE_INDENT
 145     "ParaLeftMargin",       // TEXT_ATTRIBUTE_LEFT_MARGIN
 146     "ParaLineSpacing",      // TEXT_ATTRIBUTE_LINE_SPACING
 147     "ParaRightMargin",      // TEXT_ATTRIBUTE_RIGHT_MARGIN
 148     "ParaStyleName",        // TEXT_ATTRIBUTE_STYLE_NAME
 149     "ParaTabStops",         // TEXT_ATTRIBUTE_TAB_STOPS
 150     "ParaTopMargin",        // TEXT_ATTRIBUTE_TOP_MARGIN
 151     "WritingMode"           // TEXT_ATTRIBUTE_WRITING_MODE
 152 };
 153
 154 /*****************************************************************************/
 155
 156 static gchar*
 157 get_value( const uno::Sequence< beans::PropertyValue >& rAttributeList,
 158            sal_Int32 nIndex, AtkTextAttrFunc func )
 159 {
 160     if( nIndex != -1 )
 161         return func(rAttributeList[nIndex].Value);
 162
 163     return nullptr;
 164 }
 165
 166 #define get_bool_value( list, index ) get_value( list, index, Bool2String )
 167 #define get_height_value( list, index ) get_value( list, index, Float2String )
 168 #define get_justification_value( list, index ) get_value( list, index, Adjust2Justification )
 169 #define get_cmm_value( list, index ) get_value( list, index, CMM2UnitString )
 170 #define get_scale_width( list, index ) get_value( list, index, Scale2String )
 171 #define get_strikethrough_value( list, index ) get_value( list, index, Strikeout2String )
 172 #define get_string_value( list, index ) get_value( list, index, GetString )
 173 #define get_style_value( list, index ) get_value( list, index, FontSlant2Style )
 174 #define get_underline_value( list, index ) get_value( list, index, Underline2String )
 175 #define get_variant_value( list, index ) get_value( list, index, CaseMap2String )
 176 #define get_weight_value( list, index ) get_value( list, index, Weight2String )
 177 #define get_language_string( list, index ) get_value( list, index, Locale2String )
 178
 179 /*****************************************************************************/
 180
 181 static bool
 182 InvalidValue( uno::Any&, const gchar * )
 183 {
 184     return false;
 185 }
 186
 187 /*****************************************************************************/
 188
 189 static gchar*
 190 Float2String(const uno::Any& rAny)
 191 {
 192     return g_strdup_printf( "%g", rAny.get<float>() );
 193 }
 194
 195 static bool
 196 String2Float( uno::Any& rAny, const gchar * value )
 197 {
 198     float fval;
 199
 200     if( 1 != sscanf( value, "%g", &fval ) )
 201         return false;
 202
 203     rAny <<= fval;
 204     return true;
 205 }
 206
 207 /*****************************************************************************/
 208
 209 /// @throws uno::RuntimeException
 210 static css::uno::Reference<css::accessibility::XAccessibleComponent>
 211     getComponent( AtkText *pText )
 212 {
 213     AtkObjectWrapper *pWrap = ATK_OBJECT_WRAPPER( pText );
 214     if( pWrap )
 215     {
 216         if( !pWrap->mpComponent.is() )
 217         {
 218             pWrap->mpComponent.set(pWrap->mpContext, css::uno::UNO_QUERY);
 219         }
 220
 221         return pWrap->mpComponent;
 222     }
 223
 224     return css::uno::Reference<css::accessibility::XAccessibleComponent>();
 225 }
 226
 227 static gchar*
 228 get_color_value(const uno::Sequence< beans::PropertyValue >& rAttributeList,
 229                 const sal_Int32 * pIndexArray,
 230                 ExportedAttribute attr,
 231                 AtkText * text)
 232 {
 233     sal_Int32 nColor = -1; // AUTOMATIC
 234     sal_Int32 nIndex = pIndexArray[attr];
 235
 236     if( nIndex != -1 )
 237         nColor = rAttributeList[nIndex].Value.get<sal_Int32>();
 238
 239     /*
 240      * Check for color value for 100% alpha white, which means
 241      * "automatic". Grab the RGB value from XAccessibleComponent
 242      * in this case.
 243      */
 244
 245     if( (nColor == -1) && text )
 246     {
 247         try
 248         {
 249             css::uno::Reference<css::accessibility::XAccessibleComponent>
 250                 pComponent = getComponent( text );
 251             if( pComponent.is() )
 252             {
 253                 switch( attr )
 254                 {
 255                     case TEXT_ATTRIBUTE_BACKGROUND_COLOR:
 256                         nColor = pComponent->getBackground();
 257                         break;
 258                     case TEXT_ATTRIBUTE_FOREGROUND_COLOR:
 259                         nColor = pComponent->getForeground();
 260                         break;
 261                     default:
 262                         break;
 263                 }
 264             }
 265         }
 266
 267         catch(const uno::Exception&) {
 268             g_warning( "Exception in get[Fore|Back]groundColor()" );
 269         }
 270     }
 271
 272     if( nColor != -1 )
 273     {
 274         sal_uInt8 blue  = nColor & 0xFF;
 275         sal_uInt8 green = (nColor >> 8) & 0xFF;
 276         sal_uInt8 red   = (nColor >> 16) & 0xFF;
 277
 278         return g_strdup_printf( "%u,%u,%u", red, green, blue );
 279     }
 280
 281     return nullptr;
 282 }
 283
 284 static bool
 285 String2Color( uno::Any& rAny, const gchar * value )
 286 {
 287     int red, green, blue;
 288
 289     if( 3 != sscanf( value, "%d,%d,%d", &red, &green, &blue ) )
 290         return false;
 291
 292     sal_Int32 nColor = static_cast<sal_Int32>(blue) | ( static_cast<sal_Int32>(green) << 8 ) | ( static_cast<sal_Int32>(red) << 16 );
 293     rAny <<= nColor;
 294     return true;
 295 }
 296
 297 /*****************************************************************************/
 298
 299 static gchar*
 300 FontSlant2Style(const uno::Any& rAny)
 301 {
 302     const gchar * value = nullptr;
 303
 304     awt::FontSlant aFontSlant;
 305     if(!(rAny >>= aFontSlant))
 306         return nullptr;
 307
 308     switch( aFontSlant )
 309     {
 310         case awt::FontSlant_NONE:
 311             value = "normal";
 312             break;
 313
 314         case awt::FontSlant_OBLIQUE:
 315             value = "oblique";
 316             break;
 317
 318         case awt::FontSlant_ITALIC:
 319             value = "italic";
 320             break;
 321
 322         case awt::FontSlant_REVERSE_OBLIQUE:
 323             value = "reverse oblique";
 324             break;
 325
 326         case awt::FontSlant_REVERSE_ITALIC:
 327             value = "reverse italic";
 328             break;
 329
 330         default:
 331             break;
 332     }
 333
 334     if( value )
 335          return g_strdup( value );
 336
 337     return nullptr;
 338 }
 339
 340 static bool
 341 Style2FontSlant( uno::Any& rAny, const gchar * value )
 342 {
 343     awt::FontSlant aFontSlant;
 344
 345     if( strncmp( value, STRNCMP_PARAM( "normal" ) ) == 0 )
 346         aFontSlant = awt::FontSlant_NONE;
 347     else if( strncmp( value, STRNCMP_PARAM( "oblique" ) ) == 0 )
 348         aFontSlant = awt::FontSlant_OBLIQUE;
 349     else if( strncmp( value, STRNCMP_PARAM( "italic" ) ) == 0 )
 350         aFontSlant = awt::FontSlant_ITALIC;
 351     else if( strncmp( value, STRNCMP_PARAM( "reverse oblique" ) ) == 0 )
 352         aFontSlant = awt::FontSlant_REVERSE_OBLIQUE;
 353     else if( strncmp( value, STRNCMP_PARAM( "reverse italic" ) ) == 0 )
 354         aFontSlant = awt::FontSlant_REVERSE_ITALIC;
 355     else
 356         return false;
 357
 358     rAny <<= aFontSlant;
 359     return true;
 360 }
 361
 362 /*****************************************************************************/
 363
 364 static gchar*
 365 Weight2String(const uno::Any& rAny)
 366 {
 367     return g_strdup_printf( "%g", rAny.get<float>() * 4 );
 368 }
 369
 370 static bool
 371 String2Weight( uno::Any& rAny, const gchar * value )
 372 {
 373     float weight;
 374
 375     if( 1 != sscanf( value, "%g", &weight ) )
 376         return false;
 377
 378     rAny <<= weight / 4;
 379     return true;
 380 }
 381
 382 /*****************************************************************************/
 383
 384 static gchar*
 385 Adjust2Justification(const uno::Any& rAny)
 386 {
 387     const gchar * value = nullptr;
 388
 389     switch( static_cast<style::ParagraphAdjust>(rAny.get<short>()) )
 390     {
 391         case style::ParagraphAdjust_LEFT:
 392             value = "left";
 393             break;
 394
 395         case style::ParagraphAdjust_RIGHT:
 396             value = "right";
 397             break;
 398
 399         case style::ParagraphAdjust_BLOCK:
 400         case style::ParagraphAdjust_STRETCH:
 401             value = "fill";
 402             break;
 403
 404         case style::ParagraphAdjust_CENTER:
 405             value = "center";
 406             break;
 407
 408         default:
 409             break;
 410     }
 411
 412     if( value )
 413         return g_strdup( value );
 414
 415     return nullptr;
 416 }
 417
 418 static bool
 419 Justification2Adjust( uno::Any& rAny, const gchar * value )
 420 {
 421     style::ParagraphAdjust nParagraphAdjust;
 422
 423     if( strncmp( value, STRNCMP_PARAM( "left" ) ) == 0 )
 424         nParagraphAdjust = style::ParagraphAdjust_LEFT;
 425     else if( strncmp( value, STRNCMP_PARAM( "right" ) ) == 0 )
 426         nParagraphAdjust = style::ParagraphAdjust_RIGHT;
 427     else if( strncmp( value, STRNCMP_PARAM( "fill" ) ) == 0 )
 428         nParagraphAdjust = style::ParagraphAdjust_BLOCK;
 429     else if( strncmp( value, STRNCMP_PARAM( "center" ) ) == 0 )
 430         nParagraphAdjust = style::ParagraphAdjust_CENTER;
 431     else
 432         return false;
 433
 434     rAny <<= static_cast<short>(nParagraphAdjust);
 435     return true;
 436 }
 437
 438 /*****************************************************************************/
 439
 440 const gchar * const font_strikethrough[] = {
 441     "none",   // FontStrikeout::NONE
 442     "single", // FontStrikeout::SINGLE
 443     "double", // FontStrikeout::DOUBLE
 444     nullptr,     // FontStrikeout::DONTKNOW
 445     "bold",   // FontStrikeout::BOLD
 446     "with /", // FontStrikeout::SLASH
 447     "with X"  // FontStrikeout::X
 448 };
 449
 450 static gchar*
 451 Strikeout2String(const uno::Any& rAny)
 452 {
 453     sal_Int16 n = rAny.get<sal_Int16>();
 454
 455     if( n >= 0 && o3tl::make_unsigned(n) < SAL_N_ELEMENTS(font_strikethrough) )
 456         return g_strdup( font_strikethrough[n] );
 457
 458     return nullptr;
 459 }
 460
 461 static bool
 462 String2Strikeout( uno::Any& rAny, const gchar * value )
 463 {
 464     for( sal_Int16 n=0; n < sal_Int16(SAL_N_ELEMENTS(font_strikethrough)); ++n )
 465     {
 466         if( ( nullptr != font_strikethrough[n] ) &&
 467             0 == strncmp( value, font_strikethrough[n], strlen( font_strikethrough[n] ) ) )
 468         {
 469             rAny <<= n;
 470             return true;
 471         }
 472     }
 473
 474     return false;
 475 }
 476
 477 /*****************************************************************************/
 478
 479 static gchar*
 480 Underline2String(const uno::Any& rAny)
 481 {
 482     const gchar * value = nullptr;
 483
 484     switch( rAny.get<sal_Int16>() )
 485     {
 486         case awt::FontUnderline::NONE:
 487             value = "none";
 488             break;
 489
 490         case awt::FontUnderline::SINGLE:
 491             value = "single";
 492             break;
 493
 494         case awt::FontUnderline::DOUBLE:
 495             value = "double";
 496             break;
 497
 498         default:
 499             break;
 500     }
 501
 502     if( value )
 503         return g_strdup( value );
 504
 505     return nullptr;
 506 }
 507
 508 static bool
 509 String2Underline( uno::Any& rAny, const gchar * value )
 510 {
 511     short nUnderline;
 512
 513     if( strncmp( value, STRNCMP_PARAM( "none" ) ) == 0 )
 514         nUnderline = awt::FontUnderline::NONE;
 515     else if( strncmp( value, STRNCMP_PARAM( "single" ) ) == 0 )
 516         nUnderline = awt::FontUnderline::SINGLE;
 517     else if( strncmp( value, STRNCMP_PARAM( "double" ) ) == 0 )
 518         nUnderline = awt::FontUnderline::DOUBLE;
 519     else
 520         return false;
 521
 522     rAny <<= nUnderline;
 523     return true;
 524 }
 525
 526 /*****************************************************************************/
 527
 528 static gchar*
 529 GetString(const uno::Any& rAny)
 530 {
 531     OString aFontName = OUStringToOString( rAny.get< OUString > (), RTL_TEXTENCODING_UTF8 );
 532
 533     if( !aFontName.isEmpty() )
 534         return g_strdup( aFontName.getStr() );
 535
 536     return nullptr;
 537 }
 538
 539 static bool
 540 SetString( uno::Any& rAny, const gchar * value )
 541 {
 542     OString aFontName( value );
 543
 544     if( !aFontName.isEmpty() )
 545     {
 546         rAny <<= OStringToOUString( aFontName, RTL_TEXTENCODING_UTF8 );
 547         return true;
 548     }
 549
 550     return false;
 551 }
 552
 553 /*****************************************************************************/
 554
 555 // @see http://developer.gnome.org/doc/API/2.0/atk/AtkText.html#AtkTextAttribute
 556
 557 // CMM = 100th of mm
 558 static gchar*
 559 CMM2UnitString(const uno::Any& rAny)
 560 {
 561     double fValue = rAny.get<sal_Int32>();
 562     fValue = fValue * 0.01;
 563
 564     return g_strdup_printf( "%gmm", fValue );
 565 }
 566
 567 static bool
 568 UnitString2CMM( uno::Any& rAny, const gchar * value )
 569 {
 570     float fValue = 0.0; // pb: don't use double here because of warning on linux
 571
 572     if( 1 != sscanf( value, "%gmm", &fValue ) )
 573         return false;
 574
 575     fValue = fValue * 100;
 576
 577     rAny <<= static_cast<sal_Int32>(fValue);
 578     return true;
 579 }
 580
 581 /*****************************************************************************/
 582
 583 static const gchar * bool_values[] = { "true", "false" };
 584
 585 static gchar *
 586 Bool2String( const uno::Any& rAny )
 587 {
 588     int n = 1;
 589
 590     if( rAny.get<bool>() )
 591         n = 0;
 592
 593     return g_strdup( bool_values[n] );
 594 }
 595
 596 static bool
 597 String2Bool( uno::Any& rAny, const gchar * value )
 598 {
 599     bool bValue;
 600
 601     if( strncmp( value, STRNCMP_PARAM( "true" ) ) == 0 )
 602         bValue = true;
 603     else if( strncmp( value, STRNCMP_PARAM( "false" ) ) == 0 )
 604         bValue = false;
 605     else
 606         return false;
 607
 608     rAny <<= bValue;
 609     return true;
 610 }
 611
 612 /*****************************************************************************/
 613
 614 static gchar*
 615 Scale2String( const uno::Any& rAny )
 616 {
 617     return g_strdup_printf( "%g", static_cast<double>(rAny.get< sal_Int16 > ()) / 100 );
 618 }
 619
 620 static bool
 621 String2Scale( uno::Any& rAny, const gchar * value )
 622 {
 623     double dval;
 624
 625     if( 1 != sscanf( value, "%lg", &dval ) )
 626         return false;
 627
 628     rAny <<= static_cast<sal_Int16>(dval * 100);
 629     return true;
 630 }
 631
 632 /*****************************************************************************/
 633
 634 static gchar *
 635 CaseMap2String( const uno::Any& rAny )
 636 {
 637     const gchar * value;
 638
 639     switch( rAny.get<short>() )
 640     {
 641         case style::CaseMap::SMALLCAPS:
 642             value = "small_caps";
 643             break;
 644
 645         default:
 646             value = "normal";
 647             break;
 648     }
 649
 650     return g_strdup(value);
 651 }
 652
 653 static bool
 654 String2CaseMap( uno::Any& rAny, const gchar * value )
 655 {
 656     short nCaseMap;
 657
 658     if( strncmp( value, STRNCMP_PARAM( "normal" ) ) == 0 )
 659         nCaseMap = style::CaseMap::NONE;
 660     else if( strncmp( value, STRNCMP_PARAM( "small_caps" ) ) == 0 )
 661         nCaseMap = style::CaseMap::SMALLCAPS;
 662     else
 663         return false;
 664
 665     rAny <<= nCaseMap;
 666     return true;
 667 }
 668
 669 /*****************************************************************************/
 670
 671 const gchar * const font_stretch[] = {
 672     "ultra_condensed",
 673     "extra_condensed",
 674     "condensed",
 675     "semi_condensed",
 676     "normal",
 677     "semi_expanded",
 678     "expanded",
 679     "extra_expanded",
 680     "ultra_expanded"
 681 };
 682
 683 static gchar*
 684 Kerning2Stretch(const uno::Any& rAny)
 685 {
 686     sal_Int16 n = rAny.get<sal_Int16>();
 687     int i = 4;
 688
 689     // No good idea for a mapping - just return the basic info
 690     if( n < 0 )
 691         i=2;
 692     else if( n > 0 )
 693         i=6;
 694
 695     return g_strdup(font_stretch[i]);
 696 }
 697
 698 /*****************************************************************************/
 699
 700 static gchar*
 701 Locale2String(const uno::Any& rAny)
 702 {
 703     /* FIXME-BCP47: support language tags? And why is country lowercase? */
 704     lang::Locale aLocale = rAny.get<lang::Locale> ();
 705     LanguageTag aLanguageTag( aLocale);
 706     return g_strdup_printf( "%s-%s",
 707         OUStringToOString( aLanguageTag.getLanguage(), RTL_TEXTENCODING_ASCII_US).getStr(),
 708         OUStringToOString( aLanguageTag.getCountry(), RTL_TEXTENCODING_ASCII_US).toAsciiLowerCase().getStr() );
 709 }
 710
 711 static bool
 712 String2Locale( uno::Any& rAny, const gchar * value )
 713 {
 714     /* FIXME-BCP47: support language tags? */
 715     bool ret = false;
 716
 717     gchar ** str_array = g_strsplit_set( value, "-.@", -1 );
 718     if( str_array[0] != nullptr )
 719     {
 720         ret = true;
 721
 722         lang::Locale aLocale;
 723
 724         aLocale.Language = OUString::createFromAscii(str_array[0]);
 725         if( str_array[1] != nullptr )
 726         {
 727             gchar * country = g_ascii_strup(str_array[1], -1);
 728             aLocale.Country = OUString::createFromAscii(country);
 729             g_free(country);
 730         }
 731
 732         rAny <<= aLocale;
 733     }
 734
 735     g_strfreev(str_array);
 736     return ret;
 737 }
 738
 739 /*****************************************************************************/
 740
 741 // @see http://www.w3.org/TR/2002/WD-css3-fonts-20020802/#font-effect-prop
 742 static const gchar * relief[] = { "none", "emboss", "engrave" };
 743 const gchar * const outline  = "outline";
 744
 745 static gchar *
 746 get_font_effect(const uno::Sequence< beans::PropertyValue >& rAttributeList,
 747                 sal_Int32 nContourIndex, sal_Int32 nReliefIndex)
 748 {
 749     if( nContourIndex != -1 )
 750     {
 751         if( rAttributeList[nContourIndex].Value.get<bool>() )
 752             return g_strdup(outline);
 753     }
 754
 755     if( nReliefIndex != -1 )
 756     {
 757         sal_Int16 n = rAttributeList[nReliefIndex].Value.get<sal_Int16>();
 758         if( n <  3)
 759             return g_strdup(relief[n]);
 760     }
 761
 762     return nullptr;
 763 }
 764
 765 /*****************************************************************************/
 766
 767 // @see http://www.w3.org/TR/REC-CSS2/text.html#lining-striking-props
 768
 769 enum
 770 {
 771     DECORATION_NONE = 0,
 772     DECORATION_BLINK,
 773     DECORATION_UNDERLINE,
 774     DECORATION_LINE_THROUGH
 775 };
 776
 777 static const gchar * decorations[] = { "none", "blink", "underline", "line-through" };
 778
 779 static gchar *
 780 get_text_decoration(const uno::Sequence< beans::PropertyValue >& rAttributeList,
 781                     sal_Int32 nBlinkIndex, sal_Int32 nUnderlineIndex,
 782                     sal_Int16 nStrikeoutIndex)
 783 {
 784     gchar * value_list[4] = { nullptr, nullptr, nullptr, nullptr };
 785     gint count = 0;
 786
 787     // no property value found
 788     if( ( nBlinkIndex == -1 ) && (nUnderlineIndex == -1 ) && (nStrikeoutIndex == -1))
 789         return nullptr;
 790
 791     if( nBlinkIndex != -1 )
 792     {
 793         if( rAttributeList[nBlinkIndex].Value.get<bool>() )
 794             value_list[count++] = const_cast <gchar *> (decorations[DECORATION_BLINK]);
 795     }
 796     if( nUnderlineIndex != -1 )
 797     {
 798         sal_Int16 n = rAttributeList[nUnderlineIndex].Value.get<sal_Int16> ();
 799         if( n != awt::FontUnderline::NONE )
 800             value_list[count++] = const_cast <gchar *> (decorations[DECORATION_UNDERLINE]);
 801     }
 802     if( nStrikeoutIndex != -1 )
 803     {
 804         sal_Int16 n = rAttributeList[nStrikeoutIndex].Value.get<sal_Int16> ();
 805         if( n != awt::FontStrikeout::NONE && n != awt::FontStrikeout::DONTKNOW )
 806             value_list[count++] = const_cast <gchar *> (decorations[DECORATION_LINE_THROUGH]);
 807     }
 808
 809     if( count == 0 )
 810         value_list[count++] = const_cast <gchar *> (decorations[DECORATION_NONE]);
 811
 812     return g_strjoinv(" ", value_list);
 813 }
 814
 815 /*****************************************************************************/
 816
 817 // @see http://www.w3.org/TR/REC-CSS2/text.html#propdef-text-shadow
 818
 819 static const gchar * shadow_values[] = { "none", "black" };
 820
 821 static gchar *
 822 Bool2Shadow( const uno::Any& rAny )
 823 {
 824     int n = 0;
 825
 826     if( rAny.get<bool>() )
 827         n = 1;
 828
 829     return g_strdup( shadow_values[n] );
 830 }
 831
 832 /*****************************************************************************/
 833
 834 static gchar *
 835 Short2Degree( const uno::Any& rAny )
 836 {
 837     float f = rAny.get<sal_Int16>() / 10.0;
 838     return g_strdup_printf( "%g", f );
 839 }
 840
 841 /*****************************************************************************/
 842
 843 const gchar * const directions[] = { "ltr", "rtl", "rtl", "ltr", "none" };
 844
 845 static gchar *
 846 WritingMode2Direction( const uno::Any& rAny )
 847 {
 848     sal_Int16 n = rAny.get<sal_Int16>();
 849
 850     if( 0 <= n && n <= text::WritingMode2::PAGE )
 851         return g_strdup(directions[n]);
 852
 853     return nullptr;
 854 }
 855
 856 // @see http://www.w3.org/TR/2001/WD-css3-text-20010517/#PrimaryTextAdvanceDirection
 857
 858 const gchar * const writing_modes[] = { "lr-tb", "rl-tb", "tb-rl", "tb-lr", "none" };
 859 static gchar *
 860 WritingMode2String( const uno::Any& rAny )
 861 {
 862     sal_Int16 n = rAny.get<sal_Int16>();
 863
 864     if( 0 <= n && n <= text::WritingMode2::PAGE )
 865         return g_strdup(writing_modes[n]);
 866
 867     return nullptr;
 868 }
 869
 870 /*****************************************************************************/
 871
 872 const char * const baseline_values[] = { "baseline", "sub", "super" };
 873
 874 // @see http://www.w3.org/TR/REC-CSS2/visudet.html#propdef-vertical-align
 875 static gchar *
 876 Escapement2VerticalAlign( const uno::Any& rAny )
 877 {
 878     sal_Int16 n = rAny.get<sal_Int16>();
 879     gchar * ret = nullptr;
 880
 881     // Values are in %, 101% means "automatic"
 882     if( n == 0 )
 883         ret = g_strdup(baseline_values[0]);
 884     else if( n == 101 )
 885         ret = g_strdup(baseline_values[2]);
 886     else if( n == -101 )
 887         ret = g_strdup(baseline_values[1]);
 888     else
 889         ret = g_strdup_printf( "%d%%", n );
 890
 891     return ret;
 892 }
 893
 894 /*****************************************************************************/
 895
 896 // @see http://www.w3.org/TR/REC-CSS2/visudet.html#propdef-line-height
 897 static gchar *
 898 LineSpacing2LineHeight( const uno::Any& rAny )
 899 {
 900     style::LineSpacing ls;
 901     gchar * ret = nullptr;
 902
 903     if( rAny >>= ls )
 904     {
 905         if( ls.Mode == style::LineSpacingMode::PROP )
 906             ret = g_strdup_printf( "%d%%", ls.Height );
 907         else if( ls.Mode == style::LineSpacingMode::FIX )
 908             ret = g_strdup_printf("%.3gpt", convertMm100ToPoint<double>(ls.Height));
 909     }
 910
 911     return ret;
 912 }
 913
 914 /*****************************************************************************/
 915
 916 // @see http://www.w3.org/People/howcome/t/970224HTMLERB-CSS/WD-tabs-970117.html
 917 static gchar *
 918 TabStopList2String( const uno::Any& rAny, bool default_tabs )
 919 {
 920     uno::Sequence< style::TabStop > theTabStops;
 921     gchar * ret = nullptr;
 922
 923     if( rAny >>= theTabStops)
 924     {
 925         sal_Unicode lastFillChar = ' ';
 926
 927         for (const auto& rTabStop : theTabStops)
 928         {
 929             bool is_default_tab = (style::TabAlign_DEFAULT == rTabStop.Alignment);
 930
 931             if( is_default_tab != default_tabs )
 932                 continue;
 933
 934             double fValue = rTabStop.Position;
 935             fValue = fValue * 0.01;
 936
 937             const gchar * tab_align = "";
 938             switch( rTabStop.Alignment )
 939             {
 940                 case style::TabAlign_LEFT :
 941                     tab_align = "left ";
 942                     break;
 943                 case style::TabAlign_CENTER :
 944                     tab_align = "center ";
 945                     break;
 946                 case style::TabAlign_RIGHT :
 947                     tab_align = "right ";
 948                     break;
 949                 case style::TabAlign_DECIMAL :
 950                     tab_align = "decimal ";
 951                     break;
 952                 default:
 953                     break;
 954             }
 955
 956             const gchar * lead_char = "";
 957
 958             if( rTabStop.FillChar != lastFillChar )
 959             {
 960                 lastFillChar = rTabStop.FillChar;
 961                 switch (lastFillChar)
 962                 {
 963                     case ' ':
 964                         lead_char = "blank ";
 965                         break;
 966
 967                     case '.':
 968                         lead_char = "dotted ";
 969                         break;
 970
 971                     case '-':
 972                         lead_char = "dashed ";
 973                         break;
 974
 975                     case '_':
 976                         lead_char = "lined ";
 977                         break;
 978
 979                     default:
 980                         lead_char = "custom ";
 981                         break;
 982                 }
 983             }
 984
 985             gchar * tab_str = g_strdup_printf( "%s%s%gmm", lead_char, tab_align, fValue );
 986
 987             if( ret )
 988             {
 989                 gchar * old_tab_str = ret;
 990                 ret = g_strconcat(old_tab_str, " ", tab_str, nullptr);
 991                 g_free( tab_str );
 992                 g_free( old_tab_str );
 993             }
 994             else
 995                 ret = tab_str;
 996         }
 997     }
 998
 999     return ret;
1000 }
1001
1002 static gchar *
1003 TabStops2String( const uno::Any& rAny )
1004 {
1005     return TabStopList2String(rAny, false);
1006 }
1007
1008 static gchar *
1009 DefaultTabStops2String( const uno::Any& rAny )
1010 {
1011     return TabStopList2String(rAny, true);
1012 }
1013
1014 /*****************************************************************************/
1015
1016 extern "C" {
1017
1018 static int
1019 attr_compare(const void *p1,const void *p2)
1020 {
1021     const rtl_uString * pustr = static_cast<const rtl_uString *>(p1);
1022     const char * pc = *static_cast<const char * const *>(p2);
1023
1024     return rtl_ustr_ascii_compare_WithLength(pustr->buffer, pustr->length, pc);
1025 }
1026
1027 }
1028
1029 static void
1030 find_exported_attributes( sal_Int32 *pArray,
1031     const css::uno::Sequence< css::beans::PropertyValue >& rAttributeList )
1032 {
1033     for( sal_Int32 i = 0; i < rAttributeList.getLength(); i++ )
1034     {
1035         const char ** pAttr = static_cast<const char **>(bsearch(rAttributeList[i].Name.pData,
1036             ExportedTextAttributes, TEXT_ATTRIBUTE_LAST, sizeof(const char *),
1037             attr_compare));
1038
1039         if( pAttr )
1040         {
1041             sal_Int32 nIndex = pAttr - ExportedTextAttributes;
1042             pArray[nIndex] = i;
1043         }
1044     }
1045 }
1046
1047 /*****************************************************************************/
1048
1049 static AtkAttributeSet*
1050 attribute_set_prepend( AtkAttributeSet* attribute_set,
1051                        AtkTextAttribute attribute,
1052                        gchar * value )
1053 {
1054     if( value )
1055     {
1056         AtkAttribute *at = static_cast<AtkAttribute *>(g_malloc( sizeof (AtkAttribute) ));
1057         at->name  = g_strdup( atk_text_attribute_get_name( attribute ) );
1058         at->value = value;
1059
1060         return g_slist_prepend(attribute_set, at);
1061     }
1062
1063     return attribute_set;
1064 }
1065
1066 /*****************************************************************************/
1067
1068 AtkAttributeSet*
1069 attribute_set_new_from_property_values(
1070     const uno::Sequence< beans::PropertyValue >& rAttributeList,
1071     bool run_attributes_only,
1072     AtkText *text)
1073 {
1074     AtkAttributeSet* attribute_set = nullptr;
1075
1076     sal_Int32 aIndexList[TEXT_ATTRIBUTE_LAST] = { -1 };
1077
1078     // Initialize index array with -1
1079     for(sal_Int32 & rn : aIndexList)
1080         rn = -1;
1081
1082     find_exported_attributes(aIndexList, rAttributeList);
1083
1084     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_BG_COLOR,
1085         get_color_value(rAttributeList, aIndexList, TEXT_ATTRIBUTE_BACKGROUND_COLOR, run_attributes_only ? nullptr : text ) );
1086
1087     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_FG_COLOR,
1088         get_color_value(rAttributeList, aIndexList, TEXT_ATTRIBUTE_FOREGROUND_COLOR, run_attributes_only ? nullptr : text) );
1089
1090     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_INVISIBLE,
1091         get_bool_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_HIDDEN]));
1092
1093     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_UNDERLINE,
1094         get_underline_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_UNDERLINE]));
1095
1096     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_STRIKETHROUGH,
1097         get_strikethrough_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_STRIKETHROUGH]));
1098
1099     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_SIZE,
1100         get_height_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_HEIGHT]));
1101
1102     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_WEIGHT,
1103         get_weight_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_WEIGHT]));
1104
1105     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_FAMILY_NAME,
1106         get_string_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_FONT_NAME]));
1107
1108     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_VARIANT,
1109         get_variant_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_CASEMAP]));
1110
1111     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_STYLE,
1112         get_style_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_POSTURE]));
1113
1114     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_SCALE,
1115         get_scale_width(rAttributeList, aIndexList[TEXT_ATTRIBUTE_SCALE]));
1116
1117     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_LANGUAGE,
1118         get_language_string(rAttributeList, aIndexList[TEXT_ATTRIBUTE_LOCALE]));
1119
1120     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_DIRECTION,
1121         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_WRITING_MODE], WritingMode2Direction));
1122
1123     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_STRETCH,
1124         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_KERNING], Kerning2Stretch));
1125
1126     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_font_effect )
1127         atk_text_attribute_font_effect = atk_text_attribute_register("font-effect");
1128
1129     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_font_effect,
1130         get_font_effect(rAttributeList, aIndexList[TEXT_ATTRIBUTE_CONTOURED], aIndexList[TEXT_ATTRIBUTE_RELIEF]));
1131
1132     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_decoration )
1133         atk_text_attribute_decoration = atk_text_attribute_register("text-decoration");
1134
1135     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_decoration,
1136         get_text_decoration(rAttributeList, aIndexList[TEXT_ATTRIBUTE_BLINKING],
1137             aIndexList[TEXT_ATTRIBUTE_UNDERLINE], aIndexList[TEXT_ATTRIBUTE_STRIKETHROUGH]));
1138
1139     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_rotation )
1140         atk_text_attribute_rotation = atk_text_attribute_register("text-rotation");
1141
1142     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_rotation,
1143         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_ROTATION], Short2Degree));
1144
1145     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_shadow )
1146         atk_text_attribute_shadow = atk_text_attribute_register("text-shadow");
1147
1148     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_shadow,
1149         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_SHADOWED], Bool2Shadow));
1150
1151     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_writing_mode )
1152         atk_text_attribute_writing_mode = atk_text_attribute_register("writing-mode");
1153
1154     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_writing_mode,
1155         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_WRITING_MODE], WritingMode2String));
1156
1157     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_vertical_align )
1158         atk_text_attribute_vertical_align = atk_text_attribute_register("vertical-align");
1159
1160     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_vertical_align,
1161         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_CHAR_ESCAPEMENT], Escapement2VerticalAlign));
1162
1163     if( run_attributes_only )
1164         return attribute_set;
1165
1166     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_LEFT_MARGIN,
1167         get_cmm_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_LEFT_MARGIN]));
1168
1169     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_RIGHT_MARGIN,
1170         get_cmm_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_RIGHT_MARGIN]));
1171
1172     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_INDENT,
1173         get_cmm_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_FIRST_LINE_INDENT]));
1174
1175     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_PIXELS_ABOVE_LINES,
1176         get_cmm_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_TOP_MARGIN]));
1177
1178     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_PIXELS_BELOW_LINES,
1179         get_cmm_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_BOTTOM_MARGIN]));
1180
1181     attribute_set = attribute_set_prepend(attribute_set, ATK_TEXT_ATTR_JUSTIFICATION,
1182         get_justification_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_JUSTIFICATION]));
1183
1184     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_paragraph_style )
1185         atk_text_attribute_paragraph_style = atk_text_attribute_register("paragraph-style");
1186
1187     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_paragraph_style,
1188         get_string_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_STYLE_NAME]));
1189
1190     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_line_height )
1191         atk_text_attribute_line_height = atk_text_attribute_register("line-height");
1192
1193     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_line_height,
1194         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_LINE_SPACING], LineSpacing2LineHeight));
1195
1196     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_tab_interval )
1197         atk_text_attribute_tab_interval = atk_text_attribute_register("tab-interval");
1198
1199     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_tab_interval,
1200         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_TAB_STOPS], DefaultTabStops2String));
1201
1202     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_tab_stops )
1203         atk_text_attribute_tab_stops = atk_text_attribute_register("tab-stops");
1204
1205     attribute_set = attribute_set_prepend(attribute_set, atk_text_attribute_tab_stops,
1206         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_TAB_STOPS], TabStops2String));
1207
1208     // #i92233#
1209     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_mm_to_pixel_ratio )
1210         atk_text_attribute_mm_to_pixel_ratio = atk_text_attribute_register("mm-to-pixel-ratio");
1211
1212     attribute_set = attribute_set_prepend( attribute_set, atk_text_attribute_mm_to_pixel_ratio,
1213         get_value(rAttributeList, aIndexList[TEXT_ATTRIBUTE_MM_TO_PIXEL_RATIO], Float2String));
1214
1215     return attribute_set;
1216 }
1217
1218 AtkAttributeSet*
1219 attribute_set_new_from_extended_attributes(
1220     const css::uno::Reference< css::accessibility::XAccessibleExtendedAttributes >& rExtendedAttributes )
1221 {
1222     AtkAttributeSet *pSet = nullptr;
1223
1224     // extended attributes is a string of colon-separated pairs of property and value,
1225     // with pairs separated by semicolons. Example: "heading-level:2;weight:bold;"
1226     uno::Any anyVal = rExtendedAttributes->getExtendedAttributes();
1227     OUString sExtendedAttrs;
1228     anyVal >>= sExtendedAttrs;
1229     sal_Int32 nIndex = 0;
1230     do
1231     {
1232         OUString sProperty = sExtendedAttrs.getToken( 0, ';', nIndex );
1233
1234         sal_Int32 nColonPos = 0;
1235         OString sPropertyName = OUStringToOString( o3tl::getToken(sProperty, 0, ':', nColonPos ),
1236                                                    RTL_TEXTENCODING_UTF8 );
1237         OString sPropertyValue = OUStringToOString( o3tl::getToken(sProperty, 0, ':', nColonPos ),
1238                                                     RTL_TEXTENCODING_UTF8 );
1239
1240         pSet = attribute_set_prepend( pSet,
1241                                       atk_text_attribute_register( sPropertyName.getStr() ),
1242                                       g_strdup_printf( "%s", sPropertyValue.getStr() ) );
1243     }
1244     while ( nIndex >= 0 && nIndex < sExtendedAttrs.getLength() );
1245
1246     return pSet;
1247 }
1248
1249 AtkAttributeSet* attribute_set_prepend_misspelled( AtkAttributeSet* attribute_set )
1250 {
1251     if( ATK_TEXT_ATTR_INVALID == atk_text_attribute_misspelled )
1252         atk_text_attribute_misspelled = atk_text_attribute_register( "text-spelling" );
1253
1254     attribute_set = attribute_set_prepend( attribute_set, atk_text_attribute_misspelled,
1255         g_strdup_printf( "misspelled" ) );
1256
1257     return attribute_set;
1258 }
1259
1260 // #i92232#
1261 AtkAttributeSet* attribute_set_prepend_tracked_change_insertion( AtkAttributeSet* attribute_set )
1262 {
1263     if ( ATK_TEXT_ATTR_INVALID == atk_text_attribute_tracked_change )
1264     {
1265         atk_text_attribute_tracked_change = atk_text_attribute_register( "text-tracked-change" );
1266     }
1267
1268     attribute_set = attribute_set_prepend( attribute_set,
1269                                            atk_text_attribute_tracked_change,
1270                                            g_strdup_printf( "insertion" ) );
1271
1272     return attribute_set;
1273 }
1274
1275 AtkAttributeSet* attribute_set_prepend_tracked_change_deletion( AtkAttributeSet* attribute_set )
1276 {
1277     if ( ATK_TEXT_ATTR_INVALID == atk_text_attribute_tracked_change )
1278     {
1279         atk_text_attribute_tracked_change = atk_text_attribute_register( "text-tracked-change" );
1280     }
1281
1282     attribute_set = attribute_set_prepend( attribute_set,
1283                                            atk_text_attribute_tracked_change,
1284                                            g_strdup_printf( "deletion" ) );
1285
1286     return attribute_set;
1287 }
1288
1289 AtkAttributeSet* attribute_set_prepend_tracked_change_formatchange( AtkAttributeSet* attribute_set )
1290 {
1291     if ( ATK_TEXT_ATTR_INVALID == atk_text_attribute_tracked_change )
1292     {
1293         atk_text_attribute_tracked_change = atk_text_attribute_register( "text-tracked-change" );
1294     }
1295
1296     attribute_set = attribute_set_prepend( attribute_set,
1297                                            atk_text_attribute_tracked_change,
1298                                            g_strdup_printf( "attribute-change" ) );
1299
1300     return attribute_set;
1301 }
1302
1303 /*****************************************************************************/
1304
1305 namespace {
1306
1307 struct AtkTextAttrMapping
1308 {
1309     OUString          name;
1310     TextPropertyValueFunc toPropertyValue;
1311 };
1312
1313 }
1314
1315 constexpr AtkTextAttrMapping g_TextAttrMap[]
1316 {
1317     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_INVALID = 0
1318     { u"ParaLeftMargin"_ustr, UnitString2CMM },       // ATK_TEXT_ATTR_LEFT_MARGIN
1319     { u"ParaRightMargin"_ustr, UnitString2CMM },      // ATK_TEXT_ATTR_RIGHT_MARGIN
1320     { u"ParaFirstLineIndent"_ustr, UnitString2CMM },  // ATK_TEXT_ATTR_INDENT
1321     { u"CharHidden"_ustr, String2Bool },              // ATK_TEXT_ATTR_INVISIBLE
1322     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_EDITABLE
1323     { u"ParaTopMargin"_ustr, UnitString2CMM },        // ATK_TEXT_ATTR_PIXELS_ABOVE_LINES
1324     { u"ParaBottomMargin"_ustr, UnitString2CMM },     // ATK_TEXT_ATTR_PIXELS_BELOW_LINES
1325     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP
1326     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_BG_FULL_HEIGHT
1327     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_RISE
1328     { u"CharUnderline"_ustr, String2Underline },      // ATK_TEXT_ATTR_UNDERLINE
1329     { u"CharStrikeout"_ustr, String2Strikeout },      // ATK_TEXT_ATTR_STRIKETHROUGH
1330     { u"CharHeight"_ustr, String2Float },             // ATK_TEXT_ATTR_SIZE
1331     { u"CharScaleWidth"_ustr, String2Scale },         // ATK_TEXT_ATTR_SCALE
1332     { u"CharWeight"_ustr, String2Weight },            // ATK_TEXT_ATTR_WEIGHT
1333     { u"CharLocale"_ustr, String2Locale },            // ATK_TEXT_ATTR_LANGUAGE
1334     { u"CharFontName"_ustr,  SetString },             // ATK_TEXT_ATTR_FAMILY_NAME
1335     { u"CharBackColor"_ustr, String2Color },          // ATK_TEXT_ATTR_BG_COLOR
1336     { u"CharColor"_ustr, String2Color },              // ATK_TEXT_ATTR_FG_COLOR
1337     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_BG_STIPPLE
1338     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_FG_STIPPLE
1339     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_WRAP_MODE
1340     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_DIRECTION
1341     { u"ParaAdjust"_ustr, Justification2Adjust },     // ATK_TEXT_ATTR_JUSTIFICATION
1342     { u""_ustr, InvalidValue },                       // ATK_TEXT_ATTR_STRETCH
1343     { u"CharCaseMap"_ustr, String2CaseMap },          // ATK_TEXT_ATTR_VARIANT
1344     { u"CharPosture"_ustr, Style2FontSlant }          // ATK_TEXT_ATTR_STYLE
1345 };
1346
1347 /*****************************************************************************/
1348
1349 bool
1350 attribute_set_map_to_property_values(
1351     AtkAttributeSet* attribute_set,
1352     uno::Sequence< beans::PropertyValue >& rValueList )
1353 {
1354     // Ensure enough space ..
1355     uno::Sequence< beans::PropertyValue > aAttributeList (SAL_N_ELEMENTS(g_TextAttrMap));
1356     auto pAttributeList = aAttributeList.getArray();
1357
1358     sal_Int32 nIndex = 0;
1359     for( GSList * item = attribute_set; item != nullptr; item = g_slist_next( item ) )
1360     {
1361         AtkAttribute* attribute = reinterpret_cast<AtkAttribute *>(item);
1362
1363         AtkTextAttribute text_attr = atk_text_attribute_for_name( attribute->name );
1364         if( text_attr < SAL_N_ELEMENTS(g_TextAttrMap) )
1365         {
1366             if( g_TextAttrMap[text_attr].name[0] != '\0' )
1367             {
1368                 if( ! g_TextAttrMap[text_attr].toPropertyValue( pAttributeList[nIndex].Value, attribute->value) )
1369                     return false;
1370
1371                 pAttributeList[nIndex].Name = g_TextAttrMap[text_attr].name;
1372                 pAttributeList[nIndex].State = beans::PropertyState_DIRECT_VALUE;
1373                 ++nIndex;
1374             }
1375         }
1376         else
1377         {
1378             // Unsupported text attribute
1379             return false;
1380         }
1381     }
1382
1383     aAttributeList.realloc( nIndex );
1384     rValueList = std::move(aAttributeList);
1385     return true;
1386 }
1387
1388 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */