svtools/source/control/tabbar.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: tabbar.cxx,v $
  10  * $Revision: 1.21.100.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_svtools.hxx"
  33
  34 #include "tabbar.hxx"
  35 #include <tools/time.hxx>
  36 #include <tools/debug.hxx>
  37 #include <tools/poly.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/help.hxx>
  40 #include <vcl/decoview.hxx>
  41 #include <vcl/button.hxx>
  42 #include <vcl/edit.hxx>
  43 #include "svtaccessiblefactory.hxx"
  44
  45 // =======================================================================
  46
  47 #define TABBAR_OFFSET_X         7
  48 #define TABBAR_OFFSET_X2        2
  49 #define TABBAR_DRAG_SCROLLOFF   5
  50 #define TABBAR_MINSIZE          5
  51
  52 const USHORT ADDNEWPAGE_AREAWIDTH = 10;
  53
  54 // =======================================================================
  55
  56 struct ImplTabBarItem
  57 {
  58     USHORT          mnId;
  59     TabBarPageBits  mnBits;
  60     XubString       maText;
  61     XubString       maHelpText;
  62     Rectangle       maRect;
  63     long            mnWidth;
  64     ULONG           mnHelpId;
  65     BOOL            mbShort;
  66     BOOL            mbSelect;
  67     BOOL            mbEnable;
  68
  69                     ImplTabBarItem( USHORT nItemId, const XubString& rText,
  70                                     TabBarPageBits nPageBits ) :
  71                         maText( rText )
  72                     {
  73                         mnId     = nItemId;
  74                         mnBits   = nPageBits;
  75                         mnWidth  = 0;
  76                         mnHelpId = 0;
  77                         mbShort  = FALSE;
  78                         mbSelect = FALSE;
  79                         mbEnable = TRUE;
  80                     }
  81 };
  82
  83 DECLARE_LIST( ImplTabBarList, ImplTabBarItem* )
  84
  85 // =======================================================================
  86
  87 // -----------------
  88 // - ImplTabButton -
  89 // -----------------
  90
  91 class ImplTabButton : public PushButton
  92 {
  93 public:
  94                     ImplTabButton( TabBar* pParent, WinBits nWinStyle = 0 ) :
  95                         PushButton( pParent, nWinStyle | WB_RECTSTYLE | WB_SMALLSTYLE | WB_NOLIGHTBORDER | WB_NOPOINTERFOCUS  ) {}
  96
  97     TabBar*         GetParent() const { return (TabBar*)Window::GetParent(); }
  98
  99     virtual long    PreNotify( NotifyEvent& rNEvt );
 100 };
 101
 102 // =======================================================================
 103
 104 long ImplTabButton::PreNotify( NotifyEvent& rNEvt )
 105 {
 106     if ( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
 107     {
 108         if ( GetParent()->IsInEditMode() )
 109         {
 110             GetParent()->EndEditMode();
 111             return TRUE;
 112         }
 113     }
 114
 115     return PushButton::PreNotify( rNEvt );
 116 }
 117
 118 // =======================================================================
 119
 120 // ----------------
 121 // - ImplTabSizer -
 122 // ----------------
 123
 124 class ImplTabSizer : public Window
 125 {
 126 public:
 127                     ImplTabSizer( TabBar* pParent, WinBits nWinStyle = 0 );
 128
 129     TabBar*         GetParent() const { return (TabBar*)Window::GetParent(); }
 130
 131 private:
 132     void            ImplTrack( const Point& rScreenPos );
 133
 134     virtual void    MouseButtonDown( const MouseEvent& rMEvt );
 135     virtual void    Tracking( const TrackingEvent& rTEvt );
 136     virtual void    Paint( const Rectangle& rRect );
 137
 138     Point           maStartPos;
 139     long            mnStartWidth;
 140 };
 141
 142 // -----------------------------------------------------------------------
 143
 144 ImplTabSizer::ImplTabSizer( TabBar* pParent, WinBits nWinStyle ) :
 145     Window( pParent, nWinStyle & WB_3DLOOK )
 146 {
 147     SetPointer( Pointer( POINTER_HSIZEBAR ) );
 148     SetSizePixel( Size( 7, 0 ) );
 149 }
 150
 151 // -----------------------------------------------------------------------
 152
 153 void ImplTabSizer::ImplTrack( const Point& rScreenPos )
 154 {
 155     TabBar* pParent = GetParent();
 156     long nDiff = rScreenPos.X() - maStartPos.X();
 157     pParent->mnSplitSize = mnStartWidth + (pParent->IsMirrored() ? -nDiff : nDiff);
 158     if ( pParent->mnSplitSize < TABBAR_MINSIZE )
 159         pParent->mnSplitSize = TABBAR_MINSIZE;
 160     pParent->Split();
 161     pParent->Update();
 162 }
 163
 164 // -----------------------------------------------------------------------
 165
 166 void ImplTabSizer::MouseButtonDown( const MouseEvent& rMEvt )
 167 {
 168     if ( GetParent()->IsInEditMode() )
 169     {
 170         GetParent()->EndEditMode();
 171         return;
 172     }
 173
 174     if ( rMEvt.IsLeft() )
 175     {
 176         maStartPos = OutputToScreenPixel( rMEvt.GetPosPixel() );
 177         mnStartWidth = GetParent()->GetSizePixel().Width();
 178         StartTracking();
 179     }
 180 }
 181
 182 // -----------------------------------------------------------------------
 183
 184 void ImplTabSizer::Tracking( const TrackingEvent& rTEvt )
 185 {
 186     if ( rTEvt.IsTrackingEnded() )
 187     {
 188         if ( rTEvt.IsTrackingCanceled() )
 189             ImplTrack( maStartPos );
 190         GetParent()->mnSplitSize = 0;
 191     }
 192     else
 193         ImplTrack( OutputToScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
 194 }
 195
 196 // -----------------------------------------------------------------------
 197
 198 void ImplTabSizer::Paint( const Rectangle& )
 199 {
 200     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 201     DecorationView  aDecoView( this );
 202     long            nOffX = 0;
 203     Size            aOutputSize = GetOutputSizePixel();
 204
 205     if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
 206     {
 207         SetLineColor( rStyleSettings.GetDarkShadowColor() );
 208         DrawLine( Point( 0, 0 ), Point( 0, aOutputSize.Height()-1 ) );
 209         nOffX++;
 210         aOutputSize.Width()--;
 211     }
 212     aDecoView.DrawButton( Rectangle( Point( nOffX, 0 ), aOutputSize ), BUTTON_DRAW_NOLIGHTBORDER );
 213 }
 214
 215 // =======================================================================
 216
 217 // Heisst nicht Impl, da evtl. mal von aussen benutz- und ueberladbar
 218
 219 // --------------
 220 // - TabBarEdit -
 221 // --------------
 222
 223 class TabBarEdit : public Edit
 224 {
 225 private:
 226     Timer           maLoseFocusTimer;
 227     BOOL            mbPostEvt;
 228
 229                     DECL_LINK( ImplEndEditHdl, void* );
 230                     DECL_LINK( ImplEndTimerHdl, void* );
 231
 232 public:
 233                     TabBarEdit( TabBar* pParent, WinBits nWinStyle = 0 );
 234
 235     TabBar*         GetParent() const { return (TabBar*)Window::GetParent(); }
 236
 237     void            SetPostEvent() { mbPostEvt = TRUE; }
 238     void            ResetPostEvent() { mbPostEvt = FALSE; }
 239
 240     virtual long    PreNotify( NotifyEvent& rNEvt );
 241     virtual void    LoseFocus();
 242 };
 243
 244 // -----------------------------------------------------------------------
 245
 246 TabBarEdit::TabBarEdit( TabBar* pParent, WinBits nWinStyle ) :
 247     Edit( pParent, nWinStyle )
 248 {
 249     mbPostEvt = FALSE;
 250 }
 251
 252 // -----------------------------------------------------------------------
 253
 254 long TabBarEdit::PreNotify( NotifyEvent& rNEvt )
 255 {
 256     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 257     {
 258         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 259         if ( !pKEvt->GetKeyCode().GetModifier() )
 260         {
 261             if ( pKEvt->GetKeyCode().GetCode() == KEY_RETURN )
 262             {
 263                 if ( !mbPostEvt )
 264                 {
 265                     if ( PostUserEvent( LINK( this, TabBarEdit, ImplEndEditHdl ), (void*)FALSE ) )
 266                         mbPostEvt = TRUE;
 267                 }
 268                 return TRUE;
 269             }
 270             else if ( pKEvt->GetKeyCode().GetCode() == KEY_ESCAPE )
 271             {
 272                 if ( !mbPostEvt )
 273                 {
 274                     if ( PostUserEvent( LINK( this, TabBarEdit, ImplEndEditHdl ), (void*)TRUE ) )
 275                         mbPostEvt = TRUE;
 276                 }
 277                 return TRUE;
 278             }
 279         }
 280     }
 281
 282     return Edit::PreNotify( rNEvt );
 283 }
 284
 285 // -----------------------------------------------------------------------
 286
 287 void TabBarEdit::LoseFocus()
 288 {
 289     if ( !mbPostEvt )
 290     {
 291         if ( PostUserEvent( LINK( this, TabBarEdit, ImplEndEditHdl ), (void*)FALSE ) )
 292             mbPostEvt = TRUE;
 293     }
 294
 295     Edit::LoseFocus();
 296 }
 297
 298 // -----------------------------------------------------------------------
 299
 300 IMPL_LINK( TabBarEdit, ImplEndEditHdl, void*, pCancel )
 301 {
 302     ResetPostEvent();
 303     maLoseFocusTimer.Stop();
 304
 305     // We need this query, because the edit get a losefous event,
 306     // when it shows the context menu or the insert symbol dialog
 307     if ( !HasFocus() && HasChildPathFocus( TRUE ) )
 308     {
 309         maLoseFocusTimer.SetTimeout( 30 );
 310         maLoseFocusTimer.SetTimeoutHdl( LINK( this, TabBarEdit, ImplEndTimerHdl ) );
 311         maLoseFocusTimer.Start();
 312     }
 313     else
 314         GetParent()->EndEditMode( pCancel != 0 );
 315
 316     return 0;
 317 }
 318
 319 // -----------------------------------------------------------------------
 320
 321 IMPL_LINK( TabBarEdit, ImplEndTimerHdl, void*, EMPTYARG )
 322 {
 323     if ( HasFocus() )
 324         return 0;
 325
 326     // We need this query, because the edit get a losefous event,
 327     // when it shows the context menu or the insert symbol dialog
 328     if ( HasChildPathFocus( TRUE ) )
 329         maLoseFocusTimer.Start();
 330     else
 331         GetParent()->EndEditMode( TRUE );
 332
 333     return 0;
 334 }
 335
 336 // =======================================================================
 337 struct TabBar_Impl
 338 {
 339     ImplTabSizer*                   mpSizer;
 340     ::svt::AccessibleFactoryAccess  maAccessibleFactory;
 341
 342     TabBar_Impl()
 343         :mpSizer( NULL )
 344     {
 345     }
 346     ~TabBar_Impl()
 347     {
 348         delete mpSizer;
 349     }
 350 };
 351
 352 // =======================================================================
 353
 354 void TabBar::ImplInit( WinBits nWinStyle )
 355 {
 356     mpItemList      = new ImplTabBarList;
 357     mpFirstBtn      = NULL;
 358     mpPrevBtn       = NULL;
 359     mpNextBtn       = NULL;
 360     mpLastBtn       = NULL;
 361     mpImpl          = new TabBar_Impl;
 362     mpEdit          = NULL;
 363     mnMaxPageWidth  = 0;
 364     mnCurMaxWidth   = 0;
 365     mnOffX          = 0;
 366     mnOffY          = 0;
 367     mnLastOffX      = 0;
 368     mnSplitSize     = 0;
 369     mnSwitchTime    = 0;
 370     mnWinStyle      = nWinStyle;
 371     mnCurPageId     = 0;
 372     mnFirstPos      = 0;
 373     mnDropPos       = 0;
 374     mnSwitchId      = 0;
 375     mnEditId        = 0;
 376     mbFormat        = TRUE;
 377     mbFirstFormat   = TRUE;
 378     mbSizeFormat    = TRUE;
 379     mbAutoMaxWidth  = TRUE;
 380     mbInSwitching   = FALSE;
 381     mbAutoEditMode  = FALSE;
 382     mbEditCanceled  = FALSE;
 383     mbDropPos       = FALSE;
 384     mbInSelect      = FALSE;
 385     mbSelColor      = FALSE;
 386     mbSelTextColor  = FALSE;
 387     mbMirrored      = FALSE;
 388
 389     if ( nWinStyle & WB_3DTAB )
 390         mnOffY++;
 391
 392     ImplInitControls();
 393     SetSizePixel( Size( 100, CalcWindowSizePixel().Height() ) );
 394     ImplInitSettings( TRUE, TRUE );
 395 }
 396
 397 // -----------------------------------------------------------------------
 398
 399 TabBar::TabBar( Window* pParent, WinBits nWinStyle ) :
 400     Window( pParent, (nWinStyle & WB_3DLOOK) | WB_CLIPCHILDREN )
 401 {
 402     ImplInit( nWinStyle );
 403 }
 404
 405 // -----------------------------------------------------------------------
 406
 407 TabBar::~TabBar()
 408 {
 409     EndEditMode( TRUE );
 410
 411     // Controls loeschen
 412     if ( mpPrevBtn )
 413         delete mpPrevBtn;
 414     if ( mpNextBtn )
 415         delete mpNextBtn;
 416     if ( mpFirstBtn )
 417         delete mpFirstBtn;
 418     if ( mpLastBtn )
 419         delete mpLastBtn;
 420     delete mpImpl;
 421
 422     // Alle Items loeschen
 423     ImplTabBarItem* pItem = mpItemList->First();
 424     while ( pItem )
 425     {
 426         delete pItem;
 427         pItem = mpItemList->Next();
 428     }
 429
 430     // Itemlist loeschen
 431     delete mpItemList;
 432 }
 433
 434 // -----------------------------------------------------------------------
 435
 436 void TabBar::ImplInitSettings( BOOL bFont, BOOL bBackground )
 437 {
 438     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 439
 440     if ( bFont )
 441     {
 442         Font aToolFont;
 443         aToolFont = rStyleSettings.GetToolFont();
 444         if ( IsControlFont() )
 445             aToolFont.Merge( GetControlFont() );
 446         aToolFont.SetWeight( WEIGHT_BOLD );
 447         SetZoomedPointFont( aToolFont );
 448
 449         // Font in der groesse Anpassen, wenn Fenster zu klein?
 450         while ( GetTextHeight() > (GetOutputSizePixel().Height()-1) )
 451         {
 452             Font aFont = GetFont();
 453             if ( aFont.GetHeight() <= 6 )
 454                 break;
 455             aFont.SetHeight( aFont.GetHeight()-1 );
 456             SetFont( aFont );
 457         }
 458     }
 459
 460     if ( bBackground )
 461     {
 462         Color aColor;
 463         if ( IsControlBackground() )
 464             aColor = GetControlBackground();
 465         else
 466             aColor = rStyleSettings.GetFaceColor();
 467         SetBackground( aColor );
 468     }
 469 }
 470
 471 // -----------------------------------------------------------------------
 472
 473 void TabBar::ImplGetColors( Color& rFaceColor, Color& rFaceTextColor,
 474                             Color& rSelectColor, Color& rSelectTextColor )
 475 {
 476     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 477
 478     if ( IsControlBackground() )
 479         rFaceColor = GetControlBackground();
 480     else
 481         rFaceColor = rStyleSettings.GetInactiveTabColor();
 482     if ( IsControlForeground() )
 483         rFaceTextColor = GetControlForeground();
 484     else
 485         rFaceTextColor = rStyleSettings.GetButtonTextColor();
 486     if ( mbSelColor )
 487         rSelectColor = maSelColor;
 488     else
 489         rSelectColor = rStyleSettings.GetActiveTabColor();
 490     if ( mbSelTextColor )
 491         rSelectTextColor = maSelTextColor;
 492     else
 493         rSelectTextColor = rStyleSettings.GetWindowTextColor();
 494
 495     // Bei 3D-Tabs wird Selektions- und Face-Farbe umgedreht, da die
 496     // selektierten Tabs in 3D erscheinen sollen
 497     if ( mnWinStyle & WB_3DTAB )
 498     {
 499         Color aTempColor = rFaceColor;
 500         rFaceColor = rSelectColor;
 501         rSelectColor = aTempColor;
 502         aTempColor = rFaceTextColor;
 503         rFaceTextColor = rSelectTextColor;
 504         rSelectTextColor = rFaceTextColor;
 505     }
 506 }
 507
 508 // -----------------------------------------------------------------------
 509
 510 BOOL TabBar::ImplCalcWidth()
 511 {
 512     // Groessen muessen nur ermittelt werden, wenn sich Text aendert oder
 513     // wenn der Font geaendert wurde
 514     if ( !mbSizeFormat )
 515         return FALSE;
 516
 517     // Breiten der Tabs mit dem fetten Font ermitteln
 518     Font aFont = GetFont();
 519     if ( aFont.GetWeight() != WEIGHT_BOLD )
 520     {
 521         aFont.SetWeight( WEIGHT_BOLD );
 522         SetFont( aFont );
 523     }
 524
 525     if ( mnMaxPageWidth )
 526         mnCurMaxWidth = mnMaxPageWidth;
 527     else if ( mbAutoMaxWidth )
 528     {
 529         mnCurMaxWidth = mnLastOffX-mnOffX-
 530                         TABBAR_OFFSET_X-TABBAR_OFFSET_X-
 531                         TABBAR_OFFSET_X2-TABBAR_OFFSET_X2-TABBAR_OFFSET_X2;
 532         if ( mnCurMaxWidth < 1 )
 533             mnCurMaxWidth = 1;
 534     }
 535     else
 536         mnCurMaxWidth = 0;
 537
 538     BOOL            bChanged = FALSE;
 539     ImplTabBarItem* pItem = mpItemList->First();
 540     while ( pItem )
 541     {
 542         long nNewWidth = GetTextWidth( pItem->maText );
 543         if ( mnCurMaxWidth && (nNewWidth > mnCurMaxWidth) )
 544         {
 545             pItem->mbShort = TRUE;
 546             nNewWidth = mnCurMaxWidth;
 547         }
 548         else
 549             pItem->mbShort = FALSE;
 550         nNewWidth += TABBAR_OFFSET_X+TABBAR_OFFSET_X2;
 551         if ( pItem->mnWidth != nNewWidth )
 552         {
 553             pItem->mnWidth = nNewWidth;
 554             if ( !pItem->maRect.IsEmpty() )
 555                 bChanged = TRUE;
 556         }
 557         pItem = mpItemList->Next();
 558     }
 559     mbSizeFormat = FALSE;
 560     mbFormat = TRUE;
 561     return bChanged;
 562 }
 563
 564 // -----------------------------------------------------------------------
 565
 566 void TabBar::ImplFormat()
 567 {
 568     ImplCalcWidth();
 569
 570     if ( !mbFormat )
 571         return;
 572
 573     USHORT n = 0;
 574     long x = mnOffX;
 575     ImplTabBarItem* pItem = mpItemList->First();
 576     while ( pItem )
 577     {
 578         // Bei allen nicht sichtbaren Tabs, wird ein leeres Rechteck
 579         // gesetzt
 580         if ( (n+1 < mnFirstPos) || (x > mnLastOffX) )
 581             pItem->maRect.SetEmpty();
 582         else
 583         {
 584             // Etwas von der Tab vor der ersten sichtbaren Page
 585             // muss auch zu sehen sein
 586             if ( n+1 == mnFirstPos )
 587                 pItem->maRect.Left() = x-pItem->mnWidth;
 588             else
 589             {
 590                 pItem->maRect.Left() = x;
 591                 x += pItem->mnWidth;
 592             }
 593             pItem->maRect.Right() = x+TABBAR_OFFSET_X+TABBAR_OFFSET_X2;
 594             pItem->maRect.Bottom() = maWinSize.Height()-1;
 595
 596             if( mbMirrored )
 597             {
 598                 long nTmp = mnOffX + mnLastOffX - pItem->maRect.Right();
 599                 pItem->maRect.Right() = mnOffX + mnLastOffX - pItem->maRect.Left();
 600                 pItem->maRect.Left() = nTmp;
 601             }
 602         }
 603
 604         n++;
 605         pItem = mpItemList->Next();
 606     }
 607
 608     mbFormat = FALSE;
 609
 610     // Button enablen/disablen
 611     ImplEnableControls();
 612 }
 613
 614 // -----------------------------------------------------------------------
 615
 616 USHORT TabBar::ImplGetLastFirstPos()
 617 {
 618     USHORT  nCount = (USHORT)(mpItemList->Count());
 619     if ( !nCount || mbSizeFormat || mbFormat )
 620         return 0;
 621
 622     USHORT  nLastFirstPos = nCount-1;
 623     long    nWinWidth = mnLastOffX-mnOffX-TABBAR_OFFSET_X-ADDNEWPAGE_AREAWIDTH;
 624     long    nWidth = mpItemList->GetObject( nLastFirstPos )->mnWidth;
 625     while ( nLastFirstPos && (nWidth < nWinWidth) )
 626     {
 627         nLastFirstPos--;
 628         nWidth += mpItemList->GetObject( nLastFirstPos )->mnWidth;
 629     }
 630     if ( (nLastFirstPos != (USHORT)(mpItemList->Count()-1)) &&
 631          (nWidth > nWinWidth) )
 632         nLastFirstPos++;
 633     return nLastFirstPos;
 634 }
 635
 636 // -----------------------------------------------------------------------
 637
 638 void TabBar::ImplInitControls()
 639 {
 640     if ( mnWinStyle & WB_SIZEABLE )
 641     {
 642         if ( !mpImpl->mpSizer )
 643             mpImpl->mpSizer = new ImplTabSizer( this, mnWinStyle & (WB_DRAG | WB_3DLOOK) );
 644         mpImpl->mpSizer->Show();
 645     }
 646     else
 647     {
 648         DELETEZ( mpImpl->mpSizer );
 649     }
 650
 651     Link aLink = LINK( this, TabBar, ImplClickHdl );
 652
 653     if ( mnWinStyle & (WB_MINSCROLL | WB_SCROLL) )
 654     {
 655         if ( !mpPrevBtn )
 656         {
 657             mpPrevBtn = new ImplTabButton( this, WB_REPEAT );
 658             mpPrevBtn->SetClickHdl( aLink );
 659         }
 660         mpPrevBtn->SetSymbol( mbMirrored ? SYMBOL_NEXT : SYMBOL_PREV );
 661         mpPrevBtn->Show();
 662
 663         if ( !mpNextBtn )
 664         {
 665             mpNextBtn = new ImplTabButton( this, WB_REPEAT );
 666             mpNextBtn->SetClickHdl( aLink );
 667         }
 668         mpNextBtn->SetSymbol( mbMirrored ? SYMBOL_PREV : SYMBOL_NEXT );
 669         mpNextBtn->Show();
 670     }
 671     else
 672     {
 673         DELETEZ( mpPrevBtn );
 674         DELETEZ( mpNextBtn );
 675     }
 676
 677     if ( mnWinStyle & WB_SCROLL )
 678     {
 679         if ( !mpFirstBtn )
 680         {
 681             mpFirstBtn = new ImplTabButton( this );
 682             mpFirstBtn->SetClickHdl( aLink );
 683         }
 684         mpFirstBtn->SetSymbol( mbMirrored ? SYMBOL_LAST : SYMBOL_FIRST );
 685         mpFirstBtn->Show();
 686
 687         if ( !mpLastBtn )
 688         {
 689             mpLastBtn = new ImplTabButton( this );
 690             mpLastBtn->SetClickHdl( aLink );
 691         }
 692         mpLastBtn->SetSymbol( mbMirrored ? SYMBOL_FIRST : SYMBOL_LAST );
 693         mpLastBtn->Show();
 694     }
 695     else
 696     {
 697         DELETEZ( mpFirstBtn );
 698         DELETEZ( mpLastBtn );
 699     }
 700 }
 701
 702 // -----------------------------------------------------------------------
 703
 704 void TabBar::ImplEnableControls()
 705 {
 706     if ( mbSizeFormat || mbFormat )
 707         return;
 708
 709     // Buttons enablen/disblen
 710     BOOL bEnableBtn = mnFirstPos > 0;
 711     if ( mpFirstBtn )
 712         mpFirstBtn->Enable( bEnableBtn );
 713     if ( mpPrevBtn )
 714         mpPrevBtn->Enable( bEnableBtn );
 715
 716     bEnableBtn = mnFirstPos < ImplGetLastFirstPos();
 717     if ( mpNextBtn )
 718         mpNextBtn->Enable( bEnableBtn );
 719     if ( mpLastBtn )
 720         mpLastBtn->Enable( bEnableBtn );
 721 }
 722
 723 // -----------------------------------------------------------------------
 724
 725 void TabBar::ImplShowPage( USHORT nPos )
 726 {
 727     // Breite berechnen
 728     long nWidth = GetOutputSizePixel().Width();
 729     if ( nWidth >= TABBAR_OFFSET_X )
 730         nWidth -= TABBAR_OFFSET_X;
 731     ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
 732     if ( nPos < mnFirstPos )
 733         SetFirstPageId( pItem->mnId );
 734     else if ( pItem->maRect.Right() > nWidth )
 735     {
 736         while ( pItem->maRect.Right() > nWidth )
 737         {
 738             USHORT nNewPos = mnFirstPos+1;
 739             SetFirstPageId( GetPageId( nNewPos ) );
 740             ImplFormat();
 741             if ( nNewPos != mnFirstPos )
 742                 break;
 743         }
 744     }
 745 }
 746
 747 // -----------------------------------------------------------------------
 748
 749 IMPL_LINK( TabBar, ImplClickHdl, ImplTabButton*, pBtn )
 750 {
 751     EndEditMode();
 752
 753     USHORT nNewPos = mnFirstPos;
 754
 755     if ( pBtn == mpFirstBtn )
 756         nNewPos = 0;
 757     else if ( pBtn == mpPrevBtn )
 758     {
 759         if ( mnFirstPos )
 760             nNewPos = mnFirstPos-1;
 761     }
 762     else if ( pBtn == mpNextBtn )
 763     {
 764         USHORT nCount = GetPageCount();
 765         if ( mnFirstPos <  nCount )
 766             nNewPos = mnFirstPos+1;
 767     }
 768     else
 769     {
 770         USHORT nCount = GetPageCount();
 771         if ( nCount )
 772             nNewPos = nCount-1;
 773     }
 774
 775     if ( nNewPos != mnFirstPos )
 776         SetFirstPageId( GetPageId( nNewPos ) );
 777     return 0;
 778 }
 779
 780 // -----------------------------------------------------------------------
 781
 782 void TabBar::MouseMove( const MouseEvent& rMEvt )
 783 {
 784     if ( rMEvt.IsLeaveWindow() )
 785         mbInSelect = FALSE;
 786
 787     Window::MouseMove( rMEvt );
 788 }
 789
 790 // -----------------------------------------------------------------------
 791
 792 void TabBar::MouseButtonDown( const MouseEvent& rMEvt )
 793 {
 794     // Bei Klick in unser Fenster EditModus nur beenden und Klick nicht
 795     // ausfuehren
 796     if ( IsInEditMode() )
 797     {
 798         EndEditMode();
 799         return;
 800     }
 801
 802     ImplTabBarItem* pItem;
 803     USHORT          nSelId = GetPageId( rMEvt.GetPosPixel() );
 804
 805     if ( !rMEvt.IsLeft() )
 806     {
 807         Window::MouseButtonDown( rMEvt );
 808         if ( (nSelId > 0) && (nSelId != mnCurPageId) )
 809         {
 810             USHORT nPos = GetPagePos( nSelId );
 811             pItem = mpItemList->GetObject( nPos );
 812
 813             if ( pItem->mbEnable )
 814             {
 815                 if ( ImplDeactivatePage() )
 816                 {
 817                     SetCurPageId( nSelId );
 818                     Update();
 819                     ImplActivatePage();
 820                     ImplSelect();
 821                 }
 822                 mbInSelect = TRUE;
 823             }
 824         }
 825         return;
 826     }
 827
 828     if ( rMEvt.IsMod2() && mbAutoEditMode && nSelId )
 829     {
 830         if ( StartEditMode( nSelId ) )
 831             return;
 832     }
 833
 834     if ( (rMEvt.GetMode() & (MOUSE_MULTISELECT | MOUSE_RANGESELECT)) && (rMEvt.GetClicks() == 1) )
 835     {
 836         if ( nSelId )
 837         {
 838             USHORT      nPos = GetPagePos( nSelId );
 839             BOOL        bSelectTab = FALSE;
 840             pItem = mpItemList->GetObject( nPos );
 841
 842             if ( pItem->mbEnable )
 843             {
 844                 if ( (rMEvt.GetMode() & MOUSE_MULTISELECT) && (mnWinStyle & WB_MULTISELECT) )
 845                 {
 846                     if ( nSelId != mnCurPageId )
 847                     {
 848                         SelectPage( nSelId, !IsPageSelected( nSelId ) );
 849                         bSelectTab = TRUE;
 850                     }
 851                 }
 852                 else if ( mnWinStyle & (WB_MULTISELECT | WB_RANGESELECT) )
 853                 {
 854                     bSelectTab = TRUE;
 855                     USHORT n;
 856                     BOOL   bSelect;
 857                     USHORT nCurPos = GetPagePos( mnCurPageId );
 858                     if ( nPos <= nCurPos )
 859                     {
 860                         // Alle Tabs bis zur angeklickten Tab deselektieren
 861                         // und alle Tabs von der angeklickten Tab bis
 862                         // zur aktuellen Position selektieren
 863                         n = 0;
 864                         while ( n < nCurPos )
 865                         {
 866                             pItem = mpItemList->GetObject( n );
 867                             if ( n < nPos )
 868                                 bSelect = FALSE;
 869                             else
 870                                 bSelect = TRUE;
 871
 872                             if ( pItem->mbSelect != bSelect )
 873                             {
 874                                 pItem->mbSelect = bSelect;
 875                                 if ( !pItem->maRect.IsEmpty() )
 876                                     Invalidate( pItem->maRect );
 877                             }
 878
 879                             n++;
 880                         }
 881                     }
 882
 883                     if ( nPos >= nCurPos )
 884                     {
 885                         // Alle Tabs von der aktuellen bis zur angeklickten
 886                         // Tab selektieren und alle Tabs von der angeklickten
 887                         // Tab bis zur letzten Tab deselektieren
 888                         USHORT nCount = (USHORT)mpItemList->Count();
 889                         n = nCurPos;
 890                         while ( n < nCount )
 891                         {
 892                             pItem = mpItemList->GetObject( n );
 893
 894                             if ( n <= nPos )
 895                                 bSelect = TRUE;
 896                             else
 897                                 bSelect = FALSE;
 898
 899                             if ( pItem->mbSelect != bSelect )
 900                             {
 901                                 pItem->mbSelect = bSelect;
 902                                 if ( !pItem->maRect.IsEmpty() )
 903                                     Invalidate( pItem->maRect );
 904                             }
 905
 906                             n++;
 907                         }
 908                     }
 909                 }
 910
 911                 // Gegebenenfalls muss die selektierte Tab gescrollt werden
 912                 if ( bSelectTab )
 913                 {
 914                     ImplShowPage( nPos );
 915                     Update();
 916                     ImplSelect();
 917                 }
 918             }
 919             else
 920                 ImplShowPage( nPos );
 921             mbInSelect = TRUE;
 922
 923             return;
 924         }
 925     }
 926     else if ( rMEvt.GetClicks() == 2 )
 927     {
 928         // Gegebenenfalls den Double-Click-Handler rufen
 929         if ( !rMEvt.GetModifier() && (!nSelId || (nSelId == mnCurPageId)) )
 930         {
 931             USHORT nOldCurId = mnCurPageId;
 932             mnCurPageId = nSelId;
 933             DoubleClick();
 934             // Abfrage, da im DoubleClick-Handler die aktuelle Seite
 935             // umgeschaltet werden konnte
 936             if ( mnCurPageId == nSelId )
 937                 mnCurPageId = nOldCurId;
 938         }
 939
 940         return;
 941     }
 942     else
 943     {
 944         if ( nSelId )
 945         {
 946             // Nur Select ausfuehren, wenn noch nicht aktuelle Page
 947             if ( nSelId != mnCurPageId )
 948             {
 949                 USHORT nPos = GetPagePos( nSelId );
 950                 pItem = mpItemList->GetObject( nPos );
 951
 952                 if ( pItem->mbEnable )
 953                 {
 954                     if ( !pItem->mbSelect )
 955                     {
 956                         // Muss invalidiert werden
 957                         BOOL bUpdate = FALSE;
 958                         if ( IsReallyVisible() && IsUpdateMode() )
 959                             bUpdate = TRUE;
 960
 961                         // Alle selektierten Items deselektieren
 962                         pItem = mpItemList->First();
 963                         while ( pItem )
 964                         {
 965                             if ( pItem->mbSelect || (pItem->mnId == mnCurPageId) )
 966                             {
 967                                 pItem->mbSelect = FALSE;
 968                                 if ( bUpdate )
 969                                     Invalidate( pItem->maRect );
 970                             }
 971
 972                             pItem = mpItemList->Next();
 973                         }
 974                     }
 975
 976                     if ( ImplDeactivatePage() )
 977                     {
 978                         SetCurPageId( nSelId );
 979                         Update();
 980                         ImplActivatePage();
 981                         ImplSelect();
 982                     }
 983                 }
 984                 else
 985                     ImplShowPage( nPos );
 986                 mbInSelect = TRUE;
 987             }
 988
 989             return;
 990         }
 991     }
 992
 993     Window::MouseButtonDown( rMEvt );
 994 }
 995
 996 // -----------------------------------------------------------------------
 997
 998 void TabBar::MouseButtonUp( const MouseEvent& rMEvt )
 999 {
1000     mbInSelect = FALSE;
1001     Window::MouseButtonUp( rMEvt );
1002 }
1003
1004 // -----------------------------------------------------------------------
1005
1006 void TabBar::Paint( const Rectangle& )
1007 {
1008     // Items berechnen und ausgeben
1009     USHORT          nItemCount = (USHORT)mpItemList->Count();
1010     ImplTabBarItem* pItem;
1011
1012     // kein Item, dann auch nichts zu tun
1013     if ( nItemCount )
1014     {
1015         // TabBar muss formatiert sein
1016         ImplFormat();
1017
1018         // Beim ersten Format auch dafuer sorgen, das aktuelle TabPage
1019         // sichtbar wird
1020         if ( mbFirstFormat )
1021         {
1022             mbFirstFormat = FALSE;
1023
1024             if ( mnCurPageId && (mnFirstPos == 0) && !mbDropPos )
1025             {
1026                 pItem = mpItemList->GetObject( GetPagePos( mnCurPageId ) );
1027                 if ( pItem->maRect.IsEmpty() )
1028                 {
1029                     // mbDropPos setzen (bzw. misbrauchen) um Invalidate()
1030                     // zu unterbinden
1031                     mbDropPos = TRUE;
1032                     SetFirstPageId( mnCurPageId );
1033                     mbDropPos = FALSE;
1034                     if ( mnFirstPos != 0 )
1035                         ImplFormat();
1036                 }
1037             }
1038         }
1039     }
1040
1041     // Farben ermitteln
1042     const StyleSettings&    rStyleSettings = GetSettings().GetStyleSettings();
1043     Color                   aFaceColor;
1044     Color                   aSelectColor;
1045     Color                   aFaceTextColor;
1046     Color                   aSelectTextColor;
1047     ImplGetColors( aFaceColor, aFaceTextColor, aSelectColor, aSelectTextColor );
1048
1049     // Font selektieren
1050     Font aFont = GetFont();
1051     Font aLightFont = aFont;
1052     aLightFont.SetWeight( WEIGHT_LIGHT );
1053
1054     // #i36013# exclude push buttons from painting area
1055     Rectangle aClipRect( Point( mnOffX, 0 ), Point( mnLastOffX, GetOutputHeightPixel() - 1 ) );
1056     SetClipRegion( Region( aClipRect ) );
1057
1058     // Bei Border oben und unten einen Strich extra malen
1059     if ( (mnWinStyle & WB_BORDER) || (mnWinStyle & WB_TOPBORDER) )
1060     {
1061         Size aOutputSize = GetOutputSizePixel();
1062
1063         // Bei 3D-Tabs wird auch der Border in 3D gemalt
1064         if ( mnWinStyle & WB_3DTAB )
1065         {
1066             SetLineColor( rStyleSettings.GetShadowColor() );
1067             DrawLine( Point( mnOffX, 0 ), Point( aOutputSize.Width(), 0 ) );
1068         }
1069
1070         // Border malen (Strich oben und Strich unten)
1071         SetLineColor( rStyleSettings.GetDarkShadowColor() );
1072         DrawLine( Point( mnOffX, mnOffY ), Point( aOutputSize.Width()-1, mnOffY ) );
1073     }
1074     else
1075         SetLineColor( rStyleSettings.GetDarkShadowColor() );
1076
1077     // Items ausgeben
1078     if ( nItemCount )
1079     {
1080         // letzten sichtbaren Eintrag suchen
1081         USHORT n = mnFirstPos+1;
1082         if ( n >= nItemCount )
1083             n = nItemCount-1;
1084         pItem = mpItemList->Seek( n );
1085         while ( pItem )
1086         {
1087             if ( !pItem->maRect.IsEmpty() )
1088             {
1089                 n++;
1090                 pItem = mpItemList->Next();
1091             }
1092             else
1093                 break;
1094         }
1095
1096         // Alle Tabs ausgeben (von hinten nach vorn und aktuellen zuletzt)
1097         if ( pItem )
1098             n--;
1099         else if ( n >= nItemCount )
1100             n = nItemCount-1;
1101         pItem = mpItemList->Seek( n );
1102         ImplTabBarItem* pCurItem = NULL;
1103         while ( pItem )
1104         {
1105             // CurrentItem als letztes ausgeben, da es alle anderen ueberdeckt
1106             if ( !pCurItem && (pItem->mnId == mnCurPageId) )
1107             {
1108                 pCurItem = pItem;
1109                 pItem = mpItemList->Prev();
1110                 if ( !pItem )
1111                     pItem = pCurItem;
1112                 continue;
1113             }
1114
1115             if ( !pItem->maRect.IsEmpty() )
1116             {
1117                 Rectangle aRect = pItem->maRect;
1118
1119                 // Aktuelle Page wird mit einem fetten Font ausgegeben
1120                 if ( pItem->mnId == mnCurPageId )
1121                     SetFont( aFont );
1122                 else
1123                     SetFont( aLightFont );
1124
1125                 // Je nach Status die richtige FillInBrush setzen
1126                 if ( pItem->mbSelect || (pItem->mnId == mnCurPageId) )
1127                 {
1128                     SetFillColor( aSelectColor );
1129                     SetTextColor( aSelectTextColor );
1130                 }
1131                 else
1132                 {
1133                     SetFillColor( aFaceColor );
1134                     SetTextColor( aFaceTextColor );
1135                 }
1136
1137                 // Muss Font Kursiv geschaltet werden
1138                 if ( pItem->mnBits & TPB_SPECIAL )
1139                 {
1140                     SetTextColor( Color( COL_LIGHTBLUE ) );
1141                 }
1142
1143                 // Position der Page berechnen
1144                 Point   aPos0 = Point( aRect.Left(), mnOffY );
1145                 Point   aPos1 = Point( aRect.Left()+TABBAR_OFFSET_X, aRect.Bottom() );
1146                 Point   aPos2 = Point( aRect.Right()-TABBAR_OFFSET_X, aRect.Bottom() );
1147                 Point   aPos3 = Point( aRect.Right(), mnOffY );
1148
1149                 // Zuerst geben wir das Polygon gefuellt aus
1150                 Polygon aPoly( 4 );
1151                 aPoly[0] = aPos0;
1152                 aPoly[1] = aPos1;
1153                 aPoly[2] = aPos2;
1154                 aPoly[3] = aPos3;
1155                 DrawPolygon( aPoly );
1156
1157                 // Danach den Text zentiert ausgeben
1158                 XubString aText = pItem->maText;
1159                 if ( pItem->mbShort )
1160                     aText = GetEllipsisString( aText, mnCurMaxWidth, TEXT_DRAW_ENDELLIPSIS );
1161                 Size    aRectSize = aRect.GetSize();
1162                 long    nTextWidth = GetTextWidth( aText );
1163                 long    nTextHeight = GetTextHeight();
1164                 Point   aTxtPos( aRect.Left()+(aRectSize.Width()-nTextWidth)/2,
1165                                  (aRectSize.Height()-nTextHeight)/2 );
1166                 if ( !pItem->mbEnable )
1167                     DrawCtrlText( aTxtPos, aText, 0, STRING_LEN, (TEXT_DRAW_DISABLE | TEXT_DRAW_MNEMONIC) );
1168                 else
1169                     DrawText( aTxtPos, aText );
1170
1171                 // Jetzt im Inhalt den 3D-Effekt ausgeben
1172                 aPos0.X()++;
1173                 aPos1.X()++;
1174                 aPos2.X()--;
1175                 aPos3.X()--;
1176                 SetLineColor( rStyleSettings.GetLightColor() );
1177                 DrawLine( aPos0, aPos1 );
1178
1179                 if ( !pItem->mbSelect && (pItem->mnId != mnCurPageId) )
1180                 {
1181                     DrawLine( Point( aPos0.X(), aPos0.Y()+1 ),
1182                                 Point( aPos3.X(), aPos3.Y()+1 ) );
1183                 }
1184
1185                 SetLineColor( rStyleSettings.GetShadowColor() );
1186                 DrawLine( aPos2, aPos3 );
1187                 aPos1.X()--;
1188                 aPos1.Y()--;
1189                 aPos2.Y()--;
1190                 DrawLine( aPos1, aPos2 );
1191
1192                 // Da etwas uebermalt werden konnte, muessen wir die Polygon-
1193                 // umrandung nocheinmal ausgeben
1194                 SetLineColor( rStyleSettings.GetDarkShadowColor() );
1195                 SetFillColor();
1196                 DrawPolygon( aPoly );
1197
1198                 // Beim dem aktuellen Tab die restlichten Ausgaben vornehmen und
1199                 // die Schleife abbrechen, da die aktuelle Tab als letztes
1200                 // ausgegeben wird
1201                 if ( pItem == pCurItem )
1202                 {
1203                     // Beim aktuellen Item muss der oberstes Strich geloescht
1204                     // werden
1205                     SetLineColor();
1206                     SetFillColor( aSelectColor );
1207                     Rectangle aDelRect( aPos0, aPos3 );
1208                     DrawRect( aDelRect );
1209                     if ( mnWinStyle & WB_3DTAB )
1210                     {
1211                         aDelRect.Top()--;
1212                         DrawRect( aDelRect );
1213                     }
1214
1215                     break;
1216                 }
1217
1218                 pItem = mpItemList->Prev();
1219             }
1220             else
1221             {
1222                 if ( pItem == pCurItem )
1223                     break;
1224
1225                 pItem = NULL;
1226             }
1227
1228             if ( !pItem )
1229                 pItem = pCurItem;
1230         }
1231     }
1232
1233     // Font wieder herstellen
1234     SetFont( aFont );
1235     // remove clip region
1236     SetClipRegion();
1237 }
1238
1239 // -----------------------------------------------------------------------
1240
1241 void TabBar::Resize()
1242 {
1243     Size aNewSize = GetOutputSizePixel();
1244
1245     long nSizerWidth = 0;
1246     long nButtonWidth = 0;
1247
1248     // Sizer anordnen
1249     if ( mpImpl->mpSizer )
1250     {
1251         Size    aSizerSize = mpImpl->mpSizer->GetSizePixel();
1252         Point   aNewSizerPos( mbMirrored ? 0 : (aNewSize.Width()-aSizerSize.Width()), 0 );
1253         Size    aNewSizerSize( aSizerSize.Width(), aNewSize.Height() );
1254         mpImpl->mpSizer->SetPosSizePixel( aNewSizerPos, aNewSizerSize );
1255         nSizerWidth = aSizerSize.Width();
1256     }
1257
1258     // Scroll-Buttons anordnen
1259     long nHeight = aNewSize.Height();
1260     // Font in der groesse Anpassen?
1261     ImplInitSettings( TRUE, FALSE );
1262
1263     long nX = mbMirrored ? (aNewSize.Width()-nHeight) : 0;
1264     long nXDiff = mbMirrored ? -nHeight : nHeight;
1265
1266     Size aBtnSize( nHeight, nHeight );
1267     if ( mpFirstBtn )
1268     {
1269         mpFirstBtn->SetPosSizePixel( Point( nX, 0 ), aBtnSize );
1270         nX += nXDiff;
1271         nButtonWidth += nHeight;
1272     }
1273     if ( mpPrevBtn )
1274     {
1275         mpPrevBtn->SetPosSizePixel( Point( nX, 0 ), aBtnSize );
1276         nX += nXDiff;
1277         nButtonWidth += nHeight;
1278     }
1279     if ( mpNextBtn )
1280     {
1281         mpNextBtn->SetPosSizePixel( Point( nX, 0 ), aBtnSize );
1282         nX += nXDiff;
1283         nButtonWidth += nHeight;
1284     }
1285     if ( mpLastBtn )
1286     {
1287         mpLastBtn->SetPosSizePixel( Point( nX, 0 ), aBtnSize );
1288         nX += nXDiff;
1289         nButtonWidth += nHeight;
1290     }
1291
1292     // Groesse merken
1293     maWinSize = aNewSize;
1294
1295     if( mbMirrored )
1296     {
1297         mnOffX = nSizerWidth;
1298         mnLastOffX = maWinSize.Width() - nButtonWidth - 1;
1299     }
1300     else
1301     {
1302         mnOffX = nButtonWidth;
1303         mnLastOffX = maWinSize.Width() - nSizerWidth - 1;
1304     }
1305
1306     // Neu formatieren
1307     mbSizeFormat = TRUE;
1308     if ( IsReallyVisible() )
1309     {
1310         if ( ImplCalcWidth() )
1311             Invalidate();
1312         ImplFormat();
1313     }
1314
1315     // Button enablen/disablen
1316     ImplEnableControls();
1317 }
1318
1319 // -----------------------------------------------------------------------
1320
1321 void TabBar::RequestHelp( const HelpEvent& rHEvt )
1322 {
1323     USHORT nItemId = GetPageId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
1324     if ( nItemId )
1325     {
1326         if ( rHEvt.GetMode() & HELPMODE_BALLOON )
1327         {
1328             XubString aStr = GetHelpText( nItemId );
1329             if ( aStr.Len() )
1330             {
1331                 Rectangle aItemRect = GetPageRect( nItemId );
1332                 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1333                 aItemRect.Left()   = aPt.X();
1334                 aItemRect.Top()    = aPt.Y();
1335                 aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1336                 aItemRect.Right()  = aPt.X();
1337                 aItemRect.Bottom() = aPt.Y();
1338                 Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
1339                 return;
1340             }
1341         }
1342         else if ( rHEvt.GetMode() & HELPMODE_EXTENDED )
1343         {
1344             ULONG nHelpId = GetHelpId( nItemId );
1345             if ( nHelpId )
1346             {
1347                 // Wenn eine Hilfe existiert, dann ausloesen
1348                 Help* pHelp = Application::GetHelp();
1349                 if ( pHelp )
1350                     pHelp->Start( nHelpId, this );
1351                 return;
1352             }
1353         }
1354
1355         // Bei Quick- oder Ballloon-Help zeigen wir den Text an,
1356         // wenn dieser abgeschnitten oder nicht voll sichtbar ist
1357         if ( rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON) )
1358         {
1359             USHORT nPos = GetPagePos( nItemId );
1360             ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1361             if ( pItem->mbShort ||
1362                 (pItem->maRect.Right()-TABBAR_OFFSET_X-5 > mnLastOffX) )
1363             {
1364                 Rectangle aItemRect = GetPageRect( nItemId );
1365                 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1366                 aItemRect.Left()   = aPt.X();
1367                 aItemRect.Top()    = aPt.Y();
1368                 aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1369                 aItemRect.Right()  = aPt.X();
1370                 aItemRect.Bottom() = aPt.Y();
1371                 XubString aStr = mpItemList->GetObject( nPos )->maText;
1372                 if ( aStr.Len() )
1373                 {
1374                     if ( rHEvt.GetMode() & HELPMODE_BALLOON )
1375                         Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
1376                     else
1377                         Help::ShowQuickHelp( this, aItemRect, aStr );
1378                     return;
1379                 }
1380             }
1381         }
1382     }
1383
1384     Window::RequestHelp( rHEvt );
1385 }
1386
1387 // -----------------------------------------------------------------------
1388
1389 void TabBar::StateChanged( StateChangedType nType )
1390 {
1391     Window::StateChanged( nType );
1392
1393     if ( nType == STATE_CHANGE_INITSHOW )
1394     {
1395         if ( (mbSizeFormat || mbFormat) && mpItemList->Count() )
1396             ImplFormat();
1397     }
1398     else if ( (nType == STATE_CHANGE_ZOOM) ||
1399               (nType == STATE_CHANGE_CONTROLFONT) )
1400     {
1401         ImplInitSettings( TRUE, FALSE );
1402         Invalidate();
1403     }
1404     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1405         Invalidate();
1406     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1407     {
1408         ImplInitSettings( FALSE, TRUE );
1409         Invalidate();
1410     }
1411     else if ( nType == STATE_CHANGE_MIRRORING )
1412     {
1413         // reacts on calls of EnableRTL, have to mirror all child controls
1414         if( mpFirstBtn ) mpFirstBtn->EnableRTL( IsRTLEnabled() );
1415         if( mpPrevBtn ) mpPrevBtn->EnableRTL( IsRTLEnabled() );
1416         if( mpNextBtn ) mpNextBtn->EnableRTL( IsRTLEnabled() );
1417         if( mpLastBtn ) mpLastBtn->EnableRTL( IsRTLEnabled() );
1418         if( mpImpl->mpSizer ) mpImpl->mpSizer->EnableRTL( IsRTLEnabled() );
1419         if( mpEdit ) mpEdit->EnableRTL( IsRTLEnabled() );
1420     }
1421 }
1422
1423 // -----------------------------------------------------------------------
1424
1425 void TabBar::DataChanged( const DataChangedEvent& rDCEvt )
1426 {
1427     Window::DataChanged( rDCEvt );
1428
1429     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1430          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1431          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1432           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1433     {
1434         ImplInitSettings( TRUE, TRUE );
1435         Invalidate();
1436     }
1437 }
1438
1439 // -----------------------------------------------------------------------
1440
1441 void TabBar::ImplSelect()
1442 {
1443     Select();
1444
1445     CallEventListeners( VCLEVENT_TABBAR_PAGESELECTED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(mnCurPageId)) );
1446 }
1447
1448 // -----------------------------------------------------------------------
1449
1450 void TabBar::Select()
1451 {
1452     maSelectHdl.Call( this );
1453 }
1454
1455 // -----------------------------------------------------------------------
1456
1457 void TabBar::DoubleClick()
1458 {
1459     maDoubleClickHdl.Call( this );
1460 }
1461
1462 // -----------------------------------------------------------------------
1463
1464 void TabBar::Split()
1465 {
1466     maSplitHdl.Call( this );
1467 }
1468
1469 // -----------------------------------------------------------------------
1470
1471 void TabBar::ImplActivatePage()
1472 {
1473     ActivatePage();
1474
1475     CallEventListeners( VCLEVENT_TABBAR_PAGEACTIVATED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(mnCurPageId)) );
1476 }
1477
1478 // -----------------------------------------------------------------------
1479
1480 void TabBar::ActivatePage()
1481 {
1482     maActivatePageHdl.Call( this );
1483 }
1484
1485 // -----------------------------------------------------------------------
1486
1487 long TabBar::ImplDeactivatePage()
1488 {
1489     long nRet = DeactivatePage();
1490
1491     CallEventListeners( VCLEVENT_TABBAR_PAGEDEACTIVATED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(mnCurPageId)) );
1492
1493     return nRet;
1494 }
1495
1496 // -----------------------------------------------------------------------
1497
1498 long TabBar::DeactivatePage()
1499 {
1500     if ( maDeactivatePageHdl.IsSet() )
1501         return maDeactivatePageHdl.Call( this );
1502     else
1503         return TRUE;
1504 }
1505
1506 // -----------------------------------------------------------------------
1507
1508 long TabBar::StartRenaming()
1509 {
1510     if ( maStartRenamingHdl.IsSet() )
1511         return maStartRenamingHdl.Call( this );
1512     else
1513         return TRUE;
1514 }
1515
1516 // -----------------------------------------------------------------------
1517
1518 long TabBar::AllowRenaming()
1519 {
1520     if ( maAllowRenamingHdl.IsSet() )
1521         return maAllowRenamingHdl.Call( this );
1522     else
1523         return TRUE;
1524 }
1525
1526 // -----------------------------------------------------------------------
1527
1528 void TabBar::EndRenaming()
1529 {
1530     maEndRenamingHdl.Call( this );
1531 }
1532
1533 // -----------------------------------------------------------------------
1534
1535 void TabBar::Mirror()
1536 {
1537
1538 }
1539
1540 // -----------------------------------------------------------------------
1541
1542 void TabBar::InsertPage( USHORT nPageId, const XubString& rText,
1543                          TabBarPageBits nBits, USHORT nPos )
1544 {
1545     DBG_ASSERT( nPageId, "TabBar::InsertPage(): PageId == 0" );
1546     DBG_ASSERT( GetPagePos( nPageId ) == TABBAR_PAGE_NOTFOUND,
1547                 "TabBar::InsertPage(): PageId already exists" );
1548     DBG_ASSERT( nBits <= TPB_SPECIAL, "TabBar::InsertPage(): nBits is wrong" );
1549
1550     // PageItem anlegen und in die Item-Liste eintragen
1551     ImplTabBarItem* pItem = new ImplTabBarItem( nPageId, rText, nBits );
1552     mpItemList->Insert( pItem, nPos );
1553     mbSizeFormat = TRUE;
1554
1555     // CurPageId gegebenenfalls setzen
1556     if ( !mnCurPageId )
1557         mnCurPageId = nPageId;
1558
1559     // Leiste neu ausgeben
1560     if ( IsReallyVisible() && IsUpdateMode() )
1561         Invalidate();
1562
1563     CallEventListeners( VCLEVENT_TABBAR_PAGEINSERTED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(nPageId)) );
1564 }
1565
1566 // -----------------------------------------------------------------------
1567
1568 void TabBar::RemovePage( USHORT nPageId )
1569 {
1570     USHORT nPos = GetPagePos( nPageId );
1571
1572     // Existiert Item
1573     if ( nPos != TABBAR_PAGE_NOTFOUND )
1574     {
1575         if ( mnCurPageId == nPageId )
1576             mnCurPageId = 0;
1577
1578         // Testen, ob erste sichtbare Seite verschoben werden muss
1579         if ( mnFirstPos > nPos )
1580             mnFirstPos--;
1581
1582         // Item-Daten loeschen
1583         delete mpItemList->Remove( nPos );
1584         mbFormat = TRUE;
1585
1586         // Leiste neu ausgeben
1587         if ( IsReallyVisible() && IsUpdateMode() )
1588             Invalidate();
1589
1590         CallEventListeners( VCLEVENT_TABBAR_PAGEREMOVED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(nPageId)) );
1591     }
1592 }
1593
1594 // -----------------------------------------------------------------------
1595
1596 void TabBar::MovePage( USHORT nPageId, USHORT nNewPos )
1597 {
1598     USHORT nPos = GetPagePos( nPageId );
1599     Pair aPair( nPos, nNewPos );
1600
1601     if ( nPos < nNewPos )
1602         nNewPos--;
1603
1604     if ( nPos == nNewPos )
1605         return;
1606
1607     // Existiert Item
1608     if ( nPos != TABBAR_PAGE_NOTFOUND )
1609     {
1610         // TabBar-Item in der Liste verschieben
1611         ImplTabBarItem* pItem = mpItemList->Remove( nPos );
1612         mpItemList->Insert( pItem, nNewPos );
1613         mbFormat = TRUE;
1614
1615         // Leiste neu ausgeben
1616         if ( IsReallyVisible() && IsUpdateMode() )
1617             Invalidate();
1618
1619         CallEventListeners( VCLEVENT_TABBAR_PAGEMOVED, (void*) &aPair );
1620     }
1621 }
1622
1623 // -----------------------------------------------------------------------
1624
1625 void TabBar::Clear()
1626 {
1627     // Alle Items loeschen
1628     ImplTabBarItem* pItem = mpItemList->First();
1629     while ( pItem )
1630     {
1631         // Item-Daten loeschen
1632         delete pItem;
1633         pItem = mpItemList->Next();
1634     }
1635
1636     // Items aus der Liste loeschen
1637     mpItemList->Clear();
1638     mbSizeFormat = TRUE;
1639     mnCurPageId = 0;
1640     mnFirstPos = 0;
1641
1642     // Leiste neu ausgeben
1643     if ( IsReallyVisible() && IsUpdateMode() )
1644         Invalidate();
1645
1646     CallEventListeners( VCLEVENT_TABBAR_PAGEREMOVED, (void*) TABBAR_PAGE_NOTFOUND );
1647 }
1648
1649 // -----------------------------------------------------------------------
1650
1651 void TabBar::EnablePage( USHORT nPageId, BOOL bEnable )
1652 {
1653     USHORT nPos = GetPagePos( nPageId );
1654
1655     if ( nPos != TABBAR_PAGE_NOTFOUND )
1656     {
1657         ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1658
1659         if ( pItem->mbEnable != bEnable )
1660         {
1661             pItem->mbEnable = bEnable;
1662
1663             // Leiste neu ausgeben
1664             if ( IsReallyVisible() && IsUpdateMode() )
1665                 Invalidate( pItem->maRect );
1666
1667             CallEventListeners( bEnable ? VCLEVENT_TABBAR_PAGEENABLED : VCLEVENT_TABBAR_PAGEDISABLED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(nPageId)) );
1668         }
1669     }
1670 }
1671
1672 // -----------------------------------------------------------------------
1673
1674 BOOL TabBar::IsPageEnabled( USHORT nPageId ) const
1675 {
1676     USHORT nPos = GetPagePos( nPageId );
1677
1678     if ( nPos != TABBAR_PAGE_NOTFOUND )
1679         return mpItemList->GetObject( nPos )->mbEnable;
1680     else
1681         return FALSE;
1682 }
1683
1684 // -----------------------------------------------------------------------
1685
1686 void TabBar::SetPageBits( USHORT nPageId, TabBarPageBits nBits )
1687 {
1688     USHORT nPos = GetPagePos( nPageId );
1689
1690     if ( nPos != TABBAR_PAGE_NOTFOUND )
1691     {
1692         ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1693
1694         if ( pItem->mnBits != nBits )
1695         {
1696             pItem->mnBits = nBits;
1697
1698             // Leiste neu ausgeben
1699             if ( IsReallyVisible() && IsUpdateMode() )
1700                 Invalidate( pItem->maRect );
1701         }
1702     }
1703 }
1704
1705 // -----------------------------------------------------------------------
1706
1707 TabBarPageBits TabBar::GetPageBits( USHORT nPageId ) const
1708 {
1709     USHORT nPos = GetPagePos( nPageId );
1710
1711     if ( nPos != TABBAR_PAGE_NOTFOUND )
1712         return mpItemList->GetObject( nPos )->mnBits;
1713     else
1714         return FALSE;
1715 }
1716
1717 // -----------------------------------------------------------------------
1718
1719 USHORT TabBar::GetPageCount() const
1720 {
1721     return (USHORT)mpItemList->Count();
1722 }
1723
1724 // -----------------------------------------------------------------------
1725
1726 USHORT TabBar::GetPageId( USHORT nPos ) const
1727 {
1728     ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1729     if ( pItem )
1730         return pItem->mnId;
1731     else
1732         return 0;
1733 }
1734
1735 // -----------------------------------------------------------------------
1736
1737 USHORT TabBar::GetPagePos( USHORT nPageId ) const
1738 {
1739     ImplTabBarItem* pItem = mpItemList->First();
1740     while ( pItem )
1741     {
1742         if ( pItem->mnId == nPageId )
1743             return (USHORT)mpItemList->GetCurPos();
1744
1745         pItem = mpItemList->Next();
1746     }
1747
1748     return TABBAR_PAGE_NOTFOUND;
1749 }
1750
1751 // -----------------------------------------------------------------------
1752
1753 USHORT TabBar::GetPageId( const Point& rPos ) const
1754 {
1755     ImplTabBarItem* pItem = mpItemList->First();
1756     while ( pItem )
1757     {
1758         if ( pItem->maRect.IsInside( rPos ) )
1759             return pItem->mnId;
1760
1761         pItem = mpItemList->Next();
1762     }
1763
1764     return 0;
1765 }
1766
1767 // -----------------------------------------------------------------------
1768
1769 Rectangle TabBar::GetPageRect( USHORT nPageId ) const
1770 {
1771     USHORT nPos = GetPagePos( nPageId );
1772
1773     if ( nPos != TABBAR_PAGE_NOTFOUND )
1774         return mpItemList->GetObject( nPos )->maRect;
1775     else
1776         return Rectangle();
1777 }
1778
1779 // -----------------------------------------------------------------------
1780
1781 void TabBar::SetCurPageId( USHORT nPageId )
1782 {
1783     USHORT nPos = GetPagePos( nPageId );
1784
1785     // Wenn Item nicht existiert, dann nichts machen
1786     if ( nPos != TABBAR_PAGE_NOTFOUND )
1787     {
1788         // Wenn sich aktuelle Page nicht geaendert hat, dann muessen wir
1789         // jetzt nichts mehr machen
1790         if ( nPageId == mnCurPageId )
1791             return;
1792
1793         // Muss invalidiert werden
1794         BOOL bUpdate = FALSE;
1795         if ( IsReallyVisible() && IsUpdateMode() )
1796             bUpdate = TRUE;
1797
1798         ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1799         ImplTabBarItem* pOldItem;
1800
1801         if ( mnCurPageId )
1802             pOldItem = mpItemList->GetObject( GetPagePos( mnCurPageId ) );
1803         else
1804             pOldItem = NULL;
1805
1806         // Wenn Page nicht selektiert, dann vorher selektierte Seite
1807         // deselktieren, wenn dies die einzige selektierte Seite ist
1808         if ( !pItem->mbSelect && pOldItem )
1809         {
1810             USHORT nSelPageCount = GetSelectPageCount();
1811             if ( nSelPageCount == 1 )
1812                 pOldItem->mbSelect = FALSE;
1813             pItem->mbSelect = TRUE;
1814         }
1815
1816         mnCurPageId = nPageId;
1817         mbFormat = TRUE;
1818
1819         // Dafuer sorgen, das aktuelle Page sichtbar wird
1820         if ( IsReallyVisible() )
1821         {
1822             if ( nPos < mnFirstPos )
1823                 SetFirstPageId( nPageId );
1824             else
1825             {
1826                 // sichtbare Breite berechnen
1827                 long nWidth = mnLastOffX;
1828                 if ( nWidth > TABBAR_OFFSET_X )
1829                     nWidth -= TABBAR_OFFSET_X;
1830                 if ( nWidth > ADDNEWPAGE_AREAWIDTH )
1831                     nWidth -= ADDNEWPAGE_AREAWIDTH;
1832
1833                 if ( pItem->maRect.IsEmpty() )
1834                     ImplFormat();
1835
1836                 while ( (mbMirrored ? (pItem->maRect.Left() < mnOffX) : (pItem->maRect.Right() > nWidth)) ||
1837                         pItem->maRect.IsEmpty() )
1838                 {
1839                     USHORT nNewPos = mnFirstPos+1;
1840                     // Dafuer sorgen, das min. die aktuelle TabPages als
1841                     // erste TabPage sichtbar ist
1842                     if ( nNewPos >= nPos )
1843                     {
1844                         SetFirstPageId( nPageId );
1845                         break;
1846                     }
1847                     else
1848                         SetFirstPageId( GetPageId( nNewPos ) );
1849                     ImplFormat();
1850                     // Falls erste Seite nicht weitergeschaltet wird, dann
1851                     // koennen wir abbrechen
1852                     if ( nNewPos != mnFirstPos )
1853                         break;
1854                 }
1855             }
1856         }
1857
1858         // Leiste neu ausgeben
1859         if ( bUpdate )
1860         {
1861             Invalidate( pItem->maRect );
1862             if ( pOldItem )
1863                 Invalidate( pOldItem->maRect );
1864         }
1865     }
1866 }
1867
1868 // -----------------------------------------------------------------------
1869
1870 void TabBar::MakeVisible( USHORT nPageId )
1871 {
1872     if ( !IsReallyVisible() )
1873         return;
1874
1875     USHORT nPos = GetPagePos( nPageId );
1876
1877     // Wenn Item nicht existiert, dann nichts machen
1878     if ( nPos != TABBAR_PAGE_NOTFOUND )
1879     {
1880         if ( nPos < mnFirstPos )
1881             SetFirstPageId( nPageId );
1882         else
1883         {
1884             ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1885
1886             // sichtbare Breite berechnen
1887             long nWidth = mnLastOffX;
1888             if ( nWidth > TABBAR_OFFSET_X )
1889                 nWidth -= TABBAR_OFFSET_X;
1890
1891             if ( mbFormat || pItem->maRect.IsEmpty() )
1892             {
1893                 mbFormat = TRUE;
1894                 ImplFormat();
1895             }
1896
1897             while ( (pItem->maRect.Right() > nWidth) ||
1898                     pItem->maRect.IsEmpty() )
1899             {
1900                 USHORT nNewPos = mnFirstPos+1;
1901                 // Dafuer sorgen, das min. die aktuelle TabPages als
1902                 // erste TabPage sichtbar ist
1903                 if ( nNewPos >= nPos )
1904                 {
1905                     SetFirstPageId( nPageId );
1906                     break;
1907                 }
1908                 else
1909                     SetFirstPageId( GetPageId( nNewPos ) );
1910                 ImplFormat();
1911                 // Falls erste Seite nicht weitergeschaltet wird, dann
1912                 // koennen wir abbrechen
1913                 if ( nNewPos != mnFirstPos )
1914                     break;
1915             }
1916         }
1917     }
1918 }
1919
1920 // -----------------------------------------------------------------------
1921
1922 void TabBar::SetFirstPageId( USHORT nPageId )
1923 {
1924     USHORT nPos = GetPagePos( nPageId );
1925
1926     // Wenn Item nicht existiert, dann FALSE zurueckgeben
1927     if ( nPos != TABBAR_PAGE_NOTFOUND )
1928     {
1929         if ( nPos != mnFirstPos )
1930         {
1931             // Dafuer sorgen, das nach Moeglichkteit soviele Pages wie
1932             // moeglich sichtbar sind
1933             ImplFormat();
1934             USHORT nLastFirstPos = ImplGetLastFirstPos();
1935             USHORT nNewPos;
1936             if ( nPos > nLastFirstPos )
1937                 nNewPos = nLastFirstPos;
1938             else
1939                 nNewPos = nPos;
1940
1941             if ( nNewPos != mnFirstPos )
1942             {
1943                 mnFirstPos = nNewPos;
1944                 mbFormat = TRUE;
1945
1946                 // Leiste neu ausgeben (Achtung: mbDropPos beachten, da wenn
1947                 // dieses Flag gesetzt ist, wird direkt gepaintet)
1948                 if ( IsReallyVisible() && IsUpdateMode() && !mbDropPos )
1949                     Invalidate();
1950             }
1951         }
1952     }
1953 }
1954
1955 // -----------------------------------------------------------------------
1956
1957 void TabBar::SelectPage( USHORT nPageId, BOOL bSelect )
1958 {
1959     USHORT nPos = GetPagePos( nPageId );
1960
1961     if ( nPos != TABBAR_PAGE_NOTFOUND )
1962     {
1963         ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
1964
1965         if ( pItem->mbSelect != bSelect )
1966         {
1967             pItem->mbSelect = bSelect;
1968
1969             // Leiste neu ausgeben
1970             if ( IsReallyVisible() && IsUpdateMode() )
1971                 Invalidate( pItem->maRect );
1972         }
1973     }
1974 }
1975
1976 // -----------------------------------------------------------------------
1977
1978 void TabBar::SelectPageRange( BOOL bSelect, USHORT nStartPos, USHORT nEndPos )
1979 {
1980     Rectangle       aPaintRect;
1981     USHORT          nPos = nStartPos;
1982     ImplTabBarItem* pItem = mpItemList->Seek( nPos );
1983     while ( pItem && (nPos <= nEndPos) )
1984     {
1985         if ( (pItem->mbSelect != bSelect) && (pItem->mnId != mnCurPageId) )
1986         {
1987             pItem->mbSelect = bSelect;
1988             aPaintRect.Union( pItem->maRect );
1989         }
1990
1991         nPos++;
1992         pItem = mpItemList->Next();
1993     }
1994
1995     // Leiste neu ausgeben
1996     if ( IsReallyVisible() && IsUpdateMode() && !aPaintRect.IsEmpty() )
1997         Invalidate( aPaintRect );
1998 }
1999
2000 // -----------------------------------------------------------------------
2001
2002 USHORT TabBar::GetSelectPage( USHORT nSelIndex ) const
2003 {
2004     USHORT          nSelected = 0;
2005     ImplTabBarItem* pItem = mpItemList->First();
2006     while ( pItem )
2007     {
2008         if ( pItem->mbSelect )
2009             nSelected++;
2010
2011         if ( nSelected == nSelIndex )
2012             return pItem->mnId;
2013
2014         pItem = mpItemList->Next();
2015     }
2016
2017     return 0;
2018 }
2019
2020 // -----------------------------------------------------------------------
2021
2022 USHORT TabBar::GetSelectPageCount() const
2023 {
2024     USHORT          nSelected = 0;
2025     ImplTabBarItem* pItem = mpItemList->First();
2026     while ( pItem )
2027     {
2028         if ( pItem->mbSelect )
2029             nSelected++;
2030
2031         pItem = mpItemList->Next();
2032     }
2033
2034     return nSelected;
2035 }
2036
2037 // -----------------------------------------------------------------------
2038
2039 BOOL TabBar::IsPageSelected( USHORT nPageId ) const
2040 {
2041     USHORT nPos = GetPagePos( nPageId );
2042     if ( nPos != TABBAR_PAGE_NOTFOUND )
2043         return mpItemList->GetObject( nPos )->mbSelect;
2044     else
2045         return FALSE;
2046 }
2047
2048 // -----------------------------------------------------------------------
2049
2050 BOOL TabBar::StartEditMode( USHORT nPageId )
2051 {
2052     USHORT nPos = GetPagePos( nPageId );
2053     if ( mpEdit || (nPos == TABBAR_PAGE_NOTFOUND) || (mnLastOffX < 8) )
2054         return FALSE;
2055
2056     mnEditId = nPageId;
2057     if ( StartRenaming() )
2058     {
2059         ImplShowPage( nPos );
2060         ImplFormat();
2061         Update();
2062
2063         mpEdit = new TabBarEdit( this, WB_CENTER );
2064         Rectangle aRect = GetPageRect( mnEditId );
2065         long nX = aRect.Left()+TABBAR_OFFSET_X+(TABBAR_OFFSET_X2/2);
2066         long nWidth = aRect.GetWidth()-(TABBAR_OFFSET_X*2)-TABBAR_OFFSET_X2;
2067         if ( mnEditId != GetCurPageId() )
2068             nX += 1;
2069         if ( nX+nWidth > mnLastOffX )
2070             nWidth = mnLastOffX-nX;
2071         if ( nWidth < 3 )
2072         {
2073             nX = aRect.Left();
2074             nWidth = aRect.GetWidth();
2075         }
2076         mpEdit->SetText( GetPageText( mnEditId ) );
2077         mpEdit->SetPosSizePixel( nX, aRect.Top()+mnOffY+1, nWidth, aRect.GetHeight()-3 );
2078         Font    aFont = GetPointFont();
2079         Color   aForegroundColor;
2080         Color   aBackgroundColor;
2081         Color   aFaceColor;
2082         Color   aSelectColor;
2083         Color   aFaceTextColor;
2084         Color   aSelectTextColor;
2085         ImplGetColors( aFaceColor, aFaceTextColor, aSelectColor, aSelectTextColor );
2086         if ( mnEditId != GetCurPageId() )
2087             aFont.SetWeight( WEIGHT_LIGHT );
2088         if ( IsPageSelected( mnEditId ) || (mnEditId == GetCurPageId()) )
2089         {
2090             aForegroundColor = aSelectTextColor;
2091             aBackgroundColor = aSelectColor;
2092         }
2093         else
2094         {
2095             aForegroundColor = aFaceTextColor;
2096             aBackgroundColor = aFaceColor;
2097         }
2098         if ( GetPageBits( mnEditId ) & TPB_SPECIAL )
2099             aForegroundColor = Color( COL_LIGHTBLUE );
2100         mpEdit->SetControlFont( aFont );
2101         mpEdit->SetControlForeground( aForegroundColor );
2102         mpEdit->SetControlBackground( aBackgroundColor );
2103         mpEdit->GrabFocus();
2104         mpEdit->SetSelection( Selection( 0, mpEdit->GetText().Len() ) );
2105         mpEdit->Show();
2106         return TRUE;
2107     }
2108     else
2109     {
2110         mnEditId = 0;
2111         return FALSE;
2112     }
2113 }
2114
2115 // -----------------------------------------------------------------------
2116
2117 void TabBar::EndEditMode( BOOL bCancel )
2118 {
2119     if ( mpEdit )
2120     {
2121         // call hdl
2122         BOOL bEnd = TRUE;
2123         mbEditCanceled = bCancel;
2124         maEditText = mpEdit->GetText();
2125         mpEdit->SetPostEvent();
2126         if ( !bCancel )
2127         {
2128             long nAllowRenaming = AllowRenaming();
2129             if ( nAllowRenaming == TABBAR_RENAMING_YES )
2130                 SetPageText( mnEditId, maEditText );
2131             else if ( nAllowRenaming == TABBAR_RENAMING_NO )
2132                 bEnd = FALSE;
2133             else // nAllowRenaming == TABBAR_RENAMING_CANCEL
2134                 mbEditCanceled = TRUE;
2135         }
2136
2137         // renaming not allowed, than reset edit data
2138         if ( !bEnd )
2139         {
2140             mpEdit->ResetPostEvent();
2141             mpEdit->GrabFocus();
2142         }
2143         else
2144         {
2145             // close edit and call end hdl
2146             delete mpEdit;
2147             mpEdit = NULL;
2148             EndRenaming();
2149             mnEditId = 0;
2150         }
2151
2152         // reset
2153         maEditText.Erase();
2154         mbEditCanceled = FALSE;
2155     }
2156 }
2157
2158 // -----------------------------------------------------------------------
2159
2160 void TabBar::SetMirrored( BOOL bMirrored )
2161 {
2162     if( mbMirrored != bMirrored )
2163     {
2164         mbMirrored = bMirrored;
2165         mbSizeFormat = TRUE;
2166         ImplInitControls();     // for button images
2167         Resize();               // recalculates control positions
2168         Mirror();
2169     }
2170 }
2171
2172 void TabBar::SetEffectiveRTL( BOOL bRTL )
2173 {
2174     SetMirrored( bRTL != Application::GetSettings().GetLayoutRTL() );
2175 }
2176
2177 BOOL TabBar::IsEffectiveRTL() const
2178 {
2179     return IsMirrored() != Application::GetSettings().GetLayoutRTL();
2180 }
2181
2182 // -----------------------------------------------------------------------
2183
2184 void TabBar::SetMaxPageWidth( long nMaxWidth )
2185 {
2186     if ( mnMaxPageWidth != nMaxWidth )
2187     {
2188         mnMaxPageWidth = nMaxWidth;
2189         mbSizeFormat = TRUE;
2190
2191         // Leiste neu ausgeben
2192         if ( IsReallyVisible() && IsUpdateMode() )
2193             Invalidate();
2194     }
2195 }
2196
2197 // -----------------------------------------------------------------------
2198
2199 void TabBar::SetSelectColor()
2200 {
2201     if ( mbSelColor )
2202     {
2203         maSelColor = Color( COL_TRANSPARENT );
2204         mbSelColor = FALSE;
2205         Invalidate();
2206     }
2207 }
2208
2209 // -----------------------------------------------------------------------
2210
2211 void TabBar::SetSelectColor( const Color& rColor )
2212 {
2213     if ( rColor.GetTransparency() )
2214     {
2215         if ( mbSelColor )
2216         {
2217             maSelColor = Color( COL_TRANSPARENT );
2218             mbSelColor = FALSE;
2219             Invalidate();
2220         }
2221     }
2222     else
2223     {
2224         if ( maSelColor != rColor )
2225         {
2226             maSelColor = rColor;
2227             mbSelColor = TRUE;
2228             Invalidate();
2229         }
2230     }
2231 }
2232
2233 // -----------------------------------------------------------------------
2234
2235 void TabBar::SetSelectTextColor()
2236 {
2237     if ( mbSelTextColor )
2238     {
2239         maSelTextColor = Color( COL_TRANSPARENT );
2240         mbSelTextColor = FALSE;
2241         Invalidate();
2242     }
2243 }
2244
2245 // -----------------------------------------------------------------------
2246
2247 void TabBar::SetSelectTextColor( const Color& rColor )
2248 {
2249     if ( rColor.GetTransparency() )
2250     {
2251         if ( mbSelTextColor )
2252         {
2253             maSelTextColor = Color( COL_TRANSPARENT );
2254             mbSelTextColor = FALSE;
2255             Invalidate();
2256         }
2257     }
2258     else
2259     {
2260         if ( maSelTextColor != rColor )
2261         {
2262             maSelTextColor = rColor;
2263             mbSelTextColor = TRUE;
2264             Invalidate();
2265         }
2266     }
2267 }
2268
2269 // -----------------------------------------------------------------------
2270
2271 void TabBar::SetPageText( USHORT nPageId, const XubString& rText )
2272 {
2273     USHORT nPos = GetPagePos( nPageId );
2274     if ( nPos != TABBAR_PAGE_NOTFOUND )
2275     {
2276         mpItemList->GetObject( nPos )->maText = rText;
2277         mbSizeFormat = TRUE;
2278
2279         // Leiste neu ausgeben
2280         if ( IsReallyVisible() && IsUpdateMode() )
2281             Invalidate();
2282
2283         CallEventListeners( VCLEVENT_TABBAR_PAGETEXTCHANGED, reinterpret_cast<void*>(sal::static_int_cast<sal_IntPtr>(nPageId)) );
2284     }
2285 }
2286
2287 // -----------------------------------------------------------------------
2288
2289 XubString TabBar::GetPageText( USHORT nPageId ) const
2290 {
2291     USHORT nPos = GetPagePos( nPageId );
2292     if ( nPos != TABBAR_PAGE_NOTFOUND )
2293         return mpItemList->GetObject( nPos )->maText;
2294     else
2295         return XubString();
2296 }
2297
2298 // -----------------------------------------------------------------------
2299
2300 void TabBar::SetHelpText( USHORT nPageId, const XubString& rText )
2301 {
2302     USHORT nPos = GetPagePos( nPageId );
2303     if ( nPos != TABBAR_PAGE_NOTFOUND )
2304         mpItemList->GetObject( nPos )->maHelpText = rText;
2305 }
2306
2307 // -----------------------------------------------------------------------
2308
2309 XubString TabBar::GetHelpText( USHORT nPageId ) const
2310 {
2311     USHORT nPos = GetPagePos( nPageId );
2312     if ( nPos != TABBAR_PAGE_NOTFOUND )
2313     {
2314         ImplTabBarItem* pItem = mpItemList->GetObject( nPos );
2315         if ( !pItem->maHelpText.Len() && pItem->mnHelpId )
2316         {
2317             Help* pHelp = Application::GetHelp();
2318             if ( pHelp )
2319                 pItem->maHelpText = pHelp->GetHelpText( pItem->mnHelpId, this );
2320         }
2321
2322         return pItem->maHelpText;
2323     }
2324     else
2325         return XubString();
2326 }
2327
2328 // -----------------------------------------------------------------------
2329
2330 void TabBar::SetHelpId( USHORT nPageId, ULONG nHelpId )
2331 {
2332     USHORT nPos = GetPagePos( nPageId );
2333     if ( nPos != TABBAR_PAGE_NOTFOUND )
2334         mpItemList->GetObject( nPos )->mnHelpId = nHelpId;
2335 }
2336
2337 // -----------------------------------------------------------------------
2338
2339 ULONG TabBar::GetHelpId( USHORT nPageId ) const
2340 {
2341     USHORT nPos = GetPagePos( nPageId );
2342     if ( nPos != TABBAR_PAGE_NOTFOUND )
2343         return mpItemList->GetObject( nPos )->mnHelpId;
2344     else
2345         return 0;
2346 }
2347
2348 // -----------------------------------------------------------------------
2349
2350 long TabBar::GetMinSize() const
2351 {
2352     long nMinSize = TABBAR_MINSIZE + TABBAR_OFFSET_X;
2353     if ( mnWinStyle & WB_MINSCROLL )
2354         nMinSize += mpPrevBtn->GetSizePixel().Width()*2;
2355     else if ( mnWinStyle & WB_SCROLL )
2356         nMinSize += mpFirstBtn->GetSizePixel().Width()*4;
2357     return nMinSize;
2358 }
2359
2360 // -----------------------------------------------------------------------
2361
2362 BOOL TabBar::StartDrag( const CommandEvent& rCEvt, Region& rRegion )
2363 {
2364     if ( !(mnWinStyle & WB_DRAG) || (rCEvt.GetCommand() != COMMAND_STARTDRAG) )
2365         return FALSE;
2366
2367     // Testen, ob angeklickte Seite selektiert ist. Falls dies nicht
2368     // der Fall ist, setzen wir ihn als aktuellen Eintrag. Falls Drag and
2369     // Drop auch mal ueber Tastatur ausgeloest werden kann, testen wir
2370     // dies nur bei einer Mausaktion.
2371     // Ausserdem machen wir das nur, wenn kein Select() ausgeloest wurde,
2372     // da der Select schon den Bereich gescrollt haben kann
2373     if ( rCEvt.IsMouseEvent() && !mbInSelect )
2374     {
2375         USHORT nSelId = GetPageId( rCEvt.GetMousePosPixel() );
2376
2377         // Falls kein Eintrag angeklickt wurde, starten wir kein Dragging
2378         if ( !nSelId )
2379             return FALSE;
2380
2381         // Testen, ob Seite selektiertiert ist. Falls nicht, als aktuelle
2382         // Seite setzen und Select rufen.
2383         if ( !IsPageSelected( nSelId ) )
2384         {
2385             if ( ImplDeactivatePage() )
2386             {
2387                 SetCurPageId( nSelId );
2388                 Update();
2389                 ImplActivatePage();
2390                 ImplSelect();
2391             }
2392             else
2393                 return FALSE;
2394         }
2395     }
2396     mbInSelect = FALSE;
2397
2398     Region aRegion;
2399
2400     // Region zuweisen
2401     rRegion = aRegion;
2402
2403     return TRUE;
2404 }
2405
2406 // -----------------------------------------------------------------------
2407
2408 USHORT TabBar::ShowDropPos( const Point& rPos )
2409 {
2410     ImplTabBarItem* pItem;
2411     USHORT      nDropId;
2412     USHORT      nNewDropPos;
2413     USHORT      nItemCount = (USHORT)mpItemList->Count();
2414     short       nScroll = 0;
2415
2416     if ( rPos.X() > mnLastOffX-TABBAR_DRAG_SCROLLOFF )
2417     {
2418         pItem = mpItemList->GetObject( mpItemList->Count()-1 );
2419         if ( !pItem->maRect.IsEmpty() && (rPos.X() > pItem->maRect.Right()) )
2420             nNewDropPos = (USHORT)mpItemList->Count();
2421         else
2422         {
2423             nNewDropPos = mnFirstPos+1;
2424             nScroll = 1;
2425         }
2426     }
2427     else if ( (rPos.X() <= mnOffX) ||
2428               (!mnOffX && (rPos.X() <= TABBAR_DRAG_SCROLLOFF)) )
2429     {
2430         if ( mnFirstPos )
2431         {
2432             nNewDropPos = mnFirstPos;
2433             nScroll = -1;
2434         }
2435         else
2436             nNewDropPos = 0;
2437     }
2438     else
2439     {
2440         nDropId = GetPageId( rPos );
2441         if ( nDropId )
2442         {
2443             nNewDropPos = GetPagePos( nDropId );
2444             if ( mnFirstPos && (nNewDropPos == mnFirstPos-1) )
2445                 nScroll = -1;
2446         }
2447         else
2448             nNewDropPos = nItemCount;
2449     }
2450
2451     if ( mbDropPos && (nNewDropPos == mnDropPos) && !nScroll )
2452         return mnDropPos;
2453
2454     if ( mbDropPos )
2455         HideDropPos();
2456     mbDropPos = TRUE;
2457     mnDropPos = nNewDropPos;
2458
2459     if ( nScroll )
2460     {
2461         USHORT nOldFirstPos = mnFirstPos;
2462         SetFirstPageId( GetPageId( mnFirstPos+nScroll ) );
2463
2464         // Direkt ausgeben, da kein Paint bei Drag and Drop moeglich
2465         if ( nOldFirstPos != mnFirstPos )
2466         {
2467             Rectangle aRect( mnOffX, 0, mnLastOffX, maWinSize.Height() );
2468             SetFillColor( GetBackground().GetColor() );
2469             DrawRect( aRect );
2470             Paint( aRect );
2471         }
2472     }
2473
2474     // Drop-Position-Pfeile ausgeben
2475     Color       aBlackColor( COL_BLACK );
2476     long        nX;
2477     long        nY = (maWinSize.Height()/2)-1;
2478     USHORT      nCurPos = GetPagePos( mnCurPageId );
2479
2480     SetLineColor( aBlackColor );
2481     if ( mnDropPos < nItemCount )
2482     {
2483         pItem = mpItemList->GetObject( mnDropPos );
2484         nX = pItem->maRect.Left()+TABBAR_OFFSET_X;
2485         if ( mnDropPos == nCurPos )
2486             nX--;
2487         else
2488             nX++;
2489         DrawLine( Point( nX, nY ), Point( nX, nY ) );
2490         DrawLine( Point( nX+1, nY-1 ), Point( nX+1, nY+1 ) );
2491         DrawLine( Point( nX+2, nY-2 ), Point( nX+2, nY+2 ) );
2492     }
2493     if ( (mnDropPos > 0) && (mnDropPos < nItemCount+1) )
2494     {
2495         pItem = mpItemList->GetObject( mnDropPos-1 );
2496         nX = pItem->maRect.Right()-TABBAR_OFFSET_X;
2497         if ( mnDropPos == nCurPos )
2498             nX++;
2499         DrawLine( Point( nX, nY ), Point( nX, nY ) );
2500         DrawLine( Point( nX-1, nY-1 ), Point( nX-1, nY+1 ) );
2501         DrawLine( Point( nX-2, nY-2 ), Point( nX-2, nY+2 ) );
2502     }
2503
2504     return mnDropPos;
2505 }
2506
2507 // -----------------------------------------------------------------------
2508
2509 void TabBar::HideDropPos()
2510 {
2511     if ( mbDropPos )
2512     {
2513         ImplTabBarItem* pItem;
2514         long        nX;
2515         long        nY1 = (maWinSize.Height()/2)-3;
2516         long        nY2 = nY1 + 5;
2517         USHORT      nItemCount = (USHORT)mpItemList->Count();
2518
2519         if ( mnDropPos < nItemCount )
2520         {
2521             pItem = mpItemList->GetObject( mnDropPos );
2522             nX = pItem->maRect.Left()+TABBAR_OFFSET_X;
2523             // Paint direkt aufrufen, da bei Drag and Drop kein Paint
2524             // moeglich
2525             Rectangle aRect( nX-1, nY1, nX+3, nY2 );
2526             Region aRegion( aRect );
2527             SetClipRegion( aRegion );
2528             Paint( aRect );
2529             SetClipRegion();
2530         }
2531         if ( (mnDropPos > 0) && (mnDropPos < nItemCount+1) )
2532         {
2533             pItem = mpItemList->GetObject( mnDropPos-1 );
2534             nX = pItem->maRect.Right()-TABBAR_OFFSET_X;
2535             // Paint direkt aufrufen, da bei Drag and Drop kein Paint
2536             // moeglich
2537             Rectangle aRect( nX-2, nY1, nX+1, nY2 );
2538             Region aRegion( aRect );
2539             SetClipRegion( aRegion );
2540             Paint( aRect );
2541             SetClipRegion();
2542         }
2543
2544         mbDropPos = FALSE;
2545         mnDropPos = 0;
2546     }
2547 }
2548
2549 // -----------------------------------------------------------------------
2550
2551 BOOL TabBar::SwitchPage( const Point& rPos )
2552 {
2553     BOOL    bSwitch = FALSE;
2554     USHORT  nSwitchId = GetPageId( rPos );
2555     if ( !nSwitchId )
2556         EndSwitchPage();
2557     else
2558     {
2559         if ( nSwitchId != mnSwitchId )
2560         {
2561             mnSwitchId = nSwitchId;
2562             mnSwitchTime = Time::GetSystemTicks();
2563         }
2564         else
2565         {
2566             // Erst nach 500 ms umschalten
2567             if ( mnSwitchId != GetCurPageId() )
2568             {
2569                 if ( Time::GetSystemTicks() > mnSwitchTime+500 )
2570                 {
2571                     mbInSwitching = TRUE;
2572                     if ( ImplDeactivatePage() )
2573                     {
2574                         SetCurPageId( mnSwitchId );
2575                         Update();
2576                         ImplActivatePage();
2577                         ImplSelect();
2578                         bSwitch = TRUE;
2579                     }
2580                     mbInSwitching = FALSE;
2581                 }
2582             }
2583         }
2584     }
2585
2586     return bSwitch;
2587 }
2588
2589 // -----------------------------------------------------------------------
2590
2591 void TabBar::EndSwitchPage()
2592 {
2593     mnSwitchTime    = 0;
2594     mnSwitchId      = 0;
2595 }
2596
2597 // -----------------------------------------------------------------------
2598
2599 void TabBar::SetStyle( WinBits nStyle )
2600 {
2601     mnWinStyle = nStyle;
2602     ImplInitControls();
2603     // Evt. Controls neu anordnen
2604     if ( IsReallyVisible() && IsUpdateMode() )
2605         Resize();
2606 }
2607
2608 // -----------------------------------------------------------------------
2609
2610 Size TabBar::CalcWindowSizePixel() const
2611 {
2612     long nWidth = 0;
2613
2614     if ( mpItemList->Count() )
2615     {
2616         ((TabBar*)this)->ImplCalcWidth();
2617         ImplTabBarItem* pItem = mpItemList->First();
2618         while ( pItem )
2619         {
2620             nWidth += pItem->mnWidth;
2621             pItem = mpItemList->Next();
2622         }
2623         nWidth += TABBAR_OFFSET_X+TABBAR_OFFSET_X2;
2624     }
2625
2626     return Size( nWidth, GetSettings().GetStyleSettings().GetScrollBarSize() );
2627 }
2628 // -----------------------------------------------------------------------
2629
2630 Rectangle TabBar::GetPageArea() const
2631 {
2632     return Rectangle( Point( mnOffX, mnOffY ), Size( mnLastOffX-mnOffX+1, GetSizePixel().Height()-mnOffY ) );
2633 }
2634
2635 // -----------------------------------------------------------------------
2636
2637 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > TabBar::CreateAccessible()
2638 {
2639     return mpImpl->maAccessibleFactory.getFactory().createAccessibleTabBar( *this );
2640 }
2641
2642 // -----------------------------------------------------------------------