src/osx/carbon/taskbar.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/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     wxDECLARE_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_MENU,
  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                         {
 190                             if ( itemMenu->HandleCommandProcess( item ) )
 191                                 err = noErr;
 192                         }
 193                         else if ( eventKind == kEventCommandUpdateStatus )
 194                         {
 195                             if ( itemMenu->HandleCommandUpdateStatus( item ) )
 196                                 err = noErr;
 197                         }
 198                     }
 199                 }
 200             }
 201         } //end if noErr on getting HICommand from event
 202     }
 203     else if ((eventClass == kEventClassApplication) && (eventKind == kEventAppGetDockTileMenu ))
 204     {
 205         // process the right click events
 206         // NB: This may result in double or even triple-creation of the menus
 207         // We need to do this for 2.4 compat, however
 208         wxTaskBarIconEvent downevt(wxEVT_TASKBAR_RIGHT_DOWN, NULL);
 209         pTB->m_parent->ProcessEvent(downevt);
 210
 211         wxTaskBarIconEvent upevt(wxEVT_TASKBAR_RIGHT_UP, NULL);
 212         pTB->m_parent->ProcessEvent(upevt);
 213
 214         // create popup menu
 215         wxMenu* menu = pTB->DoCreatePopupMenu();
 216
 217         if (menu != NULL)
 218         {
 219             // note to self - a MenuRef *is* a MenuHandle
 220             MenuRef hMenu = MAC_WXHMENU(menu->GetHMenu());
 221
 222             // When SetEventParameter is called it will decrement
 223             // the reference count of the menu - we need to make
 224             // sure it stays around in the wxMenu class here
 225             CFRetain(hMenu);
 226
 227             // set the actual dock menu
 228             err = SetEventParameter(
 229                 inEvent, kEventParamMenuRef,
 230                 typeMenuRef, sizeof(MenuRef), &hMenu );
 231             verify_noerr( err );
 232         }
 233     }
 234
 235     return err;
 236 }
 237
 238 //-----------------------------------------------------------------------------
 239 // wxDeepCopyMenu
 240 //
 241 // Performs a top-to-bottom copy of the input menu and all of its
 242 // submenus.
 243 //
 244 // This is mostly needed for 2.4 compatibility. However wxPython and others
 245 // still use this way of setting the taskbarmenu.
 246 //-----------------------------------------------------------------------------
 247 wxMenu * wxDeepCopyMenu( wxMenu *menu )
 248 {
 249     if (menu == NULL)
 250         return NULL;
 251
 252     // NB:  Here we have to perform a deep copy of the menu,
 253     // copying each and every menu item from menu to m_pMenu.
 254     // Other implementations use wxWindow::PopupMenu here,
 255     // which idle execution until the user selects something,
 256     // but since the Mac handles this internally, we can't -
 257     // and have no way at all to idle it while the dock menu
 258     // is being shown before menu goes out of scope (it may
 259     // not be on the heap, and may expire right after this function
 260     // is done - we need it to last until the carbon event is triggered -
 261     // that's when the user right clicks).
 262     //
 263     // Also, since there is no equal (assignment) operator
 264     // on either wxMenu or wxMenuItem, we have to do all the
 265     // dirty work ourselves.
 266
 267     // perform a deep copy of the menu
 268     wxMenuItemList& theList = menu->GetMenuItems();
 269     wxMenuItemList::compatibility_iterator theNode = theList.GetFirst();
 270
 271     // create the main menu
 272     wxMenu *m_pMenu = new wxMenu(menu->GetTitle());
 273
 274     while (theNode != NULL)
 275     {
 276         wxMenuItem* theItem = theNode->GetData();
 277         m_pMenu->Append(
 278             new wxMenuItem(
 279                 m_pMenu, // parent menu
 280                 theItem->GetId(), // id
 281                 theItem->GetItemLabel(), // text label
 282                 theItem->GetHelp(), // status bar help string
 283                 theItem->GetKind(), // menu flags - checkable, separator, etc.
 284                 wxDeepCopyMenu(theItem->GetSubMenu()) )); // submenu
 285
 286         theNode = theNode->GetNext();
 287     }
 288
 289     return m_pMenu;
 290 }
 291
 292 //-----------------------------------------------------------------------------
 293 // wxDockTaskBarIcon ctor
 294 //
 295 // Initializes the dock implementation of wxTaskBarIcon.
 296 //
 297 // Here we create some Mac-specific event handlers and UPPs.
 298 //-----------------------------------------------------------------------------
 299 wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)
 300     :   wxTaskBarIconImpl(parent),
 301         m_eventHandlerRef(NULL), m_pMenu(NULL),
 302         m_theLastMenu(GetApplicationDockTileMenu()), m_iconAdded(false)
 303 {
 304     // register the events that will return the dock menu
 305     EventTypeSpec tbEventList[] =
 306     {
 307         { kEventClassCommand, kEventProcessCommand },
 308         { kEventClassCommand, kEventCommandUpdateStatus },
 309         { kEventClassApplication, kEventAppGetDockTileMenu }
 310     };
 311
 312     m_eventupp = NewEventHandlerUPP(wxDockEventHandler);
 313     wxASSERT(m_eventupp != NULL);
 314
 315     OSStatus err = InstallApplicationEventHandler(
 316             m_eventupp,
 317             GetEventTypeCount(tbEventList), tbEventList,
 318             this, &m_eventHandlerRef);
 319     verify_noerr( err );
 320 }
 321
 322 //-----------------------------------------------------------------------------
 323 // wxDockTaskBarIcon Destructor
 324 //
 325 // Cleans up mac events and restores the old icon to the dock
 326 //-----------------------------------------------------------------------------
 327 wxDockTaskBarIcon::~wxDockTaskBarIcon()
 328 {
 329     // clean up event handler and event UPP
 330     RemoveEventHandler(m_eventHandlerRef);
 331     DisposeEventHandlerUPP(m_eventupp);
 332
 333     // restore old icon and menu to the dock
 334     RemoveIcon();
 335 }
 336
 337 //-----------------------------------------------------------------------------
 338 // wxDockTaskBarIcon::DoCreatePopupMenu
 339 //
 340 // Helper function that handles a request from the dock event handler
 341 // to get the menu for the dock
 342 //-----------------------------------------------------------------------------
 343 wxMenu * wxDockTaskBarIcon::DoCreatePopupMenu()
 344 {
 345     // get the menu from the parent
 346     wxMenu* theNewMenu = CreatePopupMenu();
 347
 348     if (theNewMenu)
 349     {
 350         delete m_pMenu;
 351         m_pMenu = theNewMenu;
 352         m_pMenu->SetInvokingWindow(m_menuEventWindow);
 353     }
 354
 355     // the return here can be one of three things
 356     // (in order of priority):
 357     // 1) User passed a menu from CreatePopupMenu override
 358     // 2) menu sent to and copied from PopupMenu
 359     // 3) If neither (1) or (2), then NULL
 360     //
 361     return m_pMenu;
 362 }
 363
 364 //-----------------------------------------------------------------------------
 365 // wxDockTaskBarIcon::IsIconInstalled
 366 //
 367 // Returns whether or not the dock is not using the default image
 368 //-----------------------------------------------------------------------------
 369 bool wxDockTaskBarIcon::IsIconInstalled() const
 370 {
 371     return m_iconAdded;
 372 }
 373
 374 //-----------------------------------------------------------------------------
 375 // wxDockTaskBarIcon::SetIcon
 376 //
 377 // Sets the icon for the dock CGImage functions and SetApplicationDockTileImage
 378 //-----------------------------------------------------------------------------
 379 bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& WXUNUSED(tooltip))
 380 {
 381     // convert the wxIcon into a wxBitmap so we can perform some
 382     // wxBitmap operations with it
 383     wxBitmap bmp( icon );
 384     wxASSERT( bmp.IsOk() );
 385
 386     // get the CGImageRef for the wxBitmap:
 387     // OSX builds only, but then the dock only exists in OSX
 388     CGImageRef pImage = (CGImageRef) bmp.CreateCGImage();
 389     wxASSERT( pImage != NULL );
 390
 391     // actually set the dock image
 392     OSStatus err = SetApplicationDockTileImage( pImage );
 393     verify_noerr( err );
 394
 395     // free the CGImage, now that it's referenced by the dock
 396     if (pImage != NULL)
 397         CGImageRelease( pImage );
 398
 399     bool success = (err == noErr);
 400     m_iconAdded = success;
 401
 402     return success;
 403 }
 404
 405 //-----------------------------------------------------------------------------
 406 // wxDockTaskBarIcon::RemoveIcon
 407 //
 408 // Restores the old image for the dock via RestoreApplicationDockTileImage
 409 //-----------------------------------------------------------------------------
 410 bool wxDockTaskBarIcon::RemoveIcon()
 411 {
 412     wxDELETE(m_pMenu);
 413
 414     // restore old icon to the dock
 415     OSStatus err = RestoreApplicationDockTileImage();
 416     verify_noerr( err );
 417
 418     // restore the old menu to the dock
 419     SetApplicationDockTileMenu( m_theLastMenu );
 420
 421     bool success = (err == noErr);
 422     m_iconAdded = !success;
 423
 424     return success;
 425 }
 426
 427 //-----------------------------------------------------------------------------
 428 // wxDockTaskBarIcon::PopupMenu
 429 //
 430 // 2.4 and wxPython method that "pops of the menu in the taskbar".
 431 //
 432 // In reality because of the way the dock menu works in carbon
 433 // we just save the menu, and if the user didn't override CreatePopupMenu
 434 // return the menu passed here, thus sort of getting the same effect.
 435 //-----------------------------------------------------------------------------
 436 bool wxDockTaskBarIcon::PopupMenu(wxMenu *menu)
 437 {
 438     wxASSERT(menu != NULL);
 439
 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 separate programs that also require a special undocumented id
 467 // hack and other such fun stuff).
 468 //-----------------------------------------------------------------------------
 469 wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType WXUNUSED_UNLESS_DEBUG(nType))
 470 {
 471     wxASSERT_MSG(
 472         nType == wxTBI_DOCK,
 473         wxT("Only the wxTBI_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