sc/source/ui/view/cellsh2.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include "scitems.hxx"
  23 #include <comphelper/lok.hxx>
  24 #include <sfx2/viewfrm.hxx>
  25 #include <sfx2/app.hxx>
  26 #include <sfx2/request.hxx>
  27 #include <svl/aeitem.hxx>
  28 #include <basic/sbxcore.hxx>
  29 #include <svl/whiter.hxx>
  30 #include <svl/zforlist.hxx>
  31 #include <vcl/msgbox.hxx>
  32 #include <svl/stritem.hxx>
  33 #include <svl/visitem.hxx>
  34 #include <svtools/miscopt.hxx>
  35 #include <unotools/moduleoptions.hxx>
  36
  37 #include <com/sun/star/frame/FrameSearchFlag.hpp>
  38 #include <com/sun/star/sdbc/XResultSet.hpp>
  39
  40 #include "cellsh.hxx"
  41 #include "tabvwsh.hxx"
  42 #include "sc.hrc"
  43 #include "globstr.hrc"
  44 #include "global.hxx"
  45 #include "globalnames.hxx"
  46 #include "scmod.hxx"
  47 #include "docsh.hxx"
  48 #include "document.hxx"
  49 #include "uiitems.hxx"
  50 #include "dbfunc.hxx"
  51 #include "dbdocfun.hxx"
  52 #include "filtdlg.hxx"
  53 #include "dbnamdlg.hxx"
  54 #include "reffact.hxx"
  55 #include "validat.hxx"
  56 #include "validate.hxx"
  57 #include "scresid.hxx"
  58
  59 #include "scui_def.hxx"
  60 #include "scabstdlg.hxx"
  61 #include "impex.hxx"
  62 #include "asciiopt.hxx"
  63 #include "datastream.hxx"
  64 #include "datastreamdlg.hxx"
  65 #include "queryentry.hxx"
  66 #include "markdata.hxx"
  67 #include <documentlinkmgr.hxx>
  68
  69 #include <config_orcus.h>
  70
  71 #include <memory>
  72
  73 using namespace com::sun::star;
  74
  75 static bool lcl_GetTextToColumnsRange( const ScViewData* pData, ScRange& rRange, bool bDoEmptyCheckOnly )
  76 {
  77     OSL_ENSURE( pData, "lcl_GetTextToColumnsRange: pData is null!" );
  78
  79     bool bRet = false;
  80     const ScMarkData& rMark = pData->GetMarkData();
  81
  82     if ( rMark.IsMarked() )
  83     {
  84         if ( !rMark.IsMultiMarked() )
  85         {
  86             rMark.GetMarkArea( rRange );
  87             if ( rRange.aStart.Col() == rRange.aEnd.Col() )
  88             {
  89                 bRet = true;
  90             }
  91         }
  92     }
  93     else
  94     {
  95         const SCCOL nCol = pData->GetCurX();
  96         const SCROW nRow = pData->GetCurY();
  97         const SCTAB nTab = pData->GetTabNo();
  98         rRange = ScRange( nCol, nRow, nTab, nCol, nRow, nTab );
  99         bRet = true;
 100     }
 101
 102     const ScDocument* pDoc = pData->GetDocument();
 103     OSL_ENSURE( pDoc, "lcl_GetTextToColumnsRange: pDoc is null!" );
 104
 105     if ( bDoEmptyCheckOnly )
 106     {
 107         if ( bRet && pDoc->IsBlockEmpty( rRange.aStart.Tab(), rRange.aStart.Col(),
 108                                          rRange.aStart.Row(), rRange.aEnd.Col(),
 109                                          rRange.aEnd.Row() ) )
 110         {
 111             bRet = false;
 112         }
 113     }
 114     else if ( bRet )
 115     {
 116         rRange.PutInOrder();
 117         SCCOL nStartCol = rRange.aStart.Col(), nEndCol = rRange.aEnd.Col();
 118         SCROW nStartRow = rRange.aStart.Row(), nEndRow = rRange.aEnd.Row();
 119         bool bShrunk = false;
 120         pDoc->ShrinkToUsedDataArea( bShrunk, rRange.aStart.Tab(), nStartCol, nStartRow,
 121                                    nEndCol, nEndRow, false, false, true );
 122         if ( bShrunk )
 123         {
 124             rRange.aStart.SetRow( nStartRow );
 125             rRange.aEnd.SetRow( nEndRow );
 126         }
 127     }
 128
 129     return bRet;
 130 }
 131
 132 static bool lcl_GetSortParam( const ScViewData* pData, ScSortParam& rSortParam )
 133 {
 134     ScTabViewShell* pTabViewShell   = pData->GetViewShell();
 135     ScDBData*   pDBData             = pTabViewShell->GetDBData();
 136     ScDocument* pDoc                = pData->GetDocument();
 137     SCTAB nTab                      = pData->GetTabNo();
 138     ScDirection eFillDir            = DIR_TOP;
 139     bool  bSort                     = true;
 140     ScRange aExternalRange;
 141
 142     if( rSortParam.nCol1 != rSortParam.nCol2 )
 143         eFillDir = DIR_LEFT;
 144     if( rSortParam.nRow1 != rSortParam.nRow2 )
 145         eFillDir = DIR_TOP;
 146
 147     if( rSortParam.nRow2 == MAXROW )
 148     {
 149         // Assume that user selected entire column(s), but cater for the
 150         // possibility that the start row is not the first row.
 151         SCSIZE nCount = pDoc->GetEmptyLinesInBlock( rSortParam.nCol1, rSortParam.nRow1, nTab,
 152                                                     rSortParam.nCol2, rSortParam.nRow2, nTab, eFillDir );
 153         aExternalRange = ScRange( rSortParam.nCol1,
 154                 ::std::min( rSortParam.nRow1 + sal::static_int_cast<SCROW>( nCount ), MAXROW), nTab );
 155     }
 156     else
 157         aExternalRange = ScRange( pData->GetCurX(), pData->GetCurY(), nTab );
 158
 159     SCROW nStartRow = aExternalRange.aStart.Row();
 160     SCCOL nStartCol = aExternalRange.aStart.Col();
 161     SCROW nEndRow   = aExternalRange.aEnd.Row();
 162     SCCOL nEndCol   = aExternalRange.aEnd.Col();
 163     pDoc->GetDataArea( aExternalRange.aStart.Tab(), nStartCol, nStartRow, nEndCol, nEndRow, false, false );
 164     aExternalRange.aStart.SetRow( nStartRow );
 165     aExternalRange.aStart.SetCol( nStartCol );
 166     aExternalRange.aEnd.SetRow( nEndRow );
 167     aExternalRange.aEnd.SetCol( nEndCol );
 168
 169     // with LibreOfficeKit, don't try to interact with the user
 170     if (!comphelper::LibreOfficeKit::isActive() &&
 171         ((rSortParam.nCol1 == rSortParam.nCol2 && aExternalRange.aStart.Col() != aExternalRange.aEnd.Col()) ||
 172          (rSortParam.nRow1 == rSortParam.nRow2 && aExternalRange.aStart.Row() != aExternalRange.aEnd.Row())))
 173     {
 174         pTabViewShell->AddHighlightRange( aExternalRange,Color( COL_LIGHTBLUE ) );
 175         ScRange rExtendRange( aExternalRange.aStart.Col(), aExternalRange.aStart.Row(), nTab, aExternalRange.aEnd.Col(), aExternalRange.aEnd.Row(), nTab );
 176         OUString aExtendStr(rExtendRange.Format(ScRefFlags::VALID, pDoc));
 177
 178         ScRange rCurrentRange( rSortParam.nCol1, rSortParam.nRow1, nTab, rSortParam.nCol2, rSortParam.nRow2, nTab );
 179         OUString aCurrentStr(rCurrentRange.Format(ScRefFlags::VALID, pDoc));
 180
 181         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 182         OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
 183
 184         std::unique_ptr<AbstractScSortWarningDlg> pWarningDlg(pFact->CreateScSortWarningDlg( pTabViewShell->GetDialogParent(), aExtendStr, aCurrentStr ));
 185         OSL_ENSURE(pWarningDlg, "Dialog create fail!");
 186         short bResult = pWarningDlg->Execute();
 187         if( bResult == BTN_EXTEND_RANGE || bResult == BTN_CURRENT_SELECTION )
 188         {
 189             if( bResult == BTN_EXTEND_RANGE )
 190             {
 191                 pTabViewShell->MarkRange( aExternalRange, false );
 192                 pDBData->SetArea( nTab, aExternalRange.aStart.Col(), aExternalRange.aStart.Row(), aExternalRange.aEnd.Col(), aExternalRange.aEnd.Row() );
 193             }
 194         }
 195         else
 196         {
 197             bSort = false;
 198             pData->GetDocShell()->CancelAutoDBRange();
 199         }
 200
 201         pTabViewShell->ClearHighlightRanges();
 202     }
 203     return bSort;
 204 }
 205
 206 void ScCellShell::ExecuteDB( SfxRequest& rReq )
 207 {
 208     ScTabViewShell* pTabViewShell   = GetViewData()->GetViewShell();
 209     sal_uInt16 nSlotId = rReq.GetSlot();
 210     const SfxItemSet*   pReqArgs    = rReq.GetArgs();
 211     ScModule*           pScMod      = SC_MOD();
 212
 213     pTabViewShell->HideListBox();                   // Autofilter-DropDown-Listbox
 214
 215     if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
 216     {
 217         pScMod->InputEnterHandler();
 218         pTabViewShell->UpdateInputHandler();
 219     }
 220
 221     switch ( nSlotId )
 222     {
 223         case SID_VIEW_DATA_SOURCE_BROWSER:
 224             {
 225                 //  check if database beamer is open
 226
 227                 SfxViewFrame* pViewFrame = pTabViewShell->GetViewFrame();
 228                 bool bWasOpen = false;
 229                 {
 230                     uno::Reference<frame::XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface();
 231                     uno::Reference<frame::XFrame> xBeamerFrame = xFrame->findFrame(
 232                                                         "_beamer",
 233                                                         frame::FrameSearchFlag::CHILDREN);
 234                     if ( xBeamerFrame.is() )
 235                         bWasOpen = true;
 236                 }
 237
 238                 if ( bWasOpen )
 239                 {
 240                     //  close database beamer: just forward to SfxViewFrame
 241
 242                     pViewFrame->ExecuteSlot( rReq );
 243                 }
 244                 else
 245                 {
 246                     //  show database beamer: SfxViewFrame call must be synchronous
 247
 248                     pViewFrame->ExecuteSlot( rReq, false );      // false = synchronous
 249
 250                     //  select current database in database beamer
 251
 252                     ScImportParam aImportParam;
 253                     ScDBData* pDBData = pTabViewShell->GetDBData(true,SC_DB_OLD);       // don't create if none found
 254                     if (pDBData)
 255                         pDBData->GetImportParam( aImportParam );
 256
 257                     ScDBDocFunc::ShowInBeamer( aImportParam, pTabViewShell->GetViewFrame() );
 258                 }
 259                 rReq.Done();        // needed because it's a toggle slot
 260             }
 261             break;
 262
 263         case SID_REIMPORT_DATA:
 264             {
 265                 bool bOk = false;
 266                 ScDBData* pDBData = pTabViewShell->GetDBData(true,SC_DB_OLD);
 267                 if (pDBData)
 268                 {
 269                     ScImportParam aImportParam;
 270                     pDBData->GetImportParam( aImportParam );
 271                     if (aImportParam.bImport && !pDBData->HasImportSelection())
 272                     {
 273                         pTabViewShell->ImportData( aImportParam );
 274                         pDBData->SetImportParam( aImportParam );    //! Undo ??
 275                         bOk = true;
 276                     }
 277                 }
 278
 279                 if (!bOk && ! rReq.IsAPI() )
 280                     pTabViewShell->ErrorMessage(STR_REIMPORT_EMPTY);
 281
 282                 if( bOk )
 283                     rReq.Done();
 284             }
 285             break;
 286
 287         case SID_REFRESH_DBAREA:
 288             {
 289                 ScDBData* pDBData = pTabViewShell->GetDBData(true,SC_DB_OLD);
 290                 if (pDBData)
 291                 {
 292                     //  repeat import like SID_REIMPORT_DATA
 293
 294                     bool bContinue = true;
 295                     ScImportParam aImportParam;
 296                     pDBData->GetImportParam( aImportParam );
 297                     if (aImportParam.bImport && !pDBData->HasImportSelection())
 298                     {
 299                         bContinue = pTabViewShell->ImportData( aImportParam );
 300                         pDBData->SetImportParam( aImportParam );    //! Undo ??
 301
 302                         //  mark (size may have been changed)
 303                         ScRange aNewRange;
 304                         pDBData->GetArea(aNewRange);
 305                         pTabViewShell->MarkRange(aNewRange);
 306                     }
 307
 308                     if ( bContinue )        // fail at import -> break
 309                     {
 310                         //  internal operations, when any stored
 311
 312                         if ( pDBData->HasQueryParam() || pDBData->HasSortParam() ||
 313                                                           pDBData->HasSubTotalParam() )
 314                             pTabViewShell->RepeatDB();
 315
 316                         //  pivot tables that have the range as data source
 317
 318                         ScRange aRange;
 319                         pDBData->GetArea(aRange);
 320                         GetViewData()->GetDocShell()->RefreshPivotTables(aRange);
 321                     }
 322                 }
 323                 rReq.Done();
 324             }
 325             break;
 326
 327         case SID_SBA_BRW_INSERT:
 328             {
 329                 OSL_FAIL( "Deprecated Slot" );
 330             }
 331             break;
 332
 333         case SID_DATA_FORM:
 334             {
 335                 ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 336                 OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
 337
 338                 std::unique_ptr<AbstractScDataFormDlg> pDlg(pFact->CreateScDataFormDlg(
 339                     pTabViewShell->GetDialogParent(), pTabViewShell));
 340                 OSL_ENSURE(pDlg, "Dialog create fail!");
 341
 342                 pDlg->Execute();
 343
 344                 rReq.Done();
 345             }
 346             break;
 347
 348         case SID_SUBTOTALS:
 349             ExecuteSubtotals(rReq);
 350             break;
 351
 352         case SID_SORT_DESCENDING:
 353         case SID_SORT_ASCENDING:
 354             {
 355                 //#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
 356                 //the patch comes from maoyg
 357                 ScSortParam aSortParam;
 358                 ScDBData*   pDBData = pTabViewShell->GetDBData();
 359                 ScViewData* pData   = GetViewData();
 360
 361                 pDBData->GetSortParam( aSortParam );
 362
 363                 if( lcl_GetSortParam( pData, aSortParam ) )
 364                 {
 365                     SfxItemSet  aArgSet( GetPool(), SCITEM_SORTDATA, SCITEM_SORTDATA );
 366                     SCCOL nCol  = GetViewData()->GetCurX();
 367                     SCCOL nTab  = GetViewData()->GetTabNo();
 368                     ScDocument* pDoc    = GetViewData()->GetDocument();
 369
 370                     pDBData->GetSortParam( aSortParam );
 371                     bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, nTab );
 372
 373                     if( nCol < aSortParam.nCol1 )
 374                         nCol = aSortParam.nCol1;
 375                     else if( nCol > aSortParam.nCol2 )
 376                         nCol = aSortParam.nCol2;
 377
 378                     aSortParam.bHasHeader       = bHasHeader;
 379                     aSortParam.bByRow           = true;
 380                     aSortParam.bCaseSens        = false;
 381                     aSortParam.bNaturalSort     = false;
 382                     aSortParam.bIncludePattern  = true;
 383                     aSortParam.bInplace         = true;
 384                     aSortParam.maKeyState[0].bDoSort = true;
 385                     aSortParam.maKeyState[0].nField = nCol;
 386                     aSortParam.maKeyState[0].bAscending = ( nSlotId == SID_SORT_ASCENDING );
 387
 388                     for ( sal_uInt16 i=1; i<aSortParam.GetSortKeyCount(); i++ )
 389                         aSortParam.maKeyState[i].bDoSort = false;
 390
 391                     aArgSet.Put( ScSortItem( SCITEM_SORTDATA, GetViewData(), &aSortParam ) );
 392
 393                     pTabViewShell->UISort( aSortParam );        // subtotal when needed new
 394
 395                     rReq.Done();
 396                 }
 397             }
 398             break;
 399
 400         case SID_SORT:
 401             {
 402                 const SfxItemSet* pArgs = rReq.GetArgs();
 403
 404                 //#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
 405                 //the patch comes from maoyg
 406
 407                 if ( pArgs )        // Basic
 408                 {
 409                     ScSortParam aSortParam;
 410                     ScDBData*   pDBData = pTabViewShell->GetDBData();
 411                     ScViewData* pData   = GetViewData();
 412
 413                     pDBData->GetSortParam( aSortParam );
 414
 415                     if( lcl_GetSortParam( pData, aSortParam ) )
 416                     {
 417                         ScDocument* pDoc = GetViewData()->GetDocument();
 418
 419                         pDBData->GetSortParam( aSortParam );
 420                         bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, pData->GetTabNo() );
 421                         if( bHasHeader )
 422                             aSortParam.bHasHeader = bHasHeader;
 423
 424                         aSortParam.bInplace = true;             // from Basic always
 425
 426                         const SfxPoolItem* pItem;
 427                         if ( pArgs->GetItemState( SID_SORT_BYROW, true, &pItem ) == SfxItemState::SET )
 428                             aSortParam.bByRow = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 429                         if ( pArgs->GetItemState( SID_SORT_HASHEADER, true, &pItem ) == SfxItemState::SET )
 430                             aSortParam.bHasHeader = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 431                         if ( pArgs->GetItemState( SID_SORT_CASESENS, true, &pItem ) == SfxItemState::SET )
 432                             aSortParam.bCaseSens = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 433                         if ( pArgs->GetItemState( SID_SORT_NATURALSORT, true, &pItem ) == SfxItemState::SET )
 434                             aSortParam.bNaturalSort = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 435                         if ( pArgs->GetItemState( SID_SORT_ATTRIBS, true, &pItem ) == SfxItemState::SET )
 436                             aSortParam.bIncludePattern = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 437                         if ( pArgs->GetItemState( SID_SORT_USERDEF, true, &pItem ) == SfxItemState::SET )
 438                         {
 439                             sal_uInt16 nUserIndex = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
 440                             aSortParam.bUserDef = ( nUserIndex != 0 );
 441                             if ( nUserIndex )
 442                                 aSortParam.nUserIndex = nUserIndex - 1;     // Basic: 1-based
 443                         }
 444
 445                         SCCOLROW nField0 = 0;
 446                         if ( pArgs->GetItemState( FN_PARAM_1, true, &pItem ) == SfxItemState::SET )
 447                             nField0 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
 448                         aSortParam.maKeyState[0].bDoSort = ( nField0 != 0 );
 449                         aSortParam.maKeyState[0].nField = nField0 > 0 ? (nField0-1) : 0;
 450                         if ( pArgs->GetItemState( FN_PARAM_2, true, &pItem ) == SfxItemState::SET )
 451                             aSortParam.maKeyState[0].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 452                         SCCOLROW nField1 = 0;
 453                         if ( pArgs->GetItemState( FN_PARAM_3, true, &pItem ) == SfxItemState::SET )
 454                             nField1 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
 455                         aSortParam.maKeyState[1].bDoSort = ( nField1 != 0 );
 456                         aSortParam.maKeyState[1].nField = nField1 > 0 ? (nField1-1) : 0;
 457                         if ( pArgs->GetItemState( FN_PARAM_4, true, &pItem ) == SfxItemState::SET )
 458                             aSortParam.maKeyState[1].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 459                         SCCOLROW nField2 = 0;
 460                         if ( pArgs->GetItemState( FN_PARAM_5, true, &pItem ) == SfxItemState::SET )
 461                             nField2 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
 462                         aSortParam.maKeyState[2].bDoSort = ( nField2 != 0 );
 463                         aSortParam.maKeyState[2].nField = nField2 > 0 ? (nField2-1) : 0;
 464                         if ( pArgs->GetItemState( FN_PARAM_6, true, &pItem ) == SfxItemState::SET )
 465                             aSortParam.maKeyState[2].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 466
 467                         // subtotal when needed new
 468                         pTabViewShell->UISort( aSortParam );
 469                         rReq.Done();
 470                     }
 471                 }
 472                 else
 473                 {
 474                     ScSortParam aSortParam;
 475                     ScDBData*   pDBData = pTabViewShell->GetDBData();
 476                     ScViewData* pData   = GetViewData();
 477
 478                     pDBData->GetSortParam( aSortParam );
 479
 480                     if( lcl_GetSortParam( pData, aSortParam ) )
 481                     {
 482                         ScDocument* pDoc = GetViewData()->GetDocument();
 483                         SfxItemSet  aArgSet( GetPool(), SCITEM_SORTDATA, SCITEM_SORTDATA );
 484
 485                         pDBData->GetSortParam( aSortParam );
 486                         bool bHasHeader = pDoc->HasColHeader( aSortParam.nCol1, aSortParam.nRow1, aSortParam.nCol2, aSortParam.nRow2, pData->GetTabNo() );
 487                         if( bHasHeader )
 488                             aSortParam.bHasHeader = bHasHeader;
 489
 490                         aArgSet.Put( ScSortItem( SCITEM_SORTDATA, GetViewData(), &aSortParam ) );
 491
 492                         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 493                         assert(pFact); //ScAbstractFactory create fail!
 494
 495                         std::unique_ptr<SfxAbstractTabDialog> pDlg(pFact->CreateScSortDlg(pTabViewShell->GetDialogParent(),  &aArgSet));
 496                         assert(pDlg); //Dialog create fail!
 497                         pDlg->SetCurPageId("criteria");  // 1=sort field tab  2=sort options tab
 498
 499                         if ( pDlg->Execute() == RET_OK )
 500                         {
 501                             const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
 502                             const ScSortParam& rOutParam = static_cast<const ScSortItem&>(
 503                                 pOutSet->Get( SCITEM_SORTDATA )).GetSortData();
 504
 505                             // subtotal when needed new
 506
 507                             pTabViewShell->UISort( rOutParam );
 508
 509                             if ( rOutParam.bInplace )
 510                             {
 511                                 rReq.AppendItem( SfxBoolItem( SID_SORT_BYROW,
 512                                     rOutParam.bByRow ) );
 513                                 rReq.AppendItem( SfxBoolItem( SID_SORT_HASHEADER,
 514                                     rOutParam.bHasHeader ) );
 515                                 rReq.AppendItem( SfxBoolItem( SID_SORT_CASESENS,
 516                                     rOutParam.bCaseSens ) );
 517                                 rReq.AppendItem( SfxBoolItem( SID_SORT_NATURALSORT,
 518                                             rOutParam.bNaturalSort ) );
 519                                 rReq.AppendItem( SfxBoolItem( SID_SORT_ATTRIBS,
 520                                     rOutParam.bIncludePattern ) );
 521                                 sal_uInt16 nUser = rOutParam.bUserDef ? ( rOutParam.nUserIndex + 1 ) : 0;
 522                                 rReq.AppendItem( SfxUInt16Item( SID_SORT_USERDEF, nUser ) );
 523                                 if ( rOutParam.maKeyState[0].bDoSort )
 524                                 {
 525                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_1,
 526                                         rOutParam.maKeyState[0].nField + 1 ) );
 527                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_2,
 528                                         rOutParam.maKeyState[0].bAscending ) );
 529                                 }
 530                                 if ( rOutParam.maKeyState[1].bDoSort )
 531                                 {
 532                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_3,
 533                                         rOutParam.maKeyState[1].nField + 1 ) );
 534                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_4,
 535                                         rOutParam.maKeyState[1].bAscending ) );
 536                                 }
 537                                 if ( rOutParam.maKeyState[2].bDoSort )
 538                                 {
 539                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_5,
 540                                         rOutParam.maKeyState[2].nField + 1 ) );
 541                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_6,
 542                                         rOutParam.maKeyState[2].bAscending ) );
 543                                 }
 544                             }
 545
 546                             rReq.Done();
 547                         }
 548                         else
 549                             GetViewData()->GetDocShell()->CancelAutoDBRange();
 550                     }
 551                 }
 552             }
 553             break;
 554
 555         case SID_FILTER:
 556             {
 557                 const SfxItemSet* pArgs = rReq.GetArgs();
 558                 if ( pArgs )
 559                 {
 560                     OSL_FAIL("SID_FILTER with arguments?");
 561                     pTabViewShell->Query( static_cast<const ScQueryItem&>(
 562                             pArgs->Get( SCITEM_QUERYDATA )).GetQueryData(), nullptr, true );
 563                     rReq.Done();
 564                 }
 565                 else
 566                 {
 567                     sal_uInt16          nId  = ScFilterDlgWrapper::GetChildWindowId();
 568                     SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
 569                     SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
 570
 571                     pScMod->SetRefDialog( nId, pWnd == nullptr );
 572                 }
 573             }
 574             break;
 575
 576         case SID_SPECIAL_FILTER:
 577             {
 578                 const SfxItemSet* pArgs = rReq.GetArgs();
 579                 if ( pArgs )
 580                 {
 581                     OSL_FAIL("SID_SPECIAL_FILTER with arguments?");
 582                     pTabViewShell->Query( static_cast<const ScQueryItem&>(
 583                             pArgs->Get( SCITEM_QUERYDATA )).GetQueryData(), nullptr, true );
 584                     rReq.Done();
 585                 }
 586                 else
 587                 {
 588                     sal_uInt16          nId  = ScSpecialFilterDlgWrapper::GetChildWindowId();
 589                     SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
 590                     SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
 591
 592                     pScMod->SetRefDialog( nId, pWnd == nullptr );
 593                 }
 594             }
 595             break;
 596
 597         case FID_FILTER_OK:
 598             {
 599                 const SfxPoolItem* pItem;
 600                 if ( pReqArgs && SfxItemState::SET ==
 601                         pReqArgs->GetItemState( SCITEM_QUERYDATA, true, &pItem ) )
 602                 {
 603                     const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(*pItem);
 604
 605                     SCTAB nCurTab = GetViewData()->GetTabNo();
 606                     SCTAB nRefTab = GetViewData()->GetRefTabNo();
 607
 608                     // If RefInput switched to a different sheet from the data sheet,
 609                     // switch back:
 610
 611                     if ( nCurTab != nRefTab )
 612                     {
 613                         pTabViewShell->SetTabNo( nRefTab );
 614                         pTabViewShell->PaintExtras();
 615                     }
 616
 617                     ScRange aAdvSource;
 618                     if (rQueryItem.GetAdvancedQuerySource(aAdvSource))
 619                         pTabViewShell->Query( rQueryItem.GetQueryData(), &aAdvSource, true );
 620                     else
 621                         pTabViewShell->Query( rQueryItem.GetQueryData(), nullptr, true );
 622                     rReq.Done( *pReqArgs );
 623                 }
 624             }
 625             break;
 626
 627         case SID_UNFILTER:
 628             {
 629                 ScQueryParam aParam;
 630                 ScDBData*    pDBData = pTabViewShell->GetDBData();
 631
 632                 pDBData->GetQueryParam( aParam );
 633                 SCSIZE nEC = aParam.GetEntryCount();
 634                 for (SCSIZE i=0; i<nEC; i++)
 635                     aParam.GetEntry(i).bDoQuery = false;
 636                 aParam.bDuplicate = true;
 637                 pTabViewShell->Query( aParam, nullptr, true );
 638                 rReq.Done();
 639             }
 640             break;
 641
 642         case SID_AUTO_FILTER:
 643             pTabViewShell->ToggleAutoFilter();
 644             rReq.Done();
 645             break;
 646
 647         case SID_AUTOFILTER_HIDE:
 648             pTabViewShell->HideAutoFilter();
 649             rReq.Done();
 650             break;
 651
 652         case SID_PIVOT_TABLE:
 653             {
 654                 const SfxPoolItem* pItem;
 655                 if ( pReqArgs && SfxItemState::SET ==
 656                         pReqArgs->GetItemState( SCITEM_PIVOTDATA, true, &pItem ) )
 657                 {
 658                     SCTAB nCurTab = GetViewData()->GetTabNo();
 659                     SCTAB nRefTab = GetViewData()->GetRefTabNo();
 660
 661                     // If RefInput switched to a different sheet from the data sheet,
 662                     // switch back:
 663
 664                     if ( nCurTab != nRefTab )
 665                     {
 666                         pTabViewShell->SetTabNo( nRefTab );
 667                         pTabViewShell->PaintExtras();
 668                     }
 669
 670                     const ScDPObject* pDPObject = pTabViewShell->GetDialogDPObject();
 671                     if ( pDPObject )
 672                     {
 673                         const ScPivotItem* pPItem = static_cast<const ScPivotItem*>(pItem);
 674                         bool bSuccess = pTabViewShell->MakePivotTable(
 675                             pPItem->GetData(), pPItem->GetDestRange(), pPItem->IsNewSheet(), *pDPObject );
 676                         SfxBoolItem aRet(0, bSuccess);
 677                         rReq.SetReturnValue(aRet);
 678                     }
 679                     rReq.Done();
 680                 }
 681 #if HAVE_FEATURE_SCRIPTING
 682                 else if (rReq.IsAPI())
 683                     SbxBase::SetError(ERRCODE_SBX_BAD_PARAMETER);
 684 #endif
 685             }
 686             break;
 687
 688         case SID_OPENDLG_PIVOTTABLE:
 689             ExecuteDataPilotDialog();
 690             break;
 691         case SID_DEFINE_DBNAME:
 692             {
 693
 694                 sal_uInt16          nId  = ScDbNameDlgWrapper::GetChildWindowId();
 695                 SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
 696                 SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
 697
 698                 pScMod->SetRefDialog( nId, pWnd == nullptr );
 699
 700             }
 701             break;
 702
 703         case SID_SELECT_DB:
 704             {
 705                 if ( pReqArgs )
 706                 {
 707                     const SfxStringItem* pItem =
 708                         static_cast<const SfxStringItem*>(&pReqArgs->Get( SID_SELECT_DB ));
 709
 710                     if( pItem )
 711                     {
 712                         pTabViewShell->GotoDBArea( pItem->GetValue() );
 713                         rReq.Done();
 714                     }
 715                     else
 716                     {
 717                         OSL_FAIL("NULL");
 718                     }
 719                 }
 720                 else
 721                 {
 722                     ScDocument*     pDoc   = GetViewData()->GetDocument();
 723                     ScDBCollection* pDBCol = pDoc->GetDBCollection();
 724
 725                     if ( pDBCol )
 726                     {
 727                         std::vector<OUString> aList;
 728                         const ScDBCollection::NamedDBs& rDBs = pDBCol->getNamedDBs();
 729                         ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
 730                         for (; itr != itrEnd; ++itr)
 731                             aList.push_back((*itr)->GetName());
 732
 733                         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 734                         OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
 735
 736                         std::unique_ptr<AbstractScSelEntryDlg> pDlg(pFact->CreateScSelEntryDlg( pTabViewShell->GetDialogParent(),
 737                                                                                                   aList ));
 738                         OSL_ENSURE(pDlg, "Dialog create fail!");
 739                         if ( pDlg->Execute() == RET_OK )
 740                         {
 741                             OUString aName = pDlg->GetSelectEntry();
 742                             pTabViewShell->GotoDBArea( aName );
 743                             rReq.AppendItem( SfxStringItem( SID_SELECT_DB, aName ) );
 744                             rReq.Done();
 745                         }
 746                     }
 747                 }
 748             }
 749             break;
 750         case SID_DATA_STREAMS:
 751         {
 752             ScopedVclPtrInstance< sc::DataStreamDlg > aDialog( GetViewData()->GetDocShell(), pTabViewShell->GetDialogParent() );
 753             ScDocument *pDoc = GetViewData()->GetDocument();
 754             sc::DocumentLinkManager& rMgr = pDoc->GetDocLinkManager();
 755             sc::DataStream* pStrm = rMgr.getDataStream();
 756             if (pStrm)
 757                 aDialog->Init(*pStrm);
 758
 759             if (aDialog->Execute() == RET_OK)
 760                 aDialog->StartStream();
 761         }
 762         break;
 763         case SID_DATA_STREAMS_PLAY:
 764         {
 765             ScDocument *pDoc = GetViewData()->GetDocument();
 766             sc::DocumentLinkManager& rMgr = pDoc->GetDocLinkManager();
 767             sc::DataStream* pStrm = rMgr.getDataStream();
 768             if (pStrm)
 769                 pStrm->StartImport();
 770         }
 771         break;
 772         case SID_DATA_STREAMS_STOP:
 773         {
 774             ScDocument *pDoc = GetViewData()->GetDocument();
 775             sc::DocumentLinkManager& rMgr = pDoc->GetDocLinkManager();
 776             sc::DataStream* pStrm = rMgr.getDataStream();
 777             if (pStrm)
 778                 pStrm->StopImport();
 779         }
 780         break;
 781         case SID_MANAGE_XML_SOURCE:
 782             ExecuteXMLSourceDialog();
 783         break;
 784         case FID_VALIDATION:
 785             {
 786                 const SfxPoolItem* pItem;
 787                 const SfxItemSet* pArgs = rReq.GetArgs();
 788                 if ( pArgs )
 789                 {
 790                     OSL_FAIL("later...");
 791                 }
 792                 else
 793                 {
 794                     SfxItemSet aArgSet( GetPool(), ScTPValidationValue::GetRanges() );
 795                     ScValidationMode eMode = SC_VALID_ANY;
 796                     ScConditionMode eOper = SC_COND_EQUAL;
 797                     OUString aExpr1, aExpr2;
 798                     bool bBlank = true;
 799                     sal_Int16 nListType = css::sheet::TableValidationVisibility::UNSORTED;
 800                     bool bShowHelp = false;
 801                     OUString aHelpTitle, aHelpText;
 802                     bool bShowError = false;
 803                     ScValidErrorStyle eErrStyle = SC_VALERR_STOP;
 804                     OUString aErrTitle, aErrText;
 805
 806                     ScDocument* pDoc = GetViewData()->GetDocument();
 807                     SCCOL nCurX = GetViewData()->GetCurX();
 808                     SCROW nCurY = GetViewData()->GetCurY();
 809                     SCTAB nTab = GetViewData()->GetTabNo();
 810                     ScAddress aCursorPos( nCurX, nCurY, nTab );
 811                     sal_uLong nIndex = static_cast<const SfxUInt32Item*>(pDoc->GetAttr(
 812                                 nCurX, nCurY, nTab, ATTR_VALIDDATA ))->GetValue();
 813                     if ( nIndex )
 814                     {
 815                         const ScValidationData* pOldData = pDoc->GetValidationEntry( nIndex );
 816                         if ( pOldData )
 817                         {
 818                             eMode = pOldData->GetDataMode();
 819                             eOper = pOldData->GetOperation();
 820                             sal_uLong nNumFmt = 0;
 821                             if ( eMode == SC_VALID_DATE || eMode == SC_VALID_TIME )
 822                             {
 823                                 short nType = ( eMode == SC_VALID_DATE ) ? css::util::NumberFormat::DATE
 824                                                                          : css::util::NumberFormat::TIME;
 825                                 nNumFmt = pDoc->GetFormatTable()->GetStandardFormat(
 826                                                                     nType, ScGlobal::eLnge );
 827                             }
 828                             aExpr1 = pOldData->GetExpression( aCursorPos, 0, nNumFmt );
 829                             aExpr2 = pOldData->GetExpression( aCursorPos, 1, nNumFmt );
 830                             bBlank = pOldData->IsIgnoreBlank();
 831                             nListType = pOldData->GetListType();
 832
 833                             bShowHelp = pOldData->GetInput( aHelpTitle, aHelpText );
 834                             bShowError = pOldData->GetErrMsg( aErrTitle, aErrText, eErrStyle );
 835
 836                             aArgSet.Put( SfxAllEnumItem( FID_VALID_MODE,        sal::static_int_cast<sal_uInt16>(eMode) ) );
 837                             aArgSet.Put( SfxAllEnumItem( FID_VALID_CONDMODE,    sal::static_int_cast<sal_uInt16>(eOper) ) );
 838                             aArgSet.Put( SfxStringItem(  FID_VALID_VALUE1,      aExpr1 ) );
 839                             aArgSet.Put( SfxStringItem(  FID_VALID_VALUE2,      aExpr2 ) );
 840                             aArgSet.Put( SfxBoolItem(    FID_VALID_BLANK,       bBlank ) );
 841                             aArgSet.Put( SfxInt16Item(   FID_VALID_LISTTYPE,    nListType ) );
 842                             aArgSet.Put( SfxBoolItem(    FID_VALID_SHOWHELP,    bShowHelp ) );
 843                             aArgSet.Put( SfxStringItem(  FID_VALID_HELPTITLE,   aHelpTitle ) );
 844                             aArgSet.Put( SfxStringItem(  FID_VALID_HELPTEXT,    aHelpText ) );
 845                             aArgSet.Put( SfxBoolItem(    FID_VALID_SHOWERR,     bShowError ) );
 846                             aArgSet.Put( SfxAllEnumItem( FID_VALID_ERRSTYLE,    sal::static_int_cast<sal_uInt16>(eErrStyle) ) );
 847                             aArgSet.Put( SfxStringItem(  FID_VALID_ERRTITLE,    aErrTitle ) );
 848                             aArgSet.Put( SfxStringItem(  FID_VALID_ERRTEXT,     aErrText ) );
 849                         }
 850                     }
 851
 852                     // cell range picker
 853                     ScopedVclPtr<ScValidationDlg> pDlg(VclPtr<ScValidationDlg>::Create(nullptr, &aArgSet, pTabViewShell));
 854
 855                     short nResult = pDlg->Execute();
 856                     if ( nResult == RET_OK )
 857                     {
 858                         const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
 859
 860                         if ( pOutSet->GetItemState( FID_VALID_MODE, true, &pItem ) == SfxItemState::SET )
 861                             eMode = (ScValidationMode) static_cast<const SfxAllEnumItem*>(pItem)->GetValue();
 862                         if ( pOutSet->GetItemState( FID_VALID_CONDMODE, true, &pItem ) == SfxItemState::SET )
 863                             eOper = (ScConditionMode) static_cast<const SfxAllEnumItem*>(pItem)->GetValue();
 864                         if ( pOutSet->GetItemState( FID_VALID_VALUE1, true, &pItem ) == SfxItemState::SET )
 865                         {
 866                             OUString aTemp1 = static_cast<const SfxStringItem*>(pItem)->GetValue();
 867                             if (eMode == SC_VALID_DATE || eMode == SC_VALID_TIME)
 868                             {
 869                                 sal_uInt32 nNumIndex = 0;
 870                                 double nVal;
 871                                 if (pDoc->GetFormatTable()->IsNumberFormat(aTemp1, nNumIndex, nVal))
 872                                     aExpr1 = ::rtl::math::doubleToUString( nVal,
 873                                             rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
 874                                             ScGlobal::pLocaleData->getNumDecimalSep()[0], true);
 875                                 else
 876                                     aExpr1 = aTemp1;
 877                             }
 878                             else
 879                                 aExpr1 = aTemp1;
 880                         }
 881                         if ( pOutSet->GetItemState( FID_VALID_VALUE2, true, &pItem ) == SfxItemState::SET )
 882                         {
 883                             OUString aTemp2 = static_cast<const SfxStringItem*>(pItem)->GetValue();
 884                             if (eMode == SC_VALID_DATE || eMode == SC_VALID_TIME)
 885                             {
 886                                 sal_uInt32 nNumIndex = 0;
 887                                 double nVal;
 888                                 if (pDoc->GetFormatTable()->IsNumberFormat(aTemp2, nNumIndex, nVal))
 889                                     aExpr2 = ::rtl::math::doubleToUString( nVal,
 890                                             rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
 891                                             ScGlobal::pLocaleData->getNumDecimalSep()[0], true);
 892                                 else
 893                                     aExpr2 = aTemp2;
 894                                 if ( eMode == SC_VALID_TIME ) {
 895                                     sal_Int32 wraparound = aExpr1.compareTo(aExpr2);
 896                                     if (wraparound > 0) {
 897                                         if (eOper == SC_COND_BETWEEN) {
 898                                             eOper = SC_COND_NOTBETWEEN;
 899                                             OUString tmp = aExpr1;
 900                                             aExpr1 = aExpr2;
 901                                             aExpr2 = tmp;
 902                                         }
 903                                         else if (eOper == SC_COND_NOTBETWEEN) {
 904                                             eOper = SC_COND_BETWEEN;
 905                                             OUString tmp = aExpr1;
 906                                             aExpr1 = aExpr2;
 907                                             aExpr2 = tmp;
 908                                         }
 909                                     }
 910                                 }
 911                             }
 912                             else
 913                                 aExpr2 = aTemp2;
 914                         }
 915                         if ( pOutSet->GetItemState( FID_VALID_BLANK, true, &pItem ) == SfxItemState::SET )
 916                             bBlank = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 917                         if ( pOutSet->GetItemState( FID_VALID_LISTTYPE, true, &pItem ) == SfxItemState::SET )
 918                             nListType = static_cast<const SfxInt16Item*>(pItem)->GetValue();
 919
 920                         if ( pOutSet->GetItemState( FID_VALID_SHOWHELP, true, &pItem ) == SfxItemState::SET )
 921                             bShowHelp = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 922                         if ( pOutSet->GetItemState( FID_VALID_HELPTITLE, true, &pItem ) == SfxItemState::SET )
 923                             aHelpTitle = static_cast<const SfxStringItem*>(pItem)->GetValue();
 924                         if ( pOutSet->GetItemState( FID_VALID_HELPTEXT, true, &pItem ) == SfxItemState::SET )
 925                             aHelpText = static_cast<const SfxStringItem*>(pItem)->GetValue();
 926
 927                         if ( pOutSet->GetItemState( FID_VALID_SHOWERR, true, &pItem ) == SfxItemState::SET )
 928                             bShowError = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 929                         if ( pOutSet->GetItemState( FID_VALID_ERRSTYLE, true, &pItem ) == SfxItemState::SET )
 930                             eErrStyle = (ScValidErrorStyle) static_cast<const SfxAllEnumItem*>(pItem)->GetValue();
 931                         if ( pOutSet->GetItemState( FID_VALID_ERRTITLE, true, &pItem ) == SfxItemState::SET )
 932                             aErrTitle = static_cast<const SfxStringItem*>(pItem)->GetValue();
 933                         if ( pOutSet->GetItemState( FID_VALID_ERRTEXT, true, &pItem ) == SfxItemState::SET )
 934                             aErrText = static_cast<const SfxStringItem*>(pItem)->GetValue();
 935
 936                         ScValidationData aData( eMode, eOper, aExpr1, aExpr2, pDoc, aCursorPos );
 937                         aData.SetIgnoreBlank( bBlank );
 938                         aData.SetListType( nListType );
 939
 940                         aData.SetInput(aHelpTitle, aHelpText);          // sets bShowInput to TRUE
 941                         if (!bShowHelp)
 942                             aData.ResetInput();                         // reset only bShowInput
 943
 944                         aData.SetError(aErrTitle, aErrText, eErrStyle); // sets bShowError to TRUE
 945                         if (!bShowError)
 946                             aData.ResetError();                         // reset only bShowError
 947
 948                         pTabViewShell->SetValidation( aData );
 949                         pTabViewShell->TestHintWindow();
 950                         rReq.Done( *pOutSet );
 951                     }
 952                 }
 953             }
 954             break;
 955
 956         case SID_TEXT_TO_COLUMNS:
 957             {
 958                 ScViewData* pData = GetViewData();
 959                 OSL_ENSURE( pData, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pData is null!" );
 960                 ScRange aRange;
 961
 962                 if ( lcl_GetTextToColumnsRange( pData, aRange, false ) )
 963                 {
 964                     ScDocument* pDoc = pData->GetDocument();
 965                     OSL_ENSURE( pDoc, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDoc is null!" );
 966
 967                     ScImportExport aExport( pDoc, aRange );
 968                     aExport.SetExportTextOptions( ScExportTextOptions( ScExportTextOptions::None, 0, false ) );
 969
 970                     // #i87703# text to columns fails with tab separator
 971                     aExport.SetDelimiter( static_cast< sal_Unicode >( 0 ) );
 972
 973                     SvMemoryStream aStream;
 974                     aStream.SetStreamCharSet( RTL_TEXTENCODING_UNICODE );
 975                     ScImportExport::SetNoEndianSwap( aStream );
 976                     aExport.ExportStream( aStream, OUString() );
 977
 978                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 979                     OSL_ENSURE( pFact, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pFact is null!" );
 980                     std::unique_ptr<AbstractScImportAsciiDlg> pDlg(pFact->CreateScImportAsciiDlg(
 981                         OUString(), &aStream, SC_TEXTTOCOLUMNS));
 982                     OSL_ENSURE( pDlg, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDlg is null!" );
 983
 984                     if ( pDlg->Execute() == RET_OK )
 985                     {
 986                         ScDocShell* pDocSh = pData->GetDocShell();
 987                         OSL_ENSURE( pDocSh, "ScCellShell::ExecuteDB: SID_TEXT_TO_COLUMNS - pDocSh is null!" );
 988
 989                         OUString aUndo = ScGlobal::GetRscString( STR_UNDO_TEXTTOCOLUMNS );
 990                         pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
 991
 992                         ScImportExport aImport( pDoc, aRange.aStart );
 993                         ScAsciiOptions aOptions;
 994                         pDlg->GetOptions( aOptions );
 995                         pDlg->SaveParameters();
 996                         aImport.SetExtOptions( aOptions );
 997                         aImport.SetApi( false );
 998                         aImport.SetImportBroadcast( true );
 999                         aImport.SetOverwriting( true );
1000                         aStream.Seek( 0 );
1001                         aImport.ImportStream( aStream, OUString() );
1002
1003                         pDocSh->GetUndoManager()->LeaveListAction();
1004                     }
1005                 }
1006             }
1007             break;
1008         }
1009 }
1010
1011 void ScCellShell::GetDBState( SfxItemSet& rSet )
1012 {
1013     ScTabViewShell* pTabViewShell   = GetViewData()->GetViewShell();
1014     ScViewData* pData       = GetViewData();
1015     ScDocShell* pDocSh      = pData->GetDocShell();
1016     ScDocument& rDoc        = pDocSh->GetDocument();
1017     SCCOL       nPosX       = pData->GetCurX();
1018     SCROW       nPosY       = pData->GetCurY();
1019     SCTAB       nTab        = pData->GetTabNo();
1020
1021     bool bAutoFilter = false;
1022     bool bAutoFilterTested = false;
1023
1024     SfxWhichIter aIter(rSet);
1025     sal_uInt16 nWhich = aIter.FirstWhich();
1026     while (nWhich)
1027     {
1028         switch (nWhich)
1029         {
1030             case SID_REFRESH_DBAREA:
1031                 {
1032                     //  imported data without selection
1033                     //  or filter,sort,subtotal (also without import)
1034                     bool bOk = false;
1035                     ScDBData* pDBData = pTabViewShell->GetDBData(false,SC_DB_OLD);
1036                     if (pDBData && rDoc.GetChangeTrack() == nullptr)
1037                     {
1038                         if ( pDBData->HasImportParam() )
1039                             bOk = !pDBData->HasImportSelection();
1040                         else
1041                         {
1042                             bOk = pDBData->HasQueryParam() ||
1043                                   pDBData->HasSortParam() ||
1044                                   pDBData->HasSubTotalParam();
1045                         }
1046                     }
1047                     if (!bOk)
1048                         rSet.DisableItem( nWhich );
1049                 }
1050                 break;
1051
1052             case SID_FILTER:
1053             case SID_SPECIAL_FILTER:
1054                 {
1055                     ScRange aDummy;
1056                     ScMarkType eMarkType = GetViewData()->GetSimpleArea( aDummy);
1057                     if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED)
1058                     {
1059                         rSet.DisableItem( nWhich );
1060                     }
1061                 }
1062                 break;
1063
1064                 //in case of Redlining and multiselection disable
1065             case SID_SORT_ASCENDING:
1066             case SID_SORT_DESCENDING:
1067             case SCITEM_SORTDATA:
1068             case SCITEM_SUBTDATA:
1069             case SID_OPENDLG_PIVOTTABLE:
1070                 {
1071                     //! move ReadOnly check to idl flags
1072
1073                     if ( pDocSh->IsReadOnly() || rDoc.GetChangeTrack()!=nullptr ||
1074                             GetViewData()->IsMultiMarked() )
1075                     {
1076                         rSet.DisableItem( nWhich );
1077                     }
1078                 }
1079                 break;
1080
1081             case SID_REIMPORT_DATA:
1082                 {
1083                     //  only imported data without selection
1084                     ScDBData* pDBData = pTabViewShell->GetDBData(false,SC_DB_OLD);
1085                     if (!pDBData || !pDBData->HasImportParam() || pDBData->HasImportSelection() ||
1086                         rDoc.GetChangeTrack()!=nullptr)
1087                     {
1088                         rSet.DisableItem( nWhich );
1089                     }
1090                 }
1091                 break;
1092
1093             case SID_VIEW_DATA_SOURCE_BROWSER:
1094                 {
1095                     if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DATABASE))
1096                         rSet.Put(SfxVisibilityItem(nWhich, false));
1097                     else
1098                         //  get state (BoolItem) from SfxViewFrame
1099                         pTabViewShell->GetViewFrame()->GetSlotState( nWhich, nullptr, &rSet );
1100                 }
1101                 break;
1102             case SID_SBA_BRW_INSERT:
1103                 {
1104                     //  SBA wants a sal_Bool-item, enabled
1105
1106                     bool bEnable = true;
1107                     rSet.Put(SfxBoolItem(nWhich, bEnable));
1108                 }
1109                 break;
1110
1111             case SID_AUTO_FILTER:
1112             case SID_AUTOFILTER_HIDE:
1113                 {
1114                     if (!bAutoFilterTested)
1115                     {
1116                         bAutoFilter = rDoc.HasAutoFilter( nPosX, nPosY, nTab );
1117                         bAutoFilterTested = true;
1118                     }
1119                     if ( nWhich == SID_AUTO_FILTER )
1120                     {
1121                         ScRange aDummy;
1122                         ScMarkType eMarkType = GetViewData()->GetSimpleArea( aDummy);
1123                         if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED)
1124                         {
1125                             rSet.DisableItem( nWhich );
1126                         }
1127                         else if (rDoc.GetDPAtBlock(aDummy))
1128                         {
1129                             rSet.DisableItem( nWhich );
1130                         }
1131                         else
1132                             rSet.Put( SfxBoolItem( nWhich, bAutoFilter ) );
1133                     }
1134                     else
1135                         if (!bAutoFilter)
1136                             rSet.DisableItem( nWhich );
1137                 }
1138                 break;
1139
1140             case SID_UNFILTER:
1141                 {
1142                     SCCOL nStartCol, nEndCol;
1143                     SCROW  nStartRow, nEndRow;
1144                     SCTAB  nStartTab, nEndTab;
1145                     bool bAnyQuery = false;
1146
1147                     bool bSelected = (GetViewData()->GetSimpleArea(
1148                                 nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab )
1149                             == SC_MARK_SIMPLE);
1150
1151                     if ( bSelected )
1152                     {
1153                         if (nStartCol==nEndCol && nStartRow==nEndRow)
1154                             bSelected = false;
1155                     }
1156                     else
1157                     {
1158                         nStartCol = GetViewData()->GetCurX();
1159                         nStartRow = GetViewData()->GetCurY();
1160                         nStartTab = GetViewData()->GetTabNo();
1161                     }
1162
1163                     ScDBData* pDBData = bSelected
1164                                 ? rDoc.GetDBAtArea( nStartTab, nStartCol, nStartRow, nEndCol, nEndRow )
1165                                 : rDoc.GetDBAtCursor( nStartCol, nStartRow, nStartTab, ScDBDataPortion::AREA );
1166
1167                     if ( pDBData )
1168                     {
1169                         ScQueryParam aParam;
1170                         pDBData->GetQueryParam( aParam );
1171                         if ( aParam.GetEntry(0).bDoQuery )
1172                             bAnyQuery = true;
1173                     }
1174
1175                     if ( !bAnyQuery )
1176                         rSet.DisableItem( nWhich );
1177                 }
1178                 break;
1179
1180             case SID_DEFINE_DBNAME:
1181                 {
1182                     if ( pDocSh->IsDocShared() )
1183                     {
1184                         rSet.DisableItem( nWhich );
1185                     }
1186                 }
1187                 break;
1188             case SID_DATA_STREAMS:
1189             case SID_DATA_STREAMS_PLAY:
1190             case SID_DATA_STREAMS_STOP:
1191                 {
1192                     SvtMiscOptions aMiscOptions;
1193                     if ( !aMiscOptions.IsExperimentalMode() )
1194                         rSet.DisableItem( nWhich );
1195                 }
1196                 break;
1197             case SID_TEXT_TO_COLUMNS:
1198                 {
1199                     ScRange aRange;
1200                     if ( !lcl_GetTextToColumnsRange( pData, aRange, true ) )
1201                     {
1202                         rSet.DisableItem( nWhich );
1203                     }
1204                 }
1205                 break;
1206 #if !ENABLE_ORCUS
1207             case SID_MANAGE_XML_SOURCE:
1208                 rSet.DisableItem(nWhich);
1209             break;
1210 #endif
1211         }
1212         nWhich = aIter.NextWhich();
1213     }
1214 }
1215
1216 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */