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