chart2/source/tools/ObjectIdentifier.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 <sal/config.h>
  21
  22 #include <cstddef>
  23 #include <map>
  24
  25 #include <ObjectIdentifier.hxx>
  26 #include <TitleHelper.hxx>
  27 #include <ChartModel.hxx>
  28 #include <ChartType.hxx>
  29 #include <Axis.hxx>
  30 #include <AxisHelper.hxx>
  31 #include <servicenames_charttypes.hxx>
  32 #include <Diagram.hxx>
  33 #include <unonames.hxx>
  34 #include <BaseCoordinateSystem.hxx>
  35 #include <DataSeries.hxx>
  36 #include <RegressionCurveModel.hxx>
  37
  38 #include <com/sun/star/chart2/XAxis.hpp>
  39 #include <com/sun/star/awt/Point.hpp>
  40 #include <com/sun/star/drawing/XShape.hpp>
  41
  42 #include <rtl/ustrbuf.hxx>
  43 #include <comphelper/diagnose_ex.hxx>
  44 #include <o3tl/safeint.hxx>
  45 #include <o3tl/string_view.hxx>
  46 #include <utility>
  47
  48 namespace com::sun::star::drawing { class XShape; }
  49
  50 namespace chart
  51 {
  52 using namespace ::com::sun::star;
  53 using namespace ::com::sun::star::chart2;
  54
  55 using ::com::sun::star::uno::Reference;
  56 using ::com::sun::star::uno::Any;
  57
  58 constexpr OUString m_aMultiClick = u"MultiClick"_ustr;
  59 constexpr OUString m_aDragMethodEquals = u"DragMethod="_ustr;
  60 constexpr OUString m_aDragParameterEquals = u"DragParameter="_ustr;
  61 constexpr OUString m_aProtocol = u"CID/"_ustr;
  62 constexpr OUString m_aPieSegmentDragMethodServiceName(u"PieSegmentDragging"_ustr);
  63
  64 namespace
  65 {
  66
  67 OUString lcl_createClassificationStringForType( ObjectType eObjectType
  68             , std::u16string_view rDragMethodServiceName
  69             , std::u16string_view rDragParameterString
  70             )
  71 {
  72     OUStringBuffer aRet;
  73     switch( eObjectType )
  74     {
  75         //these object types are all selected only after their parents was selected before
  76         case OBJECTTYPE_LEGEND_ENTRY: //parent is intended to be OBJECTTYPE_LEGEND
  77         case OBJECTTYPE_DATA_POINT: //parent is intended to be OBJECTTYPE_DATA_SERIES
  78         case OBJECTTYPE_DATA_LABEL: //parent is intended to be OBJECTTYPE_DATA_LABELS
  79         case OBJECTTYPE_DATA_ERRORS_X: //parent is intended to be OBJECTTYPE_DATA_ERRORS
  80         case OBJECTTYPE_DATA_ERRORS_Y: //parent is intended to be OBJECTTYPE_DATA_ERRORS
  81         case OBJECTTYPE_DATA_ERRORS_Z: //parent is intended to be OBJECTTYPE_DATA_ERRORS
  82             aRet=m_aMultiClick;
  83             break;
  84         default:
  85             break;//empty string
  86     }
  87     if( !rDragMethodServiceName.empty() )
  88     {
  89         if( !aRet.isEmpty() )
  90             aRet.append(":");
  91         aRet.append( OUString::Concat(m_aDragMethodEquals) + rDragMethodServiceName );
  92
  93         if( !rDragParameterString.empty() )
  94         {
  95             if( !aRet.isEmpty() )
  96                 aRet.append(":");
  97             aRet.append( OUString::Concat(m_aDragParameterEquals) + rDragParameterString );
  98         }
  99     }
 100     return aRet.makeStringAndClear();
 101 }
 102
 103 typedef std::map< TitleHelper::eTitleType, OUString > tTitleMap;
 104 const tTitleMap& lcl_getTitleMap()
 105 {
 106     //maps the title type to the ParentParticle for that title
 107     static tTitleMap s_aTitleMap{
 108         {TitleHelper::MAIN_TITLE, ""},
 109         {TitleHelper::SUB_TITLE, "D=0"},
 110         {TitleHelper::X_AXIS_TITLE, "D=0:CS=0:Axis=0,0"},
 111         {TitleHelper::Y_AXIS_TITLE, "D=0:CS=0:Axis=1,0"},
 112         {TitleHelper::Z_AXIS_TITLE, "D=0:CS=0:Axis=2,0"},
 113         {TitleHelper::SECONDARY_X_AXIS_TITLE, "D=0:CS=0:Axis=0,1"},
 114         {TitleHelper::SECONDARY_Y_AXIS_TITLE, "D=0:CS=0:Axis=1,1"}};
 115     return s_aTitleMap;
 116 }
 117
 118 OUString lcl_getTitleParentParticle( TitleHelper::eTitleType aTitleType )
 119 {
 120     OUString aRet;
 121
 122     const tTitleMap& rMap = lcl_getTitleMap();
 123     tTitleMap::const_iterator aIt( rMap.find( aTitleType ) );
 124     if( aIt != rMap.end())
 125         aRet = (*aIt).second;
 126
 127     return aRet;
 128 }
 129
 130 rtl::Reference<ChartType> lcl_getFirstStockChartType( const rtl::Reference<::chart::ChartModel>& xChartModel )
 131 {
 132     rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
 133     if(!xDiagram.is())
 134         return nullptr;
 135
 136     //iterate through all coordinate systems
 137
 138     const std::vector< rtl::Reference< BaseCoordinateSystem > > aCooSysList( xDiagram->getBaseCoordinateSystems() );
 139     for( rtl::Reference< BaseCoordinateSystem > const & coords : aCooSysList )
 140     {
 141         //iterate through all chart types in the current coordinate system
 142         for( rtl::Reference< ChartType > const & xChartType : coords->getChartTypes2() )
 143         {
 144             OUString aChartType = xChartType->getChartType();
 145             if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK) )
 146                 return xChartType;
 147         }
 148     }
 149     return nullptr;
 150 }
 151
 152 std::u16string_view lcl_getIndexStringAfterString( std::u16string_view rString, std::u16string_view rSearchString )
 153 {
 154     size_t nIndexStart = rString.rfind( rSearchString );
 155     if( nIndexStart == std::u16string_view::npos )
 156         return std::u16string_view();
 157     nIndexStart += rSearchString.size();
 158     size_t nIndexEnd = rString.size();
 159     size_t nNextColon = rString.find( ':', nIndexStart );
 160     if( nNextColon != std::u16string_view::npos )
 161         nIndexEnd = nNextColon;
 162     return rString.substr(nIndexStart,nIndexEnd-nIndexStart);
 163 }
 164
 165 sal_Int32 lcl_StringToIndex( std::u16string_view rIndexString )
 166 {
 167     sal_Int32 nRet = -1;
 168     if( !rIndexString.empty() )
 169     {
 170         nRet = o3tl::toInt32(rIndexString);
 171         if( nRet < -1 )
 172             nRet = -1;
 173     }
 174     return nRet;
 175 }
 176
 177 void lcl_parseCooSysIndices( sal_Int32& rnDiagram, sal_Int32& rnCooSys, std::u16string_view rString )
 178 {
 179     rnDiagram = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u"D=" ) );
 180     rnCooSys = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u"CS=" ) );
 181 }
 182
 183 void lcl_parseAxisIndices( sal_Int32& rnDimensionIndex, sal_Int32& rnAxisIndex, std::u16string_view rString )
 184 {
 185     std::u16string_view aAxisIndexString = lcl_getIndexStringAfterString( rString, u":Axis=" );
 186     sal_Int32 nCharacterIndex=0;
 187     rnDimensionIndex = lcl_StringToIndex( o3tl::getToken(aAxisIndexString, 0, ',', nCharacterIndex ) );
 188     rnAxisIndex = lcl_StringToIndex( o3tl::getToken(aAxisIndexString, 0, ',', nCharacterIndex ) );
 189 }
 190
 191 void lcl_parseGridIndices( sal_Int32& rnSubGridIndex, std::u16string_view rString )
 192 {
 193     rnSubGridIndex = -1;
 194     rnSubGridIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u":SubGrid=" ) );
 195 }
 196
 197 void lcl_parseSeriesIndices( sal_Int32& rnChartTypeIndex, sal_Int32& rnSeriesIndex, sal_Int32& rnPointIndex, std::u16string_view rString )
 198 {
 199     rnChartTypeIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u"CT=" ) );
 200     rnSeriesIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u"Series=" ) );
 201     rnPointIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rString, u"Point=" ) );
 202 }
 203
 204 void lcl_getDiagramAndCooSys( std::u16string_view rObjectCID
 205                 , const rtl::Reference<::chart::ChartModel>& xChartModel
 206                 , rtl::Reference< Diagram >& xDiagram
 207                 , rtl::Reference< BaseCoordinateSystem >& xCooSys )
 208 {
 209     sal_Int32 nDiagramIndex = -1;
 210     sal_Int32 nCooSysIndex = -1;
 211     lcl_parseCooSysIndices( nDiagramIndex, nCooSysIndex, rObjectCID );
 212     xDiagram = xChartModel->getFirstChartDiagram();//todo use nDiagramIndex when more than one diagram is possible in future
 213     if( !xDiagram.is() )
 214         return;
 215
 216     if( nCooSysIndex > -1 )
 217     {
 218         const std::vector< rtl::Reference< BaseCoordinateSystem > > aCooSysList( xDiagram->getBaseCoordinateSystems() );
 219         if( o3tl::make_unsigned(nCooSysIndex) < aCooSysList.size() )
 220             xCooSys = aCooSysList[nCooSysIndex];
 221     }
 222 }
 223
 224 } //anonymous namespace
 225
 226 ObjectIdentifier::ObjectIdentifier()
 227 {
 228 }
 229
 230 ObjectIdentifier::ObjectIdentifier( OUString aObjectCID )
 231     :m_aObjectCID(std::move( aObjectCID ))
 232 {
 233 }
 234
 235 ObjectIdentifier::ObjectIdentifier( const Reference< drawing::XShape >& rxShape )
 236     : m_xAdditionalShape( rxShape )
 237 {
 238 }
 239
 240 ObjectIdentifier::ObjectIdentifier( const Any& rAny )
 241 {
 242     if (rAny.getValueType() == cppu::UnoType<OUString>::get())
 243     {
 244         rAny >>= m_aObjectCID;
 245     }
 246     else
 247     {
 248         rAny >>= m_xAdditionalShape;
 249     }
 250 }
 251
 252 bool ObjectIdentifier::operator==( const ObjectIdentifier& rOID ) const
 253 {
 254     return areIdenticalObjects( m_aObjectCID, rOID.m_aObjectCID ) &&
 255          ( m_xAdditionalShape == rOID.m_xAdditionalShape );
 256 }
 257
 258 bool ObjectIdentifier::operator<( const ObjectIdentifier& rOID ) const
 259 {
 260     bool bReturn = false;
 261     if ( !(m_aObjectCID.isEmpty() || rOID.m_aObjectCID.isEmpty()) )
 262     {
 263         bReturn = ( m_aObjectCID.compareTo( rOID.m_aObjectCID ) < 0 );
 264     }
 265     else if ( !m_aObjectCID.isEmpty() )
 266     {
 267         bReturn = true;
 268     }
 269     else if ( !rOID.m_aObjectCID.isEmpty() )
 270     {
 271         bReturn = false;
 272     }
 273     else if ( m_xAdditionalShape.is() && rOID.m_xAdditionalShape.is() )
 274     {
 275         bReturn = ( m_xAdditionalShape < rOID.m_xAdditionalShape );
 276     }
 277     return bReturn;
 278 }
 279
 280 OUString ObjectIdentifier::createClassifiedIdentifierForObject(
 281           const rtl::Reference< ::chart::Title >& xTitle
 282         , const rtl::Reference<::chart::ChartModel>& xChartModel )
 283 {
 284     TitleHelper::eTitleType aTitleType;
 285     OUString aRet;
 286     const std::u16string_view aObjectID;
 287     const std::u16string_view aDragMethodServiceName;
 288     const std::u16string_view aDragParameterString;
 289     if( TitleHelper::getTitleType( aTitleType, xTitle, xChartModel ) )
 290     {
 291         enum ObjectType eObjectType = OBJECTTYPE_TITLE;
 292         OUString aParentParticle = lcl_getTitleParentParticle( aTitleType );
 293         aRet = ObjectIdentifier::createClassifiedIdentifierWithParent(
 294             eObjectType, aObjectID, aParentParticle, aDragMethodServiceName, aDragParameterString );
 295     }
 296     return aRet;
 297 }
 298
 299 OUString ObjectIdentifier::createClassifiedIdentifierForObject(
 300           const Reference< uno::XInterface >& xObject
 301         , const rtl::Reference<::chart::ChartModel>& xChartModel )
 302 {
 303     OUString aRet;
 304
 305     enum ObjectType eObjectType = OBJECTTYPE_UNKNOWN;
 306     const std::u16string_view aObjectID;
 307     OUString aParentParticle;
 308     const std::u16string_view aDragMethodServiceName;
 309     const std::u16string_view aDragParameterString;
 310
 311     try
 312     {
 313         //title
 314         if( ::chart::Title* pTitle = dynamic_cast<::chart::Title*>(xObject.get()) )
 315             return createClassifiedIdentifierForObject(rtl::Reference<Title>(pTitle), xChartModel);
 316
 317         uno::Reference<chart2::XDataTable> xDataTable(xObject, uno::UNO_QUERY);
 318         if (xDataTable.is())
 319         {
 320             return createClassifiedIdentifierForParticle(createParticleForDataTable(xChartModel));
 321         }
 322
 323         //axis
 324         rtl::Reference< Axis > xAxis = dynamic_cast<Axis*>( xObject.get() );
 325         if( xAxis.is() )
 326         {
 327             rtl::Reference<Diagram> xDiagram = xChartModel->getFirstChartDiagram();
 328             rtl::Reference< BaseCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( xAxis, xDiagram ) );
 329             OUString aCooSysParticle( createParticleForCoordinateSystem( xCooSys, xChartModel ) );
 330             sal_Int32 nDimensionIndex=-1;
 331             sal_Int32 nAxisIndex=-1;
 332             AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex );
 333             OUString aAxisParticle( createParticleForAxis( nDimensionIndex, nAxisIndex ) );
 334             return createClassifiedIdentifierForParticles( aCooSysParticle, aAxisParticle );
 335         }
 336
 337         //legend
 338         Reference< XLegend > xLegend( xObject, uno::UNO_QUERY );
 339         if( xLegend.is() )
 340         {
 341             return createClassifiedIdentifierForParticle( createParticleForLegend( xChartModel ) );
 342         }
 343
 344         //diagram
 345         Reference< XDiagram > xDiagram( xObject, uno::UNO_QUERY );
 346         if( xDiagram.is() )
 347         {
 348             return createClassifiedIdentifierForParticle( createParticleForDiagram() );
 349         }
 350
 351         //todo
 352         //XDataSeries
 353         //CooSys
 354         //charttype
 355         //datapoint?
 356         //Gridproperties
 357     }
 358     catch(const uno::Exception&)
 359     {
 360         DBG_UNHANDLED_EXCEPTION("chart2");
 361     }
 362
 363     if( eObjectType != OBJECTTYPE_UNKNOWN )
 364     {
 365         aRet = ObjectIdentifier::createClassifiedIdentifierWithParent(
 366             eObjectType, aObjectID, aParentParticle, aDragMethodServiceName, aDragParameterString );
 367     }
 368     else
 369     {
 370         OSL_FAIL("give object could not be identified in createClassifiedIdentifierForObject");
 371     }
 372
 373     return aRet;
 374 }
 375
 376 OUString ObjectIdentifier::createClassifiedIdentifierForObject(
 377           const rtl::Reference< Legend >& xLegend
 378         , const rtl::Reference<::chart::ChartModel>& xChartModel )
 379 {
 380     try
 381     {
 382         if( xLegend.is() )
 383         {
 384             return createClassifiedIdentifierForParticle( createParticleForLegend( xChartModel ) );
 385         }
 386     }
 387     catch(const uno::Exception&)
 388     {
 389         DBG_UNHANDLED_EXCEPTION("chart2");
 390     }
 391
 392     OSL_FAIL("give object could not be identified in createClassifiedIdentifierForObject");
 393
 394     return OUString();
 395 }
 396
 397 OUString ObjectIdentifier::createClassifiedIdentifierForObject(
 398           const rtl::Reference<::chart::Axis>& xAxis
 399         , const rtl::Reference<::chart::ChartModel>& xChartModel )
 400 {
 401     try
 402     {
 403         //axis
 404         if( xAxis.is() )
 405         {
 406             rtl::Reference<Diagram> xDiagram = xChartModel->getFirstChartDiagram();
 407             rtl::Reference< BaseCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( xAxis, xDiagram ) );
 408             OUString aCooSysParticle( createParticleForCoordinateSystem( xCooSys, xChartModel ) );
 409             sal_Int32 nDimensionIndex=-1;
 410             sal_Int32 nAxisIndex=-1;
 411             AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex );
 412             OUString aAxisParticle( createParticleForAxis( nDimensionIndex, nAxisIndex ) );
 413             return createClassifiedIdentifierForParticles( aCooSysParticle, aAxisParticle );
 414         }
 415     }
 416     catch(const uno::Exception&)
 417     {
 418         DBG_UNHANDLED_EXCEPTION("chart2");
 419     }
 420
 421     OSL_FAIL("give object could not be identified in createClassifiedIdentifierForObject");
 422
 423     return OUString();
 424 }
 425
 426 OUString ObjectIdentifier::createClassifiedIdentifierForParticle(
 427          std::u16string_view rParticle )
 428 {
 429     return ObjectIdentifier::createClassifiedIdentifierForParticles( rParticle, u"" );
 430 }
 431
 432 OUString ObjectIdentifier::createClassifiedIdentifierForParticles(
 433             std::u16string_view rParentParticle
 434           , std::u16string_view rChildParticle
 435           , std::u16string_view rDragMethodServiceName
 436           , std::u16string_view rDragParameterString )
 437 {
 438     ObjectType eObjectType( ObjectIdentifier::getObjectType( rChildParticle ) );
 439     if( eObjectType == OBJECTTYPE_UNKNOWN )
 440         eObjectType = ObjectIdentifier::getObjectType( rParentParticle );
 441
 442     OUStringBuffer aRet( m_aProtocol +
 443         lcl_createClassificationStringForType( eObjectType, rDragMethodServiceName, rDragParameterString ));
 444     if(aRet.getLength() > m_aProtocol.getLength())
 445         aRet.append("/");
 446
 447     if(!rParentParticle.empty())
 448     {
 449         aRet.append(rParentParticle);
 450         if( !rChildParticle.empty() )
 451             aRet.append(":");
 452     }
 453     aRet.append(rChildParticle);
 454
 455     return aRet.makeStringAndClear();
 456 }
 457
 458 OUString ObjectIdentifier::createParticleForDiagram()
 459 {
 460     //TODO: if more than one diagram is implemented, add the correct diagram index here
 461     return u"D=0"_ustr;
 462 }
 463
 464 OUString ObjectIdentifier::createParticleForCoordinateSystem(
 465           const rtl::Reference< BaseCoordinateSystem >& xCooSys
 466         , const rtl::Reference<::chart::ChartModel>& xChartModel )
 467 {
 468     OUString aRet;
 469
 470     rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
 471     if( xDiagram.is() )
 472     {
 473         std::size_t nCooSysIndex = 0;
 474         const std::vector< rtl::Reference< BaseCoordinateSystem > > aCooSysList( xDiagram->getBaseCoordinateSystems() );
 475         for( ; nCooSysIndex < aCooSysList.size(); ++nCooSysIndex )
 476         {
 477             if( xCooSys == aCooSysList[nCooSysIndex] )
 478             {
 479                 aRet = ObjectIdentifier::createParticleForDiagram() + ":CS=" + OUString::number( nCooSysIndex );
 480                 break;
 481             }
 482         }
 483     }
 484
 485     return aRet;
 486 }
 487
 488 OUString ObjectIdentifier::createParticleForAxis(
 489             sal_Int32 nDimensionIndex
 490           , sal_Int32 nAxisIndex )
 491 {
 492     return "Axis=" +
 493         OUString::number( nDimensionIndex ) +
 494         "," +
 495         OUString::number( nAxisIndex );
 496 }
 497
 498 OUString ObjectIdentifier::createParticleForGrid(
 499             sal_Int32 nDimensionIndex
 500           , sal_Int32 nAxisIndex )
 501 {
 502     OUString aRet = "Axis=" + OUString::number( nDimensionIndex )
 503                   + "," + OUString::number( nAxisIndex ) + ":Grid=0";
 504
 505     return aRet;
 506 }
 507
 508 OUString ObjectIdentifier::createClassifiedIdentifierForGrid(
 509           const Reference< XAxis >& xAxis
 510         , const rtl::Reference<::chart::ChartModel>& xChartModel
 511         , sal_Int32 nSubGridIndex )
 512 {
 513     //-1: main grid, 0: first subgrid etc
 514
 515     OUString aAxisCID( createClassifiedIdentifierForObject( xAxis, xChartModel ) );
 516     OUString aGridCID( addChildParticle( aAxisCID
 517         , createChildParticleWithIndex( OBJECTTYPE_GRID, 0 ) ) );
 518     if( nSubGridIndex >= 0 )
 519     {
 520         aGridCID = addChildParticle( aGridCID
 521             , createChildParticleWithIndex( OBJECTTYPE_SUBGRID, 0 ) );
 522     }
 523     return aGridCID;
 524 }
 525
 526 OUString ObjectIdentifier::createParticleForSeries(
 527               sal_Int32 nDiagramIndex, sal_Int32 nCooSysIndex
 528             , sal_Int32 nChartTypeIndex, sal_Int32 nSeriesIndex )
 529 {
 530     return
 531         "D=" + OUString::number( nDiagramIndex ) +
 532         ":CS=" + OUString::number( nCooSysIndex ) +
 533         ":CT=" + OUString::number( nChartTypeIndex ) +
 534         ":" + getStringForType( OBJECTTYPE_DATA_SERIES ) + "=" +
 535         OUString::number( nSeriesIndex );
 536 }
 537
 538
 539 OUString ObjectIdentifier::createParticleForLegend(
 540         const rtl::Reference<::chart::ChartModel>& )
 541 {
 542     //todo: if more than one diagram is implemented, find the correct diagram which is owner of the given legend
 543
 544     return ObjectIdentifier::createParticleForDiagram() + ":" + getStringForType( OBJECTTYPE_LEGEND ) + "=";
 545 }
 546
 547 OUString ObjectIdentifier::createParticleForDataTable(const rtl::Reference<::chart::ChartModel>& /* xChartModel */)
 548 {
 549     return ObjectIdentifier::createParticleForDiagram() + ":" + getStringForType(OBJECTTYPE_DATA_TABLE) + "=";
 550 }
 551
 552 OUString ObjectIdentifier::createClassifiedIdentifier(
 553         enum ObjectType eObjectType //e.g. OBJECTTYPE_DATA_SERIES
 554         , std::u16string_view rParticleID )//e.g. SeriesID
 555 {
 556     return createClassifiedIdentifierWithParent(
 557         eObjectType, rParticleID, u"" );
 558 }
 559
 560 OUString ObjectIdentifier::createClassifiedIdentifierWithParent(
 561         enum ObjectType eObjectType //e.g. OBJECTTYPE_DATA_POINT or OBJECTTYPE_GRID
 562         , std::u16string_view rParticleID //e.g. Point Index or SubGrid Index
 563         , std::u16string_view rParentPartical //e.g. "Series=SeriesID" or "Grid=GridId"
 564         , std::u16string_view rDragMethodServiceName
 565         , std::u16string_view rDragParameterString
 566         )
 567         //, bool bIsMultiClickObject ) //e.g. true
 568 {
 569     //e.g. "MultiClick/Series=2:Point=34"
 570
 571     OUStringBuffer aRet( m_aProtocol +
 572         lcl_createClassificationStringForType( eObjectType, rDragMethodServiceName, rDragParameterString ));
 573     if(aRet.getLength() > m_aProtocol.getLength())
 574         aRet.append("/");
 575     aRet.append(rParentPartical);
 576     if(!rParentPartical.empty())
 577         aRet.append(":");
 578
 579     aRet.append(getStringForType( eObjectType ) + "=" + rParticleID);
 580
 581     return aRet.makeStringAndClear();
 582 }
 583
 584 const OUString& ObjectIdentifier::getPieSegmentDragMethodServiceName()
 585 {
 586     return m_aPieSegmentDragMethodServiceName;
 587 }
 588
 589 OUString ObjectIdentifier::createPieSegmentDragParameterString(
 590           sal_Int32 nOffsetPercent
 591         , const awt::Point& rMinimumPosition
 592         , const awt::Point& rMaximumPosition )
 593 {
 594     OUString aRet = OUString::number( nOffsetPercent )
 595                   + "," + OUString::number( rMinimumPosition.X )
 596                   + "," + OUString::number( rMinimumPosition.Y )
 597                   + "," + OUString::number( rMaximumPosition.X )
 598                   + "," + OUString::number( rMaximumPosition.Y );
 599     return aRet;
 600 }
 601
 602 bool ObjectIdentifier::parsePieSegmentDragParameterString(
 603           std::u16string_view rDragParameterString
 604         , sal_Int32& rOffsetPercent
 605         , awt::Point& rMinimumPosition
 606         , awt::Point& rMaximumPosition )
 607 {
 608     sal_Int32 nCharacterIndex = 0;
 609
 610     std::u16string_view aValueString( o3tl::getToken(rDragParameterString, 0, ',', nCharacterIndex ) );
 611     rOffsetPercent = o3tl::toInt32(aValueString);
 612     if( nCharacterIndex < 0 )
 613         return false;
 614
 615     aValueString = o3tl::getToken(rDragParameterString, 0, ',', nCharacterIndex );
 616     rMinimumPosition.X = o3tl::toInt32(aValueString);
 617     if( nCharacterIndex < 0 )
 618         return false;
 619
 620     aValueString = o3tl::getToken(rDragParameterString, 0, ',', nCharacterIndex );
 621     rMinimumPosition.Y = o3tl::toInt32(aValueString);
 622     if( nCharacterIndex < 0 )
 623         return false;
 624
 625     aValueString = o3tl::getToken(rDragParameterString, 0, ',', nCharacterIndex );
 626     rMaximumPosition.X = o3tl::toInt32(aValueString);
 627     if( nCharacterIndex < 0 )
 628         return false;
 629
 630     aValueString = o3tl::getToken(rDragParameterString, 0, ',', nCharacterIndex );
 631     rMaximumPosition.Y = o3tl::toInt32(aValueString);
 632     return nCharacterIndex >= 0;
 633 }
 634
 635 std::u16string_view ObjectIdentifier::getDragMethodServiceName( std::u16string_view rCID )
 636 {
 637     std::u16string_view aRet;
 638
 639     size_t nIndexStart = rCID.find( m_aDragMethodEquals );
 640     if( nIndexStart != std::u16string_view::npos )
 641     {
 642         nIndexStart = rCID.find( '=', nIndexStart );
 643         if( nIndexStart != std::u16string_view::npos )
 644         {
 645             nIndexStart++;
 646             size_t nNextSlash = rCID.find( '/', nIndexStart );
 647             if( nNextSlash != std::u16string_view::npos )
 648             {
 649                 sal_Int32 nIndexEnd = nNextSlash;
 650                 size_t nNextColon = rCID.find( ':', nIndexStart );
 651                 if( nNextColon == std::u16string_view::npos || nNextColon < nNextSlash )
 652                     nIndexEnd = nNextColon;
 653                 aRet = rCID.substr(nIndexStart,nIndexEnd-nIndexStart);
 654             }
 655         }
 656     }
 657     return aRet;
 658 }
 659
 660 std::u16string_view ObjectIdentifier::getDragParameterString( std::u16string_view rCID )
 661 {
 662     std::u16string_view aRet;
 663
 664     size_t nIndexStart = rCID.find( m_aDragParameterEquals );
 665     if( nIndexStart != std::u16string_view::npos )
 666     {
 667         nIndexStart = rCID.find( '=', nIndexStart );
 668         if( nIndexStart != std::u16string_view::npos )
 669         {
 670             nIndexStart++;
 671             size_t nNextSlash = rCID.find( '/', nIndexStart );
 672             if( nNextSlash != std::u16string_view::npos )
 673             {
 674                 sal_Int32 nIndexEnd = nNextSlash;
 675                 size_t nNextColon = rCID.find( ':', nIndexStart );
 676                 if( nNextColon == std::u16string_view::npos || nNextColon < nNextSlash )
 677                     nIndexEnd = nNextColon;
 678                 aRet = rCID.substr(nIndexStart,nIndexEnd-nIndexStart);
 679             }
 680         }
 681     }
 682     return aRet;
 683 }
 684
 685 bool ObjectIdentifier::isDragableObject( std::u16string_view rClassifiedIdentifier )
 686 {
 687     bool bReturn = false;
 688     ObjectType eObjectType = ObjectIdentifier::getObjectType( rClassifiedIdentifier );
 689     switch( eObjectType )
 690     {
 691         case OBJECTTYPE_TITLE:
 692         case OBJECTTYPE_LEGEND:
 693         case OBJECTTYPE_DIAGRAM:
 694         case OBJECTTYPE_DATA_LABEL:
 695         case OBJECTTYPE_DATA_CURVE_EQUATION:
 696         //case OBJECTTYPE_DIAGRAM_WALL:
 697             bReturn = true;
 698             break;
 699         default:
 700             std::u16string_view aDragMethodServiceName( ObjectIdentifier::getDragMethodServiceName( rClassifiedIdentifier ) );
 701             bReturn = !aDragMethodServiceName.empty();
 702             break;
 703     }
 704     return bReturn;
 705 }
 706
 707 bool ObjectIdentifier::isDragableObject() const
 708 {
 709     bool bReturn = false;
 710     if ( isAutoGeneratedObject() )
 711     {
 712         bReturn = isDragableObject( m_aObjectCID );
 713     }
 714     else if ( isAdditionalShape() )
 715     {
 716         bReturn = true;
 717     }
 718     return bReturn;
 719 }
 720
 721 bool ObjectIdentifier::isRotateableObject( std::u16string_view rClassifiedIdentifier )
 722 {
 723     bool bReturn = false;
 724     ObjectType eObjectType = ObjectIdentifier::getObjectType( rClassifiedIdentifier );
 725     switch( eObjectType )
 726     {
 727         case OBJECTTYPE_DIAGRAM:
 728         //case OBJECTTYPE_DIAGRAM_WALL:
 729             bReturn = true;
 730             break;
 731         default:
 732             bReturn = false;
 733             break;
 734     }
 735     return bReturn;
 736 }
 737
 738 bool ObjectIdentifier::isMultiClickObject( std::u16string_view rClassifiedIdentifier )
 739 {
 740     //the name of a shape is it's ClassifiedIdentifier
 741
 742     //a MultiClickObject is an object that is selectable by more than one click only ;
 743     //before a MultiClickObject can be selected it is necessary that a named parent group object
 744     //was selected before;
 745
 746     //!!!!! by definition the name of a MultiClickObject starts with "CID/MultiClick:"
 747     bool bRet = o3tl::starts_with(rClassifiedIdentifier.substr( m_aProtocol.getLength() ), m_aMultiClick);
 748     return bRet;
 749 }
 750
 751 bool ObjectIdentifier::areSiblings( std::u16string_view rCID1, std::u16string_view rCID2 )
 752 {
 753     bool bRet=false;
 754     size_t nLastSign1 = rCID1.rfind( '=' );
 755     size_t nLastSign2 = rCID2.rfind( '=' );
 756     if( nLastSign1 == rCID1.find( '=' ) )//CID cannot be sibling if only one "=" occurs
 757         bRet=false;
 758     else if( nLastSign2 == rCID2.find( '=' ) )//CID cannot be sibling if only one "=" occurs
 759         bRet=false;
 760     else if( ObjectIdentifier::areIdenticalObjects( rCID1, rCID2 ) )
 761         bRet=false;
 762     else
 763     {
 764         std::u16string_view aParent1( ObjectIdentifier::getFullParentParticle( rCID1 ) );
 765         if( !aParent1.empty() )
 766         {
 767             std::u16string_view aParent2( ObjectIdentifier::getFullParentParticle( rCID2 ) );
 768             bRet=aParent1 == aParent2;
 769         }
 770         //legend entries are special:
 771         if(!bRet)
 772         {
 773             if( getObjectType(rCID1) == OBJECTTYPE_LEGEND_ENTRY
 774                 && getObjectType(rCID2) == OBJECTTYPE_LEGEND_ENTRY )
 775                 bRet = true;
 776         }
 777     }
 778     return bRet;
 779 }
 780
 781 bool ObjectIdentifier::areIdenticalObjects( std::u16string_view rCID1, std::u16string_view rCID2 )
 782 {
 783     if( rCID1 == rCID2 )
 784         return true;
 785     //draggable pie or donut segments need special treatment, as their CIDs do change with offset
 786     {
 787         if( rCID1.find( m_aPieSegmentDragMethodServiceName ) == std::u16string_view::npos
 788             || rCID2.find( m_aPieSegmentDragMethodServiceName ) == std::u16string_view::npos )
 789             return false;
 790
 791         OUString aID1( ObjectIdentifier::getObjectID( rCID1 ) );
 792         OUString aID2( ObjectIdentifier::getObjectID( rCID2 ) );
 793         if( !aID1.isEmpty() &&  aID1 == aID2 )
 794             return true;
 795         }
 796     return false;
 797 }
 798
 799 OUString ObjectIdentifier::getStringForType( ObjectType eObjectType )
 800 {
 801     OUString aRet;
 802     switch( eObjectType )
 803     {
 804         case OBJECTTYPE_PAGE:
 805                 aRet="Page";
 806                 break;
 807         case OBJECTTYPE_TITLE:
 808                 aRet="Title";
 809                 break;
 810         case OBJECTTYPE_LEGEND:
 811                 aRet="Legend";
 812                 break;
 813         case OBJECTTYPE_LEGEND_ENTRY:
 814                 aRet="LegendEntry";
 815                 break;
 816         case OBJECTTYPE_DIAGRAM:
 817                 aRet="D";
 818                 break;
 819         case OBJECTTYPE_DIAGRAM_WALL:
 820                 aRet="DiagramWall";
 821                 break;
 822         case OBJECTTYPE_DIAGRAM_FLOOR:
 823                 aRet="DiagramFloor";
 824                 break;
 825         case OBJECTTYPE_AXIS:
 826                 aRet="Axis";
 827                 break;
 828         case OBJECTTYPE_AXIS_UNITLABEL:
 829                 aRet="AxisUnitLabel";
 830                 break;
 831         case OBJECTTYPE_GRID:
 832                 aRet="Grid";
 833                 break;
 834         case OBJECTTYPE_SUBGRID:
 835                 aRet="SubGrid";
 836                 break;
 837         case OBJECTTYPE_DATA_SERIES:
 838                 aRet="Series";
 839                 break;
 840         case OBJECTTYPE_DATA_POINT:
 841                 aRet="Point";
 842                 break;
 843         case OBJECTTYPE_DATA_LABELS:
 844                 aRet="DataLabels";
 845                 break;
 846         case OBJECTTYPE_DATA_LABEL:
 847                 aRet="DataLabel";
 848                 break;
 849         case OBJECTTYPE_DATA_ERRORS_X:
 850                 aRet="ErrorsX";
 851                 break;
 852         case OBJECTTYPE_DATA_ERRORS_Y:
 853                 aRet="ErrorsY";
 854                 break;
 855         case OBJECTTYPE_DATA_ERRORS_Z:
 856                 aRet="ErrorsZ";
 857                 break;
 858         case OBJECTTYPE_DATA_CURVE:
 859                 aRet="Curve";
 860                 break;
 861         case OBJECTTYPE_DATA_CURVE_EQUATION:
 862                 aRet="Equation";
 863                 break;
 864         case OBJECTTYPE_DATA_AVERAGE_LINE:
 865                 aRet="Average";
 866                 break;
 867         case OBJECTTYPE_DATA_STOCK_RANGE:
 868                 aRet="StockRange";
 869                 break;
 870         case OBJECTTYPE_DATA_STOCK_LOSS:
 871                 aRet="StockLoss";
 872                 break;
 873         case OBJECTTYPE_DATA_STOCK_GAIN:
 874                 aRet="StockGain";
 875                 break;
 876         case OBJECTTYPE_DATA_TABLE:
 877                 aRet="DataTable";
 878                 break;
 879         default: //OBJECTTYPE_UNKNOWN
 880             ;
 881     }
 882     return aRet;
 883 }
 884
 885 ObjectType ObjectIdentifier::getObjectType( std::u16string_view aCID )
 886 {
 887     ObjectType eRet;
 888     size_t nLastSign = aCID.rfind( ':' );//last sign before the type string
 889     if(nLastSign == std::u16string_view::npos)
 890         nLastSign = aCID.rfind( '/' );
 891     if(nLastSign == std::u16string_view::npos)
 892     {
 893         size_t nEndIndex = aCID.rfind( '=' );
 894         if(nEndIndex == std::u16string_view::npos)
 895             return OBJECTTYPE_UNKNOWN;
 896         nLastSign = 0;
 897     }
 898     if( nLastSign>0 )
 899         nLastSign++;
 900
 901     aCID = aCID.substr(nLastSign);
 902     if( o3tl::starts_with(aCID, u"Page") )
 903         eRet = OBJECTTYPE_PAGE;
 904     else if( o3tl::starts_with(aCID, u"Title") )
 905         eRet = OBJECTTYPE_TITLE;
 906     else if( o3tl::starts_with(aCID, u"LegendEntry") )
 907         eRet = OBJECTTYPE_LEGEND_ENTRY;
 908     else if( o3tl::starts_with(aCID, u"Legend") )
 909         eRet = OBJECTTYPE_LEGEND;
 910     else if( o3tl::starts_with(aCID, u"DiagramWall") )
 911         eRet = OBJECTTYPE_DIAGRAM_WALL;
 912     else if( o3tl::starts_with(aCID, u"DiagramFloor") )
 913         eRet = OBJECTTYPE_DIAGRAM_FLOOR;
 914     else if( o3tl::starts_with(aCID, u"D=") )
 915         eRet = OBJECTTYPE_DIAGRAM;
 916     else if( o3tl::starts_with(aCID, u"AxisUnitLabel") )
 917         eRet = OBJECTTYPE_AXIS_UNITLABEL;
 918     else if( o3tl::starts_with(aCID, u"Axis") )
 919         eRet = OBJECTTYPE_AXIS;
 920     else if( o3tl::starts_with(aCID, u"Grid") )
 921         eRet = OBJECTTYPE_GRID;
 922     else if( o3tl::starts_with(aCID, u"SubGrid") )
 923         eRet = OBJECTTYPE_SUBGRID;
 924     else if( o3tl::starts_with(aCID, u"Series") )
 925         eRet = OBJECTTYPE_DATA_SERIES;
 926     else if( o3tl::starts_with(aCID, u"Point") )
 927         eRet = OBJECTTYPE_DATA_POINT;
 928     else if( o3tl::starts_with(aCID, u"DataLabels") )
 929         eRet = OBJECTTYPE_DATA_LABELS;
 930     else if( o3tl::starts_with(aCID, u"DataLabel") )
 931         eRet = OBJECTTYPE_DATA_LABEL;
 932     else if( o3tl::starts_with(aCID, u"ErrorsX") )
 933         eRet = OBJECTTYPE_DATA_ERRORS_X;
 934     else if( o3tl::starts_with(aCID, u"ErrorsY") )
 935         eRet = OBJECTTYPE_DATA_ERRORS_Y;
 936     else if( o3tl::starts_with(aCID, u"ErrorsZ") )
 937         eRet = OBJECTTYPE_DATA_ERRORS_Z;
 938     else if( o3tl::starts_with(aCID, u"Curve") )
 939         eRet = OBJECTTYPE_DATA_CURVE;
 940     else if( o3tl::starts_with(aCID, u"Equation") )
 941         eRet = OBJECTTYPE_DATA_CURVE_EQUATION;
 942     else if( o3tl::starts_with(aCID, u"Average") )
 943         eRet = OBJECTTYPE_DATA_AVERAGE_LINE;
 944     else if( o3tl::starts_with(aCID, u"StockRange") )
 945         eRet = OBJECTTYPE_DATA_STOCK_RANGE;
 946     else if( o3tl::starts_with(aCID, u"StockLoss") )
 947         eRet = OBJECTTYPE_DATA_STOCK_LOSS;
 948     else if( o3tl::starts_with(aCID, u"StockGain") )
 949         eRet = OBJECTTYPE_DATA_STOCK_GAIN;
 950     else if( o3tl::starts_with(aCID, u"DataTable") )
 951         eRet = OBJECTTYPE_DATA_TABLE;
 952     else
 953         eRet = OBJECTTYPE_UNKNOWN;
 954
 955     return eRet;
 956 }
 957
 958 ObjectType ObjectIdentifier::getObjectType() const
 959 {
 960     ObjectType eObjectType( OBJECTTYPE_UNKNOWN );
 961     if ( isAutoGeneratedObject() )
 962     {
 963         eObjectType = getObjectType( m_aObjectCID );
 964     }
 965     else if ( isAdditionalShape() )
 966     {
 967         eObjectType = OBJECTTYPE_SHAPE;
 968     }
 969     return eObjectType;
 970 }
 971
 972 OUString ObjectIdentifier::createDataCurveCID(
 973                                 std::u16string_view rSeriesParticle
 974                                 , sal_Int32 nCurveIndex
 975                                 , bool bAverageLine )
 976 {
 977     OUString aParticleID( OUString::number( nCurveIndex ) );
 978     ObjectType eType = bAverageLine ? OBJECTTYPE_DATA_AVERAGE_LINE : OBJECTTYPE_DATA_CURVE;
 979     return createClassifiedIdentifierWithParent( eType, aParticleID, rSeriesParticle );
 980 }
 981
 982 OUString ObjectIdentifier::createDataCurveEquationCID(
 983                                 std::u16string_view rSeriesParticle
 984                                 , sal_Int32 nCurveIndex )
 985 {
 986     OUString aParticleID( OUString::number( nCurveIndex ) );
 987     return createClassifiedIdentifierWithParent( OBJECTTYPE_DATA_CURVE_EQUATION, aParticleID, rSeriesParticle );
 988 }
 989
 990 OUString ObjectIdentifier::addChildParticle( std::u16string_view rParticle, std::u16string_view rChildParticle )
 991 {
 992     OUStringBuffer aRet(rParticle);
 993
 994     if( !aRet.isEmpty() && !rChildParticle.empty() )
 995         aRet.append(":");
 996     if( !rChildParticle.empty() )
 997         aRet.append(rChildParticle);
 998
 999     return aRet.makeStringAndClear();
1000 }
1001
1002 OUString ObjectIdentifier::createChildParticleWithIndex( ObjectType eObjectType, sal_Int32 nIndex )
1003 {
1004     OUStringBuffer aRet( getStringForType( eObjectType ) );
1005     if( !aRet.isEmpty() )
1006     {
1007         aRet.append("=" + OUString::number(nIndex));
1008     }
1009     return aRet.makeStringAndClear();
1010 }
1011
1012 sal_Int32 ObjectIdentifier::getIndexFromParticleOrCID( std::u16string_view rParticleOrCID )
1013 {
1014     const std::u16string_view aIndexString = lcl_getIndexStringAfterString( rParticleOrCID, u"=" );
1015     return lcl_StringToIndex( o3tl::getToken(aIndexString, 0, ',' ) );
1016 }
1017
1018 OUString ObjectIdentifier::createSeriesSubObjectStub( ObjectType eSubObjectType
1019                     , std::u16string_view rSeriesParticle
1020                     , std::u16string_view rDragMethodServiceName
1021                     , std::u16string_view rDragParameterString )
1022 {
1023     OUString aChildParticle = getStringForType( eSubObjectType ) + "=";
1024
1025     return createClassifiedIdentifierForParticles(
1026             rSeriesParticle, aChildParticle
1027           , rDragMethodServiceName, rDragParameterString );
1028 }
1029
1030 OUString ObjectIdentifier::createPointCID( std::u16string_view rPointCID_Stub, sal_Int32 nIndex  )
1031 {
1032     return rPointCID_Stub + OUString::number( nIndex );
1033 }
1034
1035 std::u16string_view ObjectIdentifier::getParticleID( std::u16string_view rCID )
1036 {
1037     std::u16string_view aRet;
1038     size_t nLast = rCID.rfind('=');
1039     if(nLast != std::u16string_view::npos)
1040         aRet = rCID.substr(++nLast);
1041     return aRet;
1042 }
1043
1044 std::u16string_view ObjectIdentifier::getFullParentParticle( std::u16string_view rCID )
1045 {
1046     std::u16string_view aRet;
1047
1048     size_t nStartPos = rCID.rfind('/');
1049     if( nStartPos != std::u16string_view::npos )
1050     {
1051         nStartPos++;
1052         size_t nEndPos = rCID.rfind(':');
1053         if( nEndPos != std::u16string_view::npos && nStartPos < nEndPos )
1054         {
1055             aRet = rCID.substr(nStartPos,nEndPos-nStartPos);
1056         }
1057     }
1058
1059     return aRet;
1060 }
1061
1062 OUString ObjectIdentifier::getObjectID( std::u16string_view rCID )
1063 {
1064     OUString aRet;
1065
1066     size_t nStartPos = rCID.rfind('/');
1067     if( nStartPos != std::u16string_view::npos )
1068     {
1069         nStartPos++;
1070         size_t nEndPos = rCID.size();
1071         aRet = rCID.substr(nStartPos,nEndPos-nStartPos);
1072     }
1073
1074     return aRet;
1075 }
1076
1077 bool ObjectIdentifier::isCID( std::u16string_view rName )
1078 {
1079     return !rName.empty() && o3tl::starts_with( rName, m_aProtocol );
1080 }
1081
1082 Reference< beans::XPropertySet > ObjectIdentifier::getObjectPropertySet(
1083                 std::u16string_view rObjectCID
1084                 , const rtl::Reference<::chart::ChartModel>& xChartModel )
1085 {
1086     //return the model object that is indicated by rObjectCID
1087     if(rObjectCID.empty())
1088         return nullptr;
1089     if(!xChartModel.is())
1090         return nullptr;
1091
1092     Reference< beans::XPropertySet > xObjectProperties;
1093     try
1094     {
1095         ObjectType eObjectType = ObjectIdentifier::getObjectType( rObjectCID );
1096         std::u16string_view aParticleID = ObjectIdentifier::getParticleID( rObjectCID );
1097
1098         rtl::Reference< Diagram > xDiagram;
1099         rtl::Reference< BaseCoordinateSystem > xCooSys;
1100         lcl_getDiagramAndCooSys( rObjectCID, xChartModel, xDiagram, xCooSys );
1101
1102         switch(eObjectType)
1103         {
1104             case OBJECTTYPE_PAGE:
1105                 {
1106                     xObjectProperties.set( xChartModel->getPageBackground() );
1107                 }
1108                 break;
1109             case OBJECTTYPE_TITLE:
1110                 {
1111                     TitleHelper::eTitleType aTitleType = getTitleTypeForCID( rObjectCID );
1112                     rtl::Reference< Title > xTitle( TitleHelper::getTitle( aTitleType, xChartModel ) );
1113                     xObjectProperties = xTitle;
1114                 }
1115                 break;
1116             case OBJECTTYPE_LEGEND:
1117                 {
1118                     if( xDiagram.is() )
1119                         xObjectProperties.set( xDiagram->getLegend(), uno::UNO_QUERY );
1120                 }
1121                 break;
1122             case OBJECTTYPE_LEGEND_ENTRY:
1123                     break;
1124             case OBJECTTYPE_DIAGRAM:
1125                 {
1126                     xObjectProperties = xDiagram;
1127                 }
1128                 break;
1129             case OBJECTTYPE_DIAGRAM_WALL:
1130                 {
1131                     if( xDiagram.is() )
1132                         xObjectProperties.set( xDiagram->getWall() );
1133                 }
1134                 break;
1135             case OBJECTTYPE_DIAGRAM_FLOOR:
1136                 {
1137                     if( xDiagram.is() )
1138                         xObjectProperties.set( xDiagram->getFloor() );
1139                 }
1140                 break;
1141             case OBJECTTYPE_AXIS:
1142                 {
1143                     sal_Int32 nDimensionIndex = -1;
1144                     sal_Int32 nAxisIndex = -1;
1145                     lcl_parseAxisIndices( nDimensionIndex, nAxisIndex, rObjectCID );
1146
1147                     rtl::Reference< Axis > xAxis =
1148                         AxisHelper::getAxis( nDimensionIndex, nAxisIndex, xCooSys );
1149                     if( xAxis.is() )
1150                         xObjectProperties = xAxis;
1151                 }
1152                 break;
1153             case OBJECTTYPE_AXIS_UNITLABEL:
1154                     break;
1155             case OBJECTTYPE_GRID:
1156             case OBJECTTYPE_SUBGRID:
1157                 {
1158                     sal_Int32 nDimensionIndex = -1;
1159                     sal_Int32 nAxisIndex = -1;
1160                     lcl_parseAxisIndices( nDimensionIndex, nAxisIndex, rObjectCID );
1161
1162                     sal_Int32 nSubGridIndex = -1;
1163                     lcl_parseGridIndices( nSubGridIndex, rObjectCID );
1164
1165                     xObjectProperties = AxisHelper::getGridProperties( xCooSys , nDimensionIndex, nAxisIndex, nSubGridIndex );
1166                 }
1167                 break;
1168             case OBJECTTYPE_DATA_LABELS:
1169             case OBJECTTYPE_DATA_SERIES:
1170                 {
1171                     rtl::Reference< DataSeries > xSeries( ObjectIdentifier::getDataSeriesForCID(
1172                         rObjectCID, xChartModel ) );
1173                     if( xSeries.is() )
1174                         xObjectProperties = xSeries;
1175
1176                     break;
1177                 }
1178             case OBJECTTYPE_DATA_LABEL:
1179             case OBJECTTYPE_DATA_POINT:
1180                 {
1181                     rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID(
1182                         rObjectCID, xChartModel );
1183                     if(xSeries.is())
1184                     {
1185                         sal_Int32 nIndex = o3tl::toInt32(aParticleID);
1186                         xObjectProperties = xSeries->getDataPointByIndex( nIndex );
1187                     }
1188                     break;
1189                 }
1190             case OBJECTTYPE_DATA_ERRORS_X:
1191             case OBJECTTYPE_DATA_ERRORS_Y:
1192             case OBJECTTYPE_DATA_ERRORS_Z:
1193                 {
1194                     rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID(
1195                         rObjectCID, xChartModel );
1196                     if(xSeries.is())
1197                     {
1198                         Reference< beans::XPropertySet > xErrorBarProp;
1199                         OUString errorBar;
1200
1201                         if ( eObjectType == OBJECTTYPE_DATA_ERRORS_X)
1202                             errorBar = CHART_UNONAME_ERRORBAR_X;
1203                         else if (eObjectType == OBJECTTYPE_DATA_ERRORS_Y)
1204                             errorBar = CHART_UNONAME_ERRORBAR_Y;
1205                         else
1206                             errorBar = "ErrorBarZ";
1207
1208                         xSeries->getPropertyValue( errorBar ) >>= xErrorBarProp;
1209                         xObjectProperties = std::move(xErrorBarProp);
1210                     }
1211                     break;
1212                 }
1213             case OBJECTTYPE_DATA_AVERAGE_LINE:
1214             case OBJECTTYPE_DATA_CURVE:
1215             case OBJECTTYPE_DATA_CURVE_EQUATION:
1216                 {
1217                     rtl::Reference< DataSeries > xRegressionContainer = ObjectIdentifier::getDataSeriesForCID(
1218                         rObjectCID, xChartModel );
1219                     if(xRegressionContainer.is())
1220                     {
1221                         sal_Int32 nIndex = o3tl::toInt32(aParticleID);
1222                         const std::vector< rtl::Reference< RegressionCurveModel > > & aCurveList =
1223                             xRegressionContainer->getRegressionCurves2();
1224                         if( nIndex >= 0 && o3tl::make_unsigned(nIndex) < aCurveList.size() )
1225                         {
1226                             if( eObjectType == OBJECTTYPE_DATA_CURVE_EQUATION )
1227                                 xObjectProperties = aCurveList[nIndex]->getEquationProperties();
1228                             else
1229                                 xObjectProperties = aCurveList[nIndex];
1230                         }
1231                     }
1232                     break;
1233                 }
1234             case OBJECTTYPE_DATA_STOCK_RANGE:
1235                     break;
1236             case OBJECTTYPE_DATA_STOCK_LOSS:
1237                     {
1238                         rtl::Reference<ChartType> xChartType( lcl_getFirstStockChartType( xChartModel ) );
1239                         if(xChartType.is())
1240                             xChartType->getPropertyValue( u"BlackDay"_ustr ) >>= xObjectProperties;
1241                     }
1242                     break;
1243             case OBJECTTYPE_DATA_STOCK_GAIN:
1244                     {
1245                         rtl::Reference<ChartType> xChartType( lcl_getFirstStockChartType( xChartModel ) );
1246                         if(xChartType.is())
1247                             xChartType->getPropertyValue( u"WhiteDay"_ustr ) >>= xObjectProperties;
1248                     }
1249                     break;
1250             case OBJECTTYPE_DATA_TABLE:
1251                     {
1252                         if (xDiagram.is())
1253                             xObjectProperties.set(xDiagram->getDataTable(), uno::UNO_QUERY);
1254                     }
1255                 break;
1256                     break;
1257             default: //OBJECTTYPE_UNKNOWN
1258                     break;
1259         }
1260     }
1261     catch(const uno::Exception&)
1262     {
1263         DBG_UNHANDLED_EXCEPTION("chart2");
1264     }
1265     return xObjectProperties;
1266 }
1267
1268 rtl::Reference< Axis > ObjectIdentifier::getAxisForCID(
1269                 std::u16string_view rObjectCID
1270                 , const rtl::Reference<::chart::ChartModel>& xChartModel )
1271 {
1272     rtl::Reference< Diagram > xDiagram;
1273     rtl::Reference< BaseCoordinateSystem > xCooSys;
1274     lcl_getDiagramAndCooSys( rObjectCID, xChartModel, xDiagram, xCooSys );
1275
1276     sal_Int32 nDimensionIndex = -1;
1277     sal_Int32 nAxisIndex = -1;
1278     lcl_parseAxisIndices( nDimensionIndex, nAxisIndex, rObjectCID );
1279
1280     return AxisHelper::getAxis( nDimensionIndex, nAxisIndex, xCooSys );
1281 }
1282
1283 rtl::Reference< DataSeries > ObjectIdentifier::getDataSeriesForCID(
1284                 std::u16string_view rObjectCID
1285                 , const rtl::Reference<::chart::ChartModel>& xChartModel )
1286 {
1287     rtl::Reference< Diagram > xDiagram;
1288     rtl::Reference< BaseCoordinateSystem > xCooSys;
1289     lcl_getDiagramAndCooSys( rObjectCID, xChartModel, xDiagram, xCooSys );
1290
1291     sal_Int32 nChartTypeIndex = -1;
1292     sal_Int32 nSeriesIndex = -1;
1293     sal_Int32 nPointIndex = -1;
1294     lcl_parseSeriesIndices( nChartTypeIndex, nSeriesIndex, nPointIndex, rObjectCID );
1295
1296     rtl::Reference< DataSeries > xSeries;
1297     if (xDiagram)
1298     {
1299         rtl::Reference< ChartType > xDataSeriesContainer( xDiagram->getChartTypeByIndex( nChartTypeIndex ) );
1300         if( xDataSeriesContainer.is() )
1301         {
1302             const std::vector< rtl::Reference< DataSeries > > & aDataSeriesSeq( xDataSeriesContainer->getDataSeries2() );
1303             if( nSeriesIndex >= 0 && o3tl::make_unsigned(nSeriesIndex) < aDataSeriesSeq.size() )
1304                 xSeries = aDataSeriesSeq[nSeriesIndex];
1305         }
1306     }
1307     return xSeries;
1308 }
1309
1310 rtl::Reference< Diagram > ObjectIdentifier::getDiagramForCID(
1311                   std::u16string_view rObjectCID
1312                 , const rtl::Reference<::chart::ChartModel>& xChartModel )
1313 {
1314     rtl::Reference< Diagram > xDiagram;
1315     rtl::Reference< BaseCoordinateSystem > xCooSys;
1316     lcl_getDiagramAndCooSys( rObjectCID, xChartModel, xDiagram, xCooSys );
1317
1318     return xDiagram;
1319 }
1320
1321 TitleHelper::eTitleType ObjectIdentifier::getTitleTypeForCID( std::u16string_view rCID )
1322 {
1323     TitleHelper::eTitleType eRet( TitleHelper::MAIN_TITLE );
1324
1325     std::u16string_view aParentParticle = ObjectIdentifier::getFullParentParticle( rCID );
1326     const tTitleMap& rMap = lcl_getTitleMap();
1327     tTitleMap::const_iterator aIt = std::find_if(rMap.begin(), rMap.end(),
1328         [&aParentParticle](tTitleMap::const_reference rEntry) { return aParentParticle == rEntry.second; });
1329     if (aIt != rMap.end())
1330         eRet = (*aIt).first;
1331
1332     return eRet;
1333 }
1334
1335 OUString ObjectIdentifier::getSeriesParticleFromCID( std::u16string_view rCID )
1336 {
1337     sal_Int32 nDiagramIndex = -1;
1338     sal_Int32 nCooSysIndex = -1;
1339     lcl_parseCooSysIndices( nDiagramIndex, nCooSysIndex, rCID );
1340
1341     sal_Int32 nChartTypeIndex = -1;
1342     sal_Int32 nSeriesIndex = -1;
1343     sal_Int32 nPointIndex = -1;
1344     lcl_parseSeriesIndices( nChartTypeIndex, nSeriesIndex, nPointIndex, rCID );
1345
1346     return ObjectIdentifier::createParticleForSeries( nDiagramIndex, nCooSysIndex, nChartTypeIndex, nSeriesIndex );
1347 }
1348
1349 OUString ObjectIdentifier::getMovedSeriesCID( std::u16string_view rObjectCID, bool bForward )
1350 {
1351     sal_Int32 nDiagramIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rObjectCID, u"CID/D=" ) );
1352     sal_Int32 nCooSysIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rObjectCID, u"CS=" ) );
1353     sal_Int32 nChartTypeIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rObjectCID, u"CT=" ) );
1354     sal_Int32 nSeriesIndex = lcl_StringToIndex( lcl_getIndexStringAfterString( rObjectCID, u"Series=" ) );
1355
1356     if( bForward )
1357         nSeriesIndex--;
1358     else
1359         nSeriesIndex++;
1360
1361     OUString aRet = ObjectIdentifier::createParticleForSeries( nDiagramIndex, nCooSysIndex, nChartTypeIndex, nSeriesIndex );
1362     return ObjectIdentifier::createClassifiedIdentifierForParticle( aRet );
1363 }
1364
1365 bool ObjectIdentifier::isValid() const
1366 {
1367     return ( isAutoGeneratedObject() || isAdditionalShape() );
1368 }
1369
1370 bool ObjectIdentifier::isAutoGeneratedObject() const
1371 {
1372     return ( !m_aObjectCID.isEmpty() );
1373 }
1374
1375 bool ObjectIdentifier::isAdditionalShape() const
1376 {
1377     return m_xAdditionalShape.is();
1378 }
1379
1380 Any ObjectIdentifier::getAny() const
1381 {
1382     Any aAny;
1383     if ( isAutoGeneratedObject() )
1384     {
1385         aAny <<= getObjectCID();
1386     }
1387     else if ( isAdditionalShape() )
1388     {
1389         aAny <<= getAdditionalShape();
1390     }
1391     return aAny;
1392 }
1393
1394 } //namespace chart
1395
1396 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */