xref: /AOO41X/main/sc/source/ui/view/cellsh2.cxx (revision 8e8ee8fefdac26d905672cc573c35fd0ae1f9356)

/**************************************************************
 *
 * 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"



//------------------------------------------------------------------

// INCLUDE ---------------------------------------------------------------

#include "scitems.hxx"
#include <sfx2/viewfrm.hxx>
#include <sfx2/app.hxx>
#include <sfx2/request.hxx>
#include <svl/aeitem.hxx>
#include <basic/sbxcore.hxx>
#include <svl/whiter.hxx>
#include <svl/zforlist.hxx>
#include <vcl/msgbox.hxx>
#include <svl/stritem.hxx>
#include <svl/visitem.hxx>
#include <unotools/moduleoptions.hxx>

#include <com/sun/star/frame/FrameSearchFlag.hpp>
#include <com/sun/star/sdbc/XResultSet.hpp>

#include "cellsh.hxx"
#include "tabvwsh.hxx"
#include "sc.hrc"
#include "globstr.hrc"
#include "global.hxx"
#include "scmod.hxx"
#include "docsh.hxx"
#include "document.hxx"
#include "uiitems.hxx"
#include "dbfunc.hxx"
#include "dbdocfun.hxx"
//CHINA001 #include "lbseldlg.hxx"
//CHINA001 #include "sortdlg.hxx"
#include "filtdlg.hxx"
#include "dbnamdlg.hxx"
//CHINA001 #include "subtdlg.hxx"
#include "reffact.hxx"
#include "pvlaydlg.hxx"
#include "validat.hxx"
#include "scresid.hxx"
//CHINA001 #include "validate.hxx"
#include "pivot.hxx"
#include "dpobject.hxx"
//CHINA001 #include "dapitype.hxx"
//CHINA001 #include "dapidata.hxx"
#include "dpsdbtab.hxx"		// ScImportSourceDesc
#include "dpshttab.hxx"		// ScSheetSourceDesc

#include "validate.hrc" //CHINA001 add for ScValidationDlg
#include "scui_def.hxx" //CHINA001
#include "scabstdlg.hxx" //CHINA001
#include "impex.hxx"
#include "asciiopt.hxx"
using namespace com::sun::star;

//#include "strindlg.hxx"		//! Test !!!!!

//static ScArea aPivotSource; 		//! wohin? (ueber den Dialog retten)


#define IS_AVAILABLE(WhichId,ppItem) \
    (pReqArgs->GetItemState((WhichId), sal_True, ppItem ) == SFX_ITEM_SET)

//------------------------------------------------------------------

bool lcl_GetTextToColumnsRange( const ScViewData* pData, ScRange& rRange )
{
    DBG_ASSERT( pData, "lcl_GetTextToColumnsRange: pData is null!" );

    bool bRet = false;
    const ScMarkData& rMark = pData->GetMarkData();

    if ( rMark.IsMarked() )
    {
        if ( !rMark.IsMultiMarked() )
        {
            rMark.GetMarkArea( rRange );
            if ( rRange.aStart.Col() == rRange.aEnd.Col() )
            {
                bRet = true;
            }
        }
    }
    else
    {
        const SCCOL nCol = pData->GetCurX();
        const SCROW nRow = pData->GetCurY();
        const SCTAB nTab = pData->GetTabNo();
        rRange = ScRange( nCol, nRow, nTab, nCol, nRow, nTab );
        bRet = true;
    }

    const ScDocument* pDoc = pData->GetDocument();
    DBG_ASSERT( pDoc, "lcl_GetTextToColumnsRange: pDoc is null!" );

    if ( bRet && pDoc->IsBlockEmpty( rRange.aStart.Tab(), rRange.aStart.Col(),
                                     rRange.aStart.Row(), rRange.aEnd.Col(),
                                     rRange.aEnd.Row() ) )
    {
        bRet = false;
    }

    return bRet;
}

sal_Bool lcl_GetSortParam( const ScViewData* pData, ScSortParam& rSortParam )
{
    ScTabViewShell* pTabViewShell   = pData->GetViewShell();
    ScDBData*	pDBData             = pTabViewShell->GetDBData();
    ScDocument* pDoc                = pData->GetDocument();
    SCTAB nTab                      = pData->GetTabNo();
    ScDirection eFillDir            = DIR_TOP;
    sal_Bool  bSort                     = sal_True;
    ScRange aExternalRange;

    if( rSortParam.nCol1 != rSortParam.nCol2 )
        eFillDir = DIR_LEFT;
    if( rSortParam.nRow1 != rSortParam.nRow2 )
        eFillDir = DIR_TOP;

    SCSIZE nCount = pDoc->GetEmptyLinesInBlock( rSortParam.nCol1, rSortParam.nRow1, nTab, rSortParam.nCol2, rSortParam.nRow2, nTab, eFillDir );

    if( rSortParam.nRow2 == MAXROW )
        aExternalRange = ScRange( rSortParam.nCol1,sal::static_int_cast<SCROW>( nCount ), nTab );
    else
        aExternalRange = ScRange( pData->GetCurX(), pData->GetCurY(), nTab );

    SCROW nStartRow = aExternalRange.aStart.Row();
    SCCOL nStartCol = aExternalRange.aStart.Col();
    SCROW nEndRow   = aExternalRange.aEnd.Row();
    SCCOL nEndCol   = aExternalRange.aEnd.Col();
    pDoc->GetDataArea( aExternalRange.aStart.Tab(), nStartCol, nStartRow, nEndCol, nEndRow, sal_False, false );
    aExternalRange.aStart.SetRow( nStartRow );
    aExternalRange.aStart.SetCol( nStartCol );
    aExternalRange.aEnd.SetRow( nEndRow );
    aExternalRange.aEnd.SetCol( nEndCol );

    if(( rSortParam.nCol1 == rSortParam.nCol2 && aExternalRange.aStart.Col() != aExternalRange.aEnd.Col() ) ||
        ( rSortParam.nRow1 == rSortParam.nRow2 && aExternalRange.aStart.Row() != aExternalRange.aEnd.Row() ) )
    {
        sal_uInt16 nFmt = SCA_VALID;
        String aExtendStr,aCurrentStr;

        pTabViewShell->AddHighlightRange( aExternalRange,Color( COL_LIGHTBLUE ) );
        ScRange rExtendRange( aExternalRange.aStart.Col(), aExternalRange.aStart.Row(), nTab, aExternalRange.aEnd.Col(), aExternalRange.aEnd.Row(), nTab );
        rExtendRange.Format( aExtendStr, nFmt, pDoc );

        ScRange rCurrentRange( rSortParam.nCol1, rSortParam.nRow1, nTab, rSortParam.nCol2, rSortParam.nRow2, nTab );
        rCurrentRange.Format( aCurrentStr, nFmt, pDoc );

        ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
        DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

        VclAbstractDialog* pWarningDlg = pFact->CreateScSortWarningDlg( pTabViewShell->GetDialogParent(),aExtendStr,aCurrentStr,RID_SCDLG_SORT_WARNING );
        DBG_ASSERT(pWarningDlg, "Dialog create fail!");//CHINA001
        short bResult = pWarningDlg->Execute();
        if( bResult == BTN_EXTEND_RANGE || bResult == BTN_CURRENT_SELECTION )
        {
            if( bResult == BTN_EXTEND_RANGE )
            {
                pTabViewShell->MarkRange( aExternalRange, sal_False );
                pDBData->SetArea( nTab, aExternalRange.aStart.Col(), aExternalRange.aStart.Row(), aExternalRange.aEnd.Col(), aExternalRange.aEnd.Row() );
            }
        }
        else
        {
            bSort = sal_False;
            pData->GetDocShell()->CancelAutoDBRange();
        }

        delete pWarningDlg;
        pTabViewShell->ClearHighlightRanges();
    }
    return bSort;
}

//<!-- Added by PengYunQuan for Validity Cell Range Picker
//after end execute from !IsModalInputMode, it is safer to delay deleting
namespace
{
	long DelayDeleteAbstractDialog( void *pAbstractDialog, void * /*pArg*/ )
	{
		delete reinterpret_cast<VclAbstractDialog*>( pAbstractDialog );
		return 0;
	}
}
//--> Added by PengYunQuan for Validity Cell Range Picker

