]>
Commit | Line | Data |
---|---|---|
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/mac/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 |