///////////////////////////////////////////////////////////////////////////////
// Name: taskbar.cpp
-// Purpose: wxTaskBarIcon OSX Implementation
+// Purpose: wxTaskBarIcon - OSX implementation
// Author: Ryan Norton
// Modified by:
// Created: 09/25/2004
// Superclass of wxTaskBarIcon implementations
//-----------------------------------------------------------------------------
-class wxTaskBarIconImpl
+class wxTaskBarIconImpl
{
public:
wxTaskBarIconImpl(wxTaskBarIcon* parent);
virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip) = 0;
virtual bool RemoveIcon() = 0;
virtual bool PopupMenu(wxMenu *menu) = 0;
-
+
wxMenu* CreatePopupMenu()
{ return m_parent->CreatePopupMenu(); }
-
+
wxTaskBarIcon* m_parent;
class wxTaskBarIconWindow* m_menuEventWindow;
+
+ DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)
};
//-----------------------------------------------------------------------------
class wxTaskBarIconWindow : public wxTopLevelWindow
{
public:
- wxTaskBarIconWindow(wxTaskBarIconImpl* impl)
- : wxTopLevelWindow(NULL, -1, wxT("")), m_impl(impl)
+ wxTaskBarIconWindow(wxTaskBarIconImpl* impl)
+ : wxTopLevelWindow(NULL, -1, wxT("")), m_impl(impl)
{
- Connect(-1, wxEVT_COMMAND_MENU_SELECTED,
+ Connect(-1, wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent)
);
}
- void OnMenuEvent(wxCommandEvent& event)
+ void OnMenuEvent(wxCommandEvent& event)
{
m_impl->m_parent->ProcessEvent(event);
}
public:
wxDockTaskBarIcon(wxTaskBarIcon* parent);
virtual ~wxDockTaskBarIcon();
-
+
virtual bool IsIconInstalled() const;
virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip);
virtual bool RemoveIcon();
EventHandlerRef m_eventHandlerRef;
EventHandlerUPP m_eventupp;
+ wxWindow* m_eventWindow;
wxMenu* m_pMenu;
MenuRef m_theLastMenu;
bool m_iconAdded;
- wxWindow* m_eventWindow;
};
// Forward declarations for utility functions for dock implementation
pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
EventRef inEvent, void* pData);
wxMenu* wxDeepCopyMenu(wxMenu* menu);
-
+
//=============================================================================
//
//
// Initializes members and creates the event window
//-----------------------------------------------------------------------------
-wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent)
+wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent)
: m_parent(parent), m_menuEventWindow(new wxTaskBarIconWindow(this))
{
}
wxDockTaskBarIcon* pTB = (wxDockTaskBarIcon*) pData;
const UInt32 eventClass = GetEventClass(inEvent);
const UInt32 eventKind = GetEventKind(inEvent);
-
- //
+
// Handle wxTaskBar menu events (note that this is a global event handler
// so it will actually get called by all commands/menus)
- //
- if (eventClass == kEventClassCommand && eventKind == kEventCommandProcess)
+ //
+ if ((eventClass == kEventClassCommand) && (eventKind == kEventCommandProcess))
{
// if we have no taskbar menu quickly pass it back to wxApp
- if (! pTB->m_pMenu )
- {
+ if (pTB->m_pMenu == NULL)
return eventNotHandledErr;
- }
-
+
//
// This is the real reason why we need this. Normally menus
// get handled in wxMacAppEventHandler
//
- // pascal OSStatus wxMacAppEventHandler(EventHandlerCallRef handler,
+ // pascal OSStatus wxMacAppEventHandler(EventHandlerCallRef handler,
// EventRef event, void *data)
//
- // However, in the case of a taskbar menu call
+ // However, in the case of a taskbar menu call
// command.menu.menuRef IS NULL!
// Which causes the wxApp handler just to skip it.
//
MenuRef taskbarMenuRef = MAC_WXHMENU(pTB->m_pMenu->GetHMenu());
- OSStatus result = eventNotHandledErr;
OSErr err;
-
+
// get the HICommand from the event
HICommand command;
err = GetEventParameter(inEvent, kEventParamDirectObject,
- typeHICommand, NULL,
+ typeHICommand, NULL,
sizeof(HICommand), NULL, &command);
if (err == noErr)
- {
- //
+ {
// Obtain the REAL menuRef and the menuItemIndex in the real menuRef
//
- // NOTE: menuRef is generally used here for submenus, as
- // GetMenuItemRefCon could give an incorrect wxMenuItem if we pass
+ // NOTE: menuRef is generally used here for submenus, as
+ // GetMenuItemRefCon could give an incorrect wxMenuItem if we pass
// just the top level wxTaskBar menu
//
MenuItemIndex menuItemIndex;
MenuRef menuRef;
- err = GetIndMenuItemWithCommandID(taskbarMenuRef,
- command.commandID,
+ err = GetIndMenuItemWithCommandID(taskbarMenuRef,
+ command.commandID,
1, &menuRef, &menuItemIndex);
if (err == noErr)
{
MenuCommand id = command.commandID;
wxMenuItem* item = NULL;
-
+
if (id != 0) // get the wxMenuItem reference from the MenuRef
GetMenuItemRefCon(menuRef, menuItemIndex, (UInt32*) &item);
-
+
if (item)
{
// Handle items that are checkable
item->Check( !item->IsChecked() ) ;
// send the wxEvent to the wxMenu
- item->GetMenu()->SendEvent(id,
- item->IsCheckable() ?
- item->IsChecked() : -1
+ item->GetMenu()->SendEvent(id,
+ item->IsCheckable() ?
+ item->IsChecked() : -1
);
err = noErr; // successfully handled the event
}
}
- } //end if noErr on getting HICommand from event
+ } //end if noErr on getting HICommand from event
- return err; // return whether we handled the event or not
+ // return whether we handled the event or not
+ return err;
}
// We better have a kEventClassApplication/kEventAppGetDockTileMenu combo here,
- // otherwise something is truly funky
- wxASSERT(eventClass == kEventClassApplication &&
+ // otherwise something is truly funky
+ wxASSERT(eventClass == kEventClassApplication &&
eventKind == kEventAppGetDockTileMenu);
// process the right click events
wxTaskBarIconEvent upevt(wxEVT_TASKBAR_RIGHT_UP,NULL);
pTB->m_parent->ProcessEvent(upevt);
- //create popup menu
+ // create popup menu
wxMenu* menu = pTB->DoCreatePopupMenu();
-
- OSStatus err = noErr;
- if (menu)
+ OSStatus err = eventNotHandledErr;
+
+ if (menu != NULL)
{
- //note to self - a MenuRef IS A MenuHandle
+ // note to self - a MenuRef *is* a MenuHandle
MenuRef hMenu = MAC_WXHMENU(menu->GetHMenu());
- // When we call SetEventParameter it will decrement
+ // When SetEventParameter is called it will decrement
// the reference count of the menu - we need to make
// sure it stays around in the wxMenu class here
RetainMenu(hMenu);
// set the actual dock menu
- err = SetEventParameter(inEvent, kEventParamMenuRef,
+ err = SetEventParameter(inEvent, kEventParamMenuRef,
typeMenuRef, sizeof(MenuRef), &hMenu);
wxASSERT(err == noErr);
-
- return err;
}
- else
- return eventNotHandledErr;
+
+ return err;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// NB: Here we have to perform a deep copy of the menu,
// copying each and every menu item from menu to m_pMenu.
- // Other implementations use wxWindow::PopupMenu here,
+ // Other implementations use wxWindow::PopupMenu here,
// which idle execution until the user selects something,
- // but since the mac handles this internally, we can't -
+ // but since the mac handles this internally, we can't -
// and have no way at all to idle it while the dock menu
// is being shown before menu goes out of scope (it may
// not be on the heap, and may expire right after this function
- // is done - we need it to last until the carbon event is triggered -
+ // is done - we need it to last until the carbon event is triggered -
// that's when the user right clicks).
//
- // Also, since there is no equal (assignment) operator
+ // Also, since there is no equal (assignment) operator
// on either wxMenu or wxMenuItem, we have to do all the
// dirty work ourselves.
//
// perform a deep copy of the menu
wxMenuItemList& theList = menu->GetMenuItems();
wxMenuItemList::compatibility_iterator theNode = theList.GetFirst();
-
+
// create the main menu
wxMenu* m_pMenu = new wxMenu(menu->GetTitle());
while (theNode != NULL)
{
wxMenuItem* theItem = theNode->GetData();
- m_pMenu->Append(new wxMenuItem(m_pMenu, // parent menu
- theItem->GetId(), // id
- theItem->GetText(), // text label
- theItem->GetHelp(), // status bar help string
- theItem->GetKind(), // menu flags - checkable, separator, etc.
- wxDeepCopyMenu(theItem->GetSubMenu()) // submenu
- ));
+ m_pMenu->Append(
+ new wxMenuItem(
+ m_pMenu, // parent menu
+ theItem->GetId(), // id
+ theItem->GetText(), // text label
+ theItem->GetHelp(), // status bar help string
+ theItem->GetKind(), // menu flags - checkable, separator, etc.
+ wxDeepCopyMenu(theItem->GetSubMenu()) // submenu
+ ));
theNode = theNode->GetNext();
}
-
+
return m_pMenu;
}
//-----------------------------------------------------------------------------
-// wxDockTaskBarIcon Constructor
+// wxDockTaskBarIcon ctor
//
// Initializes the dock implementation of wxTaskBarIcon.
//
// Here we create some mac-specific event handlers and UPPs.
//-----------------------------------------------------------------------------
-wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)
+wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)
: wxTaskBarIconImpl(parent),
- m_eventHandlerRef(NULL), m_pMenu(NULL),
- m_theLastMenu(GetApplicationDockTileMenu()), m_iconAdded(false)
+ m_eventHandlerRef(NULL), m_pMenu(NULL),
+ m_theLastMenu(GetApplicationDockTileMenu()), m_iconAdded(false)
{
// register the events that will return the dock menu
- EventTypeSpec tbEventList[] = { { kEventClassCommand, kEventProcessCommand },
- { kEventClassApplication, kEventAppGetDockTileMenu } };
-
+ EventTypeSpec tbEventList[] =
+ {
+ { kEventClassCommand, kEventProcessCommand },
+ { kEventClassApplication, kEventAppGetDockTileMenu }
+ };
+
m_eventupp = NewEventHandlerUPP(wxDockEventHandler);
wxASSERT(m_eventupp != NULL);
-
+
#ifdef __WXDEBUG__
OSStatus err =
#endif
InstallApplicationEventHandler(
m_eventupp,
- GetEventTypeCount(tbEventList), tbEventList,
+ GetEventTypeCount(tbEventList), tbEventList,
this, &m_eventHandlerRef);
- wxASSERT(err == noErr);
+ wxASSERT( err == noErr );
}
//-----------------------------------------------------------------------------
DisposeEventHandlerUPP(m_eventupp);
// restore old icon and menu to the dock
- RemoveIcon();
+ RemoveIcon();
}
//-----------------------------------------------------------------------------
// wxDockTaskBarIcon::DoCreatePopupMenu
//
-// Helper function that handles a request from the dock event handler
+// Helper function that handles a request from the dock event handler
// to get the menu for the dock
//-----------------------------------------------------------------------------
wxMenu* wxDockTaskBarIcon::DoCreatePopupMenu()
{
// get the menu from the parent
wxMenu* theNewMenu = CreatePopupMenu();
-
+
if (theNewMenu)
{
if (m_pMenu)
m_pMenu = theNewMenu;
m_pMenu->SetInvokingWindow(m_menuEventWindow);
}
-
- // the return here can be one of three things
+
+ // the return here can be one of three things
// (in order of priority):
// 1) User passed a menu from CreatePopupMenu override
// 2) menu sent to and copied from PopupMenu
// Returns whether or not the dock is not using the default image
//-----------------------------------------------------------------------------
bool wxDockTaskBarIcon::IsIconInstalled() const
-{
- return m_iconAdded;
+{
+ return m_iconAdded;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{
+ // convert the wxIcon into a wxBitmap so we can perform some
+ // wxBitmap operations with it
wxBitmap bmp( icon ) ;
- OSStatus err = noErr ;
-
- CGImageRef pImage;
-
-#if 0 // is always available under OSX now -- crashes on 10.2 in CFRetain() - RN
- pImage = (CGImageRef) bmp.CGImageCreate() ;
-#else
- WXHBITMAP iconport ;
- WXHBITMAP maskport ;
- iconport = bmp.GetHBITMAP( &maskport ) ;
-
- if (!maskport)
- {
- // Make a mask with no transparent pixels
- wxBitmap mbmp(icon.GetWidth(), icon.GetHeight());
- wxMemoryDC dc;
- dc.SelectObject(mbmp);
- dc.SetBackground(*wxBLACK_BRUSH);
- dc.Clear();
- dc.SelectObject(wxNullBitmap);
- bmp.SetMask( new wxMask(mbmp, *wxWHITE) ) ;
- iconport = bmp.GetHBITMAP( &maskport ) ;
- }
-
- //create the icon from the bitmap and mask bitmap contained within
- err = CreateCGImageFromPixMaps(
- GetGWorldPixMap(MAC_WXHBITMAP(iconport)),
- GetGWorldPixMap(MAC_WXHBITMAP(maskport)),
- &pImage
- );
- wxASSERT(err == 0);
-#endif
+ wxASSERT( bmp.Ok() );
- wxASSERT(pImage != NULL);
- err = SetApplicationDockTileImage(pImage);
-
- wxASSERT(err == 0);
-
+ // get the CGImageRef for the wxBitmap:
+ // OSX builds only, but then the dock only exists in OSX
+ CGImageRef pImage = (CGImageRef) bmp.CGImageCreate();
+ wxASSERT( pImage != NULL );
+
+ // actually set the dock image
+ OSStatus err = SetApplicationDockTileImage( pImage );
+ wxASSERT( err == noErr );
+
+ // free the CGImage, now that it's referenced by the dock
if (pImage != NULL)
- CGImageRelease(pImage);
-
- return m_iconAdded = err == noErr;
+ CGImageRelease( pImage );
+
+ bool success = (err == noErr);
+ m_iconAdded = success;
+
+ return success;
}
-
+
//-----------------------------------------------------------------------------
// wxDockTaskBarIcon::RemoveIcon
//
delete m_pMenu;
m_pMenu = NULL;
}
-
+
// restore old icon to the dock
OSStatus err = RestoreApplicationDockTileImage();
wxASSERT(err == noErr);
-
+
// restore the old menu to the dock
SetApplicationDockTileMenu(m_theLastMenu);
- return !(m_iconAdded = !(err == noErr));
+ bool success = (err == noErr);
+ m_iconAdded = !success;
+
+ return success;
}
-
+
//-----------------------------------------------------------------------------
// wxDockTaskBarIcon::PopupMenu
//
// 2.4 and wxPython method that "pops of the menu in the taskbar".
//
-// In reality because of the way the dock menu works in carbon
+// In reality because of the way the dock menu works in carbon
// we just save the menu, and if the user didn't override CreatePopupMenu
// return the menu passed here, thus sort of getting the same effect.
//-----------------------------------------------------------------------------
if (m_pMenu)
delete m_pMenu;
-
+
//start copy of menu
m_pMenu = wxDeepCopyMenu(menu);
-
+
//finish up
m_pMenu->SetInvokingWindow(m_menuEventWindow);
return true;
}
-
+
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxTaskBarIcon
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
+
IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)
-
+
//-----------------------------------------------------------------------------
// wxTaskBarIcon Constructor
//
//
// Note that we only support DOCK currently as others require cocoa and
// also some require hacks and other such things. (MenuExtras are
-// actually seperate programs that also require a special undocumented id
+// actually seperate programs that also require a special undocumented id
// hack and other such fun stuff).
//-----------------------------------------------------------------------------
wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType nType)
{
- wxASSERT_MSG(nType == DOCK,
+ wxASSERT_MSG(nType == DOCK,
wxT("Only the DOCK implementation of wxTaskBarIcon")
wxT("on mac carbon is currently supported!"));
m_impl = new wxDockTaskBarIcon(this);
bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{ return m_impl->SetIcon(icon, tooltip); }
bool wxTaskBarIcon::RemoveIcon()
-{ return m_impl->RemoveIcon(); }
+{ return m_impl->RemoveIcon(); }
bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
{ return m_impl->PopupMenu(menu); }
projects / wxWidgets.git / blobdiff