chart2/source/controller/itemsetwrapper/TextLabelItemConverter.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 <TextLabelItemConverter.hxx>
  21 #include <CharacterPropertyItemConverter.hxx>
  22 #include <ChartModelHelper.hxx>
  23 #include <ChartTypeHelper.hxx>
  24 #include <DataSeriesHelper.hxx>
  25 #include <DiagramHelper.hxx>
  26 #include <ItemPropertyMap.hxx>
  27 #include "SchWhichPairs.hxx"
  28 #include <unonames.hxx>
  29
  30 #include <editeng/brushitem.hxx>
  31 #include <editeng/sizeitem.hxx>
  32 #include <svl/eitem.hxx>
  33 #include <svl/ilstitem.hxx>
  34 #include <svl/intitem.hxx>
  35 #include <svl/stritem.hxx>
  36 #include <svx/tabline.hxx>
  37 #include <tools/diagnose_ex.h>
  38 #include <vcl/graph.hxx>
  39 #include <rtl/math.hxx>
  40
  41 #include <com/sun/star/chart/DataLabelPlacement.hpp>
  42 #include <com/sun/star/chart2/AxisType.hpp>
  43 #include <com/sun/star/chart2/DataPointLabel.hpp>
  44 #include <com/sun/star/chart2/Symbol.hpp>
  45 #include <com/sun/star/chart2/RelativePosition.hpp>
  46 #include <com/sun/star/frame/XModel.hpp>
  47 #include <memory>
  48
  49 using namespace com::sun::star;
  50 using namespace com::sun::star::chart2;
  51 using com::sun::star::uno::Reference;
  52
  53 namespace chart::wrapper {
  54
  55 namespace {
  56
  57 const ItemPropertyMapType& getTextLabelPropertyMap()
  58 {
  59     static ItemPropertyMapType aMap{
  60         {XATTR_LINESTYLE, {CHART_UNONAME_LABEL_BORDER_STYLE, 0}},
  61         {XATTR_LINEWIDTH, {CHART_UNONAME_LABEL_BORDER_WIDTH, 0}},
  62         {XATTR_LINEDASH,  {CHART_UNONAME_LABEL_BORDER_DASH, 0}},
  63         {XATTR_LINECOLOR, {CHART_UNONAME_LABEL_BORDER_COLOR, 0}},
  64         {XATTR_LINETRANSPARENCE, {CHART_UNONAME_LABEL_BORDER_TRANS, 0}}};
  65     return aMap;
  66 };
  67
  68 sal_Int32 getSymbolStyleForSymbol( const chart2::Symbol& rSymbol )
  69 {
  70     sal_Int32 nStyle = SVX_SYMBOLTYPE_UNKNOWN;
  71     switch (rSymbol.Style)
  72     {
  73         case chart2::SymbolStyle_NONE:
  74             nStyle = SVX_SYMBOLTYPE_NONE;
  75         break;
  76         case chart2::SymbolStyle_AUTO:
  77             nStyle = SVX_SYMBOLTYPE_AUTO;
  78         break;
  79         case chart2::SymbolStyle_GRAPHIC:
  80             nStyle = SVX_SYMBOLTYPE_BRUSHITEM;
  81         break;
  82         case chart2::SymbolStyle_STANDARD:
  83             nStyle = rSymbol.StandardSymbol;
  84         break;
  85         case chart2::SymbolStyle_POLYGON:
  86         default:
  87             ;
  88     }
  89     return nStyle;
  90 }
  91
  92 bool numberFormatFromItemToPropertySet(
  93     sal_uInt16 nWhichId, const SfxItemSet& rItemSet, const uno::Reference<beans::XPropertySet>& xPropertySet,
  94     bool bOverwriteDataPoints )
  95 {
  96     bool bChanged = false;
  97     if (!xPropertySet.is())
  98         return bChanged;
  99
 100     OUString aPropertyName = (nWhichId == SID_ATTR_NUMBERFORMAT_VALUE) ? OUString(CHART_UNONAME_NUMFMT) : OUString("PercentageNumberFormat");
 101     sal_uInt16 nSourceWhich = (nWhichId == SID_ATTR_NUMBERFORMAT_VALUE) ? SID_ATTR_NUMBERFORMAT_SOURCE : SCHATTR_PERCENT_NUMBERFORMAT_SOURCE;
 102
 103     if (rItemSet.GetItemState(nSourceWhich) != SfxItemState::SET)
 104         return bChanged;
 105
 106     uno::Any aValue;
 107     bool bUseSourceFormat = static_cast<const SfxBoolItem&>(rItemSet.Get(nSourceWhich)).GetValue();
 108     if (!bUseSourceFormat)
 109     {
 110         SfxItemState aState = rItemSet.GetItemState(nWhichId);
 111         if (aState == SfxItemState::SET)
 112         {
 113             sal_Int32 nFmt = static_cast<sal_Int32>(
 114                 static_cast<const SfxUInt32Item&>(
 115                     rItemSet.Get(nWhichId)).GetValue());
 116             aValue <<= nFmt;
 117         }
 118         else
 119             return bChanged;
 120     }
 121
 122     uno::Any aOldValue = xPropertySet->getPropertyValue(aPropertyName);
 123     if (bOverwriteDataPoints)
 124     {
 125         Reference<chart2::XDataSeries> xSeries(xPropertySet, uno::UNO_QUERY);
 126         if (aValue != aOldValue ||
 127             ::chart::DataSeriesHelper::hasAttributedDataPointDifferentValue(xSeries, aPropertyName, aOldValue))
 128         {
 129             ::chart::DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, aPropertyName, aValue);
 130             bChanged = true;
 131         }
 132     }
 133     else if (aOldValue != aValue)
 134     {
 135         xPropertySet->setPropertyValue(aPropertyName, aValue);
 136         bChanged = true;
 137     }
 138     return bChanged;
 139 }
 140
 141 bool useSourceFormatFromItemToPropertySet(
 142     sal_uInt16 nWhichId, const SfxItemSet& rItemSet, const uno::Reference<beans::XPropertySet>& xPropertySet,
 143     bool bOverwriteDataPoints )
 144 {
 145     bool bChanged = false;
 146     if (!xPropertySet.is())
 147         return bChanged;
 148     OUString aPropertyName = (nWhichId == SID_ATTR_NUMBERFORMAT_SOURCE) ? OUString(CHART_UNONAME_NUMFMT) : OUString("PercentageNumberFormat");
 149     sal_uInt16 nFormatWhich = (nWhichId == SID_ATTR_NUMBERFORMAT_SOURCE) ? SID_ATTR_NUMBERFORMAT_VALUE : SCHATTR_PERCENT_NUMBERFORMAT_VALUE;
 150
 151     if (rItemSet.GetItemState(nWhichId) != SfxItemState::SET)
 152         return bChanged;
 153
 154     uno::Any aNewValue;
 155     bool bUseSourceFormat = static_cast<const SfxBoolItem&>(
 156             rItemSet.Get(nWhichId)).GetValue();
 157     xPropertySet->setPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT, uno::Any(bUseSourceFormat));
 158     if (!bUseSourceFormat)
 159     {
 160         SfxItemState aState = rItemSet.GetItemState(nFormatWhich);
 161         if (aState == SfxItemState::SET)
 162         {
 163             sal_Int32 nFormatKey = static_cast<sal_Int32>(
 164                 static_cast<const SfxUInt32Item&>(
 165                     rItemSet.Get(nFormatWhich)).GetValue());
 166             aNewValue <<= nFormatKey;
 167         }
 168         else
 169             return bChanged;
 170     }
 171
 172     uno::Any aOldValue(xPropertySet->getPropertyValue(aPropertyName));
 173     if (bOverwriteDataPoints)
 174     {
 175         Reference<chart2::XDataSeries> xSeries(xPropertySet, uno::UNO_QUERY);
 176         if (aNewValue != aOldValue ||
 177             ::chart::DataSeriesHelper::hasAttributedDataPointDifferentValue(xSeries, aPropertyName, aOldValue))
 178         {
 179             ::chart::DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, aPropertyName, aNewValue);
 180             bChanged = true;
 181         }
 182     }
 183     else if (aOldValue != aNewValue)
 184     {
 185         xPropertySet->setPropertyValue(aPropertyName, aNewValue);
 186         bChanged = true;
 187     }
 188
 189     return bChanged;
 190 }
 191
 192 } // anonymous namespace
 193
 194 TextLabelItemConverter::TextLabelItemConverter(
 195     const uno::Reference<frame::XModel>& xChartModel,
 196     const uno::Reference<beans::XPropertySet>& rPropertySet,
 197     const uno::Reference<XDataSeries>& xSeries,
 198     SfxItemPool& rItemPool, const awt::Size* pRefSize,
 199     bool bDataSeries, sal_Int32 nNumberFormat, sal_Int32 nPercentNumberFormat ) :
 200     ItemConverter(rPropertySet, rItemPool),
 201     mnNumberFormat(nNumberFormat),
 202     mnPercentNumberFormat(nPercentNumberFormat),
 203     mbDataSeries(bDataSeries),
 204     mbForbidPercentValue(true),
 205     m_xSeries(xSeries)
 206 {
 207     maConverters.emplace_back(new CharacterPropertyItemConverter(rPropertySet, rItemPool, pRefSize, "ReferencePageSize"));
 208
 209     uno::Reference<XDiagram> xDiagram(ChartModelHelper::findDiagram(xChartModel));
 210     uno::Reference<XChartType> xChartType(DiagramHelper::getChartTypeOfSeries(xDiagram, xSeries));
 211     bool bFound = false;
 212     bool bAmbiguous = false;
 213     bool bSwapXAndY = DiagramHelper::getVertical(xDiagram, bFound, bAmbiguous);
 214     maAvailableLabelPlacements = ChartTypeHelper::getSupportedLabelPlacements(xChartType, bSwapXAndY, xSeries);
 215
 216     mbForbidPercentValue = ChartTypeHelper::getAxisType(xChartType, 0) != AxisType::CATEGORY;
 217 }
 218
 219 TextLabelItemConverter::~TextLabelItemConverter()
 220 {
 221 }
 222
 223 void TextLabelItemConverter::FillItemSet( SfxItemSet& rOutItemSet ) const
 224 {
 225     for( const auto& pConv : maConverters )
 226         pConv->FillItemSet( rOutItemSet );
 227
 228     // own items
 229     ItemConverter::FillItemSet(rOutItemSet);
 230 }
 231
 232 bool TextLabelItemConverter::ApplyItemSet( const SfxItemSet& rItemSet )
 233 {
 234     bool bResult = false;
 235
 236     for( const auto& pConv: maConverters )
 237         bResult = pConv->ApplyItemSet( rItemSet ) || bResult;
 238
 239     // own items
 240     return ItemConverter::ApplyItemSet(rItemSet) || bResult;
 241 }
 242
 243 const sal_uInt16* TextLabelItemConverter::GetWhichPairs() const
 244 {
 245     // must span all used items!
 246     return nTextLabelWhichPairs;
 247 }
 248
 249 bool TextLabelItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId& rOutProperty ) const
 250 {
 251     const ItemPropertyMapType& rMap = getTextLabelPropertyMap();
 252     ItemPropertyMapType::const_iterator it = rMap.find(nWhichId);
 253
 254     if (it == rMap.end())
 255         return false;
 256
 257     rOutProperty = it->second;
 258     return true;
 259 }
 260
 261 bool TextLabelItemConverter::ApplySpecialItem( sal_uInt16 nWhichId, const SfxItemSet& rItemSet )
 262 {
 263     bool bChanged = false;
 264
 265     switch (nWhichId)
 266     {
 267         case SCHATTR_DATADESCR_SHOW_NUMBER:
 268         case SCHATTR_DATADESCR_SHOW_PERCENTAGE:
 269         case SCHATTR_DATADESCR_SHOW_CATEGORY:
 270         case SCHATTR_DATADESCR_SHOW_SYMBOL:
 271         {
 272             const SfxBoolItem& rItem = static_cast<const SfxBoolItem&>(rItemSet.Get(nWhichId));
 273
 274             uno::Any aOldValue = GetPropertySet()->getPropertyValue(CHART_UNONAME_LABEL);
 275             chart2::DataPointLabel aLabel;
 276             if (aOldValue >>= aLabel)
 277             {
 278                 sal_Bool& rValue = (nWhichId == SCHATTR_DATADESCR_SHOW_NUMBER) ? aLabel.ShowNumber : (
 279                     (nWhichId == SCHATTR_DATADESCR_SHOW_PERCENTAGE) ? aLabel.ShowNumberInPercent : (
 280                         (nWhichId == SCHATTR_DATADESCR_SHOW_CATEGORY) ? aLabel.ShowCategoryName : aLabel.ShowLegendSymbol));
 281                 bool bOldValue = rValue;
 282                 rValue = rItem.GetValue();
 283                 if (mbDataSeries)
 284                 {
 285                     Reference<chart2::XDataSeries> xSeries(GetPropertySet(), uno::UNO_QUERY);
 286                     if (bOldValue != bool(rValue) ||
 287                         DataSeriesHelper::hasAttributedDataPointDifferentValue(xSeries, CHART_UNONAME_LABEL, aOldValue))
 288                     {
 289                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, CHART_UNONAME_LABEL, uno::Any(aLabel));
 290                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, CHART_UNONAME_CUSTOM_LABEL_FIELDS, uno::Any());
 291                         bChanged = true;
 292                     }
 293                 }
 294                 else if (bOldValue != bool(rValue))
 295                 {
 296                     GetPropertySet()->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
 297                     bChanged = true;
 298                 }
 299             }
 300         }
 301         break;
 302         case SID_ATTR_NUMBERFORMAT_VALUE:
 303         case SCHATTR_PERCENT_NUMBERFORMAT_VALUE:  //fall through intended
 304         {
 305             bChanged = numberFormatFromItemToPropertySet(nWhichId, rItemSet, GetPropertySet(), mbDataSeries);
 306         }
 307         break;
 308         case SID_ATTR_NUMBERFORMAT_SOURCE:
 309         case SCHATTR_PERCENT_NUMBERFORMAT_SOURCE: //fall through intended
 310         {
 311             bChanged = useSourceFormatFromItemToPropertySet(nWhichId, rItemSet, GetPropertySet(), mbDataSeries);
 312         }
 313         break;
 314         case SCHATTR_DATADESCR_SEPARATOR:
 315         {
 316             OUString aNewValue = static_cast<const SfxStringItem&>(rItemSet.Get(nWhichId)).GetValue();
 317             try
 318             {
 319                 OUString aOldValue;
 320                 GetPropertySet()->getPropertyValue("LabelSeparator") >>= aOldValue;
 321                 if (mbDataSeries)
 322                 {
 323                     Reference<chart2::XDataSeries> xSeries(GetPropertySet(), uno::UNO_QUERY);
 324                     if (aOldValue != aNewValue ||
 325                         DataSeriesHelper::hasAttributedDataPointDifferentValue(xSeries, "LabelSeparator", uno::Any(aOldValue)))
 326                     {
 327                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, "LabelSeparator", uno::Any(aNewValue));
 328                         bChanged = true;
 329                     }
 330                 }
 331                 else if (aOldValue != aNewValue)
 332                 {
 333                     GetPropertySet()->setPropertyValue("LabelSeparator", uno::Any(aNewValue));
 334                     bChanged = true;
 335                 }
 336             }
 337             catch (const uno::Exception&)
 338             {
 339                 TOOLS_WARN_EXCEPTION("chart2", "");
 340             }
 341         }
 342         break;
 343         case SCHATTR_DATADESCR_WRAP_TEXT:
 344         {
 345
 346             try
 347             {
 348                 bool bNew = static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
 349                 bool bOld = false;
 350                 GetPropertySet()->getPropertyValue( "TextWordWrap" ) >>= bOld;
 351                 if( mbDataSeries )
 352                 {
 353                     Reference< chart2::XDataSeries > xSeries( GetPropertySet(), uno::UNO_QUERY);
 354                     if( bOld!=bNew ||
 355                         DataSeriesHelper::hasAttributedDataPointDifferentValue( xSeries, "TextWordWrap", uno::Any( bOld ) ) )
 356                     {
 357                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, "TextWordWrap", uno::Any( bNew ) );
 358                         bChanged = true;
 359                     }
 360                 }
 361                 else if( bOld!=bNew )
 362                 {
 363                     GetPropertySet()->setPropertyValue( "TextWordWrap", uno::Any( bNew ));
 364                     bChanged = true;
 365                 }
 366             }
 367             catch( const uno::Exception& )
 368             {
 369                 TOOLS_WARN_EXCEPTION("chart2", "" );
 370             }
 371         }
 372         break;
 373         case SCHATTR_DATADESCR_PLACEMENT:
 374         {
 375             try
 376             {
 377                 sal_Int32 nNew = static_cast<const SfxInt32Item&>(rItemSet.Get(nWhichId)).GetValue();
 378                 sal_Int32 nOld = -1;
 379                 RelativePosition aCustomLabelPosition;
 380                 GetPropertySet()->getPropertyValue("LabelPlacement") >>= nOld;
 381                 if (mbDataSeries)
 382                 {
 383                     Reference<chart2::XDataSeries> xSeries(GetPropertySet(), uno::UNO_QUERY);
 384                     if (nOld != nNew ||
 385                         DataSeriesHelper::hasAttributedDataPointDifferentValue(xSeries, "LabelPlacement", uno::Any(nOld)))
 386                     {
 387                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints(xSeries, "LabelPlacement", uno::Any(nNew));
 388                         bChanged = true;
 389                     }
 390                 }
 391                 else if (nOld != nNew || (GetPropertySet()->getPropertyValue("CustomLabelPosition") >>= aCustomLabelPosition))
 392                 {
 393                     GetPropertySet()->setPropertyValue("LabelPlacement", uno::Any(nNew));
 394                     GetPropertySet()->setPropertyValue("CustomLabelPosition", uno::Any());
 395                     bChanged = true;
 396                 }
 397             }
 398             catch (const uno::Exception&)
 399             {
 400                 TOOLS_WARN_EXCEPTION("chart2", "" );
 401             }
 402         }
 403         break;
 404         case SCHATTR_STYLE_SYMBOL:
 405         {
 406             sal_Int32 nStyle =
 407                 static_cast<const SfxInt32Item&>(
 408                 rItemSet.Get(nWhichId)).GetValue();
 409             chart2::Symbol aSymbol;
 410
 411             GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol;
 412             sal_Int32 nOldStyle = getSymbolStyleForSymbol(aSymbol);
 413
 414             if (nStyle != nOldStyle)
 415             {
 416                 bool bDeleteSymbol = false;
 417                 switch (nStyle)
 418                 {
 419                     case SVX_SYMBOLTYPE_NONE:
 420                         aSymbol.Style = chart2::SymbolStyle_NONE;
 421                         break;
 422                     case SVX_SYMBOLTYPE_AUTO:
 423                         aSymbol.Style = chart2::SymbolStyle_AUTO;
 424                         break;
 425                     case SVX_SYMBOLTYPE_BRUSHITEM:
 426                         aSymbol.Style = chart2::SymbolStyle_GRAPHIC;
 427                         break;
 428                     case SVX_SYMBOLTYPE_UNKNOWN:
 429                         bDeleteSymbol = true;
 430                         break;
 431
 432                     default:
 433                         aSymbol.Style = chart2::SymbolStyle_STANDARD;
 434                         aSymbol.StandardSymbol = nStyle;
 435                 }
 436
 437                 if (bDeleteSymbol)
 438                     GetPropertySet()->setPropertyValue("Symbol", uno::Any());
 439                 else
 440                     GetPropertySet()->setPropertyValue("Symbol", uno::Any(aSymbol));
 441                 bChanged = true;
 442             }
 443         }
 444         break;
 445         case SCHATTR_SYMBOL_SIZE:
 446         {
 447             Size aSize = static_cast<const SvxSizeItem&>(
 448                 rItemSet.Get(nWhichId)).GetSize();
 449             chart2::Symbol aSymbol;
 450
 451             GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol;
 452             if (aSize.getWidth() != aSymbol.Size.Width ||
 453                 aSize.getHeight() != aSymbol.Size.Height)
 454             {
 455                 aSymbol.Size.Width = aSize.getWidth();
 456                 aSymbol.Size.Height = aSize.getHeight();
 457
 458                 GetPropertySet()->setPropertyValue("Symbol", uno::Any(aSymbol));
 459                 bChanged = true;
 460             }
 461         }
 462         break;
 463         case SCHATTR_SYMBOL_BRUSH:
 464         {
 465             const SvxBrushItem& rBrshItem(static_cast<const SvxBrushItem&>(
 466                     rItemSet.Get(nWhichId)));
 467             uno::Any aXGraphicAny;
 468             const Graphic* pGraphic(rBrshItem.GetGraphic());
 469             if (pGraphic)
 470             {
 471                 uno::Reference<graphic::XGraphic> xGraphic(pGraphic->GetXGraphic());
 472                 if (xGraphic.is())
 473                 {
 474                     aXGraphicAny <<= xGraphic;
 475                     chart2::Symbol aSymbol;
 476                     GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol;
 477                     if (aSymbol.Graphic != xGraphic)
 478                     {
 479                         aSymbol.Graphic = xGraphic;
 480                         GetPropertySet()->setPropertyValue("Symbol", uno::Any(aSymbol));
 481                         bChanged = true;
 482                     }
 483                 }
 484             }
 485         }
 486         break;
 487         case SCHATTR_TEXT_DEGREES:
 488         {
 489             double fValue = static_cast<double>(
 490                 static_cast<const SfxInt32Item&>(
 491                     rItemSet.Get(nWhichId)).GetValue()) / 100.0;
 492             double fOldValue = 0.0;
 493             bool bPropExisted =
 494                 (GetPropertySet()->getPropertyValue("TextRotation") >>= fOldValue);
 495
 496             if (!bPropExisted || fOldValue != fValue)
 497             {
 498                 GetPropertySet()->setPropertyValue("TextRotation", uno::Any(fValue));
 499                 bChanged = true;
 500             }
 501         }
 502         break;
 503         case SCHATTR_DATADESCR_CUSTOM_LEADER_LINES:
 504         {
 505             try
 506             {
 507                 bool bNew = static_cast<const SfxBoolItem&>(rItemSet.Get(nWhichId)).GetValue();
 508                 bool bOld = true;
 509                 Reference<beans::XPropertySet> xSeriesProp(m_xSeries, uno::UNO_QUERY);
 510                 if( (xSeriesProp->getPropertyValue("ShowCustomLeaderLines") >>= bOld) && bOld != bNew )
 511                 {
 512                     xSeriesProp->setPropertyValue("ShowCustomLeaderLines", uno::Any(bNew));
 513                     bChanged = true;
 514                 }
 515             }
 516             catch (const uno::Exception&)
 517             {
 518                 TOOLS_WARN_EXCEPTION("chart2", "");
 519             }
 520         }
 521         break;
 522     }
 523
 524     return bChanged;
 525 }
 526
 527 void TextLabelItemConverter::FillSpecialItem( sal_uInt16 nWhichId, SfxItemSet& rOutItemSet ) const
 528 {
 529     switch (nWhichId)
 530     {
 531         case SCHATTR_DATADESCR_SHOW_NUMBER:
 532         case SCHATTR_DATADESCR_SHOW_PERCENTAGE:
 533         case SCHATTR_DATADESCR_SHOW_CATEGORY:
 534         case SCHATTR_DATADESCR_SHOW_SYMBOL:
 535         {
 536             chart2::DataPointLabel aLabel;
 537             if (GetPropertySet()->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel)
 538             {
 539                 bool bValue = (nWhichId == SCHATTR_DATADESCR_SHOW_NUMBER) ? aLabel.ShowNumber : (
 540                     (nWhichId == SCHATTR_DATADESCR_SHOW_PERCENTAGE) ? aLabel.ShowNumberInPercent : (
 541                         (nWhichId == SCHATTR_DATADESCR_SHOW_CATEGORY) ? aLabel.ShowCategoryName : aLabel.ShowLegendSymbol));
 542
 543                 rOutItemSet.Put(SfxBoolItem(nWhichId, bValue));
 544
 545                 if (mbDataSeries)
 546                 {
 547                     if (DataSeriesHelper::hasAttributedDataPointDifferentValue(
 548                             Reference<chart2::XDataSeries>(GetPropertySet(), uno::UNO_QUERY), CHART_UNONAME_LABEL, uno::Any(aLabel)))
 549                     {
 550                         rOutItemSet.InvalidateItem(nWhichId);
 551                     }
 552                 }
 553             }
 554         }
 555         break;
 556         case SID_ATTR_NUMBERFORMAT_VALUE:
 557         {
 558             sal_Int32 nKey = 0;
 559             if (!(GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT) >>= nKey))
 560                 nKey = mnNumberFormat;
 561             rOutItemSet.Put(SfxUInt32Item(nWhichId, nKey));
 562         }
 563         break;
 564         case SCHATTR_PERCENT_NUMBERFORMAT_VALUE:
 565         {
 566             sal_Int32 nKey = 0;
 567             if (!(GetPropertySet()->getPropertyValue("PercentageNumberFormat") >>= nKey))
 568                 nKey = mnPercentNumberFormat;
 569             rOutItemSet.Put(SfxUInt32Item(nWhichId, nKey));
 570         }
 571         break;
 572         case SID_ATTR_NUMBERFORMAT_SOURCE:
 573         {
 574             bool bUseSourceFormat = false;
 575             try
 576             {
 577                 GetPropertySet()->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bUseSourceFormat;
 578             }
 579             catch (const uno::Exception&)
 580             {
 581                 TOOLS_WARN_EXCEPTION("chart2", "");
 582             }
 583             bool bNumberFormatIsSet = GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT).hasValue() && !bUseSourceFormat;
 584             rOutItemSet.Put(SfxBoolItem(nWhichId, !bNumberFormatIsSet));
 585         }
 586         break;
 587         case SCHATTR_PERCENT_NUMBERFORMAT_SOURCE:
 588         {
 589             bool bUseSourceFormat = false;
 590             try
 591             {
 592                 GetPropertySet()->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bUseSourceFormat;
 593             }
 594             catch (const uno::Exception&)
 595             {
 596                 TOOLS_WARN_EXCEPTION("chart2", "");
 597             }
 598             bool bNumberFormatIsSet = GetPropertySet()->getPropertyValue("PercentageNumberFormat").hasValue() && !bUseSourceFormat;
 599             rOutItemSet.Put(SfxBoolItem(nWhichId, !bNumberFormatIsSet));
 600         }
 601         break;
 602         case SCHATTR_DATADESCR_SEPARATOR:
 603         {
 604             try
 605             {
 606                 OUString aValue;
 607                 GetPropertySet()->getPropertyValue("LabelSeparator") >>= aValue;
 608                 rOutItemSet.Put(SfxStringItem(nWhichId, aValue));
 609             }
 610             catch (const uno::Exception&)
 611             {
 612                 TOOLS_WARN_EXCEPTION("chart2", "" );
 613             }
 614         }
 615         break;
 616         case SCHATTR_DATADESCR_WRAP_TEXT:
 617         {
 618             try
 619             {
 620                 bool bValue = false;
 621                 GetPropertySet()->getPropertyValue( "TextWordWrap" ) >>= bValue;
 622                 rOutItemSet.Put( SfxBoolItem( nWhichId, bValue ));
 623             }
 624             catch( const uno::Exception& )
 625             {
 626                 TOOLS_WARN_EXCEPTION("chart2", "" );
 627             }
 628         }
 629         break;
 630         case SCHATTR_DATADESCR_PLACEMENT:
 631         {
 632             try
 633             {
 634                 sal_Int32 nPlacement = 0;
 635                 RelativePosition aCustomLabelPosition;
 636                 if (!mbDataSeries && (GetPropertySet()->getPropertyValue("CustomLabelPosition") >>= aCustomLabelPosition))
 637                     rOutItemSet.Put(SfxInt32Item(nWhichId, css::chart::DataLabelPlacement::CUSTOM));
 638                 else if (GetPropertySet()->getPropertyValue("LabelPlacement") >>= nPlacement)
 639                     rOutItemSet.Put(SfxInt32Item(nWhichId, nPlacement));
 640                 else if (maAvailableLabelPlacements.hasElements())
 641                     rOutItemSet.Put(SfxInt32Item(nWhichId, maAvailableLabelPlacements[0]));
 642             }
 643             catch (const uno::Exception&)
 644             {
 645                 TOOLS_WARN_EXCEPTION("chart2", "" );
 646             }
 647         }
 648         break;
 649         case SCHATTR_DATADESCR_AVAILABLE_PLACEMENTS:
 650         {
 651             rOutItemSet.Put(SfxIntegerListItem(nWhichId, maAvailableLabelPlacements));
 652         }
 653         break;
 654         case SCHATTR_DATADESCR_NO_PERCENTVALUE:
 655         {
 656             rOutItemSet.Put(SfxBoolItem(nWhichId, mbForbidPercentValue));
 657         }
 658         break;
 659         case SCHATTR_DATADESCR_CUSTOM_LEADER_LINES:
 660         {
 661             try
 662             {
 663                 bool bValue = true;
 664                 Reference<beans::XPropertySet> xSeriesProp(m_xSeries, uno::UNO_QUERY);
 665                 if( xSeriesProp->getPropertyValue( "ShowCustomLeaderLines" ) >>= bValue )
 666                     rOutItemSet.Put(SfxBoolItem(nWhichId, bValue));
 667             }
 668             catch (const uno::Exception&)
 669             {
 670                 TOOLS_WARN_EXCEPTION("chart2", "");
 671             }
 672         }
 673         break;
 674         case SCHATTR_STYLE_SYMBOL:
 675         {
 676             chart2::Symbol aSymbol;
 677             if (GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol)
 678                 rOutItemSet.Put(SfxInt32Item(nWhichId, getSymbolStyleForSymbol(aSymbol)));
 679         }
 680         break;
 681         case SCHATTR_SYMBOL_SIZE:
 682         {
 683             chart2::Symbol aSymbol;
 684             if (GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol)
 685                 rOutItemSet.Put(
 686                     SvxSizeItem(nWhichId, Size(aSymbol.Size.Width, aSymbol.Size.Height)));
 687         }
 688         break;
 689         case SCHATTR_SYMBOL_BRUSH:
 690         {
 691             chart2::Symbol aSymbol;
 692             if ((GetPropertySet()->getPropertyValue("Symbol") >>= aSymbol)
 693                 && aSymbol.Graphic.is())
 694             {
 695                 rOutItemSet.Put(
 696                     SvxBrushItem(Graphic(aSymbol.Graphic), GPOS_MM, SCHATTR_SYMBOL_BRUSH));
 697             }
 698         }
 699         break;
 700         case SCHATTR_TEXT_DEGREES:
 701         {
 702             double fValue = 0;
 703
 704             if (GetPropertySet()->getPropertyValue("TextRotation") >>= fValue)
 705             {
 706                 rOutItemSet.Put(
 707                     SfxInt32Item(nWhichId, static_cast<sal_Int32>(rtl::math::round(fValue * 100.0))));
 708             }
 709         }
 710         break;
 711     }
 712 }
 713
 714 }
 715
 716 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */