LCOV - code coverage report
Current view: top level - libreoffice/sc/source/ui/dbgui - validate.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 474 0.0 %
Date: 2012-12-27 Functions: 0 69 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             : 
      21             : #ifdef SC_DLLIMPLEMENTATION
      22             : #undef SC_DLLIMPLEMENTATION
      23             : #endif
      24             : 
      25             : #include <comphelper/string.hxx>
      26             : #include <vcl/svapp.hxx>
      27             : #include <svl/aeitem.hxx>
      28             : #include <svl/stritem.hxx>
      29             : #include <svl/eitem.hxx>
      30             : #include <svl/intitem.hxx>
      31             : #include <basic/sbmeth.hxx>
      32             : #include <basic/sbstar.hxx>
      33             : #include <basic/sbmod.hxx>
      34             : #include <sfx2/app.hxx>
      35             : 
      36             : #include "scresid.hxx"
      37             : #include "sc.hrc"       // -> Slot IDs
      38             : 
      39             : #include "stringutil.hxx"
      40             : #include "validat.hxx"
      41             : #include "validate.hrc"
      42             : #include "validate.hxx"
      43             : #include "compiler.hxx"
      44             : #include "formula/opcode.hxx"
      45             : 
      46             : // cell range picker
      47             : #include "tabvwsh.hxx"
      48             : #include <sfx2/viewfrm.hxx>
      49             : #include <sfx2/childwin.hxx>
      50             : #include "reffact.hxx"
      51             : 
      52             : // ============================================================================
      53             : 
      54             : static sal_uInt16 pValueRanges[] =
      55             : {
      56             :     FID_VALID_MODE, FID_VALID_ERRTEXT,
      57             :     FID_VALID_LISTTYPE, FID_VALID_LISTTYPE,
      58             :     0
      59             : };
      60             : 
      61             : 
      62             : // ============================================================================
      63             : 
      64           0 : ScValidationDlg::ScValidationDlg( Window*           pParent,
      65             :                                  const SfxItemSet* pArgSet,
      66             :                                  ScTabViewShell *pTabViewSh,
      67             :                                  SfxBindings *pB /*= NULL*/
      68             :                       ) :
      69           0 :         ScValidationDlgBase( pParent ? pParent : SFX_APP()->GetTopWindow(), TAB_DLG_VALIDATION, pArgSet, pB ),
      70             :             m_bOwnRefHdlr( false ),
      71             :             m_pTabVwSh( pTabViewSh ),
      72           0 :             m_bRefInputting( false )
      73             : {
      74           0 :     AddTabPage( TP_VALIDATION_VALUES,    ScTPValidationValue::Create, 0 );
      75           0 :     AddTabPage( TP_VALIDATION_INPUTHELP, ScTPValidationHelp::Create,  0 );
      76           0 :     AddTabPage( TP_VALIDATION_ERROR,     ScTPValidationError::Create, 0 );
      77           0 :     FreeResource();
      78           0 : }
      79             : 
      80           0 : void ScTPValidationValue::SetReferenceHdl( const ScRange&rRange , ScDocument* pDoc )
      81             : {
      82           0 :     if ( rRange.aStart != rRange.aEnd )
      83           0 :         if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
      84           0 :             if( m_pRefEdit )
      85           0 :                 pValidationDlg->RefInputStart( m_pRefEdit );
      86             : 
      87           0 :     if ( m_pRefEdit )
      88             :     {
      89           0 :         String  aStr;
      90           0 :         rRange.Format( aStr, SCR_ABS_3D, pDoc );
      91           0 :         m_pRefEdit->SetRefString( aStr );
      92             :     }
      93           0 : }
      94             : 
      95           0 : void ScTPValidationValue:: SetActiveHdl()
      96             : {
      97           0 :     if ( m_pRefEdit ) m_pRefEdit->GrabFocus();
      98             : 
      99           0 :     if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
     100           0 :         if( m_pRefEdit )
     101             :         {
     102           0 :             pValidationDlg->RefInputDone();
     103             :         }
     104           0 : }
     105             : 
     106           0 : void            ScTPValidationValue::RefInputStartPreHdl( formula::RefEdit* pEdit, formula::RefButton* pButton )
     107             : {
     108           0 :     if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
     109             :     {
     110           0 :         if( pEdit == m_pRefEdit )
     111             :         {
     112           0 :             if( Window *pPreWnd = pEdit==&maEdMax?&maFtMax:(pEdit==&maEdMin?&maFtMin:NULL) )
     113             :             {
     114           0 :                 pPreWnd->SetParent( pValidationDlg );
     115           0 :                 pPreWnd->Hide();
     116             :             }
     117             : 
     118           0 :             m_pRefEdit->SetParent( pValidationDlg );
     119             :         }
     120             : 
     121           0 :         if( pButton == &m_btnRef )m_btnRef.SetParent( pValidationDlg );
     122             :     }
     123           0 : }
     124             : 
     125           0 : void            ScTPValidationValue::RefInputDonePreHdl()
     126             : {
     127             : 
     128           0 :     if( m_pRefEdit && m_pRefEdit->GetParent()!= this )
     129             :     {
     130           0 :         if( Window *pPreWnd = m_pRefEdit==&maEdMax?&maFtMax:(m_pRefEdit==&maEdMin?&maFtMin:NULL) )
     131             :         {
     132           0 :             pPreWnd->SetParent( this );
     133           0 :             pPreWnd->Show();
     134             :         }
     135             : 
     136           0 :         m_pRefEdit->SetParent( this );
     137             : 
     138           0 :         m_btnRef.SetParent( m_pRefEdit ); //if Edit SetParent but button not, the tab order will be incorrect, need button to setparent to anthor window and restore parent later in order to restore the tab order
     139             :     }
     140             : 
     141           0 :     if( m_btnRef.GetParent()!=this ) m_btnRef.SetParent( this );
     142           0 : }
     143             : 
     144           0 : void            ScTPValidationValue::RefInputDonePostHdl()
     145             : {
     146             : 
     147             : 
     148           0 :     if( m_pRefEdit && !m_pRefEdit->HasFocus() )
     149           0 :         m_pRefEdit->GrabFocus();
     150             : 
     151           0 : }
     152             : 
     153             : 
     154           0 : sal_Bool ScValidationDlg::Close()
     155             : {
     156           0 :     if( m_bOwnRefHdlr )
     157           0 :         if( SfxTabPage* pPage = GetTabPage( TP_VALIDATION_VALUES ) )
     158           0 :             static_cast<ScTPValidationValue*>(pPage)->RemoveRefDlg();
     159             : 
     160           0 :     return ScValidationDlgBase::Close();
     161             : }
     162             : 
     163           0 : ScValidationDlg::~ScValidationDlg()
     164             : {
     165           0 :     if( m_bOwnRefHdlr )
     166           0 :         RemoveRefDlg( false );
     167           0 : }
     168             : 
     169             : 
     170             : // ============================================================================
     171             : 
     172             : namespace {
     173             : 
     174             : /** Converts the passed ScValidationMode to the position in the list box. */
     175           0 : sal_uInt16 lclGetPosFromValMode( ScValidationMode eValMode )
     176             : {
     177           0 :     sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
     178           0 :     switch( eValMode )
     179             :     {
     180           0 :         case SC_VALID_ANY:      nLbPos = SC_VALIDDLG_ALLOW_ANY;     break;
     181           0 :         case SC_VALID_WHOLE:    nLbPos = SC_VALIDDLG_ALLOW_WHOLE;   break;
     182           0 :         case SC_VALID_DECIMAL:  nLbPos = SC_VALIDDLG_ALLOW_DECIMAL; break;
     183           0 :         case SC_VALID_DATE:     nLbPos = SC_VALIDDLG_ALLOW_DATE;    break;
     184           0 :         case SC_VALID_TIME:     nLbPos = SC_VALIDDLG_ALLOW_TIME;    break;
     185           0 :         case SC_VALID_TEXTLEN:  nLbPos = SC_VALIDDLG_ALLOW_TEXTLEN; break;
     186           0 :         case SC_VALID_LIST:     nLbPos = SC_VALIDDLG_ALLOW_RANGE;   break;
     187           0 :         case SC_VALID_CUSTOM:   nLbPos = SC_VALIDDLG_ALLOW_ANY;     break;  // not supported
     188             :         default:    OSL_FAIL( "lclGetPosFromValMode - unknown validity mode" );
     189             :     }
     190           0 :     return nLbPos;
     191             : }
     192             : 
     193             : /** Converts the passed list box position to an ScValidationMode. */
     194           0 : ScValidationMode lclGetValModeFromPos( sal_uInt16 nLbPos )
     195             : {
     196           0 :     ScValidationMode eValMode = SC_VALID_ANY;
     197           0 :     switch( nLbPos )
     198             :     {
     199           0 :         case SC_VALIDDLG_ALLOW_ANY:     eValMode = SC_VALID_ANY;        break;
     200           0 :         case SC_VALIDDLG_ALLOW_WHOLE:   eValMode = SC_VALID_WHOLE;      break;
     201           0 :         case SC_VALIDDLG_ALLOW_DECIMAL: eValMode = SC_VALID_DECIMAL;    break;
     202           0 :         case SC_VALIDDLG_ALLOW_DATE:    eValMode = SC_VALID_DATE;       break;
     203           0 :         case SC_VALIDDLG_ALLOW_TIME:    eValMode = SC_VALID_TIME;       break;
     204           0 :         case SC_VALIDDLG_ALLOW_RANGE:   eValMode = SC_VALID_LIST;       break;
     205           0 :         case SC_VALIDDLG_ALLOW_LIST:    eValMode = SC_VALID_LIST;       break;
     206           0 :         case SC_VALIDDLG_ALLOW_TEXTLEN: eValMode = SC_VALID_TEXTLEN;    break;
     207             :         default:    OSL_FAIL( "lclGetValModeFromPos - invalid list box position" );
     208             :     }
     209           0 :     return eValMode;
     210             : }
     211             : 
     212             : /** Converts the passed ScConditionMode to the position in the list box. */
     213           0 : sal_uInt16 lclGetPosFromCondMode( ScConditionMode eCondMode )
     214             : {
     215           0 :     sal_uInt16 nLbPos = SC_VALIDDLG_DATA_EQUAL;
     216           0 :     switch( eCondMode )
     217             :     {
     218             :         case SC_COND_NONE:          // may occur in old XML files after Excel import
     219           0 :         case SC_COND_EQUAL:         nLbPos = SC_VALIDDLG_DATA_EQUAL;        break;
     220           0 :         case SC_COND_LESS:          nLbPos = SC_VALIDDLG_DATA_LESS;         break;
     221           0 :         case SC_COND_GREATER:       nLbPos = SC_VALIDDLG_DATA_GREATER;      break;
     222           0 :         case SC_COND_EQLESS:        nLbPos = SC_VALIDDLG_DATA_EQLESS;       break;
     223           0 :         case SC_COND_EQGREATER:     nLbPos = SC_VALIDDLG_DATA_EQGREATER;    break;
     224           0 :         case SC_COND_NOTEQUAL:      nLbPos = SC_VALIDDLG_DATA_NOTEQUAL;     break;
     225           0 :         case SC_COND_BETWEEN:       nLbPos = SC_VALIDDLG_DATA_VALIDRANGE;      break;
     226           0 :         case SC_COND_NOTBETWEEN:    nLbPos = SC_VALIDDLG_DATA_INVALIDRANGE;   break;
     227             :         default:    OSL_FAIL( "lclGetPosFromCondMode - unknown condition mode" );
     228             :     }
     229           0 :     return nLbPos;
     230             : }
     231             : 
     232             : /** Converts the passed list box position to an ScConditionMode. */
     233           0 : ScConditionMode lclGetCondModeFromPos( sal_uInt16 nLbPos )
     234             : {
     235           0 :     ScConditionMode eCondMode = SC_COND_EQUAL;
     236           0 :     switch( nLbPos )
     237             :     {
     238           0 :         case SC_VALIDDLG_DATA_EQUAL:        eCondMode = SC_COND_EQUAL;      break;
     239           0 :         case SC_VALIDDLG_DATA_LESS:         eCondMode = SC_COND_LESS;       break;
     240           0 :         case SC_VALIDDLG_DATA_GREATER:      eCondMode = SC_COND_GREATER;    break;
     241           0 :         case SC_VALIDDLG_DATA_EQLESS:       eCondMode = SC_COND_EQLESS;     break;
     242           0 :         case SC_VALIDDLG_DATA_EQGREATER:    eCondMode = SC_COND_EQGREATER;  break;
     243           0 :         case SC_VALIDDLG_DATA_NOTEQUAL:     eCondMode = SC_COND_NOTEQUAL;   break;
     244           0 :         case SC_VALIDDLG_DATA_VALIDRANGE:      eCondMode = SC_COND_BETWEEN;    break;
     245           0 :         case SC_VALIDDLG_DATA_INVALIDRANGE:   eCondMode = SC_COND_NOTBETWEEN; break;
     246             :         default:    OSL_FAIL( "lclGetCondModeFromPos - invalid list box position" );
     247             :     }
     248           0 :     return eCondMode;
     249             : }
     250             : 
     251             : /** Converts line feed separated string to a formula with strings separated by semicolons.
     252             :     @descr  Keeps all empty strings.
     253             :     Example: abc\ndef\n\nghi -> "abc";"def";"";"ghi".
     254             :     @param rFmlaStr  (out-param) The converted formula string. */
     255           0 : void lclGetFormulaFromStringList( String& rFmlaStr, const String& rStringList, sal_Unicode cFmlaSep )
     256             : {
     257           0 :     rFmlaStr.Erase();
     258           0 :     xub_StrLen nTokenCnt = comphelper::string::getTokenCount(rStringList, '\n');
     259           0 :     for( xub_StrLen nToken = 0, nStringIx = 0; nToken < nTokenCnt; ++nToken )
     260             :     {
     261           0 :         String aToken( rStringList.GetToken( 0, '\n', nStringIx ) );
     262           0 :         ScGlobal::AddQuotes( aToken, '"' );
     263           0 :         rFmlaStr = ScGlobal::addToken(rFmlaStr, aToken, cFmlaSep);
     264           0 :     }
     265           0 :     if( !rFmlaStr.Len() )
     266           0 :         rFmlaStr.AssignAscii( "\"\"" );
     267           0 : }
     268             : 
     269             : 
     270             : /** Converts formula with strings separated by semicolons to line feed separated string.
     271             :     @descr  Keeps all empty strings. Ignores all empty tokens (multiple semicolons).
     272             :     Example: "abc";;;"def";"";"ghi" -> abc\ndef\n\nghi.
     273             :     @param rStringList  (out-param) The converted line feed separated string list.
     274             :     @return  true = Conversion successful. */
     275           0 : bool lclGetStringListFromFormula( String& rStringList, const String& rFmlaStr, sal_Unicode cFmlaSep )
     276             : {
     277           0 :     String aQuotes( RTL_CONSTASCII_USTRINGPARAM( "\"\"" ) );
     278           0 :     xub_StrLen nTokenCnt = ScStringUtil::GetQuotedTokenCount(rFmlaStr, aQuotes, cFmlaSep );
     279             : 
     280           0 :     rStringList.Erase();
     281           0 :     bool bIsStringList = (nTokenCnt > 0);
     282           0 :     bool bTokenAdded = false;
     283             : 
     284           0 :     for( xub_StrLen nToken = 0, nStringIx = 0; bIsStringList && (nToken < nTokenCnt); ++nToken )
     285             :     {
     286           0 :         String aToken( ScStringUtil::GetQuotedToken(rFmlaStr, 0, aQuotes, cFmlaSep, nStringIx ) );
     287           0 :         aToken = comphelper::string::strip(aToken, ' ');
     288           0 :         if( aToken.Len() )      // ignore empty tokens, i.e. "a";;"b"
     289             :         {
     290           0 :             bIsStringList = ScGlobal::IsQuoted( aToken, '"' );
     291           0 :             if( bIsStringList )
     292             :             {
     293           0 :                 ScGlobal::EraseQuotes( aToken, '"' );
     294           0 :                 rStringList = ScGlobal::addToken(rStringList, aToken, '\n', 1, bTokenAdded);
     295           0 :                 bTokenAdded = true;
     296             :             }
     297             :         }
     298           0 :     }
     299             : 
     300           0 :     return bIsStringList;
     301             : }
     302             : 
     303             : } // namespace
     304             : 
     305             : // ----------------------------------------------------------------------------
     306             : 
     307           0 : ScTPValidationValue::ScTPValidationValue( Window* pParent, const SfxItemSet& rArgSet ) :
     308             :     SfxTabPage( pParent, ScResId( TP_VALIDATION_VALUES ), rArgSet ),
     309             :     maFtAllow ( this, ScResId( FT_ALLOW ) ),
     310             :     maLbAllow ( this, ScResId( LB_ALLOW ) ),
     311             :     maCbAllow ( this, ScResId( TSB_ALLOW_BLANKS ) ),
     312             :     maCbShow  ( this, ScResId( CB_SHOWLIST ) ),
     313             :     maCbSort  ( this, ScResId( CB_SORTLIST ) ),
     314             :     maFtValue ( this, ScResId( FT_VALUE ) ),
     315             :     maLbValue ( this, ScResId( LB_VALUE ) ),
     316             :     maFtMin   ( this, ScResId( FT_MIN ) ),
     317             :     maEdMin   ( this, NULL, ScResId( EDT_MIN ) ),
     318             :     maEdList  ( this, ScResId( EDT_LIST ) ),
     319             :     maFtMax   ( this, ScResId( FT_MAX ) ),
     320             :     maEdMax   ( this, NULL, ScResId( EDT_MAX ) ),
     321             :     maFtHint  ( this, ScResId( FT_SOURCEHINT ) ),
     322             :     maStrMin  ( ScResId( SCSTR_VALID_MINIMUM ) ),
     323             :     maStrMax  ( ScResId( SCSTR_VALID_MAXIMUM ) ),
     324             :     maStrValue( ScResId( SCSTR_VALID_VALUE ) ),
     325             :     maStrRange( ScResId( SCSTR_VALID_RANGE ) ),
     326             :     maStrList ( ScResId( SCSTR_VALID_LIST ) ),
     327           0 :     m_btnRef( this, ScResId( RB_VALIDITY_REF ) )
     328             : {
     329           0 :     Init();
     330           0 :     FreeResource();
     331             : 
     332             :     // list separator in formulas
     333           0 :     String aListSep = ::ScCompiler::GetNativeSymbol( ocSep );
     334             :     OSL_ENSURE( aListSep.Len() == 1, "ScTPValidationValue::ScTPValidationValue - list separator error" );
     335           0 :     mcFmlaSep = aListSep.Len() ? aListSep.GetChar( 0 ) : ';';
     336           0 :     m_btnRef.Hide(); // cell range picker
     337           0 : }
     338             : 
     339           0 : ScTPValidationValue::~ScTPValidationValue()
     340             : {
     341           0 : }
     342             : 
     343           0 : void ScTPValidationValue::Init()
     344             : {
     345           0 :     maLbAllow.SetSelectHdl( LINK( this, ScTPValidationValue, SelectHdl ) );
     346           0 :     maLbValue.SetSelectHdl( LINK( this, ScTPValidationValue, SelectHdl ) );
     347           0 :     maCbShow.SetClickHdl( LINK( this, ScTPValidationValue, CheckHdl ) );
     348             : 
     349             :     // cell range picker
     350           0 :     maEdMin.SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
     351           0 :     maEdMin.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
     352           0 :     maEdMax.SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
     353           0 :     m_btnRef.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
     354           0 :     maEdMax.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
     355             : 
     356           0 :     maLbAllow.SelectEntryPos( SC_VALIDDLG_ALLOW_ANY );
     357           0 :     maLbValue.SelectEntryPos( SC_VALIDDLG_DATA_EQUAL );
     358             : 
     359           0 :     SelectHdl( NULL );
     360           0 :     CheckHdl( NULL );
     361           0 : }
     362             : 
     363           0 : SfxTabPage* ScTPValidationValue::Create( Window* pParent, const SfxItemSet& rArgSet )
     364             : {
     365           0 :     return( new ScTPValidationValue( pParent, rArgSet ) );
     366             : }
     367             : 
     368           0 : sal_uInt16* ScTPValidationValue::GetRanges()
     369             : {
     370           0 :     return pValueRanges;
     371             : }
     372             : 
     373           0 : void ScTPValidationValue::Reset( const SfxItemSet& rArgSet )
     374             : {
     375             :     const SfxPoolItem* pItem;
     376             : 
     377           0 :     sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
     378           0 :     if( rArgSet.GetItemState( FID_VALID_MODE, sal_True, &pItem ) == SFX_ITEM_SET )
     379             :         nLbPos = lclGetPosFromValMode( static_cast< ScValidationMode >(
     380           0 :             static_cast< const SfxAllEnumItem* >( pItem )->GetValue() ) );
     381           0 :     maLbAllow.SelectEntryPos( nLbPos );
     382             : 
     383           0 :     nLbPos = SC_VALIDDLG_DATA_EQUAL;
     384           0 :     if( rArgSet.GetItemState( FID_VALID_CONDMODE, sal_True, &pItem ) == SFX_ITEM_SET )
     385             :         nLbPos = lclGetPosFromCondMode( static_cast< ScConditionMode >(
     386           0 :             static_cast< const SfxAllEnumItem* >( pItem )->GetValue() ) );
     387           0 :     maLbValue.SelectEntryPos( nLbPos );
     388             : 
     389             :     // *** check boxes ***
     390           0 :     sal_Bool bCheck = sal_True;
     391           0 :     if( rArgSet.GetItemState( FID_VALID_BLANK, sal_True, &pItem ) == SFX_ITEM_SET )
     392           0 :         bCheck = static_cast< const SfxBoolItem* >( pItem )->GetValue();
     393           0 :     maCbAllow.Check( bCheck );
     394             : 
     395           0 :     sal_Int32 nListType = ValidListType::UNSORTED;
     396           0 :     if( rArgSet.GetItemState( FID_VALID_LISTTYPE, sal_True, &pItem ) == SFX_ITEM_SET )
     397           0 :         nListType = static_cast< const SfxInt16Item* >( pItem )->GetValue();
     398           0 :     maCbShow.Check( nListType != ValidListType::INVISIBLE );
     399           0 :     maCbSort.Check( nListType == ValidListType::SORTEDASCENDING );
     400             : 
     401             :     // *** formulas ***
     402           0 :     String aFmlaStr;
     403           0 :     if ( rArgSet.GetItemState( FID_VALID_VALUE1, sal_True, &pItem ) == SFX_ITEM_SET )
     404           0 :         aFmlaStr = static_cast< const SfxStringItem* >( pItem )->GetValue();
     405           0 :     SetFirstFormula( aFmlaStr );
     406             : 
     407           0 :     aFmlaStr.Erase();
     408           0 :     if ( rArgSet.GetItemState( FID_VALID_VALUE2, sal_True, &pItem ) == SFX_ITEM_SET )
     409           0 :         aFmlaStr = static_cast< const SfxStringItem* >( pItem )->GetValue();
     410           0 :     SetSecondFormula( aFmlaStr );
     411             : 
     412           0 :     SelectHdl( NULL );
     413           0 :     CheckHdl( NULL );
     414           0 : }
     415             : 
     416           0 : sal_Bool ScTPValidationValue::FillItemSet( SfxItemSet& rArgSet )
     417             : {
     418           0 :     sal_Int16 nListType = maCbShow.IsChecked() ?
     419           0 :         (maCbSort.IsChecked() ? ValidListType::SORTEDASCENDING : ValidListType::UNSORTED) :
     420           0 :         ValidListType::INVISIBLE;
     421             : 
     422             :     rArgSet.Put( SfxAllEnumItem( FID_VALID_MODE, sal::static_int_cast<sal_uInt16>(
     423           0 :                     lclGetValModeFromPos( maLbAllow.GetSelectEntryPos() ) ) ) );
     424             :     rArgSet.Put( SfxAllEnumItem( FID_VALID_CONDMODE, sal::static_int_cast<sal_uInt16>(
     425           0 :                     lclGetCondModeFromPos( maLbValue.GetSelectEntryPos() ) ) ) );
     426           0 :     rArgSet.Put( SfxStringItem( FID_VALID_VALUE1, GetFirstFormula() ) );
     427           0 :     rArgSet.Put( SfxStringItem( FID_VALID_VALUE2, GetSecondFormula() ) );
     428           0 :     rArgSet.Put( SfxBoolItem( FID_VALID_BLANK, maCbAllow.IsChecked() ) );
     429           0 :     rArgSet.Put( SfxInt16Item( FID_VALID_LISTTYPE, nListType ) );
     430           0 :     return sal_True;
     431             : }
     432             : 
     433           0 : String ScTPValidationValue::GetFirstFormula() const
     434             : {
     435           0 :     String aFmlaStr;
     436           0 :     if( maLbAllow.GetSelectEntryPos() == SC_VALIDDLG_ALLOW_LIST )
     437           0 :         lclGetFormulaFromStringList( aFmlaStr, maEdList.GetText(), mcFmlaSep );
     438             :     else
     439           0 :         aFmlaStr = maEdMin.GetText();
     440           0 :     return aFmlaStr;
     441             : }
     442             : 
     443           0 : String ScTPValidationValue::GetSecondFormula() const
     444             : {
     445           0 :     return maEdMax.GetText();
     446             : }
     447             : 
     448           0 : void ScTPValidationValue::SetFirstFormula( const String& rFmlaStr )
     449             : {
     450             :     // try if formula is a string list, validation mode must already be set
     451           0 :     String aStringList;
     452           0 :     if( (maLbAllow.GetSelectEntryPos() == SC_VALIDDLG_ALLOW_RANGE) &&
     453           0 :         lclGetStringListFromFormula( aStringList, rFmlaStr, mcFmlaSep ) )
     454             :     {
     455           0 :         maEdList.SetText( aStringList );
     456           0 :         maEdMin.SetText( EMPTY_STRING );
     457             :         // change validation mode to string list
     458           0 :         maLbAllow.SelectEntryPos( SC_VALIDDLG_ALLOW_LIST );
     459             :     }
     460             :     else
     461             :     {
     462           0 :         maEdMin.SetText( rFmlaStr );
     463           0 :         maEdList.SetText( EMPTY_STRING );
     464           0 :     }
     465           0 : }
     466             : 
     467           0 : void ScTPValidationValue::SetSecondFormula( const String& rFmlaStr )
     468             : {
     469           0 :     maEdMax.SetText( rFmlaStr );
     470           0 : }
     471             : 
     472           0 : ScValidationDlg * ScTPValidationValue::GetValidationDlg()
     473             : {
     474           0 :     if( Window *pParent = GetParent() )
     475           0 :         do{
     476           0 :             if ( dynamic_cast<ScValidationDlg*>( pParent ) )
     477           0 :                 return static_cast< ScValidationDlg * >( pParent );
     478             :         }while ( NULL != ( pParent = pParent->GetParent() ) );
     479           0 :     return NULL;
     480             : }
     481             : 
     482           0 : void ScTPValidationValue::SetupRefDlg()
     483             : {
     484           0 :     if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
     485           0 :         if( pValidationDlg->SetupRefDlg() )
     486             :         {
     487           0 :             pValidationDlg->SetHandler( this );
     488           0 :             pValidationDlg->SetSetRefHdl( (ScRefHandlerHelper::PFUNCSETREFHDLTYPE)( &ScTPValidationValue::SetReferenceHdl ) );
     489           0 :             pValidationDlg->SetSetActHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::SetActiveHdl ) );
     490           0 :             pValidationDlg->SetRefInputStartPreHdl( (ScRefHandlerHelper::PINPUTSTARTDLTYPE)( &ScTPValidationValue::RefInputStartPreHdl ) );
     491           0 :             pValidationDlg->SetRefInputDonePreHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::RefInputDonePreHdl ) );
     492           0 :             pValidationDlg->SetRefInputDonePostHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::RefInputDonePostHdl ) );
     493             : 
     494           0 :             if ( maEdMax.IsVisible() ) { m_pRefEdit = &maEdMax; }
     495           0 :             else if ( maEdMin.IsVisible() ) {  m_pRefEdit = &maEdMin; }
     496             : 
     497           0 :             if( m_pRefEdit && !m_pRefEdit->HasFocus() ) m_pRefEdit->GrabFocus();
     498             : 
     499           0 :             if( m_pRefEdit ) m_pRefEdit->SetRefDialog( pValidationDlg );
     500           0 :             m_btnRef.SetReferences( pValidationDlg, m_pRefEdit );
     501             :         }
     502           0 : }
     503             : 
     504           0 : void ScTPValidationValue::RemoveRefDlg()
     505             : {
     506           0 :     if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
     507           0 :         if( pValidationDlg->RemoveRefDlg() )
     508             :         {
     509           0 :             pValidationDlg->SetHandler( NULL );
     510           0 :             pValidationDlg->SetSetRefHdl( NULL );
     511           0 :             pValidationDlg->SetSetActHdl( NULL );
     512           0 :             pValidationDlg->SetRefInputStartPreHdl( NULL );
     513           0 :             pValidationDlg->SetRefInputDonePreHdl( NULL );
     514           0 :             pValidationDlg->SetRefInputDonePostHdl( NULL );
     515             : 
     516           0 :             if( m_pRefEdit ) m_pRefEdit->SetRefDialog( NULL );
     517           0 :             m_pRefEdit = NULL;
     518             : 
     519           0 :             m_btnRef.SetReferences( NULL, NULL );
     520             : 
     521             : #if ! defined( WNT ) && !defined( _MSC_VER )
     522           0 :             TidyListBoxes();
     523             : #endif
     524             :         }
     525           0 : }
     526             : 
     527           0 : void ScTPValidationValue::TidyListBoxes()
     528             : {
     529           0 :     if ( Window *pWnd = GetChild( 0 ) )
     530             :     {
     531           0 :         bool bFindLst = false;
     532           0 :         std::list<Window*> alstOrder;
     533             : 
     534           0 :         do{
     535           0 :             if( pWnd->GetParent() == this )
     536             :             {
     537           0 :                 if ( !bFindLst )
     538             :                 {
     539             :                     try{
     540           0 :                         if( dynamic_cast<ListBox*>(pWnd)||dynamic_cast<ListBox*>(pWnd->GetWindow(WINDOW_CLIENT) ) )
     541           0 :                             bFindLst = true;
     542             :                     }
     543           0 :                     catch( ... )
     544             :                     {
     545           0 :                         if ( *(void**)pWnd == *(void**)&maLbValue )
     546           0 :                             bFindLst = true;
     547           0 :                         else if ( Window *pClient = pWnd->GetWindow( WINDOW_CLIENT ) )
     548           0 :                             if ( *(void**)pClient == *(void**)&maLbValue )
     549           0 :                                 bFindLst = true;
     550             :                     }
     551             :                 }
     552             : 
     553           0 :                 if ( bFindLst )
     554           0 :                     alstOrder.push_back( pWnd->GetWindow( WINDOW_CLIENT ) );
     555             :             }
     556           0 :         }while( NULL != ( pWnd = pWnd->GetWindow( WINDOW_NEXT  ) ) );
     557             : 
     558           0 :         pWnd = GetChild(0);
     559             : 
     560           0 :         while( std::find( alstOrder.begin(), alstOrder.end(), pWnd ) != alstOrder.end() && NULL != ( pWnd = pWnd->GetWindow( WINDOW_NEXT) ) ) ;
     561             : 
     562           0 :         if ( pWnd )
     563             :         {
     564           0 :             for ( std::list<Window*>::iterator i = alstOrder.begin(); i!=alstOrder.end(); ++i )
     565             :             {
     566           0 :                 Window *pParent = (*i)->GetParent();
     567           0 :                 (*i)->SetParent( pWnd );
     568           0 :                 (*i)->SetParent( pParent );
     569             :             }
     570           0 :         }
     571             :     }
     572           0 : }
     573             : 
     574           0 : IMPL_LINK_NOARG(ScTPValidationValue, EditSetFocusHdl)
     575             : {
     576           0 :     sal_uInt16  nPos=maLbAllow.GetSelectEntryPos();
     577             : 
     578           0 :     if ( nPos == SC_VALIDDLG_ALLOW_RANGE )
     579             :     {
     580           0 :         SetupRefDlg();
     581             :     }
     582             : 
     583           0 :     return 0;
     584             : }
     585             : 
     586           0 : IMPL_LINK( ScTPValidationValue, KillFocusHdl, Window *, pWnd )
     587             : {
     588           0 :     if( pWnd == m_pRefEdit || pWnd == &m_btnRef )
     589           0 :         if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
     590           0 :             if ( (pValidationDlg->IsActive() || pValidationDlg->IsChildFocus() ) && !pValidationDlg->IsRefInputting() )
     591           0 :                 if( ( !m_pRefEdit || !m_pRefEdit->HasFocus()) && !m_btnRef.HasFocus() )
     592             :                 {
     593           0 :                     RemoveRefDlg();
     594             :                 }
     595             : 
     596           0 :     return 0;
     597             : }
     598             : 
     599             : // ----------------------------------------------------------------------------
     600             : 
     601           0 : IMPL_LINK_NOARG(ScTPValidationValue, SelectHdl)
     602             : {
     603           0 :     sal_uInt16 nLbPos = maLbAllow.GetSelectEntryPos();
     604           0 :     bool bEnable = (nLbPos != SC_VALIDDLG_ALLOW_ANY);
     605           0 :     bool bRange = (nLbPos == SC_VALIDDLG_ALLOW_RANGE);
     606           0 :     bool bList = (nLbPos == SC_VALIDDLG_ALLOW_LIST);
     607             : 
     608           0 :     maCbAllow.Enable( bEnable );   // Empty cell
     609           0 :     maFtValue.Enable( bEnable );
     610           0 :     maLbValue.Enable( bEnable );
     611           0 :     maFtMin.Enable( bEnable );
     612           0 :     maEdMin.Enable( bEnable );
     613           0 :     maEdList.Enable( bEnable );
     614           0 :     maFtMax.Enable( bEnable );
     615           0 :     maEdMax.Enable( bEnable );
     616             : 
     617           0 :     bool bShowMax = false;
     618           0 :     if( bRange )
     619           0 :         maFtMin.SetText( maStrRange );
     620           0 :     else if( bList )
     621           0 :         maFtMin.SetText( maStrList );
     622             :     else
     623             :     {
     624           0 :         switch( maLbValue.GetSelectEntryPos() )
     625             :         {
     626             :             case SC_VALIDDLG_DATA_EQUAL:
     627           0 :             case SC_VALIDDLG_DATA_NOTEQUAL:     maFtMin.SetText( maStrValue );  break;
     628             : 
     629             :             case SC_VALIDDLG_DATA_LESS:
     630           0 :             case SC_VALIDDLG_DATA_EQLESS:       maFtMin.SetText( maStrMax );    break;
     631             : 
     632             :             case SC_VALIDDLG_DATA_VALIDRANGE:
     633           0 :             case SC_VALIDDLG_DATA_INVALIDRANGE:   bShowMax = true;    // fall through
     634             :             case SC_VALIDDLG_DATA_GREATER:
     635           0 :             case SC_VALIDDLG_DATA_EQGREATER:    maFtMin.SetText( maStrMin );    break;
     636             : 
     637             :             default:
     638             :                 OSL_FAIL( "ScTPValidationValue::SelectHdl - unknown condition mode" );
     639             :         }
     640             :     }
     641             : 
     642           0 :     maCbShow.Show( bRange || bList );
     643           0 :     maCbSort.Show( bRange || bList );
     644           0 :     maFtValue.Show( !bRange && !bList );
     645           0 :     maLbValue.Show( !bRange && !bList );
     646           0 :     maEdMin.Show( !bList );
     647           0 :     maEdList.Show( bList );
     648           0 :     maFtMax.Show( bShowMax );
     649           0 :     maEdMax.Show( bShowMax );
     650           0 :     maFtHint.Show( bRange );
     651           0 :     m_btnRef.Show( bRange );  // cell range picker
     652           0 :     return 0;
     653             : }
     654             : 
     655           0 : IMPL_LINK_NOARG(ScTPValidationValue, CheckHdl)
     656             : {
     657           0 :     maCbSort.Enable( maCbShow.IsChecked() );
     658           0 :     return 0;
     659             : }
     660             : 
     661             : 
     662             : //========================================================================
     663             : //========================================================================
     664             : // Input Help Page
     665             : 
     666           0 : ScTPValidationHelp::ScTPValidationHelp( Window*         pParent,
     667             :                                           const SfxItemSet& rArgSet )
     668             : 
     669             :     :   SfxTabPage      ( pParent,
     670             :                           ScResId( TP_VALIDATION_INPUTHELP ),
     671             :                           rArgSet ),
     672             :         aTsbHelp        ( this, ScResId( TSB_HELP ) ),
     673             :         aFlContent      ( this, ScResId( FL_CONTENT ) ),
     674             :         aFtTitle        ( this, ScResId( FT_TITLE ) ),
     675             :         aEdtTitle       ( this, ScResId( EDT_TITLE ) ),
     676             :         aFtInputHelp    ( this, ScResId( FT_INPUTHELP ) ),
     677           0 :         aEdInputHelp    ( this, ScResId( EDT_INPUTHELP ) )
     678             : {
     679           0 :     Init();
     680           0 :     FreeResource();
     681           0 : }
     682             : 
     683             : // -----------------------------------------------------------------------
     684             : 
     685           0 : ScTPValidationHelp::~ScTPValidationHelp()
     686             : {
     687           0 : }
     688             : 
     689             : // -----------------------------------------------------------------------
     690             : 
     691           0 : void ScTPValidationHelp::Init()
     692             : {
     693           0 :     aTsbHelp.EnableTriState( false );
     694           0 : }
     695             : 
     696             : //------------------------------------------------------------------------
     697             : 
     698           0 : sal_uInt16* ScTPValidationHelp::GetRanges()
     699             : {
     700           0 :     return pValueRanges;
     701             : }
     702             : 
     703             : // -----------------------------------------------------------------------
     704             : 
     705           0 : SfxTabPage* ScTPValidationHelp::Create( Window* pParent,
     706             :                                          const SfxItemSet&  rArgSet )
     707             : {
     708           0 :     return ( new ScTPValidationHelp( pParent, rArgSet ) );
     709             : }
     710             : 
     711             : // -----------------------------------------------------------------------
     712             : 
     713           0 : void ScTPValidationHelp::Reset( const SfxItemSet& rArgSet )
     714             : {
     715             :     const SfxPoolItem* pItem;
     716             : 
     717           0 :     if ( rArgSet.GetItemState( FID_VALID_SHOWHELP, sal_True, &pItem ) == SFX_ITEM_SET )
     718           0 :         aTsbHelp.SetState( ((const SfxBoolItem*)pItem)->GetValue() ? STATE_CHECK : STATE_NOCHECK );
     719             :     else
     720           0 :         aTsbHelp.SetState( STATE_NOCHECK );
     721             : 
     722           0 :     if ( rArgSet.GetItemState( FID_VALID_HELPTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
     723           0 :         aEdtTitle.SetText( ((const SfxStringItem*)pItem)->GetValue() );
     724             :     else
     725           0 :         aEdtTitle.SetText( EMPTY_STRING );
     726             : 
     727           0 :     if ( rArgSet.GetItemState( FID_VALID_HELPTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
     728           0 :         aEdInputHelp.SetText( ((const SfxStringItem*)pItem)->GetValue() );
     729             :     else
     730           0 :         aEdInputHelp.SetText( EMPTY_STRING );
     731           0 : }
     732             : 
     733             : // -----------------------------------------------------------------------
     734             : 
     735           0 : sal_Bool ScTPValidationHelp::FillItemSet( SfxItemSet& rArgSet )
     736             : {
     737           0 :     rArgSet.Put( SfxBoolItem( FID_VALID_SHOWHELP, aTsbHelp.GetState() == STATE_CHECK ) );
     738           0 :     rArgSet.Put( SfxStringItem( FID_VALID_HELPTITLE, aEdtTitle.GetText() ) );
     739           0 :     rArgSet.Put( SfxStringItem( FID_VALID_HELPTEXT, aEdInputHelp.GetText() ) );
     740             : 
     741           0 :     return sal_True;
     742             : }
     743             : 
     744             : //========================================================================
     745             : //========================================================================
     746             : // Error Alert Page
     747             : 
     748           0 : ScTPValidationError::ScTPValidationError( Window*           pParent,
     749             :                                           const SfxItemSet& rArgSet )
     750             : 
     751             :     :   SfxTabPage      ( pParent,
     752             :                           ScResId( TP_VALIDATION_ERROR ),
     753             :                           rArgSet ),
     754             :         aTsbShow        ( this, ScResId( TSB_SHOW ) ),
     755             :         aFlContent      ( this, ScResId( FL_CONTENT ) ),
     756             :         aFtAction       ( this, ScResId( FT_ACTION ) ),
     757             :         aLbAction       ( this, ScResId( LB_ACTION ) ),
     758             :         aBtnSearch      ( this, ScResId( BTN_SEARCH ) ),
     759             :         aFtTitle        ( this, ScResId( FT_TITLE ) ),
     760             :         aEdtTitle       ( this, ScResId( EDT_TITLE ) ),
     761             :         aFtError        ( this, ScResId( FT_ERROR ) ),
     762           0 :         aEdError        ( this, ScResId( EDT_ERROR ) )
     763             : {
     764           0 :     Init();
     765           0 :     FreeResource();
     766           0 : }
     767             : 
     768             : // -----------------------------------------------------------------------
     769             : 
     770           0 : ScTPValidationError::~ScTPValidationError()
     771             : {
     772           0 : }
     773             : 
     774             : // -----------------------------------------------------------------------
     775             : 
     776           0 : void ScTPValidationError::Init()
     777             : {
     778           0 :     aLbAction.SetSelectHdl( LINK( this, ScTPValidationError, SelectActionHdl ) );
     779           0 :     aBtnSearch.SetClickHdl( LINK( this, ScTPValidationError, ClickSearchHdl ) );
     780             : 
     781           0 :     aLbAction.SelectEntryPos( 0 );
     782           0 :     aTsbShow.EnableTriState( false );
     783             : 
     784           0 :     SelectActionHdl( NULL );
     785           0 : }
     786             : 
     787             : //------------------------------------------------------------------------
     788             : 
     789           0 : sal_uInt16* ScTPValidationError::GetRanges()
     790             : {
     791           0 :     return pValueRanges;
     792             : }
     793             : 
     794             : // -----------------------------------------------------------------------
     795             : 
     796           0 : SfxTabPage* ScTPValidationError::Create( Window*    pParent,
     797             :                                          const SfxItemSet&  rArgSet )
     798             : {
     799           0 :     return ( new ScTPValidationError( pParent, rArgSet ) );
     800             : }
     801             : 
     802             : // -----------------------------------------------------------------------
     803             : 
     804           0 : void ScTPValidationError::Reset( const SfxItemSet& rArgSet )
     805             : {
     806             :     const SfxPoolItem* pItem;
     807             : 
     808           0 :     if ( rArgSet.GetItemState( FID_VALID_SHOWERR, sal_True, &pItem ) == SFX_ITEM_SET )
     809           0 :         aTsbShow.SetState( ((const SfxBoolItem*)pItem)->GetValue() ? STATE_CHECK : STATE_NOCHECK );
     810             :     else
     811           0 :         aTsbShow.SetState( STATE_CHECK );   // check by default
     812             : 
     813           0 :     if ( rArgSet.GetItemState( FID_VALID_ERRSTYLE, sal_True, &pItem ) == SFX_ITEM_SET )
     814           0 :         aLbAction.SelectEntryPos( ((const SfxAllEnumItem*)pItem)->GetValue() );
     815             :     else
     816           0 :         aLbAction.SelectEntryPos( 0 );
     817             : 
     818           0 :     if ( rArgSet.GetItemState( FID_VALID_ERRTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
     819           0 :         aEdtTitle.SetText( ((const SfxStringItem*)pItem)->GetValue() );
     820             :     else
     821           0 :         aEdtTitle.SetText( EMPTY_STRING );
     822             : 
     823           0 :     if ( rArgSet.GetItemState( FID_VALID_ERRTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
     824           0 :         aEdError.SetText( ((const SfxStringItem*)pItem)->GetValue() );
     825             :     else
     826           0 :         aEdError.SetText( EMPTY_STRING );
     827             : 
     828           0 :     SelectActionHdl( NULL );
     829           0 : }
     830             : 
     831             : // -----------------------------------------------------------------------
     832             : 
     833           0 : sal_Bool ScTPValidationError::FillItemSet( SfxItemSet& rArgSet )
     834             : {
     835           0 :     rArgSet.Put( SfxBoolItem( FID_VALID_SHOWERR, aTsbShow.GetState() == STATE_CHECK ) );
     836           0 :     rArgSet.Put( SfxAllEnumItem( FID_VALID_ERRSTYLE, aLbAction.GetSelectEntryPos() ) );
     837           0 :     rArgSet.Put( SfxStringItem( FID_VALID_ERRTITLE, aEdtTitle.GetText() ) );
     838           0 :     rArgSet.Put( SfxStringItem( FID_VALID_ERRTEXT, aEdError.GetText() ) );
     839             : 
     840           0 :     return sal_True;
     841             : }
     842             : 
     843             : // -----------------------------------------------------------------------
     844             : 
     845           0 : IMPL_LINK_NOARG(ScTPValidationError, SelectActionHdl)
     846             : {
     847           0 :     ScValidErrorStyle eStyle = (ScValidErrorStyle) aLbAction.GetSelectEntryPos();
     848           0 :     sal_Bool bMacro = ( eStyle == SC_VALERR_MACRO );
     849             : 
     850           0 :     aBtnSearch.Enable( bMacro );
     851           0 :     aFtError.Enable( !bMacro );
     852           0 :     aEdError.Enable( !bMacro );
     853             : 
     854           0 :     return( 0L );
     855             : }
     856             : 
     857             : // -----------------------------------------------------------------------
     858             : 
     859           0 : IMPL_LINK_NOARG(ScTPValidationError, ClickSearchHdl)
     860             : {
     861           0 :     Window* pOld = Application::GetDefDialogParent();
     862           0 :     Application::SetDefDialogParent( this );
     863             : 
     864             :     // Use static SfxApplication method to bring up selector dialog for
     865             :     // choosing a script
     866           0 :     ::rtl::OUString aScriptURL = SfxApplication::ChooseScript();
     867             : 
     868           0 :     Application::SetDefDialogParent( pOld );
     869             : 
     870           0 :     if ( aScriptURL != NULL && !aScriptURL.isEmpty() )
     871             :     {
     872           0 :         aEdtTitle.SetText( aScriptURL );
     873             :     }
     874             : 
     875           0 :     return( 0L );
     876             : }
     877             : 
     878           0 : bool ScValidationDlg::EnterRefStatus()
     879             : {
     880           0 :     ScTabViewShell *pTabViewShell = GetTabViewShell();
     881             : 
     882           0 :     if( !pTabViewShell ) return false;
     883             : 
     884           0 :     sal_uInt16 nId  = SLOTID;
     885           0 :     SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
     886           0 :     SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
     887             : 
     888           0 :     if ( pWnd && pWnd->GetWindow()!= this ) pWnd = NULL;
     889             : 
     890           0 :     SC_MOD()->SetRefDialog( nId, pWnd ? false : sal_True );
     891             : 
     892           0 :     return true;
     893             : }
     894             : 
     895           0 : bool ScValidationDlg::LeaveRefStatus()
     896             : {
     897           0 :     ScTabViewShell *pTabViewShell = GetTabViewShell();
     898             : 
     899           0 :     if( !pTabViewShell ) return false;
     900             : 
     901           0 :     sal_uInt16 nId  = SLOTID;
     902           0 :     SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
     903           0 :     if ( pViewFrm->GetChildWindow( nId ) )
     904             :     {
     905           0 :         DoClose( nId );
     906             :     }
     907           0 :     return true;
     908             : }
     909             : 
     910           0 : bool ScValidationDlg::SetupRefDlg()
     911             : {
     912           0 :     if ( m_bOwnRefHdlr ) return false;
     913           0 :     if( EnterRefMode() )
     914             :     {
     915           0 :         SetModal( false );
     916           0 :         return  m_bOwnRefHdlr = true && EnterRefStatus();
     917             :     }
     918             : 
     919           0 :     return false;
     920             : }
     921             : 
     922           0 : bool ScValidationDlg::RemoveRefDlg( sal_Bool bRestoreModal /* = sal_True */ )
     923             : {
     924           0 :     bool bVisLock = false;
     925           0 :     bool bFreeWindowLock = false;
     926             : 
     927           0 :     ScTabViewShell *pTabVwSh = GetTabViewShell();
     928             : 
     929           0 :     if( !pTabVwSh ) return false;
     930             : 
     931           0 :     if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
     932             :     {
     933           0 :         bVisLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( true );
     934           0 :         bFreeWindowLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( true );
     935             :     }
     936             : 
     937           0 :     if ( !m_bOwnRefHdlr ) return false;
     938           0 :     if( LeaveRefStatus() && LeaveRefMode() )
     939             :     {
     940           0 :         m_bOwnRefHdlr = false;
     941             : 
     942           0 :         if( bRestoreModal )
     943           0 :             SetModal( sal_True );
     944             :     }
     945             : 
     946           0 :     if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
     947             :     {
     948           0 :         static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( bVisLock );
     949           0 :         static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( bFreeWindowLock );
     950             :     }
     951             : 
     952           0 :     return true;
     953             : }
     954             : 
     955           0 : void ScTPValidationValue::ScRefButtonEx::Click()
     956             : {
     957           0 :     if( ScTPValidationValue *pParent = dynamic_cast< ScTPValidationValue*>( GetParent() ) )
     958           0 :         pParent->OnClick( this );
     959             : 
     960           0 :     formula::RefButton::Click();
     961           0 : }
     962             : 
     963           0 : void ScTPValidationValue::OnClick( Button *pBtn )
     964             : {
     965           0 :     if( pBtn == &m_btnRef )
     966           0 :         SetupRefDlg();
     967           0 : }
     968             : 
     969           0 : sal_Bool ScValidationDlg::IsChildFocus()
     970             : {
     971           0 :     if ( const Window *pWin = Application::GetFocusWindow() )
     972           0 :         while( NULL != ( pWin = pWin->GetParent() ) )
     973           0 :             if( pWin == this )
     974           0 :                 return sal_True;
     975             : 
     976           0 :     return false;
     977             : }
     978             : 
     979             : 
     980           0 : bool    ScValidationDlg::IsAlive()
     981             : {
     982           0 :     return SC_MOD()->IsAliveRefDlg( SLOTID, this );
     983           0 : }
     984             : 
     985             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10