svtools/inc/taskbar.hxx

   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.hxx,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 #ifndef _TASKBAR_HXX
  32 #define _TASKBAR_HXX
  33
  34 #include "svtools/svtdllapi.h"
  35 #include <tools/time.hxx>
  36 #ifndef _TOOLS_LIST_HXX
  37 #include <tools/list.hxx>
  38 #endif
  39 #include <vcl/timer.hxx>
  40 #include <vcl/toolbox.hxx>
  41 #include <vcl/status.hxx>
  42
  43 class TaskBar;
  44 class TaskStatusFieldItem;
  45 class ImplTaskItemList;
  46 class ImplTaskSBItemList;
  47 class ImplTaskBarFloat;
  48 struct ImplTaskSBFldItem;
  49
  50 // -----------------
  51 // - Dokumentation -
  52 // -----------------
  53
  54 /*
  55
  56 TaskToolBox
  57 ===========
  58
  59 StartUpdateTask()/UpdateTask()/EndUpdateTask()
  60 Diese muessen gerufen werden, wenn die Task upgedatet werden muessen.
  61 Dann muss StartUpdateTask() gerufen werden, dann UpdateTask() fuer alle
  62 Task's und danach EndUpdateTask() wo dann die TaskButtons entsprechend
  63 neu angeordnet werden.
  64
  65 ActivateTask()
  66 Handler der gerufen wird, wenn ein Task aktiviert werden muss. Mit
  67 GetTaskItem() kann abgefragt werden, welcher Task aktiviert werden muss.
  68
  69 ContextMenu()
  70 Dieser Handler wird gerufen, wenn ein ContextMenu angezeigt werden soll.
  71 Mit GetTaskMode() kann abgefragt werden, ob fuer einen Task oder ein
  72 Item.
  73
  74 GetTaskItem()
  75 Diese Methode liefert das Item zurueck, welches bei UpdateTask an der
  76 entsprechenden Position eingefuegt wurde.
  77
  78 GetContextMenuPos()
  79 Liefert die Position zurueck, wo das Contextmenu angezeigt werden soll.
  80
  81
  82 TaskStatusBar
  83 =============
  84
  85 InsertStatusField()/RemoveStatusField()
  86 Fuegt ein Statusfeld ein, wo die aktuelle Uhrzeit angezeigt wird. In
  87 dieses Feld koennen dann mit AddStatusFielItem(), ModifyStatusFielItem()
  88 und RemoveStatusFielItem() Status-Items eingefuegt werden. Bei diesen
  89 muss man ein Image angeben, welches dann angezeigt wird. Ausserdem kann
  90 man bei diesen noch Hilfe-Texte angeben oder sagen, ob sie blinken
  91 sollen und ein Notify-Object, worueber man informiert wird, wenn ein
  92 Kontextmenu angezeigt wird oder das Item angeklickt wird. Am
  93 TaskStatusBar kann auch ein Notify-Object gesetzt werden, wenn man
  94 benachrichtigt werden will, wenn die Uhrzeit oder die TaskStatusBar
  95 angeklickt wird. Wenn der Notify fuer die Uhrzeit kommt, ist die
  96 Id TASKSTATUSBAR_CLOCKID, wenn er fuer die TaskStatusBar kommt, ist
  97 die Id 0. Mit SetFieldFlags() kann am TaskStatusBar auch die Flags
  98 hinterher umgesetzt werden, um zum Beispiel die Uhrzeit ein- und
  99 auszuschalten.
 100
 101
 102 TaskBar
 103 =======
 104
 105 Erlaubte StyleBits
 106 ------------------
 107
 108 WB_BORDER       - Border an der oberen Kante
 109 WB_SIZEABLE     - Zwischen TaskToolBox und TaskStatusBar kann der Anwender
 110                   die Groesse aendern.
 111
 112 Wenn WB_SIZEABLE gesetzt ist, kann die Breite des StatusBars gesetzt und
 113 abgefragt werden. Dazu kann man SetStatusSize()/GetStatusSize() aufrufen.
 114 0 steht dabei fuer optimale Groesse, was auch der Default ist. Bei einem
 115 Doppelklick auf den Trenner kann der Anwender auch wieder die optimale
 116 Groesse einstellen.
 117
 118 Wichtige Methoden
 119 ------------------
 120
 121 virtual TaskToolBox* TaskBar::CreateButtonBar();
 122 virtual TaskToolBox* TaskBar::CreateTaskToolBox();
 123 virtual TaskStatusBar* TaskBar::CreateTaskStatusBar();
 124
 125 Diese Methoden muesste man ueberladen, wenn man eine eigene Klasse anlegen
 126 will.
 127
 128 void TaskBar::ShowStatusText( const String& rText );
 129 void TaskBar::HideStatusText();
 130
 131 Blendet den ButtonBar und die TaskBar ein bzw. aus um den Hilfetexte in der
 132 gesammten Zeile anzuzeigen.
 133 */
 134
 135 // -----------------
 136 // - TaskButtonBar -
 137 // -----------------
 138
 139 class TaskButtonBar : public ToolBox
 140 {
 141     friend class TaskBar;
 142
 143 private:
 144     TaskBar*            mpNotifyTaskBar;
 145     void*               mpDummy1;
 146     void*               mpDummy2;
 147     void*               mpDummy3;
 148     void*               mpDummy4;
 149
 150 public:
 151                         TaskButtonBar( Window* pParent, WinBits nWinStyle = 0 );
 152                         ~TaskButtonBar();
 153
 154     virtual void        RequestHelp( const HelpEvent& rHEvt );
 155
 156     void                InsertButton( USHORT nItemId,
 157                                       const Image& rImage, const String& rText,
 158                                       USHORT nPos = TOOLBOX_APPEND )
 159                             { InsertItem( nItemId, rImage, rText, TIB_LEFT | TIB_AUTOSIZE, nPos ); }
 160     void                RemoveButton( USHORT nItemId )
 161                             { RemoveItem( nItemId ); }
 162 };
 163
 164 // ---------------------
 165 // - TaskToolBox-Types -
 166 // ---------------------
 167
 168 #define TASKTOOLBOX_TASK_NOTFOUND       ((USHORT)0xFFFF)
 169
 170 // ---------------
 171 // - TaskToolBox -
 172 // ---------------
 173
 174 class SVT_DLLPUBLIC TaskToolBox : public ToolBox
 175 {
 176     friend class TaskBar;
 177
 178 private:
 179     ImplTaskItemList*   mpItemList;
 180     TaskBar*            mpNotifyTaskBar;
 181     Point               maContextMenuPos;
 182     ULONG               mnOldItemCount;
 183     long                mnMaxTextWidth;
 184     long                mnDummy1;
 185     USHORT              mnUpdatePos;
 186     USHORT              mnUpdateNewPos;
 187     USHORT              mnActiveItemId;
 188     USHORT              mnNewActivePos;
 189     USHORT              mnTaskItem;
 190     USHORT              mnSmallItem;
 191     USHORT              mnDummy2;
 192     BOOL                mbMinActivate;
 193     BOOL                mbDummy1;
 194     Link                maActivateTaskHdl;
 195     Link                maContextMenuHdl;
 196
 197 #ifdef _TASKBAR_CXX
 198     SVT_DLLPRIVATE void                ImplFormatTaskToolBox();
 199 #endif
 200
 201     // Forbidden and not implemented.
 202     TaskToolBox (const TaskToolBox &);
 203     TaskToolBox & operator= (const TaskToolBox &);
 204
 205 public:
 206                         TaskToolBox( Window* pParent, WinBits nWinStyle = 0 );
 207                         ~TaskToolBox();
 208
 209     void                ActivateTaskItem( USHORT nItemId,
 210                                           BOOL bMinActivate = FALSE );
 211     USHORT              GetTaskItem( const Point& rPos ) const;
 212
 213     virtual void        ActivateTask();
 214     virtual void        ContextMenu();
 215
 216     virtual void        Select();
 217
 218     virtual void        MouseButtonDown( const MouseEvent& rMEvt );
 219     virtual void        Resize();
 220     virtual void        Command( const CommandEvent& rCEvt );
 221     virtual void        RequestHelp( const HelpEvent& rHEvt );
 222
 223     void                StartUpdateTask();
 224     void                UpdateTask( const Image& rImage, const String& rText,
 225                                     BOOL bActive = FALSE );
 226     void                EndUpdateTask();
 227
 228     const Point&        GetContextMenuPos() const { return maContextMenuPos; }
 229     USHORT              GetTaskItem() const { return mnTaskItem; }
 230     BOOL                IsMinActivate() const { return mbMinActivate; }
 231
 232     void                SetActivateTaskHdl( const Link& rLink ) { maActivateTaskHdl = rLink; }
 233     const Link&         GetActivateTaskHdl() const { return maActivateTaskHdl; }
 234     void                SetContextMenuHdl( const Link& rLink ) { maContextMenuHdl = rLink; }
 235     const Link&         GetContextMenuHdl() const { return maContextMenuHdl; }
 236 };
 237
 238 inline USHORT TaskToolBox::GetTaskItem( const Point& rPos ) const
 239 {
 240     USHORT nId = GetItemId( rPos );
 241     if ( nId )
 242         return nId-1;
 243     else
 244         return TASKTOOLBOX_TASK_NOTFOUND;
 245 }
 246
 247 // ---------------------
 248 // - ITaskStatusNotify -
 249 // ---------------------
 250
 251 class ITaskStatusNotify
 252 {
 253 public:
 254     virtual BOOL        MouseButtonDown( USHORT nItemd, const MouseEvent& rMEvt );
 255     virtual BOOL        MouseButtonUp( USHORT nItemd, const MouseEvent& rMEvt );
 256     virtual BOOL        MouseMove( USHORT nItemd, const MouseEvent& rMEvt );
 257     virtual BOOL        Command( USHORT nItemd, const CommandEvent& rCEvt );
 258     virtual BOOL        UpdateHelp( USHORT nItemd );
 259 };
 260
 261 // -----------------------
 262 // - TaskStatusFieldItem -
 263 // -----------------------
 264
 265 #define TASKSTATUSFIELDITEM_FLASH           ((USHORT)0x0001)
 266
 267 class TaskStatusFieldItem
 268 {
 269 private:
 270     ITaskStatusNotify*  mpNotify;
 271     Image               maImage;
 272     XubString           maQuickHelpText;
 273     XubString           maHelpText;
 274     ULONG               mnHelpId;
 275     USHORT              mnFlags;
 276
 277 public:
 278                         TaskStatusFieldItem();
 279                         TaskStatusFieldItem( const TaskStatusFieldItem& rItem );
 280                         TaskStatusFieldItem( ITaskStatusNotify* pNotify,
 281                                              const Image& rImage,
 282                                              const XubString& rQuickHelpText,
 283                                              const XubString& rHelpText,
 284                                              USHORT nFlags );
 285                         ~TaskStatusFieldItem();
 286
 287     void                SetNotifyObject( ITaskStatusNotify* pNotify ) { mpNotify = pNotify; }
 288     ITaskStatusNotify*  GetNotifyObject() const { return mpNotify; }
 289     void                SetImage( const Image& rImage ) { maImage = rImage; }
 290     const Image&        GetImage() const { return maImage; }
 291     void                SetQuickHelpText( const XubString& rStr ) { maQuickHelpText = rStr; }
 292     const XubString&    GetQuickHelpText() const { return maQuickHelpText; }
 293     void                SetHelpText( const XubString& rStr ) { maHelpText = rStr; }
 294     const XubString&    GetHelpText() const { return maHelpText; }
 295     void                SetHelpId( ULONG nHelpId ) { mnHelpId = nHelpId; }
 296     ULONG               GetHelpId() const { return mnHelpId; }
 297     void                SetFlags( USHORT nFlags ) { mnFlags = nFlags; }
 298     USHORT              GetFlags() const { return mnFlags; }
 299
 300     const TaskStatusFieldItem& operator=( const TaskStatusFieldItem& rItem );
 301 };
 302
 303 // -----------------
 304 // - TaskStatusBar -
 305 // -----------------
 306
 307 #define TASKSTATUSBAR_STATUSFIELDID         ((USHORT)61000)
 308
 309 #define TASKSTATUSBAR_CLOCKID               ((USHORT)61000)
 310 #define TASKSTATUSFIELD_CLOCK               ((USHORT)0x0001)
 311
 312 class SVT_DLLPUBLIC TaskStatusBar : public StatusBar
 313 {
 314     friend class TaskBar;
 315
 316 private:
 317     ImplTaskSBItemList* mpFieldItemList;
 318     TaskBar*            mpNotifyTaskBar;
 319     ITaskStatusNotify*  mpNotify;
 320     Time                maTime;
 321     XubString           maTimeText;
 322     AutoTimer           maTimer;
 323     long                mnClockWidth;
 324     long                mnItemWidth;
 325     long                mnFieldWidth;
 326     USHORT              mnFieldFlags;
 327     USHORT              mnDummy1;
 328     BOOL                mbFlashItems;
 329     BOOL                mbOutInterval;
 330     BOOL                mbDummy1;
 331     BOOL                mbDummy2;
 332
 333 #ifdef _TASKBAR_CXX
 334     SVT_DLLPRIVATE ImplTaskSBFldItem*  ImplGetFieldItem( USHORT nItemId ) const;
 335     SVT_DLLPRIVATE ImplTaskSBFldItem*  ImplGetFieldItem( const Point& rPos, BOOL& rFieldRect ) const;
 336     SVT_DLLPRIVATE BOOL                ImplUpdateClock();
 337     SVT_DLLPRIVATE BOOL                ImplUpdateFlashItems();
 338     SVT_DLLPRIVATE void                ImplUpdateField( BOOL bItems );
 339                         DECL_DLLPRIVATE_LINK( ImplTimerHdl, Timer* );
 340 #endif
 341
 342 public:
 343                         TaskStatusBar( Window* pParent, WinBits nWinStyle = WB_LEFT );
 344                         ~TaskStatusBar();
 345
 346     virtual void        MouseButtonDown( const MouseEvent& rMEvt );
 347     virtual void        MouseButtonUp( const MouseEvent& rMEvt );
 348     virtual void        MouseMove( const MouseEvent& rMEvt );
 349     virtual void        Command( const CommandEvent& rCEvt );
 350     virtual void        RequestHelp( const HelpEvent& rHEvt );
 351     virtual void        UserDraw( const UserDrawEvent& rUDEvt );
 352
 353     void                InsertStatusField( long nOffset = STATUSBAR_OFFSET,
 354                                            USHORT nPos = STATUSBAR_APPEND,
 355                                            USHORT nFlags = TASKSTATUSFIELD_CLOCK );
 356     void                RemoveStatusField()
 357                             { maTimer.Stop(); RemoveItem( TASKSTATUSBAR_STATUSFIELDID ); }
 358     void                SetFieldFlags( USHORT nFlags );
 359     USHORT              GetFieldFlags() const { return mnFieldFlags; }
 360     void                SetNotifyObject( ITaskStatusNotify* pNotify ) { mpNotify = pNotify; }
 361     ITaskStatusNotify*  GetNotifyObject() const { return mpNotify; }
 362
 363     void                AddStatusFieldItem( USHORT nItemId, const TaskStatusFieldItem& rItem,
 364                                             USHORT nPos = 0xFFFF );
 365     void                ModifyStatusFieldItem( USHORT nItemId, const TaskStatusFieldItem& rItem );
 366     void                RemoveStatusFieldItem( USHORT nItemId );
 367     BOOL                GetStatusFieldItem( USHORT nItemId, TaskStatusFieldItem& rItem ) const;
 368 };
 369
 370 // -----------
 371 // - TaskBar -
 372 // -----------
 373
 374 class SVT_DLLPUBLIC TaskBar : public Window
 375 {
 376 private:
 377     ImplTaskBarFloat*       mpAutoHideBar;
 378     TaskButtonBar*          mpButtonBar;
 379     TaskToolBox*            mpTaskToolBox;
 380     TaskStatusBar*          mpStatusBar;
 381     void*                   mpDummy1;
 382     void*                   mpDummy2;
 383     void*                   mpDummy3;
 384     void*                   mpDummy4;
 385     String                  maOldText;
 386     long                    mnStatusWidth;
 387     long                    mnMouseOff;
 388     long                    mnOldStatusWidth;
 389     long                    mnDummy1;
 390     long                    mnDummy2;
 391     long                    mnDummy3;
 392     long                    mnDummy4;
 393     WinBits                 mnWinBits;
 394     USHORT                  mnLines;
 395     BOOL                    mbStatusText;
 396     BOOL                    mbShowItems;
 397     BOOL                    mbAutoHide;
 398     BOOL                    mbAlignDummy1;
 399     BOOL                    mbDummy1;
 400     BOOL                    mbDummy2;
 401     BOOL                    mbDummy3;
 402     BOOL                    mbDummy4;
 403     Link                    maTaskResizeHdl;
 404
 405 #ifdef _TASKBAR_CXX
 406     SVT_DLLPRIVATE void                    ImplInitSettings();
 407     SVT_DLLPRIVATE void                    ImplNewHeight( long nNewHeight );
 408 #endif
 409
 410 public:
 411                             TaskBar( Window* pParent, WinBits nWinStyle = WB_BORDER | WB_SIZEABLE );
 412                             ~TaskBar();
 413
 414     virtual void            TaskResize();
 415
 416     virtual TaskButtonBar*  CreateButtonBar();
 417     virtual TaskToolBox*    CreateTaskToolBox();
 418     virtual TaskStatusBar*  CreateTaskStatusBar();
 419
 420     virtual void            MouseMove( const MouseEvent& rMEvt );
 421     virtual void            MouseButtonDown( const MouseEvent& rMEvt );
 422     virtual void            Tracking( const TrackingEvent& rMEvt );
 423     virtual void            Paint( const Rectangle& rRect );
 424     virtual void            Resize();
 425     virtual void            StateChanged( StateChangedType nType );
 426     virtual void            DataChanged( const DataChangedEvent& rDCEvt );
 427
 428     void                    Format();
 429
 430     void                    SetLines( USHORT nLines );
 431     USHORT                  GetLines() const { return mnLines; }
 432     void                    EnableAutoHide( BOOL bAutoHide = TRUE );
 433     BOOL                    IsAutoHideEnabled() const { return mbAutoHide; }
 434
 435     void                    ShowStatusText( const String& rText );
 436     void                    HideStatusText();
 437
 438     void                    SetStatusSize( long nNewSize )
 439                                 { mnStatusWidth=nNewSize; Resize(); }
 440     long                    GetStatusSize() const { return mnStatusWidth; }
 441
 442     Size                    CalcWindowSizePixel() const;
 443
 444     TaskButtonBar*          GetButtonBar() const;
 445     TaskToolBox*            GetTaskToolBox() const;
 446     TaskStatusBar*          GetStatusBar() const;
 447
 448     void                    SetTaskResizeHdl( const Link& rLink ) { maTaskResizeHdl = rLink; }
 449     const Link&             GetTaskResizeHdl() const { return maTaskResizeHdl; }
 450 };
 451
 452 // -----------------------
 453 // - WindowArrange-Types -
 454 // -----------------------
 455
 456 #define WINDOWARRANGE_TILE      1
 457 #define WINDOWARRANGE_HORZ      2
 458 #define WINDOWARRANGE_VERT      3
 459 #define WINDOWARRANGE_CASCADE   4
 460
 461 class ImplWindowArrangeList;
 462
 463 // -----------------------
 464 // - class WindowArrange -
 465 // -----------------------
 466
 467 class SVT_DLLPUBLIC WindowArrange
 468 {
 469 private:
 470     List*                   mpWinList;
 471     void*                   mpDummy;
 472     ULONG                   mnDummy;
 473
 474 #ifdef _TASKBAR_CXX
 475     SVT_DLLPRIVATE void                    ImplTile( const Rectangle& rRect );
 476     SVT_DLLPRIVATE void                    ImplHorz( const Rectangle& rRect );
 477     SVT_DLLPRIVATE void                    ImplVert( const Rectangle& rRect );
 478     SVT_DLLPRIVATE void                    ImplCascade( const Rectangle& rRect );
 479 #endif
 480
 481 public:
 482                             WindowArrange();
 483                             ~WindowArrange();
 484
 485     void                    AddWindow( Window* pWindow, ULONG nPos = LIST_APPEND )
 486                                 { mpWinList->Insert( (void*)pWindow, nPos ); }
 487     void                    RemoveAllWindows()
 488                                 { mpWinList->Clear(); }
 489
 490     void                    Arrange( USHORT nType, const Rectangle& rRect );
 491 };
 492
 493 #endif  // _TASKBAR_HXX