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 "res_ErrorBar.hxx"
21 : #include "ResId.hxx"
22 : #include "Bitmaps.hrc"
23 : #include "RangeSelectionHelper.hxx"
24 : #include "TabPageNotifiable.hxx"
25 : #include "macros.hxx"
26 :
27 : #include <rtl/math.hxx>
28 : #include <vcl/dialog.hxx>
29 : #include <svl/stritem.hxx>
30 :
31 : #define CHART_LB_FUNCTION_STD_ERROR 0
32 : #define CHART_LB_FUNCTION_STD_DEV 1
33 : #define CHART_LB_FUNCTION_VARIANCE 2
34 : #define CHART_LB_FUNCTION_ERROR_MARGIN 3
35 :
36 : using namespace ::com::sun::star;
37 :
38 : namespace
39 : {
40 0 : void lcl_enableRangeChoosing( bool bEnable, Dialog * pDialog )
41 : {
42 0 : if( pDialog )
43 : {
44 0 : pDialog->Show( !bEnable );
45 0 : pDialog->SetModalInputMode( !bEnable );
46 : }
47 0 : }
48 :
49 0 : sal_uInt16 lcl_getLbEntryPosByErrorKind( SvxChartKindError eErrorKind )
50 : {
51 0 : sal_uInt16 nResult = 0;
52 0 : switch( eErrorKind )
53 : {
54 : // for these cases select the default in the list box
55 : case CHERROR_NONE:
56 : case CHERROR_PERCENT:
57 : case CHERROR_CONST:
58 : case CHERROR_RANGE:
59 0 : nResult = CHART_LB_FUNCTION_STD_DEV;
60 0 : break;
61 : case CHERROR_VARIANT:
62 0 : nResult = CHART_LB_FUNCTION_VARIANCE;
63 0 : break;
64 : case CHERROR_SIGMA:
65 0 : nResult = CHART_LB_FUNCTION_STD_DEV;
66 0 : break;
67 : case CHERROR_BIGERROR:
68 0 : nResult = CHART_LB_FUNCTION_ERROR_MARGIN;
69 0 : break;
70 : case CHERROR_STDERROR:
71 0 : nResult = CHART_LB_FUNCTION_STD_ERROR;
72 0 : break;
73 : }
74 0 : return nResult;
75 : }
76 : } // anonymous namespace
77 :
78 : namespace chart
79 : {
80 :
81 0 : ErrorBarResources::ErrorBarResources( VclBuilderContainer* pParent, Dialog * pParentDialog,
82 : const SfxItemSet& rInAttrs, bool bNoneAvailable,
83 : tErrorBarType eType /* = ERROR_BAR_Y */ ) :
84 : m_eErrorKind( CHERROR_NONE ),
85 : m_eIndicate( CHINDICATE_BOTH ),
86 : m_bErrorKindUnique( true ),
87 : m_bIndicatorUnique( true ),
88 : m_bPlusUnique( true ),
89 : m_bMinusUnique( true ),
90 : m_bRangePosUnique( true ),
91 : m_bRangeNegUnique( true ),
92 : m_bNoneAvailable( bNoneAvailable ),
93 : m_eErrorBarType( eType ),
94 : m_nConstDecimalDigits( 1 ),
95 : m_nConstSpinSize( 1 ),
96 : m_fPlusValue(0.0),
97 : m_fMinusValue(0.0),
98 : m_pParentDialog( pParentDialog ),
99 : m_pCurrentRangeChoosingField( 0 ),
100 : m_bHasInternalDataProvider( true ),
101 0 : m_bEnableDataTableDialog( true )
102 : {
103 0 : pParent->get(m_pRbNone,"RB_NONE");
104 0 : pParent->get(m_pRbConst, "RB_CONST");
105 0 : pParent->get(m_pRbPercent, "RB_PERCENT");
106 0 : pParent->get(m_pRbFunction, "RB_FUNCTION");
107 0 : pParent->get(m_pRbRange, "RB_RANGE");
108 0 : pParent->get(m_pLbFunction, "LB_FUNCTION");
109 :
110 0 : pParent->get(m_pFlParameters, "framePARAMETERS");
111 0 : pParent->get(m_pBxPositive, "boxPOSITIVE");
112 0 : pParent->get(m_pMfPositive, "MF_POSITIVE");
113 0 : pParent->get(m_pEdRangePositive, "ED_RANGE_POSITIVE");
114 0 : pParent->get(m_pIbRangePositive, "IB_RANGE_POSITIVE");
115 0 : pParent->get(m_pBxNegative, "boxNEGATIVE");
116 0 : pParent->get(m_pMfNegative, "MF_NEGATIVE");
117 0 : pParent->get(m_pEdRangeNegative, "ED_RANGE_NEGATIVE");
118 0 : pParent->get(m_pIbRangeNegative, "IB_RANGE_NEGATIVE");
119 0 : pParent->get(m_pCbSyncPosNeg, "CB_SYN_POS_NEG");
120 :
121 0 : pParent->get(m_pRbBoth, "RB_BOTH");
122 0 : pParent->get(m_pRbPositive, "RB_POSITIVE");
123 0 : pParent->get(m_pRbNegative, "RB_NEGATIVE");
124 0 : pParent->get(m_pFiBoth, "FI_BOTH");
125 0 : pParent->get(m_pFiPositive, "FI_POSITIVE");
126 0 : pParent->get(m_pFiNegative, "FI_NEGATIVE");
127 :
128 0 : pParent->get(m_pUIStringPos, "STR_DATA_SELECT_RANGE_FOR_POSITIVE_ERRORBARS");
129 0 : pParent->get(m_pUIStringNeg, "STR_DATA_SELECT_RANGE_FOR_NEGATIVE_ERRORBARS");
130 0 : pParent->get(m_pUIStringRbRange, "STR_CONTROLTEXT_ERROR_BARS_FROM_DATA");
131 :
132 0 : if( m_bNoneAvailable )
133 0 : m_pRbNone->SetClickHdl( LINK( this, ErrorBarResources, CategoryChosen ));
134 : else
135 0 : m_pRbNone->Hide();
136 :
137 0 : m_pRbConst->SetClickHdl( LINK( this, ErrorBarResources, CategoryChosen ));
138 0 : m_pRbPercent->SetClickHdl( LINK( this, ErrorBarResources, CategoryChosen ));
139 0 : m_pRbFunction->SetClickHdl( LINK( this, ErrorBarResources, CategoryChosen ));
140 0 : m_pRbRange->SetClickHdl( LINK( this, ErrorBarResources, CategoryChosen ));
141 0 : m_pLbFunction->SetSelectHdl( LINK( this, ErrorBarResources, CategoryChosen ));
142 :
143 0 : m_pCbSyncPosNeg->Check( false );
144 0 : m_pCbSyncPosNeg->SetToggleHdl( LINK( this, ErrorBarResources, SynchronizePosAndNeg ));
145 :
146 0 : m_pMfPositive->SetModifyHdl( LINK( this, ErrorBarResources, PosValueChanged ));
147 0 : m_pEdRangePositive->SetModifyHdl( LINK( this, ErrorBarResources, RangeChanged ));
148 0 : m_pEdRangeNegative->SetModifyHdl( LINK( this, ErrorBarResources, RangeChanged ));
149 :
150 0 : m_pRbPositive->SetClickHdl( LINK( this, ErrorBarResources, IndicatorChanged ));
151 0 : m_pRbNegative->SetClickHdl( LINK( this, ErrorBarResources, IndicatorChanged ));
152 0 : m_pRbBoth->SetClickHdl( LINK( this, ErrorBarResources, IndicatorChanged ));
153 :
154 0 : m_pIbRangePositive->SetClickHdl( LINK( this, ErrorBarResources, ChooseRange ));
155 0 : m_pIbRangeNegative->SetClickHdl( LINK( this, ErrorBarResources, ChooseRange ));
156 :
157 0 : FillValueSets();
158 0 : Reset( rInAttrs );
159 0 : }
160 :
161 0 : ErrorBarResources::~ErrorBarResources()
162 : {
163 0 : }
164 :
165 0 : void ErrorBarResources::SetErrorBarType( tErrorBarType eNewType )
166 : {
167 0 : if( m_eErrorBarType != eNewType )
168 : {
169 0 : m_eErrorBarType = eNewType;
170 0 : FillValueSets();
171 : }
172 0 : }
173 :
174 0 : void ErrorBarResources::SetChartDocumentForRangeChoosing(
175 : const uno::Reference< chart2::XChartDocument > & xChartDocument )
176 : {
177 0 : if( xChartDocument.is())
178 : {
179 0 : m_bHasInternalDataProvider = xChartDocument->hasInternalDataProvider();
180 0 : uno::Reference< beans::XPropertySet > xProps( xChartDocument, uno::UNO_QUERY );
181 0 : if ( xProps.is() )
182 : {
183 : try
184 : {
185 0 : xProps->getPropertyValue("EnableDataTableDialog") >>= m_bEnableDataTableDialog;
186 : }
187 0 : catch( const uno::Exception& e )
188 : {
189 : ASSERT_EXCEPTION( e );
190 : }
191 0 : }
192 : }
193 0 : m_apRangeSelectionHelper.reset( new RangeSelectionHelper( xChartDocument ));
194 :
195 : // has internal data provider => rename "cell range" to "from data"
196 : OSL_ASSERT( m_apRangeSelectionHelper.get());
197 0 : if( m_bHasInternalDataProvider )
198 : {
199 0 : m_pRbRange->SetText(m_pUIStringRbRange->GetText());
200 : }
201 :
202 0 : if( m_pRbRange->IsChecked())
203 : {
204 0 : isRangeFieldContentValid( *m_pEdRangePositive );
205 0 : isRangeFieldContentValid( *m_pEdRangeNegative );
206 : }
207 0 : }
208 :
209 0 : void ErrorBarResources::SetAxisMinorStepWidthForErrorBarDecimals( double fMinorStepWidth )
210 : {
211 0 : if( fMinorStepWidth < 0 )
212 0 : fMinorStepWidth = -fMinorStepWidth;
213 :
214 0 : sal_Int32 nExponent = static_cast< sal_Int32 >( ::rtl::math::approxFloor( log10( fMinorStepWidth )));
215 0 : if( nExponent <= 0 )
216 : {
217 : // one digit precision more
218 0 : m_nConstDecimalDigits = static_cast< sal_uInt16 >( (-nExponent) + 1 );
219 0 : m_nConstSpinSize = 10;
220 : }
221 : else
222 : {
223 0 : m_nConstDecimalDigits = 0;
224 0 : m_nConstSpinSize = static_cast< sal_Int64 >( pow( 10.0, (int)nExponent ));
225 : }
226 0 : }
227 :
228 0 : void ErrorBarResources::UpdateControlStates()
229 : {
230 : // function
231 0 : bool bIsFunction = m_pRbFunction->IsChecked();
232 0 : m_pLbFunction->Enable( bIsFunction );
233 :
234 : // range buttons
235 0 : m_pRbRange->Enable( !m_bHasInternalDataProvider || m_bEnableDataTableDialog );
236 0 : bool bShowRange = ( m_pRbRange->IsChecked());
237 : bool bCanChooseRange =
238 0 : ( bShowRange &&
239 0 : m_apRangeSelectionHelper.get() &&
240 0 : m_apRangeSelectionHelper->hasRangeSelection());
241 :
242 0 : m_pMfPositive->Show( ! bShowRange );
243 0 : m_pMfNegative->Show( ! bShowRange );
244 :
245 : // use range but without range chooser => hide controls
246 0 : m_pEdRangePositive->Show( bShowRange && ! m_bHasInternalDataProvider );
247 0 : m_pIbRangePositive->Show( bCanChooseRange );
248 0 : m_pEdRangeNegative->Show( bShowRange && ! m_bHasInternalDataProvider );
249 0 : m_pIbRangeNegative->Show( bCanChooseRange );
250 :
251 0 : bool bShowPosNegAndSync = ! (bShowRange && m_bHasInternalDataProvider);
252 0 : m_pFlParameters->Show( bShowPosNegAndSync );
253 :
254 : // unit for metric fields
255 : bool bIsErrorMargin(
256 0 : ( m_pRbFunction->IsChecked()) &&
257 0 : ( m_pLbFunction->GetSelectEntryPos() == CHART_LB_FUNCTION_ERROR_MARGIN ));
258 0 : bool bIsPercentage( m_pRbPercent->IsChecked() || bIsErrorMargin );
259 0 : OUString aCustomUnit;
260 :
261 0 : if( bIsPercentage )
262 : {
263 0 : aCustomUnit = " %";
264 0 : m_pMfPositive->SetDecimalDigits( 1 );
265 0 : m_pMfPositive->SetSpinSize( 10 );
266 0 : m_pMfNegative->SetDecimalDigits( 1 );
267 0 : m_pMfNegative->SetSpinSize( 10 );
268 : }
269 : else
270 : {
271 0 : m_pMfPositive->SetDecimalDigits( m_nConstDecimalDigits );
272 0 : m_pMfPositive->SetSpinSize( m_nConstSpinSize );
273 0 : m_pMfNegative->SetDecimalDigits( m_nConstDecimalDigits );
274 0 : m_pMfNegative->SetSpinSize( m_nConstSpinSize );
275 : }
276 :
277 0 : sal_Int32 nPlusValue = static_cast< sal_Int32 >( m_fPlusValue * pow(10.0,m_pMfPositive->GetDecimalDigits()) );
278 0 : sal_Int32 nMinusValue = static_cast< sal_Int32 >( m_fMinusValue * pow(10.0,m_pMfNegative->GetDecimalDigits()) );
279 :
280 0 : m_pMfPositive->SetValue( nPlusValue );
281 0 : m_pMfNegative->SetValue( nMinusValue );
282 :
283 0 : m_pMfPositive->SetCustomUnitText( aCustomUnit );
284 0 : m_pMfNegative->SetCustomUnitText( aCustomUnit );
285 :
286 : // positive and negative value fields
287 0 : bool bPosEnabled = ( m_pRbPositive->IsChecked() || m_pRbBoth->IsChecked());
288 0 : bool bNegEnabled = ( m_pRbNegative->IsChecked() || m_pRbBoth->IsChecked());
289 0 : if( !( bPosEnabled || bNegEnabled ))
290 : {
291 : // all three controls are not checked -> ambiguous state
292 0 : bPosEnabled = true;
293 0 : bNegEnabled = true;
294 : }
295 :
296 : // functions with only one parameter
297 : bool bOneParameterCategory =
298 0 : bIsErrorMargin || m_pRbPercent->IsChecked();
299 0 : if( bOneParameterCategory )
300 : {
301 0 : m_pCbSyncPosNeg->Check();
302 : }
303 :
304 0 : if( m_pCbSyncPosNeg->IsChecked())
305 : {
306 0 : bPosEnabled = true;
307 0 : bNegEnabled = false;
308 : }
309 :
310 : // all functions except error margin take no arguments
311 0 : if( m_pRbFunction->IsChecked() && ( m_pLbFunction->GetSelectEntryPos() != CHART_LB_FUNCTION_ERROR_MARGIN ))
312 : {
313 0 : bPosEnabled = false;
314 0 : bNegEnabled = false;
315 : }
316 :
317 : // enable/disable pos/neg fields
318 0 : m_pBxPositive->Enable( bPosEnabled );
319 0 : m_pBxNegative->Enable( bNegEnabled );
320 0 : if( bShowRange )
321 : {
322 0 : m_pEdRangePositive->Enable( bPosEnabled );
323 0 : m_pIbRangePositive->Enable( bPosEnabled );
324 0 : m_pEdRangeNegative->Enable( bNegEnabled );
325 0 : m_pIbRangeNegative->Enable( bNegEnabled );
326 : }
327 : else
328 : {
329 0 : m_pMfPositive->Enable( bPosEnabled );
330 0 : m_pMfNegative->Enable( bNegEnabled );
331 : }
332 :
333 0 : m_pCbSyncPosNeg->Enable( !bOneParameterCategory && ( bPosEnabled || bNegEnabled ));
334 :
335 : // mark invalid entries in the range fields
336 0 : if( bShowRange && ! m_bHasInternalDataProvider )
337 : {
338 0 : isRangeFieldContentValid( *m_pEdRangePositive );
339 0 : isRangeFieldContentValid( *m_pEdRangeNegative );
340 0 : }
341 0 : }
342 :
343 0 : IMPL_LINK_NOARG( ErrorBarResources, CategoryChosen )
344 : {
345 0 : m_bErrorKindUnique = true;
346 0 : SvxChartKindError eOldError = m_eErrorKind;
347 :
348 0 : if( m_pRbNone->IsChecked())
349 0 : m_eErrorKind = CHERROR_NONE;
350 0 : else if( m_pRbConst->IsChecked())
351 0 : m_eErrorKind = CHERROR_CONST;
352 0 : else if( m_pRbPercent->IsChecked())
353 0 : m_eErrorKind = CHERROR_PERCENT;
354 0 : else if( m_pRbRange->IsChecked())
355 0 : m_eErrorKind = CHERROR_RANGE;
356 0 : else if( m_pRbFunction->IsChecked())
357 : {
358 0 : if( m_pLbFunction->GetSelectEntryCount() == 1 )
359 : {
360 0 : switch( m_pLbFunction->GetSelectEntryPos())
361 : {
362 : case CHART_LB_FUNCTION_STD_ERROR:
363 0 : m_eErrorKind = CHERROR_STDERROR; break;
364 : case CHART_LB_FUNCTION_STD_DEV:
365 0 : m_eErrorKind = CHERROR_SIGMA; break;
366 : case CHART_LB_FUNCTION_VARIANCE:
367 0 : m_eErrorKind = CHERROR_VARIANT; break;
368 : case CHART_LB_FUNCTION_ERROR_MARGIN:
369 0 : m_eErrorKind = CHERROR_BIGERROR; break;
370 : default:
371 0 : m_bErrorKindUnique = false;
372 : }
373 : }
374 : else
375 0 : m_bErrorKindUnique = false;
376 : }
377 : else
378 : {
379 : OSL_FAIL( "Unknown category chosen" );
380 0 : m_bErrorKindUnique = false;
381 : }
382 :
383 : // changed to range
384 0 : if( m_eErrorKind == CHERROR_RANGE &&
385 : eOldError != CHERROR_RANGE )
386 : {
387 : m_pCbSyncPosNeg->Check(
388 0 : (!m_pEdRangePositive->GetText().isEmpty()) &&
389 0 : m_pEdRangePositive->GetText() == m_pEdRangeNegative->GetText());
390 : }
391 : // changed from range
392 0 : else if( m_eErrorKind != CHERROR_RANGE &&
393 : eOldError == CHERROR_RANGE )
394 : {
395 0 : m_pCbSyncPosNeg->Check( m_pMfPositive->GetValue() == m_pMfNegative->GetValue());
396 : }
397 :
398 0 : UpdateControlStates();
399 0 : return 0;
400 : }
401 :
402 0 : IMPL_LINK_NOARG(ErrorBarResources, SynchronizePosAndNeg)
403 : {
404 0 : UpdateControlStates();
405 0 : PosValueChanged( 0 );
406 0 : return 0;
407 : }
408 :
409 0 : IMPL_LINK_NOARG(ErrorBarResources, PosValueChanged)
410 : {
411 0 : if( m_pCbSyncPosNeg->IsChecked())
412 : {
413 0 : if( m_pRbRange->IsChecked())
414 : {
415 0 : m_pEdRangeNegative->SetText( m_pEdRangePositive->GetText());
416 0 : m_bRangeNegUnique = m_bRangePosUnique;
417 : }
418 : else
419 0 : m_pMfNegative->SetValue( m_pMfPositive->GetValue());
420 : }
421 :
422 0 : return 0;
423 : }
424 :
425 0 : IMPL_LINK_NOARG(ErrorBarResources, IndicatorChanged)
426 : {
427 0 : m_bIndicatorUnique = true;
428 0 : if( m_pRbBoth->IsChecked())
429 0 : m_eIndicate = CHINDICATE_BOTH;
430 0 : else if( m_pRbPositive->IsChecked())
431 0 : m_eIndicate = CHINDICATE_UP;
432 0 : else if( m_pRbNegative->IsChecked())
433 0 : m_eIndicate = CHINDICATE_DOWN;
434 : else
435 0 : m_bIndicatorUnique = false;
436 :
437 0 : UpdateControlStates();
438 0 : return 0;
439 : }
440 :
441 0 : IMPL_LINK( ErrorBarResources, ChooseRange, PushButton*, pButton )
442 : {
443 : OSL_ASSERT( m_apRangeSelectionHelper.get());
444 0 : if( ! m_apRangeSelectionHelper.get())
445 0 : return 0;
446 : OSL_ASSERT( m_pCurrentRangeChoosingField == nullptr );
447 :
448 0 : OUString aUIString;
449 :
450 0 : if( pButton == m_pIbRangePositive )
451 : {
452 0 : m_pCurrentRangeChoosingField = m_pEdRangePositive;
453 0 : aUIString = m_pUIStringPos->GetText();
454 : }
455 : else
456 : {
457 0 : m_pCurrentRangeChoosingField = m_pEdRangeNegative;
458 0 : aUIString = m_pUIStringNeg->GetText();
459 : }
460 :
461 : assert( m_pParentDialog );
462 0 : if( m_pParentDialog )
463 : {
464 0 : lcl_enableRangeChoosing( true, m_pParentDialog );
465 : m_apRangeSelectionHelper->chooseRange(
466 0 : m_pCurrentRangeChoosingField->GetText(),
467 0 : aUIString, *this );
468 : }
469 : else
470 0 : m_pCurrentRangeChoosingField = 0;
471 :
472 0 : return 0;
473 : }
474 :
475 0 : IMPL_LINK( ErrorBarResources, RangeChanged, Edit *, pEdit )
476 : {
477 0 : if( pEdit == m_pEdRangePositive )
478 : {
479 0 : m_bRangePosUnique = true;
480 0 : PosValueChanged( 0 );
481 : }
482 : else
483 : {
484 0 : m_bRangeNegUnique = true;
485 : }
486 :
487 0 : isRangeFieldContentValid( *pEdit );
488 :
489 0 : return 0;
490 : }
491 :
492 0 : void ErrorBarResources::Reset(const SfxItemSet& rInAttrs)
493 : {
494 0 : const SfxPoolItem *pPoolItem = NULL;
495 0 : SfxItemState aState = SfxItemState::UNKNOWN;
496 :
497 : // category
498 0 : m_eErrorKind = CHERROR_NONE;
499 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_KIND_ERROR, true, &pPoolItem );
500 0 : m_bErrorKindUnique = ( aState != SfxItemState::DONTCARE );
501 :
502 0 : if( aState == SfxItemState::SET )
503 0 : m_eErrorKind = static_cast<const SvxChartKindErrorItem*>(pPoolItem)->GetValue();
504 :
505 0 : m_pLbFunction->SelectEntryPos( lcl_getLbEntryPosByErrorKind( m_eErrorKind ));
506 :
507 0 : if( m_bErrorKindUnique )
508 : {
509 0 : switch( m_eErrorKind )
510 : {
511 : case CHERROR_NONE:
512 0 : m_pRbNone->Check();
513 0 : break;
514 : case CHERROR_PERCENT:
515 0 : m_pRbPercent->Check();
516 0 : break;
517 : case CHERROR_CONST:
518 0 : m_pRbConst->Check();
519 0 : break;
520 : case CHERROR_STDERROR:
521 : case CHERROR_VARIANT:
522 : case CHERROR_SIGMA:
523 : case CHERROR_BIGERROR:
524 0 : m_pRbFunction->Check();
525 0 : break;
526 : case CHERROR_RANGE:
527 0 : m_pRbRange->Check();
528 0 : break;
529 : }
530 : }
531 : else
532 : {
533 0 : m_pRbNone->Check( false );
534 0 : m_pRbConst->Check( false );
535 0 : m_pRbPercent->Check( false );
536 0 : m_pRbFunction->Check( false );
537 : }
538 :
539 : // parameters
540 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_CONSTPLUS, true, &pPoolItem );
541 0 : m_bPlusUnique = ( aState != SfxItemState::DONTCARE );
542 0 : if( aState == SfxItemState::SET )
543 : {
544 0 : m_fPlusValue = static_cast<const SvxDoubleItem*>(pPoolItem)->GetValue();
545 : }
546 :
547 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_CONSTMINUS, true, &pPoolItem );
548 0 : m_bMinusUnique = ( aState != SfxItemState::DONTCARE );
549 0 : if( aState == SfxItemState::SET )
550 : {
551 0 : m_fMinusValue = static_cast<const SvxDoubleItem*>(pPoolItem)->GetValue();
552 :
553 0 : if( m_eErrorKind != CHERROR_RANGE &&
554 0 : m_fPlusValue == m_fMinusValue )
555 0 : m_pCbSyncPosNeg->Check();
556 : }
557 :
558 : // indicator
559 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_INDICATE, true, &pPoolItem );
560 0 : m_bIndicatorUnique = ( aState != SfxItemState::DONTCARE );
561 0 : if( aState == SfxItemState::SET)
562 0 : m_eIndicate = static_cast<const SvxChartIndicateItem *>(pPoolItem)->GetValue();
563 :
564 0 : if( m_bIndicatorUnique )
565 : {
566 0 : switch( m_eIndicate )
567 : {
568 : case CHINDICATE_NONE :
569 : // no longer used, use both as default
570 0 : m_eIndicate = CHINDICATE_BOTH;
571 : // fall-through intended to BOTH
572 : case CHINDICATE_BOTH :
573 0 : m_pRbBoth->Check(); break;
574 : case CHINDICATE_UP :
575 0 : m_pRbPositive->Check(); break;
576 : case CHINDICATE_DOWN :
577 0 : m_pRbNegative->Check(); break;
578 : }
579 : }
580 : else
581 : {
582 0 : m_pRbBoth->Check( false );
583 0 : m_pRbPositive->Check( false );
584 0 : m_pRbNegative->Check( false );
585 : }
586 :
587 : // ranges
588 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_RANGE_POS, true, &pPoolItem );
589 0 : m_bRangePosUnique = ( aState != SfxItemState::DONTCARE );
590 0 : if( aState == SfxItemState::SET )
591 : {
592 0 : OUString sRangePositive = (static_cast< const SfxStringItem * >( pPoolItem ))->GetValue();
593 0 : m_pEdRangePositive->SetText( sRangePositive );
594 : }
595 :
596 0 : aState = rInAttrs.GetItemState( SCHATTR_STAT_RANGE_NEG, true, &pPoolItem );
597 0 : m_bRangeNegUnique = ( aState != SfxItemState::DONTCARE );
598 0 : if( aState == SfxItemState::SET )
599 : {
600 0 : OUString sRangeNegative = (static_cast< const SfxStringItem * >( pPoolItem ))->GetValue();
601 0 : m_pEdRangeNegative->SetText( sRangeNegative );
602 0 : if( m_eErrorKind == CHERROR_RANGE &&
603 0 : !sRangeNegative.isEmpty() &&
604 0 : sRangeNegative == m_pEdRangePositive->GetText() )
605 0 : m_pCbSyncPosNeg->Check();
606 : }
607 :
608 0 : UpdateControlStates();
609 0 : }
610 :
611 0 : bool ErrorBarResources::FillItemSet(SfxItemSet& rOutAttrs) const
612 : {
613 0 : if( m_bErrorKindUnique )
614 0 : rOutAttrs.Put( SvxChartKindErrorItem( m_eErrorKind, SCHATTR_STAT_KIND_ERROR ));
615 0 : if( m_bIndicatorUnique )
616 0 : rOutAttrs.Put( SvxChartIndicateItem( m_eIndicate, SCHATTR_STAT_INDICATE ));
617 :
618 0 : if( m_bErrorKindUnique )
619 : {
620 0 : if( m_eErrorKind == CHERROR_RANGE )
621 : {
622 0 : OUString aPosRange;
623 0 : OUString aNegRange;
624 0 : if( m_bHasInternalDataProvider )
625 : {
626 : // the strings aPosRange/aNegRange have to be set to a non-empty
627 : // arbitrary string to generate error-bar sequences
628 0 : aPosRange = "x";
629 0 : aNegRange = aPosRange;
630 : }
631 : else
632 : {
633 0 : aPosRange = m_pEdRangePositive->GetText();
634 0 : if( m_pCbSyncPosNeg->IsChecked())
635 0 : aNegRange = aPosRange;
636 : else
637 0 : aNegRange = m_pEdRangeNegative->GetText();
638 : }
639 :
640 0 : if( m_bRangePosUnique )
641 0 : rOutAttrs.Put( SfxStringItem( SCHATTR_STAT_RANGE_POS, aPosRange ));
642 0 : if( m_bRangeNegUnique )
643 0 : rOutAttrs.Put( SfxStringItem( SCHATTR_STAT_RANGE_NEG, aNegRange ));
644 : }
645 0 : else if( m_eErrorKind == CHERROR_CONST ||
646 0 : m_eErrorKind == CHERROR_PERCENT ||
647 0 : m_eErrorKind == CHERROR_BIGERROR )
648 : {
649 0 : double fPosValue = static_cast< double >( m_pMfPositive->GetValue()) /
650 0 : pow( 10.0, m_pMfPositive->GetDecimalDigits());
651 0 : double fNegValue = 0.0;
652 :
653 0 : if( m_pCbSyncPosNeg->IsChecked())
654 0 : fNegValue = fPosValue;
655 : else
656 0 : fNegValue = static_cast< double >( m_pMfNegative->GetValue()) /
657 0 : pow( 10.0, m_pMfNegative->GetDecimalDigits());
658 :
659 0 : rOutAttrs.Put( SvxDoubleItem( fPosValue, SCHATTR_STAT_CONSTPLUS ));
660 0 : rOutAttrs.Put( SvxDoubleItem( fNegValue, SCHATTR_STAT_CONSTMINUS ));
661 : }
662 : }
663 :
664 0 : rOutAttrs.Put( SfxBoolItem( SCHATTR_STAT_ERRORBAR_TYPE , m_eErrorBarType == ERROR_BAR_Y ));
665 :
666 0 : return true;
667 : }
668 :
669 0 : void ErrorBarResources::FillValueSets()
670 : {
671 0 : if( m_eErrorBarType == ERROR_BAR_Y )
672 : {
673 0 : m_pFiNegative->SetImage( Image( SchResId( BMP_INDICATE_DOWN ) ) );
674 0 : m_pFiPositive->SetImage( Image( SchResId( BMP_INDICATE_UP ) ) );
675 0 : m_pFiBoth->SetImage( Image( SchResId( BMP_INDICATE_BOTH_VERTI ) ) );
676 : }
677 0 : else if( m_eErrorBarType == ERROR_BAR_X )
678 : {
679 0 : m_pFiNegative->SetImage( Image( SchResId( BMP_INDICATE_LEFT ) ) );
680 0 : m_pFiPositive->SetImage( Image( SchResId( BMP_INDICATE_RIGHT ) ) );
681 0 : m_pFiBoth->SetImage( Image( SchResId( BMP_INDICATE_BOTH_HORI ) ) );
682 : }
683 0 : }
684 :
685 0 : void ErrorBarResources::listeningFinished(
686 : const OUString & rNewRange )
687 : {
688 : OSL_ASSERT( m_apRangeSelectionHelper.get());
689 0 : if( ! m_apRangeSelectionHelper.get())
690 0 : return;
691 :
692 : // rNewRange becomes invalid after removing the listener
693 0 : OUString aRange( rNewRange );
694 :
695 : // stop listening
696 0 : m_apRangeSelectionHelper->stopRangeListening();
697 :
698 : // change edit field
699 : // if( m_pParentWindow )
700 : // {
701 : // m_pParentWindow->ToTop();
702 : // m_pParentWindow->GrabFocus();
703 : // }
704 :
705 0 : if( m_pCurrentRangeChoosingField )
706 : {
707 0 : m_pCurrentRangeChoosingField->SetText( aRange );
708 0 : m_pCurrentRangeChoosingField->GrabFocus();
709 0 : PosValueChanged( 0 );
710 : }
711 :
712 0 : m_pCurrentRangeChoosingField = 0;
713 :
714 0 : UpdateControlStates();
715 : OSL_ASSERT( m_pParentDialog );
716 0 : if( m_pParentDialog )
717 0 : lcl_enableRangeChoosing( false, m_pParentDialog );
718 : }
719 :
720 0 : void ErrorBarResources::disposingRangeSelection()
721 : {
722 : OSL_ASSERT( m_apRangeSelectionHelper.get());
723 0 : if( m_apRangeSelectionHelper.get())
724 0 : m_apRangeSelectionHelper->stopRangeListening( false );
725 0 : }
726 :
727 0 : bool ErrorBarResources::isRangeFieldContentValid( Edit & rEdit )
728 : {
729 0 : OUString aRange( rEdit.GetText());
730 0 : bool bIsValid = ( aRange.isEmpty() ) ||
731 0 : ( m_apRangeSelectionHelper.get() &&
732 0 : m_apRangeSelectionHelper->verifyCellRange( aRange ));
733 :
734 0 : if( bIsValid || !rEdit.IsEnabled())
735 : {
736 0 : rEdit.SetControlForeground();
737 0 : rEdit.SetControlBackground();
738 : }
739 : else
740 : {
741 0 : rEdit.SetControlBackground( RANGE_SELECTION_INVALID_RANGE_BACKGROUND_COLOR );
742 0 : rEdit.SetControlForeground( RANGE_SELECTION_INVALID_RANGE_FOREGROUND_COLOR );
743 : }
744 :
745 0 : return bIsValid;
746 : }
747 :
748 57 : } //namespace chart
749 :
750 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
