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