basctl/source/basicide/bastypes.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 <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <strings.hrc>
  25 #include <helpids.h>
  26 #include <iderid.hxx>
  27
  28 #include "baside2.hxx"
  29 #include <baside3.hxx>
  30 #include <basidesh.hxx>
  31 #include <basobj.hxx>
  32 #include <iderdll.hxx>
  33 #include "iderdll2.hxx"
  34
  35 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  36 #include <sal/log.hxx>
  37 #include <sfx2/dispatch.hxx>
  38 #include <sfx2/infobar.hxx>
  39 #include <sfx2/passwd.hxx>
  40 #include <sfx2/sfxsids.hrc>
  41 #include <sfx2/viewfrm.hxx>
  42 #include <svl/intitem.hxx>
  43 #include <svl/stritem.hxx>
  44 #include <svl/srchdefs.hxx>
  45 #include <utility>
  46 #include <vcl/commandevent.hxx>
  47 #include <vcl/event.hxx>
  48 #include <vcl/svapp.hxx>
  49 #include <vcl/weld.hxx>
  50 #include <tools/stream.hxx>
  51 #include <o3tl/hash_combine.hxx>
  52
  53 namespace basctl
  54 {
  55
  56 // ID used for the read-only infobar
  57 constexpr OUStringLiteral BASIC_IDE_READONLY_INFOBAR = u"readonly";
  58
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star;
  61
  62 BaseWindow::BaseWindow( vcl::Window* pParent, ScriptDocument aDocument, OUString aLibName, OUString aName )
  63     :Window( pParent, WinBits( WB_3DLOOK ) )
  64     ,pShellHScrollBar( nullptr)
  65     ,pShellVScrollBar( nullptr)
  66     ,nStatus( 0)
  67     ,m_aDocument(std::move( aDocument ))
  68     ,m_aLibName(std::move( aLibName ))
  69     ,m_aName(std::move( aName ))
  70 {
  71 }
  72
  73 BaseWindow::~BaseWindow()
  74 {
  75     disposeOnce();
  76 }
  77
  78 void BaseWindow::dispose()
  79 {
  80     if (pShellVScrollBar && !pShellVScrollBar->isDisposed())
  81         pShellVScrollBar->SetScrollHdl( Link<weld::Scrollbar&,void>() );
  82     if (pShellHScrollBar && !pShellHScrollBar->isDisposed())
  83         pShellHScrollBar->SetScrollHdl( Link<weld::Scrollbar&,void>() );
  84     pShellVScrollBar.clear();
  85     pShellHScrollBar.clear();
  86     vcl::Window::dispose();
  87 }
  88
  89 void BaseWindow::Init()
  90 {
  91     if ( pShellVScrollBar )
  92         pShellVScrollBar->SetScrollHdl( LINK( this, BaseWindow, VertScrollHdl ) );
  93     if ( pShellHScrollBar )
  94         pShellHScrollBar->SetScrollHdl( LINK( this, BaseWindow, HorzScrollHdl ) );
  95
  96     // Show the read-only infobar if the module/dialog is read-only
  97     GetShell()->GetViewFrame().RemoveInfoBar(BASIC_IDE_READONLY_INFOBAR);
  98     if (IsReadOnly())
  99         ShowReadOnlyInfoBar();
 100
 101     DoInit();   // virtual...
 102 }
 103
 104 void BaseWindow::DoInit()
 105 {
 106 }
 107
 108 void BaseWindow::GrabScrollBars(ScrollAdaptor* pHScroll, ScrollAdaptor* pVScroll)
 109 {
 110     pShellHScrollBar = pHScroll;
 111     pShellVScrollBar = pVScroll;
 112 }
 113
 114 IMPL_LINK_NOARG(BaseWindow, VertScrollHdl, weld::Scrollbar&, void)
 115 {
 116     DoScroll(pShellVScrollBar);
 117 }
 118
 119 IMPL_LINK_NOARG(BaseWindow, HorzScrollHdl, weld::Scrollbar&, void)
 120 {
 121     DoScroll(pShellHScrollBar);
 122 }
 123
 124 void BaseWindow::ExecuteCommand (SfxRequest&)
 125 {
 126 }
 127
 128 void BaseWindow::ExecuteGlobal (SfxRequest&)
 129 {
 130 }
 131
 132 bool BaseWindow::EventNotify( NotifyEvent& rNEvt )
 133 {
 134     bool bDone = false;
 135
 136     if ( rNEvt.GetType() == NotifyEventType::KEYINPUT )
 137     {
 138         KeyEvent aKEvt = *rNEvt.GetKeyEvent();
 139         vcl::KeyCode aCode = aKEvt.GetKeyCode();
 140         sal_uInt16 nCode = aCode.GetCode();
 141
 142         switch ( nCode )
 143         {
 144             case KEY_PAGEUP:
 145             case KEY_PAGEDOWN:
 146             {
 147                 if ( aCode.IsMod1() )
 148                 {
 149                     if (Shell* pShell = GetShell())
 150                         pShell->NextPage( nCode == KEY_PAGEUP );
 151                     bDone = true;
 152                 }
 153             }
 154             break;
 155         }
 156     }
 157
 158     return bDone || Window::EventNotify( rNEvt );
 159 }
 160
 161 void BaseWindow::ShowShellScrollBars(bool bVisible)
 162 {
 163     if (bVisible)
 164     {
 165         if (pShellHScrollBar)
 166         {
 167             pShellHScrollBar->Enable();
 168             pShellHScrollBar->Show();
 169         }
 170         if (pShellVScrollBar)
 171         {
 172             pShellVScrollBar->Enable();
 173             pShellVScrollBar->Show();
 174         }
 175     }
 176     else
 177     {
 178         if (pShellHScrollBar)
 179         {
 180             pShellHScrollBar->Disable();
 181             pShellHScrollBar->Hide();
 182         }
 183         if (pShellVScrollBar)
 184         {
 185             pShellVScrollBar->Disable();
 186             pShellVScrollBar->Hide();
 187         }
 188     }
 189 }
 190
 191 void BaseWindow::DoScroll( Scrollable* )
 192 {
 193 }
 194
 195 void BaseWindow::StoreData()
 196 {
 197 }
 198
 199 bool BaseWindow::AllowUndo()
 200 {
 201     return true;
 202 }
 203
 204 void BaseWindow::UpdateData()
 205 {
 206 }
 207
 208 OUString BaseWindow::GetTitle()
 209 {
 210     return OUString();
 211 }
 212
 213 OUString BaseWindow::CreateQualifiedName()
 214 {
 215     OUString aName;
 216     if ( !m_aLibName.isEmpty() )
 217     {
 218         LibraryLocation eLocation = m_aDocument.getLibraryLocation( m_aLibName );
 219         aName = m_aDocument.getTitle(eLocation) + "." + m_aLibName + "." +
 220                 GetTitle();
 221     }
 222     return aName;
 223 }
 224
 225 void BaseWindow::SetReadOnly (bool)
 226 {
 227 }
 228
 229 bool BaseWindow::IsReadOnly ()
 230 {
 231     return false;
 232 }
 233
 234 // Show the read-only warning messages for module and dialog windows
 235 void BaseWindow::ShowReadOnlyInfoBar()
 236 {
 237     OUString aMsg;
 238     if (dynamic_cast<ModulWindow*>(this))
 239         aMsg = IDEResId(RID_STR_MODULE_READONLY);
 240     else
 241         aMsg = IDEResId(RID_STR_DIALOG_READONLY);
 242
 243     GetShell()->GetViewFrame().AppendInfoBar(BASIC_IDE_READONLY_INFOBAR, OUString(),
 244                                               aMsg, InfobarType::INFO, true);
 245 }
 246
 247 void BaseWindow::BasicStarted()
 248 {
 249 }
 250
 251 void BaseWindow::BasicStopped()
 252 {
 253 }
 254
 255 bool BaseWindow::IsModified ()
 256 {
 257     return true;
 258 }
 259
 260 SfxUndoManager* BaseWindow::GetUndoManager()
 261 {
 262     return nullptr;
 263 }
 264
 265 SearchOptionFlags BaseWindow::GetSearchOptions()
 266 {
 267     return SearchOptionFlags::NONE;
 268 }
 269
 270 sal_uInt16 BaseWindow::StartSearchAndReplace (SvxSearchItem const&, bool)
 271 {
 272     return 0;
 273 }
 274
 275 void BaseWindow::OnNewDocument ()
 276 { }
 277
 278 void BaseWindow::InsertLibInfo () const
 279 {
 280     if (ExtraData* pData = GetExtraData())
 281         pData->GetLibInfo().InsertInfo(m_aDocument, m_aLibName, m_aName, GetType());
 282 }
 283
 284 bool BaseWindow::Is (
 285     ScriptDocument const& rDocument,
 286     std::u16string_view rLibName, std::u16string_view rName,
 287     ItemType eType, bool bFindSuspended
 288 )
 289 {
 290     if (bFindSuspended || !IsSuspended())
 291     {
 292         // any non-suspended window is ok
 293         if (rLibName.empty() || rName.empty() || eType == TYPE_UNKNOWN)
 294             return true;
 295         // ok if the parameters match
 296         if (m_aDocument == rDocument && m_aLibName == rLibName && m_aName == rName && GetType() == eType)
 297             return true;
 298     }
 299     return false;
 300 }
 301
 302 bool BaseWindow::HasActiveEditor () const
 303 {
 304     return false;
 305 }
 306
 307
 308 // DockingWindow
 309
 310
 311 // style bits for DockingWindow
 312 WinBits const DockingWindow::StyleBits =
 313     WB_BORDER | WB_3DLOOK | WB_CLIPCHILDREN |
 314     WB_MOVEABLE | WB_SIZEABLE | WB_DOCKABLE;
 315
 316 DockingWindow::DockingWindow(vcl::Window* pParent, const OUString& rUIXMLDescription, const OUString& rID)
 317     : ResizableDockingWindow(pParent)
 318     , m_xBuilder(Application::CreateInterimBuilder(m_xBox.get(), rUIXMLDescription, true))
 319     , pLayout(nullptr)
 320     , nShowCount(0)
 321 {
 322     m_xContainer = m_xBuilder->weld_container(rID);
 323 }
 324
 325 DockingWindow::DockingWindow (Layout* pParent)
 326     : ResizableDockingWindow(pParent, StyleBits)
 327     , pLayout(pParent)
 328     , nShowCount(0)
 329 { }
 330
 331 DockingWindow::~DockingWindow()
 332 {
 333     disposeOnce();
 334 }
 335
 336 void DockingWindow::dispose()
 337 {
 338     m_xContainer.reset();
 339     m_xBuilder.reset();
 340     pLayout.clear();
 341     ResizableDockingWindow::dispose();
 342 }
 343
 344 // Sets the position and the size of the docking window. This property is saved
 345 // when the window is floating. Called by Layout.
 346 void DockingWindow::ResizeIfDocking (Point const& rPos, Size const& rSize)
 347 {
 348     tools::Rectangle const rRect(rPos, rSize);
 349     if (rRect != aDockingRect)
 350     {
 351         // saving the position and the size
 352         aDockingRect = rRect;
 353         // resizing if actually docking
 354         if (!IsFloatingMode())
 355             SetPosSizePixel(rPos, rSize);
 356     }
 357 }
 358 void DockingWindow::ResizeIfDocking (Size const& rSize)
 359 {
 360     ResizeIfDocking(aDockingRect.TopLeft(), rSize);
 361 }
 362
 363 // Sets the parent Layout window.
 364 // The physical parent is set only when the window is docking.
 365 void DockingWindow::SetLayoutWindow (Layout* pLayout_)
 366 {
 367     pLayout = pLayout_;
 368     if (!IsFloatingMode())
 369         SetParent(pLayout);
 370
 371 }
 372
 373 // Increases the "show" reference count.
 374 // The window is shown when the reference count is positive.
 375 void DockingWindow::Show (bool bShow) // = true
 376 {
 377     if (bShow)
 378     {
 379         if (++nShowCount == 1)
 380             ResizableDockingWindow::Show();
 381     }
 382     else
 383     {
 384         if (--nShowCount == 0)
 385             ResizableDockingWindow::Hide();
 386     }
 387 }
 388
 389 // Decreases the "show" reference count.
 390 // The window is hidden when the reference count reaches zero.
 391 void DockingWindow::Hide ()
 392 {
 393     Show(false);
 394 }
 395
 396 bool DockingWindow::Docking( const Point& rPos, tools::Rectangle& rRect )
 397 {
 398     if (aDockingRect.Contains(rPos))
 399     {
 400         rRect.SetSize(aDockingRect.GetSize());
 401         return false; // dock
 402     }
 403     else // adjust old size
 404     {
 405         if (!aFloatingRect.IsEmpty())
 406             rRect.SetSize(aFloatingRect.GetSize());
 407         return true; // float
 408     }
 409 }
 410
 411 void DockingWindow::EndDocking( const tools::Rectangle& rRect, bool bFloatMode )
 412 {
 413     if ( bFloatMode )
 414         ResizableDockingWindow::EndDocking( rRect, bFloatMode );
 415     else
 416     {
 417         SetFloatingMode(false);
 418         DockThis();
 419     }
 420 }
 421
 422 void DockingWindow::ToggleFloatingMode()
 423 {
 424     if (IsFloatingMode())
 425     {
 426         if (!aFloatingRect.IsEmpty())
 427             SetPosSizePixel(
 428                 GetParent()->ScreenToOutputPixel(aFloatingRect.TopLeft()),
 429                 aFloatingRect.GetSize()
 430             );
 431     }
 432     DockThis();
 433 }
 434
 435 bool DockingWindow::PrepareToggleFloatingMode()
 436 {
 437     if (IsFloatingMode())
 438     {
 439         // memorize position and size on the desktop...
 440         aFloatingRect = tools::Rectangle(
 441             GetParent()->OutputToScreenPixel(GetPosPixel()),
 442             GetSizePixel()
 443         );
 444     }
 445     return true;
 446 }
 447
 448 void DockingWindow::StartDocking()
 449 {
 450     if (IsFloatingMode())
 451     {
 452         aFloatingRect = tools::Rectangle(
 453             GetParent()->OutputToScreenPixel(GetPosPixel()),
 454             GetSizePixel()
 455         );
 456     }
 457 }
 458
 459 void DockingWindow::DockThis ()
 460 {
 461     // resizing when floating -> docking
 462     if (!IsFloatingMode())
 463     {
 464         Point const aPos = aDockingRect.TopLeft();
 465         Size const aSize = aDockingRect.GetSize();
 466         if (aSize != GetSizePixel() || aPos != GetPosPixel())
 467             SetPosSizePixel(aPos, aSize);
 468     }
 469
 470     if (pLayout)
 471     {
 472         if (!IsFloatingMode() && GetParent() != pLayout)
 473             SetParent(pLayout);
 474         pLayout->ArrangeWindows();
 475     }
 476 }
 477
 478 TabBar::TabBar( vcl::Window* pParent ) :
 479     ::TabBar( pParent, WinBits( WB_3DLOOK | WB_SCROLL | WB_BORDER | WB_DRAG ) )
 480 {
 481     EnableEditMode();
 482
 483     SetHelpId( HID_BASICIDE_TABBAR );
 484 }
 485
 486 void TabBar::MouseButtonDown( const MouseEvent& rMEvt )
 487 {
 488     if ( rMEvt.IsLeft() && ( rMEvt.GetClicks() == 2 ) && !IsInEditMode() )
 489     {
 490         if (SfxDispatcher* pDispatcher = GetDispatcher())
 491             pDispatcher->Execute( SID_BASICIDE_MODULEDLG );
 492     }
 493     else
 494     {
 495         ::TabBar::MouseButtonDown( rMEvt ); // base class version
 496     }
 497 }
 498
 499 void TabBar::Command( const CommandEvent& rCEvt )
 500 {
 501     if ( ( rCEvt.GetCommand() == CommandEventId::ContextMenu ) && !IsInEditMode() )
 502     {
 503         Point aPos( rCEvt.IsMouseEvent() ? rCEvt.GetMousePosPixel() : Point(1,1) );
 504         if ( rCEvt.IsMouseEvent() )     // select right tab
 505         {
 506             Point aP = PixelToLogic( aPos );
 507             MouseEvent aMouseEvent( aP, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT );
 508             ::TabBar::MouseButtonDown( aMouseEvent ); // base class
 509         }
 510         if (SfxDispatcher* pDispatcher = GetDispatcher())
 511             pDispatcher->ExecutePopup("tabbar", this, &aPos);
 512     }
 513 }
 514
 515 TabBarAllowRenamingReturnCode TabBar::AllowRenaming()
 516 {
 517     bool const bValid = IsValidSbxName(GetEditText());
 518
 519     if ( !bValid )
 520     {
 521         std::unique_ptr<weld::MessageDialog> xError(Application::CreateMessageDialog(GetFrameWeld(),
 522                                                     VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_BADSBXNAME)));
 523         xError->run();
 524     }
 525
 526     return bValid ? TABBAR_RENAMING_YES : TABBAR_RENAMING_NO;
 527 }
 528
 529
 530 void TabBar::EndRenaming()
 531 {
 532     if ( !IsEditModeCanceled() )
 533     {
 534         SfxUInt16Item aID( SID_BASICIDE_ARG_TABID, GetEditPageId() );
 535         SfxStringItem aNewName( SID_BASICIDE_ARG_MODULENAME, GetEditText() );
 536         if (SfxDispatcher* pDispatcher = GetDispatcher())
 537             pDispatcher->ExecuteList( SID_BASICIDE_NAMECHANGEDONTAB,
 538                       SfxCallMode::SYNCHRON, { &aID, &aNewName });
 539     }
 540 }
 541
 542
 543 namespace
 544 {
 545
 546 // helper class for sorting TabBar
 547 struct TabBarSortHelper
 548 {
 549     sal_uInt16      nPageId;
 550     OUString        aPageText;
 551
 552     bool operator < (TabBarSortHelper const& rComp) const
 553     {
 554         return aPageText.compareToIgnoreAsciiCase(rComp.aPageText) < 0;
 555     }
 556 };
 557
 558 } // namespace
 559
 560 void TabBar::Sort()
 561 {
 562     Shell* pShell = GetShell();
 563     if (!pShell)
 564         return;
 565
 566     Shell::WindowTable& aWindowTable = pShell->GetWindowTable();
 567     TabBarSortHelper aTabBarSortHelper;
 568     std::vector<TabBarSortHelper> aModuleList;
 569     std::vector<TabBarSortHelper> aDialogList;
 570     sal_uInt16 nPageCount = GetPageCount();
 571     sal_uInt16 i;
 572
 573     // create module and dialog lists for sorting
 574     for ( i = 0; i < nPageCount; i++)
 575     {
 576         sal_uInt16 nId = GetPageId( i );
 577         aTabBarSortHelper.nPageId = nId;
 578         aTabBarSortHelper.aPageText = GetPageText( nId );
 579         BaseWindow* pWin = aWindowTable[ nId ].get();
 580
 581         if (dynamic_cast<ModulWindow*>(pWin))
 582         {
 583             aModuleList.push_back( aTabBarSortHelper );
 584         }
 585         else if (dynamic_cast<DialogWindow*>(pWin))
 586         {
 587             aDialogList.push_back( aTabBarSortHelper );
 588         }
 589     }
 590
 591     // sort module and dialog lists by page text
 592     std::sort( aModuleList.begin() , aModuleList.end() );
 593     std::sort( aDialogList.begin() , aDialogList.end() );
 594
 595
 596     sal_uInt16 nModules = sal::static_int_cast<sal_uInt16>( aModuleList.size() );
 597     sal_uInt16 nDialogs = sal::static_int_cast<sal_uInt16>( aDialogList.size() );
 598
 599     // move module pages to new positions
 600     for (i = 0; i < nModules; i++)
 601     {
 602         MovePage( aModuleList[i].nPageId , i );
 603     }
 604
 605     // move dialog pages to new positions
 606     for (i = 0; i < nDialogs; i++)
 607     {
 608         MovePage( aDialogList[i].nPageId , nModules + i );
 609     }
 610 }
 611
 612 void CutLines( OUString& rStr, sal_Int32 nStartLine, sal_Int32 nLines )
 613 {
 614     sal_Int32 nStartPos = 0;
 615     sal_Int32 nLine = 0;
 616     while ( nLine < nStartLine )
 617     {
 618         nStartPos = searchEOL( rStr, nStartPos );
 619         if( nStartPos == -1 )
 620             break;
 621         nStartPos++;    // not the \n.
 622         nLine++;
 623     }
 624
 625     SAL_WARN_IF( nStartPos == -1, "basctl.basicide", "CutLines: Start line not found!" );
 626
 627     if ( nStartPos == -1 )
 628         return;
 629
 630     sal_Int32 nEndPos = nStartPos;
 631
 632     for ( sal_Int32 i = 0; i < nLines; i++ )
 633         nEndPos = searchEOL( rStr, nEndPos+1 );
 634
 635     if ( nEndPos == -1 ) // might happen at the last line
 636         nEndPos = rStr.getLength();
 637     else
 638         nEndPos++;
 639
 640     rStr = OUString::Concat(rStr.subView( 0, nStartPos )) + rStr.subView( nEndPos );
 641
 642     // erase trailing empty lines
 643     {
 644         sal_Int32 n = nStartPos;
 645         sal_Int32 nLen = rStr.getLength();
 646         while ( ( n < nLen ) && ( rStr[ n ] == LINE_SEP ||
 647                                   rStr[ n ] == LINE_SEP_CR ) )
 648         {
 649             n++;
 650         }
 651
 652         if ( n > nStartPos )
 653         {
 654             rStr = OUString::Concat(rStr.subView( 0, nStartPos )) + rStr.subView( n );
 655         }
 656     }
 657 }
 658
 659 sal_uInt32 CalcLineCount( SvStream& rStream )
 660 {
 661     sal_uInt32 nLFs = 0;
 662     sal_uInt32 nCRs = 0;
 663     char c;
 664
 665     rStream.Seek( 0 );
 666     rStream.ReadChar( c );
 667     while ( !rStream.eof() )
 668     {
 669         if ( c == '\n' )
 670             nLFs++;
 671         else if ( c == '\r' )
 672             nCRs++;
 673         rStream.ReadChar( c );
 674     }
 675
 676     rStream.Seek( 0 );
 677     if ( nLFs > nCRs )
 678         return nLFs;
 679     return nCRs;
 680 }
 681
 682
 683 // LibInfo
 684
 685
 686 LibInfo::LibInfo ()
 687 { }
 688
 689 LibInfo::~LibInfo ()
 690 { }
 691
 692 void LibInfo::InsertInfo (
 693     ScriptDocument const& rDocument,
 694     OUString const& rLibName,
 695     OUString const& rCurrentName,
 696     ItemType eCurrentType
 697 )
 698 {
 699     Key aKey(rDocument, rLibName);
 700     m_aMap.erase(aKey);
 701     m_aMap.emplace(aKey, Item(rCurrentName, eCurrentType));
 702 }
 703
 704 void LibInfo::RemoveInfoFor (ScriptDocument const& rDocument)
 705 {
 706     Map::iterator it = std::find_if(m_aMap.begin(), m_aMap.end(),
 707         [&rDocument](Map::reference rEntry) { return rEntry.first.GetDocument() == rDocument; });
 708     if (it != m_aMap.end())
 709         m_aMap.erase(it);
 710 }
 711
 712 LibInfo::Item const* LibInfo::GetInfo (
 713     ScriptDocument const& rDocument, OUString const& rLibName
 714 )
 715 {
 716     Map::iterator it = m_aMap.find(Key(rDocument, rLibName));
 717     return it != m_aMap.end() ? &it->second : nullptr;
 718 }
 719
 720 LibInfo::Key::Key (ScriptDocument aDocument, OUString aLibName) :
 721     m_aDocument(std::move(aDocument)), m_aLibName(std::move(aLibName))
 722 { }
 723
 724 bool LibInfo::Key::operator == (Key const& rKey) const
 725 {
 726     return m_aDocument == rKey.m_aDocument && m_aLibName == rKey.m_aLibName;
 727 }
 728
 729 size_t LibInfo::Key::Hash::operator () (Key const& rKey) const
 730 {
 731     std::size_t seed = 0;
 732     o3tl::hash_combine(seed, rKey.m_aDocument.hashCode());
 733     o3tl::hash_combine(seed, rKey.m_aLibName.hashCode());
 734     return seed;
 735 }
 736
 737 LibInfo::Item::Item (
 738     OUString aCurrentName,
 739     ItemType eCurrentType
 740 ) :
 741     m_aCurrentName(std::move(aCurrentName)),
 742     m_eCurrentType(eCurrentType)
 743 { }
 744
 745 static bool QueryDel(std::u16string_view rName, const OUString &rStr, weld::Widget* pParent)
 746 {
 747     OUString aName = OUString::Concat("\'") + rName + "\'";
 748     OUString aQuery = rStr.replaceAll("XX", aName);
 749     std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(pParent,
 750                                                    VclMessageType::Question, VclButtonsType::YesNo, aQuery));
 751     return (xQueryBox->run() == RET_YES);
 752 }
 753
 754 bool QueryDelMacro( std::u16string_view rName, weld::Widget* pParent )
 755 {
 756     return QueryDel( rName, IDEResId( RID_STR_QUERYDELMACRO ), pParent );
 757 }
 758
 759 bool QueryReplaceMacro( std::u16string_view rName, weld::Widget* pParent )
 760 {
 761     return QueryDel( rName, IDEResId( RID_STR_QUERYREPLACEMACRO ), pParent );
 762 }
 763
 764 bool QueryDelDialog( std::u16string_view rName, weld::Widget* pParent )
 765 {
 766     return QueryDel( rName, IDEResId( RID_STR_QUERYDELDIALOG ), pParent );
 767 }
 768
 769 bool QueryDelLib( std::u16string_view rName, bool bRef, weld::Widget* pParent )
 770 {
 771     return QueryDel( rName, IDEResId( bRef ? RID_STR_QUERYDELLIBREF : RID_STR_QUERYDELLIB ), pParent );
 772 }
 773
 774 bool QueryDelModule( std::u16string_view rName, weld::Widget* pParent )
 775 {
 776     return QueryDel( rName, IDEResId( RID_STR_QUERYDELMODULE ), pParent );
 777 }
 778
 779 bool QueryPassword(weld::Widget* pDialogParent, const Reference< script::XLibraryContainer >& xLibContainer, const OUString& rLibName, OUString& rPassword, bool bRepeat, bool bNewTitle)
 780 {
 781     bool bOK = false;
 782     sal_uInt16 nRet = 0;
 783
 784     do
 785     {
 786         // password dialog
 787         SfxPasswordDialog aDlg(pDialogParent);
 788         aDlg.SetMinLen(1);
 789
 790         // set new title
 791         if ( bNewTitle )
 792         {
 793             OUString aTitle(IDEResId(RID_STR_ENTERPASSWORD));
 794             aTitle = aTitle.replaceAll("XX", rLibName);
 795             aDlg.set_title(aTitle);
 796         }
 797
 798         // execute dialog
 799         nRet = aDlg.run();
 800
 801         // verify password
 802         if ( nRet == RET_OK )
 803         {
 804             if ( xLibContainer.is() && xLibContainer->hasByName( rLibName ) )
 805             {
 806                 Reference< script::XLibraryContainerPassword > xPasswd( xLibContainer, UNO_QUERY );
 807                 if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( rLibName ) && !xPasswd->isLibraryPasswordVerified( rLibName ) )
 808                 {
 809                     rPassword = aDlg.GetPassword();
 810                     bOK = xPasswd->verifyLibraryPassword( rLibName, rPassword );
 811
 812                     if ( !bOK )
 813                     {
 814                         std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(pDialogParent,
 815                                                                        VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_WRONGPASSWORD)));
 816                         xErrorBox->run();
 817                     }
 818                 }
 819             }
 820         }
 821     }
 822     while ( bRepeat && !bOK && nRet == RET_OK );
 823
 824     return bOK;
 825 }
 826
 827
 828 } // namespace basctl
 829
 830 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */