src/mac/carbon/taskbar.cpp

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