src/osx/carbon/taskbar.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/taskbar.cpp
   3 // Purpose:     wxTaskBarIcon
   4 // Author:      Ryan Norton
   5 // Modified by:
   6 // Created:     09/25/2004
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2004 Ryan Norton
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #if wxUSE_TASKBARICON
  15
  16 #include "wx/taskbar.h"
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/dcmemory.h"
  20     #include "wx/menu.h"
  21     #include "wx/toplevel.h"
  22     #include "wx/icon.h"
  23 #endif
  24
  25 #include "wx/osx/private.h"
  26
  27 class wxTaskBarIconImpl
  28 {
  29 public:
  30     wxTaskBarIconImpl(wxTaskBarIcon* parent);
  31     virtual ~wxTaskBarIconImpl();
  32
  33     virtual bool IsIconInstalled() const = 0;
  34     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip) = 0;
  35     virtual bool RemoveIcon() = 0;
  36     virtual bool PopupMenu(wxMenu *menu) = 0;
  37
  38     wxMenu * CreatePopupMenu()
  39     { return m_parent->CreatePopupMenu(); }
  40
  41     wxTaskBarIcon *m_parent;
  42     class wxTaskBarIconWindow *m_menuEventWindow;
  43
  44     DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)
  45 };
  46
  47 //-----------------------------------------------------------------------------
  48 //
  49 //  wxTaskBarIconWindow
  50 //
  51 //  Event handler for menus
  52 //  NB: Since wxWindows in Mac HAVE to have parents we need this to be
  53 //  a top level window...
  54 //-----------------------------------------------------------------------------
  55
  56 class wxTaskBarIconWindow : public wxTopLevelWindow
  57 {
  58 public:
  59     wxTaskBarIconWindow(wxTaskBarIconImpl *impl)
  60         : wxTopLevelWindow(NULL, wxID_ANY, wxEmptyString), m_impl(impl)
  61     {
  62         Connect(
  63             -1, wxEVT_COMMAND_MENU_SELECTED,
  64             wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent) );
  65     }
  66
  67     void OnMenuEvent(wxCommandEvent& event)
  68     {
  69         m_impl->m_parent->ProcessEvent(event);
  70     }
  71
  72 private:
  73     wxTaskBarIconImpl *m_impl;
  74 };
  75
  76 class wxDockTaskBarIcon : public wxTaskBarIconImpl
  77 {
  78 public:
  79     wxDockTaskBarIcon(wxTaskBarIcon* parent);
  80     virtual ~wxDockTaskBarIcon();
  81
  82     virtual bool IsIconInstalled() const;
  83     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip);
  84     virtual bool RemoveIcon();
  85     virtual bool PopupMenu(wxMenu *menu);
  86
  87     wxMenu* DoCreatePopupMenu();
  88
  89     EventHandlerRef     m_eventHandlerRef;
  90     EventHandlerUPP     m_eventupp;
  91     wxWindow           *m_eventWindow;
  92     wxMenu             *m_pMenu;
  93     MenuRef             m_theLastMenu;
  94     bool                m_iconAdded;
  95 };
  96
  97 // Forward declarations for utility functions for dock implementation
  98 pascal OSStatus wxDockEventHandler(
  99     EventHandlerCallRef inHandlerCallRef,
 100     EventRef inEvent, void* pData );
 101 wxMenu * wxDeepCopyMenu( wxMenu *menu );
 102
 103
 104 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 105 //
 106 //  wxTaskBarIconImpl
 107 //
 108 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 109
 110 wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent)
 111     : m_parent(parent), m_menuEventWindow(new wxTaskBarIconWindow(this))
 112 {
 113 }
 114
 115 wxTaskBarIconImpl::~wxTaskBarIconImpl()
 116 {
 117     delete m_menuEventWindow;
 118 }
 119
 120 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 121 //
 122 //  wxDockTaskBarIcon
 123 //
 124 //  OS X Dock implementation of wxTaskBarIcon using Carbon
 125 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 126
 127 //-----------------------------------------------------------------------------
 128 // wxDockEventHandler
 129 //
 130 // This is the global Mac/Carbon event handler for the dock.
 131 // We need this for two reasons:
 132 // 1) To handle wxTaskBarIcon menu events (see below for why)
 133 // 2) To handle events from the dock when it requests a menu
 134 //-----------------------------------------------------------------------------
 135 pascal OSStatus
 136 wxDockEventHandler(EventHandlerCallRef WXUNUSED(inHandlerCallRef),
 137                    EventRef inEvent,
 138                    void *pData)
 139 {
 140     // Get the parameters we want from the event
 141     wxDockTaskBarIcon* pTB = (wxDockTaskBarIcon*) pData;
 142     const UInt32 eventClass = GetEventClass(inEvent);
 143     const UInt32 eventKind = GetEventKind(inEvent);
 144
 145     OSStatus err = eventNotHandledErr;
 146
 147     // Handle wxTaskBar menu events (note that this is a global event handler
 148     // so it will actually get called by all commands/menus)
 149     if ((eventClass == kEventClassCommand) && (eventKind == kEventCommandProcess || eventKind == kEventCommandUpdateStatus ))
 150     {
 151         // if we have no taskbar menu quickly pass it back to wxApp
 152         if (pTB->m_pMenu != NULL)
 153         {
 154             // This is the real reason why we need this. Normally menus
 155             // get handled in wxMacAppEventHandler
 156             // However, in the case of a taskbar menu call
 157             // command.menu.menuRef IS NULL!
 158             // Which causes the wxApp handler just to skip it.
 159
 160             // get the HICommand from the event
 161             HICommand command;
 162             if (GetEventParameter(inEvent, kEventParamDirectObject,
 163                 typeHICommand, NULL,sizeof(HICommand), NULL, &command ) == noErr)
 164             {
 165                 // Obtain the REAL menuRef and the menuItemIndex in the real menuRef
 166                 //
 167                 // NOTE: menuRef is generally used here for submenus, as
 168                 // GetMenuItemRefCon could give an incorrect wxMenuItem if we pass
 169                 // just the top level wxTaskBar menu
 170                 MenuItemIndex menuItemIndex;
 171                 MenuRef menuRef;
 172                 MenuRef taskbarMenuRef = MAC_WXHMENU(pTB->m_pMenu->GetHMenu());
 173
 174                 // the next command is only successful if it was a command from the taskbar menu
 175                 // otherwise we pass it on
 176                 if (GetIndMenuItemWithCommandID(taskbarMenuRef,command.commandID,
 177                     1, &menuRef, &menuItemIndex ) == noErr)
 178                 {
 179                     wxMenu* itemMenu = wxFindMenuFromMacMenu( menuRef ) ;
 180                     int id = wxMacCommandToId( command.commandID ) ;
 181                     wxMenuItem *item = NULL;
 182
 183                     if (id != 0) // get the wxMenuItem reference from the MenuRef
 184                         GetMenuItemRefCon( menuRef, menuItemIndex, (URefCon*) &item );
 185
 186                     if (item && itemMenu )
 187                     {
 188                         if ( eventKind == kEventCommandProcess )
 189                             err = itemMenu->MacHandleCommandProcess( item, id );
 190                         else if ( eventKind == kEventCommandUpdateStatus )
 191                             err = itemMenu->MacHandleCommandUpdateStatus( item, id );
 192                     }
 193                 }
 194             }
 195         } //end if noErr on getting HICommand from event
 196     }
 197     else if ((eventClass == kEventClassApplication) && (eventKind == kEventAppGetDockTileMenu ))
 198     {
 199         // process the right click events
 200         // NB: This may result in double or even triple-creation of the menus
 201         // We need to do this for 2.4 compat, however
 202         wxTaskBarIconEvent downevt(wxEVT_TASKBAR_RIGHT_DOWN, NULL);
 203         pTB->m_parent->ProcessEvent(downevt);
 204
 205         wxTaskBarIconEvent upevt(wxEVT_TASKBAR_RIGHT_UP, NULL);
 206         pTB->m_parent->ProcessEvent(upevt);
 207
 208         // create popup menu
 209         wxMenu* menu = pTB->DoCreatePopupMenu();
 210
 211         if (menu != NULL)
 212         {
 213             // note to self - a MenuRef *is* a MenuHandle
 214             MenuRef hMenu = MAC_WXHMENU(menu->GetHMenu());
 215
 216             // When SetEventParameter is called it will decrement
 217             // the reference count of the menu - we need to make
 218             // sure it stays around in the wxMenu class here
 219             CFRetain(hMenu);
 220
 221             // set the actual dock menu
 222             err = SetEventParameter(
 223                 inEvent, kEventParamMenuRef,
 224                 typeMenuRef, sizeof(MenuRef), &hMenu );
 225             verify_noerr( err );
 226         }
 227     }
 228
 229     return err;
 230 }
 231
 232 //-----------------------------------------------------------------------------
 233 // wxDeepCopyMenu
 234 //
 235 // Performs a top-to-bottom copy of the input menu and all of its
 236 // submenus.
 237 //
 238 // This is mostly needed for 2.4 compatability. However wxPython and others
 239 // still use this way of setting the taskbarmenu.
 240 //-----------------------------------------------------------------------------
 241 wxMenu * wxDeepCopyMenu( wxMenu *menu )
 242 {
 243     if (menu == NULL)
 244         return NULL;
 245
 246     // NB:  Here we have to perform a deep copy of the menu,
 247     // copying each and every menu item from menu to m_pMenu.
 248     // Other implementations use wxWindow::PopupMenu here,
 249     // which idle execution until the user selects something,
 250     // but since the Mac handles this internally, we can't -
 251     // and have no way at all to idle it while the dock menu
 252     // is being shown before menu goes out of scope (it may
 253     // not be on the heap, and may expire right after this function
 254     // is done - we need it to last until the carbon event is triggered -
 255     // that's when the user right clicks).
 256     //
 257     // Also, since there is no equal (assignment) operator
 258     // on either wxMenu or wxMenuItem, we have to do all the
 259     // dirty work ourselves.
 260
 261     // perform a deep copy of the menu
 262     wxMenuItemList& theList = menu->GetMenuItems();
 263     wxMenuItemList::compatibility_iterator theNode = theList.GetFirst();
 264
 265     // create the main menu
 266     wxMenu *m_pMenu = new wxMenu(menu->GetTitle());
 267
 268     while (theNode != NULL)
 269     {
 270         wxMenuItem* theItem = theNode->GetData();
 271         m_pMenu->Append(
 272             new wxMenuItem(
 273                 m_pMenu, // parent menu
 274                 theItem->GetId(), // id
 275                 theItem->GetItemLabel(), // text label
 276                 theItem->GetHelp(), // status bar help string
 277                 theItem->GetKind(), // menu flags - checkable, separator, etc.
 278                 wxDeepCopyMenu(theItem->GetSubMenu()) )); // submenu
 279
 280         theNode = theNode->GetNext();
 281     }
 282
 283     return m_pMenu;
 284 }
 285
 286 //-----------------------------------------------------------------------------
 287 // wxDockTaskBarIcon ctor
 288 //
 289 // Initializes the dock implementation of wxTaskBarIcon.
 290 //
 291 // Here we create some Mac-specific event handlers and UPPs.
 292 //-----------------------------------------------------------------------------
 293 wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)
 294     :   wxTaskBarIconImpl(parent),
 295         m_eventHandlerRef(NULL), m_pMenu(NULL),
 296         m_theLastMenu(GetApplicationDockTileMenu()), m_iconAdded(false)
 297 {
 298     // register the events that will return the dock menu
 299     EventTypeSpec tbEventList[] =
 300     {
 301         { kEventClassCommand, kEventProcessCommand },
 302         { kEventClassCommand, kEventCommandUpdateStatus },
 303         { kEventClassApplication, kEventAppGetDockTileMenu }
 304     };
 305
 306     m_eventupp = NewEventHandlerUPP(wxDockEventHandler);
 307     wxASSERT(m_eventupp != NULL);
 308
 309     OSStatus err = InstallApplicationEventHandler(
 310             m_eventupp,
 311             GetEventTypeCount(tbEventList), tbEventList,
 312             this, &m_eventHandlerRef);
 313     verify_noerr( err );
 314 }
 315
 316 //-----------------------------------------------------------------------------
 317 // wxDockTaskBarIcon Destructor
 318 //
 319 // Cleans up mac events and restores the old icon to the dock
 320 //-----------------------------------------------------------------------------
 321 wxDockTaskBarIcon::~wxDockTaskBarIcon()
 322 {
 323     // clean up event handler and event UPP
 324     RemoveEventHandler(m_eventHandlerRef);
 325     DisposeEventHandlerUPP(m_eventupp);
 326
 327     // restore old icon and menu to the dock
 328     RemoveIcon();
 329 }
 330
 331 //-----------------------------------------------------------------------------
 332 // wxDockTaskBarIcon::DoCreatePopupMenu
 333 //
 334 // Helper function that handles a request from the dock event handler
 335 // to get the menu for the dock
 336 //-----------------------------------------------------------------------------
 337 wxMenu * wxDockTaskBarIcon::DoCreatePopupMenu()
 338 {
 339     // get the menu from the parent
 340     wxMenu* theNewMenu = CreatePopupMenu();
 341
 342     if (theNewMenu)
 343     {
 344         if (m_pMenu)
 345             delete m_pMenu;
 346         m_pMenu = theNewMenu;
 347         m_pMenu->SetInvokingWindow(m_menuEventWindow);
 348     }
 349
 350     // the return here can be one of three things
 351     // (in order of priority):
 352     // 1) User passed a menu from CreatePopupMenu override
 353     // 2) menu sent to and copied from PopupMenu
 354     // 3) If neither (1) or (2), then NULL
 355     //
 356     return m_pMenu;
 357 }
 358
 359 //-----------------------------------------------------------------------------
 360 // wxDockTaskBarIcon::IsIconInstalled
 361 //
 362 // Returns whether or not the dock is not using the default image
 363 //-----------------------------------------------------------------------------
 364 bool wxDockTaskBarIcon::IsIconInstalled() const
 365 {
 366     return m_iconAdded;
 367 }
 368
 369 //-----------------------------------------------------------------------------
 370 // wxDockTaskBarIcon::SetIcon
 371 //
 372 // Sets the icon for the dock CGImage functions and SetApplicationDockTileImage
 373 //-----------------------------------------------------------------------------
 374 bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& WXUNUSED(tooltip))
 375 {
 376     // convert the wxIcon into a wxBitmap so we can perform some
 377     // wxBitmap operations with it
 378     wxBitmap bmp( icon );
 379     wxASSERT( bmp.Ok() );
 380
 381     // get the CGImageRef for the wxBitmap:
 382     // OSX builds only, but then the dock only exists in OSX
 383     CGImageRef pImage = (CGImageRef) bmp.CreateCGImage();
 384     wxASSERT( pImage != NULL );
 385
 386     // actually set the dock image
 387     OSStatus err = SetApplicationDockTileImage( pImage );
 388     verify_noerr( err );
 389
 390     // free the CGImage, now that it's referenced by the dock
 391     if (pImage != NULL)
 392         CGImageRelease( pImage );
 393
 394     bool success = (err == noErr);
 395     m_iconAdded = success;
 396
 397     return success;
 398 }
 399
 400 //-----------------------------------------------------------------------------
 401 // wxDockTaskBarIcon::RemoveIcon
 402 //
 403 // Restores the old image for the dock via RestoreApplicationDockTileImage
 404 //-----------------------------------------------------------------------------
 405 bool wxDockTaskBarIcon::RemoveIcon()
 406 {
 407     if (m_pMenu)
 408     {
 409         delete m_pMenu;
 410         m_pMenu = NULL;
 411     }
 412
 413     // restore old icon to the dock
 414     OSStatus err = RestoreApplicationDockTileImage();
 415     verify_noerr( err );
 416
 417     // restore the old menu to the dock
 418     SetApplicationDockTileMenu( m_theLastMenu );
 419
 420     bool success = (err == noErr);
 421     m_iconAdded = !success;
 422
 423     return success;
 424 }
 425
 426 //-----------------------------------------------------------------------------
 427 // wxDockTaskBarIcon::PopupMenu
 428 //
 429 // 2.4 and wxPython method that "pops of the menu in the taskbar".
 430 //
 431 // In reality because of the way the dock menu works in carbon
 432 // we just save the menu, and if the user didn't override CreatePopupMenu
 433 // return the menu passed here, thus sort of getting the same effect.
 434 //-----------------------------------------------------------------------------
 435 bool wxDockTaskBarIcon::PopupMenu(wxMenu *menu)
 436 {
 437     wxASSERT(menu != NULL);
 438
 439     if (m_pMenu)
 440         delete m_pMenu;
 441
 442     // start copy of menu
 443     m_pMenu = wxDeepCopyMenu(menu);
 444
 445     // finish up
 446     m_pMenu->SetInvokingWindow(m_menuEventWindow);
 447
 448     return true;
 449 }
 450
 451 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 452 //
 453 //  wxTaskBarIcon
 454 //
 455 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 456
 457 IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)
 458
 459 //-----------------------------------------------------------------------------
 460 // wxTaskBarIcon Constructor
 461 //
 462 // Creates the backend
 463 //
 464 // Note that we only support DOCK currently as others require cocoa and
 465 // also some require hacks and other such things. (MenuExtras are
 466 // actually seperate programs that also require a special undocumented id
 467 // hack and other such fun stuff).
 468 //-----------------------------------------------------------------------------
 469 wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType nType)
 470 {
 471     wxASSERT_MSG(
 472         nType == DOCK,
 473         wxT("Only the DOCK implementation of wxTaskBarIcon on Mac-Carbon is currently supported!") );
 474
 475     m_impl = new wxDockTaskBarIcon(this);
 476 }
 477
 478 //-----------------------------------------------------------------------------
 479 // wxTaskBarIcon Destructor
 480 //
 481 // Destroys the backend
 482 //-----------------------------------------------------------------------------
 483 wxTaskBarIcon::~wxTaskBarIcon()
 484 {
 485     delete m_impl;
 486 }
 487
 488 //-----------------------------------------------------------------------------
 489 // wxTaskBarIcon::SetIcon
 490 // wxTaskBarIcon::RemoveIcon
 491 // wxTaskBarIcon::PopupMenu
 492 //
 493 // Just calls the backend version of the said function.
 494 //-----------------------------------------------------------------------------
 495 bool wxTaskBarIcon::IsIconInstalled() const
 496 { return m_impl->IsIconInstalled(); }
 497
 498 bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
 499 { return m_impl->SetIcon(icon, tooltip); }
 500
 501 bool wxTaskBarIcon::RemoveIcon()
 502 { return m_impl->RemoveIcon(); }
 503
 504 bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
 505 { return m_impl->PopupMenu(menu); }
 506
 507 #endif // wxUSE_TASKBARICON