svtools/source/control/taskbar.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: taskbar.cxx,v $
  10  * $Revision: 1.7 $
  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 #define _TASKBAR_CXX
  35
  36 #ifndef _TOOLS_LIST_HXX
  37 #include <tools/list.hxx>
  38 #endif
  39 #include <tools/debug.hxx>
  40
  41 #ifndef _VCL_FLOATWIN_HXX
  42 #include <vcl/floatwin.hxx>
  43 #endif
  44
  45 #include <taskbar.hxx>
  46
  47 // =======================================================================
  48
  49 class ImplTaskBarFloat : public FloatingWindow
  50 {
  51 public:
  52     TaskBar*                    mpTaskBar;
  53
  54 public:
  55                         ImplTaskBarFloat( TaskBar* pTaskBar );
  56 };
  57
  58 // -----------------------------------------------------------------------
  59
  60 ImplTaskBarFloat::ImplTaskBarFloat( TaskBar* pTaskBar ) :
  61     FloatingWindow( pTaskBar, 0 )
  62 {
  63     mpTaskBar   = pTaskBar;
  64 }
  65
  66 // =======================================================================
  67
  68 #define TASKBAR_BORDER                          2
  69 #define TASKBAR_OFFSIZE                         3
  70 #define TASKBAR_OFFX                            2
  71 #define TASKBAR_OFFY                            1
  72 #define TASKBAR_BUTTONOFF                       5
  73 #define TASKBAR_AUTOHIDE_HEIGHT         2
  74
  75 // =======================================================================
  76
  77 TaskBar::TaskBar( Window* pParent, WinBits nWinStyle ) :
  78     Window( pParent, WB_3DLOOK )
  79 {
  80     mpButtonBar                 = NULL;
  81     mpTaskToolBox               = NULL;
  82     mpStatusBar                 = NULL;
  83     mnStatusWidth               = 0;
  84     mnOldStatusWidth    = 0;
  85     mnLines                     = 1;
  86     mnWinBits                   = nWinStyle;
  87     mbStatusText                = FALSE;
  88     mbShowItems                 = FALSE;
  89     mbAutoHide                  = FALSE;
  90
  91     ImplInitSettings();
  92 }
  93
  94 // -----------------------------------------------------------------------
  95
  96 TaskBar::~TaskBar()
  97 {
  98     if ( mpButtonBar )
  99         delete mpButtonBar;
 100     if ( mpTaskToolBox )
 101         delete mpTaskToolBox;
 102     if ( mpStatusBar )
 103         delete mpStatusBar;
 104 }
 105
 106 // -----------------------------------------------------------------------
 107
 108 void TaskBar::ImplInitSettings()
 109 {
 110     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 111
 112     Color aColor;
 113     if ( IsControlBackground() )
 114         aColor = GetControlBackground();
 115     else if ( Window::GetStyle() & WB_3DLOOK )
 116         aColor = rStyleSettings.GetFaceColor();
 117     else
 118         aColor = rStyleSettings.GetWindowColor();
 119     SetBackground( aColor );
 120 }
 121
 122 // -----------------------------------------------------------------------
 123
 124 void TaskBar::ImplNewHeight( long nNewHeight )
 125 {
 126     long nOldHeight = GetSizePixel().Height();
 127     if ( nNewHeight != nOldHeight )
 128     {
 129         long nY = GetPosPixel().Y()-(nNewHeight-nOldHeight);
 130         SetPosSizePixel( 0, nY, 0, nNewHeight,
 131                          WINDOW_POSSIZE_Y | WINDOW_POSSIZE_HEIGHT );
 132         TaskResize();
 133     }
 134 }
 135
 136 // -----------------------------------------------------------------------
 137
 138 void TaskBar::TaskResize()
 139 {
 140     maTaskResizeHdl.Call( this );
 141 }
 142
 143 // -----------------------------------------------------------------------
 144
 145 TaskButtonBar* TaskBar::CreateButtonBar()
 146 {
 147     return new TaskButtonBar( this );
 148 }
 149
 150 // -----------------------------------------------------------------------
 151
 152 TaskToolBox* TaskBar::CreateTaskToolBox()
 153 {
 154     return new TaskToolBox( this );
 155 }
 156
 157 // -----------------------------------------------------------------------
 158
 159 TaskStatusBar* TaskBar::CreateTaskStatusBar()
 160 {
 161     return new TaskStatusBar( this );
 162 }
 163
 164 // -----------------------------------------------------------------------
 165
 166 void TaskBar::MouseMove( const MouseEvent& rMEvt )
 167 {
 168     if ( mnWinBits & WB_SIZEABLE )
 169     {
 170         TaskToolBox*    pTempTaskToolBox = GetTaskToolBox();
 171         TaskStatusBar*  pTempStatusBar = GetStatusBar();
 172
 173         if ( pTempTaskToolBox && pTempStatusBar )
 174         {
 175             long                        nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 176             long                        nMouseX = rMEvt.GetPosPixel().X();
 177             PointerStyle        ePtrStyle;
 178             if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
 179                 ePtrStyle = POINTER_HSIZEBAR;
 180             else
 181                 ePtrStyle = POINTER_ARROW;
 182             Pointer aPtr( ePtrStyle );
 183             SetPointer( aPtr );
 184         }
 185     }
 186 }
 187
 188 // -----------------------------------------------------------------------
 189
 190 void TaskBar::MouseButtonDown( const MouseEvent& rMEvt )
 191 {
 192     if ( rMEvt.IsLeft() && (mnWinBits & WB_SIZEABLE) )
 193     {
 194         TaskToolBox*    pTempTaskToolBox = GetTaskToolBox();
 195         TaskStatusBar*  pTempStatusBar = GetStatusBar();
 196
 197         if ( pTempTaskToolBox && pTempStatusBar )
 198         {
 199             long        nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 200             long        nMouseX = rMEvt.GetPosPixel().X();
 201             if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
 202             {
 203                 if ( rMEvt.GetClicks() == 2 )
 204                 {
 205                     if ( mnStatusWidth )
 206                     {
 207                         mnStatusWidth = 0;
 208                         Resize();
 209                     }
 210                 }
 211                 else
 212                 {
 213                     StartTracking();
 214                     mnOldStatusWidth = mnStatusWidth;
 215                     mnMouseOff = nMouseX-nStatusX;
 216                 }
 217             }
 218         }
 219     }
 220 }
 221
 222 // -----------------------------------------------------------------------
 223
 224 void TaskBar::Tracking( const TrackingEvent& rTEvt )
 225 {
 226     if ( rTEvt.IsTrackingEnded() )
 227     {
 228         if ( rTEvt.IsTrackingCanceled() )
 229         {
 230             mnStatusWidth = mnOldStatusWidth;
 231             Resize();
 232             Update();
 233         }
 234     }
 235     else
 236     {
 237         Size aSize = GetOutputSizePixel();
 238
 239         long nMouseX = rTEvt.GetMouseEvent().GetPosPixel().X()-mnMouseOff;
 240         if ( nMouseX < 0 )
 241             nMouseX = 0;
 242         long nMaxX = aSize.Width()-TASKBAR_OFFX-TASKBAR_OFFSIZE-1;
 243         if ( nMouseX > nMaxX )
 244             nMouseX = nMaxX;
 245         mnStatusWidth = aSize.Width()-nMouseX-TASKBAR_OFFX-TASKBAR_OFFSIZE;
 246         Resize();
 247         Update();
 248     }
 249 }
 250
 251 // -----------------------------------------------------------------------
 252
 253 void TaskBar::Paint( const Rectangle& rRect )
 254 {
 255     if ( mnWinBits & (WB_BORDER | WB_SIZEABLE) )
 256     {
 257         const StyleSettings&    rStyleSettings = GetSettings().GetStyleSettings();
 258         Size                                    aSize = GetOutputSizePixel();
 259         long    nY = 0;
 260
 261         if ( mnWinBits & WB_BORDER )
 262         {
 263             SetLineColor( rStyleSettings.GetShadowColor() );
 264             DrawLine( Point( 0, 0 ), Point( aSize.Width()-1, 0 ) );
 265             SetLineColor( rStyleSettings.GetLightColor() );
 266             DrawLine( Point( 0, 1 ), Point( aSize.Width()-1, 1 ) );
 267             nY += 2;
 268         }
 269
 270         if ( (mnWinBits & WB_SIZEABLE) )
 271         {
 272             //TaskButtonBar*    pTempButtonBar = GetButtonBar();
 273             TaskToolBox*        pTempTaskToolBox = GetTaskToolBox();
 274             TaskStatusBar*      pTempStatusBar = GetStatusBar();
 275
 276             if ( pTempTaskToolBox && pTempStatusBar )
 277             {
 278                 long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 279                 if ( nStatusX > 0 )
 280                 {
 281                     SetLineColor( rStyleSettings.GetShadowColor() );
 282                     DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
 283                     nStatusX++;
 284                     SetLineColor( rStyleSettings.GetLightColor() );
 285                     DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
 286                 }
 287             }
 288         }
 289     }
 290
 291     Window::Paint( rRect );
 292 }
 293
 294 // -----------------------------------------------------------------------
 295
 296 void TaskBar::Resize()
 297 {
 298     if ( !IsReallyShown() )
 299         return;
 300
 301     TaskButtonBar*      pTempButtonBar = GetButtonBar();
 302     TaskToolBox*        pTempTaskToolBox = GetTaskToolBox();
 303     TaskStatusBar*      pTempStatusBar = GetStatusBar();
 304     Point                       aToolPos( TASKBAR_OFFX, 0 );
 305     Size                        aSize = GetOutputSizePixel();
 306     Size                        aStatusSize;
 307     Size                        aToolSize( aSize.Width()-(TASKBAR_OFFX*2), 0 );
 308     long                        nOldStatusX = -1;
 309     long                        nNewStatusX = -1;
 310     long                        nTaskHeight = aSize.Height() - (TASKBAR_OFFY*2);
 311
 312     if ( mnWinBits & WB_BORDER )
 313     {
 314         nTaskHeight -= TASKBAR_BORDER;
 315         aToolPos.Y() += TASKBAR_BORDER;
 316     }
 317
 318     if ( pTempButtonBar )
 319     {
 320         USHORT  i = 0;
 321         BOOL    bVisibleItems = FALSE;
 322         while ( i < pTempButtonBar->GetItemCount() )
 323         {
 324             if ( pTempButtonBar->IsItemVisible( pTempButtonBar->GetItemId( i ) ) )
 325             {
 326                 bVisibleItems = TRUE;
 327                 break;
 328             }
 329             i++;
 330         }
 331         if ( mbStatusText || !bVisibleItems )
 332             pTempButtonBar->Hide();
 333         else
 334         {
 335             Size aButtonBarSize = pTempButtonBar->CalcWindowSizePixel();
 336             if ( pTempButtonBar->GetItemCount() )
 337                 nTaskHeight = aButtonBarSize.Height();
 338             else
 339                 aButtonBarSize.Height() = nTaskHeight;
 340             Point aTempPos = aToolPos;
 341             aTempPos.Y() += (aSize.Height()-aButtonBarSize.Height()-aTempPos.Y())/2;
 342             pTempButtonBar->SetPosSizePixel( aTempPos, aButtonBarSize );
 343             pTempButtonBar->Show();
 344             aToolPos.X() += aButtonBarSize.Width()+TASKBAR_BUTTONOFF;
 345         }
 346     }
 347
 348     if ( pTempStatusBar )
 349     {
 350         aStatusSize = pTempStatusBar->CalcWindowSizePixel();
 351         if ( mnStatusWidth )
 352             aStatusSize.Width() = mnStatusWidth;
 353         if ( !pTempTaskToolBox || mbStatusText )
 354             aStatusSize.Width() = aSize.Width();
 355         long nMaxHeight = aSize.Height()-(TASKBAR_OFFY*2);
 356         if ( mnWinBits & WB_BORDER )
 357             nMaxHeight -= TASKBAR_BORDER;
 358         if ( nMaxHeight+2 > aStatusSize.Height() )
 359             aStatusSize.Height() = nMaxHeight;
 360         Point aPos( aSize.Width()-aStatusSize.Width(), 0 );
 361         if ( pTempTaskToolBox && (mnWinBits & WB_SIZEABLE) && !mbStatusText )
 362         {
 363             long nMinToolWidth = aToolPos.X()+50;
 364             if ( aPos.X() < nMinToolWidth )
 365             {
 366                 aStatusSize.Width() -= nMinToolWidth-aPos.X();
 367                 aPos.X() = nMinToolWidth;
 368             }
 369         }
 370         if ( aPos.X() < 0 )
 371         {
 372             aStatusSize.Width() = aSize.Width();
 373             aPos.X() = 0;
 374         }
 375         if ( mnWinBits & WB_BORDER )
 376             aPos.Y() += TASKBAR_BORDER;
 377         aPos.Y() += (aSize.Height()-aStatusSize.Height()-aPos.Y())/2;
 378         if ( mnWinBits & WB_SIZEABLE )
 379         {
 380             if ( pTempTaskToolBox )
 381             {
 382                 nOldStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 383                 nNewStatusX = aPos.X()-TASKBAR_OFFSIZE-2;
 384             }
 385         }
 386         pTempStatusBar->SetPosSizePixel( aPos, aStatusSize );
 387         pTempStatusBar->Show();
 388         aToolSize.Width() = aPos.X()-aToolPos.X()-TASKBAR_OFFX;
 389         if ( mnWinBits & WB_SIZEABLE )
 390             aToolSize.Width() -= (TASKBAR_OFFSIZE*2)-2;
 391     }
 392
 393     if ( pTempTaskToolBox )
 394     {
 395         if ( aToolSize.Width() <= 24 )
 396             pTempTaskToolBox->Hide();
 397         else
 398         {
 399             aToolSize.Height() = pTempTaskToolBox->CalcWindowSizePixel().Height();
 400             if ( pTempTaskToolBox->GetItemCount() )
 401                 nTaskHeight = aToolSize.Height();
 402             else
 403                 aToolSize.Height() = nTaskHeight;
 404             aToolPos.Y() += (aSize.Height()-aToolSize.Height()-aToolPos.Y())/2;
 405             pTempTaskToolBox->SetPosSizePixel( aToolPos, aToolSize );
 406             pTempTaskToolBox->Show();
 407         }
 408     }
 409
 410     if ( nOldStatusX != nNewStatusX )
 411     {
 412         if ( nOldStatusX > 0 )
 413         {
 414             Rectangle aRect( nOldStatusX, 0, nOldStatusX+2, aSize.Height()-1 );
 415             Invalidate( aRect );
 416         }
 417         if ( nNewStatusX > 0 )
 418         {
 419             Rectangle aRect( nNewStatusX, 0, nNewStatusX+2, aSize.Height()-1 );
 420             Invalidate( aRect );
 421         }
 422     }
 423 }
 424
 425 // -----------------------------------------------------------------------
 426
 427 void TaskBar::StateChanged( StateChangedType nType )
 428 {
 429     Window::StateChanged( nType );
 430
 431     if ( nType == STATE_CHANGE_INITSHOW )
 432         Format();
 433     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 434     {
 435         ImplInitSettings();
 436         Invalidate();
 437     }
 438     else if ( nType == STATE_CHANGE_FORMAT )
 439     {
 440         ImplInitSettings();
 441         ImplNewHeight( CalcWindowSizePixel().Height() );
 442         Format();
 443         Invalidate();
 444     }
 445 }
 446
 447 // -----------------------------------------------------------------------
 448
 449 void TaskBar::DataChanged( const DataChangedEvent& rDCEvt )
 450 {
 451     Window::DataChanged( rDCEvt );
 452
 453     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 454          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 455          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 456           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 457     {
 458         // Asyncronen StateChanged ausloesen, damit sich die
 459         // TaskBar an die neuen Groessen der Child-Fenster
 460         // orientieren kann
 461         PostStateChanged( STATE_CHANGE_FORMAT );
 462     }
 463 }
 464
 465 // -----------------------------------------------------------------------
 466
 467 void TaskBar::Format()
 468 {
 469     ImplNewHeight( CalcWindowSizePixel().Height() );
 470     Resize();
 471 }
 472
 473 // -----------------------------------------------------------------------
 474
 475 void TaskBar::SetLines( USHORT nLines )
 476 {
 477     mnLines = nLines;
 478 }
 479
 480 // -----------------------------------------------------------------------
 481
 482 void TaskBar::EnableAutoHide( BOOL bAutoHide )
 483 {
 484     mbAutoHide = bAutoHide;
 485
 486     if ( mbAutoHide )
 487     {
 488         ImplNewHeight( TASKBAR_AUTOHIDE_HEIGHT );
 489     }
 490     else
 491     {
 492         ImplNewHeight( CalcWindowSizePixel().Height() );
 493     }
 494 }
 495
 496 // -----------------------------------------------------------------------
 497
 498 void TaskBar::ShowStatusText( const String& rText )
 499 {
 500     if ( mpStatusBar )
 501     {
 502         if ( !mbStatusText )
 503         {
 504             mbStatusText = TRUE;
 505             if ( mpStatusBar->AreItemsVisible() )
 506             {
 507                 mbShowItems = TRUE;
 508                 mpStatusBar->HideItems();
 509             }
 510             else
 511                 mbShowItems = TRUE;
 512             maOldText = mpStatusBar->GetText();
 513             Resize();
 514             mpStatusBar->SetText( rText );
 515             Update();
 516             mpStatusBar->Update();
 517         }
 518         else
 519             mpStatusBar->SetText( rText );
 520     }
 521 }
 522
 523 // -----------------------------------------------------------------------
 524
 525 void TaskBar::HideStatusText()
 526 {
 527     if ( mbStatusText && mpStatusBar )
 528     {
 529         mbStatusText = FALSE;
 530         mpStatusBar->SetText( maOldText );
 531         Resize();
 532         if ( mbShowItems )
 533             mpStatusBar->ShowItems();
 534     }
 535 }
 536
 537 // -----------------------------------------------------------------------
 538
 539 Size TaskBar::CalcWindowSizePixel() const
 540 {
 541     TaskButtonBar*      pTempButtonBar = GetButtonBar();
 542     TaskToolBox*        pTempTaskToolBox = GetTaskToolBox();
 543     TaskStatusBar*      pTempStatusBar = GetStatusBar();
 544     Size                        aSize;
 545     long                        nTempHeight;
 546
 547     if ( pTempButtonBar && pTempButtonBar->GetItemCount() )
 548         aSize.Height() = pTempButtonBar->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
 549     if ( pTempTaskToolBox && pTempTaskToolBox->GetItemCount() )
 550     {
 551         nTempHeight = pTempTaskToolBox->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
 552         if ( nTempHeight > aSize.Height() )
 553              aSize.Height() = nTempHeight;
 554     }
 555     if ( pTempStatusBar )
 556     {
 557         nTempHeight = pTempStatusBar->GetSizePixel().Height();
 558         if ( nTempHeight > aSize.Height() )
 559              aSize.Height() = nTempHeight;
 560     }
 561
 562     if ( mnWinBits & WB_BORDER )
 563         aSize.Height() += TASKBAR_BORDER;
 564
 565     return aSize;
 566 }
 567
 568 // -----------------------------------------------------------------------
 569
 570 TaskButtonBar* TaskBar::GetButtonBar() const
 571 {
 572     if ( !mpButtonBar )
 573         ((TaskBar*)this)->mpButtonBar = ((TaskBar*)this)->CreateButtonBar();
 574     return mpButtonBar;
 575 }
 576
 577 // -----------------------------------------------------------------------
 578
 579 TaskToolBox* TaskBar::GetTaskToolBox() const
 580 {
 581     if ( !mpTaskToolBox )
 582         ((TaskBar*)this)->mpTaskToolBox = ((TaskBar*)this)->CreateTaskToolBox();
 583     return mpTaskToolBox;
 584 }
 585
 586 // -----------------------------------------------------------------------
 587
 588 TaskStatusBar* TaskBar::GetStatusBar() const
 589 {
 590     if ( !mpStatusBar )
 591     {
 592         ((TaskBar*)this)->mpStatusBar = ((TaskBar*)this)->CreateTaskStatusBar();
 593         if ( mpStatusBar )
 594             mpStatusBar->mpNotifyTaskBar = (TaskBar*)this;
 595     }
 596     return mpStatusBar;
 597 }