svtools/source/control/taskstat.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: taskstat.cxx,v $
  10  * $Revision: 1.10 $
  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 #include <tools/date.hxx>
  41 #include <vcl/image.hxx>
  42 #include <vcl/help.hxx>
  43 #include <vcl/svapp.hxx>
  44 #include <unotools/calendarwrapper.hxx>
  45
  46 #include <svtools/syslocale.hxx>
  47 #include <taskbar.hxx>
  48
  49 // =======================================================================
  50
  51 #define TASKSTATUSBAR_CLOCXOFFX     3
  52 #define TASKSTATUSBAR_IMAGEOFFX     1
  53
  54 // =======================================================================
  55
  56 struct ImplTaskSBFldItem
  57 {
  58     TaskStatusFieldItem     maItem;
  59     USHORT                  mnId;
  60     long                    mnOffX;
  61 };
  62
  63 DECLARE_LIST( ImplTaskSBItemList, ImplTaskSBFldItem* )
  64
  65 // =======================================================================
  66
  67 BOOL ITaskStatusNotify::MouseButtonDown( USHORT, const MouseEvent& )
  68 {
  69     return FALSE;
  70 }
  71
  72 // -----------------------------------------------------------------------
  73
  74 BOOL ITaskStatusNotify::MouseButtonUp( USHORT, const MouseEvent& )
  75 {
  76     return FALSE;
  77 }
  78
  79 // -----------------------------------------------------------------------
  80
  81 BOOL ITaskStatusNotify::MouseMove( USHORT, const MouseEvent& )
  82 {
  83     return FALSE;
  84 }
  85
  86 // -----------------------------------------------------------------------
  87
  88 BOOL ITaskStatusNotify::Command( USHORT, const CommandEvent& )
  89 {
  90     return FALSE;
  91 }
  92
  93 // -----------------------------------------------------------------------
  94
  95 BOOL ITaskStatusNotify::UpdateHelp( USHORT )
  96 {
  97     return FALSE;
  98 }
  99
 100 // =======================================================================
 101
 102 TaskStatusFieldItem::TaskStatusFieldItem()
 103 {
 104     mpNotify        = NULL;
 105     mnFlags         = 0;
 106 }
 107
 108 // -----------------------------------------------------------------------
 109
 110 TaskStatusFieldItem::TaskStatusFieldItem( const TaskStatusFieldItem& rItem ) :
 111     mpNotify( rItem.mpNotify ),
 112     maImage( rItem.maImage ),
 113     maQuickHelpText( rItem.maQuickHelpText ),
 114     maHelpText( rItem.maHelpText ),
 115     mnFlags( rItem.mnFlags )
 116 {
 117 }
 118
 119 // -----------------------------------------------------------------------
 120
 121 TaskStatusFieldItem::TaskStatusFieldItem( ITaskStatusNotify* pNotify,
 122                                           const Image& rImage,
 123                                           const XubString& rQuickHelpText,
 124                                           const XubString& rHelpText,
 125                                           USHORT nFlags ) :
 126     mpNotify( pNotify ),
 127     maImage( rImage ),
 128     maQuickHelpText( rQuickHelpText ),
 129     maHelpText( rHelpText ),
 130     mnFlags( nFlags )
 131 {
 132 }
 133
 134 // -----------------------------------------------------------------------
 135
 136 TaskStatusFieldItem::~TaskStatusFieldItem()
 137 {
 138 }
 139
 140 // -----------------------------------------------------------------------
 141
 142 const TaskStatusFieldItem& TaskStatusFieldItem::operator=( const TaskStatusFieldItem& rItem )
 143 {
 144     mpNotify        = rItem.mpNotify;
 145     maImage         = rItem.maImage;
 146     maQuickHelpText = rItem.maQuickHelpText;
 147     maHelpText      = rItem.maHelpText;
 148     mnFlags         = rItem.mnFlags;
 149     return *this;
 150 }
 151
 152 // =======================================================================
 153
 154 TaskStatusBar::TaskStatusBar( Window* pParent, WinBits nWinStyle ) :
 155     StatusBar( pParent, nWinStyle | WB_3DLOOK ),
 156     maTime( 0, 0, 0 )
 157 {
 158     mpFieldItemList = NULL;
 159     mpNotifyTaskBar = NULL;
 160     mpNotify        = NULL;
 161     mnClockWidth    = 0;
 162     mnItemWidth     = 0;
 163     mnFieldWidth    = 0;
 164     mnFieldFlags    = 0;
 165     mbFlashItems    = FALSE;
 166     mbOutInterval   = FALSE;
 167
 168     maTimer.SetTimeoutHdl( LINK( this, TaskStatusBar, ImplTimerHdl ) );
 169 }
 170
 171 // -----------------------------------------------------------------------
 172
 173 TaskStatusBar::~TaskStatusBar()
 174 {
 175     if ( mpFieldItemList )
 176     {
 177         ImplTaskSBFldItem* pItem = mpFieldItemList->First();
 178         while ( pItem )
 179         {
 180             delete pItem;
 181             pItem = mpFieldItemList->Next();
 182         }
 183
 184         delete mpFieldItemList;
 185     }
 186 }
 187
 188 // -----------------------------------------------------------------------
 189
 190 IMPL_LINK( TaskStatusBar, ImplTimerHdl, Timer*, EMPTYARG )
 191 {
 192     BOOL bUpdate = ImplUpdateClock();
 193     if ( ImplUpdateFlashItems() )
 194         bUpdate = TRUE;
 195     if ( bUpdate )
 196         SetItemData( TASKSTATUSBAR_STATUSFIELDID, NULL );
 197
 198     return 0;
 199 }
 200
 201 // -----------------------------------------------------------------------
 202
 203 ImplTaskSBFldItem* TaskStatusBar::ImplGetFieldItem( USHORT nItemId ) const
 204 {
 205     if ( !mpFieldItemList )
 206         return NULL;
 207
 208     ImplTaskSBFldItem* pItem = mpFieldItemList->First();
 209     while ( pItem )
 210     {
 211         if ( pItem->mnId == nItemId )
 212             return pItem;
 213
 214         pItem = mpFieldItemList->Next();
 215     }
 216
 217     return NULL;
 218 }
 219
 220 // -----------------------------------------------------------------------
 221
 222 ImplTaskSBFldItem* TaskStatusBar::ImplGetFieldItem( const Point& rPos, BOOL& rFieldRect ) const
 223 {
 224     if ( GetItemId( rPos ) == TASKSTATUSBAR_STATUSFIELDID )
 225     {
 226         rFieldRect = TRUE;
 227
 228         if ( mpFieldItemList )
 229         {
 230             long nX = rPos.X()-GetItemRect( TASKSTATUSBAR_STATUSFIELDID ).Left();
 231             ImplTaskSBFldItem* pItem = mpFieldItemList->First();
 232             while ( pItem )
 233             {
 234                 if ( nX < pItem->mnOffX+pItem->maItem.GetImage().GetSizePixel().Width() )
 235                     return pItem;
 236
 237                 pItem = mpFieldItemList->Next();
 238             }
 239         }
 240     }
 241     else
 242         rFieldRect = FALSE;
 243
 244     return NULL;
 245 }
 246
 247 // -----------------------------------------------------------------------
 248
 249 BOOL TaskStatusBar::ImplUpdateClock()
 250 {
 251     if ( mnFieldFlags & TASKSTATUSFIELD_CLOCK )
 252     {
 253         Time aTime;
 254         maTimer.SetTimeout( ((long)60000)-((aTime.GetSec()*1000)+(aTime.Get100Sec()*10)) );
 255         if ( (aTime.GetMin()  != maTime.GetMin()) ||
 256              (aTime.GetHour() != maTime.GetHour()) )
 257         {
 258             maTime = aTime;
 259             maTimeText = SvtSysLocale().GetLocaleData().getTime( aTime, FALSE, FALSE );
 260             return TRUE;
 261         }
 262     }
 263
 264     return FALSE;
 265 }
 266
 267 // -----------------------------------------------------------------------
 268
 269 BOOL TaskStatusBar::ImplUpdateFlashItems()
 270 {
 271     if ( mbFlashItems )
 272     {
 273         if ( mbOutInterval )
 274         {
 275             maTimer.SetTimeout( 900 );
 276             mbOutInterval = FALSE;
 277         }
 278         else
 279         {
 280             maTimer.SetTimeout( 700 );
 281             mbOutInterval = TRUE;
 282         }
 283
 284         return TRUE;
 285     }
 286
 287     return FALSE;
 288 }
 289
 290 // -----------------------------------------------------------------------
 291
 292 void TaskStatusBar::ImplUpdateField( BOOL bItems )
 293 {
 294     maTimer.Stop();
 295
 296     if ( bItems )
 297     {
 298         ImplTaskSBFldItem* pItem = mpFieldItemList->First();
 299         mnItemWidth = 0;
 300         mbFlashItems = FALSE;
 301         mbOutInterval = FALSE;
 302         while ( pItem )
 303         {
 304             mnItemWidth += TASKSTATUSBAR_IMAGEOFFX;
 305             pItem->mnOffX = mnItemWidth;
 306             mnItemWidth += pItem->maItem.GetImage().GetSizePixel().Width();
 307             if ( pItem->maItem.GetFlags() & TASKSTATUSFIELDITEM_FLASH )
 308                 mbFlashItems = TRUE;
 309
 310             pItem = mpFieldItemList->Next();
 311         }
 312     }
 313     else
 314     {
 315         if ( mnFieldFlags & TASKSTATUSFIELD_CLOCK )
 316         {
 317             XubString aStr = SvtSysLocale().GetLocaleData().getTime( Time( 23, 59, 59 ), FALSE, FALSE );
 318             mnClockWidth = GetTextWidth( aStr )+(TASKSTATUSBAR_CLOCXOFFX*2);
 319         }
 320         else
 321             mnClockWidth = 0;
 322     }
 323
 324     long nNewWidth = mnItemWidth+mnClockWidth;
 325     if ( mnItemWidth && !mnClockWidth )
 326         nNewWidth += TASKSTATUSBAR_IMAGEOFFX;
 327     if ( nNewWidth != mnFieldWidth )
 328     {
 329         RemoveItem( TASKSTATUSBAR_STATUSFIELDID );
 330
 331         if ( mnItemWidth || mnClockWidth )
 332         {
 333             mnFieldWidth = nNewWidth;
 334             long    nOffset = GetItemOffset( TASKSTATUSBAR_STATUSFIELDID );
 335             USHORT  nItemPos = GetItemPos( TASKSTATUSBAR_STATUSFIELDID );
 336             InsertItem( TASKSTATUSBAR_STATUSFIELDID, nNewWidth, SIB_RIGHT | SIB_IN | SIB_USERDRAW, nOffset, nItemPos );
 337         }
 338         else
 339             mnFieldWidth = 0;
 340
 341         if ( mpNotifyTaskBar )
 342             mpNotifyTaskBar->Resize();
 343     }
 344     else
 345         SetItemData( TASKSTATUSBAR_STATUSFIELDID, NULL );
 346
 347     if ( mbFlashItems || (mnFieldFlags & TASKSTATUSFIELD_CLOCK) )
 348     {
 349         ImplUpdateClock();
 350         mbOutInterval = TRUE;
 351         ImplUpdateFlashItems();
 352         maTimer.Start();
 353     }
 354 }
 355
 356 // -----------------------------------------------------------------------
 357
 358 void TaskStatusBar::MouseButtonDown( const MouseEvent& rMEvt )
 359 {
 360     BOOL bFieldRect;
 361     BOOL bBaseClass = FALSE;
 362     ImplTaskSBFldItem* pItem = ImplGetFieldItem( rMEvt.GetPosPixel(), bFieldRect );
 363
 364     ITaskStatusNotify*  pNotify = mpNotify;
 365     USHORT              nItemId = 0;
 366
 367     if ( bFieldRect )
 368         nItemId = TASKSTATUSBAR_CLOCKID;
 369
 370     if ( pItem )
 371     {
 372         pNotify = pItem->maItem.GetNotifyObject();
 373         nItemId = pItem->mnId;
 374     }
 375
 376     if ( pNotify )
 377         bBaseClass = pNotify->MouseButtonDown( nItemId, rMEvt );
 378
 379     if ( bBaseClass )
 380         StatusBar::MouseButtonDown( rMEvt );
 381 }
 382
 383 // -----------------------------------------------------------------------
 384
 385 void TaskStatusBar::MouseButtonUp( const MouseEvent& rMEvt )
 386 {
 387     BOOL bFieldRect;
 388     BOOL bBaseClass = FALSE;
 389     ImplTaskSBFldItem* pItem = ImplGetFieldItem( rMEvt.GetPosPixel(), bFieldRect );
 390
 391     ITaskStatusNotify*  pNotify = mpNotify;
 392     USHORT              nItemId = 0;
 393
 394     if ( bFieldRect )
 395         nItemId = TASKSTATUSBAR_CLOCKID;
 396
 397     if ( pItem )
 398     {
 399         pNotify = pItem->maItem.GetNotifyObject();
 400         nItemId = pItem->mnId;
 401     }
 402
 403     if ( pNotify )
 404         bBaseClass = pNotify->MouseButtonUp( nItemId, rMEvt );
 405
 406     if ( bBaseClass )
 407         StatusBar::MouseButtonUp( rMEvt );
 408 }
 409
 410 // -----------------------------------------------------------------------
 411
 412 void TaskStatusBar::MouseMove( const MouseEvent& rMEvt )
 413 {
 414     BOOL bFieldRect;
 415     BOOL bBaseClass = FALSE;
 416     ImplTaskSBFldItem* pItem = ImplGetFieldItem( rMEvt.GetPosPixel(), bFieldRect );
 417
 418     ITaskStatusNotify*  pNotify = mpNotify;
 419     USHORT              nItemId = 0;
 420
 421     if ( bFieldRect )
 422         nItemId = TASKSTATUSBAR_CLOCKID;
 423
 424     if ( pItem )
 425     {
 426         pNotify = pItem->maItem.GetNotifyObject();
 427         nItemId = pItem->mnId;
 428     }
 429
 430     if ( pNotify )
 431         bBaseClass = pNotify->MouseMove( nItemId, rMEvt );
 432
 433     if ( bBaseClass )
 434         StatusBar::MouseMove( rMEvt );
 435 }
 436
 437 // -----------------------------------------------------------------------
 438
 439 void TaskStatusBar::Command( const CommandEvent& rCEvt )
 440 {
 441     BOOL bFieldRect;
 442     BOOL bBaseClass = FALSE;
 443     ImplTaskSBFldItem* pItem = ImplGetFieldItem( rCEvt.GetMousePosPixel(), bFieldRect );
 444
 445     ITaskStatusNotify*  pNotify = mpNotify;
 446     USHORT              nItemId = 0;
 447
 448     if ( bFieldRect )
 449         nItemId = TASKSTATUSBAR_CLOCKID;
 450
 451     if ( pItem )
 452     {
 453         pNotify = pItem->maItem.GetNotifyObject();
 454         nItemId = pItem->mnId;
 455     }
 456
 457     if ( pNotify )
 458         bBaseClass = pNotify->Command( nItemId, rCEvt );
 459
 460     if ( bBaseClass )
 461         StatusBar::Command( rCEvt );
 462 }
 463
 464 // -----------------------------------------------------------------------
 465
 466 void TaskStatusBar::RequestHelp( const HelpEvent& rHEvt )
 467 {
 468     BOOL bFieldRect;
 469     ImplTaskSBFldItem* pItem = ImplGetFieldItem( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ), bFieldRect );
 470     if ( bFieldRect )
 471     {
 472         ITaskStatusNotify*  pNotify = mpNotify;
 473         USHORT              nItemId = 0;
 474
 475         if ( pItem )
 476         {
 477             pNotify = pItem->maItem.GetNotifyObject();
 478             nItemId = pItem->mnId;
 479         }
 480
 481         if ( pNotify )
 482             pNotify->UpdateHelp( nItemId );
 483
 484         if ( rHEvt.GetMode() & (HELPMODE_BALLOON | HELPMODE_QUICK) )
 485         {
 486             Rectangle aItemRect = GetItemRect( TASKSTATUSBAR_STATUSFIELDID );
 487             Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
 488             aItemRect.Left()   = aPt.X();
 489             aItemRect.Top()    = aPt.Y();
 490             aPt = OutputToScreenPixel( aItemRect.BottomRight() );
 491             aItemRect.Right()  = aPt.X();
 492             aItemRect.Bottom() = aPt.Y();
 493             if ( pItem )
 494             {
 495                 if ( rHEvt.GetMode() & HELPMODE_BALLOON )
 496                 {
 497                     XubString aStr = pItem->maItem.GetHelpText();
 498                     if ( !aStr.Len() )
 499                         aStr = pItem->maItem.GetQuickHelpText();
 500                     Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
 501                 }
 502                 else
 503                     Help::ShowQuickHelp( this, aItemRect, pItem->maItem.GetQuickHelpText() );
 504             }
 505             else
 506             {
 507                 SvtSysLocale aSL;
 508                 const LocaleDataWrapper& rLDW = aSL.GetLocaleData();
 509                 CalendarWrapper aCal( rLDW.getServiceFactory());
 510                 aCal.loadDefaultCalendar( rLDW.getLoadedLocale());
 511                 XubString aStr = rLDW.getLongDate( Date(), aCal );
 512                 if ( rHEvt.GetMode() & HELPMODE_BALLOON )
 513                     Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
 514                 else
 515                     Help::ShowQuickHelp( this, aItemRect, aStr );
 516             }
 517             return;
 518         }
 519         else if ( rHEvt.GetMode() & HELPMODE_EXTENDED )
 520         {
 521             if ( pItem )
 522             {
 523                 ULONG nHelpId = pItem->maItem.GetHelpId();
 524                 if ( nHelpId )
 525                 {
 526                     // Wenn eine Hilfe existiert, dann ausloesen
 527                     Help* pHelp = Application::GetHelp();
 528                     if ( pHelp )
 529                         pHelp->Start( nHelpId, this );
 530                     return;
 531                 }
 532             }
 533         }
 534     }
 535
 536     StatusBar::RequestHelp( rHEvt );
 537 }
 538
 539 // -----------------------------------------------------------------------
 540
 541 void TaskStatusBar::UserDraw( const UserDrawEvent& rUDEvt )
 542 {
 543     if ( rUDEvt.GetItemId() == TASKSTATUSBAR_STATUSFIELDID )
 544     {
 545         OutputDevice*   pDev = rUDEvt.GetDevice();
 546         Rectangle       aRect = rUDEvt.GetRect();
 547
 548         if ( mpFieldItemList )
 549         {
 550             ImplTaskSBFldItem* pItem = mpFieldItemList->First();
 551             while ( pItem )
 552             {
 553                 if ( !mbOutInterval || !(pItem->maItem.GetFlags() & TASKSTATUSFIELDITEM_FLASH) )
 554                 {
 555                     const Image& rImage = pItem->maItem.GetImage();
 556                     Size aImgSize = rImage.GetSizePixel();
 557                     pDev->DrawImage( Point( aRect.Left()+pItem->mnOffX,
 558                                             aRect.Top()+((aRect.GetHeight()-aImgSize.Width())/2) ),
 559                                      rImage );
 560                 }
 561
 562                 pItem = mpFieldItemList->Next();
 563             }
 564         }
 565
 566         if ( mnFieldFlags & TASKSTATUSFIELD_CLOCK )
 567         {
 568             long nX = mnItemWidth+TASKSTATUSBAR_CLOCXOFFX;
 569             Point aPos = GetItemTextPos( TASKSTATUSBAR_STATUSFIELDID );
 570             aPos.X() = aRect.Left()+nX;
 571             pDev->DrawText( aPos, maTimeText );
 572         }
 573     }
 574     else
 575         StatusBar::UserDraw( rUDEvt );
 576 }
 577
 578 // -----------------------------------------------------------------------
 579
 580 void TaskStatusBar::InsertStatusField( long, USHORT,
 581                                        USHORT nFlags )
 582 {
 583     mnFieldFlags = nFlags;
 584     ImplUpdateField( FALSE );
 585 }
 586
 587 // -----------------------------------------------------------------------
 588
 589 void TaskStatusBar::SetFieldFlags( USHORT nFlags )
 590 {
 591     if ( mnFieldFlags != nFlags )
 592     {
 593         mnFieldFlags = nFlags;
 594         ImplUpdateField( FALSE );
 595     }
 596 }
 597
 598 // -----------------------------------------------------------------------
 599
 600 void TaskStatusBar::AddStatusFieldItem( USHORT nItemId, const TaskStatusFieldItem& rItem,
 601                                         USHORT nPos )
 602 {
 603     DBG_ASSERT( nItemId, "TaskStatusBar::AddStatusFieldItem() - Item is 0" );
 604     DBG_ASSERT( !ImplGetFieldItem( nItemId ), "TaskStatusBar::AddStatusFieldItem() - Item-Id already exist" );
 605
 606     if ( !mpFieldItemList )
 607         mpFieldItemList = new ImplTaskSBItemList;
 608
 609     ImplTaskSBFldItem* pItem = new ImplTaskSBFldItem;
 610     pItem->maItem   = rItem;
 611     pItem->mnId     = nItemId;
 612     pItem->mnOffX   = 0;
 613     mpFieldItemList->Insert( pItem, (ULONG)nPos );
 614
 615     ImplUpdateField( TRUE );
 616 }
 617
 618 // -----------------------------------------------------------------------
 619
 620 void TaskStatusBar::ModifyStatusFieldItem( USHORT nItemId, const TaskStatusFieldItem& rItem )
 621 {
 622     ImplTaskSBFldItem* pItem = ImplGetFieldItem( nItemId );
 623     if ( pItem )
 624     {
 625         BOOL bUpdate = (pItem->maItem.GetImage() != rItem.GetImage()) ||
 626                        (pItem->maItem.GetFlags() != rItem.GetFlags());
 627         pItem->maItem = rItem;
 628         if ( bUpdate )
 629             ImplUpdateField( TRUE );
 630     }
 631 }
 632
 633 // -----------------------------------------------------------------------
 634
 635 void TaskStatusBar::RemoveStatusFieldItem( USHORT nItemId )
 636 {
 637     ImplTaskSBFldItem* pItem = ImplGetFieldItem( nItemId );
 638     if ( pItem )
 639     {
 640         mpFieldItemList->Remove( pItem );
 641         delete pItem;
 642         ImplUpdateField( TRUE );
 643     }
 644 }
 645
 646 // -----------------------------------------------------------------------
 647
 648 BOOL TaskStatusBar::GetStatusFieldItem( USHORT nItemId, TaskStatusFieldItem& rItem ) const
 649 {
 650     ImplTaskSBFldItem* pItem = ImplGetFieldItem( nItemId );
 651     if ( pItem )
 652     {
 653         rItem = pItem->maItem;
 654         return TRUE;
 655     }
 656
 657     return FALSE;
 658 }
 659