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