]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/taskbar.cpp
new file added
[wxWidgets.git] / 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_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 {
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 compatability. 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 seperate 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