/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"
#ifdef SC_DLLIMPLEMENTATION
#undef SC_DLLIMPLEMENTATION
#endif
#include <vcl/svapp.hxx>
#include <svl/aeitem.hxx>
#include <svl/stritem.hxx>
#include <svl/eitem.hxx>
#include <svl/intitem.hxx>
#include <basic/sbmeth.hxx>
#include <basic/sbstar.hxx>
#include <basic/sbmod.hxx>
#include <sfx2/app.hxx>
#include "scresid.hxx"
#include "sc.hrc" // -> Slot IDs
#include "validat.hxx"
#include "validate.hrc"
#include "validate.hxx"
#include "compiler.hxx"
#include "formula/opcode.hxx" //CHINA001
//<!--Added by PengYunQuan for Validity Cell Range Picker
#include "tabvwsh.hxx"
#include <sfx2/viewfrm.hxx>
#include <sfx2/childwin.hxx>
#include "reffact.hxx"
//-->Added by PengYunQuan for Validity Cell Range Picker
// ============================================================================
static sal_uInt16 pValueRanges[] =
{
FID_VALID_MODE, FID_VALID_ERRTEXT,
FID_VALID_LISTTYPE, FID_VALID_LISTTYPE,
0
};
// ============================================================================
//<!--Modified by PengYunQuan for Validity Cell Range Picker
//ScValidationDlg::ScValidationDlg( Window* pParent, const SfxItemSet* pArgSet ) :
// SfxTabDialog( pParent, ScResId( TAB_DLG_VALIDATION ), pArgSet )
ScValidationDlg::ScValidationDlg( Window* pParent,
const SfxItemSet* pArgSet,
ScTabViewShell *pTabViewSh,
SfxBindings *pB /*= NULL*/
) :
ScValidationDlgBase( pParent ? pParent : SFX_APP()->GetTopWindow(), TAB_DLG_VALIDATION, pArgSet, pB ),
m_bOwnRefHdlr( false ),
m_pTabVwSh( pTabViewSh ),
m_bRefInputting( false )
//-->Modified by PengYunQuan for Validity Cell Range Picker
{
AddTabPage( TP_VALIDATION_VALUES, ScTPValidationValue::Create, 0 );
AddTabPage( TP_VALIDATION_INPUTHELP, ScTPValidationHelp::Create, 0 );
AddTabPage( TP_VALIDATION_ERROR, ScTPValidationError::Create, 0 );
FreeResource();
}
//<!--Added by PengYunQuan for Validity Cell Range Picker
void ScTPValidationValue::SetReferenceHdl( const ScRange&rRange , ScDocument* pDoc )
{
if ( rRange.aStart != rRange.aEnd )
if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
if( m_pRefEdit )
pValidationDlg/*->GetRefHandler()*/->RefInputStart( m_pRefEdit );
if ( m_pRefEdit )
{
String aStr;
rRange.Format( aStr, SCR_ABS_3D, pDoc );
m_pRefEdit->SetRefString( aStr );
//m_pRefEdit->SetRefString( rRange.aStart != rRange.aEnd ? aStr : String::CreateFromAscii("=").Append( aStr ) );
}
}
void ScTPValidationValue:: SetActiveHdl()
{
if ( m_pRefEdit ) m_pRefEdit->GrabFocus();
if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
if( m_pRefEdit )
{
pValidationDlg/*->GetRefHandler()*/->RefInputDone();
}
}
void ScTPValidationValue::RefInputStartPreHdl( ScRefEdit* pEdit, ScRefButton* pButton )
{
if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
{
if( pEdit == m_pRefEdit )
{
if( Window *pPreWnd = pEdit==&maEdMax?&maFtMax:(pEdit==&maEdMin?&maFtMin:NULL) )
{
pPreWnd->SetParent( pValidationDlg );
pPreWnd->Hide();
}
m_pRefEdit->SetParent( pValidationDlg );
}
if( pButton == &m_btnRef )m_btnRef.SetParent( pValidationDlg );
}
}
void ScTPValidationValue::RefInputDonePreHdl()
{
if( m_pRefEdit && m_pRefEdit->GetParent()!= this )
{
if( Window *pPreWnd = m_pRefEdit==&maEdMax?&maFtMax:(m_pRefEdit==&maEdMin?&maFtMin:NULL) )
{
pPreWnd->SetParent( this );
pPreWnd->Show();
}
m_pRefEdit->SetParent( this );
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
// aExample1.SetParent( m_pRefEdit ); // the aExample1's child order will affect acc key
}
if( m_btnRef.GetParent()!=this ) m_btnRef.SetParent( this );
// if( aExample1.GetParent()!=this ) aExample1.SetParent( this );
}
void ScTPValidationValue::RefInputDonePostHdl()
{
if( m_pRefEdit && !m_pRefEdit->HasFocus() )
m_pRefEdit->GrabFocus();
}
sal_Bool ScValidationDlg::Close()
{
if( m_bOwnRefHdlr )
if( SfxTabPage* pPage = GetTabPage( TP_VALIDATION_VALUES ) )
static_cast<ScTPValidationValue*>(pPage)->RemoveRefDlg();
return ScValidationDlgBase::Close();
}
//-->Added by PengYunQuan for Validity Cell Range Picker
ScValidationDlg::~ScValidationDlg()
{
//<!--Added by PengYunQuan for Validity Cell Range Picker
if( m_bOwnRefHdlr )
RemoveRefDlg( sal_False );
//-->Added by PengYunQuan for Validity Cell Range Picker
}
// ============================================================================
namespace {
/** Converts the passed ScValidationMode to the position in the list box. */
sal_uInt16 lclGetPosFromValMode( ScValidationMode eValMode )
{
sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
switch( eValMode )
{
case SC_VALID_ANY: nLbPos = SC_VALIDDLG_ALLOW_ANY; break;
case SC_VALID_WHOLE: nLbPos = SC_VALIDDLG_ALLOW_WHOLE; break;
case SC_VALID_DECIMAL: nLbPos = SC_VALIDDLG_ALLOW_DECIMAL; break;
case SC_VALID_DATE: nLbPos = SC_VALIDDLG_ALLOW_DATE; break;
case SC_VALID_TIME: nLbPos = SC_VALIDDLG_ALLOW_TIME; break;
case SC_VALID_TEXTLEN: nLbPos = SC_VALIDDLG_ALLOW_TEXTLEN; break;
case SC_VALID_LIST: nLbPos = SC_VALIDDLG_ALLOW_RANGE; break;
case SC_VALID_CUSTOM: nLbPos = SC_VALIDDLG_ALLOW_ANY; break; // not supported
default: DBG_ERRORFILE( "lclGetPosFromValMode - unknown validity mode" );
}
return nLbPos;
}
/** Converts the passed list box position to an ScValidationMode. */
ScValidationMode lclGetValModeFromPos( sal_uInt16 nLbPos )
{
ScValidationMode eValMode = SC_VALID_ANY;
switch( nLbPos )
{
case SC_VALIDDLG_ALLOW_ANY: eValMode = SC_VALID_ANY; break;
case SC_VALIDDLG_ALLOW_WHOLE: eValMode = SC_VALID_WHOLE; break;
case SC_VALIDDLG_ALLOW_DECIMAL: eValMode = SC_VALID_DECIMAL; break;
case SC_VALIDDLG_ALLOW_DATE: eValMode = SC_VALID_DATE; break;
case SC_VALIDDLG_ALLOW_TIME: eValMode = SC_VALID_TIME; break;
case SC_VALIDDLG_ALLOW_RANGE: eValMode = SC_VALID_LIST; break;
case SC_VALIDDLG_ALLOW_LIST: eValMode = SC_VALID_LIST; break;
case SC_VALIDDLG_ALLOW_TEXTLEN: eValMode = SC_VALID_TEXTLEN; break;
default: DBG_ERRORFILE( "lclGetValModeFromPos - invalid list box position" );
}
return eValMode;
}
/** Converts the passed ScConditionMode to the position in the list box. */
sal_uInt16 lclGetPosFromCondMode( ScConditionMode eCondMode )
{
sal_uInt16 nLbPos = SC_VALIDDLG_DATA_EQUAL;
switch( eCondMode )
{
case SC_COND_NONE: // #111771# may occur in old XML files after Excel import
case SC_COND_EQUAL: nLbPos = SC_VALIDDLG_DATA_EQUAL; break;
case SC_COND_LESS: nLbPos = SC_VALIDDLG_DATA_LESS; break;
case SC_COND_GREATER: nLbPos = SC_VALIDDLG_DATA_GREATER; break;
case SC_COND_EQLESS: nLbPos = SC_VALIDDLG_DATA_EQLESS; break;
case SC_COND_EQGREATER: nLbPos = SC_VALIDDLG_DATA_EQGREATER; break;
case SC_COND_NOTEQUAL: nLbPos = SC_VALIDDLG_DATA_NOTEQUAL; break;
case SC_COND_BETWEEN: nLbPos = SC_VALIDDLG_DATA_BETWEEN; break;
case SC_COND_NOTBETWEEN: nLbPos = SC_VALIDDLG_DATA_NOTBETWEEN; break;
default: DBG_ERRORFILE( "lclGetPosFromCondMode - unknown condition mode" );
}
return nLbPos;
}
/** Converts the passed list box position to an ScConditionMode. */
ScConditionMode lclGetCondModeFromPos( sal_uInt16 nLbPos )
{
ScConditionMode eCondMode = SC_COND_EQUAL;
switch( nLbPos )
{
case SC_VALIDDLG_DATA_EQUAL: eCondMode = SC_COND_EQUAL; break;
case SC_VALIDDLG_DATA_LESS: eCondMode = SC_COND_LESS; break;
case SC_VALIDDLG_DATA_GREATER: eCondMode = SC_COND_GREATER; break;
case SC_VALIDDLG_DATA_EQLESS: eCondMode = SC_COND_EQLESS; break;
case SC_VALIDDLG_DATA_EQGREATER: eCondMode = SC_COND_EQGREATER; break;
case SC_VALIDDLG_DATA_NOTEQUAL: eCondMode = SC_COND_NOTEQUAL; break;
case SC_VALIDDLG_DATA_BETWEEN: eCondMode = SC_COND_BETWEEN; break;
case SC_VALIDDLG_DATA_NOTBETWEEN: eCondMode = SC_COND_NOTBETWEEN; break;
default: DBG_ERRORFILE( "lclGetCondModeFromPos - invalid list box position" );
}
return eCondMode;
}
/** Converts line feed separated string to a formula with strings separated by semicolons.
@descr Keeps all empty strings.
Example: abc\ndef\n\nghi -> "abc";"def";"";"ghi".
@param rFmlaStr (out-param) The converted formula string. */
void lclGetFormulaFromStringList( String& rFmlaStr, const String& rStringList, sal_Unicode cFmlaSep )
{
rFmlaStr.Erase();
xub_StrLen nTokenCnt = rStringList.GetTokenCount( '\n' );
for( xub_StrLen nToken = 0, nStringIx = 0; nToken < nTokenCnt; ++nToken )
{
String aToken( rStringList.GetToken( 0, '\n', nStringIx ) );
ScGlobal::AddQuotes( aToken, '"' );
ScGlobal::AddToken( rFmlaStr, aToken, cFmlaSep );
}
if( !rFmlaStr.Len() )
rFmlaStr.AssignAscii( "\"\"" );
}
/** Converts formula with strings separated by semicolons to line feed separated string.
@descr Keeps all empty strings. Ignores all empty tokens (multiple semicolons).
Example: "abc";;;"def";"";"ghi" -> abc\ndef\n\nghi.
@param rStringList (out-param) The converted line feed separated string list.
@return true = Conversion successful. */
bool lclGetStringListFromFormula( String& rStringList, const String& rFmlaStr, sal_Unicode cFmlaSep )
{
String aQuotes( RTL_CONSTASCII_USTRINGPARAM( "\"\"" ) );
xub_StrLen nTokenCnt = rFmlaStr.GetQuotedTokenCount( aQuotes, cFmlaSep );
rStringList.Erase();
bool bIsStringList = (nTokenCnt > 0);
bool bTokenAdded = false;
for( xub_StrLen nToken = 0, nStringIx = 0; bIsStringList && (nToken < nTokenCnt); ++nToken )
{
String aToken( rFmlaStr.GetQuotedToken( 0, aQuotes, cFmlaSep, nStringIx ) );
aToken.EraseLeadingAndTrailingChars();
if( aToken.Len() ) // ignore empty tokens, i.e. "a";;"b"
{
bIsStringList = ScGlobal::IsQuoted( aToken, '"' );
if( bIsStringList )
{
ScGlobal::EraseQuotes( aToken, '"' );
ScGlobal::AddToken( rStringList, aToken, '\n', 1, bTokenAdded );
bTokenAdded = true;
}
}
}
return bIsStringList;
}
} // namespace
// ----------------------------------------------------------------------------
ScTPValidationValue::ScTPValidationValue( Window* pParent, const SfxItemSet& rArgSet ) :
SfxTabPage( pParent, ScResId( TP_VALIDATION_VALUES ), rArgSet ),
maFtAllow ( this, ScResId( FT_ALLOW ) ),
maLbAllow ( this, ScResId( LB_ALLOW ) ),
maCbAllow ( this, ScResId( TSB_ALLOW_BLANKS ) ),
maCbShow ( this, ScResId( CB_SHOWLIST ) ),
maCbSort ( this, ScResId( CB_SORTLIST ) ),
maFtValue ( this, ScResId( FT_VALUE ) ),
maLbValue ( this, ScResId( LB_VALUE ) ),
maFtMin ( this, ScResId( FT_MIN ) ),
maEdMin ( this, ScResId( EDT_MIN ) ),
maEdList ( this, ScResId( EDT_LIST ) ),
maFtMax ( this, ScResId( FT_MAX ) ),
maEdMax ( this, ScResId( EDT_MAX ) ),
maFtHint ( this, ScResId( FT_SOURCEHINT ) ),
maStrMin ( ScResId( SCSTR_VALID_MINIMUM ) ),
maStrMax ( ScResId( SCSTR_VALID_MAXIMUM ) ),
maStrValue( ScResId( SCSTR_VALID_VALUE ) ),
maStrRange( ScResId( SCSTR_VALID_RANGE ) ),
maStrList ( ScResId( SCSTR_VALID_LIST ) ),
//<!--Added by PengYunQuan for Validity Cell Range Picker
m_btnRef( this, ScResId( RB_VALIDITY_REF ) )
//-->Added by PengYunQuan for Validity Cell Range Picker
{
Init();
FreeResource();
// list separator in formulas
//CHINA001 const String& rListSep = ScCompiler::pSymbolTableNative[ ocSep ];
String aListSep = ::GetScCompilerNativeSymbol( ocSep ); //CHINA001
DBG_ASSERT( aListSep.Len() == 1, "ScTPValidationValue::ScTPValidationValue - list separator error" );
mcFmlaSep = aListSep.Len() ? aListSep.GetChar( 0 ) : ';';
//<!--Added by PengYunQuan for Validity Cell Range Picker
m_btnRef.Hide();
//-->Added by PengYunQuan for Validity Cell Range Picker
}
ScTPValidationValue::~ScTPValidationValue()
{
}
void ScTPValidationValue::Init()
{
maLbAllow.SetSelectHdl( LINK( this, ScTPValidationValue, SelectHdl ) );
maLbValue.SetSelectHdl( LINK( this, ScTPValidationValue, SelectHdl ) );
maCbShow.SetClickHdl( LINK( this, ScTPValidationValue, CheckHdl ) );
//<!--Added by PengYunQuan for Validity Cell Range Picker
maEdMin.SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
maEdMin.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
maEdMax.SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
m_btnRef.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
maEdMax.SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillFocusHdl ) );
//-->Added by PengYunQuan for Validity Cell Range Picker
maLbAllow.SelectEntryPos( SC_VALIDDLG_ALLOW_ANY );
maLbValue.SelectEntryPos( SC_VALIDDLG_DATA_EQUAL );
SelectHdl( NULL );
CheckHdl( NULL );
}
SfxTabPage* ScTPValidationValue::Create( Window* pParent, const SfxItemSet& rArgSet )
{
return( new ScTPValidationValue( pParent, rArgSet ) );
}
sal_uInt16* ScTPValidationValue::GetRanges()
{
return pValueRanges;
}
void ScTPValidationValue::Reset( const SfxItemSet& rArgSet )
{
const SfxPoolItem* pItem;
sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
if( rArgSet.GetItemState( FID_VALID_MODE, sal_True, &pItem ) == SFX_ITEM_SET )
nLbPos = lclGetPosFromValMode( static_cast< ScValidationMode >(
static_cast< const SfxAllEnumItem* >( pItem )->GetValue() ) );
maLbAllow.SelectEntryPos( nLbPos );
nLbPos = SC_VALIDDLG_DATA_EQUAL;
if( rArgSet.GetItemState( FID_VALID_CONDMODE, sal_True, &pItem ) == SFX_ITEM_SET )
nLbPos = lclGetPosFromCondMode( static_cast< ScConditionMode >(
static_cast< const SfxAllEnumItem* >( pItem )->GetValue() ) );
maLbValue.SelectEntryPos( nLbPos );
// *** check boxes ***
sal_Bool bCheck = sal_True;
if( rArgSet.GetItemState( FID_VALID_BLANK, sal_True, &pItem ) == SFX_ITEM_SET )
bCheck = static_cast< const SfxBoolItem* >( pItem )->GetValue();
maCbAllow.Check( bCheck );
sal_Int32 nListType = ValidListType::UNSORTED;
if( rArgSet.GetItemState( FID_VALID_LISTTYPE, sal_True, &pItem ) == SFX_ITEM_SET )
nListType = static_cast< const SfxInt16Item* >( pItem )->GetValue();
maCbShow.Check( nListType != ValidListType::INVISIBLE );
maCbSort.Check( nListType == ValidListType::SORTEDASCENDING );
// *** formulas ***
String aFmlaStr;
if ( rArgSet.GetItemState( FID_VALID_VALUE1, sal_True, &pItem ) == SFX_ITEM_SET )
aFmlaStr = static_cast< const SfxStringItem* >( pItem )->GetValue();
SetFirstFormula( aFmlaStr );
aFmlaStr.Erase();
if ( rArgSet.GetItemState( FID_VALID_VALUE2, sal_True, &pItem ) == SFX_ITEM_SET )
aFmlaStr = static_cast< const SfxStringItem* >( pItem )->GetValue();
SetSecondFormula( aFmlaStr );
SelectHdl( NULL );
CheckHdl( NULL );
}
sal_Bool ScTPValidationValue::FillItemSet( SfxItemSet& rArgSet )
{
sal_Int16 nListType = maCbShow.IsChecked() ?
(maCbSort.IsChecked() ? ValidListType::SORTEDASCENDING : ValidListType::UNSORTED) :
ValidListType::INVISIBLE;
rArgSet.Put( SfxAllEnumItem( FID_VALID_MODE, sal::static_int_cast<sal_uInt16>(
lclGetValModeFromPos( maLbAllow.GetSelectEntryPos() ) ) ) );
rArgSet.Put( SfxAllEnumItem( FID_VALID_CONDMODE, sal::static_int_cast<sal_uInt16>(
lclGetCondModeFromPos( maLbValue.GetSelectEntryPos() ) ) ) );
rArgSet.Put( SfxStringItem( FID_VALID_VALUE1, GetFirstFormula() ) );
rArgSet.Put( SfxStringItem( FID_VALID_VALUE2, GetSecondFormula() ) );
rArgSet.Put( SfxBoolItem( FID_VALID_BLANK, maCbAllow.IsChecked() ) );
rArgSet.Put( SfxInt16Item( FID_VALID_LISTTYPE, nListType ) );
return sal_True;
}
String ScTPValidationValue::GetFirstFormula() const
{
String aFmlaStr;
if( maLbAllow.GetSelectEntryPos() == SC_VALIDDLG_ALLOW_LIST )
lclGetFormulaFromStringList( aFmlaStr, maEdList.GetText(), mcFmlaSep );
else
aFmlaStr = maEdMin.GetText();
return aFmlaStr;
}
String ScTPValidationValue::GetSecondFormula() const
{
return maEdMax.GetText();
}
void ScTPValidationValue::SetFirstFormula( const String& rFmlaStr )
{
// try if formula is a string list, validation mode must already be set
String aStringList;
if( (maLbAllow.GetSelectEntryPos() == SC_VALIDDLG_ALLOW_RANGE) &&
lclGetStringListFromFormula( aStringList, rFmlaStr, mcFmlaSep ) )
{
maEdList.SetText( aStringList );
maEdMin.SetText( EMPTY_STRING );
// change validation mode to string list
maLbAllow.SelectEntryPos( SC_VALIDDLG_ALLOW_LIST );
}
else
{
maEdMin.SetText( rFmlaStr );
maEdList.SetText( EMPTY_STRING );
}
}
void ScTPValidationValue::SetSecondFormula( const String& rFmlaStr )
{
maEdMax.SetText( rFmlaStr );
}
//<!--Added by PengYunQuan for Validity Cell Range Picker
ScValidationDlg * ScTPValidationValue::GetValidationDlg()
{
if( Window *pParent = GetParent() )
do{
if ( dynamic_cast<ScValidationDlg*>( pParent ) )
return static_cast< ScValidationDlg * >( pParent );
}while ( NULL != ( pParent = pParent->GetParent() ) );
return NULL;
}
void ScTPValidationValue::SetupRefDlg()
{
if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
if( pValidationDlg->SetupRefDlg() )
{
pValidationDlg->SetHandler( this );
pValidationDlg->SetSetRefHdl( (ScRefHandlerHelper::PFUNCSETREFHDLTYPE)( &ScTPValidationValue::SetReferenceHdl ) );
pValidationDlg->SetSetActHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::SetActiveHdl ) );
pValidationDlg->SetRefInputStartPreHdl( (ScRefHandlerHelper::PINPUTSTARTDLTYPE)( &ScTPValidationValue::RefInputStartPreHdl ) );
pValidationDlg->SetRefInputDonePreHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::RefInputDonePreHdl ) );
pValidationDlg->SetRefInputDonePostHdl( (ScRefHandlerHelper::PCOMMONHDLTYPE)( &ScTPValidationValue::RefInputDonePostHdl ) );
if ( maEdMax.IsVisible() ) { m_pRefEdit = &maEdMax; }
else if ( maEdMin.IsVisible() ) { m_pRefEdit = &maEdMin; }
if( m_pRefEdit && !m_pRefEdit->HasFocus() ) m_pRefEdit->GrabFocus();
if( m_pRefEdit ) m_pRefEdit->SetRefDialog( pValidationDlg );
m_btnRef.SetReferences( pValidationDlg, m_pRefEdit );
}
}
void ScTPValidationValue::RemoveRefDlg()
{
if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
if( pValidationDlg->RemoveRefDlg() )
{
pValidationDlg->SetHandler( NULL );
pValidationDlg->SetSetRefHdl( NULL );
pValidationDlg->SetSetActHdl( NULL );
pValidationDlg->SetRefInputStartPreHdl( NULL );
pValidationDlg->SetRefInputDonePreHdl( NULL );
pValidationDlg->SetRefInputDonePostHdl( NULL );
if( m_pRefEdit ) m_pRefEdit->SetRefDialog( NULL );
m_pRefEdit = NULL;
m_btnRef.SetReferences( NULL, NULL );
#if ! defined( WNT ) && !defined( _MSC_VER )
TidyListBoxes();
#endif
}
}
void ScTPValidationValue::TidyListBoxes()
{
if ( Window *pWnd = GetChild( 0 ) )
{
bool bFindLst = false;
std::list<Window*> alstOrder;
do{
if( pWnd->GetParent() == this )
{
if ( !bFindLst )
{
try{
if( dynamic_cast<ListBox*>(pWnd)||dynamic_cast<ListBox*>(pWnd->GetWindow(WINDOW_CLIENT) ) )
bFindLst = true;
}
catch( ... )
{
if ( *(void**)pWnd == *(void**)&maLbValue )
bFindLst = true;
else if ( Window *pClient = pWnd->GetWindow( WINDOW_CLIENT ) )
if ( *(void**)pClient == *(void**)&maLbValue )
bFindLst = true;
}
}
if ( bFindLst )
alstOrder.push_back( pWnd->GetWindow( WINDOW_CLIENT ) );
}
}while( NULL != ( pWnd = pWnd->GetWindow( WINDOW_NEXT ) ) );
pWnd = GetChild(0);
while( std::find( alstOrder.begin(), alstOrder.end(), pWnd ) != alstOrder.end() && NULL != ( pWnd = pWnd->GetWindow( WINDOW_NEXT) ) ) ;
if ( pWnd )
{
for ( std::list<Window*>::iterator i = alstOrder.begin(); i!=alstOrder.end(); i++ )
{
Window *pParent = (*i)->GetParent();
(*i)->SetParent( pWnd );
(*i)->SetParent( pParent );
}
}
}
}
IMPL_LINK( ScTPValidationValue, EditSetFocusHdl, Edit *, /*pEdit*/ )
{
sal_uInt16 nPos=maLbAllow.GetSelectEntryPos();
if ( nPos == SC_VALIDDLG_ALLOW_RANGE )
{
SetupRefDlg();
}
return 0;
}
IMPL_LINK( ScTPValidationValue, KillFocusHdl, Window *, pWnd )
{
if( pWnd == m_pRefEdit || pWnd == &m_btnRef )
if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
if ( (pValidationDlg->IsActive() || pValidationDlg->IsChildFocus() ) && !pValidationDlg->IsRefInputting() )
if( ( !m_pRefEdit || !m_pRefEdit->HasFocus()) && !m_btnRef.HasFocus() )
{
RemoveRefDlg();
}
return 0;
}
//-->Added by PengYunQuan for Validity Cell Range Picker
// ----------------------------------------------------------------------------
IMPL_LINK( ScTPValidationValue, SelectHdl, ListBox*, EMPTYARG )
{
sal_uInt16 nLbPos = maLbAllow.GetSelectEntryPos();
bool bEnable = (nLbPos != SC_VALIDDLG_ALLOW_ANY);
bool bRange = (nLbPos == SC_VALIDDLG_ALLOW_RANGE);
bool bList = (nLbPos == SC_VALIDDLG_ALLOW_LIST);
maCbAllow.Enable( bEnable ); // Leerzellen
maFtValue.Enable( bEnable );
maLbValue.Enable( bEnable );
maFtMin.Enable( bEnable );
maEdMin.Enable( bEnable );
maEdList.Enable( bEnable );
maFtMax.Enable( bEnable );
maEdMax.Enable( bEnable );
bool bShowMax = false;
if( bRange )
maFtMin.SetText( maStrRange );
else if( bList )
maFtMin.SetText( maStrList );
else
{
switch( maLbValue.GetSelectEntryPos() )
{
case SC_VALIDDLG_DATA_EQUAL:
case SC_VALIDDLG_DATA_NOTEQUAL: maFtMin.SetText( maStrValue ); break;
case SC_VALIDDLG_DATA_LESS:
case SC_VALIDDLG_DATA_EQLESS: maFtMin.SetText( maStrMax ); break;
case SC_VALIDDLG_DATA_BETWEEN:
case SC_VALIDDLG_DATA_NOTBETWEEN: bShowMax = true; // fall through
case SC_VALIDDLG_DATA_GREATER:
case SC_VALIDDLG_DATA_EQGREATER: maFtMin.SetText( maStrMin ); break;
default:
DBG_ERRORFILE( "ScTPValidationValue::SelectHdl - unknown condition mode" );
}
}
maCbShow.Show( bRange || bList );
maCbSort.Show( bRange || bList );
maFtValue.Show( !bRange && !bList );
maLbValue.Show( !bRange && !bList );
maEdMin.Show( !bList );
maEdList.Show( bList );
maFtMax.Show( bShowMax );
maEdMax.Show( bShowMax );
maFtHint.Show( bRange );
//<!--Added by PengYunQuan for Validity Cell Range Picker
m_btnRef.Show( bRange );
//-->Added by PengYunQuan for Validity Cell Range Picker
return 0;
}
IMPL_LINK( ScTPValidationValue, CheckHdl, CheckBox*, EMPTYARG )
{
maCbSort.Enable( maCbShow.IsChecked() );
return 0;
}
//========================================================================
//========================================================================
// Input Help Page
ScTPValidationHelp::ScTPValidationHelp( Window* pParent,
const SfxItemSet& rArgSet )
: SfxTabPage ( pParent,
ScResId( TP_VALIDATION_INPUTHELP ),
rArgSet ),
aTsbHelp ( this, ScResId( TSB_HELP ) ),
aFlContent ( this, ScResId( FL_CONTENT ) ),
aFtTitle ( this, ScResId( FT_TITLE ) ),
aEdtTitle ( this, ScResId( EDT_TITLE ) ),
aFtInputHelp ( this, ScResId( FT_INPUTHELP ) ),
aEdInputHelp ( this, ScResId( EDT_INPUTHELP ) ),
mrArgSet ( rArgSet )
{
Init();
FreeResource();
}
// -----------------------------------------------------------------------
__EXPORT ScTPValidationHelp::~ScTPValidationHelp()
{
}
// -----------------------------------------------------------------------
void ScTPValidationHelp::Init()
{
//aLb.SetSelectHdl( LINK( this, ScTPValidationHelp, SelectHdl ) );
aTsbHelp.EnableTriState( sal_False );
}
//------------------------------------------------------------------------
sal_uInt16* __EXPORT ScTPValidationHelp::GetRanges()
{
return pValueRanges;
}
// -----------------------------------------------------------------------
SfxTabPage* __EXPORT ScTPValidationHelp::Create( Window* pParent,
const SfxItemSet& rArgSet )
{
return ( new ScTPValidationHelp( pParent, rArgSet ) );
}
// -----------------------------------------------------------------------
void __EXPORT ScTPValidationHelp::Reset( const SfxItemSet& rArgSet )
{
const SfxPoolItem* pItem;
if ( rArgSet.GetItemState( FID_VALID_SHOWHELP, sal_True, &pItem ) == SFX_ITEM_SET )
aTsbHelp.SetState( ((const SfxBoolItem*)pItem)->GetValue() ? STATE_CHECK : STATE_NOCHECK );
else
aTsbHelp.SetState( STATE_NOCHECK );
if ( rArgSet.GetItemState( FID_VALID_HELPTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
aEdtTitle.SetText( ((const SfxStringItem*)pItem)->GetValue() );
else
aEdtTitle.SetText( EMPTY_STRING );
if ( rArgSet.GetItemState( FID_VALID_HELPTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
aEdInputHelp.SetText( ((const SfxStringItem*)pItem)->GetValue() );
else
aEdInputHelp.SetText( EMPTY_STRING );
}
// -----------------------------------------------------------------------
sal_Bool __EXPORT ScTPValidationHelp::FillItemSet( SfxItemSet& rArgSet )
{
rArgSet.Put( SfxBoolItem( FID_VALID_SHOWHELP, aTsbHelp.GetState() == STATE_CHECK ) );
rArgSet.Put( SfxStringItem( FID_VALID_HELPTITLE, aEdtTitle.GetText() ) );
rArgSet.Put( SfxStringItem( FID_VALID_HELPTEXT, aEdInputHelp.GetText() ) );
return sal_True;
}
//========================================================================
//========================================================================
// Error Alert Page
ScTPValidationError::ScTPValidationError( Window* pParent,
const SfxItemSet& rArgSet )
: SfxTabPage ( pParent,
ScResId( TP_VALIDATION_ERROR ),
rArgSet ),
aTsbShow ( this, ScResId( TSB_SHOW ) ),
aFlContent ( this, ScResId( FL_CONTENT ) ),
aFtAction ( this, ScResId( FT_ACTION ) ),
aLbAction ( this, ScResId( LB_ACTION ) ),
aBtnSearch ( this, ScResId( BTN_SEARCH ) ),
aFtTitle ( this, ScResId( FT_TITLE ) ),
aEdtTitle ( this, ScResId( EDT_TITLE ) ),
aFtError ( this, ScResId( FT_ERROR ) ),
aEdError ( this, ScResId( EDT_ERROR ) ),
mrArgSet ( rArgSet )
{
Init();
FreeResource();
}
// -----------------------------------------------------------------------
__EXPORT ScTPValidationError::~ScTPValidationError()
{
}
// -----------------------------------------------------------------------
void ScTPValidationError::Init()
{
aLbAction.SetSelectHdl( LINK( this, ScTPValidationError, SelectActionHdl ) );
aBtnSearch.SetClickHdl( LINK( this, ScTPValidationError, ClickSearchHdl ) );
aLbAction.SelectEntryPos( 0 );
aTsbShow.EnableTriState( sal_False );
SelectActionHdl( NULL );
}
//------------------------------------------------------------------------
sal_uInt16* __EXPORT ScTPValidationError::GetRanges()
{
return pValueRanges;
}
// -----------------------------------------------------------------------
SfxTabPage* __EXPORT ScTPValidationError::Create( Window* pParent,
const SfxItemSet& rArgSet )
{
return ( new ScTPValidationError( pParent, rArgSet ) );
}
// -----------------------------------------------------------------------
void __EXPORT ScTPValidationError::Reset( const SfxItemSet& rArgSet )
{
const SfxPoolItem* pItem;
if ( rArgSet.GetItemState( FID_VALID_SHOWERR, sal_True, &pItem ) == SFX_ITEM_SET )
aTsbShow.SetState( ((const SfxBoolItem*)pItem)->GetValue() ? STATE_CHECK : STATE_NOCHECK );
else
aTsbShow.SetState( STATE_CHECK ); // #111720# check by default
if ( rArgSet.GetItemState( FID_VALID_ERRSTYLE, sal_True, &pItem ) == SFX_ITEM_SET )
aLbAction.SelectEntryPos( ((const SfxAllEnumItem*)pItem)->GetValue() );
else
aLbAction.SelectEntryPos( 0 );
if ( rArgSet.GetItemState( FID_VALID_ERRTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
aEdtTitle.SetText( ((const SfxStringItem*)pItem)->GetValue() );
else
aEdtTitle.SetText( EMPTY_STRING );
if ( rArgSet.GetItemState( FID_VALID_ERRTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
aEdError.SetText( ((const SfxStringItem*)pItem)->GetValue() );
else
aEdError.SetText( EMPTY_STRING );
SelectActionHdl( NULL );
}
// -----------------------------------------------------------------------
sal_Bool __EXPORT ScTPValidationError::FillItemSet( SfxItemSet& rArgSet )
{
rArgSet.Put( SfxBoolItem( FID_VALID_SHOWERR, aTsbShow.GetState() == STATE_CHECK ) );
rArgSet.Put( SfxAllEnumItem( FID_VALID_ERRSTYLE, aLbAction.GetSelectEntryPos() ) );
rArgSet.Put( SfxStringItem( FID_VALID_ERRTITLE, aEdtTitle.GetText() ) );
rArgSet.Put( SfxStringItem( FID_VALID_ERRTEXT, aEdError.GetText() ) );
return sal_True;
}
// -----------------------------------------------------------------------
IMPL_LINK( ScTPValidationError, SelectActionHdl, ListBox*, EMPTYARG )
{
ScValidErrorStyle eStyle = (ScValidErrorStyle) aLbAction.GetSelectEntryPos();
sal_Bool bMacro = ( eStyle == SC_VALERR_MACRO );
aBtnSearch.Enable( bMacro );
aFtError.Enable( !bMacro );
aEdError.Enable( !bMacro );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( ScTPValidationError, ClickSearchHdl, PushButton*, EMPTYARG )
{
Window* pOld = Application::GetDefDialogParent();
Application::SetDefDialogParent( this );
// Use static SfxApplication method to bring up selector dialog for
// choosing a script
::rtl::OUString aScriptURL = SfxApplication::ChooseScript();
Application::SetDefDialogParent( pOld );
if ( aScriptURL != NULL && aScriptURL.getLength() != 0 )
{
aEdtTitle.SetText( aScriptURL );
}
return( 0L );
}
//<!--Added by PengYunQuan for Validity Cell Range Picker
bool ScValidationDlg::EnterRefStatus()
{
ScTabViewShell *pTabViewShell = GetTabViewShell();
if( !pTabViewShell ) return false;
sal_uInt16 nId = SLOTID;
SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
if ( pWnd && pWnd->GetWindow()!= this ) pWnd = NULL;
SC_MOD()->SetRefDialog( nId, pWnd ? sal_False : sal_True );
return true;
}
bool ScValidationDlg::LeaveRefStatus()
{
ScTabViewShell *pTabViewShell = GetTabViewShell();
if( !pTabViewShell ) return false;
sal_uInt16 nId = SLOTID;
SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
//SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
if ( pViewFrm->GetChildWindow( nId ) )
{
DoClose( nId );
}
return true;
}
bool ScValidationDlg::SetupRefDlg()
{
if ( m_bOwnRefHdlr ) return false;
if( EnterRefMode() )
{
SetModal( sal_False );
return /*SetChkShell( GetDocShell() ),*/ m_bOwnRefHdlr = true && EnterRefStatus();
}
return false;
}
bool ScValidationDlg::RemoveRefDlg( sal_Bool bRestoreModal /* = sal_True */ )
{
bool bVisLock = false;
bool bFreeWindowLock = false;
ScTabViewShell *pTabVwSh = GetTabViewShell();
if( !pTabVwSh ) return false;
if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
{
bVisLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( true );
bFreeWindowLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( true );
}
if ( !m_bOwnRefHdlr ) return false;
if( LeaveRefStatus() && LeaveRefMode() )
{
m_bOwnRefHdlr = false;
if( bRestoreModal )
SetModal( sal_True );
}
if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
{
static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( bVisLock );
static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( bFreeWindowLock );
}
return true;
}
//TYPEINIT1( ScTPValidationValue, SfxTabPage )
void ScTPValidationValue::ScRefButtonEx::Click()
{
if( ScTPValidationValue *pParent = dynamic_cast< ScTPValidationValue*>( GetParent() ) )
pParent->OnClick( this );
ScRefButton::Click();
}
void ScTPValidationValue::OnClick( Button *pBtn )
{
if( pBtn == &m_btnRef )
SetupRefDlg();
}
sal_Bool ScValidationDlg::IsChildFocus()
{
if ( const Window *pWin = Application::GetFocusWindow() )
while( NULL != ( pWin = pWin->GetParent() ) )
if( pWin == this )
return sal_True;
return sal_False;
}
bool ScValidationDlg::IsAlive()
{
return SC_MOD()->IsAliveRefDlg( SLOTID, this );
}
//-->Added by PengYunQuan for Validity Cell Range Picker