]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/taskbar.cpp
Use IsOk() instead of Ok()
[wxWidgets.git] / src / mac / carbon / taskbar.cpp
... / ...
CommitLineData
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
27class wxTaskBarIconImpl
28{
29public:
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
56class wxTaskBarIconWindow : public wxTopLevelWindow
57{
58public:
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
72private:
73 wxTaskBarIconImpl *m_impl;
74};
75
76class wxDockTaskBarIcon : public wxTaskBarIconImpl
77{
78public:
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
98pascal OSStatus wxDockEventHandler(
99 EventHandlerCallRef inHandlerCallRef,
100 EventRef inEvent, void* pData );
101wxMenu * wxDeepCopyMenu( wxMenu *menu );
102
103
104//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
105//
106// wxTaskBarIconImpl
107//
108//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
109
110wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent)
111 : m_parent(parent), m_menuEventWindow(new wxTaskBarIconWindow(this))
112{
113}
114
115wxTaskBarIconImpl::~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//-----------------------------------------------------------------------------
135pascal OSStatus
136wxDockEventHandler(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//-----------------------------------------------------------------------------
241wxMenu * 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//-----------------------------------------------------------------------------
293wxDockTaskBarIcon::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//-----------------------------------------------------------------------------
321wxDockTaskBarIcon::~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//-----------------------------------------------------------------------------
337wxMenu * 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//-----------------------------------------------------------------------------
364bool 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//-----------------------------------------------------------------------------
374bool 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//-----------------------------------------------------------------------------
405bool 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//-----------------------------------------------------------------------------
435bool 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
457IMPLEMENT_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//-----------------------------------------------------------------------------
469wxTaskBarIcon::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//-----------------------------------------------------------------------------
483wxTaskBarIcon::~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//-----------------------------------------------------------------------------
495bool wxTaskBarIcon::IsIconInstalled() const
496{ return m_impl->IsIconInstalled(); }
497
498bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
499{ return m_impl->SetIcon(icon, tooltip); }
500
501bool wxTaskBarIcon::RemoveIcon()
502{ return m_impl->RemoveIcon(); }
503
504bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
505{ return m_impl->PopupMenu(menu); }
506
507#endif // wxUSE_TASKBARICON