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