chart2/source/controller/main/ObjectHierarchy.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 <ObjectHierarchy.hxx>
  21 #include <ObjectIdentifier.hxx>
  22 #include <ChartModelHelper.hxx>
  23 #include <DiagramHelper.hxx>
  24 #include <RegressionCurveHelper.hxx>
  25 #include <AxisHelper.hxx>
  26 #include <chartview/ExplicitValueProvider.hxx>
  27 #include <ChartTypeHelper.hxx>
  28 #include <DataSeriesHelper.hxx>
  29 #include <LegendHelper.hxx>
  30 #include <chartview/DrawModelWrapper.hxx>
  31 #include <unonames.hxx>
  32
  33 #include <map>
  34 #include <algorithm>
  35 #include <iterator>
  36
  37 #include <com/sun/star/drawing/XShapes.hpp>
  38 #include <com/sun/star/chart2/XTitled.hpp>
  39 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  40 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  41 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  42 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
  43 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  44
  45 #include <com/sun/star/container/XIndexAccess.hpp>
  46 #include <com/sun/star/awt/Key.hpp>
  47 #include <com/sun/star/awt/KeyEvent.hpp>
  48 #include <com/sun/star/awt/KeyModifier.hpp>
  49 #include <com/sun/star/frame/XModel.hpp>
  50 #include <tools/diagnose_ex.h>
  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::Sequence;
  57
  58 namespace
  59 {
  60
  61 struct lcl_ObjectToOID
  62 {
  63     explicit lcl_ObjectToOID( const Reference< chart2::XChartDocument > & xChartDoc ) :
  64             m_xModel( xChartDoc, uno::UNO_QUERY )
  65     {}
  66
  67     ::chart::ObjectIdentifier operator() ( const Reference< uno::XInterface > & xObj )
  68     {
  69         return ::chart::ObjectIdentifier( ::chart::ObjectIdentifier::createClassifiedIdentifierForObject( xObj, m_xModel ) );
  70     }
  71
  72 private:
  73     Reference< frame::XModel > m_xModel;
  74 };
  75
  76 void lcl_getChildOIDs(
  77     ::chart::ObjectHierarchy::tChildContainer& rOutChildren,
  78     const Reference< container::XIndexAccess >& xShapes )
  79 {
  80     if( xShapes.is())
  81     {
  82         sal_Int32 nCount = xShapes->getCount();
  83         for( sal_Int32 i=0; i<nCount; ++i)
  84         {
  85             Reference< beans::XPropertySet > xShapeProp( xShapes->getByIndex( i ), uno::UNO_QUERY );
  86             if( xShapeProp.is())
  87             {
  88                 Reference< beans::XPropertySetInfo > xInfo( xShapeProp->getPropertySetInfo());
  89                 OUString aName;
  90                 if( xInfo.is() &&
  91                     xInfo->hasPropertyByName( "Name") &&
  92                     (xShapeProp->getPropertyValue( "Name") >>= aName ) &&
  93                     !aName.isEmpty() &&
  94                     ::chart::ObjectIdentifier::isCID( aName ))
  95                 {
  96                     rOutChildren.emplace_back( aName );
  97                 }
  98                 Reference< container::XIndexAccess > xNewShapes( xShapeProp, uno::UNO_QUERY );
  99                 if( xNewShapes.is())
 100                     lcl_getChildOIDs( rOutChildren, xNewShapes );
 101             }
 102         }
 103     }
 104 }
 105
 106 void lcl_addAxisTitle( const Reference< XAxis >& xAxis, ::chart::ObjectHierarchy::tChildContainer& rContainer, const Reference< frame::XModel >& xChartModel )
 107 {
 108     Reference< XTitled > xAxisTitled( xAxis, uno::UNO_QUERY );
 109     if( xAxisTitled.is())
 110     {
 111         Reference< XTitle > xAxisTitle( xAxisTitled->getTitleObject());
 112         if( xAxisTitle.is())
 113             rContainer.emplace_back( ::chart::ObjectIdentifier::createClassifiedIdentifierForObject( xAxisTitle, xChartModel ) );
 114     }
 115 }
 116
 117 } // anonymous namespace
 118
 119 namespace chart
 120 {
 121
 122 namespace impl
 123 {
 124
 125 class ImplObjectHierarchy
 126 {
 127 public:
 128     explicit ImplObjectHierarchy(
 129         const Reference< XChartDocument >& xChartDocument,
 130         ExplicitValueProvider* pExplicitValueProvider,
 131         bool bFlattenDiagram, bool bOrderingForElementSelector );
 132
 133     bool                              hasChildren( const ObjectIdentifier& rParent );
 134     ObjectHierarchy::tChildContainer  getChildren( const ObjectIdentifier& rParent );
 135     ObjectHierarchy::tChildContainer  getSiblings( const ObjectIdentifier& rNode );
 136
 137     ObjectIdentifier getParent( const ObjectIdentifier& rOID );
 138
 139 private:
 140     void createTree( const Reference< XChartDocument > & xChartDocument );
 141     void createAxesTree(
 142         ObjectHierarchy::tChildContainer & rContainer,
 143         const Reference< XChartDocument > & xChartDoc,
 144         const Reference< XDiagram > & xDiagram  );
 145     void createDiagramTree(
 146         ObjectHierarchy::tChildContainer& rContainer,
 147         const Reference< XChartDocument >& xChartDoc,
 148         const Reference< XDiagram >& xDiagram );
 149     void createDataSeriesTree(
 150         ObjectHierarchy::tChildContainer & rOutDiagramSubContainer,
 151         const Reference< XDiagram > & xDiagram );
 152     static void createWallAndFloor(
 153         ObjectHierarchy::tChildContainer & rContainer,
 154         const Reference< XDiagram > & xDiagram );
 155     void createLegendTree(
 156         ObjectHierarchy::tChildContainer & rContainer,
 157         const Reference< XChartDocument > & xChartDoc,
 158         const Reference< XDiagram > & xDiagram  );
 159     void createAdditionalShapesTree( ObjectHierarchy::tChildContainer& rContainer );
 160
 161     ObjectIdentifier getParentImpl(
 162         const ObjectIdentifier& rParentOID,
 163         const ObjectIdentifier& rOID );
 164
 165     typedef std::map< ObjectIdentifier, ObjectHierarchy::tChildContainer >
 166         tChildMap;
 167     tChildMap m_aChildMap;
 168     ExplicitValueProvider* m_pExplicitValueProvider;
 169     bool m_bFlattenDiagram;
 170     bool m_bOrderingForElementSelector;
 171 };
 172
 173 ImplObjectHierarchy::ImplObjectHierarchy(
 174     const Reference< XChartDocument >& xChartDocument,
 175     ExplicitValueProvider* pExplicitValueProvider,
 176     bool bFlattenDiagram,
 177     bool bOrderingForElementSelector ) :
 178         m_pExplicitValueProvider( pExplicitValueProvider ),
 179         m_bFlattenDiagram( bFlattenDiagram ),
 180         m_bOrderingForElementSelector( bOrderingForElementSelector )
 181 {
 182     createTree( xChartDocument );
 183     // don't remember this helper to avoid access after lifetime
 184     m_pExplicitValueProvider = nullptr;
 185 }
 186
 187 void ImplObjectHierarchy::createTree( const Reference< XChartDocument >& xChartDocument )
 188 {
 189     m_aChildMap = tChildMap();//clear tree
 190
 191     if( !xChartDocument.is() )
 192         return;
 193
 194     //@todo: change ObjectIdentifier to take an XChartDocument rather than XModel
 195     Reference< frame::XModel > xModel( xChartDocument, uno::UNO_QUERY );
 196     Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartDocument ) );
 197     ObjectIdentifier aDiaOID;
 198     if( xDiagram.is() )
 199         aDiaOID = ObjectIdentifier( ObjectIdentifier::createClassifiedIdentifierForObject( xDiagram, xModel ) );
 200     ObjectHierarchy::tChildContainer aTopLevelContainer;
 201
 202     // First Level
 203
 204     // Chart Area
 205     if( m_bOrderingForElementSelector )
 206     {
 207         aTopLevelContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_PAGE, OUString() ) );
 208         if( xDiagram.is() )
 209         {
 210             aTopLevelContainer.push_back( aDiaOID );
 211             createWallAndFloor( aTopLevelContainer, xDiagram );
 212             createLegendTree( aTopLevelContainer, xChartDocument, xDiagram  );
 213         }
 214     }
 215
 216     // Main Title
 217     Reference< XTitled > xDocTitled( xChartDocument, uno::UNO_QUERY );
 218     if( xDocTitled.is())
 219     {
 220         Reference< XTitle > xMainTitle( xDocTitled->getTitleObject());
 221         if( xMainTitle.is())
 222             aTopLevelContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForObject( xMainTitle, xModel ) );
 223     }
 224
 225     if( xDiagram.is())
 226     {
 227         // Sub Title.  Note: This is interpreted of being top level
 228         Reference< XTitled > xDiaTitled( xDiagram, uno::UNO_QUERY );
 229         if( xDiaTitled.is())
 230         {
 231             Reference< XTitle > xSubTitle( xDiaTitled->getTitleObject());
 232             if( xSubTitle.is())
 233                 aTopLevelContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForObject( xSubTitle, xModel ) );
 234         }
 235
 236         if( !m_bOrderingForElementSelector )
 237         {
 238             // Axis Titles. Note: These are interpreted of being top level
 239             Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 240             for( sal_Int32 i=0; i<aAxes.getLength(); ++i )
 241                 lcl_addAxisTitle( aAxes[i], aTopLevelContainer, xModel );
 242
 243             // Diagram
 244             aTopLevelContainer.push_back( aDiaOID );
 245         }
 246
 247         if( m_bFlattenDiagram )
 248             createDiagramTree( aTopLevelContainer, xChartDocument, xDiagram );
 249         else
 250         {
 251             ObjectHierarchy::tChildContainer aSubContainer;
 252             createDiagramTree( aSubContainer, xChartDocument, xDiagram );
 253             if( !aSubContainer.empty() )
 254                 m_aChildMap[ aDiaOID ] = aSubContainer;
 255         }
 256
 257         if( !m_bOrderingForElementSelector )
 258             createLegendTree( aTopLevelContainer, xChartDocument, xDiagram  );
 259     }
 260
 261     // #i12587# support for shapes in chart
 262     if ( !m_bOrderingForElementSelector )
 263     {
 264         createAdditionalShapesTree( aTopLevelContainer );
 265     }
 266
 267     // Chart Area
 268     if( !m_bOrderingForElementSelector )
 269         aTopLevelContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_PAGE, OUString() ) );
 270
 271     if( ! aTopLevelContainer.empty())
 272         m_aChildMap[ ObjectHierarchy::getRootNodeOID() ] = aTopLevelContainer;
 273 }
 274
 275 void ImplObjectHierarchy::createLegendTree(
 276     ObjectHierarchy::tChildContainer & rContainer,
 277     const Reference< XChartDocument > & xChartDoc,
 278     const Reference< XDiagram > & xDiagram  )
 279 {
 280     if( xDiagram.is() && LegendHelper::hasLegend( xDiagram ) )
 281     {
 282         ObjectIdentifier aLegendOID( ObjectIdentifier( ObjectIdentifier::createClassifiedIdentifierForObject( xDiagram->getLegend(), Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ) ) ) );
 283         rContainer.push_back( aLegendOID );
 284
 285         // iterate over child shapes of legend and search for matching CIDs
 286         if( m_pExplicitValueProvider )
 287         {
 288             Reference< container::XIndexAccess > xLegendShapeContainer(
 289                 m_pExplicitValueProvider->getShapeForCID( aLegendOID.getObjectCID() ), uno::UNO_QUERY );
 290             ObjectHierarchy::tChildContainer aLegendEntryOIDs;
 291             lcl_getChildOIDs( aLegendEntryOIDs, xLegendShapeContainer );
 292
 293             m_aChildMap[ aLegendOID ] = aLegendEntryOIDs;
 294         }
 295     }
 296 }
 297
 298 void ImplObjectHierarchy::createAxesTree(
 299     ObjectHierarchy::tChildContainer & rContainer,
 300     const Reference< XChartDocument > & xChartDoc,
 301     const Reference< XDiagram > & xDiagram  )
 302 {
 303     Reference< XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW );
 304     sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
 305     uno::Reference< chart2::XChartType > xChartType( DiagramHelper::getChartTypeByIndex( xDiagram, 0 ) );
 306     bool bSupportsAxesGrids = ChartTypeHelper::isSupportingMainAxis( xChartType, nDimensionCount, 0 );
 307     if( bSupportsAxesGrids )
 308     {
 309         Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram, /* bOnlyVisible = */ true ) );
 310         if( !m_bOrderingForElementSelector )
 311             std::transform( aAxes.begin(), aAxes.end(),
 312                           std::back_inserter( rContainer ),
 313                           lcl_ObjectToOID( xChartDoc ));
 314
 315         // get all axes, also invisible ones
 316         aAxes = AxisHelper::getAllAxesOfDiagram( xDiagram );
 317         // Grids
 318         Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
 319         for( sal_Int32 nA=0; nA<aAxes.getLength(); ++nA )
 320         {
 321             Reference< XAxis > xAxis( aAxes[nA] );
 322             if(!xAxis.is())
 323                 continue;
 324
 325             sal_Int32 nCooSysIndex = 0;
 326             sal_Int32 nDimensionIndex = 0;
 327             sal_Int32 nAxisIndex = 0;
 328             AxisHelper::getIndicesForAxis( xAxis, xDiagram, nCooSysIndex, nDimensionIndex, nAxisIndex );
 329             if( nAxisIndex>0 && !ChartTypeHelper::isSupportingSecondaryAxis( xChartType, nDimensionCount ) )
 330                 continue;
 331
 332             if( m_bOrderingForElementSelector )
 333             {
 334                 // axis
 335                 if( AxisHelper::isAxisVisible( xAxis ) )
 336                     rContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForObject( xAxis, xChartModel ) );
 337
 338                 // axis title
 339                 lcl_addAxisTitle( aAxes[nA], rContainer, xChartModel );
 340             }
 341
 342             Reference< beans::XPropertySet > xGridProperties( xAxis->getGridProperties() );
 343             if( AxisHelper::isGridVisible( xGridProperties ) )
 344             {
 345                 //main grid
 346                 rContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel ) );
 347             }
 348
 349             Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 350             sal_Int32 nSubGrid = 0;
 351             for( nSubGrid = 0; nSubGrid < aSubGrids.getLength(); ++nSubGrid )
 352             {
 353                 Reference< beans::XPropertySet > xSubGridProperties( aSubGrids[nSubGrid] );
 354                 if( AxisHelper::isGridVisible( xSubGridProperties ) )
 355                 {
 356                     //sub grid
 357                     rContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel, nSubGrid ) );
 358                 }
 359             }
 360         }
 361     }
 362 }
 363
 364 void ImplObjectHierarchy::createWallAndFloor(
 365     ObjectHierarchy::tChildContainer & rContainer,
 366     const Reference< XDiagram > & xDiagram )
 367 {
 368     sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
 369     bool bIsThreeD = ( nDimensionCount == 3 );
 370     bool bHasWall = DiagramHelper::isSupportingFloorAndWall( xDiagram );
 371     if( bHasWall && bIsThreeD )
 372     {
 373         rContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_WALL, OUString() ) );
 374
 375         Reference< beans::XPropertySet > xFloor( xDiagram->getFloor());
 376         if( xFloor.is())
 377             rContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_FLOOR, OUString() ) );
 378     }
 379
 380 }
 381
 382 void ImplObjectHierarchy::createDiagramTree(
 383     ObjectHierarchy::tChildContainer & rContainer,
 384     const Reference< XChartDocument > & xChartDoc,
 385     const Reference< XDiagram > & xDiagram )
 386 {
 387     if( !m_bOrderingForElementSelector )
 388     {
 389         createDataSeriesTree( rContainer, xDiagram );
 390         createAxesTree( rContainer, xChartDoc, xDiagram  );
 391         createWallAndFloor( rContainer, xDiagram );
 392     }
 393     else
 394     {
 395         createAxesTree( rContainer, xChartDoc, xDiagram  );
 396         createDataSeriesTree( rContainer, xDiagram );
 397     }
 398 }
 399
 400 void ImplObjectHierarchy::createDataSeriesTree(
 401     ObjectHierarchy::tChildContainer & rOutDiagramSubContainer,
 402     const Reference< XDiagram > & xDiagram )
 403 {
 404     Reference< XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW );
 405
 406     try
 407     {
 408         sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
 409         Sequence< Reference< XCoordinateSystem > > aCooSysSeq(
 410             xCooSysCnt->getCoordinateSystems());
 411         for( sal_Int32 nCooSysIdx=0; nCooSysIdx<aCooSysSeq.getLength(); ++nCooSysIdx )
 412         {
 413             Reference< XChartTypeContainer > xCTCnt( aCooSysSeq[nCooSysIdx], uno::UNO_QUERY_THROW );
 414             Sequence< Reference< XChartType > > aChartTypeSeq( xCTCnt->getChartTypes());
 415             for( sal_Int32 nCTIdx=0; nCTIdx<aChartTypeSeq.getLength(); ++nCTIdx )
 416             {
 417                 Reference< XChartType > xChartType( aChartTypeSeq[nCTIdx] );
 418                 Reference< XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY_THROW );
 419                 Sequence< Reference< XDataSeries > > aSeriesSeq( xDSCnt->getDataSeries() );
 420                 const sal_Int32 nNumberOfSeries =
 421                     ChartTypeHelper::getNumberOfDisplayedSeries( xChartType, aSeriesSeq.getLength());
 422
 423                 for( sal_Int32 nSeriesIdx=0; nSeriesIdx<nNumberOfSeries; ++nSeriesIdx )
 424                 {
 425                     OUString aSeriesParticle(
 426                         ObjectIdentifier::createParticleForSeries(
 427                             0, nCooSysIdx, nCTIdx, nSeriesIdx ));
 428                     ObjectIdentifier aSeriesOID(
 429                         ObjectIdentifier( ObjectIdentifier::createClassifiedIdentifierForParticle( aSeriesParticle ) ) );
 430                     rOutDiagramSubContainer.push_back( aSeriesOID );
 431
 432                     ObjectHierarchy::tChildContainer aSeriesSubContainer;
 433
 434                     Reference< chart2::XDataSeries > xSeries( aSeriesSeq[nSeriesIdx], uno::UNO_QUERY );
 435
 436                     // data labels
 437                     if( DataSeriesHelper::hasDataLabelsAtSeries( xSeries ) )
 438                     {
 439                         OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_LABELS ) + "=" );
 440                         aSeriesSubContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierForParticles( aSeriesParticle, aChildParticle ) );
 441                     }
 442
 443                     // Statistics
 444                     if( ChartTypeHelper::isSupportingStatisticProperties( xChartType, nDimensionCount ) )
 445                     {
 446                         Reference< chart2::XRegressionCurveContainer > xCurveCnt( xSeries, uno::UNO_QUERY );
 447                         if( xCurveCnt.is())
 448                         {
 449                             Sequence< Reference< chart2::XRegressionCurve > > aCurves( xCurveCnt->getRegressionCurves());
 450                             for( sal_Int32 nCurveIdx=0; nCurveIdx<aCurves.getLength(); ++nCurveIdx )
 451                             {
 452                                 bool bIsAverageLine = RegressionCurveHelper::isMeanValueLine( aCurves[nCurveIdx] );
 453                                 aSeriesSubContainer.emplace_back( ObjectIdentifier::createDataCurveCID( aSeriesParticle, nCurveIdx, bIsAverageLine ) );
 454                                 if( RegressionCurveHelper::hasEquation( aCurves[nCurveIdx] ) )
 455                                 {
 456                                     aSeriesSubContainer.emplace_back( ObjectIdentifier::createDataCurveEquationCID( aSeriesParticle, nCurveIdx ) );
 457                                 }
 458                             }
 459                             Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
 460                             Reference< beans::XPropertySet > xErrorBarProp;
 461                             if( xSeriesProp.is() &&
 462                                 (xSeriesProp->getPropertyValue( CHART_UNONAME_ERRORBAR_Y) >>= xErrorBarProp) &&
 463                                 xErrorBarProp.is())
 464                             {
 465                                 sal_Int32 nStyle = css::chart::ErrorBarStyle::NONE;
 466                                 if( ( xErrorBarProp->getPropertyValue( "ErrorBarStyle") >>= nStyle ) &&
 467                                     ( nStyle != css::chart::ErrorBarStyle::NONE ) )
 468                                 {
 469                                     aSeriesSubContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierWithParent(
 470                                             OBJECTTYPE_DATA_ERRORS_Y, OUString(), aSeriesParticle ) );
 471                                 }
 472                             }
 473
 474                             if( xSeriesProp.is() &&
 475                                 (xSeriesProp->getPropertyValue(CHART_UNONAME_ERRORBAR_X) >>= xErrorBarProp) &&
 476                                 xErrorBarProp.is())
 477                             {
 478                                 sal_Int32 nStyle = css::chart::ErrorBarStyle::NONE;
 479                                 if( ( xErrorBarProp->getPropertyValue( "ErrorBarStyle") >>= nStyle ) &&
 480                                     ( nStyle != css::chart::ErrorBarStyle::NONE ) )
 481                                 {
 482                                     aSeriesSubContainer.emplace_back( ObjectIdentifier::createClassifiedIdentifierWithParent(
 483                                             OBJECTTYPE_DATA_ERRORS_X, OUString(), aSeriesParticle ) );
 484                                 }
 485                             }
 486                         }
 487                     }
 488
 489                     // Data Points
 490                     // iterate over child shapes of legend and search for matching CIDs
 491                     if( m_pExplicitValueProvider )
 492                     {
 493                         Reference< container::XIndexAccess > xSeriesShapeContainer(
 494                             m_pExplicitValueProvider->getShapeForCID( aSeriesOID.getObjectCID() ), uno::UNO_QUERY );
 495                         lcl_getChildOIDs( aSeriesSubContainer, xSeriesShapeContainer );
 496                     }
 497
 498                     if( ! aSeriesSubContainer.empty())
 499                         m_aChildMap[ aSeriesOID ] = aSeriesSubContainer;
 500                 }
 501             }
 502         }
 503     }
 504     catch( const uno::Exception & )
 505     {
 506         DBG_UNHANDLED_EXCEPTION("chart2");
 507     }
 508 }
 509
 510 void ImplObjectHierarchy::createAdditionalShapesTree( ObjectHierarchy::tChildContainer& rContainer )
 511 {
 512     try
 513     {
 514         if ( m_pExplicitValueProvider )
 515         {
 516             Reference< drawing::XDrawPage > xDrawPage( m_pExplicitValueProvider->getDrawModelWrapper()->getMainDrawPage() );
 517             Reference< drawing::XShapes > xDrawPageShapes( xDrawPage, uno::UNO_QUERY_THROW );
 518             Reference< drawing::XShapes > xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
 519             sal_Int32 nCount = xDrawPageShapes->getCount();
 520             for ( sal_Int32 i = 0; i < nCount; ++i )
 521             {
 522                 Reference< drawing::XShape > xShape;
 523                 if ( xDrawPageShapes->getByIndex( i ) >>= xShape )
 524                 {
 525                     if ( xShape.is() && xShape != xChartRoot )
 526                     {
 527                         rContainer.emplace_back( xShape );
 528                     }
 529                 }
 530             }
 531         }
 532     }
 533     catch ( const uno::Exception& )
 534     {
 535         DBG_UNHANDLED_EXCEPTION("chart2");
 536     }
 537 }
 538
 539 bool ImplObjectHierarchy::hasChildren( const ObjectIdentifier& rParent )
 540 {
 541     if ( rParent.isValid() )
 542     {
 543         tChildMap::const_iterator aIt( m_aChildMap.find( rParent ));
 544         if( aIt != m_aChildMap.end())
 545             return ! (aIt->second.empty());
 546     }
 547     return false;
 548 }
 549
 550 ObjectHierarchy::tChildContainer ImplObjectHierarchy::getChildren( const ObjectIdentifier& rParent )
 551 {
 552     if ( rParent.isValid() )
 553     {
 554         tChildMap::const_iterator aIt( m_aChildMap.find( rParent ));
 555         if( aIt != m_aChildMap.end())
 556             return aIt->second;
 557     }
 558     return ObjectHierarchy::tChildContainer();
 559 }
 560
 561 ObjectHierarchy::tChildContainer ImplObjectHierarchy::getSiblings( const ObjectIdentifier& rNode )
 562 {
 563     if ( rNode.isValid() && !ObjectHierarchy::isRootNode( rNode ) )
 564     {
 565         for (auto const& child : m_aChildMap)
 566         {
 567             ObjectHierarchy::tChildContainer::const_iterator aElemIt(
 568                 std::find( child.second.begin(), child.second.end(), rNode ));
 569             if( aElemIt != child.second.end())
 570                 return child.second;
 571         }
 572     }
 573     return ObjectHierarchy::tChildContainer();
 574 }
 575
 576 ObjectIdentifier ImplObjectHierarchy::getParentImpl(
 577     const ObjectIdentifier & rParentOID,
 578     const ObjectIdentifier & rOID )
 579 {
 580     // search children
 581     ObjectHierarchy::tChildContainer aChildren( getChildren( rParentOID ));
 582     ObjectHierarchy::tChildContainer::const_iterator aIt(
 583         std::find( aChildren.begin(), aChildren.end(), rOID ));
 584     // recursion end
 585     if( aIt != aChildren.end())
 586         return rParentOID;
 587
 588     for (auto const& child : aChildren)
 589     {
 590         // recursion
 591         ObjectIdentifier aTempParent( getParentImpl( child, rOID ));
 592         if ( aTempParent.isValid() )
 593         {
 594             // exit on success
 595             return aTempParent;
 596         }
 597     }
 598
 599     // exit on fail
 600     return ObjectIdentifier();
 601 }
 602
 603 ObjectIdentifier ImplObjectHierarchy::getParent(
 604     const ObjectIdentifier & rOID )
 605 {
 606     return getParentImpl( ObjectHierarchy::getRootNodeOID(), rOID );
 607 }
 608
 609 } // namespace impl
 610
 611 ObjectHierarchy::ObjectHierarchy(
 612     const Reference< XChartDocument > & xChartDocument,
 613     ExplicitValueProvider * pExplicitValueProvider /* = 0 */,
 614     bool bFlattenDiagram /* = false */,
 615     bool bOrderingForElementSelector /* = false */) :
 616         m_apImpl( new impl::ImplObjectHierarchy( xChartDocument, pExplicitValueProvider, bFlattenDiagram, bOrderingForElementSelector ))
 617 {}
 618
 619 ObjectHierarchy::~ObjectHierarchy()
 620 {}
 621
 622 ObjectIdentifier ObjectHierarchy::getRootNodeOID()
 623 {
 624     return ObjectIdentifier( "ROOT" );
 625 }
 626
 627 bool ObjectHierarchy::isRootNode( const ObjectIdentifier& rOID )
 628 {
 629     return ( rOID == ObjectHierarchy::getRootNodeOID() );
 630 }
 631
 632 ObjectHierarchy::tChildContainer ObjectHierarchy::getTopLevelChildren() const
 633 {
 634     return m_apImpl->getChildren( ObjectHierarchy::getRootNodeOID());
 635 }
 636
 637 bool ObjectHierarchy::hasChildren( const ObjectIdentifier& rParent ) const
 638 {
 639     return m_apImpl->hasChildren( rParent );
 640 }
 641
 642 ObjectHierarchy::tChildContainer ObjectHierarchy::getChildren(
 643     const ObjectIdentifier& rParent ) const
 644 {
 645     if ( rParent.isValid() )
 646         return m_apImpl->getChildren( rParent );
 647
 648     return ObjectHierarchy::tChildContainer();
 649 }
 650
 651 ObjectHierarchy::tChildContainer ObjectHierarchy::getSiblings(
 652     const ObjectIdentifier& rNode ) const
 653 {
 654     if ( rNode.isValid() && !isRootNode( rNode ) )
 655         return m_apImpl->getSiblings( rNode );
 656
 657     return ObjectHierarchy::tChildContainer();
 658 }
 659
 660 ObjectIdentifier ObjectHierarchy::getParent(
 661     const ObjectIdentifier& rNode ) const
 662 {
 663     return m_apImpl->getParent( rNode );
 664 }
 665
 666 sal_Int32 ObjectHierarchy::getIndexInParent(
 667     const ObjectIdentifier& rNode ) const
 668 {
 669     ObjectIdentifier aParentOID( m_apImpl->getParent( rNode ));
 670     tChildContainer aChildren( m_apImpl->getChildren( aParentOID ) );
 671     sal_Int32 nIndex = 0;
 672     for (auto const& child : aChildren)
 673     {
 674         if ( child == rNode )
 675             return nIndex;
 676         ++nIndex;
 677     }
 678     return -1;
 679 }
 680
 681 ObjectKeyNavigation::ObjectKeyNavigation(
 682     const ObjectIdentifier & rCurrentOID,
 683     const Reference< chart2::XChartDocument > & xChartDocument,
 684     ExplicitValueProvider * pExplicitValueProvider /* = 0 */ ) :
 685         m_aCurrentOID( rCurrentOID ),
 686         m_xChartDocument( xChartDocument ),
 687         m_pExplicitValueProvider( pExplicitValueProvider )
 688 {
 689     if ( !m_aCurrentOID.isValid() )
 690     {
 691         setCurrentSelection( ObjectHierarchy::getRootNodeOID() );
 692     }
 693 }
 694
 695 bool ObjectKeyNavigation::handleKeyEvent(
 696     const awt::KeyEvent & rEvent )
 697 {
 698     bool bResult = false;
 699
 700     switch( rEvent.KeyCode )
 701     {
 702         case awt::Key::TAB:
 703             if( rEvent.Modifiers & awt::KeyModifier::SHIFT )
 704                 bResult = previous();
 705             else
 706                 bResult = next();
 707             break;
 708         case awt::Key::HOME:
 709             bResult = first();
 710             break;
 711         case awt::Key::END:
 712             bResult = last();
 713             break;
 714         case awt::Key::F3:
 715             if( rEvent.Modifiers & awt::KeyModifier::SHIFT )
 716                 bResult = up();
 717             else
 718                 bResult = down();
 719             break;
 720         case awt::Key::ESCAPE:
 721             setCurrentSelection( ObjectIdentifier() );
 722             bResult = true;
 723             break;
 724         default:
 725             bResult = false;
 726             break;
 727     }
 728     return bResult;
 729 }
 730
 731 void ObjectKeyNavigation::setCurrentSelection( const ObjectIdentifier& rOID )
 732 {
 733     m_aCurrentOID = rOID;
 734 }
 735
 736 bool ObjectKeyNavigation::first()
 737 {
 738     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 739     ObjectHierarchy::tChildContainer aSiblings( aHierarchy.getSiblings( getCurrentSelection() ) );
 740     bool bResult = !aSiblings.empty();
 741     if( bResult )
 742         setCurrentSelection( aSiblings.front());
 743     else
 744         bResult = veryFirst();
 745     return bResult;
 746 }
 747
 748 bool ObjectKeyNavigation::last()
 749 {
 750     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 751     ObjectHierarchy::tChildContainer aSiblings( aHierarchy.getSiblings( getCurrentSelection() ) );
 752     bool bResult = !aSiblings.empty();
 753     if( bResult )
 754         setCurrentSelection( aSiblings.back());
 755     else
 756         bResult = veryLast();
 757     return bResult;
 758 }
 759
 760 bool ObjectKeyNavigation::next()
 761 {
 762     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 763     ObjectHierarchy::tChildContainer aSiblings( aHierarchy.getSiblings( getCurrentSelection() ) );
 764     bool bResult = !aSiblings.empty();
 765     if( bResult )
 766     {
 767         ObjectHierarchy::tChildContainer::const_iterator aIt(
 768             std::find( aSiblings.begin(), aSiblings.end(), getCurrentSelection()));
 769         assert(aIt != aSiblings.end());
 770         if( ++aIt == aSiblings.end())
 771             aIt = aSiblings.begin();
 772         setCurrentSelection( *aIt );
 773     }
 774     else
 775         bResult = veryFirst();
 776
 777     return bResult;
 778 }
 779
 780 bool ObjectKeyNavigation::previous()
 781 {
 782     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 783     ObjectHierarchy::tChildContainer aSiblings( aHierarchy.getSiblings( getCurrentSelection()));
 784     bool bResult = !aSiblings.empty();
 785     if( bResult )
 786     {
 787         ObjectHierarchy::tChildContainer::const_iterator aIt(
 788             std::find( aSiblings.begin(), aSiblings.end(), getCurrentSelection()));
 789         OSL_ASSERT( aIt != aSiblings.end());
 790         if( aIt == aSiblings.begin())
 791             aIt = aSiblings.end();
 792         --aIt;
 793         setCurrentSelection( *aIt );
 794     }
 795     else
 796         bResult = veryLast();
 797     return bResult;
 798 }
 799
 800 bool ObjectKeyNavigation::up()
 801 {
 802     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 803     bool bResult = !ObjectHierarchy::isRootNode( getCurrentSelection());
 804     if( bResult )
 805         setCurrentSelection( aHierarchy.getParent( getCurrentSelection()));
 806     return bResult;
 807 }
 808
 809 bool ObjectKeyNavigation::down()
 810 {
 811     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 812     bool bResult = aHierarchy.hasChildren( getCurrentSelection());
 813     if( bResult )
 814     {
 815         ObjectHierarchy::tChildContainer aChildren = aHierarchy.getChildren( getCurrentSelection());
 816         OSL_ASSERT( !aChildren.empty());
 817         setCurrentSelection( aChildren.front());
 818     }
 819     return bResult;
 820 }
 821
 822 bool ObjectKeyNavigation::veryFirst()
 823 {
 824     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 825     ObjectHierarchy::tChildContainer aChildren( aHierarchy.getTopLevelChildren());
 826     bool bResult = !aChildren.empty();
 827     if( bResult )
 828         setCurrentSelection( aChildren.front());
 829     return bResult;
 830 }
 831
 832 bool ObjectKeyNavigation::veryLast()
 833 {
 834     ObjectHierarchy aHierarchy( m_xChartDocument, m_pExplicitValueProvider, true/*StepDownInDiagram*/ );
 835     ObjectHierarchy::tChildContainer aChildren( aHierarchy.getTopLevelChildren());
 836     bool bResult = !aChildren.empty();
 837     if( bResult )
 838         setCurrentSelection( aChildren.back());
 839     return bResult;
 840 }
 841
 842 } //  namespace chart
 843
 844 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */