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 "RegressionCurveHelper.hxx"
21 : #include "MeanValueRegressionCurveCalculator.hxx"
22 : #include "LinearRegressionCurveCalculator.hxx"
23 : #include "PolynomialRegressionCurveCalculator.hxx"
24 : #include "MovingAverageRegressionCurveCalculator.hxx"
25 : #include "LogarithmicRegressionCurveCalculator.hxx"
26 : #include "ExponentialRegressionCurveCalculator.hxx"
27 : #include "PotentialRegressionCurveCalculator.hxx"
28 : #include "CommonConverters.hxx"
29 : #include "RegressionCurveModel.hxx"
30 : #include "ChartTypeHelper.hxx"
31 : #include "ChartModelHelper.hxx"
32 : #include "macros.hxx"
33 : #include "PropertyHelper.hxx"
34 : #include "ResId.hxx"
35 : #include "Strings.hrc"
36 : #include "DiagramHelper.hxx"
37 : #include <com/sun/star/chart2/XChartDocument.hpp>
38 :
39 : using namespace ::com::sun::star;
40 : using namespace ::com::sun::star::chart2;
41 :
42 : using ::com::sun::star::uno::Reference;
43 : using ::com::sun::star::uno::Sequence;
44 : using ::com::sun::star::uno::XComponentContext;
45 : using ::com::sun::star::lang::XServiceName;
46 : using ::com::sun::star::beans::XPropertySet;
47 : using ::com::sun::star::uno::Exception;
48 :
49 : namespace
50 : {
51 0 : OUString lcl_getServiceNameForType( ::chart::RegressionCurveHelper::tRegressionType eType )
52 : {
53 0 : OUString aServiceName;
54 0 : switch( eType )
55 : {
56 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_LINEAR:
57 0 : aServiceName = "com.sun.star.chart2.LinearRegressionCurve";
58 0 : break;
59 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_LOG:
60 0 : aServiceName = "com.sun.star.chart2.LogarithmicRegressionCurve";
61 0 : break;
62 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_EXP:
63 0 : aServiceName = "com.sun.star.chart2.ExponentialRegressionCurve";
64 0 : break;
65 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_POWER:
66 0 : aServiceName = "com.sun.star.chart2.PotentialRegressionCurve";
67 0 : break;
68 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_POLYNOMIAL:
69 0 : aServiceName = "com.sun.star.chart2.PolynomialRegressionCurve";
70 0 : break;
71 : case ::chart::RegressionCurveHelper::REGRESSION_TYPE_MOVING_AVERAGE:
72 0 : aServiceName = "com.sun.star.chart2.MovingAverageRegressionCurve";
73 0 : break;
74 : default:
75 : OSL_FAIL("unknown regression curve type - use linear instead");
76 0 : aServiceName = "com.sun.star.chart2.LinearRegressionCurve";
77 0 : break;
78 : }
79 0 : return aServiceName;
80 : }
81 :
82 : } // anonymous namespace
83 :
84 : namespace chart
85 : {
86 :
87 4 : Reference< XRegressionCurve > RegressionCurveHelper::createMeanValueLine(
88 : const Reference< XComponentContext > & xContext )
89 : {
90 : return Reference< XRegressionCurve >(
91 4 : new MeanValueRegressionCurve( xContext ));
92 : }
93 :
94 0 : Reference< XRegressionCurve > RegressionCurveHelper::createRegressionCurveByServiceName(
95 : const Reference< XComponentContext > & xContext,
96 : const OUString& aServiceName )
97 : {
98 0 : Reference< XRegressionCurve > xResult;
99 :
100 : // todo: use factory methods with service name
101 0 : if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
102 : {
103 0 : xResult.set( new LinearRegressionCurve( xContext ) );
104 : }
105 0 : else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
106 : {
107 0 : xResult.set( new LogarithmicRegressionCurve( xContext ) );
108 : }
109 0 : else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
110 : {
111 0 : xResult.set( new ExponentialRegressionCurve( xContext ) );
112 : }
113 0 : else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
114 : {
115 0 : xResult.set( new PotentialRegressionCurve( xContext ) );
116 : }
117 0 : else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
118 : {
119 0 : xResult.set( new PolynomialRegressionCurve( xContext ) );
120 : }
121 0 : else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
122 : {
123 0 : xResult.set( new MovingAverageRegressionCurve( xContext ) );
124 : }
125 :
126 0 : return xResult;
127 : }
128 :
129 53 : Reference< XRegressionCurveCalculator > RegressionCurveHelper::createRegressionCurveCalculatorByServiceName(
130 : const OUString& aServiceName )
131 : {
132 53 : Reference< XRegressionCurveCalculator > xResult;
133 :
134 : // todo: use factory methods with service name
135 53 : if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
136 : {
137 32 : xResult.set( new MeanValueRegressionCurveCalculator() );
138 : }
139 53 : if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
140 : {
141 7 : xResult.set( new LinearRegressionCurveCalculator() );
142 : }
143 46 : else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
144 : {
145 0 : xResult.set( new LogarithmicRegressionCurveCalculator() );
146 : }
147 46 : else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
148 : {
149 0 : xResult.set( new ExponentialRegressionCurveCalculator() );
150 : }
151 46 : else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
152 : {
153 0 : xResult.set( new PotentialRegressionCurveCalculator() );
154 : }
155 46 : else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
156 : {
157 7 : xResult.set( new PolynomialRegressionCurveCalculator() );
158 : }
159 39 : else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
160 : {
161 7 : xResult.set( new MovingAverageRegressionCurveCalculator() );
162 : }
163 :
164 53 : return xResult;
165 : }
166 :
167 0 : void RegressionCurveHelper::initializeCurveCalculator(
168 : const Reference< XRegressionCurveCalculator > & xOutCurveCalculator,
169 : const Reference< data::XDataSource > & xSource,
170 : bool bUseXValuesIfAvailable /* = true */ )
171 : {
172 0 : if( ! (xOutCurveCalculator.is() &&
173 0 : xSource.is() ))
174 0 : return;
175 :
176 0 : Sequence< double > aXValues, aYValues;
177 0 : bool bXValuesFound = false, bYValuesFound = false;
178 :
179 0 : Sequence< Reference< data::XLabeledDataSequence > > aDataSeqs( xSource->getDataSequences());
180 0 : sal_Int32 i = 0;
181 0 : for( i=0;
182 0 : ! (bXValuesFound && bYValuesFound) && i<aDataSeqs.getLength();
183 : ++i )
184 : {
185 : try
186 : {
187 0 : Reference< data::XDataSequence > xSeq( aDataSeqs[i]->getValues());
188 0 : Reference< XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW );
189 0 : OUString aRole;
190 0 : if( xProp->getPropertyValue( "Role" ) >>= aRole )
191 : {
192 0 : if( bUseXValuesIfAvailable && !bXValuesFound && aRole == "values-x" )
193 : {
194 0 : aXValues = DataSequenceToDoubleSequence( xSeq );
195 0 : bXValuesFound = true;
196 : }
197 0 : else if( !bYValuesFound && aRole == "values-y" )
198 : {
199 0 : aYValues = DataSequenceToDoubleSequence( xSeq );
200 0 : bYValuesFound = true;
201 : }
202 0 : }
203 : }
204 0 : catch( const Exception & ex )
205 : {
206 : ASSERT_EXCEPTION( ex );
207 : }
208 : }
209 :
210 0 : if( ! bXValuesFound &&
211 : bYValuesFound )
212 : {
213 : // initialize with 1, 2, ...
214 : //first category (index 0) matches with real number 1.0
215 0 : aXValues.realloc( aYValues.getLength());
216 0 : for( i=0; i<aXValues.getLength(); ++i )
217 0 : aXValues[i] = i+1;
218 0 : bXValuesFound = true;
219 : }
220 :
221 0 : if( bXValuesFound && bYValuesFound &&
222 0 : aXValues.getLength() > 0 &&
223 0 : aYValues.getLength() > 0 )
224 0 : xOutCurveCalculator->recalculateRegression( aXValues, aYValues );
225 : }
226 :
227 0 : void RegressionCurveHelper::initializeCurveCalculator(
228 : const Reference< XRegressionCurveCalculator > & xOutCurveCalculator,
229 : const Reference< XDataSeries > & xSeries,
230 : const Reference< frame::XModel > & xModel )
231 : {
232 : sal_Int32 nAxisType = ChartTypeHelper::getAxisType(
233 0 : ChartModelHelper::getChartTypeOfSeries( xModel, xSeries ), 0 ); // x-axis
234 :
235 : initializeCurveCalculator( xOutCurveCalculator,
236 : uno::Reference< data::XDataSource >( xSeries, uno::UNO_QUERY ),
237 0 : (nAxisType == AxisType::REALNUMBER) );
238 0 : }
239 :
240 2497 : bool RegressionCurveHelper::hasMeanValueLine(
241 : const uno::Reference< XRegressionCurveContainer > & xRegCnt )
242 : {
243 2497 : if( !xRegCnt.is())
244 0 : return false;
245 :
246 : try
247 : {
248 : uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
249 2497 : xRegCnt->getRegressionCurves());
250 2515 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
251 : {
252 21 : if( isMeanValueLine( aCurves[i] ))
253 3 : return true;
254 2494 : }
255 : }
256 0 : catch( const Exception & ex )
257 : {
258 : ASSERT_EXCEPTION( ex );
259 : }
260 :
261 2494 : return false;
262 : }
263 :
264 134 : bool RegressionCurveHelper::isMeanValueLine(
265 : const uno::Reference< chart2::XRegressionCurve > & xRegCurve )
266 : {
267 134 : uno::Reference< XServiceName > xServName( xRegCurve, uno::UNO_QUERY );
268 670 : if( xServName.is() &&
269 134 : xServName->getServiceName().equals(
270 670 : "com.sun.star.chart2.MeanValueRegressionCurve"))
271 74 : return true;
272 60 : return false;
273 : }
274 :
275 : uno::Reference< chart2::XRegressionCurve >
276 1 : RegressionCurveHelper::getMeanValueLine(
277 : const uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
278 : {
279 1 : if( xRegCnt.is())
280 : {
281 : try
282 : {
283 : uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
284 1 : xRegCnt->getRegressionCurves());
285 1 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
286 : {
287 1 : if( isMeanValueLine( aCurves[i] ))
288 1 : return aCurves[i];
289 0 : }
290 : }
291 0 : catch( const Exception & ex )
292 : {
293 : ASSERT_EXCEPTION( ex );
294 : }
295 : }
296 :
297 0 : return uno::Reference< chart2::XRegressionCurve >();
298 : }
299 :
300 4 : void RegressionCurveHelper::addMeanValueLine(
301 : uno::Reference< XRegressionCurveContainer > & xRegCnt,
302 : const uno::Reference< XComponentContext > & xContext,
303 : const uno::Reference< XPropertySet > & xSeriesProp )
304 : {
305 8 : if( !xRegCnt.is() ||
306 4 : ::chart::RegressionCurveHelper::hasMeanValueLine( xRegCnt ) )
307 4 : return;
308 :
309 : // todo: use a valid context
310 4 : uno::Reference< XRegressionCurve > xCurve( createMeanValueLine( xContext ));
311 4 : xRegCnt->addRegressionCurve( xCurve );
312 :
313 4 : if( xSeriesProp.is())
314 : {
315 0 : uno::Reference< XPropertySet > xProp( xCurve, uno::UNO_QUERY );
316 0 : if( xProp.is())
317 : {
318 0 : xProp->setPropertyValue( "LineColor",
319 0 : xSeriesProp->getPropertyValue( "Color"));
320 0 : }
321 4 : }
322 : }
323 :
324 184 : void RegressionCurveHelper::removeMeanValueLine(
325 : Reference< XRegressionCurveContainer > & xRegCnt )
326 : {
327 184 : if( !xRegCnt.is())
328 184 : return;
329 :
330 : try
331 : {
332 : Sequence< Reference< XRegressionCurve > > aCurves(
333 184 : xRegCnt->getRegressionCurves());
334 184 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
335 : {
336 0 : if( isMeanValueLine( aCurves[i] ))
337 : {
338 0 : xRegCnt->removeRegressionCurve( aCurves[i] );
339 : // attention: the iterator i has become invalid now
340 :
341 : // note: assume that there is only one mean-value curve
342 : // to remove multiple mean-value curves remove the break
343 0 : break;
344 : }
345 184 : }
346 : }
347 0 : catch( const Exception & ex )
348 : {
349 : ASSERT_EXCEPTION( ex );
350 : }
351 : }
352 :
353 0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::addRegressionCurve(
354 : tRegressionType eType,
355 : uno::Reference< XRegressionCurveContainer >& xRegressionCurveContainer,
356 : const uno::Reference< XComponentContext >& /* xContext */,
357 : const uno::Reference< beans::XPropertySet >& xPropertySource,
358 : const uno::Reference< beans::XPropertySet >& xEquationProperties )
359 : {
360 0 : uno::Reference< chart2::XRegressionCurve > xCurve;
361 :
362 0 : if( !xRegressionCurveContainer.is() )
363 0 : return xCurve;
364 :
365 0 : if( eType == REGRESSION_TYPE_NONE )
366 : {
367 : OSL_FAIL("don't create a regression curve of type none");
368 0 : return xCurve;
369 : }
370 :
371 0 : OUString aServiceName( lcl_getServiceNameForType( eType ));
372 0 : if( !aServiceName.isEmpty())
373 : {
374 : // todo: use a valid context
375 : xCurve.set( createRegressionCurveByServiceName(
376 0 : uno::Reference< uno::XComponentContext >(), aServiceName ));
377 :
378 0 : if( xEquationProperties.is())
379 0 : xCurve->setEquationProperties( xEquationProperties );
380 :
381 0 : uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
382 0 : if( xProperties.is())
383 : {
384 0 : if( xPropertySource.is())
385 0 : comphelper::copyProperties( xPropertySource, xProperties );
386 : else
387 : {
388 0 : uno::Reference< XPropertySet > xSeriesProp( xRegressionCurveContainer, uno::UNO_QUERY );
389 0 : if( xSeriesProp.is())
390 : {
391 0 : xProperties->setPropertyValue( "LineColor",
392 0 : xSeriesProp->getPropertyValue( "Color"));
393 0 : }
394 : }
395 0 : }
396 : }
397 0 : xRegressionCurveContainer->addRegressionCurve( xCurve );
398 :
399 0 : return xCurve;
400 : }
401 :
402 : /** removes all regression curves that are not of type mean value
403 : and returns true, if anything was removed
404 : */
405 0 : bool RegressionCurveHelper::removeAllExceptMeanValueLine(
406 : uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
407 : {
408 0 : bool bRemovedSomething = false;
409 0 : if( xRegCnt.is())
410 : {
411 : try
412 : {
413 : uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
414 0 : xRegCnt->getRegressionCurves());
415 0 : ::std::vector< uno::Reference< chart2::XRegressionCurve > > aCurvesToDelete;
416 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
417 : {
418 0 : if( ! isMeanValueLine( aCurves[i] ))
419 : {
420 0 : aCurvesToDelete.push_back( aCurves[ i ] );
421 : }
422 : }
423 :
424 0 : for( ::std::vector< uno::Reference< chart2::XRegressionCurve > >::const_iterator aIt = aCurvesToDelete.begin();
425 0 : aIt != aCurvesToDelete.end(); ++aIt )
426 : {
427 0 : xRegCnt->removeRegressionCurve( *aIt );
428 0 : bRemovedSomething = true;
429 0 : }
430 : }
431 0 : catch( const uno::Exception & ex )
432 : {
433 : ASSERT_EXCEPTION( ex );
434 : }
435 : }
436 0 : return bRemovedSomething;
437 : }
438 :
439 0 : void RegressionCurveHelper::removeEquations(
440 : uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
441 : {
442 0 : if( xRegCnt.is())
443 : {
444 : try
445 : {
446 : uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
447 0 : xRegCnt->getRegressionCurves());
448 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
449 : {
450 0 : if( !isMeanValueLine( aCurves[i] ) )
451 : {
452 0 : uno::Reference< chart2::XRegressionCurve > xRegCurve( aCurves[ i ] );
453 0 : if( xRegCurve.is() )
454 : {
455 0 : uno::Reference< beans::XPropertySet > xEqProp( xRegCurve->getEquationProperties() ) ;
456 0 : if( xEqProp.is())
457 : {
458 0 : xEqProp->setPropertyValue( "ShowEquation", uno::makeAny( false ));
459 0 : xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( false ));
460 0 : }
461 0 : }
462 : }
463 0 : }
464 : }
465 0 : catch( const uno::Exception & ex )
466 : {
467 : ASSERT_EXCEPTION( ex );
468 : }
469 : }
470 0 : }
471 :
472 0 : uno::Reference< XRegressionCurve > RegressionCurveHelper::changeRegressionCurveType(
473 : tRegressionType eType,
474 : uno::Reference< XRegressionCurveContainer > & xRegressionCurveContainer,
475 : uno::Reference< XRegressionCurve > & xRegressionCurve,
476 : const uno::Reference< XComponentContext > & xContext )
477 : {
478 0 : xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );
479 : return RegressionCurveHelper::addRegressionCurve(
480 : eType,
481 : xRegressionCurveContainer,
482 : xContext,
483 : uno::Reference< beans::XPropertySet >( xRegressionCurve, uno::UNO_QUERY ),
484 0 : xRegressionCurve->getEquationProperties());
485 : }
486 :
487 0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getFirstCurveNotMeanValueLine(
488 : const Reference< XRegressionCurveContainer > & xRegCnt )
489 : {
490 0 : if( !xRegCnt.is())
491 0 : return NULL;
492 :
493 : try
494 : {
495 : uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
496 0 : xRegCnt->getRegressionCurves());
497 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
498 : {
499 0 : if( ! isMeanValueLine( aCurves[i] ))
500 : {
501 0 : return aCurves[ i ];
502 : }
503 0 : }
504 : }
505 0 : catch( const Exception & ex )
506 : {
507 : ASSERT_EXCEPTION( ex );
508 : }
509 :
510 0 : return NULL;
511 : }
512 :
513 0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getRegressionCurveAtIndex(
514 : const Reference< XRegressionCurveContainer >& xCurveContainer,
515 : sal_Int32 aIndex )
516 : {
517 0 : if( !xCurveContainer.is())
518 0 : return NULL;
519 :
520 : try
521 : {
522 0 : uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(xCurveContainer->getRegressionCurves());
523 0 : if(0 <= aIndex && aIndex < aCurves.getLength())
524 : {
525 0 : if(!isMeanValueLine(aCurves[aIndex]))
526 0 : return aCurves[aIndex];
527 0 : }
528 : }
529 0 : catch( const Exception & ex )
530 : {
531 : ASSERT_EXCEPTION( ex );
532 : }
533 :
534 0 : return NULL;
535 : }
536 :
537 0 : RegressionCurveHelper::tRegressionType RegressionCurveHelper::getRegressionType(
538 : const Reference< XRegressionCurve > & xCurve )
539 : {
540 0 : tRegressionType eResult = REGRESSION_TYPE_UNKNOWN;
541 :
542 : try
543 : {
544 0 : Reference< lang::XServiceName > xServName( xCurve, uno::UNO_QUERY );
545 0 : if( xServName.is())
546 : {
547 0 : OUString aServiceName( xServName->getServiceName() );
548 :
549 0 : if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
550 : {
551 0 : eResult = REGRESSION_TYPE_LINEAR;
552 : }
553 0 : else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
554 : {
555 0 : eResult = REGRESSION_TYPE_LOG;
556 : }
557 0 : else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
558 : {
559 0 : eResult = REGRESSION_TYPE_EXP;
560 : }
561 0 : else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
562 : {
563 0 : eResult = REGRESSION_TYPE_POWER;
564 : }
565 0 : else if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
566 : {
567 0 : eResult = REGRESSION_TYPE_MEAN_VALUE;
568 : }
569 0 : else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
570 : {
571 0 : eResult = REGRESSION_TYPE_POLYNOMIAL;
572 : }
573 0 : else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
574 : {
575 0 : eResult = REGRESSION_TYPE_MOVING_AVERAGE;
576 0 : }
577 0 : }
578 : }
579 0 : catch( const Exception & ex )
580 : {
581 : ASSERT_EXCEPTION( ex );
582 : }
583 :
584 0 : return eResult;
585 : }
586 :
587 0 : RegressionCurveHelper::tRegressionType RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
588 : const Reference< XRegressionCurveContainer > & xRegCnt )
589 : {
590 0 : tRegressionType eResult = REGRESSION_TYPE_NONE;
591 :
592 0 : if( xRegCnt.is())
593 : {
594 : Sequence< Reference< XRegressionCurve > > aCurves(
595 0 : xRegCnt->getRegressionCurves());
596 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
597 : {
598 0 : tRegressionType eType = getRegressionType( aCurves[i] );
599 0 : if( eType != REGRESSION_TYPE_MEAN_VALUE &&
600 : eType != REGRESSION_TYPE_UNKNOWN )
601 : {
602 0 : eResult = eType;
603 0 : break;
604 : }
605 0 : }
606 : }
607 :
608 0 : return eResult;
609 : }
610 :
611 53 : OUString RegressionCurveHelper::getUINameForRegressionCurve( const Reference< XRegressionCurve >& xRegressionCurve )
612 : {
613 53 : OUString aResult = getRegressionCurveSpecificName(xRegressionCurve);
614 53 : if (aResult.isEmpty())
615 : {
616 32 : aResult = getRegressionCurveGenericName(xRegressionCurve);
617 32 : if (!aResult.isEmpty())
618 : {
619 32 : aResult += " (%SERIESNAME)";
620 : }
621 : }
622 53 : return aResult;
623 : }
624 :
625 32 : OUString RegressionCurveHelper::getRegressionCurveGenericName(const Reference< XRegressionCurve >& xRegressionCurve)
626 : {
627 32 : OUString aResult;
628 32 : if(!xRegressionCurve.is())
629 0 : return aResult;
630 :
631 64 : Reference< lang::XServiceName > xServiceName( xRegressionCurve, uno::UNO_QUERY );
632 32 : if(!xServiceName.is())
633 0 : return aResult;
634 :
635 64 : OUString aServiceName(xServiceName->getServiceName());
636 :
637 32 : if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
638 : {
639 32 : aResult = SCH_RESSTR(STR_REGRESSION_MEAN);
640 : }
641 0 : else if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
642 : {
643 0 : aResult = SCH_RESSTR(STR_REGRESSION_LINEAR);
644 : }
645 0 : else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
646 : {
647 0 : aResult = SCH_RESSTR(STR_REGRESSION_LOG);
648 : }
649 0 : else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
650 : {
651 0 : aResult = SCH_RESSTR(STR_REGRESSION_EXP);
652 : }
653 0 : else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
654 : {
655 0 : aResult = SCH_RESSTR(STR_REGRESSION_POWER);
656 : }
657 0 : else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
658 : {
659 0 : aResult = SCH_RESSTR(STR_REGRESSION_POLYNOMIAL);
660 : }
661 0 : else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
662 : {
663 0 : aResult = SCH_RESSTR(STR_REGRESSION_MOVING_AVERAGE);
664 : }
665 32 : return aResult;
666 : }
667 :
668 53 : OUString RegressionCurveHelper::getRegressionCurveSpecificName(const Reference< XRegressionCurve >& xRegressionCurve)
669 : {
670 53 : OUString aResult;
671 :
672 53 : if(!xRegressionCurve.is())
673 0 : return aResult;
674 :
675 106 : Reference<XPropertySet> xProperties( xRegressionCurve, uno::UNO_QUERY );
676 53 : if(!xProperties.is())
677 0 : return aResult;
678 :
679 53 : xProperties->getPropertyValue("CurveName") >>= aResult;
680 :
681 53 : return aResult;
682 : }
683 :
684 0 : OUString RegressionCurveHelper::getRegressionCurveName( const Reference< XRegressionCurve >& xRegressionCurve )
685 : {
686 0 : OUString aResult = getRegressionCurveSpecificName(xRegressionCurve);
687 0 : if (aResult.isEmpty())
688 0 : return getRegressionCurveGenericName(xRegressionCurve);
689 0 : return aResult;
690 : }
691 :
692 : std::vector< Reference< chart2::XRegressionCurve > >
693 0 : RegressionCurveHelper::getAllRegressionCurvesNotMeanValueLine(
694 : const Reference< chart2::XDiagram > & xDiagram )
695 : {
696 0 : std::vector< Reference< chart2::XRegressionCurve > > aResult;
697 0 : std::vector< Reference< chart2::XDataSeries > > aSeries( DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
698 0 : for( std::vector< Reference< chart2::XDataSeries > >::iterator aIt( aSeries.begin());
699 0 : aIt != aSeries.end(); ++aIt )
700 : {
701 0 : Reference< chart2::XRegressionCurveContainer > xContainer( *aIt, uno::UNO_QUERY );
702 0 : if(xContainer.is())
703 : {
704 0 : uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(xContainer->getRegressionCurves());
705 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
706 : {
707 0 : if( ! isMeanValueLine( aCurves[i] ))
708 0 : aResult.push_back( aCurves[i] );
709 0 : }
710 : }
711 0 : }
712 :
713 0 : return aResult;
714 : }
715 :
716 0 : void RegressionCurveHelper::resetEquationPosition(
717 : const Reference< chart2::XRegressionCurve > & xCurve )
718 : {
719 0 : if( xCurve.is())
720 : {
721 : try
722 : {
723 0 : const OUString aPosPropertyName( "RelativePosition" );
724 0 : Reference< beans::XPropertySet > xEqProp( xCurve->getEquationProperties()); // since m233: , uno::UNO_SET_THROW );
725 0 : if( xEqProp->getPropertyValue( aPosPropertyName ).hasValue())
726 0 : xEqProp->setPropertyValue( aPosPropertyName, uno::Any());
727 : }
728 0 : catch( const uno::Exception & ex )
729 : {
730 : ASSERT_EXCEPTION( ex );
731 : }
732 : }
733 0 : }
734 :
735 0 : sal_Int32 RegressionCurveHelper::getRegressionCurveIndex(
736 : const Reference< chart2::XRegressionCurveContainer >& xContainer,
737 : const Reference< chart2::XRegressionCurve >& xCurve )
738 : {
739 0 : if( xContainer.is())
740 : {
741 : uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
742 0 : xContainer->getRegressionCurves());
743 :
744 0 : for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
745 : {
746 0 : if( xCurve == aCurves[i] )
747 0 : return i;
748 0 : }
749 : }
750 0 : return -1;
751 : }
752 :
753 6 : bool RegressionCurveHelper::hasEquation( const Reference< chart2::XRegressionCurve > & xCurve )
754 : {
755 6 : bool bHasEquation = false;
756 6 : if( xCurve.is())
757 : {
758 6 : uno::Reference< beans::XPropertySet > xEquationProp( xCurve->getEquationProperties());
759 6 : if( xEquationProp.is())
760 : {
761 6 : bool bShowEquation = false;
762 6 : bool bShowCoefficient = false;
763 6 : xEquationProp->getPropertyValue( "ShowEquation") >>= bShowEquation;
764 6 : xEquationProp->getPropertyValue( "ShowCorrelationCoefficient") >>= bShowCoefficient;
765 6 : bHasEquation = bShowEquation || bShowCoefficient;
766 6 : }
767 : }
768 6 : return bHasEquation;
769 : }
770 :
771 : } //namespace chart
772 :
773 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
