LCOV - code coverage report
Current view: top level - chart2/source/controller/dialogs - res_ErrorBar.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 374 0.3 %
Date: 2014-11-03 Functions: 2 29 6.9 %
Legend: Lines: hit not hit

          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 ? sal_False : sal_True );
      45           0 :         pDialog->SetModalInputMode( bEnable ? sal_False : sal_True );
      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( ErrorBarResources, CategoryChosen, void *,  )
     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 == 0 );
     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         102 : } //namespace chart
     749             : 
     750             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10