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

Generated by: LCOV version 1.10