basctl/source/basicide/basides1.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 <memory>
  21 #include <iderid.hxx>
  22 #include <strings.hrc>
  23 #include <helpids.h>
  24
  25 #include "baside2.hxx"
  26 #include <baside3.hxx>
  27 #include <basidesh.hxx>
  28 #include <basobj.hxx>
  29 #include <docsignature.hxx>
  30 #include <iderdll.hxx>
  31 #include "iderdll2.hxx"
  32 #include <localizationmgr.hxx>
  33 #include <managelang.hxx>
  34 #include <ColorSchemeDialog.hxx>
  35
  36 #include <basic/basmgr.hxx>
  37 #include <com/sun/star/script/ModuleType.hpp>
  38 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  39 #include <com/sun/star/script/XLibraryContainer2.hpp>
  40 #include <com/sun/star/frame/XLayoutManager.hpp>
  41 #include <svl/srchdefs.hxx>
  42 #include <sal/log.hxx>
  43 #include <osl/diagnose.h>
  44 #include <sfx2/app.hxx>
  45 #include <sfx2/bindings.hxx>
  46 #include <sfx2/childwin.hxx>
  47 #include <sfx2/dinfdlg.hxx>
  48 #include <sfx2/minfitem.hxx>
  49 #include <sfx2/request.hxx>
  50 #include <sfx2/viewfrm.hxx>
  51 #include <svx/svxids.hrc>
  52 #include <svl/eitem.hxx>
  53 #include <svl/intitem.hxx>
  54 #include <svl/visitem.hxx>
  55 #include <svl/whiter.hxx>
  56 #include <vcl/texteng.hxx>
  57 #include <vcl/textview.hxx>
  58 #include <vcl/svapp.hxx>
  59 #include <vcl/weld.hxx>
  60 #include <svx/zoomsliderctrl.hxx>
  61 #include <svx/zoomslideritem.hxx>
  62 #include <basegfx/utils/zoomtools.hxx>
  63 #include <officecfg/Office/BasicIDE.hxx>
  64
  65 constexpr sal_Int32 TAB_HEIGHT_MARGIN = 10;
  66
  67 namespace basctl
  68 {
  69
  70 using namespace ::com::sun::star;
  71 using namespace ::com::sun::star::uno;
  72 using namespace ::com::sun::star::frame;
  73
  74 static void lcl_InvalidateZoomSlots(SfxBindings* pBindings)
  75 {
  76     if (!pBindings)
  77         return;
  78
  79     static sal_uInt16 const aInval[] = {
  80         SID_ZOOM_OUT, SID_ZOOM_IN, SID_ATTR_ZOOMSLIDER, 0
  81     };
  82     pBindings->Invalidate(aInval);
  83 }
  84
  85 void Shell::ExecuteSearch( SfxRequest& rReq )
  86 {
  87     if ( !pCurWin )
  88         return;
  89
  90     const SfxItemSet* pArgs = rReq.GetArgs();
  91     sal_uInt16 nSlot = rReq.GetSlot();
  92
  93     // if searching has not been done before this time
  94     if (nSlot == SID_BASICIDE_REPEAT_SEARCH && !mpSearchItem)
  95     {
  96         rReq.SetReturnValue(SfxBoolItem(nSlot, false));
  97         nSlot = 0;
  98     }
  99
 100     switch ( nSlot )
 101     {
 102         case SID_SEARCH_OPTIONS:
 103             break;
 104         case SID_SEARCH_ITEM:
 105             mpSearchItem.reset(pArgs->Get(SID_SEARCH_ITEM).Clone());
 106             break;
 107         case FID_SEARCH_ON:
 108             mbJustOpened = true;
 109             GetViewFrame().GetBindings().Invalidate(SID_SEARCH_ITEM);
 110             break;
 111         case SID_BASICIDE_REPEAT_SEARCH:
 112         case FID_SEARCH_NOW:
 113         {
 114             if (!pCurWin->HasActiveEditor())
 115                 break;
 116
 117             // If it is a repeat searching
 118             if ( nSlot == SID_BASICIDE_REPEAT_SEARCH )
 119             {
 120                 if( !mpSearchItem )
 121                     mpSearchItem.reset( new SvxSearchItem( SID_SEARCH_ITEM ));
 122             }
 123             else
 124             {
 125                 // Get SearchItem from request if it is the first searching
 126                 if ( pArgs )
 127                 {
 128                     mpSearchItem.reset(pArgs->Get(SID_SEARCH_ITEM).Clone());
 129                 }
 130             }
 131
 132             sal_Int32 nFound = 0;
 133
 134             if ( mpSearchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL )
 135             {
 136                 sal_uInt16 nActModWindows = 0;
 137                 for (auto const& window : aWindowTable)
 138                 {
 139                     BaseWindow* pWin = window.second;
 140                     if (pWin->HasActiveEditor())
 141                         nActModWindows++;
 142                 }
 143
 144                 bool bAllModules = nActModWindows <= 1;
 145                 if (!bAllModules)
 146                 {
 147                     std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(pCurWin ? pCurWin->GetFrameWeld() : nullptr,
 148                                                                    VclMessageType::Question, VclButtonsType::YesNo,
 149                                                                    IDEResId(RID_STR_SEARCHALLMODULES)));
 150                     xQueryBox->set_default_response(RET_YES);
 151                     bAllModules = xQueryBox->run() == RET_YES;
 152                 }
 153
 154                 if (bAllModules)
 155                 {
 156                     for (auto const& window : aWindowTable)
 157                     {
 158                         BaseWindow* pWin = window.second;
 159                         nFound += pWin->StartSearchAndReplace( *mpSearchItem );
 160                     }
 161                 }
 162                 else
 163                     nFound = pCurWin->StartSearchAndReplace( *mpSearchItem );
 164
 165                 OUString aReplStr(IDEResId(RID_STR_SEARCHREPLACES));
 166                 aReplStr = aReplStr.replaceAll("XX", OUString::number(nFound));
 167
 168                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pCurWin->GetFrameWeld(),
 169                                                               VclMessageType::Info, VclButtonsType::Ok,
 170                                                               aReplStr));
 171                 xInfoBox->run();
 172             }
 173             else
 174             {
 175                 bool bCanceled = false;
 176                 nFound = pCurWin->StartSearchAndReplace( *mpSearchItem );
 177                 if ( !nFound && !mpSearchItem->GetSelection() )
 178                 {
 179                     // search other modules...
 180                     bool bChangeCurWindow = false;
 181                     auto it = std::find_if(aWindowTable.cbegin(), aWindowTable.cend(),
 182                                            [this](const WindowTable::value_type& item) { return item.second == pCurWin; });
 183                     if (it != aWindowTable.cend())
 184                         ++it;
 185                     BaseWindow* pWin = it != aWindowTable.cend() ? it->second.get() : nullptr;
 186
 187                     bool bSearchedFromStart = false;
 188                     while ( !nFound && !bCanceled && ( pWin || !bSearchedFromStart ) )
 189                     {
 190                         if ( !pWin )
 191                         {
 192                             SfxViewFrame& rViewFrame = GetViewFrame();
 193                             SfxChildWindow* pChildWin = rViewFrame.GetChildWindow(SID_SEARCH_DLG);
 194                             auto xParent = pChildWin ? pChildWin->GetController() : nullptr;
 195
 196                             std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(xParent ? xParent->getDialog() : nullptr,
 197                                                                            VclMessageType::Question, VclButtonsType::YesNo,
 198                                                                            IDEResId(RID_STR_SEARCHFROMSTART)));
 199                             xQueryBox->set_default_response(RET_YES);
 200                             if (xQueryBox->run() == RET_YES)
 201                             {
 202                                 it = aWindowTable.cbegin();
 203                                 if ( it != aWindowTable.cend() )
 204                                     pWin = it->second;
 205                                 bSearchedFromStart = true;
 206                             }
 207                             else
 208                                 bCanceled = true;
 209                         }
 210
 211                         if (pWin && pWin->HasActiveEditor())
 212                         {
 213                             if ( pWin != pCurWin )
 214                             {
 215                                 if ( pCurWin )
 216                                     pWin->SetSizePixel( pCurWin->GetSizePixel() );
 217                                 nFound = pWin->StartSearchAndReplace( *mpSearchItem, true );
 218                             }
 219                             if ( nFound )
 220                             {
 221                                 bChangeCurWindow = true;
 222                                 break;
 223                             }
 224                         }
 225                         if ( pWin && ( pWin != pCurWin ) )
 226                         {
 227                             if ( it != aWindowTable.cend() )
 228                                 ++it;
 229                             pWin = it != aWindowTable.cend() ? it->second.get() : nullptr;
 230                         }
 231                         else
 232                             pWin = nullptr;
 233                     }
 234                     if ( !nFound && bSearchedFromStart )
 235                         nFound = pCurWin->StartSearchAndReplace( *mpSearchItem, true );
 236                     if ( bChangeCurWindow )
 237                         SetCurWindow( pWin, true );
 238                 }
 239                 if ( !nFound && !bCanceled )
 240                 {
 241                     std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pCurWin->GetFrameWeld(),
 242                                                                   VclMessageType::Info, VclButtonsType::Ok,
 243                                                                   IDEResId(RID_STR_SEARCHNOTFOUND)));
 244                     xInfoBox->run();
 245                 }
 246             }
 247
 248             rReq.Done();
 249             break;
 250         }
 251         default:
 252             pCurWin->ExecuteCommand( rReq );
 253     }
 254 }
 255
 256 void Shell::ExecuteCurrent( SfxRequest& rReq )
 257 {
 258     if ( !pCurWin )
 259         return;
 260
 261     switch ( rReq.GetSlot() )
 262     {
 263         case SID_BASICIDE_HIDECURPAGE:
 264         {
 265             pCurWin->StoreData();
 266             RemoveWindow( pCurWin, false );
 267         }
 268         break;
 269         case SID_BASICIDE_RENAMECURRENT:
 270         {
 271             pTabBar->StartEditMode( pTabBar->GetCurPageId() );
 272         }
 273         break;
 274         case SID_UNDO:
 275         case SID_REDO:
 276             if ( GetUndoManager() && pCurWin->AllowUndo() )
 277                 GetViewFrame().ExecuteSlot( rReq );
 278             break;
 279         default:
 280             pCurWin->ExecuteCommand( rReq );
 281     }
 282 }
 283
 284 //  no matter who's at the top, influence on the shell:
 285 void Shell::ExecuteGlobal( SfxRequest& rReq )
 286 {
 287     sal_uInt16 nSlot = rReq.GetSlot();
 288     switch ( nSlot )
 289     {
 290         case SID_NEWDOCDIRECT:
 291         {
 292             // we do not have a new document factory,
 293             // so just forward to a fallback method.
 294             SfxGetpApp()->ExecuteSlot(rReq);
 295         }
 296         break;
 297
 298         case SID_BASICSTOP:
 299         {
 300             // maybe do not simply stop if on breakpoint!
 301             if (ModulWindow* pMCurWin = dynamic_cast<ModulWindow*>(pCurWin.get()))
 302                 pMCurWin->BasicStop();
 303             StopBasic();
 304         }
 305         break;
 306
 307         case SID_SAVEDOC:
 308         {
 309             if ( pCurWin )
 310             {
 311                 // rewrite date into the BASIC
 312                 StoreAllWindowData();
 313
 314                 // document basic
 315                 ScriptDocument aDocument( pCurWin->GetDocument() );
 316                 if ( aDocument.isDocument() )
 317                 {
 318                     uno::Reference< task::XStatusIndicator > xStatusIndicator;
 319
 320                     const SfxUnoAnyItem* pStatusIndicatorItem = rReq.GetArg<SfxUnoAnyItem>(SID_PROGRESS_STATUSBAR_CONTROL);
 321                     if ( pStatusIndicatorItem )
 322                         OSL_VERIFY( pStatusIndicatorItem->GetValue() >>= xStatusIndicator );
 323                     else
 324                     {
 325                         // get statusindicator
 326                         SfxViewFrame *pFrame_ = GetFrame();
 327                         if ( pFrame_ )
 328                         {
 329                             uno::Reference< task::XStatusIndicatorFactory > xStatFactory(
 330                                                                         pFrame_->GetFrame().GetFrameInterface(),
 331                                                                         uno::UNO_QUERY );
 332                             if( xStatFactory.is() )
 333                                 xStatusIndicator = xStatFactory->createStatusIndicator();
 334                         }
 335
 336                         if ( xStatusIndicator.is() )
 337                             rReq.AppendItem( SfxUnoAnyItem( SID_PROGRESS_STATUSBAR_CONTROL, uno::Any( xStatusIndicator ) ) );
 338                     }
 339
 340                     aDocument.saveDocument( xStatusIndicator );
 341                 }
 342
 343                 if (SfxBindings* pBindings = GetBindingsPtr())
 344                 {
 345                     pBindings->Invalidate( SID_DOC_MODIFIED );
 346                     pBindings->Invalidate( SID_SAVEDOC );
 347                     pBindings->Invalidate( SID_SIGNATURE );
 348                 }
 349             }
 350         }
 351         break;
 352         case SID_BASICIDE_MODULEDLG:
 353         {
 354             if ( rReq.GetArgs() )
 355             {
 356                 const SfxUInt16Item &rTabId = rReq.GetArgs()->Get(SID_BASICIDE_ARG_TABID );
 357                 Organize(rReq.GetFrameWeld(), nullptr, rTabId.GetValue());
 358             }
 359             else
 360                 Organize(rReq.GetFrameWeld(), nullptr, 0);
 361         }
 362         break;
 363         case SID_BASICIDE_CHOOSEMACRO:
 364         {
 365             ChooseMacro(rReq.GetFrameWeld(), nullptr);
 366         }
 367         break;
 368         case SID_BASICIDE_CREATEMACRO:
 369         case SID_BASICIDE_EDITMACRO:
 370         {
 371             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 372             const SfxMacroInfoItem& rInfo = rReq.GetArgs()->Get(SID_BASICIDE_ARG_MACROINFO );
 373             BasicManager* pBasMgr = const_cast<BasicManager*>(rInfo.GetBasicManager());
 374             DBG_ASSERT( pBasMgr, "Nothing selected in basic tree?" );
 375
 376             ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 377
 378             StartListening(*pBasMgr, DuplicateHandling::Prevent /* log on only once */);
 379             OUString aLibName( rInfo.GetLib() );
 380             if ( aLibName.isEmpty() )
 381                 aLibName = "Standard" ;
 382             StarBASIC* pBasic = pBasMgr->GetLib( aLibName );
 383             if ( !pBasic )
 384             {
 385                 // load module and dialog library (if not loaded)
 386                 aDocument.loadLibraryIfExists( E_SCRIPTS, aLibName );
 387                 aDocument.loadLibraryIfExists( E_DIALOGS, aLibName );
 388
 389                 // get Basic
 390                 pBasic = pBasMgr->GetLib( aLibName );
 391             }
 392             DBG_ASSERT( pBasic, "No Basic!" );
 393
 394             SetCurLib( aDocument, aLibName );
 395
 396             if ( pBasic && rReq.GetSlot() == SID_BASICIDE_CREATEMACRO )
 397             {
 398                 SbModule* pModule = pBasic->FindModule( rInfo.GetModule() );
 399                 if ( !pModule )
 400                 {
 401                     if ( !rInfo.GetModule().isEmpty() || pBasic->GetModules().empty() )
 402                     {
 403                         const OUString& aModName = rInfo.GetModule();
 404
 405                         OUString sModuleCode;
 406                         if ( aDocument.createModule( aLibName, aModName, false, sModuleCode ) )
 407                             pModule = pBasic->FindModule( aModName );
 408                     }
 409                     else
 410                         pModule = pBasic->GetModules().front().get();
 411                 }
 412                 DBG_ASSERT( pModule, "No Module!" );
 413                 if ( pModule && !pModule->GetMethods()->Find( rInfo.GetMethod(), SbxClassType::Method ) )
 414                     CreateMacro( pModule, rInfo.GetMethod() );
 415             }
 416             SfxViewFrame& rViewFrame = GetViewFrame();
 417             rViewFrame.ToTop();
 418             VclPtr<ModulWindow> pWin = FindBasWin( aDocument, aLibName, rInfo.GetModule(), true );
 419             DBG_ASSERT( pWin, "Edit/Create Macro: Window was not created/found!" );
 420             SetCurWindow( pWin, true );
 421             pWin->EditMacro( rInfo.GetMethod() );
 422         }
 423         break;
 424
 425         case SID_BASICIDE_OBJCAT:
 426         {
 427             // Toggle the visibility of the object catalog
 428             bool bVisible = aObjectCatalog->IsVisible();
 429             aObjectCatalog->Show(!bVisible);
 430             if (pLayout)
 431                 pLayout->ArrangeWindows();
 432             // refresh the button state
 433             if (SfxBindings* pBindings = GetBindingsPtr())
 434                 pBindings->Invalidate(SID_BASICIDE_OBJCAT);
 435
 436             std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
 437             officecfg::Office::BasicIDE::EditorSettings::ObjectCatalog::set(!bVisible, batch);
 438             batch->commit();
 439         }
 440         break;
 441
 442         case SID_BASICIDE_WATCH:
 443         {
 444             // Toggling the watch window can only be done from a ModulWindow
 445             if (!dynamic_cast<ModulWindowLayout*>(pLayout.get()))
 446                 return;
 447
 448             bool bVisible = pModulLayout->IsWatchWindowVisible();
 449             pModulLayout->ShowWatchWindow(!bVisible);
 450             if (SfxBindings* pBindings = GetBindingsPtr())
 451                 pBindings->Invalidate(SID_BASICIDE_WATCH);
 452
 453             std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
 454             officecfg::Office::BasicIDE::EditorSettings::WatchWindow::set(!bVisible, batch);
 455             batch->commit();
 456         }
 457         break;
 458
 459         case SID_BASICIDE_STACK:
 460         {
 461             // Toggling the stack window can only be done from a ModulWindow
 462             if (!dynamic_cast<ModulWindowLayout*>(pLayout.get()))
 463                 return;
 464
 465             bool bVisible = pModulLayout->IsStackWindowVisible();
 466             pModulLayout->ShowStackWindow(!bVisible);
 467             if (SfxBindings* pBindings = GetBindingsPtr())
 468                 pBindings->Invalidate(SID_BASICIDE_STACK);
 469
 470             std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
 471             officecfg::Office::BasicIDE::EditorSettings::StackWindow::set(!bVisible, batch);
 472             batch->commit();
 473         }
 474         break;
 475
 476         case SID_BASICIDE_NAMECHANGEDONTAB:
 477         {
 478             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 479             const SfxUInt16Item &rTabId = rReq.GetArgs()->Get(SID_BASICIDE_ARG_TABID );
 480             const SfxStringItem &rModName = rReq.GetArgs()->Get(SID_BASICIDE_ARG_MODULENAME );
 481             if ( aWindowTable.find( rTabId.GetValue() ) !=  aWindowTable.end() )
 482             {
 483                 VclPtr<BaseWindow> pWin = aWindowTable[ rTabId.GetValue() ];
 484                 const OUString& aNewName( rModName.GetValue() );
 485                 OUString aOldName( pWin->GetName() );
 486                 if ( aNewName != aOldName )
 487                 {
 488                     bool bRenameOk = false;
 489                     if (ModulWindow* pModWin = dynamic_cast<ModulWindow*>(pWin.get()))
 490                     {
 491                         const OUString& aLibName = pModWin->GetLibName();
 492                         ScriptDocument aDocument( pWin->GetDocument() );
 493
 494                         if (RenameModule(pModWin->GetFrameWeld(), aDocument, aLibName, aOldName, aNewName))
 495                         {
 496                             bRenameOk = true;
 497                             // Because we listen for container events for script
 498                             // modules, rename will delete the 'old' window
 499                             // pWin has been invalidated, restore now
 500                             pWin = FindBasWin( aDocument, aLibName, aNewName, true );
 501                         }
 502
 503                     }
 504                     else if (DialogWindow* pDlgWin = dynamic_cast<DialogWindow*>(pWin.get()))
 505                     {
 506                         bRenameOk = pDlgWin->RenameDialog( aNewName );
 507                     }
 508                     if ( bRenameOk )
 509                     {
 510                         MarkDocumentModified( pWin->GetDocument() );
 511                     }
 512                     else
 513                     {
 514                         // set old name in TabWriter
 515                         sal_uInt16 nId = GetWindowId( pWin );
 516                         DBG_ASSERT( nId, "No entry in Tabbar!" );
 517                         if ( nId )
 518                             pTabBar->SetPageText( nId, aOldName );
 519                     }
 520                 }
 521
 522                 // set focus to current window
 523                 pWin->GrabFocus();
 524             }
 525         }
 526         break;
 527         case SID_BASICIDE_STOREMODULESOURCE:
 528         case SID_BASICIDE_UPDATEMODULESOURCE:
 529         {
 530             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 531             const SfxMacroInfoItem& rInfo = rReq.GetArgs()->Get(SID_BASICIDE_ARG_MACROINFO );
 532             BasicManager* pBasMgr = const_cast<BasicManager*>(rInfo.GetBasicManager());
 533             DBG_ASSERT( pBasMgr, "Store source: No BasMgr?" );
 534             ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 535             VclPtr<ModulWindow> pWin = FindBasWin( aDocument, rInfo.GetLib(), rInfo.GetModule(), false, true );
 536             if ( pWin )
 537             {
 538                 if ( rReq.GetSlot() == SID_BASICIDE_STOREMODULESOURCE )
 539                     pWin->StoreData();
 540                 else
 541                     pWin->UpdateData();
 542             }
 543         }
 544         break;
 545         case SID_BASICIDE_STOREALLMODULESOURCES:
 546         case SID_BASICIDE_UPDATEALLMODULESOURCES:
 547         {
 548             for (auto const& window : aWindowTable)
 549             {
 550                 BaseWindow* pWin = window.second;
 551                 if (!pWin->IsSuspended() && dynamic_cast<ModulWindow*>(pWin))
 552                 {
 553                     if ( rReq.GetSlot() == SID_BASICIDE_STOREALLMODULESOURCES )
 554                         pWin->StoreData();
 555                     else
 556                         pWin->UpdateData();
 557                 }
 558             }
 559         }
 560         break;
 561         case SID_BASICIDE_LIBSELECTED:
 562         case SID_BASICIDE_LIBREMOVED:
 563         case SID_BASICIDE_LIBLOADED:
 564         {
 565             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 566             const SfxUnoAnyItem& rShellItem = rReq.GetArgs()->Get( SID_BASICIDE_ARG_DOCUMENT_MODEL );
 567             uno::Reference< frame::XModel > xModel( rShellItem.GetValue(), UNO_QUERY );
 568             ScriptDocument aDocument( xModel.is() ? ScriptDocument( xModel ) : ScriptDocument::getApplicationScriptDocument() );
 569             const SfxStringItem& rLibNameItem = rReq.GetArgs()->Get( SID_BASICIDE_ARG_LIBNAME );
 570             const OUString& aLibName( rLibNameItem.GetValue() );
 571
 572             if ( nSlot == SID_BASICIDE_LIBSELECTED )
 573             {
 574                 // load module and dialog library (if not loaded)
 575                 aDocument.loadLibraryIfExists( E_SCRIPTS, aLibName );
 576                 aDocument.loadLibraryIfExists( E_DIALOGS, aLibName );
 577
 578                 // check password, if library is password protected and not verified
 579                 bool bOK = true;
 580                 Reference< script::XLibraryContainer > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ) );
 581                 if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
 582                 {
 583                     Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
 584                     if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) )
 585                     {
 586                         OUString aPassword;
 587                         bOK = QueryPassword(rReq.GetFrameWeld(), xModLibContainer, aLibName, aPassword);
 588                     }
 589                 }
 590
 591                 if ( bOK )
 592                 {
 593                     SetCurLib( aDocument, aLibName, true, false );
 594                 }
 595                 else
 596                 {
 597                     // adjust old value...
 598                     if (SfxBindings* pBindings = GetBindingsPtr())
 599                         pBindings->Invalidate(SID_BASICIDE_LIBSELECTOR, true);
 600                 }
 601             }
 602             else if ( nSlot == SID_BASICIDE_LIBREMOVED )
 603             {
 604                 if ( m_aCurLibName.isEmpty() || ( aDocument == m_aCurDocument && aLibName == m_aCurLibName ) )
 605                 {
 606                     RemoveWindows( aDocument, aLibName );
 607                     if ( aDocument == m_aCurDocument && aLibName == m_aCurLibName )
 608                     {
 609                         m_aCurDocument = ScriptDocument::getApplicationScriptDocument();
 610                         m_aCurLibName.clear();
 611                         // no UpdateWindows!
 612                         if (SfxBindings* pBindings = GetBindingsPtr())
 613                             pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR );
 614                     }
 615                 }
 616             }
 617             else    // Loaded...
 618                 UpdateWindows();
 619         }
 620         break;
 621         case SID_BASICIDE_NEWMODULE:
 622         {
 623             VclPtr<ModulWindow> pWin = CreateBasWin( m_aCurDocument, m_aCurLibName, OUString() );
 624             DBG_ASSERT( pWin, "New Module: Could not create window!" );
 625             SetCurWindow( pWin, true );
 626         }
 627         break;
 628         case SID_BASICIDE_NEWDIALOG:
 629         {
 630             VclPtr<DialogWindow> pWin = CreateDlgWin( m_aCurDocument, m_aCurLibName, OUString() );
 631             DBG_ASSERT( pWin, "New Module: Could not create window!" );
 632             SetCurWindow( pWin, true );
 633         }
 634         break;
 635         case SID_BASICIDE_SBXRENAMED:
 636         {
 637             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 638         }
 639         break;
 640         case SID_BASICIDE_SBXINSERTED:
 641         {
 642             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 643             const SbxItem& rSbxItem = rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX );
 644             const ScriptDocument& aDocument( rSbxItem.GetDocument() );
 645             const OUString& aLibName( rSbxItem.GetLibName() );
 646             const OUString& aName( rSbxItem.GetName() );
 647             if ( m_aCurLibName.isEmpty() || ( aDocument == m_aCurDocument && aLibName == m_aCurLibName ) )
 648             {
 649                 if ( rSbxItem.GetSbxType() == SBX_TYPE_MODULE )
 650                     FindBasWin( aDocument, aLibName, aName, true );
 651                 else if ( rSbxItem.GetSbxType() == SBX_TYPE_DIALOG )
 652                     FindDlgWin( aDocument, aLibName, aName, true );
 653             }
 654         }
 655         break;
 656         case SID_BASICIDE_SBXDELETED:
 657         {
 658             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 659             const SbxItem& rSbxItem = rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX );
 660             const ScriptDocument& aDocument( rSbxItem.GetDocument() );
 661             VclPtr<BaseWindow> pWin = FindWindow( aDocument, rSbxItem.GetLibName(), rSbxItem.GetName(), rSbxItem.GetSbxType(), true );
 662             if ( pWin )
 663                 RemoveWindow( pWin, true );
 664         }
 665         break;
 666         case SID_BASICIDE_SHOWSBX:
 667         {
 668             DBG_ASSERT( rReq.GetArgs(), "arguments expected" );
 669             const SbxItem& rSbxItem = rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX );
 670             const ScriptDocument& aDocument( rSbxItem.GetDocument() );
 671             const OUString& aLibName( rSbxItem.GetLibName() );
 672             const OUString& aName( rSbxItem.GetName() );
 673             SetCurLib( aDocument, aLibName );
 674             BaseWindow* pWin = nullptr;
 675             if ( rSbxItem.GetSbxType() == SBX_TYPE_DIALOG )
 676             {
 677                 pWin = FindDlgWin( aDocument, aLibName, aName, true );
 678             }
 679             else if ( rSbxItem.GetSbxType() == SBX_TYPE_MODULE )
 680             {
 681                 pWin = FindBasWin( aDocument, aLibName, aName, true );
 682             }
 683             else if ( rSbxItem.GetSbxType() == SBX_TYPE_METHOD )
 684             {
 685                 pWin = FindBasWin( aDocument, aLibName, aName, true );
 686                 static_cast<ModulWindow*>(pWin)->EditMacro( rSbxItem.GetMethodName() );
 687             }
 688             DBG_ASSERT( pWin, "Window was not created!" );
 689             SetCurWindow( pWin, true );
 690             pTabBar->MakeVisible( pTabBar->GetCurPageId() );
 691         }
 692         break;
 693         case SID_BASICIDE_SHOWWINDOW:
 694         {
 695             std::unique_ptr< ScriptDocument > pDocument;
 696
 697             const SfxStringItem* pDocumentItem = rReq.GetArg<SfxStringItem>(SID_BASICIDE_ARG_DOCUMENT);
 698             if ( pDocumentItem )
 699             {
 700                 const OUString& sDocumentCaption = pDocumentItem->GetValue();
 701                 if ( !sDocumentCaption.isEmpty() )
 702                     pDocument.reset( new ScriptDocument( ScriptDocument::getDocumentWithURLOrCaption( sDocumentCaption ) ) );
 703             }
 704
 705             const SfxUnoAnyItem* pDocModelItem = rReq.GetArg<SfxUnoAnyItem>(SID_BASICIDE_ARG_DOCUMENT_MODEL);
 706             if (!pDocument && pDocModelItem)
 707             {
 708                 uno::Reference< frame::XModel > xModel( pDocModelItem->GetValue(), UNO_QUERY );
 709                 if ( xModel.is() )
 710                     pDocument.reset( new ScriptDocument( xModel ) );
 711             }
 712
 713             if (!pDocument)
 714                 break;
 715
 716             const SfxStringItem* pLibNameItem = rReq.GetArg<SfxStringItem>(SID_BASICIDE_ARG_LIBNAME);
 717             if ( !pLibNameItem )
 718                 break;
 719
 720             OUString aLibName( pLibNameItem->GetValue() );
 721             pDocument->loadLibraryIfExists( E_SCRIPTS, aLibName );
 722             SetCurLib( *pDocument, aLibName );
 723             const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_BASICIDE_ARG_NAME);
 724             if ( pNameItem )
 725             {
 726                 const OUString& aName( pNameItem->GetValue() );
 727                 OUString aModType( u"Module"_ustr );
 728                 OUString aType( aModType );
 729                 const SfxStringItem* pTypeItem = rReq.GetArg<SfxStringItem>(SID_BASICIDE_ARG_TYPE);
 730                 if ( pTypeItem )
 731                     aType = pTypeItem->GetValue();
 732
 733                 BaseWindow* pWin = nullptr;
 734                 if ( aType == aModType )
 735                     pWin = FindBasWin( *pDocument, aLibName, aName );
 736                 else if ( aType == "Dialog" )
 737                     pWin = FindDlgWin( *pDocument, aLibName, aName );
 738
 739                 if ( pWin )
 740                 {
 741                     SetCurWindow( pWin, true );
 742                     if ( pTabBar )
 743                         pTabBar->MakeVisible( pTabBar->GetCurPageId() );
 744
 745                     if (ModulWindow* pModWin = dynamic_cast<ModulWindow*>(pWin))
 746                     {
 747                         const SfxUInt32Item* pLineItem = rReq.GetArg<SfxUInt32Item>(SID_BASICIDE_ARG_LINE);
 748                         if ( pLineItem )
 749                         {
 750                             pModWin->AssertValidEditEngine();
 751                             TextView* pTextView = pModWin->GetEditView();
 752                             if ( pTextView )
 753                             {
 754                                 TextEngine* pTextEngine = pTextView->GetTextEngine();
 755                                 if ( pTextEngine )
 756                                 {
 757                                     sal_uInt32 nLine = pLineItem->GetValue();
 758                                     sal_uInt32 nLineCount = 0;
 759                                     for ( sal_uInt32 i = 0, nCount = pTextEngine->GetParagraphCount(); i < nCount; ++i )
 760                                         nLineCount += pTextEngine->GetLineCount( i );
 761                                     if ( nLine > nLineCount )
 762                                         nLine = nLineCount;
 763                                     if ( nLine > 0 )
 764                                         --nLine;
 765
 766                                     // scroll window and set selection
 767                                     tools::Long nVisHeight = pModWin->GetOutputSizePixel().Height();
 768                                     tools::Long nTextHeight = pTextEngine->GetTextHeight();
 769                                     if ( nTextHeight > nVisHeight )
 770                                     {
 771                                         tools::Long nMaxY = nTextHeight - nVisHeight;
 772                                         tools::Long nOldY = pTextView->GetStartDocPos().Y();
 773                                         tools::Long nNewY = nLine * pTextEngine->GetCharHeight() - nVisHeight / 2;
 774                                         nNewY = std::min( nNewY, nMaxY );
 775                                         pTextView->Scroll( 0, -( nNewY - nOldY ) );
 776                                         pTextView->ShowCursor( false );
 777                                         pModWin->GetEditVScrollBar().SetThumbPos( pTextView->GetStartDocPos().Y() );
 778                                     }
 779                                     sal_uInt16 nCol1 = 0, nCol2 = 0;
 780                                     const SfxUInt16Item* pCol1Item = rReq.GetArg<SfxUInt16Item>(SID_BASICIDE_ARG_COLUMN1);
 781                                     if ( pCol1Item )
 782                                     {
 783                                         nCol1 = pCol1Item->GetValue();
 784                                         if ( nCol1 > 0 )
 785                                             --nCol1;
 786                                         nCol2 = nCol1;
 787                                     }
 788                                     const SfxUInt16Item* pCol2Item = rReq.GetArg<SfxUInt16Item>(SID_BASICIDE_ARG_COLUMN2);
 789                                     if ( pCol2Item )
 790                                     {
 791                                         nCol2 = pCol2Item->GetValue();
 792                                         if ( nCol2 > 0 )
 793                                             --nCol2;
 794                                     }
 795                                     TextSelection aSel( TextPaM( nLine, nCol1 ), TextPaM( nLine, nCol2 ) );
 796                                     pTextView->SetSelection( aSel );
 797                                     pTextView->ShowCursor();
 798                                     vcl::Window* pWindow_ = pTextView->GetWindow();
 799                                     if ( pWindow_ )
 800                                         pWindow_->GrabFocus();
 801                                 }
 802                             }
 803                         }
 804                     }
 805                 }
 806             }
 807             rReq.Done();
 808         }
 809         break;
 810
 811         case SID_BASICIDE_COLOR_SCHEME_DLG:
 812         {
 813             ModulWindowLayout* pMyLayout = dynamic_cast<ModulWindowLayout*>(pLayout.get());
 814             if (!pMyLayout)
 815                 return;
 816
 817             OUString curScheme = pMyLayout->GetActiveColorSchemeId();
 818             auto xDlg = std::make_shared<ColorSchemeDialog>(pCurWin ? pCurWin->GetFrameWeld() : nullptr,
 819                                                             pMyLayout);
 820             weld::DialogController::runAsync(xDlg, [xDlg, pMyLayout, curScheme](sal_Int32 nResult){
 821                 OUString sNewScheme(xDlg->GetColorSchemeId());
 822                 // If the user canceled the dialog, restores the original color scheme
 823                 if (nResult != RET_OK)
 824                 {
 825                     if (curScheme != sNewScheme)
 826                         pMyLayout->ApplyColorSchemeToCurrentWindow(curScheme);
 827                 }
 828
 829                 // If the user selects OK, apply the color scheme to all open ModulWindow
 830                 if (nResult == RET_OK)
 831                 {
 832                     // Set the global color scheme in ModulWindowLayout and update definitions in SyntaxColors
 833                     pMyLayout->ApplyColorSchemeToCurrentWindow(sNewScheme);
 834
 835                     // Update color scheme for all windows
 836                     for (auto const& window : GetShell()->GetWindowTable())
 837                     {
 838                         ModulWindow* pModuleWindow = dynamic_cast<ModulWindow*>(window.second.get());
 839                         if (pModuleWindow)
 840                         {
 841                             // We need to set the current scheme for each window
 842                             pModuleWindow->SetEditorColorScheme(sNewScheme);
 843                         }
 844                     }
 845
 846                     // Update registry with the new color scheme ID
 847                     std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
 848                     officecfg::Office::BasicIDE::EditorSettings::ColorScheme::set(sNewScheme, batch);
 849                     batch->commit();
 850                 }
 851             });
 852         }
 853         break;
 854
 855         case SID_BASICIDE_MANAGE_LANG:
 856         {
 857             auto xRequest = std::make_shared<SfxRequest>(rReq);
 858             rReq.Ignore(); // the 'old' request is not relevant any more
 859             auto xDlg = std::make_shared<ManageLanguageDialog>(pCurWin ? pCurWin->GetFrameWeld() : nullptr, m_pCurLocalizationMgr);
 860             weld::DialogController::runAsync(xDlg, [xRequest=std::move(xRequest)](sal_Int32 /*nResult*/){
 861                     xRequest->Done();
 862                 });
 863         }
 864         break;
 865
 866         case SID_ATTR_ZOOMSLIDER:
 867         {
 868             const SfxItemSet *pArgs = rReq.GetArgs();
 869             const SfxPoolItem* pItem;
 870
 871             if (pArgs && pArgs->GetItemState(SID_ATTR_ZOOMSLIDER, true, &pItem ) == SfxItemState::SET)
 872                 SetGlobalEditorZoomLevel(static_cast<const SvxZoomSliderItem*>(pItem)->GetValue());
 873
 874             lcl_InvalidateZoomSlots(GetBindingsPtr());
 875         }
 876         break;
 877
 878         case SID_ZOOM_IN:
 879         case SID_ZOOM_OUT:
 880         {
 881             const sal_uInt16 nOldZoom = GetCurrentZoomSliderValue();
 882             sal_uInt16 nNewZoom;
 883             if (nSlot == SID_ZOOM_IN)
 884                 nNewZoom = std::min<sal_uInt16>(GetMaxZoom(), basegfx::zoomtools::zoomIn(nOldZoom));
 885             else
 886                 nNewZoom = std::max<sal_uInt16>(GetMinZoom(), basegfx::zoomtools::zoomOut(nOldZoom));
 887             SetGlobalEditorZoomLevel(nNewZoom);
 888             lcl_InvalidateZoomSlots(GetBindingsPtr());
 889         }
 890         break;
 891
 892         default:
 893             if (pLayout)
 894                 pLayout->ExecuteGlobal(rReq);
 895             if (pCurWin)
 896                 pCurWin->ExecuteGlobal(rReq);
 897             break;
 898     }
 899 }
 900
 901 void Shell::GetState(SfxItemSet &rSet)
 902 {
 903     SfxWhichIter aIter(rSet);
 904     for ( sal_uInt16 nWh = aIter.FirstWhich(); nWh != 0; nWh = aIter.NextWhich() )
 905     {
 906         switch ( nWh )
 907         {
 908             case SID_NEWDOCDIRECT:
 909             {
 910                 // we do not have a new document factory,
 911                 // so just forward to a fallback method.
 912                 SfxGetpApp()->GetSlotState(nWh, nullptr, &rSet);
 913             }
 914             break;
 915             case SID_DOCINFO:
 916             case SID_NEWWINDOW:
 917             case SID_SAVEASDOC:
 918             {
 919                 rSet.DisableItem( nWh );
 920             }
 921             break;
 922             case SID_SAVEDOC:
 923             {
 924                 bool bDisable = false;
 925
 926                 if ( pCurWin )
 927                 {
 928                     if ( !pCurWin->IsModified() )
 929                     {
 930                         ScriptDocument aDocument( pCurWin->GetDocument() );
 931                         bDisable =  ( !aDocument.isAlive() )
 932                                 ||  ( aDocument.isDocument() ? !aDocument.isDocumentModified() : !IsAppBasicModified() );
 933                     }
 934                 }
 935                 else
 936                 {
 937                     bDisable = true;
 938                 }
 939
 940                 if ( bDisable )
 941                     rSet.DisableItem( nWh );
 942             }
 943             break;
 944             case SID_SIGNATURE:
 945             {
 946                 SignatureState nState = SignatureState::NOSIGNATURES;
 947                 if ( pCurWin )
 948                 {
 949                     DocumentSignature aSignature( pCurWin->GetDocument() );
 950                     nState = aSignature.getScriptingSignatureState();
 951                 }
 952                 rSet.Put( SfxUInt16Item( SID_SIGNATURE, static_cast<sal_uInt16>(nState) ) );
 953             }
 954             break;
 955             case SID_BASICIDE_MODULEDLG:
 956             {
 957                 if ( StarBASIC::IsRunning() )
 958                     rSet.DisableItem( nWh );
 959             }
 960             break;
 961
 962             case SID_BASICIDE_OBJCAT:
 963             {
 964                 if (pLayout)
 965                     rSet.Put(SfxBoolItem(nWh, aObjectCatalog->IsVisible()));
 966                 else
 967                     rSet.Put(SfxVisibilityItem(nWh, false));
 968             }
 969             break;
 970
 971             case SID_BASICIDE_WATCH:
 972             {
 973                 if (pLayout)
 974                 {
 975                     rSet.Put(SfxBoolItem(nWh, pModulLayout->IsWatchWindowVisible()));
 976                     // Disable command if the visible window is not a ModulWindow
 977                     if (!dynamic_cast<ModulWindowLayout*>(pLayout.get()))
 978                         rSet.DisableItem(nWh);
 979                 }
 980                 else
 981                     rSet.Put(SfxVisibilityItem(nWh, false));
 982             }
 983             break;
 984
 985             case SID_BASICIDE_STACK:
 986             {
 987                 if (pLayout)
 988                 {
 989                     rSet.Put(SfxBoolItem(nWh, pModulLayout->IsStackWindowVisible()));
 990                     // Disable command if the visible window is not a ModulWindow
 991                     if (!dynamic_cast<ModulWindowLayout*>(pLayout.get()))
 992                         rSet.DisableItem(nWh);
 993                 }
 994                 else
 995                     rSet.Put(SfxVisibilityItem(nWh, false));
 996             }
 997             break;
 998
 999             case SID_BASICIDE_SHOWSBX:
1000             case SID_BASICIDE_CREATEMACRO:
1001             case SID_BASICIDE_EDITMACRO:
1002             case SID_BASICIDE_NAMECHANGEDONTAB:
1003             {
1004                 ;
1005             }
1006             break;
1007
1008             case SID_BASICIDE_ADDWATCH:
1009             case SID_BASICIDE_REMOVEWATCH:
1010             case SID_BASICLOAD:
1011             case SID_BASICSAVEAS:
1012             case SID_BASICIDE_MATCHGROUP:
1013             {
1014                 if (!dynamic_cast<ModulWindow*>(pCurWin.get()))
1015                     rSet.DisableItem( nWh );
1016                 else if ( ( nWh == SID_BASICLOAD ) && ( StarBASIC::IsRunning() || ( pCurWin && pCurWin->IsReadOnly() ) ) )
1017                     rSet.DisableItem( nWh );
1018             }
1019             break;
1020             case SID_BASICRUN:
1021             case SID_BASICSTEPINTO:
1022             case SID_BASICSTEPOVER:
1023             case SID_BASICSTEPOUT:
1024             case SID_BASICIDE_TOGGLEBRKPNT:
1025             case SID_BASICIDE_MANAGEBRKPNTS:
1026             {
1027                 if (ModulWindow* pMCurWin = dynamic_cast<ModulWindow*>(pCurWin.get()))
1028                 {
1029                     if (StarBASIC::IsRunning() && !pMCurWin->GetBasicStatus().bIsInReschedule)
1030                         rSet.DisableItem(nWh);
1031                 }
1032                 else
1033                     rSet.DisableItem( nWh );
1034             }
1035             break;
1036             case SID_BASICCOMPILE:
1037             {
1038                 if (StarBASIC::IsRunning() || !dynamic_cast<ModulWindow*>(pCurWin.get()))
1039                     rSet.DisableItem( nWh );
1040             }
1041             break;
1042             case SID_BASICSTOP:
1043             {
1044                 // stop is always possible when some Basic is running...
1045                 if (!StarBASIC::IsRunning())
1046                     rSet.DisableItem( nWh );
1047             }
1048             break;
1049             case SID_CHOOSE_CONTROLS:
1050             case SID_DIALOG_TESTMODE:
1051             case SID_INSERT_SELECT:
1052             case SID_INSERT_PUSHBUTTON:
1053             case SID_INSERT_RADIOBUTTON:
1054             case SID_INSERT_CHECKBOX:
1055             case SID_INSERT_LISTBOX:
1056             case SID_INSERT_COMBOBOX:
1057             case SID_INSERT_GROUPBOX:
1058             case SID_INSERT_EDIT:
1059             case SID_INSERT_FIXEDTEXT:
1060             case SID_INSERT_IMAGECONTROL:
1061             case SID_INSERT_PROGRESSBAR:
1062             case SID_INSERT_HSCROLLBAR:
1063             case SID_INSERT_VSCROLLBAR:
1064             case SID_INSERT_HFIXEDLINE:
1065             case SID_INSERT_VFIXEDLINE:
1066             case SID_INSERT_DATEFIELD:
1067             case SID_INSERT_TIMEFIELD:
1068             case SID_INSERT_NUMERICFIELD:
1069             case SID_INSERT_CURRENCYFIELD:
1070             case SID_INSERT_FORMATTEDFIELD:
1071             case SID_INSERT_PATTERNFIELD:
1072             case SID_INSERT_FILECONTROL:
1073             case SID_INSERT_SPINBUTTON:
1074             case SID_INSERT_GRIDCONTROL:
1075             case SID_INSERT_HYPERLINKCONTROL:
1076             case SID_INSERT_TREECONTROL:
1077             case SID_INSERT_FORM_RADIO:
1078             case SID_INSERT_FORM_CHECK:
1079             case SID_INSERT_FORM_LIST:
1080             case SID_INSERT_FORM_COMBO:
1081             case SID_INSERT_FORM_VSCROLL:
1082             case SID_INSERT_FORM_HSCROLL:
1083             case SID_INSERT_FORM_SPIN:
1084             {
1085                 if (!dynamic_cast<DialogWindow*>(pCurWin.get()))
1086                     rSet.DisableItem( nWh );
1087             }
1088             break;
1089             case SID_SEARCH_OPTIONS:
1090             {
1091                 SearchOptionFlags nOptions = SearchOptionFlags::NONE;
1092                 if( pCurWin )
1093                     nOptions = pCurWin->GetSearchOptions();
1094                 rSet.Put( SfxUInt16Item( SID_SEARCH_OPTIONS, static_cast<sal_uInt16>(nOptions) ) );
1095             }
1096             break;
1097             case SID_BASICIDE_LIBSELECTOR:
1098             {
1099                 OUString aName;
1100                 if ( !m_aCurLibName.isEmpty() )
1101                 {
1102                     LibraryLocation eLocation = m_aCurDocument.getLibraryLocation( m_aCurLibName );
1103                     aName = CreateMgrAndLibStr( m_aCurDocument.getTitle( eLocation ), m_aCurLibName );
1104                 }
1105                 SfxStringItem aItem( SID_BASICIDE_LIBSELECTOR, aName );
1106                 rSet.Put( aItem );
1107             }
1108             break;
1109             case SID_SEARCH_ITEM:
1110             {
1111                 if ( !mpSearchItem )
1112                 {
1113                     mpSearchItem.reset( new SvxSearchItem( SID_SEARCH_ITEM ));
1114                     mpSearchItem->SetSearchString( GetSelectionText( true ));
1115                 }
1116
1117                 if ( mbJustOpened && HasSelection() )
1118                 {
1119                     OUString aText = GetSelectionText( true );
1120
1121                     if ( !aText.isEmpty() )
1122                     {
1123                         mpSearchItem->SetSearchString( aText );
1124                         mpSearchItem->SetSelection( false );
1125                     }
1126                     else
1127                         mpSearchItem->SetSelection( true );
1128                 }
1129
1130                 mbJustOpened = false;
1131                 rSet.Put( *mpSearchItem );
1132             }
1133             break;
1134             case SID_BASICIDE_STAT_DATE:
1135             {
1136                 SfxStringItem aItem( SID_BASICIDE_STAT_DATE, u"Datum?!"_ustr );
1137                 rSet.Put( aItem );
1138             }
1139             break;
1140             case SID_DOC_MODIFIED:
1141             {
1142                 bool bModified = false;
1143
1144                 if ( pCurWin )
1145                 {
1146                     if ( pCurWin->IsModified() )
1147                         bModified = true;
1148                     else
1149                     {
1150                         ScriptDocument aDocument( pCurWin->GetDocument() );
1151                         bModified = aDocument.isDocument() ? aDocument.isDocumentModified() : IsAppBasicModified();
1152                     }
1153                 }
1154
1155                 SfxBoolItem aItem(SID_DOC_MODIFIED, bModified);
1156                 rSet.Put( aItem );
1157             }
1158             break;
1159             case SID_BASICIDE_STAT_TITLE:
1160             {
1161                 if ( pCurWin )
1162                 {
1163                     OUString aTitle = pCurWin->CreateQualifiedName();
1164                     if (pCurWin->IsReadOnly())
1165                         aTitle += " (" + IDEResId(RID_STR_READONLY) + ")";
1166                     SfxStringItem aItem( SID_BASICIDE_STAT_TITLE, aTitle );
1167                     rSet.Put( aItem );
1168                 }
1169             }
1170             break;
1171             case SID_BASICIDE_CURRENT_ZOOM:
1172             {
1173                 // The current zoom value is only visible in a module window
1174                 ModulWindow* pModuleWindow = dynamic_cast<ModulWindow*>(pCurWin.get());
1175                 if (pModuleWindow)
1176                 {
1177                     OUString sZoom;
1178                     sZoom = OUString::number(m_nCurrentZoomSliderValue) + "%";
1179                     SfxStringItem aItem( SID_BASICIDE_CURRENT_ZOOM, sZoom );
1180                     rSet.Put( aItem );
1181                 }
1182             }
1183             break;
1184             // are interpreted by the controller:
1185             case SID_ATTR_SIZE:
1186             case SID_ATTR_INSERT:
1187             break;
1188             case SID_UNDO:
1189             case SID_REDO:
1190             {
1191                 if( GetUndoManager() )  // recursive GetState else
1192                     GetViewFrame().GetSlotState( nWh, nullptr, &rSet );
1193             }
1194             break;
1195             case SID_BASICIDE_CURRENT_LANG:
1196             {
1197                 if( (pCurWin && pCurWin->IsReadOnly()) || GetCurLibName().isEmpty() )
1198                     rSet.DisableItem( nWh );
1199                 else
1200                 {
1201                     OUString aItemStr;
1202                     std::shared_ptr<LocalizationMgr> pCurMgr(GetCurLocalizationMgr());
1203                     if ( pCurMgr->isLibraryLocalized() )
1204                     {
1205                         Sequence< lang::Locale > aLocaleSeq = pCurMgr->getStringResourceManager()->getLocales();
1206                         sal_Int32 i, nCount = aLocaleSeq.getLength();
1207
1208                         // Force different results for any combination of locales and default locale
1209                         OUString aLangStr;
1210                         for ( i = 0;  i <= nCount;  ++i )
1211                         {
1212                             lang::Locale aLocale;
1213                             if( i < nCount )
1214                                 aLocale = aLocaleSeq[i];
1215                             else
1216                                 aLocale = pCurMgr->getStringResourceManager()->getDefaultLocale();
1217
1218                             aLangStr += aLocale.Language + aLocale.Country + aLocale.Variant;
1219                         }
1220                         aItemStr = aLangStr;
1221                     }
1222                     rSet.Put( SfxStringItem( nWh, aItemStr ) );
1223                 }
1224             }
1225             break;
1226
1227             case SID_BASICIDE_MANAGE_LANG:
1228             {
1229                 if( (pCurWin && pCurWin->IsReadOnly()) || GetCurLibName().isEmpty() )
1230                     rSet.DisableItem( nWh );
1231             }
1232             break;
1233             case SID_TOGGLE_COMMENT:
1234             {
1235                 // Only available in a ModulWindow if the document can be edited
1236                 if (pCurWin && (!dynamic_cast<ModulWindow*>(pCurWin.get()) || pCurWin->IsReadOnly()))
1237                     rSet.DisableItem(nWh);
1238             }
1239             break;
1240             case SID_GOTOLINE:
1241             {
1242                 // if this is not a module window hide the
1243                 // setting, doesn't make sense for example if the
1244                 // dialog editor is open
1245                 if (pCurWin && !dynamic_cast<ModulWindow*>(pCurWin.get()))
1246                 {
1247                     rSet.DisableItem( nWh );
1248                     rSet.Put(SfxVisibilityItem(nWh, false));
1249                 }
1250                 break;
1251             }
1252             case SID_BASICIDE_HIDECURPAGE:
1253             {
1254                 if (pTabBar->GetPageCount() == 0)
1255                     rSet.DisableItem(nWh);
1256             }
1257             break;
1258             case SID_BASICIDE_DELETECURRENT:
1259             case SID_BASICIDE_RENAMECURRENT:
1260             {
1261                 if (pTabBar->GetPageCount() == 0 || StarBASIC::IsRunning())
1262                     rSet.DisableItem(nWh);
1263                 else if (m_aCurDocument.isInVBAMode())
1264                 {
1265                     // disable to delete or rename object modules in IDE
1266                     BasicManager* pBasMgr = m_aCurDocument.getBasicManager();
1267                     StarBASIC* pBasic = pBasMgr ? pBasMgr->GetLib(m_aCurLibName) : nullptr;
1268                     if (pBasic && dynamic_cast<ModulWindow*>(pCurWin.get()))
1269                     {
1270                         SbModule* pActiveModule = pBasic->FindModule( pCurWin->GetName() );
1271                         if ( pActiveModule && ( pActiveModule->GetModuleType() == script::ModuleType::DOCUMENT ) )
1272                             rSet.DisableItem(nWh);
1273                     }
1274                 }
1275             }
1276             [[fallthrough]];
1277
1278             case SID_BASICIDE_NEWMODULE:
1279             case SID_BASICIDE_NEWDIALOG:
1280             {
1281                 Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
1282                 Reference< script::XLibraryContainer2 > xDlgLibContainer( m_aCurDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
1283                 if ( ( xModLibContainer.is() && xModLibContainer->hasByName( m_aCurLibName ) && xModLibContainer->isLibraryReadOnly( m_aCurLibName ) ) ||
1284                      ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( m_aCurLibName ) && xDlgLibContainer->isLibraryReadOnly( m_aCurLibName ) ) )
1285                     rSet.DisableItem(nWh);
1286             }
1287             break;
1288
1289             case SID_ZOOM_IN:
1290             case SID_ZOOM_OUT:
1291             {
1292                 const sal_uInt16 nCurrentZoom = GetCurrentZoomSliderValue();
1293                 if ((nWh == SID_ZOOM_IN && nCurrentZoom >= GetMaxZoom()) ||
1294                     (nWh == SID_ZOOM_OUT && nCurrentZoom <= GetMinZoom()))
1295                     rSet.DisableItem(nWh);
1296             }
1297             break;
1298
1299             case SID_BASICIDE_COLOR_SCHEME_DLG:
1300             {
1301                 if (!dynamic_cast<ModulWindowLayout*>(pLayout.get()))
1302                     rSet.DisableItem(nWh);
1303             }
1304             break;
1305
1306             case SID_ATTR_ZOOMSLIDER:
1307             {
1308                 // The zoom slider is only visible in a module window
1309                 ModulWindow* pModuleWindow = dynamic_cast<ModulWindow*>(pCurWin.get());
1310                 if (pModuleWindow)
1311                 {
1312                     SvxZoomSliderItem aZoomSliderItem(GetCurrentZoomSliderValue(), GetMinZoom(), GetMaxZoom());
1313                     aZoomSliderItem.AddSnappingPoint(100);
1314                     rSet.Put( aZoomSliderItem );
1315                 }
1316             }
1317             break;
1318
1319             default:
1320                 if (pLayout)
1321                     pLayout->GetState(rSet, nWh);
1322         }
1323     }
1324     if ( pCurWin )
1325         pCurWin->GetState( rSet );
1326 }
1327
1328 bool Shell::HasUIFeature(SfxShellFeature nFeature) const
1329 {
1330     assert((nFeature & ~SfxShellFeature::BasicMask) == SfxShellFeature::NONE);
1331     bool bResult = false;
1332
1333     if (nFeature & SfxShellFeature::BasicShowBrowser)
1334     {
1335         // fade out (in) property browser in module (dialog) windows
1336         if (dynamic_cast<DialogWindow*>(pCurWin.get()) && !pCurWin->IsReadOnly())
1337             bResult = true;
1338     }
1339
1340     return bResult;
1341 }
1342
1343 void Shell::SetCurWindow( BaseWindow* pNewWin, bool bUpdateTabBar, bool bRememberAsCurrent )
1344 {
1345     if ( pNewWin == pCurWin )
1346         return;
1347
1348     pCurWin = pNewWin;
1349     if (pLayout)
1350         pLayout->Deactivating();
1351     if (pCurWin)
1352     {
1353         if (pCurWin->GetSbxType() == SBX_TYPE_MODULE)
1354             pLayout = pModulLayout.get();
1355         else
1356             pLayout = pDialogLayout.get();
1357         AdjustPosSizePixel(Point(0, 0), GetViewFrame().GetWindow().GetOutputSizePixel());
1358         pLayout->Activating(*pCurWin);
1359         GetViewFrame().GetWindow().SetHelpId(pCurWin->GetHid());
1360         if (bRememberAsCurrent)
1361             pCurWin->InsertLibInfo();
1362         if (GetViewFrame().GetWindow().IsVisible()) // SFX will do it later otherwise
1363             pCurWin->Show();
1364         pCurWin->Init();
1365         if (!GetExtraData()->ShellInCriticalSection())
1366         {
1367             vcl::Window* pFrameWindow = &GetViewFrame().GetWindow();
1368             vcl::Window* pFocusWindow = Application::GetFocusWindow();
1369             while ( pFocusWindow && ( pFocusWindow != pFrameWindow ) )
1370                 pFocusWindow = pFocusWindow->GetParent();
1371             if ( pFocusWindow ) // Focus in BasicIDE
1372                 pCurWin->GrabFocus();
1373         }
1374     }
1375     else
1376     {
1377         SetWindow(pLayout);
1378         pLayout = nullptr;
1379     }
1380     if ( bUpdateTabBar )
1381     {
1382         sal_uInt16 nKey = GetWindowId( pCurWin );
1383         if ( pCurWin && ( pTabBar->GetPagePos( nKey ) == TabBar::PAGE_NOT_FOUND ) )
1384             pTabBar->InsertPage( nKey, pCurWin->GetTitle() );   // has just been faded in
1385         pTabBar->SetCurPageId( nKey );
1386     }
1387     if ( pCurWin && pCurWin->IsSuspended() )    // if the window is shown in the case of an error...
1388         pCurWin->SetStatus( pCurWin->GetStatus() & ~BASWIN_SUSPENDED );
1389     if ( pCurWin )
1390     {
1391         SetWindow( pCurWin );
1392         if ( pCurWin->GetDocument().isDocument() )
1393             SfxObjectShell::SetCurrentComponent( pCurWin->GetDocument().getDocument() );
1394     }
1395     else if (pLayout)
1396     {
1397         SetWindow(pLayout);
1398         GetViewFrame().GetWindow().SetHelpId( HID_BASICIDE_MODULWINDOW );
1399         SfxObjectShell::SetCurrentComponent(nullptr);
1400     }
1401     aObjectCatalog->SetCurrentEntry(pCurWin);
1402     SetUndoManager( pCurWin ? pCurWin->GetUndoManager() : nullptr );
1403     InvalidateBasicIDESlots();
1404     InvalidateControlSlots();
1405
1406     if ( m_pCurLocalizationMgr )
1407         m_pCurLocalizationMgr->handleTranslationbar();
1408
1409     ManageToolbars();
1410
1411     // fade out (in) property browser in module (dialog) windows
1412     UIFeatureChanged();
1413 }
1414
1415 void Shell::ManageToolbars()
1416 {
1417     static constexpr OUString aMacroBarResName = u"private:resource/toolbar/macrobar"_ustr;
1418     static constexpr OUString aDialogBarResName = u"private:resource/toolbar/dialogbar"_ustr;
1419     static constexpr OUString aInsertControlsBarResName
1420         = u"private:resource/toolbar/insertcontrolsbar"_ustr;
1421     static constexpr OUString aFormControlsBarResName
1422         = u"private:resource/toolbar/formcontrolsbar"_ustr;
1423
1424     if( !pCurWin )
1425         return;
1426
1427     Reference< beans::XPropertySet > xFrameProps
1428         ( GetViewFrame().GetFrame().GetFrameInterface(), uno::UNO_QUERY );
1429     if ( !xFrameProps.is() )
1430         return;
1431
1432     Reference< css::frame::XLayoutManager > xLayoutManager;
1433     uno::Any a = xFrameProps->getPropertyValue( u"LayoutManager"_ustr );
1434     a >>= xLayoutManager;
1435     if ( !xLayoutManager.is() )
1436         return;
1437
1438     xLayoutManager->lock();
1439     if (dynamic_cast<DialogWindow*>(pCurWin.get()))
1440     {
1441         xLayoutManager->destroyElement( aMacroBarResName );
1442
1443         xLayoutManager->requestElement( aDialogBarResName );
1444         xLayoutManager->requestElement( aInsertControlsBarResName );
1445         xLayoutManager->requestElement( aFormControlsBarResName );
1446     }
1447     else
1448     {
1449         xLayoutManager->destroyElement( aDialogBarResName );
1450         xLayoutManager->destroyElement( aInsertControlsBarResName );
1451         xLayoutManager->destroyElement( aFormControlsBarResName );
1452
1453         xLayoutManager->requestElement( aMacroBarResName );
1454     }
1455     xLayoutManager->unlock();
1456 }
1457
1458 VclPtr<BaseWindow> Shell::FindApplicationWindow()
1459 {
1460     return FindWindow( ScriptDocument::getApplicationScriptDocument(), u"", u"", SBX_TYPE_UNKNOWN );
1461 }
1462
1463 VclPtr<BaseWindow> Shell::FindWindow(
1464     ScriptDocument const& rDocument,
1465     std::u16string_view rLibName, std::u16string_view rName,
1466     SbxItemType eSbxItemType, bool bFindSuspended
1467 )
1468 {
1469     for (auto const& window : aWindowTable)
1470     {
1471         BaseWindow* const pWin = window.second;
1472         if (pWin->Is(rDocument, rLibName, rName, eSbxItemType, bFindSuspended))
1473             return pWin;
1474     }
1475     return nullptr;
1476 }
1477
1478 bool Shell::CallBasicErrorHdl( StarBASIC const * pBasic )
1479 {
1480     VclPtr<ModulWindow> pModWin = ShowActiveModuleWindow( pBasic );
1481     if ( pModWin )
1482         pModWin->BasicErrorHdl( pBasic );
1483     return false;
1484 }
1485
1486 BasicDebugFlags Shell::CallBasicBreakHdl( StarBASIC const * pBasic )
1487 {
1488     BasicDebugFlags nRet = BasicDebugFlags::NONE;
1489     VclPtr<ModulWindow> pModWin = ShowActiveModuleWindow( pBasic );
1490     if ( pModWin )
1491     {
1492         bool bAppWindowDisabled, bDispatcherLocked;
1493         sal_uInt16 nWaitCount;
1494         SfxUInt16Item *pSWActionCount, *pSWLockViewCount;
1495         BasicStopped( &bAppWindowDisabled, &bDispatcherLocked,
1496                                 &nWaitCount, &pSWActionCount, &pSWLockViewCount );
1497
1498         nRet = pModWin->BasicBreakHdl();
1499
1500         if ( StarBASIC::IsRunning() )   // if cancelled...
1501         {
1502             if ( bAppWindowDisabled )
1503                 Application::GetDefDialogParent()->set_sensitive(false);
1504
1505             if ( nWaitCount )
1506             {
1507                 Shell* pShell = GetShell();
1508                 for ( sal_uInt16 n = 0; n < nWaitCount; n++ )
1509                     pShell->GetViewFrame().GetWindow().EnterWait();
1510             }
1511         }
1512     }
1513     return nRet;
1514 }
1515
1516 VclPtr<ModulWindow> Shell::ShowActiveModuleWindow( StarBASIC const * pBasic )
1517 {
1518     SetCurLib( ScriptDocument::getApplicationScriptDocument(), OUString(), false );
1519
1520     SbModule* pActiveModule = StarBASIC::GetActiveModule();
1521     if (SbClassModuleObject* pCMO = dynamic_cast<SbClassModuleObject*>(pActiveModule))
1522         pActiveModule = &pCMO->getClassModule();
1523
1524     DBG_ASSERT( pActiveModule, "No active module in ErrorHdl!?" );
1525     if ( pActiveModule )
1526     {
1527         VclPtr<ModulWindow> pWin;
1528         SbxObject* pParent = pActiveModule->GetParent();
1529         if (StarBASIC* pLib = dynamic_cast<StarBASIC*>(pParent))
1530         {
1531             if (BasicManager* pBasMgr = FindBasicManager(pLib))
1532             {
1533                 ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
1534                 const OUString& aLibName = pLib->GetName();
1535                 pWin = FindBasWin( aDocument, aLibName, pActiveModule->GetName(), true );
1536                 DBG_ASSERT( pWin, "Error/Step-Hdl: Window was not created/found!" );
1537                 SetCurLib( aDocument, aLibName );
1538                 SetCurWindow( pWin, true );
1539             }
1540         }
1541         else
1542             SAL_WARN( "basctl.basicide", "No BASIC!");
1543         if (BasicManager* pBasicMgr = FindBasicManager(pBasic))
1544             StartListening(*pBasicMgr, DuplicateHandling::Prevent /* log on only once */);
1545         return pWin;
1546     }
1547     return nullptr;
1548 }
1549
1550 void Shell::AdjustPosSizePixel( const Point &rPos, const Size &rSize )
1551 {
1552     // not if iconified because the whole text would be displaced then at restore
1553     if ( GetViewFrame().GetWindow().GetOutputSizePixel().Height() == 0 )
1554         return;
1555
1556     Size aTabBarSize;
1557     aTabBarSize.setHeight( GetViewFrame().GetWindow().GetFont().GetFontHeight() + TAB_HEIGHT_MARGIN );
1558     aTabBarSize.setWidth( rSize.Width() );
1559
1560     Size aSz( rSize );
1561     auto nScrollBarSz(Application::GetSettings().GetStyleSettings().GetScrollBarSize());
1562     aSz.AdjustHeight(-aTabBarSize.Height());
1563
1564     Size aOutSz( aSz );
1565     aSz.AdjustWidth(-nScrollBarSz);
1566     aSz.AdjustHeight(-nScrollBarSz);
1567     aVScrollBar->SetPosSizePixel( Point( rPos.X()+aSz.Width(), rPos.Y() ), Size( nScrollBarSz, aSz.Height() ) );
1568     aHScrollBar->SetPosSizePixel( Point( rPos.X(), rPos.Y()+aSz.Height() ), Size( aOutSz.Width(), nScrollBarSz ) );
1569     pTabBar->SetPosSizePixel( Point( rPos.X(), rPos.Y() + nScrollBarSz + aSz.Height()), aTabBarSize );
1570
1571     // The size to be applied depends on whether it is a DialogWindow or a ModulWindow
1572     if (pLayout)
1573     {
1574         if (dynamic_cast<DialogWindow*>(pCurWin.get()))
1575         {
1576             pCurWin->ShowShellScrollBars();
1577             pLayout->SetPosSizePixel(rPos, aSz);
1578         }
1579         else
1580         {
1581             pCurWin->ShowShellScrollBars(false);
1582             pLayout->SetPosSizePixel(rPos, aOutSz);
1583         }
1584     }
1585 }
1586
1587 Reference< XModel > Shell::GetCurrentDocument() const
1588 {
1589     Reference< XModel > xDocument;
1590     if ( pCurWin && pCurWin->GetDocument().isDocument() )
1591         xDocument = pCurWin->GetDocument().getDocument();
1592     return xDocument;
1593 }
1594
1595 void Shell::Activate( bool bMDI )
1596 {
1597     SfxViewShell::Activate( bMDI );
1598
1599     if ( bMDI )
1600     {
1601         if (DialogWindow* pDCurWin = dynamic_cast<DialogWindow*>(pCurWin.get()))
1602             pDCurWin->UpdateBrowser();
1603     }
1604 }
1605
1606 void Shell::Deactivate( bool bMDI )
1607 {
1608     // bMDI == true means that another MDI has been activated; in case of a
1609     // deactivate due to a MessageBox bMDI is false
1610     if ( bMDI )
1611     {
1612         if (DialogWindow* pXDlgWin = dynamic_cast<DialogWindow*>(pCurWin.get()))
1613         {
1614             pXDlgWin->DisableBrowser();
1615             if( pXDlgWin->IsModified() )
1616                 MarkDocumentModified( pXDlgWin->GetDocument() );
1617         }
1618     }
1619 }
1620
1621 } // namespace basctl
1622
1623 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */