basctl/source/basicide/bastypes.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: bastypes.cxx,v $
  10  * $Revision: 1.32.30.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basctl.hxx"
  33
  34
  35 #include <vector>
  36 #include <algorithm>
  37
  38 #include <ide_pch.hxx>
  39
  40
  41 #include <basic/sbx.hxx>
  42 #include <helpid.hrc>
  43 #include <basidesh.hrc>
  44 #include <bastypes.hxx>
  45 #include <bastype2.hxx>
  46 #include <baside2.hxx>  // Leider brauche ich teilweise pModulWindow...
  47 #include <baside3.hxx>
  48 #include <baside2.hrc>
  49 #include <svtools/textview.hxx>
  50 #include <svtools/texteng.hxx>
  51 #include <basobj.hxx>
  52 #include <sbxitem.hxx>
  53 #include <iderdll.hxx>
  54
  55 #ifndef _PASSWD_HXX //autogen
  56 #include <sfx2/passwd.hxx>
  57 #endif
  58
  59 #ifndef _COM_SUN_STAR_SCRIPT_XLIBRYARYCONTAINER2_HPP_
  60 #include <com/sun/star/script/XLibraryContainer2.hpp>
  61 #endif
  62 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  63 #include <com/sun/star/script/ModuleType.hpp>
  64
  65 using namespace ::com::sun::star::uno;
  66 using namespace ::com::sun::star;
  67
  68
  69 DBG_NAME( IDEBaseWindow )
  70
  71 const char* pRegName = "BasicIDETabBar";
  72
  73 TYPEINIT0( IDEBaseWindow )
  74 TYPEINIT1( SbxItem, SfxPoolItem );
  75
  76 IDEBaseWindow::IDEBaseWindow( Window* pParent, const ScriptDocument& rDocument, String aLibName, String aName )
  77     :Window( pParent, WinBits( WB_3DLOOK ) )
  78     ,m_aDocument( rDocument )
  79     ,m_aLibName( aLibName )
  80     ,m_aName( aName )
  81 {
  82     DBG_CTOR( IDEBaseWindow, 0 );
  83     pShellHScrollBar = 0;
  84     pShellVScrollBar = 0;
  85     nStatus     = 0;
  86 }
  87
  88
  89
  90 __EXPORT IDEBaseWindow::~IDEBaseWindow()
  91 {
  92     DBG_DTOR( IDEBaseWindow, 0 );
  93     if ( pShellVScrollBar )
  94         pShellVScrollBar->SetScrollHdl( Link() );
  95     if ( pShellHScrollBar )
  96         pShellHScrollBar->SetScrollHdl( Link() );
  97 }
  98
  99
 100
 101 void IDEBaseWindow::Init()
 102 {
 103     DBG_CHKTHIS( IDEBaseWindow, 0 );
 104     if ( pShellVScrollBar )
 105         pShellVScrollBar->SetScrollHdl( LINK( this, IDEBaseWindow, ScrollHdl ) );
 106     if ( pShellHScrollBar )
 107         pShellHScrollBar->SetScrollHdl( LINK( this, IDEBaseWindow, ScrollHdl ) );
 108     DoInit();   // virtuell...
 109 }
 110
 111
 112
 113 void __EXPORT IDEBaseWindow::DoInit()
 114 {
 115 }
 116
 117
 118
 119 void IDEBaseWindow::GrabScrollBars( ScrollBar* pHScroll, ScrollBar* pVScroll )
 120 {
 121     DBG_CHKTHIS( IDEBaseWindow, 0 );
 122     pShellHScrollBar = pHScroll;
 123     pShellVScrollBar = pVScroll;
 124 //      Init(); // macht kein Sinn, fuehrt zu flackern, fuehr zu Fehlern...
 125 }
 126
 127
 128
 129 IMPL_LINK_INLINE_START( IDEBaseWindow, ScrollHdl, ScrollBar *, pCurScrollBar )
 130 {
 131     DBG_CHKTHIS( IDEBaseWindow, 0 );
 132     DoScroll( pCurScrollBar );
 133     return 0;
 134 }
 135 IMPL_LINK_INLINE_END( IDEBaseWindow, ScrollHdl, ScrollBar *, pCurScrollBar )
 136
 137
 138
 139 void __EXPORT IDEBaseWindow::ExecuteCommand( SfxRequest& )
 140 {
 141     DBG_CHKTHIS( IDEBaseWindow, 0 );
 142 }
 143
 144
 145
 146 void __EXPORT IDEBaseWindow::GetState( SfxItemSet& )
 147 {
 148     DBG_CHKTHIS( IDEBaseWindow, 0 );
 149 }
 150
 151
 152 long IDEBaseWindow::Notify( NotifyEvent& rNEvt )
 153 {
 154     long nDone = 0;
 155
 156     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 157     {
 158         KeyEvent aKEvt = *rNEvt.GetKeyEvent();
 159         KeyCode aCode = aKEvt.GetKeyCode();
 160         USHORT nCode = aCode.GetCode();
 161
 162         switch ( nCode )
 163         {
 164             case KEY_PAGEUP:
 165             case KEY_PAGEDOWN:
 166             {
 167                 if ( aCode.IsMod1() )
 168                 {
 169                     BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 170                     if ( pIDEShell )
 171                         pIDEShell->NextPage( nCode == KEY_PAGEUP );
 172
 173                     nDone = 1;
 174                 }
 175             }
 176             break;
 177         }
 178     }
 179
 180     return nDone ? nDone : Window::Notify( rNEvt );
 181 }
 182
 183
 184 void __EXPORT IDEBaseWindow::DoScroll( ScrollBar* )
 185 {
 186     DBG_CHKTHIS( IDEBaseWindow, 0 );
 187 }
 188
 189
 190 void __EXPORT IDEBaseWindow::StoreData()
 191 {
 192 }
 193
 194 BOOL __EXPORT IDEBaseWindow::CanClose()
 195 {
 196     return TRUE;
 197 }
 198
 199 BOOL __EXPORT IDEBaseWindow::AllowUndo()
 200 {
 201     return TRUE;
 202 }
 203
 204
 205
 206 void __EXPORT IDEBaseWindow::UpdateData()
 207 {
 208 }
 209
 210
 211
 212 void __EXPORT IDEBaseWindow::PrintData( Printer* )
 213 {
 214 }
 215
 216
 217
 218 String __EXPORT IDEBaseWindow::GetTitle()
 219 {
 220     return String();
 221 }
 222
 223
 224
 225 String IDEBaseWindow::CreateQualifiedName()
 226 {
 227     String aName;
 228     if ( m_aLibName.Len() )
 229     {
 230         LibraryLocation eLocation = m_aDocument.getLibraryLocation( m_aLibName );
 231         aName = m_aDocument.getTitle( eLocation );
 232         aName += '.';
 233         aName += m_aLibName;
 234         aName += '.';
 235         aName += GetTitle();
 236     }
 237
 238     return aName;
 239 }
 240
 241 void IDEBaseWindow::SetReadOnly( BOOL )
 242 {
 243 }
 244
 245 BOOL IDEBaseWindow::IsReadOnly()
 246 {
 247     return FALSE;
 248 }
 249
 250 void __EXPORT IDEBaseWindow::BasicStarted()
 251 {
 252 }
 253
 254 void __EXPORT IDEBaseWindow::BasicStopped()
 255 {
 256 }
 257
 258 BOOL __EXPORT IDEBaseWindow::IsModified()
 259 {
 260     return TRUE;
 261 }
 262
 263 BOOL __EXPORT IDEBaseWindow::IsPasteAllowed()
 264 {
 265     return FALSE;
 266 }
 267
 268 Window* __EXPORT IDEBaseWindow::GetLayoutWindow()
 269 {
 270     return this;
 271 }
 272
 273 SfxUndoManager* __EXPORT IDEBaseWindow::GetUndoManager()
 274 {
 275     return NULL;
 276 }
 277
 278 BreakPointList::BreakPointList()
 279 {}
 280
 281 BreakPointList::BreakPointList(BreakPointList const & rList):
 282     BreakPL( sal::static_int_cast<USHORT>( rList.Count() ))
 283 {
 284     for (ULONG i = 0; i < rList.Count(); ++i)
 285         Insert(new BreakPoint(*rList.GetObject(i)), i);
 286 }
 287
 288 BreakPointList::~BreakPointList()
 289 {
 290     reset();
 291 }
 292
 293 void BreakPointList::reset()
 294 {
 295     while (Count() > 0)
 296         delete Remove(Count() - 1);
 297 }
 298
 299 void BreakPointList::transfer(BreakPointList & rList)
 300 {
 301     reset();
 302     for (ULONG i = 0; i < rList.Count(); ++i)
 303         Insert(rList.GetObject(i), i);
 304     rList.Clear();
 305 }
 306
 307 void BreakPointList::InsertSorted( BreakPoint* pNewBrk )
 308 {
 309     BreakPoint* pBrk = First();
 310     while ( pBrk )
 311     {
 312         if ( pNewBrk->nLine <= pBrk->nLine )
 313         {
 314             DBG_ASSERT( ( pBrk->nLine != pNewBrk->nLine ) || pNewBrk->bTemp, "BreakPoint existiert schon!" );
 315             Insert( pNewBrk );
 316             return;
 317         }
 318         pBrk = Next();
 319     }
 320     // Keine Einfuegeposition gefunden => LIST_APPEND
 321     Insert( pNewBrk, LIST_APPEND );
 322 }
 323
 324 void BreakPointList::SetBreakPointsInBasic( SbModule* pModule )
 325 {
 326     pModule->ClearAllBP();
 327
 328     BreakPoint* pBrk = First();
 329     while ( pBrk )
 330     {
 331         if ( pBrk->bEnabled )
 332             pModule->SetBP( (USHORT)pBrk->nLine );
 333         pBrk = Next();
 334     }
 335 }
 336
 337 BreakPoint*     BreakPointList::FindBreakPoint( ULONG nLine )
 338 {
 339     BreakPoint* pBrk = First();
 340     while ( pBrk )
 341     {
 342         if ( pBrk->nLine == nLine )
 343             return pBrk;
 344
 345         pBrk = Next();
 346     }
 347
 348     return (BreakPoint*)0;
 349 }
 350
 351
 352
 353 void BreakPointList::AdjustBreakPoints( ULONG nLine, BOOL bInserted )
 354 {
 355     BreakPoint* pBrk = First();
 356     while ( pBrk )
 357     {
 358         BOOL bDelBrk = FALSE;
 359         if ( pBrk->nLine == nLine )
 360         {
 361             if ( bInserted )
 362                 pBrk->nLine++;
 363             else
 364                 bDelBrk = TRUE;
 365         }
 366         else if ( pBrk->nLine > nLine )
 367         {
 368             if ( bInserted )
 369                 pBrk->nLine++;
 370             else
 371                 pBrk->nLine--;
 372         }
 373
 374         if ( bDelBrk )
 375         {
 376             ULONG n = GetCurPos();
 377             delete Remove( pBrk );
 378             pBrk = Seek( n );
 379         }
 380         else
 381         {
 382             pBrk = Next();
 383         }
 384     }
 385 }
 386
 387 void BreakPointList::ResetHitCount()
 388 {
 389     BreakPoint* pBrk = First();
 390     while ( pBrk )
 391     {
 392         pBrk->nHitCount = 0;
 393         pBrk = Next();
 394     }
 395 }
 396
 397 void IDEBaseWindow::Deactivating()
 398 {
 399 }
 400
 401 USHORT __EXPORT IDEBaseWindow::GetSearchOptions()
 402 {
 403     return 0;
 404 }
 405
 406
 407 BasicDockingWindow::BasicDockingWindow( Window* pParent ) :
 408     DockingWindow( pParent,     WB_BORDER | WB_3DLOOK | WB_DOCKABLE | WB_MOVEABLE |
 409                             WB_SIZEABLE | WB_ROLLABLE |
 410                             WB_DOCKABLE | WB_CLIPCHILDREN )
 411 {
 412 }
 413
 414
 415
 416 BOOL __EXPORT BasicDockingWindow::Docking( const Point& rPos, Rectangle& rRect )
 417 {
 418     ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent();
 419     Rectangle aTmpRec( rRect );
 420     BOOL bDock = IsDockingPrevented() ? FALSE : pLayout->IsToBeDocked( this, rPos, aTmpRec );
 421     if ( bDock )
 422     {
 423         rRect.SetSize( aTmpRec.GetSize() );
 424     }
 425     else        // Alte Groesse einstellen
 426     {
 427         if ( !aFloatingPosAndSize.IsEmpty() )
 428             rRect.SetSize( aFloatingPosAndSize.GetSize() );
 429     }
 430     return !bDock;      // bFloat
 431 }
 432
 433
 434
 435 void __EXPORT BasicDockingWindow::EndDocking( const Rectangle& rRect, BOOL bFloatMode )
 436 {
 437     if ( bFloatMode )
 438         DockingWindow::EndDocking( rRect, bFloatMode );
 439     else
 440     {
 441         SetFloatingMode( FALSE );
 442         ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent();
 443         pLayout->DockaWindow( this );
 444     }
 445 }
 446
 447
 448
 449 void __EXPORT BasicDockingWindow::ToggleFloatingMode()
 450 {
 451     ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent();
 452     if ( IsFloatingMode() )
 453     {
 454         if ( !aFloatingPosAndSize.IsEmpty() )
 455             SetPosSizePixel( GetParent()->ScreenToOutputPixel( aFloatingPosAndSize.TopLeft() ),
 456                 aFloatingPosAndSize.GetSize() );
 457     }
 458     pLayout->DockaWindow( this );
 459 }
 460
 461
 462
 463 BOOL __EXPORT BasicDockingWindow::PrepareToggleFloatingMode()
 464 {
 465     if ( IsFloatingMode() )
 466     {
 467         // Position und Groesse auf dem Desktop merken...
 468         aFloatingPosAndSize.SetPos( GetParent()->OutputToScreenPixel( GetPosPixel() ) );
 469         aFloatingPosAndSize.SetSize( GetSizePixel() );
 470     }
 471     return TRUE;
 472 }
 473
 474
 475
 476 void __EXPORT BasicDockingWindow::StartDocking()
 477 {
 478     // Position und Groesse auf dem Desktop merken...
 479     if ( IsFloatingMode() )
 480     {
 481         aFloatingPosAndSize.SetPos( GetParent()->OutputToScreenPixel( GetPosPixel() ) );
 482         aFloatingPosAndSize.SetSize( GetSizePixel() );
 483     }
 484 }
 485
 486
 487
 488 ExtendedEdit::ExtendedEdit( Window* pParent, IDEResId nRes ) :
 489     Edit( pParent, nRes )
 490 {
 491     aAcc.SetSelectHdl( LINK( this, ExtendedEdit, EditAccHdl ) );
 492     Control::SetGetFocusHdl( LINK( this, ExtendedEdit, ImplGetFocusHdl ) );
 493     Control::SetLoseFocusHdl( LINK( this, ExtendedEdit, ImplLoseFocusHdl ) );
 494 }
 495
 496 IMPL_LINK( ExtendedEdit, ImplGetFocusHdl, Control*, EMPTYARG )
 497 {
 498     Application::InsertAccel( &aAcc );
 499     aLoseFocusHdl.Call( this );
 500     return 0;
 501 }
 502
 503
 504 IMPL_LINK( ExtendedEdit, ImplLoseFocusHdl, Control*, EMPTYARG )
 505 {
 506     Application::RemoveAccel( &aAcc );
 507     return 0;
 508 }
 509
 510
 511 IMPL_LINK_INLINE_START( ExtendedEdit, EditAccHdl, Accelerator *, pAcc )
 512 {
 513     aAccHdl.Call( pAcc );
 514     return 0;
 515 }
 516 IMPL_LINK_INLINE_END( ExtendedEdit, EditAccHdl, Accelerator *, pAcc )
 517
 518
 519
 520 struct TabBarDDInfo
 521 {
 522     ULONG       npTabBar;
 523     USHORT      nPage;
 524
 525     TabBarDDInfo() { npTabBar = 0; nPage = 0; }
 526     TabBarDDInfo( ULONG _npTabBar, USHORT _nPage ) { npTabBar = _npTabBar; nPage = _nPage; }
 527 };
 528
 529
 530 BasicIDETabBar::BasicIDETabBar( Window* pParent ) :
 531     TabBar( pParent, WinBits( WB_3DLOOK | WB_SCROLL | WB_BORDER | WB_SIZEABLE | WB_DRAG ) )
 532 {
 533     EnableEditMode( TRUE );
 534
 535     SetHelpId( HID_BASICIDE_TABBAR );
 536 }
 537
 538 void __EXPORT BasicIDETabBar::MouseButtonDown( const MouseEvent& rMEvt )
 539 {
 540     if ( rMEvt.IsLeft() && ( rMEvt.GetClicks() == 2 ) && !IsInEditMode() )
 541     {
 542         BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 543         SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL;
 544         SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL;
 545         if( pDispatcher )
 546         {
 547             pDispatcher->Execute( SID_BASICIDE_MODULEDLG );
 548         }
 549     }
 550     else
 551     {
 552         TabBar::MouseButtonDown( rMEvt );
 553     }
 554 }
 555
 556 void __EXPORT BasicIDETabBar::Command( const CommandEvent& rCEvt )
 557 {
 558     if ( ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ) && !IsInEditMode() )
 559     {
 560         Point aPos( rCEvt.IsMouseEvent() ? rCEvt.GetMousePosPixel() : Point(1,1) );
 561         if ( rCEvt.IsMouseEvent() )     // Richtige Tab selektieren
 562         {
 563             Point aP = PixelToLogic( aPos );
 564             MouseEvent aMouseEvent( aP, 1, MOUSE_SIMPLECLICK, MOUSE_LEFT );
 565             TabBar::MouseButtonDown( aMouseEvent );
 566         }
 567
 568         PopupMenu aPopup( IDEResId( RID_POPUP_TABBAR ) );
 569         if ( GetPageCount() == 0 )
 570         {
 571             aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE );
 572             aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE );
 573             aPopup.EnableItem( SID_BASICIDE_HIDECURPAGE, FALSE );
 574         }
 575
 576         if ( StarBASIC::IsRunning() )
 577         {
 578             aPopup.EnableItem(SID_BASICIDE_DELETECURRENT, false);
 579             aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, false);
 580             aPopup.EnableItem(SID_BASICIDE_MODULEDLG, false);
 581         }
 582
 583         BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 584         if ( pIDEShell )
 585         {
 586             ScriptDocument aDocument( pIDEShell->GetCurDocument() );
 587             ::rtl::OUString aOULibName( pIDEShell->GetCurLibName() );
 588             Reference< script::XLibraryContainer2 > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
 589             Reference< script::XLibraryContainer2 > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
 590             if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && xModLibContainer->isLibraryReadOnly( aOULibName ) ) ||
 591                  ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && xDlgLibContainer->isLibraryReadOnly( aOULibName ) ) )
 592             {
 593                 aPopup.EnableItem( aPopup.GetItemId( 0 ), FALSE );
 594                 aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE );
 595                 aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE );
 596                 aPopup.RemoveDisabledEntries();
 597             }
 598
 599                         // disable to delete or remove object modules in IDE
 600                         BasicManager* pBasMgr = aDocument.getBasicManager();
 601                         if ( pBasMgr )
 602                         {
 603                                 StarBASIC* pBasic = pBasMgr->GetLib( aOULibName );
 604                                 if( pBasic )
 605                                 {
 606                                         IDEWindowTable& aIDEWindowTable = pIDEShell->GetIDEWindowTable();
 607                                         IDEBaseWindow* pWin = aIDEWindowTable.Get( GetCurPageId() );
 608                                         if( pWin && pWin->ISA( ModulWindow ) )
 609                                         {
 610                                                 SbModule* pActiveModule = (SbModule*)pBasic->FindModule( pWin->GetName() );
 611                                                 if( pActiveModule && ( pActiveModule->GetModuleType() == script::ModuleType::Document ) )
 612                                                 {
 613                                                         aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE );
 614                                                         aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE );
 615         }
 616                                         }
 617                                 }
 618                         }
 619         }
 620
 621
 622         SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL;
 623         SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL;
 624         if ( pDispatcher )
 625             pDispatcher->Execute( aPopup.Execute( this, aPos ) );
 626     }
 627 }
 628
 629 long BasicIDETabBar::AllowRenaming()
 630 {
 631     BOOL bValid = BasicIDE::IsValidSbxName( GetEditText() );
 632
 633     if ( !bValid )
 634         ErrorBox( this, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_BADSBXNAME ) ) ).Execute();
 635
 636     return bValid ? TABBAR_RENAMING_YES : TABBAR_RENAMING_NO;
 637 }
 638
 639
 640 void __EXPORT BasicIDETabBar::EndRenaming()
 641 {
 642     if ( !IsEditModeCanceled() )
 643     {
 644         SfxUInt16Item aID( SID_BASICIDE_ARG_TABID, GetEditPageId() );
 645         SfxStringItem aNewName( SID_BASICIDE_ARG_MODULENAME, GetEditText() );
 646         BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 647         SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL;
 648         SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL;
 649         if( pDispatcher )
 650         {
 651             pDispatcher->Execute( SID_BASICIDE_NAMECHANGEDONTAB,
 652                                   SFX_CALLMODE_SYNCHRON, &aID, &aNewName, 0L );
 653         }
 654     }
 655 }
 656
 657
 658 void BasicIDETabBar::Sort()
 659 {
 660     BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 661     if ( pIDEShell )
 662     {
 663         IDEWindowTable& aIDEWindowTable = pIDEShell->GetIDEWindowTable();
 664         TabBarSortHelper aTabBarSortHelper;
 665         ::std::vector<TabBarSortHelper> aModuleList;
 666         ::std::vector<TabBarSortHelper> aDialogList;
 667         USHORT nPageCount = GetPageCount();
 668         USHORT i;
 669
 670         // create module and dialog lists for sorting
 671         for ( i = 0; i < nPageCount; i++)
 672         {
 673             USHORT nId = GetPageId( i );
 674             aTabBarSortHelper.nPageId = nId;
 675             aTabBarSortHelper.aPageText = GetPageText( nId );
 676             IDEBaseWindow* pWin = aIDEWindowTable.Get( nId );
 677
 678             if ( pWin->IsA( TYPE( ModulWindow ) ) )
 679             {
 680                 aModuleList.push_back( aTabBarSortHelper );
 681             }
 682             else if ( pWin->IsA( TYPE( DialogWindow ) ) )
 683             {
 684                 aDialogList.push_back( aTabBarSortHelper );
 685             }
 686         }
 687
 688         // sort module and dialog lists by page text
 689         ::std::sort( aModuleList.begin() , aModuleList.end() );
 690         ::std::sort( aDialogList.begin() , aDialogList.end() );
 691
 692
 693         USHORT nModules = sal::static_int_cast<USHORT>( aModuleList.size() );
 694         USHORT nDialogs = sal::static_int_cast<USHORT>( aDialogList.size() );
 695
 696         // move module pages to new positions
 697         for (i = 0; i < nModules; i++)
 698         {
 699             MovePage( aModuleList[i].nPageId , i );
 700         }
 701
 702         // move dialog pages to new positions
 703         for (i = 0; i < nDialogs; i++)
 704         {
 705             MovePage( aDialogList[i].nPageId , nModules + i );
 706         }
 707     }
 708 }
 709
 710 void CutLines( ::rtl::OUString& rStr, sal_Int32 nStartLine, sal_Int32 nLines, BOOL bEraseTrailingEmptyLines )
 711 {
 712     sal_Int32 nStartPos = 0;
 713     sal_Int32 nEndPos = 0;
 714     sal_Int32 nLine = 0;
 715     while ( nLine < nStartLine )
 716     {
 717         nStartPos = searchEOL( rStr, nStartPos );
 718         if( nStartPos == -1 )
 719             break;
 720         nStartPos++;    // nicht das \n.
 721         nLine++;
 722     }
 723
 724     DBG_ASSERTWARNING( nStartPos != -1, "CutLines: Startzeile nicht gefunden!" );
 725
 726     if ( nStartPos != -1 )
 727     {
 728         nEndPos = nStartPos;
 729         for ( sal_Int32 i = 0; i < nLines; i++ )
 730             nEndPos = searchEOL( rStr, nEndPos+1 );
 731
 732         if ( nEndPos == -1 ) // kann bei letzter Zeile passieren
 733             nEndPos = rStr.getLength();
 734         else
 735             nEndPos++;
 736
 737         ::rtl::OUString aEndStr = rStr.copy( nEndPos );
 738         rStr = rStr.copy( 0, nStartPos );
 739         rStr += aEndStr;
 740     }
 741     if ( bEraseTrailingEmptyLines )
 742     {
 743         sal_Int32 n = nStartPos;
 744         sal_Int32 nLen = rStr.getLength();
 745         while ( ( n < nLen ) && ( rStr.getStr()[ n ] == LINE_SEP ||
 746                                   rStr.getStr()[ n ] == LINE_SEP_CR ) )
 747         {
 748             n++;
 749         }
 750
 751         if ( n > nStartPos )
 752         {
 753             ::rtl::OUString aEndStr = rStr.copy( n );
 754             rStr = rStr.copy( 0, nStartPos );
 755             rStr += aEndStr;
 756         }
 757     }
 758 }
 759
 760 ULONG CalcLineCount( SvStream& rStream )
 761 {
 762     ULONG nLFs = 0;
 763     ULONG nCRs = 0;
 764     char c;
 765
 766     rStream.Seek( 0 );
 767     rStream >> c;
 768     while ( !rStream.IsEof() )
 769     {
 770         if ( c == '\n' )
 771             nLFs++;
 772         else if ( c == '\r' )
 773             nCRs++;
 774         rStream >> c;
 775     }
 776
 777     rStream.Seek( 0 );
 778     if ( nLFs > nCRs )
 779         return nLFs;
 780     return nCRs;
 781 }
 782
 783 LibInfoKey::LibInfoKey( const ScriptDocument& rDocument, const String& rLibName )
 784     :m_aDocument( rDocument )
 785     ,m_aLibName( rLibName )
 786 {
 787 }
 788
 789 LibInfoKey::~LibInfoKey()
 790 {
 791 }
 792
 793 LibInfoKey::LibInfoKey( const LibInfoKey& rKey )
 794     :m_aDocument( rKey.m_aDocument )
 795     ,m_aLibName( rKey.m_aLibName )
 796 {
 797 }
 798
 799 LibInfoKey& LibInfoKey::operator=( const LibInfoKey& rKey )
 800 {
 801     m_aDocument = rKey.m_aDocument;
 802     m_aLibName = rKey.m_aLibName;
 803     return *this;
 804 }
 805
 806 bool LibInfoKey::operator==( const LibInfoKey& rKey ) const
 807 {
 808     bool bRet = false;
 809     if ( m_aDocument == rKey.m_aDocument && m_aLibName == rKey.m_aLibName )
 810         bRet = true;
 811     return bRet;
 812 }
 813
 814 LibInfoItem::LibInfoItem( const ScriptDocument& rDocument, const String& rLibName, const String& rCurrentName, USHORT nCurrentType )
 815     :m_aDocument( rDocument )
 816     ,m_aLibName( rLibName )
 817     ,m_aCurrentName( rCurrentName )
 818     ,m_nCurrentType( nCurrentType )
 819 {
 820 }
 821
 822 LibInfoItem::~LibInfoItem()
 823 {
 824 }
 825
 826 LibInfoItem::LibInfoItem( const LibInfoItem& rItem )
 827     :m_aDocument( rItem.m_aDocument )
 828     ,m_aLibName( rItem.m_aLibName )
 829     ,m_aCurrentName( rItem.m_aCurrentName )
 830     ,m_nCurrentType( rItem.m_nCurrentType )
 831 {
 832 }
 833
 834 LibInfoItem& LibInfoItem::operator=( const LibInfoItem& rItem )
 835 {
 836     m_aDocument = rItem.m_aDocument;
 837     m_aLibName = rItem.m_aLibName;
 838     m_aCurrentName = rItem.m_aCurrentName;
 839     m_nCurrentType = rItem.m_nCurrentType;
 840
 841     return *this;
 842 }
 843
 844 LibInfos::LibInfos()
 845 {
 846 }
 847
 848 LibInfos::~LibInfos()
 849 {
 850     LibInfoMap::iterator end = m_aLibInfoMap.end();
 851     for ( LibInfoMap::iterator it = m_aLibInfoMap.begin(); it != end; ++it )
 852         delete it->second;
 853     m_aLibInfoMap.clear();
 854 }
 855
 856 void LibInfos::InsertInfo( LibInfoItem* pItem )
 857 {
 858     LibInfoKey aKey( pItem->GetDocument(), pItem->GetLibName() );
 859     LibInfoMap::iterator it = m_aLibInfoMap.find( aKey );
 860     if ( it != m_aLibInfoMap.end() )
 861     {
 862         LibInfoItem* pI = it->second;
 863         m_aLibInfoMap.erase( it );
 864         delete pI;
 865     }
 866     m_aLibInfoMap.insert( LibInfoMap::value_type( aKey, pItem ) );
 867 }
 868
 869 void LibInfos::RemoveInfoFor( const ScriptDocument& _rDocument )
 870 {
 871     for (   LibInfoMap::iterator it = m_aLibInfoMap.begin();
 872             it != m_aLibInfoMap.end();
 873         )
 874     {
 875         if ( it->first.GetDocument() != _rDocument )
 876         {
 877             ++it;
 878             continue;
 879         }
 880
 881         LibInfoItem* pItem = it->second;
 882
 883         LibInfoMap::iterator next_it = it; ++next_it;
 884         m_aLibInfoMap.erase( it );
 885         it = next_it;
 886
 887         delete pItem;
 888     }
 889 }
 890
 891 LibInfoItem* LibInfos::GetInfo( const LibInfoKey& rKey )
 892 {
 893     LibInfoItem* pItem = 0;
 894     LibInfoMap::iterator it = m_aLibInfoMap.find( rKey );
 895     if ( it != m_aLibInfoMap.end() )
 896         pItem = it->second;
 897     return pItem;
 898 }
 899
 900 SbxItem::SbxItem(USHORT nWhich_, const ScriptDocument& rDocument, const String& aLibName, const String& aName, USHORT nType )
 901     :SfxPoolItem( nWhich_ )
 902     ,m_aDocument(rDocument)
 903     ,m_aLibName(aLibName)
 904     ,m_aName(aName)
 905     ,m_nType(nType)
 906 {
 907 }
 908
 909 SbxItem::SbxItem(USHORT nWhich_, const ScriptDocument& rDocument, const String& aLibName, const String& aName, const String& aMethodName, USHORT nType )
 910     :SfxPoolItem( nWhich_ )
 911     ,m_aDocument(rDocument)
 912     ,m_aLibName(aLibName)
 913     ,m_aName(aName)
 914     ,m_aMethodName(aMethodName)
 915     ,m_nType(nType)
 916 {
 917 }
 918
 919 SbxItem::SbxItem(const SbxItem& rCopy)
 920     :SfxPoolItem( rCopy )
 921     ,m_aDocument( rCopy.m_aDocument )
 922 {
 923     m_aLibName = rCopy.m_aLibName;
 924     m_aName = rCopy.m_aName;
 925     m_aMethodName = rCopy.m_aMethodName;
 926     m_nType = rCopy.m_nType;
 927 }
 928
 929 int SbxItem::operator==( const SfxPoolItem& rCmp) const
 930 {
 931     DBG_ASSERT( rCmp.ISA( SbxItem ), "==: Kein SbxItem!" );
 932     return ( SfxPoolItem::operator==( rCmp ) && ( m_aDocument == ((const SbxItem&)rCmp).m_aDocument )
 933                                              && ( m_aLibName == ((const SbxItem&)rCmp).m_aLibName )
 934                                              && ( m_aName == ((const SbxItem&)rCmp).m_aName )
 935                                              && ( m_aMethodName == ((const SbxItem&)rCmp).m_aMethodName )
 936                                              && ( m_nType == ((const SbxItem&)rCmp).m_nType ) );
 937 }
 938
 939 SfxPoolItem *SbxItem::Clone( SfxItemPool* ) const
 940 {
 941     return new SbxItem(*this);
 942 }
 943
 944 BOOL QueryDel( const String& rName, const ResId& rId, Window* pParent )
 945 {
 946     String aQuery( rId );
 947     String aName( rName );
 948     aName += '\'';
 949     aName.Insert( '\'', 0 );
 950     aQuery.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "XX" ) ), aName );
 951     QueryBox aQueryBox( pParent, WB_YES_NO | WB_DEF_YES, aQuery );
 952     if ( aQueryBox.Execute() == RET_YES )
 953         return TRUE;
 954     return FALSE;
 955 }
 956
 957 BOOL QueryDelMacro( const String& rName, Window* pParent )
 958 {
 959     return QueryDel( rName, IDEResId( RID_STR_QUERYDELMACRO ), pParent );
 960 }
 961
 962 BOOL QueryReplaceMacro( const String& rName, Window* pParent )
 963 {
 964     return QueryDel( rName, IDEResId( RID_STR_QUERYREPLACEMACRO ), pParent );
 965 }
 966
 967 BOOL QueryDelDialog( const String& rName, Window* pParent )
 968 {
 969     return QueryDel( rName, IDEResId( RID_STR_QUERYDELDIALOG ), pParent );
 970 }
 971
 972 BOOL QueryDelLib( const String& rName, BOOL bRef, Window* pParent )
 973 {
 974     return QueryDel( rName, IDEResId( bRef ? RID_STR_QUERYDELLIBREF : RID_STR_QUERYDELLIB ), pParent );
 975 }
 976
 977 BOOL QueryDelModule( const String& rName, Window* pParent )
 978 {
 979     return QueryDel( rName, IDEResId( RID_STR_QUERYDELMODULE ), pParent );
 980 }
 981
 982 BOOL QueryPassword( const Reference< script::XLibraryContainer >& xLibContainer, const String& rLibName, String& rPassword, BOOL bRepeat, BOOL bNewTitle )
 983 {
 984     BOOL bOK = FALSE;
 985     USHORT nRet = 0;
 986
 987     do
 988     {
 989         // password dialog
 990         SfxPasswordDialog* pDlg = new SfxPasswordDialog( Application::GetDefDialogParent() );
 991         pDlg->SetMinLen( 1 );
 992
 993         // set new title
 994         if ( bNewTitle )
 995         {
 996             String aTitle( IDEResId( RID_STR_ENTERPASSWORD ) );
 997             aTitle.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "XX" ) ), rLibName );
 998             pDlg->SetText( aTitle );
 999         }
1000
1001         // execute dialog
1002         nRet = pDlg->Execute();
1003
1004         // verify password
1005         if ( nRet == RET_OK )
1006         {
1007             ::rtl::OUString aOULibName( rLibName );
1008             if ( xLibContainer.is() && xLibContainer->hasByName( aOULibName ) )
1009             {
1010                 Reference< script::XLibraryContainerPassword > xPasswd( xLibContainer, UNO_QUERY );
1011                 if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aOULibName ) && !xPasswd->isLibraryPasswordVerified( aOULibName ) )
1012                 {
1013                     rPassword = pDlg->GetPassword();
1014                     ::rtl::OUString aOUPassword( rPassword );
1015                     bOK = xPasswd->verifyLibraryPassword( aOULibName, aOUPassword );
1016
1017                     if ( !bOK )
1018                     {
1019                         ErrorBox aErrorBox( Application::GetDefDialogParent(), WB_OK, String( IDEResId( RID_STR_WRONGPASSWORD ) ) );
1020                         aErrorBox.Execute();
1021                     }
1022                 }
1023             }
1024         }
1025
1026         delete pDlg;
1027     }
1028     while ( bRepeat && !bOK && nRet == RET_OK );
1029
1030     return bOK;
1031 }
1032