void ScCellShell::ExecuteDB( SfxRequest& rReq )
{
	ScTabViewShell*	pTabViewShell  	= GetViewData()->GetViewShell();
	sal_uInt16 nSlotId = rReq.GetSlot();
	const SfxItemSet*	pReqArgs	= rReq.GetArgs();
	ScModule*			pScMod		= SC_MOD();

	pTabViewShell->HideListBox();					// Autofilter-DropDown-Listbox

	if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
	{
		pScMod->InputEnterHandler();
		pTabViewShell->UpdateInputHandler();
	}

	switch ( nSlotId )
	{
		case SID_VIEW_DATA_SOURCE_BROWSER:
			{
				//	check if database beamer is open

				SfxViewFrame* pViewFrame = pTabViewShell->GetViewFrame();
				sal_Bool bWasOpen = sal_False;
				{
					uno::Reference<frame::XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface();
					uno::Reference<frame::XFrame> xBeamerFrame = xFrame->findFrame(
														rtl::OUString::createFromAscii("_beamer"),
														frame::FrameSearchFlag::CHILDREN);
					if ( xBeamerFrame.is() )
						bWasOpen = sal_True;
				}

				if ( bWasOpen )
				{
					//	close database beamer: just forward to SfxViewFrame

					pViewFrame->ExecuteSlot( rReq );
				}
				else
				{
					//	show database beamer: SfxViewFrame call must be synchronous

					pViewFrame->ExecuteSlot( rReq, (sal_Bool) sal_False );		// sal_False = synchronous

					//	select current database in database beamer

					ScImportParam aImportParam;
					ScDBData* pDBData = pTabViewShell->GetDBData(sal_True,SC_DB_OLD);		// don't create if none found
					if (pDBData)
						pDBData->GetImportParam( aImportParam );

					ScDBDocFunc::ShowInBeamer( aImportParam, pTabViewShell->GetViewFrame() );
				}
				rReq.Done();		// needed because it's a toggle slot
			}
			break;

		case SID_REIMPORT_DATA:
			{
				sal_Bool bOk = sal_False;
				ScDBData* pDBData = pTabViewShell->GetDBData(sal_True,SC_DB_OLD);
				if (pDBData)
				{
					ScImportParam aImportParam;
					pDBData->GetImportParam( aImportParam );
					if (aImportParam.bImport && !pDBData->HasImportSelection())
					{
						pTabViewShell->ImportData( aImportParam );
						pDBData->SetImportParam( aImportParam );	//! Undo ??
						bOk = sal_True;
					}
				}

				if (!bOk && ! rReq.IsAPI() )
					pTabViewShell->ErrorMessage(STR_REIMPORT_EMPTY);

				if( bOk )
					rReq.Done();
			}
			break;

		case SID_REFRESH_DBAREA:
			{
				ScDBData* pDBData = pTabViewShell->GetDBData(sal_True,SC_DB_OLD);
				if (pDBData)
				{
					//	Import wiederholen wie SID_REIMPORT_DATA

					sal_Bool bContinue = sal_True;
					ScImportParam aImportParam;
					pDBData->GetImportParam( aImportParam );
					if (aImportParam.bImport && !pDBData->HasImportSelection())
					{
						bContinue = pTabViewShell->ImportData( aImportParam );
						pDBData->SetImportParam( aImportParam );	//! Undo ??

						//	markieren (Groesse kann sich geaendert haben)
						ScRange aNewRange;
						pDBData->GetArea(aNewRange);
						pTabViewShell->MarkRange(aNewRange);
					}

					if ( bContinue )		// #41905# Fehler beim Import -> Abbruch
					{
						//	interne Operationen, wenn welche gespeichert

						if ( pDBData->HasQueryParam() || pDBData->HasSortParam() ||
														  pDBData->HasSubTotalParam() )
							pTabViewShell->RepeatDB();

						//	Pivottabellen die den Bereich als Quelldaten haben

						ScRange aRange;
						pDBData->GetArea(aRange);
						GetViewData()->GetDocShell()->RefreshPivotTables(aRange);
					}
				}
				rReq.Done();
			}
			break;

		case SID_SBA_BRW_INSERT:
			{
				DBG_ERROR( "Deprecated Slot" );
			}
			break;

		case SID_SUBTOTALS:
			{
				const SfxItemSet* pArgs = rReq.GetArgs();
				if ( pArgs )
				{
					pTabViewShell->DoSubTotals( ((const ScSubTotalItem&) pArgs->Get( SCITEM_SUBTDATA )).
									GetSubTotalData() );
					rReq.Done();
				}
				else
				{
					//CHINA001 ScSubTotalDlg*	pDlg = NULL;
					SfxAbstractTabDialog * pDlg = NULL;
					ScSubTotalParam aSubTotalParam;
					SfxItemSet		aArgSet( GetPool(), SCITEM_SUBTDATA, SCITEM_SUBTDATA );

                    ScDBData* pDBData = pTabViewShell->GetDBData();
					pDBData->GetSubTotalParam( aSubTotalParam );
					aSubTotalParam.bRemoveOnly = sal_False;

					aArgSet.Put( ScSubTotalItem( SCITEM_SUBTDATA, GetViewData(), &aSubTotalParam ) );
					//CHINA001 pDlg = new ScSubTotalDlg( pTabViewShell->GetDialogParent(), &aArgSet );
					ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
					DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

					pDlg = pFact->CreateScSubTotalDlg( pTabViewShell->GetDialogParent(), &aArgSet, RID_SCDLG_SUBTOTALS );
					DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001
					pDlg->SetCurPageId(1);

					short bResult = pDlg->Execute();

					if ( (bResult == RET_OK) || (bResult == SCRET_REMOVE) )
					{
						const SfxItemSet* pOutSet = NULL;

						if ( bResult == RET_OK )
						{
							pOutSet = pDlg->GetOutputItemSet();
							aSubTotalParam =
								((const ScSubTotalItem&)
									pOutSet->Get( SCITEM_SUBTDATA )).
										GetSubTotalData();
						}
						else // if (bResult == SCRET_REMOVE)
						{
							pOutSet = &aArgSet;
							aSubTotalParam.bRemoveOnly = sal_True;
							aSubTotalParam.bReplace    = sal_True;
							aArgSet.Put( ScSubTotalItem( SCITEM_SUBTDATA,
														 GetViewData(),
														 &aSubTotalParam ) );
						}

						pTabViewShell->DoSubTotals( aSubTotalParam );
						rReq.Done( *pOutSet );
					}
                    else
                        GetViewData()->GetDocShell()->CancelAutoDBRange();

					delete pDlg;
				}
			}
			break;

        case SID_SORT_DESCENDING:
        case SID_SORT_ASCENDING:
            {
                //#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
                //the patch comes from maoyg
                ScSortParam aSortParam;
                ScDBData*	pDBData = pTabViewShell->GetDBData();
                ScViewData* pData   = GetViewData();

                pDBData->GetSortParam( aSortParam );

                if( lcl_GetSortParam( pData, aSortParam ) )
                {
                    SfxItemSet  aArgSet( GetPool(), SCITEM_SORTDATA, SCITEM_SORTDATA );
                    SCCOL nCol  = GetViewData()->GetCurX();
                    SCCOL nTab  = GetViewData()->GetTabNo();
                    ScDocument* pDoc    = GetViewData()->GetDocument();

                    pDBData->GetSortParam( aSortParam );
                    sal_Bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, nTab );

                    if( nCol < aSortParam.nCol1 )
                        nCol = aSortParam.nCol1;
                    else if( nCol > aSortParam.nCol2 )
                        nCol = aSortParam.nCol2;

                    aSortParam.bHasHeader		= bHasHeader;
                    aSortParam.bByRow			= sal_True;
                    aSortParam.bCaseSens		= sal_False;
                    aSortParam.bIncludePattern	= sal_True;
                    aSortParam.bInplace 		= sal_True;
                    aSortParam.bDoSort[0]		= sal_True;
                    aSortParam.nField[0]		= nCol;
                    aSortParam.bAscending[0]	= (nSlotId == SID_SORT_ASCENDING);

                    for ( sal_uInt16 i=1; i<MAXSORT; i++ )
                        aSortParam.bDoSort[i] = sal_False;

                    aArgSet.Put( ScSortItem( SCITEM_SORTDATA, GetViewData(), &aSortParam ) );

                    pTabViewShell->UISort( aSortParam );		// Teilergebnisse bei Bedarf neu

                    rReq.Done();
                }
            }
            break;

        case SID_SORT:
            {
                const SfxItemSet* pArgs = rReq.GetArgs();

                //#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
                //the patch comes from maoyg

                if ( pArgs )		// Basic
                {
                    ScSortParam aSortParam;
                    ScDBData*	pDBData = pTabViewShell->GetDBData();
                    ScViewData* pData   = GetViewData();

                    pDBData->GetSortParam( aSortParam );

                    if( lcl_GetSortParam( pData, aSortParam ) )
                    {
                        ScDocument* pDoc = GetViewData()->GetDocument();

                        pDBData->GetSortParam( aSortParam );
                        sal_Bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, pData->GetTabNo() );
                        if( bHasHeader )
                            aSortParam.bHasHeader = bHasHeader;

                        aSortParam.bInplace = sal_True;				// von Basic immer

                        const SfxPoolItem* pItem;
                        if ( pArgs->GetItemState( SID_SORT_BYROW, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bByRow = ((const SfxBoolItem*)pItem)->GetValue();
                        if ( pArgs->GetItemState( SID_SORT_HASHEADER, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bHasHeader = ((const SfxBoolItem*)pItem)->GetValue();
                        if ( pArgs->GetItemState( SID_SORT_CASESENS, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bCaseSens = ((const SfxBoolItem*)pItem)->GetValue();
                        if ( pArgs->GetItemState( SID_SORT_ATTRIBS, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bIncludePattern = ((const SfxBoolItem*)pItem)->GetValue();
                        if ( pArgs->GetItemState( SID_SORT_USERDEF, sal_True, &pItem ) == SFX_ITEM_SET )
                        {
                            sal_uInt16 nUserIndex = ((const SfxUInt16Item*)pItem)->GetValue();
                            aSortParam.bUserDef = ( nUserIndex != 0 );
                            if ( nUserIndex )
                                aSortParam.nUserIndex = nUserIndex - 1;		// Basic: 1-basiert
                        }

                        SCCOLROW nField0 = 0;
                        if ( pArgs->GetItemState( FN_PARAM_1, sal_True, &pItem ) == SFX_ITEM_SET )
                            nField0 = ((const SfxInt32Item*)pItem)->GetValue();
                        aSortParam.bDoSort[0] = ( nField0 != 0 );
                        aSortParam.nField[0] = nField0 > 0 ? (nField0-1) : 0;
                        if ( pArgs->GetItemState( FN_PARAM_2, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bAscending[0] = ((const SfxBoolItem*)pItem)->GetValue();
                        SCCOLROW nField1 = 0;
                        if ( pArgs->GetItemState( FN_PARAM_3, sal_True, &pItem ) == SFX_ITEM_SET )
                            nField1 = ((const SfxInt32Item*)pItem)->GetValue();
                        aSortParam.bDoSort[1] = ( nField1 != 0 );
                        aSortParam.nField[1] = nField1 > 0 ? (nField1-1) : 0;
                        if ( pArgs->GetItemState( FN_PARAM_4, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bAscending[1] = ((const SfxBoolItem*)pItem)->GetValue();
                        SCCOLROW nField2 = 0;
                        if ( pArgs->GetItemState( FN_PARAM_5, sal_True, &pItem ) == SFX_ITEM_SET )
                            nField2 = ((const SfxInt32Item*)pItem)->GetValue();
                        aSortParam.bDoSort[2] = ( nField2 != 0 );
                        aSortParam.nField[2] = nField2 > 0 ? (nField2-1) : 0;
                        if ( pArgs->GetItemState( FN_PARAM_6, sal_True, &pItem ) == SFX_ITEM_SET )
                            aSortParam.bAscending[2] = ((const SfxBoolItem*)pItem)->GetValue();

                        // Teilergebnisse bei Bedarf neu
                        pTabViewShell->UISort( aSortParam );
                        rReq.Done();
                    }
                }
                else
                {
                    ScSortParam aSortParam;
                    ScDBData*	pDBData = pTabViewShell->GetDBData();
                    ScViewData* pData   = GetViewData();

                    pDBData->GetSortParam( aSortParam );

                    if( lcl_GetSortParam( pData, aSortParam ) )
                    {
                        SfxAbstractTabDialog* pDlg = NULL;
                        ScDocument* pDoc = GetViewData()->GetDocument();
                        SfxItemSet	aArgSet( GetPool(), SCITEM_SORTDATA, SCITEM_SORTDATA );

                        pDBData->GetSortParam( aSortParam );
                        sal_Bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, pData->GetTabNo() );
                        if( bHasHeader )
                            aSortParam.bHasHeader = bHasHeader;

                        aArgSet.Put( ScSortItem( SCITEM_SORTDATA, GetViewData(), &aSortParam ) );

                        ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
                        DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

                        pDlg = pFact->CreateScSortDlg( pTabViewShell->GetDialogParent(),  &aArgSet, RID_SCDLG_SORT );
                        DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001
                        pDlg->SetCurPageId(1);

                        if ( pDlg->Execute() == RET_OK )
                        {
                            const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
                            const ScSortParam& rOutParam = ((const ScSortItem&)
                                pOutSet->Get( SCITEM_SORTDATA )).GetSortData();

                            // Teilergebnisse bei Bedarf neu
                            pTabViewShell->UISort( rOutParam );

                            if ( rOutParam.bInplace )
                            {
                                rReq.AppendItem( SfxBoolItem( SID_SORT_BYROW,
                                    rOutParam.bByRow ) );
                                rReq.AppendItem( SfxBoolItem( SID_SORT_HASHEADER,
                                    rOutParam.bHasHeader ) );
                                rReq.AppendItem( SfxBoolItem( SID_SORT_CASESENS,
                                    rOutParam.bCaseSens ) );
                                rReq.AppendItem( SfxBoolItem( SID_SORT_ATTRIBS,
                                    rOutParam.bIncludePattern ) );
                                sal_uInt16 nUser = rOutParam.bUserDef ? ( rOutParam.nUserIndex + 1 ) : 0;
                                rReq.AppendItem( SfxUInt16Item( SID_SORT_USERDEF, nUser ) );
                                if ( rOutParam.bDoSort[0] )
                                {
                                    rReq.AppendItem( SfxInt32Item( FN_PARAM_1,
                                        rOutParam.nField[0] + 1 ) );
                                    rReq.AppendItem( SfxBoolItem( FN_PARAM_2,
                                        rOutParam.bAscending[0] ) );
                                }
                                if ( rOutParam.bDoSort[1] )
                                {
                                    rReq.AppendItem( SfxInt32Item( FN_PARAM_3,
                                        rOutParam.nField[1] + 1 ) );
                                    rReq.AppendItem( SfxBoolItem( FN_PARAM_4,
                                        rOutParam.bAscending[1] ) );
                                }
                                if ( rOutParam.bDoSort[2] )
                                {
                                    rReq.AppendItem( SfxInt32Item( FN_PARAM_5,
                                        rOutParam.nField[2] + 1 ) );
                                    rReq.AppendItem( SfxBoolItem( FN_PARAM_6,
                                        rOutParam.bAscending[2] ) );
                                }
                            }

                            rReq.Done();
                        }
                        else
                            GetViewData()->GetDocShell()->CancelAutoDBRange();

                        delete pDlg;
                    }
                }
            }
            break;

		case SID_FILTER:
			{
				const SfxItemSet* pArgs = rReq.GetArgs();
				if ( pArgs )
				{
					DBG_ERROR("SID_FILTER with arguments?");
					pTabViewShell->Query( ((const ScQueryItem&)
							pArgs->Get( SCITEM_QUERYDATA )).GetQueryData(), NULL, sal_True );
					rReq.Done();
				}
				else
				{
					sal_uInt16			nId  = ScFilterDlgWrapper::GetChildWindowId();
					SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
					SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );

					pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True );
				}
			}
			break;

		case SID_SPECIAL_FILTER:
			{
				const SfxItemSet* pArgs = rReq.GetArgs();
				if ( pArgs )
				{
					DBG_ERROR("SID_SPECIAL_FILTER with arguments?");
					pTabViewShell->Query( ((const ScQueryItem&)
							pArgs->Get( SCITEM_QUERYDATA )).GetQueryData(), NULL, sal_True );
					rReq.Done();
				}
				else
				{
					sal_uInt16			nId  = ScSpecialFilterDlgWrapper::GetChildWindowId();
					SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
					SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );

					pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True );
				}
			}
			break;

		case FID_FILTER_OK:
			{
                const SfxPoolItem* pItem;
                if ( pReqArgs && SFX_ITEM_SET ==
                        pReqArgs->GetItemState( SCITEM_QUERYDATA, sal_True, &pItem ) )
                {
                    const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(*pItem);

                    SCTAB nCurTab = GetViewData()->GetTabNo();
                    SCTAB nRefTab = GetViewData()->GetRefTabNo();

                    // If RefInput switched to a different sheet from the data sheet,
                    // switch back:

                    if ( nCurTab != nRefTab )
                    {
                        pTabViewShell->SetTabNo( nRefTab );
                        pTabViewShell->PaintExtras();
                    }

                    ScRange aAdvSource;
                    if (rQueryItem.GetAdvancedQuerySource(aAdvSource))
                        pTabViewShell->Query( rQueryItem.GetQueryData(), &aAdvSource, sal_True );
                    else
                        pTabViewShell->Query( rQueryItem.GetQueryData(), NULL, sal_True );
                    rReq.Done( *pReqArgs );
                }
			}
			break;

		case SID_UNFILTER:
			{
				ScQueryParam aParam;
				ScDBData*	 pDBData = pTabViewShell->GetDBData();

				pDBData->GetQueryParam( aParam );
				SCSIZE nEC = aParam.GetEntryCount();
				for (SCSIZE i=0; i<nEC; i++)
					aParam.GetEntry(i).bDoQuery = sal_False;
				aParam.bDuplicate = sal_True;
				pTabViewShell->Query( aParam, NULL, sal_True );
				rReq.Done();
			}
			break;

		case SID_AUTO_FILTER:
			pTabViewShell->ToggleAutoFilter();
			rReq.Done();
			break;

		case SID_AUTOFILTER_HIDE:
			pTabViewShell->HideAutoFilter();
			rReq.Done();
			break;

		case SID_PIVOT_TABLE:
			{
				const SfxPoolItem* pItem;
				if ( pReqArgs && SFX_ITEM_SET ==
						pReqArgs->GetItemState( SCITEM_PIVOTDATA, sal_True, &pItem ) )
				{
					SCTAB nCurTab = GetViewData()->GetTabNo();
					SCTAB nRefTab = GetViewData()->GetRefTabNo();

					// Wenn RefInput auf andere Tabelle als Datentabelle umgeschaltet
					// hat wieder zurueckschalten:

					if ( nCurTab != nRefTab )
					{
						pTabViewShell->SetTabNo( nRefTab );
						pTabViewShell->PaintExtras();
					}

					const ScDPObject* pDPObject = pTabViewShell->GetDialogDPObject();
					if ( pDPObject )
					{
						const ScPivotItem* pPItem = (const ScPivotItem*)pItem;
                        bool bSuccess = pTabViewShell->MakePivotTable(
                            pPItem->GetData(), pPItem->GetDestRange(), pPItem->IsNewSheet(), *pDPObject );
                        SfxBoolItem aRet(0, bSuccess);
                        rReq.SetReturnValue(aRet);
					}
					rReq.Done();
				}
				else if (rReq.IsAPI())
					SbxBase::SetError(SbxERR_BAD_PARAMETER);
			}
			break;

		case SID_OPENDLG_PIVOTTABLE:
			{
				ScViewData* pData = GetViewData();
				ScDocument* pDoc = pData->GetDocument();

				ScDPObject* pNewDPObject = NULL;

				// ScPivot is no longer used...
				ScDPObject* pDPObj = pDoc->GetDPAtCursor(
											pData->GetCurX(), pData->GetCurY(),
											pData->GetTabNo() );
				if ( pDPObj )	// on an existing table?
				{
					pNewDPObject = new ScDPObject( *pDPObj );
				}
				else	 		// create new table
				{
					//	select database range or data
					pTabViewShell->GetDBData( sal_True, SC_DB_OLD );
                    ScMarkData& rMark = GetViewData()->GetMarkData();
					if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
						pTabViewShell->MarkDataArea( sal_False );

					//	output to cursor position for non-sheet data
					ScAddress aDestPos( pData->GetCurX(), pData->GetCurY(),
											pData->GetTabNo() );

					//	first select type of source data

					sal_Bool bEnableExt = ScDPObject::HasRegisteredSources();
					//CHINA001 ScDataPilotSourceTypeDlg* pTypeDlg = new ScDataPilotSourceTypeDlg(
					//CHINA001 							pTabViewShell->GetDialogParent(), bEnableExt );

					ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
					DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

					AbstractScDataPilotSourceTypeDlg* pTypeDlg = pFact->CreateScDataPilotSourceTypeDlg( pTabViewShell->GetDialogParent(), bEnableExt, RID_SCDLG_DAPITYPE );
					DBG_ASSERT(pTypeDlg, "Dialog create fail!");//CHINA001
					if ( pTypeDlg->Execute() == RET_OK )
					{
						if ( pTypeDlg->IsExternal() )
						{
							uno::Sequence<rtl::OUString> aSources = ScDPObject::GetRegisteredSources();
							//CHINA001 ScDataPilotServiceDlg* pServDlg = new ScDataPilotServiceDlg(
							//CHINA001 					pTabViewShell->GetDialogParent(), aSources );
							AbstractScDataPilotServiceDlg* pServDlg = pFact->CreateScDataPilotServiceDlg( pTabViewShell->GetDialogParent(), aSources, RID_SCDLG_DAPISERVICE );
							DBG_ASSERT(pServDlg, "Dialog create fail!");//CHINA001
							if ( pServDlg->Execute() == RET_OK )
							{
								ScDPServiceDesc aServDesc(
										pServDlg->GetServiceName(),
										pServDlg->GetParSource(),
										pServDlg->GetParName(),
										pServDlg->GetParUser(),
										pServDlg->GetParPass() );
								pNewDPObject = new ScDPObject( pDoc );
								pNewDPObject->SetServiceData( aServDesc );
							}
							delete pServDlg;
						}
						else if ( pTypeDlg->IsDatabase() )
						{
							//CHINA001 ScDataPilotDatabaseDlg* pDataDlg = new ScDataPilotDatabaseDlg(
							//CHINA001 								pTabViewShell->GetDialogParent() );
                            //ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
							DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

							AbstractScDataPilotDatabaseDlg* pDataDlg = pFact->CreateScDataPilotDatabaseDlg( pTabViewShell->GetDialogParent(), RID_SCDLG_DAPIDATA);
							DBG_ASSERT(pDataDlg, "Dialog create fail!");//CHINA001
							if ( pDataDlg->Execute() == RET_OK )
							{
								ScImportSourceDesc aImpDesc;
								pDataDlg->GetValues( aImpDesc );
								pNewDPObject = new ScDPObject( pDoc );
								pNewDPObject->SetImportDesc( aImpDesc );
							}
							delete pDataDlg;
						}
						else		// selection
						{
							//!	use database ranges (select before type dialog?)
							ScRange aRange;
                            ScMarkType eType = GetViewData()->GetSimpleArea(aRange);
                            if ( (eType & SC_MARK_SIMPLE) == SC_MARK_SIMPLE )
							{
                                // Shrink the range to the data area.
                                SCCOL nStartCol = aRange.aStart.Col(), nEndCol = aRange.aEnd.Col();
                                SCROW nStartRow = aRange.aStart.Row(), nEndRow = aRange.aEnd.Row();
                                if (pDoc->ShrinkToDataArea(aRange.aStart.Tab(), nStartCol, nStartRow, nEndCol, nEndRow))
                                {
                                    aRange.aStart.SetCol(nStartCol);
                                    aRange.aStart.SetRow(nStartRow);
                                    aRange.aEnd.SetCol(nEndCol);
                                    aRange.aEnd.SetRow(nEndRow);
                                    rMark.SetMarkArea(aRange);
                                    pTabViewShell->MarkRange(aRange);
                                }

								sal_Bool bOK = sal_True;
								if ( pDoc->HasSubTotalCells( aRange ) )
								{
									//	confirm selection if it contains SubTotal cells

									QueryBox aBox( pTabViewShell->GetDialogParent(),
													WinBits(WB_YES_NO | WB_DEF_YES),
													ScGlobal::GetRscString(STR_DATAPILOT_SUBTOTAL) );
									if (aBox.Execute() == RET_NO)
										bOK = sal_False;
								}
								if (bOK)
								{
									ScSheetSourceDesc aShtDesc;
									aShtDesc.aSourceRange = aRange;
									pNewDPObject = new ScDPObject( pDoc );
									pNewDPObject->SetSheetDesc( aShtDesc );

									//	output below source data
									if ( aRange.aEnd.Row()+2 <= MAXROW - 4 )
										aDestPos = ScAddress( aRange.aStart.Col(),
																aRange.aEnd.Row()+2,
																aRange.aStart.Tab() );
								}
							}
						}
					}
					delete pTypeDlg;

					if ( pNewDPObject )
						pNewDPObject->SetOutRange( aDestPos );

#if 0
					ScDBData*	pDBData = pTabViewShell->GetDBData();
					String		aErrMsg;

					pDBData->GetArea( nTab, nCol1, nRow1, nCol2, nRow2 );

					bAreaOk = sal_True;
					if ( nRow2-nRow1 < 1 )
					{
						// "mindestens eine Datenzeile"
						pTabViewShell->ErrorMessage(STR_PIVOT_INVALID_DBAREA);
						bAreaOk = sal_False;
					}
					else if (!pDBData->HasHeader())
					{
						if ( MessBox( pTabViewShell->GetDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES),
								ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ),		// "StarCalc"
								ScGlobal::GetRscString( STR_MSSG_MAKEAUTOFILTER_0 ) 	// Koepfe aus erster Zeile?
							).Execute() == RET_YES )
						{
							pDBData->SetHeader( sal_True ); 	//! Undo ??
						}
						else
							bAreaOk = sal_False;
					}
#endif
				}

				pTabViewShell->SetDialogDPObject( pNewDPObject );	// is copied
				if ( pNewDPObject )
				{
					//	start layout dialog

					sal_uInt16 nId  = ScPivotLayoutWrapper::GetChildWindowId();
					SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
					SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
					pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True );
				}
				delete pNewDPObject;
			}
			break;

		case SID_DEFINE_DBNAME:
			{

				sal_uInt16			nId  = ScDbNameDlgWrapper::GetChildWindowId();
				SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
				SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );

				pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True );

			}
			break;

		case SID_SELECT_DB:
			{
				if ( pReqArgs )
				{
					const SfxStringItem* pItem =
						(const SfxStringItem*)&pReqArgs->Get( SID_SELECT_DB );

					if( pItem )
					{
						pTabViewShell->GotoDBArea( pItem->GetValue() );
						rReq.Done();
					}
					else
					{
						DBG_ERROR("NULL");
					}
				}
				else
				{
					ScDocument* 	pDoc   = GetViewData()->GetDocument();
					ScDBCollection* pDBCol = pDoc->GetDBCollection();

					if ( pDBCol )
					{
						List			aList;
						sal_uInt16			nDBCount = pDBCol->GetCount();
						ScDBData*		pDbData  = NULL;
						String*			pDBName  = NULL;

						for ( sal_uInt16 i=0; i < nDBCount; i++ )
						{
							pDbData = (ScDBData*)(pDBCol->At( i ));
							if ( pDbData )
							{
								pDBName = new String;
								pDbData->GetName( *pDBName );

								if ( !pDbData->IsInternalUnnamed() )
									aList.Insert( pDBName );
								else
									DELETEZ(pDBName);
							}
						}

						ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
						DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

						AbstractScSelEntryDlg* pDlg = pFact->CreateScSelEntryDlg( pTabViewShell->GetDialogParent(),
																				RID_SCDLG_SELECTDB,
																				String(ScResId(SCSTR_SELECTDB)),
																				String(ScResId(SCSTR_AREAS)),
																				aList,
																				RID_SCDLG_SELECTDB);
						DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001
						if ( pDlg->Execute() == RET_OK )
						{
							String aName = pDlg->GetSelectEntry();
							pTabViewShell->GotoDBArea( aName );
							rReq.AppendItem( SfxStringItem( SID_SELECT_DB, aName ) );
							rReq.Done();
						}

						delete pDlg;

						void* pEntry = aList.First();
						while ( pEntry )
						{
							delete (String*) aList.Remove( pEntry );
							pEntry = aList.Next();
						}
					}
				}
			}
			break;

		case FID_VALIDATION:
			{
				const SfxPoolItem* pItem;
				const SfxItemSet* pArgs = rReq.GetArgs();
				if ( pArgs )
				{
					DBG_ERROR("spaeter...");
				}
				else
				{
                    //CHINA001 SfxItemSet aArgSet( GetPool(), ScTPValidationValue::GetRanges() );
					ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
					DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001
					::GetTabPageRanges ScTPValidationValueGetRanges = pFact->GetTabPageRangesFunc(TP_VALIDATION_VALUES);
					DBG_ASSERT(ScTPValidationValueGetRanges, "TabPage create fail!");//CHINA001
					SfxItemSet aArgSet( GetPool(), (*ScTPValidationValueGetRanges)() );//CHINA001
					ScValidationMode eMode = SC_VALID_ANY;
					ScConditionMode eOper = SC_COND_EQUAL;
					String aExpr1, aExpr2;
					sal_Bool bBlank = sal_True;
                    sal_Int16 nListType = ValidListType::UNSORTED;
					sal_Bool bShowHelp = sal_False;
					String aHelpTitle, aHelpText;
					sal_Bool bShowError = sal_False;
					ScValidErrorStyle eErrStyle = SC_VALERR_STOP;
					String aErrTitle, aErrText;

					ScDocument* pDoc = GetViewData()->GetDocument();
					SCCOL nCurX = GetViewData()->GetCurX();
					SCROW nCurY = GetViewData()->GetCurY();
					SCTAB nTab = GetViewData()->GetTabNo();
					ScAddress aCursorPos( nCurX, nCurY, nTab );
					sal_uLong nIndex = ((SfxUInt32Item*)pDoc->GetAttr(
								nCurX, nCurY, nTab, ATTR_VALIDDATA ))->GetValue();
					if ( nIndex )
					{
						const ScValidationData*	pOldData = pDoc->GetValidationEntry( nIndex );
						if ( pOldData )
						{
							eMode = pOldData->GetDataMode();
							eOper = pOldData->GetOperation();
							sal_uLong nNumFmt = 0;
							if ( eMode == SC_VALID_DATE || eMode == SC_VALID_TIME )
							{
								short nType = ( eMode == SC_VALID_DATE ) ? NUMBERFORMAT_DATE
																		 : NUMBERFORMAT_TIME;
								nNumFmt = pDoc->GetFormatTable()->GetStandardFormat(
																	nType, ScGlobal::eLnge );
							}
							aExpr1 = pOldData->GetExpression( aCursorPos, 0, nNumFmt );
							aExpr2 = pOldData->GetExpression( aCursorPos, 1, nNumFmt );
							bBlank = pOldData->IsIgnoreBlank();
                            nListType = pOldData->GetListType();

							bShowHelp = pOldData->GetInput( aHelpTitle, aHelpText );
							bShowError = pOldData->GetErrMsg( aErrTitle, aErrText, eErrStyle );

                            aArgSet.Put( SfxAllEnumItem( FID_VALID_MODE,        sal::static_int_cast<sal_uInt16>(eMode) ) );
                            aArgSet.Put( SfxAllEnumItem( FID_VALID_CONDMODE,    sal::static_int_cast<sal_uInt16>(eOper) ) );
							aArgSet.Put( SfxStringItem(	 FID_VALID_VALUE1,		aExpr1 ) );
							aArgSet.Put( SfxStringItem(	 FID_VALID_VALUE2,		aExpr2 ) );
							aArgSet.Put( SfxBoolItem(	 FID_VALID_BLANK,		bBlank ) );
                            aArgSet.Put( SfxInt16Item(   FID_VALID_LISTTYPE,    nListType ) );
							aArgSet.Put( SfxBoolItem(	 FID_VALID_SHOWHELP,	bShowHelp ) );
							aArgSet.Put( SfxStringItem(	 FID_VALID_HELPTITLE,	aHelpTitle ) );
							aArgSet.Put( SfxStringItem(	 FID_VALID_HELPTEXT,	aHelpText ) );
							aArgSet.Put( SfxBoolItem(	 FID_VALID_SHOWERR,		bShowError ) );
                            aArgSet.Put( SfxAllEnumItem( FID_VALID_ERRSTYLE,    sal::static_int_cast<sal_uInt16>(eErrStyle) ) );
							aArgSet.Put( SfxStringItem(  FID_VALID_ERRTITLE,	aErrTitle ) );
							aArgSet.Put( SfxStringItem(  FID_VALID_ERRTEXT,		aErrText ) );
						}
					}

					//CHINA001 ScValidationDlg* pDlg = new ScValidationDlg( NULL, &aArgSet );
					//CHINA001 ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
					//CHINA001 DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001

					//<!--Modified by PengYunQuan for Validity Cell Range Picker
					//SfxAbstractTabDialog* pDlg = pFact->CreateScValidationDlg( NULL, &aArgSet, TAB_DLG_VALIDATION );
					SfxAbstractTabDialog* pDlg = pFact->CreateScValidationDlg( NULL, &aArgSet, TAB_DLG_VALIDATION, pTabViewShell );
					//-->Modified by PengYunQuan for Validity Cell Range Picker
					DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001

					//<!--Modified by PengYunQuan for Validity Cell Range Picker
					//if ( pDlg->Execute() == RET_OK )
					short nResult = pDlg->Execute();
					pTabViewShell->SetTabNo( nTab );//When picking Cell Range ,other Tab may be switched. Need restore the correct tab
					if ( nResult == RET_OK )
					//-->Modified by PengYunQuan for Validity Cell Range Picker
					{
						const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();

						if ( pOutSet->GetItemState( FID_VALID_MODE, sal_True, &pItem ) == SFX_ITEM_SET )
							eMode = (ScValidationMode) ((const SfxAllEnumItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_CONDMODE, sal_True, &pItem ) == SFX_ITEM_SET )
							eOper = (ScConditionMode) ((const SfxAllEnumItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_VALUE1, sal_True, &pItem ) == SFX_ITEM_SET )
                        {
                            String aTemp1 = ((const SfxStringItem*)pItem)->GetValue();
                            if (eMode == SC_VALID_DATE || eMode == SC_VALID_TIME)
                            {
                                sal_uInt32 nNumIndex = 0;
                                double nVal;
                                if (pDoc->GetFormatTable()->IsNumberFormat(aTemp1, nNumIndex, nVal))
                                    aExpr1 =String( ::rtl::math::doubleToUString( nVal,
                                            rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
                                            ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0), sal_True));
                                else
                                    aExpr1 = aTemp1;
                            }
                            else
                                aExpr1 = aTemp1;
                        }
						if ( pOutSet->GetItemState( FID_VALID_VALUE2, sal_True, &pItem ) == SFX_ITEM_SET )
                        {
                            String aTemp2 = ((const SfxStringItem*)pItem)->GetValue();
                            if (eMode == SC_VALID_DATE || eMode == SC_VALID_TIME)
                            {
                                sal_uInt32 nNumIndex = 0;
                                double nVal;
                                if (pDoc->GetFormatTable()->IsNumberFormat(aTemp2, nNumIndex, nVal))
                                    aExpr2 =String( ::rtl::math::doubleToUString( nVal,
                                            rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
                                            ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0), sal_True));
                                else
                                    aExpr2 = aTemp2;
                            }
                            else
                                aExpr2 = aTemp2;
                        }

						if ( pOutSet->GetItemState( FID_VALID_BLANK, sal_True, &pItem ) == SFX_ITEM_SET )
							bBlank = ((const SfxBoolItem*)pItem)->GetValue();
                        if ( pOutSet->GetItemState( FID_VALID_LISTTYPE, sal_True, &pItem ) == SFX_ITEM_SET )
                            nListType = ((const SfxInt16Item*)pItem)->GetValue();

						if ( pOutSet->GetItemState( FID_VALID_SHOWHELP, sal_True, &pItem ) == SFX_ITEM_SET )
							bShowHelp = ((const SfxBoolItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_HELPTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
							aHelpTitle = ((const SfxStringItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_HELPTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
							aHelpText = ((const SfxStringItem*)pItem)->GetValue();

						if ( pOutSet->GetItemState( FID_VALID_SHOWERR, sal_True, &pItem ) == SFX_ITEM_SET )
							bShowError = ((const SfxBoolItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_ERRSTYLE, sal_True, &pItem ) == SFX_ITEM_SET )
							eErrStyle = (ScValidErrorStyle) ((const SfxAllEnumItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_ERRTITLE, sal_True, &pItem ) == SFX_ITEM_SET )
							aErrTitle = ((const SfxStringItem*)pItem)->GetValue();
						if ( pOutSet->GetItemState( FID_VALID_ERRTEXT, sal_True, &pItem ) == SFX_ITEM_SET )
							aErrText = ((const SfxStringItem*)pItem)->GetValue();

						ScValidationData aData( eMode, eOper, aExpr1, aExpr2, pDoc, aCursorPos );
						aData.SetIgnoreBlank( bBlank );
                        aData.SetListType( nListType );

						aData.SetInput(aHelpTitle, aHelpText);		// sets bShowInput to TRUE
						if (!bShowHelp)
							aData.ResetInput();						// reset only bShowInput

						aData.SetError(aErrTitle, aErrText, eErrStyle);	// sets bShowError to TRUE
						if (!bShowError)
							aData.ResetError();						// reset only bShowError

						pTabViewShell->SetValidation( aData );
						rReq.Done( *pOutSet );
					}
					//<!-- Modified by PengYunQuan for Validity Cell Range Picker
					//after end execute from !IsModalInputMode, it is safer to delay deleting
					//delete pDlg;
					Application::PostUserEvent( Link( pDlg, &DelayDeleteAbstractDialog ) );
					//--> Modified by PengYunQuan for Validity Cell Range Picker
				}
			}
			break;

        case SID_TEXT_TO_COLUMNS:
            {
                ScViewData* pData = GetViewData();
                DBG_ASSERT( pData, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pData is null!" );
                ScRange aRange;

                if ( lcl_GetTextToColumnsRange( pData, aRange ) )
                {
                    ScDocument* pDoc = pData->GetDocument();
                    DBG_ASSERT( pDoc, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDoc is null!" );

                    ScImportExport aExport( pDoc, aRange );
                    aExport.SetExportTextOptions( ScExportTextOptions( ScExportTextOptions::None, 0, false ) );

                    // #i87703# text to columns fails with tab separator
                    aExport.SetDelimiter( static_cast< sal_Unicode >( 0 ) );

                    SvMemoryStream aStream;
                    aStream.SetStreamCharSet( RTL_TEXTENCODING_UNICODE );
                    ScImportExport::SetNoEndianSwap( aStream );
                    aExport.ExportStream( aStream, String(), FORMAT_STRING );

                    ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
                    DBG_ASSERT( pFact, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pFact is null!" );
                    AbstractScImportAsciiDlg *pDlg = pFact->CreateScImportAsciiDlg(
                        NULL, String(), &aStream, RID_SCDLG_ASCII );
                    DBG_ASSERT( pDlg, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDlg is null!" );
                    pDlg->SetTextToColumnsMode();

                    if ( pDlg->Execute() == RET_OK )
                    {
                        ScDocShell* pDocSh = pData->GetDocShell();
                        DBG_ASSERT( pDocSh, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDocSh is null!" );

                        String aUndo = ScGlobal::GetRscString( STR_UNDO_TEXTTOCOLUMNS );
                        pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );

                        ScImportExport aImport( pDoc, aRange.aStart );
                        ScAsciiOptions aOptions;
                        pDlg->GetOptions( aOptions );
                        aImport.SetExtOptions( aOptions );
                        aImport.SetApi( false );
                        aStream.Seek( 0 );
                        aImport.ImportStream( aStream, String(), FORMAT_STRING );

                        pDocSh->GetUndoManager()->LeaveListAction();
                    }
                    delete pDlg;
                }
            }
            break;
		}
}

void __EXPORT ScCellShell::GetDBState( SfxItemSet& rSet )
{
	ScTabViewShell*	pTabViewShell  	= GetViewData()->GetViewShell();
    ScViewData* pData       = GetViewData();
	ScDocShell*	pDocSh		= pData->GetDocShell();
	ScDocument* pDoc		= pDocSh->GetDocument();
	SCCOL		nPosX		= pData->GetCurX();
	SCROW		nPosY		= pData->GetCurY();
	SCTAB		nTab		= pData->GetTabNo();

    sal_Bool bAutoFilter = sal_False;
	sal_Bool bAutoFilterTested = sal_False;

	SfxWhichIter aIter(rSet);
	sal_uInt16 nWhich = aIter.FirstWhich();
	while (nWhich)
	{
		switch (nWhich)
		{
			case SID_REFRESH_DBAREA:
				{
					//	importierte Daten ohne Selektion
					//	oder Filter,Sortierung,Teilergebis (auch ohne Import)
					sal_Bool bOk = sal_False;
					ScDBData* pDBData = pTabViewShell->GetDBData(sal_False,SC_DB_OLD);
					if (pDBData && pDoc->GetChangeTrack() == NULL)
					{
						if ( pDBData->HasImportParam() )
							bOk = !pDBData->HasImportSelection();
						else
						{
							bOk = pDBData->HasQueryParam() ||
								  pDBData->HasSortParam() ||
								  pDBData->HasSubTotalParam();
						}
					}
					if (!bOk)
						rSet.DisableItem( nWhich );
				}
				break;

			case SID_FILTER:
			case SID_SPECIAL_FILTER:
				{
                    ScRange aDummy;
                    ScMarkType eMarkType = GetViewData()->GetSimpleArea( aDummy);
					if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED)
					{
						rSet.DisableItem( nWhich );
					}
				}
				break;


				//Bei Redlining und Multiselektion Disablen
			case SID_SORT_ASCENDING:
			case SID_SORT_DESCENDING:
			case SCITEM_SORTDATA:
			case SCITEM_SUBTDATA:
			case SID_OPENDLG_PIVOTTABLE:
				{
					//!	move ReadOnly check to idl flags

					if ( pDocSh->IsReadOnly() || pDoc->GetChangeTrack()!=NULL ||
							GetViewData()->IsMultiMarked() )
					{
						rSet.DisableItem( nWhich );
					}
				}
				break;

			case SID_REIMPORT_DATA:
				{
					//	nur importierte Daten ohne Selektion
					ScDBData* pDBData = pTabViewShell->GetDBData(sal_False,SC_DB_OLD);
					if (!pDBData || !pDBData->HasImportParam() || pDBData->HasImportSelection() ||
						pDoc->GetChangeTrack()!=NULL)
					{
						rSet.DisableItem( nWhich );
					}
				}
				break;

			case SID_VIEW_DATA_SOURCE_BROWSER:
				{
                    if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SDATABASE))
                        rSet.Put(SfxVisibilityItem(nWhich, sal_False));
                    else
					    //	get state (BoolItem) from SfxViewFrame
					    pTabViewShell->GetViewFrame()->GetSlotState( nWhich, NULL, &rSet );
				}
				break;
			case SID_SBA_BRW_INSERT:
				{
					//	SBA will ein sal_Bool-Item, damit ueberhaupt enabled

					sal_Bool bEnable = sal_True;
					rSet.Put(SfxBoolItem(nWhich, bEnable));
				}
				break;

			case SID_AUTO_FILTER:
			case SID_AUTOFILTER_HIDE:
				{
					if (!bAutoFilterTested)
					{
						bAutoFilter = pDoc->HasAutoFilter( nPosX, nPosY, nTab );
						bAutoFilterTested = sal_True;
					}
					if ( nWhich == SID_AUTO_FILTER )
					{
                        ScRange aDummy;
                        ScMarkType eMarkType = GetViewData()->GetSimpleArea( aDummy);
                        if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED)
						{
							rSet.DisableItem( nWhich );
						}
						else if (pDoc->GetDPAtBlock(aDummy))
                        {
                            rSet.DisableItem( nWhich );
                        }
                        else
							rSet.Put( SfxBoolItem( nWhich, bAutoFilter ) );
					}
					else
						if (!bAutoFilter)
							rSet.DisableItem( nWhich );
				}
				break;

			case SID_UNFILTER:
				{
                    SCCOL nStartCol, nEndCol;
                    SCROW  nStartRow, nEndRow;
                    SCTAB  nStartTab, nEndTab;
                    sal_Bool bAnyQuery = sal_False;

                    sal_Bool bSelected = (GetViewData()->GetSimpleArea(
                                nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab )
                            == SC_MARK_SIMPLE);

					if ( bSelected )
					{
						if (nStartCol==nEndCol && nStartRow==nEndRow)
							bSelected = sal_False;
					}
					else
					{
						nStartCol = GetViewData()->GetCurX();
						nStartRow = GetViewData()->GetCurY();
						nStartTab = GetViewData()->GetTabNo();
					}

					ScDBData* pDBData = bSelected
								? pDoc->GetDBAtArea( nStartTab, nStartCol, nStartRow, nEndCol, nEndRow )
								: pDoc->GetDBAtCursor( nStartCol, nStartRow, nStartTab );

					if ( pDBData )
					{
						ScQueryParam aParam;
						pDBData->GetQueryParam( aParam );
						if ( aParam.GetEntry(0).bDoQuery )
							bAnyQuery = sal_True;
					}

					if ( !bAnyQuery )
						rSet.DisableItem( nWhich );
				}
				break;

            case SID_DEFINE_DBNAME:
                {
                    if ( pDocSh && pDocSh->IsDocShared() )
                    {
                        rSet.DisableItem( nWhich );
                    }
                }
                break;

            case SID_TEXT_TO_COLUMNS:
                {
                    ScRange aRange;
                    if ( !lcl_GetTextToColumnsRange( pData, aRange ) )
                    {
                        rSet.DisableItem( nWhich );
                    }
                }
                break;
		}
		nWhich = aIter.NextWhich();
	}
}