chart2/source/controller/itemsetwrapper/CharacterPropertyItemConverter.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 <CharacterPropertyItemConverter.hxx>
  21 #include "SchWhichPairs.hxx"
  22 #include <ItemPropertyMap.hxx>
  23 #include <RelativeSizeHelper.hxx>
  24 #include <editeng/memberids.h>
  25 #include <editeng/eeitem.hxx>
  26 #include <editeng/udlnitem.hxx>
  27 #include <editeng/fontitem.hxx>
  28 #include <editeng/postitem.hxx>
  29 #include <editeng/wghtitem.hxx>
  30 #include <editeng/fhgtitem.hxx>
  31 #include <o3tl/any.hxx>
  32 #include <svl/stritem.hxx>
  33
  34 #include <com/sun/star/beans/XPropertySet.hpp>
  35 #include <com/sun/star/chart2/XFormattedString.hpp>
  36 #include <tools/diagnose_ex.h>
  37
  38 using namespace ::com::sun::star;
  39
  40 namespace chart { namespace wrapper {
  41
  42 namespace {
  43
  44 ItemPropertyMapType & lcl_GetCharacterPropertyPropertyMap()
  45 {
  46     static ItemPropertyMapType aCharacterPropertyMap{
  47         {EE_CHAR_COLOR, {"CharColor", 0}},
  48         {EE_CHAR_LANGUAGE, {"CharLocale", MID_LANG_LOCALE}},
  49         {EE_CHAR_LANGUAGE_CJK, {"CharLocaleAsian", MID_LANG_LOCALE}},
  50         {EE_CHAR_LANGUAGE_CTL, {"CharLocaleComplex", MID_LANG_LOCALE}},
  51
  52         {EE_CHAR_STRIKEOUT, {"CharStrikeout", MID_CROSS_OUT}},
  53         {EE_CHAR_WLM, {"CharWordMode", 0}},
  54         {EE_CHAR_SHADOW, {"CharShadowed", 0}},
  55         {EE_CHAR_RELIEF, {"CharRelief", 0}},
  56         {EE_CHAR_OUTLINE, {"CharContoured", 0}},
  57         {EE_CHAR_EMPHASISMARK, {"CharEmphasis", 0}},
  58
  59         {EE_PARA_WRITINGDIR, {"WritingMode", 0}},
  60
  61         {EE_PARA_ASIANCJKSPACING, {"ParaIsCharacterDistance", 0}}};
  62
  63     return aCharacterPropertyMap;
  64 }
  65 } // anonymous namespace
  66
  67 CharacterPropertyItemConverter::CharacterPropertyItemConverter(
  68     const uno::Reference< beans::XPropertySet > & rPropertySet,
  69     SfxItemPool& rItemPool ) :
  70         ItemConverter( rPropertySet, rItemPool )
  71 {}
  72
  73 CharacterPropertyItemConverter::CharacterPropertyItemConverter(
  74     const uno::Reference< beans::XPropertySet > & rPropertySet,
  75     SfxItemPool& rItemPool,
  76     const awt::Size* pRefSize,
  77     const OUString & rRefSizePropertyName,
  78     const uno::Reference< beans::XPropertySet > & rRefSizePropSet ) :
  79         ItemConverter( rPropertySet, rItemPool ),
  80         m_aRefSizePropertyName( rRefSizePropertyName ),
  81         m_xRefSizePropSet( rRefSizePropSet.is() ? rRefSizePropSet : rPropertySet )
  82 {
  83     if (pRefSize)
  84         m_pRefSize.reset(*pRefSize);
  85 }
  86
  87 CharacterPropertyItemConverter::~CharacterPropertyItemConverter()
  88 {}
  89
  90 const sal_uInt16 * CharacterPropertyItemConverter::GetWhichPairs() const
  91 {
  92     return nCharacterPropertyWhichPairs;
  93 }
  94
  95 bool CharacterPropertyItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
  96 {
  97     ItemPropertyMapType & rMap( lcl_GetCharacterPropertyPropertyMap());
  98     ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));
  99
 100     if( aIt == rMap.end())
 101         return false;
 102
 103     rOutProperty =(*aIt).second;
 104     return true;
 105 }
 106
 107 void CharacterPropertyItemConverter::FillSpecialItem(
 108     sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
 109 {
 110     switch( nWhichId )
 111     {
 112         case EE_CHAR_FONTINFO:
 113         case EE_CHAR_FONTINFO_CJK:
 114         case EE_CHAR_FONTINFO_CTL:
 115         {
 116             OUString aPostfix;
 117             if( nWhichId == EE_CHAR_FONTINFO_CJK )
 118                 aPostfix = "Asian";
 119             else if( nWhichId == EE_CHAR_FONTINFO_CTL )
 120                 aPostfix = "Complex";
 121
 122             SvxFontItem aItem( nWhichId );
 123
 124             aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix),
 125                             MID_FONT_FAMILY_NAME );
 126             aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix),
 127                             MID_FONT_FAMILY );
 128             aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix),
 129                             MID_FONT_STYLE_NAME );
 130             aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix),
 131                             MID_FONT_CHAR_SET );
 132             aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix),
 133                             MID_FONT_PITCH );
 134
 135             rOutItemSet.Put( aItem );
 136         }
 137         break;
 138
 139         case EE_CHAR_UNDERLINE:
 140         {
 141             SvxUnderlineItem aItem(LINESTYLE_NONE, EE_CHAR_UNDERLINE);
 142             bool bModified = false;
 143
 144             uno::Any aValue( GetPropertySet()->getPropertyValue( "CharUnderline" ));
 145             if( aValue.hasValue())
 146             {
 147                 aItem.PutValue( aValue, MID_TL_STYLE );
 148                 bModified = true;
 149             }
 150
 151             aValue = GetPropertySet()->getPropertyValue( "CharUnderlineHasColor" );
 152             if( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
 153             {
 154                 aItem.PutValue( aValue, MID_TL_HASCOLOR );
 155                 bModified = true;
 156             }
 157
 158             aValue = GetPropertySet()->getPropertyValue( "CharUnderlineColor" );
 159             if( aValue.hasValue())
 160             {
 161                 aItem.PutValue( aValue, MID_TL_COLOR );
 162                 bModified = true;
 163             }
 164
 165             if( bModified )
 166                 rOutItemSet.Put( aItem );
 167         }
 168         break;
 169
 170         case EE_CHAR_OVERLINE:
 171         {
 172             SvxOverlineItem aItem( LINESTYLE_NONE, EE_CHAR_OVERLINE );
 173             bool bModified = false;
 174
 175             uno::Any aValue( GetPropertySet()->getPropertyValue( "CharOverline" ) );
 176             if ( aValue.hasValue() )
 177             {
 178                 aItem.PutValue( aValue, MID_TL_STYLE );
 179                 bModified = true;
 180             }
 181
 182             aValue = GetPropertySet()->getPropertyValue( "CharOverlineHasColor" );
 183             if ( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
 184             {
 185                 aItem.PutValue( aValue, MID_TL_HASCOLOR );
 186                 bModified = true;
 187             }
 188
 189             aValue = GetPropertySet()->getPropertyValue( "CharOverlineColor" );
 190             if ( aValue.hasValue() )
 191             {
 192                 aItem.PutValue( aValue, MID_TL_COLOR );
 193                 bModified = true;
 194             }
 195
 196             if ( bModified )
 197             {
 198                 rOutItemSet.Put( aItem );
 199             }
 200         }
 201         break;
 202
 203         case EE_CHAR_ITALIC:
 204         case EE_CHAR_ITALIC_CJK:
 205         case EE_CHAR_ITALIC_CTL:
 206         {
 207             OUString aPostfix;
 208             if( nWhichId == EE_CHAR_ITALIC_CJK )
 209                 aPostfix = "Asian";
 210             else if( nWhichId == EE_CHAR_ITALIC_CTL )
 211                 aPostfix = "Complex";
 212
 213             SvxPostureItem aItem( ITALIC_NONE, nWhichId );
 214
 215             uno::Any aValue( GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix));
 216             if( aValue.hasValue())
 217             {
 218                 aItem.PutValue( aValue, MID_POSTURE );
 219                 rOutItemSet.Put( aItem );
 220             }
 221         }
 222         break;
 223
 224         case EE_CHAR_WEIGHT:
 225         case EE_CHAR_WEIGHT_CJK:
 226         case EE_CHAR_WEIGHT_CTL:
 227         {
 228             OUString aPostfix;
 229             if( nWhichId == EE_CHAR_WEIGHT_CJK )
 230                 aPostfix = "Asian";
 231             else if( nWhichId == EE_CHAR_WEIGHT_CTL )
 232                 aPostfix = "Complex";
 233
 234             SvxWeightItem aItem( WEIGHT_NORMAL, nWhichId );
 235
 236             uno::Any aValue( GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix));
 237             if( aValue.hasValue())
 238             {
 239                 aItem.PutValue( aValue, MID_WEIGHT );
 240                 rOutItemSet.Put( aItem );
 241             }
 242         }
 243         break;
 244
 245         case EE_CHAR_FONTHEIGHT:
 246         case EE_CHAR_FONTHEIGHT_CJK:
 247         case EE_CHAR_FONTHEIGHT_CTL:
 248         {
 249             OUString aPostfix;
 250             if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
 251                 aPostfix = "Asian";
 252             else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
 253                 aPostfix = "Complex";
 254
 255             SvxFontHeightItem aItem( 240, 100, nWhichId );
 256
 257             try
 258             {
 259                 uno::Any aValue( GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ));
 260                 float fHeight;
 261                 if( aValue >>= fHeight )
 262                 {
 263                     if (m_pRefSize)
 264                     {
 265                         awt::Size aOldRefSize;
 266                         if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
 267                         {
 268                             // calculate font height in view
 269                             fHeight = static_cast< float >(
 270                                 RelativeSizeHelper::calculate( fHeight, aOldRefSize, *m_pRefSize ));
 271                             aValue <<= fHeight;
 272                         }
 273                     }
 274
 275                     aItem.PutValue( aValue, MID_FONTHEIGHT );
 276                     rOutItemSet.Put( aItem );
 277                 }
 278             }
 279             catch( const uno::Exception & )
 280             {
 281                 DBG_UNHANDLED_EXCEPTION("chart2");
 282             }
 283         }
 284         break;
 285
 286         case SID_CHAR_DLG_PREVIEW_STRING:
 287         {
 288             uno::Reference< chart2::XFormattedString > xFormattedString( GetPropertySet(), uno::UNO_QUERY );
 289             if( xFormattedString.is() )
 290             {
 291                 OUString aString = xFormattedString->getString();
 292                 rOutItemSet.Put( SfxStringItem( nWhichId, aString ) );
 293             }
 294             else
 295                 rOutItemSet.Put( SfxStringItem( nWhichId, OUString() ) );
 296         }
 297         break;
 298
 299         case EE_PARA_FORBIDDENRULES:
 300         case EE_PARA_HANGINGPUNCTUATION:
 301             rOutItemSet.DisableItem( nWhichId );
 302             break;
 303     }
 304 }
 305
 306 bool CharacterPropertyItemConverter::ApplySpecialItem(
 307     sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
 308 {
 309     bool bChanged = false;
 310     uno::Any aValue;
 311
 312     switch( nWhichId )
 313     {
 314         case EE_CHAR_FONTINFO:
 315         case EE_CHAR_FONTINFO_CJK:
 316         case EE_CHAR_FONTINFO_CTL:
 317         {
 318             OUString aPostfix;
 319             if( nWhichId == EE_CHAR_FONTINFO_CJK )
 320                 aPostfix = "Asian";
 321             else if( nWhichId == EE_CHAR_FONTINFO_CTL )
 322                 aPostfix = "Complex";
 323
 324             const SvxFontItem & rItem =
 325                 static_cast< const SvxFontItem & >(
 326                     rItemSet.Get( nWhichId ));
 327
 328             if( rItem.QueryValue( aValue, MID_FONT_FAMILY_NAME ))
 329             {
 330                 if( aValue != GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix ))
 331                 {
 332                     GetPropertySet()->setPropertyValue( "CharFontName" + aPostfix, aValue );
 333                     bChanged = true;
 334                 }
 335             }
 336             if( rItem.QueryValue( aValue, MID_FONT_FAMILY ))
 337             {
 338                 if( aValue != GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix ))
 339                 {
 340                     GetPropertySet()->setPropertyValue( "CharFontFamily" + aPostfix, aValue );
 341                     bChanged = true;
 342                 }
 343             }
 344             if( rItem.QueryValue( aValue, MID_FONT_STYLE_NAME ))
 345             {
 346                 if( aValue != GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix ))
 347                 {
 348                     GetPropertySet()->setPropertyValue( "CharFontStyleName" + aPostfix, aValue );
 349                     bChanged = true;
 350                 }
 351             }
 352             if( rItem.QueryValue( aValue, MID_FONT_CHAR_SET ))
 353             {
 354                 if( aValue != GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix ))
 355                 {
 356                     GetPropertySet()->setPropertyValue( "CharFontCharSet" + aPostfix, aValue );
 357                     bChanged = true;
 358                 }
 359             }
 360             if( rItem.QueryValue( aValue, MID_FONT_PITCH ))
 361             {
 362                 if( aValue != GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix ))
 363                 {
 364                     GetPropertySet()->setPropertyValue( "CharFontPitch" + aPostfix, aValue );
 365                     bChanged = true;
 366                 }
 367             }
 368         }
 369         break;
 370
 371         case EE_CHAR_UNDERLINE:
 372         {
 373             const SvxUnderlineItem & rItem =
 374                static_cast< const SvxUnderlineItem & >(
 375                     rItemSet.Get( nWhichId ));
 376
 377             if( rItem.QueryValue( aValue, MID_TL_STYLE ))
 378             {
 379                 if( aValue != GetPropertySet()->getPropertyValue( "CharUnderline" ))
 380                 {
 381                     GetPropertySet()->setPropertyValue( "CharUnderline" , aValue );
 382                     bChanged = true;
 383                 }
 384             }
 385
 386             if( rItem.QueryValue( aValue, MID_TL_COLOR ))
 387             {
 388                 if( aValue != GetPropertySet()->getPropertyValue( "CharUnderlineColor" ))
 389                 {
 390                     GetPropertySet()->setPropertyValue( "CharUnderlineColor" , aValue );
 391                     bChanged = true;
 392                 }
 393             }
 394
 395             if( rItem.QueryValue( aValue, MID_TL_HASCOLOR ))
 396             {
 397                 if( aValue != GetPropertySet()->getPropertyValue( "CharUnderlineHasColor" ))
 398                 {
 399                     GetPropertySet()->setPropertyValue( "CharUnderlineHasColor" , aValue );
 400                     bChanged = true;
 401                 }
 402             }
 403         }
 404         break;
 405
 406         case EE_CHAR_OVERLINE:
 407         {
 408             const SvxOverlineItem& rItem = static_cast< const SvxOverlineItem & >( rItemSet.Get( nWhichId ) );
 409
 410             if ( rItem.QueryValue( aValue, MID_TL_STYLE ) )
 411             {
 412                 if ( aValue != GetPropertySet()->getPropertyValue( "CharOverline" ) )
 413                 {
 414                     GetPropertySet()->setPropertyValue( "CharOverline" , aValue );
 415                     bChanged = true;
 416                 }
 417             }
 418
 419             if ( rItem.QueryValue( aValue, MID_TL_COLOR ) )
 420             {
 421                 if ( aValue != GetPropertySet()->getPropertyValue( "CharOverlineColor" ) )
 422                 {
 423                     GetPropertySet()->setPropertyValue( "CharOverlineColor" , aValue );
 424                     bChanged = true;
 425                 }
 426             }
 427
 428             if ( rItem.QueryValue( aValue, MID_TL_HASCOLOR ) )
 429             {
 430                 if ( aValue != GetPropertySet()->getPropertyValue( "CharOverlineHasColor" ) )
 431                 {
 432                     GetPropertySet()->setPropertyValue( "CharOverlineHasColor" , aValue );
 433                     bChanged = true;
 434                 }
 435             }
 436         }
 437         break;
 438
 439         case EE_CHAR_ITALIC:
 440         case EE_CHAR_ITALIC_CJK:
 441         case EE_CHAR_ITALIC_CTL:
 442         {
 443             OUString aPostfix;
 444             if( nWhichId == EE_CHAR_ITALIC_CJK )
 445                 aPostfix = "Asian";
 446             else if( nWhichId == EE_CHAR_ITALIC_CTL )
 447                 aPostfix = "Complex";
 448
 449             const SvxPostureItem & rItem =
 450                 static_cast< const SvxPostureItem & >(
 451                     rItemSet.Get( nWhichId ));
 452
 453             if( rItem.QueryValue( aValue, MID_POSTURE ))
 454             {
 455                 if( aValue != GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix))
 456                 {
 457                     GetPropertySet()->setPropertyValue( "CharPosture" + aPostfix, aValue );
 458                     bChanged = true;
 459                 }
 460             }
 461         }
 462         break;
 463
 464         case EE_CHAR_WEIGHT:
 465         case EE_CHAR_WEIGHT_CJK:
 466         case EE_CHAR_WEIGHT_CTL:
 467         {
 468             OUString aPostfix;
 469             if( nWhichId == EE_CHAR_WEIGHT_CJK )
 470                 aPostfix = "Asian" ;
 471             else if( nWhichId == EE_CHAR_WEIGHT_CTL )
 472                 aPostfix = "Complex";
 473
 474             const SvxWeightItem & rItem =
 475                 static_cast< const SvxWeightItem & >(
 476                     rItemSet.Get( nWhichId ));
 477
 478             if( rItem.QueryValue( aValue, MID_WEIGHT ))
 479             {
 480                 if( aValue != GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix))
 481                 {
 482                     GetPropertySet()->setPropertyValue( "CharWeight" + aPostfix, aValue );
 483                     bChanged = true;
 484                 }
 485             }
 486         }
 487         break;
 488
 489         case EE_CHAR_FONTHEIGHT:
 490         case EE_CHAR_FONTHEIGHT_CJK:
 491         case EE_CHAR_FONTHEIGHT_CTL:
 492         {
 493             OUString aPostfix;
 494             if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
 495                 aPostfix = "Asian";
 496             else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
 497                 aPostfix = "Complex";
 498
 499             const SvxFontHeightItem & rItem =
 500                 static_cast< const SvxFontHeightItem & >(
 501                     rItemSet.Get( nWhichId ));
 502
 503             try
 504             {
 505                 if( rItem.QueryValue( aValue, MID_FONTHEIGHT ) )
 506                 {
 507                     bool bSetValue = false;
 508                     if( aValue != GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ))
 509                         bSetValue = true;
 510                     else
 511                     {
 512                         if (m_pRefSize)
 513                         {
 514                             awt::Size aNewRefSize = *m_pRefSize;
 515                             awt::Size aOldRefSize;
 516                             if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
 517                             {
 518                                 if( aNewRefSize.Width != aOldRefSize.Width
 519                                     || aNewRefSize.Height != aOldRefSize.Height )
 520                                     bSetValue = true;
 521                             }
 522                         }
 523                     }
 524                     if( bSetValue )
 525                     {
 526                         // set new reference size only if there was a reference size before (auto-scaling on)
 527                         if (m_pRefSize && GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ).hasValue())
 528                         {
 529                             GetRefSizePropertySet()->setPropertyValue(
 530                                 m_aRefSizePropertyName, uno::Any(*m_pRefSize));
 531                         }
 532
 533                         GetPropertySet()->setPropertyValue( "CharHeight" + aPostfix, aValue );
 534                         bChanged = true;
 535                     }
 536                 }
 537             }
 538             catch( const uno::Exception & )
 539             {
 540                 DBG_UNHANDLED_EXCEPTION("chart2");
 541             }
 542         }
 543         break;
 544     }
 545
 546     return bChanged;
 547 }
 548
 549 const uno::Reference<beans::XPropertySet>& CharacterPropertyItemConverter::GetRefSizePropertySet() const
 550 {
 551     return m_xRefSizePropSet;
 552 }
 553
 554 }}
 555
 556 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */