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 "StatisticsItemConverter.hxx"
27 #include "SchWhichPairs.hxx"
28 #include "macros.hxx"
29 #include "RegressionCurveHelper.hxx"
30 #include "ItemPropertyMap.hxx"
31 #include "ErrorBar.hxx"
32 #include "PropertyHelper.hxx"
33 #include "ChartModelHelper.hxx"
34 #include "ChartTypeHelper.hxx"
35 #include "StatisticsHelper.hxx"
36
37 #include "GraphicPropertyItemConverter.hxx"
38
39 #include <svl/stritem.hxx>
40 #include <svx/chrtitem.hxx>
41 #include <svl/intitem.hxx>
42 #include <rtl/math.hxx>
43
44 #include <com/sun/star/chart2/DataPointLabel.hpp>
45 #include <com/sun/star/chart2/XInternalDataProvider.hpp>
46 #include <com/sun/star/chart/ErrorBarStyle.hpp>
47 #include <com/sun/star/lang/XServiceName.hpp>
48
49 #include <functional>
50 #include <algorithm>
51 #include <vector>
52
53 using namespace ::com::sun::star;
54
55 namespace
56 {
57
lcl_GetYErrorBar(const uno::Reference<beans::XPropertySet> & xProp)58 uno::Reference< beans::XPropertySet > lcl_GetYErrorBar(
59 const uno::Reference< beans::XPropertySet > & xProp )
60 {
61 uno::Reference< beans::XPropertySet > xResult;
62
63 if( xProp.is())
64 try
65 {
66 ( xProp->getPropertyValue( C2U( "ErrorBarY" )) >>= xResult );
67 }
68 catch( uno::Exception & ex )
69 {
70 ASSERT_EXCEPTION( ex );
71 }
72
73 return xResult;
74 }
75
lcl_convertRegressionType(SvxChartRegress eRegress)76 ::chart::RegressionCurveHelper::tRegressionType lcl_convertRegressionType( SvxChartRegress eRegress )
77 {
78 ::chart::RegressionCurveHelper::tRegressionType eType = ::chart::RegressionCurveHelper::REGRESSION_TYPE_NONE;
79 switch( eRegress )
80 {
81 case CHREGRESS_LINEAR:
82 eType = ::chart::RegressionCurveHelper::REGRESSION_TYPE_LINEAR;
83 break;
84 case CHREGRESS_LOG:
85 eType = ::chart::RegressionCurveHelper::REGRESSION_TYPE_LOG;
86 break;
87 case CHREGRESS_EXP:
88 eType = ::chart::RegressionCurveHelper::REGRESSION_TYPE_EXP;
89 break;
90 case CHREGRESS_POWER:
91 eType = ::chart::RegressionCurveHelper::REGRESSION_TYPE_POWER;
92 break;
93 case CHREGRESS_NONE:
94 break;
95 }
96 return eType;
97 }
98
99
lcl_GetDefaultErrorBar()100 uno::Reference< beans::XPropertySet > lcl_GetDefaultErrorBar()
101 {
102 // todo: use a valid context
103 return uno::Reference< beans::XPropertySet >(
104 ::chart::createErrorBar( uno::Reference< uno::XComponentContext >()));
105 }
106
lcl_getErrorValues(const uno::Reference<beans::XPropertySet> & xErrorBarProp,double & rOutPosError,double & rOutNegError)107 void lcl_getErrorValues( const uno::Reference< beans::XPropertySet > & xErrorBarProp,
108 double & rOutPosError, double & rOutNegError )
109 {
110 if( ! xErrorBarProp.is())
111 return;
112
113 try
114 {
115 xErrorBarProp->getPropertyValue( C2U( "PositiveError" )) >>= rOutPosError;
116 xErrorBarProp->getPropertyValue( C2U( "NegativeError" )) >>= rOutNegError;
117 }
118 catch( uno::Exception & ex )
119 {
120 ASSERT_EXCEPTION( ex );
121 }
122 }
123
lcl_getErrorIndicatorValues(const uno::Reference<beans::XPropertySet> & xErrorBarProp,bool & rOutShowPosError,bool & rOutShowNegError)124 void lcl_getErrorIndicatorValues(
125 const uno::Reference< beans::XPropertySet > & xErrorBarProp,
126 bool & rOutShowPosError, bool & rOutShowNegError )
127 {
128 if( ! xErrorBarProp.is())
129 return;
130
131 try
132 {
133 xErrorBarProp->getPropertyValue( C2U( "ShowPositiveError" )) >>= rOutShowPosError;
134 xErrorBarProp->getPropertyValue( C2U( "ShowNegativeError" )) >>= rOutShowNegError;
135 }
136 catch( uno::Exception & ex )
137 {
138 ASSERT_EXCEPTION( ex );
139 }
140 }
141
lcl_getEquationProperties(const uno::Reference<beans::XPropertySet> & xSeriesPropSet,const SfxItemSet * pItemSet)142 uno::Reference< beans::XPropertySet > lcl_getEquationProperties(
143 const uno::Reference< beans::XPropertySet > & xSeriesPropSet, const SfxItemSet * pItemSet )
144 {
145 bool bEquationExists = true;
146
147 // ensure that a trendline is on
148 if( pItemSet )
149 {
150 SvxChartRegress eRegress = CHREGRESS_NONE;
151 const SfxPoolItem *pPoolItem = NULL;
152 if( pItemSet->GetItemState( SCHATTR_REGRESSION_TYPE, sal_True, &pPoolItem ) == SFX_ITEM_SET )
153 {
154 eRegress = static_cast< const SvxChartRegressItem * >( pPoolItem )->GetValue();
155 bEquationExists = ( eRegress != CHREGRESS_NONE );
156 }
157 }
158
159 if( bEquationExists )
160 {
161 uno::Reference< chart2::XRegressionCurveContainer > xRegCnt( xSeriesPropSet, uno::UNO_QUERY );
162 uno::Reference< chart2::XRegressionCurve > xCurve(
163 ::chart::RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt ));
164 if( xCurve.is())
165 {
166 return xCurve->getEquationProperties();
167 }
168 }
169
170 return uno::Reference< beans::XPropertySet >();
171 }
172
173 } // anonymous namespace
174
175 namespace chart
176 {
177 namespace wrapper
178 {
179
StatisticsItemConverter(const uno::Reference<frame::XModel> & xModel,const uno::Reference<beans::XPropertySet> & rPropertySet,SfxItemPool & rItemPool)180 StatisticsItemConverter::StatisticsItemConverter(
181 const uno::Reference< frame::XModel > & xModel,
182 const uno::Reference< beans::XPropertySet > & rPropertySet,
183 SfxItemPool& rItemPool ) :
184 ItemConverter( rPropertySet, rItemPool ),
185 m_xModel( xModel )
186 {
187 OSL_ASSERT( static_cast< int >( RegressionCurveHelper::REGRESSION_TYPE_NONE ) ==
188 static_cast< int >( CHREGRESS_NONE ));
189 OSL_ASSERT( static_cast< int >( RegressionCurveHelper::REGRESSION_TYPE_LINEAR ) ==
190 static_cast< int >( CHREGRESS_LINEAR ));
191 OSL_ASSERT( static_cast< int >( RegressionCurveHelper::REGRESSION_TYPE_LOG ) ==
192 static_cast< int >( CHREGRESS_LOG ));
193 OSL_ASSERT( static_cast< int >( RegressionCurveHelper::REGRESSION_TYPE_EXP ) ==
194 static_cast< int >( CHREGRESS_EXP ));
195 OSL_ASSERT( static_cast< int >( RegressionCurveHelper::REGRESSION_TYPE_POWER ) ==
196 static_cast< int >( CHREGRESS_POWER ));
197 }
198
~StatisticsItemConverter()199 StatisticsItemConverter::~StatisticsItemConverter()
200 {}
201
GetWhichPairs() const202 const sal_uInt16 * StatisticsItemConverter::GetWhichPairs() const
203 {
204 // must span all used items!
205 return nStatWhichPairs;
206 }
207
GetItemProperty(tWhichIdType,tPropertyNameWithMemberId &) const208 bool StatisticsItemConverter::GetItemProperty(
209 tWhichIdType /* nWhichId */,
210 tPropertyNameWithMemberId & /* rOutProperty */ ) const
211 {
212 return false;
213 }
214
ApplySpecialItem(sal_uInt16 nWhichId,const SfxItemSet & rItemSet)215 bool StatisticsItemConverter::ApplySpecialItem(
216 sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
217 throw( uno::Exception )
218 {
219 bool bChanged = false;
220 uno::Any aValue;
221
222 switch( nWhichId )
223 {
224 case SCHATTR_STAT_AVERAGE:
225 {
226 uno::Reference< chart2::XRegressionCurveContainer > xRegCnt(
227 GetPropertySet(), uno::UNO_QUERY );
228 bool bOldHasMeanValueLine = RegressionCurveHelper::hasMeanValueLine( xRegCnt );
229
230 bool bNewHasMeanValueLine =
231 static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
232
233 if( bOldHasMeanValueLine != bNewHasMeanValueLine )
234 {
235 if( ! bNewHasMeanValueLine )
236 RegressionCurveHelper::removeMeanValueLine( xRegCnt );
237 else
238 RegressionCurveHelper::addMeanValueLine(
239 xRegCnt, uno::Reference< uno::XComponentContext >(), GetPropertySet() );
240 bChanged = true;
241 }
242 }
243 break;
244
245 // Attention !!! This case must be passed before SCHATTR_STAT_PERCENT,
246 // SCHATTR_STAT_BIGERROR, SCHATTR_STAT_CONSTPLUS,
247 // SCHATTR_STAT_CONSTMINUS and SCHATTR_STAT_INDICATE
248 case SCHATTR_STAT_KIND_ERROR:
249 {
250 uno::Reference< beans::XPropertySet > xErrorBarProp(
251 lcl_GetYErrorBar( GetPropertySet() ));
252
253 SvxChartKindError eErrorKind =
254 static_cast< const SvxChartKindErrorItem & >(
255 rItemSet.Get( nWhichId )).GetValue();
256
257 if( !xErrorBarProp.is() && eErrorKind == CHERROR_NONE)
258 {
259 //nothing to do
260 }
261 else
262 {
263 sal_Int32 nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE;
264
265 switch( eErrorKind )
266 {
267 case CHERROR_NONE:
268 nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE; break;
269 case CHERROR_VARIANT:
270 nStyle = ::com::sun::star::chart::ErrorBarStyle::VARIANCE; break;
271 case CHERROR_SIGMA:
272 nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION; break;
273 case CHERROR_PERCENT:
274 nStyle = ::com::sun::star::chart::ErrorBarStyle::RELATIVE; break;
275 case CHERROR_BIGERROR:
276 nStyle = ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN; break;
277 case CHERROR_CONST:
278 nStyle = ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE; break;
279 case CHERROR_STDERROR:
280 nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR; break;
281 case CHERROR_RANGE:
282 nStyle = ::com::sun::star::chart::ErrorBarStyle::FROM_DATA; break;
283 }
284
285 if( !xErrorBarProp.is() )
286 {
287 xErrorBarProp = lcl_GetDefaultErrorBar();
288 GetPropertySet()->setPropertyValue(
289 C2U( "ErrorBarY" ), uno::makeAny( xErrorBarProp ));
290 }
291
292 xErrorBarProp->setPropertyValue( C2U( "ErrorBarStyle" ),
293 uno::makeAny( nStyle ));
294 bChanged = true;
295 }
296 }
297 break;
298
299 case SCHATTR_STAT_PERCENT:
300 case SCHATTR_STAT_BIGERROR:
301 {
302 OSL_ENSURE( false, "Deprectaed item" );
303 uno::Reference< beans::XPropertySet > xErrorBarProp(
304 lcl_GetYErrorBar( GetPropertySet()));
305 bool bOldHasErrorBar = xErrorBarProp.is();
306
307 double fValue =
308 static_cast< const SvxDoubleItem & >(
309 rItemSet.Get( nWhichId )).GetValue();
310 double fPos, fNeg;
311 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
312
313 if( bOldHasErrorBar &&
314 ! ( ::rtl::math::approxEqual( fPos, fValue ) &&
315 ::rtl::math::approxEqual( fNeg, fValue )))
316 {
317 xErrorBarProp->setPropertyValue( C2U( "PositiveError" ),
318 uno::makeAny( fValue ));
319 xErrorBarProp->setPropertyValue( C2U( "NegativeError" ),
320 uno::makeAny( fValue ));
321 bChanged = true;
322 }
323 }
324 break;
325
326 case SCHATTR_STAT_CONSTPLUS:
327 {
328 uno::Reference< beans::XPropertySet > xErrorBarProp(
329 lcl_GetYErrorBar( GetPropertySet()));
330 bool bOldHasErrorBar = xErrorBarProp.is();
331
332 double fValue =
333 static_cast< const SvxDoubleItem & >(
334 rItemSet.Get( nWhichId )).GetValue();
335 double fPos, fNeg;
336 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
337
338 if( bOldHasErrorBar &&
339 ! ::rtl::math::approxEqual( fPos, fValue ))
340 {
341 xErrorBarProp->setPropertyValue( C2U( "PositiveError" ), uno::makeAny( fValue ));
342 bChanged = true;
343 }
344 }
345 break;
346
347 case SCHATTR_STAT_CONSTMINUS:
348 {
349 uno::Reference< beans::XPropertySet > xErrorBarProp(
350 lcl_GetYErrorBar( GetPropertySet()));
351 bool bOldHasErrorBar = xErrorBarProp.is();
352
353 double fValue =
354 static_cast< const SvxDoubleItem & >(
355 rItemSet.Get( nWhichId )).GetValue();
356 double fPos, fNeg;
357 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
358
359 if( bOldHasErrorBar &&
360 ! ::rtl::math::approxEqual( fNeg, fValue ))
361 {
362 xErrorBarProp->setPropertyValue( C2U( "NegativeError" ), uno::makeAny( fValue ));
363 bChanged = true;
364 }
365 }
366 break;
367
368 case SCHATTR_REGRESSION_TYPE:
369 {
370 SvxChartRegress eRegress =
371 static_cast< const SvxChartRegressItem & >(
372 rItemSet.Get( nWhichId )).GetValue();
373
374 uno::Reference< chart2::XRegressionCurveContainer > xRegCnt(
375 GetPropertySet(), uno::UNO_QUERY );
376
377 if( eRegress == CHREGRESS_NONE )
378 {
379 bChanged = RegressionCurveHelper::removeAllExceptMeanValueLine( xRegCnt );
380 }
381 else
382 {
383 SvxChartRegress eOldRegress(
384 static_cast< SvxChartRegress >(
385 static_cast< sal_Int32 >(
386 RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine( xRegCnt ))));
387 if( eOldRegress != eRegress )
388 {
389 RegressionCurveHelper::replaceOrAddCurveAndReduceToOne(
390 lcl_convertRegressionType( eRegress ), xRegCnt,
391 uno::Reference< uno::XComponentContext >());
392 bChanged = true;
393 }
394 }
395 }
396 break;
397
398 case SCHATTR_REGRESSION_SHOW_EQUATION:
399 {
400 uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), &rItemSet ));
401 if( xEqProp.is())
402 {
403 bool bShowEq = false;
404 xEqProp->getPropertyValue( C2U("ShowEquation")) >>= bShowEq;
405 bool bNewShowEq =
406 static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
407 if( bShowEq != bNewShowEq )
408 {
409 xEqProp->setPropertyValue( C2U("ShowEquation"), uno::makeAny( bNewShowEq ));
410 bChanged = true;
411 }
412 }
413 }
414 break;
415
416 case SCHATTR_REGRESSION_SHOW_COEFF:
417 {
418 uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), &rItemSet ));
419 if( xEqProp.is())
420 {
421 bool bShowCoeff = false;
422 xEqProp->getPropertyValue( C2U("ShowCorrelationCoefficient")) >>= bShowCoeff;
423 bool bNewShowCoeff =
424 static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
425 if( bShowCoeff != bNewShowCoeff )
426 {
427 xEqProp->setPropertyValue( C2U("ShowCorrelationCoefficient"), uno::makeAny( bNewShowCoeff ));
428 bChanged = true;
429 }
430 }
431 }
432 break;
433
434 case SCHATTR_STAT_INDICATE:
435 {
436 uno::Reference< beans::XPropertySet > xErrorBarProp(
437 lcl_GetYErrorBar( GetPropertySet()));
438 bool bOldHasErrorBar = xErrorBarProp.is();
439
440 SvxChartIndicate eIndicate =
441 static_cast< const SvxChartIndicateItem & >(
442 rItemSet.Get( nWhichId )).GetValue();
443
444 bool bNewIndPos = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_UP );
445 bool bNewIndNeg = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_DOWN );
446
447 bool bShowPos, bShowNeg;
448 lcl_getErrorIndicatorValues( xErrorBarProp, bShowPos, bShowNeg );
449
450 if( bOldHasErrorBar &&
451 ( bShowPos != bNewIndPos ||
452 bShowNeg != bNewIndNeg ))
453 {
454 xErrorBarProp->setPropertyValue( C2U( "ShowPositiveError" ), uno::makeAny( bNewIndPos ));
455 xErrorBarProp->setPropertyValue( C2U( "ShowNegativeError" ), uno::makeAny( bNewIndNeg ));
456 bChanged = true;
457 }
458 }
459 break;
460
461 case SCHATTR_STAT_RANGE_POS:
462 case SCHATTR_STAT_RANGE_NEG:
463 {
464 // @todo: also be able to deal with x-error bars
465 const bool bYError = true;
466 uno::Reference< chart2::data::XDataSource > xErrorBarSource( lcl_GetYErrorBar( GetPropertySet()), uno::UNO_QUERY );
467 uno::Reference< chart2::XChartDocument > xChartDoc( m_xModel, uno::UNO_QUERY );
468 uno::Reference< chart2::data::XDataProvider > xDataProvider;
469
470 if( xChartDoc.is())
471 xDataProvider.set( xChartDoc->getDataProvider());
472 if( xErrorBarSource.is() && xDataProvider.is())
473 {
474 ::rtl::OUString aNewRange( static_cast< const SfxStringItem & >( rItemSet.Get( nWhichId )).GetValue());
475 bool bApplyNewRange = false;
476
477 bool bIsPositiveValue( nWhichId == SCHATTR_STAT_RANGE_POS );
478 if( xChartDoc->hasInternalDataProvider())
479 {
480 if( !aNewRange.isEmpty() )
481 {
482 uno::Reference< chart2::data::XDataSequence > xSeq(
483 StatisticsHelper::getErrorDataSequenceFromDataSource(
484 xErrorBarSource, bIsPositiveValue, bYError ));
485 if( ! xSeq.is())
486 {
487 // no data range for error bars yet => create
488 uno::Reference< chart2::XInternalDataProvider > xIntDataProvider( xDataProvider, uno::UNO_QUERY );
489 OSL_ASSERT( xIntDataProvider.is());
490 if( xIntDataProvider.is())
491 {
492 xIntDataProvider->appendSequence();
493 aNewRange = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("last"));
494 bApplyNewRange = true;
495 }
496 }
497 }
498 }
499 else
500 {
501 uno::Reference< chart2::data::XDataSequence > xSeq(
502 StatisticsHelper::getErrorDataSequenceFromDataSource(
503 xErrorBarSource, bIsPositiveValue, bYError ));
504 bApplyNewRange =
505 ! ( xSeq.is() && aNewRange.equals( xSeq->getSourceRangeRepresentation()));
506 }
507
508 if( bApplyNewRange )
509 StatisticsHelper::setErrorDataSequence(
510 xErrorBarSource, xDataProvider, aNewRange, bIsPositiveValue, bYError );
511 }
512 }
513 break;
514 }
515
516 return bChanged;
517 }
518
FillSpecialItem(sal_uInt16 nWhichId,SfxItemSet & rOutItemSet) const519 void StatisticsItemConverter::FillSpecialItem(
520 sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
521 throw( uno::Exception )
522 {
523 switch( nWhichId )
524 {
525 case SCHATTR_STAT_AVERAGE:
526 rOutItemSet.Put(
527 SfxBoolItem( nWhichId,
528 RegressionCurveHelper::hasMeanValueLine(
529 uno::Reference< chart2::XRegressionCurveContainer >(
530 GetPropertySet(), uno::UNO_QUERY ))));
531 break;
532
533 case SCHATTR_STAT_KIND_ERROR:
534 {
535 SvxChartKindError eErrorKind = CHERROR_NONE;
536 uno::Reference< beans::XPropertySet > xErrorBarProp(
537 lcl_GetYErrorBar( GetPropertySet()));
538 if( xErrorBarProp.is() )
539 {
540 sal_Int32 nStyle = 0;
541 if( xErrorBarProp->getPropertyValue( C2U( "ErrorBarStyle" )) >>= nStyle )
542 {
543 switch( nStyle )
544 {
545 case ::com::sun::star::chart::ErrorBarStyle::NONE:
546 break;
547 case ::com::sun::star::chart::ErrorBarStyle::VARIANCE:
548 eErrorKind = CHERROR_VARIANT; break;
549 case ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION:
550 eErrorKind = CHERROR_SIGMA; break;
551 case ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE:
552 eErrorKind = CHERROR_CONST; break;
553 case ::com::sun::star::chart::ErrorBarStyle::RELATIVE:
554 eErrorKind = CHERROR_PERCENT; break;
555 case ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN:
556 eErrorKind = CHERROR_BIGERROR; break;
557 case ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR:
558 eErrorKind = CHERROR_STDERROR; break;
559 case ::com::sun::star::chart::ErrorBarStyle::FROM_DATA:
560 eErrorKind = CHERROR_RANGE; break;
561 }
562 }
563 }
564 rOutItemSet.Put( SvxChartKindErrorItem( eErrorKind, SCHATTR_STAT_KIND_ERROR ));
565 }
566 break;
567
568 case SCHATTR_STAT_PERCENT:
569 {
570 uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetYErrorBar( GetPropertySet()));
571 if( xErrorBarProp.is())
572 {
573 double fPos, fNeg;
574 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
575 rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
576 }
577 }
578 break;
579
580 case SCHATTR_STAT_BIGERROR:
581 {
582 uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetYErrorBar( GetPropertySet()));
583 if( xErrorBarProp.is())
584 {
585 double fPos, fNeg;
586 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
587 rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
588 }
589 }
590 break;
591
592 case SCHATTR_STAT_CONSTPLUS:
593 {
594 uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetYErrorBar( GetPropertySet()));
595 if( xErrorBarProp.is())
596 {
597 double fPos, fNeg;
598 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
599 rOutItemSet.Put( SvxDoubleItem( fPos, nWhichId ));
600 }
601 }
602 break;
603
604 case SCHATTR_STAT_CONSTMINUS:
605 {
606 uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetYErrorBar( GetPropertySet()));
607 if( xErrorBarProp.is())
608 {
609 double fPos, fNeg;
610 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
611 rOutItemSet.Put( SvxDoubleItem( fNeg, nWhichId ));
612 }
613 }
614 break;
615
616 case SCHATTR_REGRESSION_TYPE:
617 {
618 SvxChartRegress eRegress = static_cast< SvxChartRegress >(
619 static_cast< sal_Int32 >(
620 RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
621 uno::Reference< chart2::XRegressionCurveContainer >(
622 GetPropertySet(), uno::UNO_QUERY ) )));
623 rOutItemSet.Put( SvxChartRegressItem( eRegress, SCHATTR_REGRESSION_TYPE ));
624 }
625 break;
626
627 case SCHATTR_REGRESSION_SHOW_EQUATION:
628 {
629 bool bShowEq = false;
630 uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), 0 ));
631 if( xEqProp.is())
632 xEqProp->getPropertyValue( C2U("ShowEquation")) >>= bShowEq;
633 rOutItemSet.Put( SfxBoolItem( nWhichId, bShowEq ));
634 }
635 break;
636
637 case SCHATTR_REGRESSION_SHOW_COEFF:
638 {
639 bool bShowCoeff = false;
640 uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), 0 ));
641 if( xEqProp.is())
642 xEqProp->getPropertyValue( C2U("ShowCorrelationCoefficient")) >>= bShowCoeff;
643 rOutItemSet.Put( SfxBoolItem( nWhichId, bShowCoeff ));
644 }
645 break;
646
647 case SCHATTR_STAT_INDICATE:
648 {
649 uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetYErrorBar( GetPropertySet()));
650 SvxChartIndicate eIndicate = CHINDICATE_BOTH;
651 if( xErrorBarProp.is())
652 {
653 bool bShowPos, bShowNeg;
654 lcl_getErrorIndicatorValues( xErrorBarProp, bShowPos, bShowNeg );
655
656 if( bShowPos )
657 {
658 if( bShowNeg )
659 eIndicate = CHINDICATE_BOTH;
660 else
661 eIndicate = CHINDICATE_UP;
662 }
663 else
664 {
665 if( bShowNeg )
666 eIndicate = CHINDICATE_DOWN;
667 else
668 eIndicate = CHINDICATE_NONE;
669 }
670 }
671 rOutItemSet.Put( SvxChartIndicateItem( eIndicate, SCHATTR_STAT_INDICATE ));
672 }
673 break;
674
675 case SCHATTR_STAT_RANGE_POS:
676 case SCHATTR_STAT_RANGE_NEG:
677 {
678 uno::Reference< chart2::data::XDataSource > xErrorBarSource( lcl_GetYErrorBar( GetPropertySet()), uno::UNO_QUERY );
679 if( xErrorBarSource.is())
680 {
681 uno::Reference< chart2::data::XDataSequence > xSeq(
682 StatisticsHelper::getErrorDataSequenceFromDataSource(
683 xErrorBarSource, (nWhichId == SCHATTR_STAT_RANGE_POS) /*, true */ /* y */ ));
684 if( xSeq.is())
685 rOutItemSet.Put( SfxStringItem( nWhichId, String( xSeq->getSourceRangeRepresentation())));
686 }
687 }
688 break;
689 }
690 }
691
692 } // namespace wrapper
693 } // namespace chart
694