]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/taskbar.cpp
OSXTimer for all variants
[wxWidgets.git] / 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