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