[ 1473731 ] 'wxColourBase and wxString <-> wxColour implementation' with minor modifi...

[wxWidgets.git] / src / mac / carbon / taskbar.cpp

diff --git a/src/mac/carbon/taskbar.cpp b/src/mac/carbon/taskbar.cpp
index 5d0ff841a925eef3f43a99771107b210e46f9b08..5fea2b7552e73e3db85f9df4a241d32a0235cb7f 100644 (file)
--- a/src/mac/carbon/taskbar.cpp
+++ b/src/mac/carbon/taskbar.cpp
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        taskbar.cpp
-// Purpose:     wxTaskBarIcon OSX Implementation
+// Name:        src/mac/carbon/taskbar.cpp
+// Purpose:    wxTaskBarIcon

 // Author:      Ryan Norton
 // Modified by:
 // Created:     09/25/2004
 // Author:      Ryan Norton
 // Modified by:
 // Created:     09/25/2004


@@ -9,14 +9,6 @@
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 

-//=============================================================================
-// Declarations
-//=============================================================================
-
-//-----------------------------------------------------------------------------
-// Includes
-//-----------------------------------------------------------------------------
-

 #include "wx/wxprec.h"
 
 #ifdef wxHAS_TASK_BAR_ICON
 #include "wx/wxprec.h"
 
 #ifdef wxHAS_TASK_BAR_ICON


@@ -28,14 +20,8 @@
 #include "wx/icon.h"
 #include "wx/dcmemory.h"
 
 #include "wx/icon.h"
 #include "wx/dcmemory.h"
 

-//-----------------------------------------------------------------------------
-//
-//  wxTaskBarIconImpl
-//
-//  Superclass of wxTaskBarIcon implementations
-//-----------------------------------------------------------------------------

 
 

-class wxTaskBarIconImpl 
+class wxTaskBarIconImpl

 {
 public:
     wxTaskBarIconImpl(wxTaskBarIcon* parent);
 {
 public:
     wxTaskBarIconImpl(wxTaskBarIcon* parent);


@@ -45,12 +31,14 @@ public:
     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip) = 0;
     virtual bool RemoveIcon() = 0;
     virtual bool PopupMenu(wxMenu *menu) = 0;
     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip) = 0;
     virtual bool RemoveIcon() = 0;
     virtual bool PopupMenu(wxMenu *menu) = 0;

-    
-    wxMenu* CreatePopupMenu()
+
+    wxMenu * CreatePopupMenu()

     { return m_parent->CreatePopupMenu(); }
     { return m_parent->CreatePopupMenu(); }

-    
-    wxTaskBarIcon*       m_parent;
-    class wxTaskBarIconWindow* m_menuEventWindow;
+
+    wxTaskBarIcon *m_parent;
+    class wxTaskBarIconWindow *m_menuEventWindow;
+
+    DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)

 };
 
 //-----------------------------------------------------------------------------
 };
 
 //-----------------------------------------------------------------------------


@@ -58,42 +46,36 @@ public:
 //  wxTaskBarIconWindow
 //
 //  Event handler for menus
 //  wxTaskBarIconWindow
 //
 //  Event handler for menus

-//  NB: Since wxWindows in mac HAVE to have parents we need this to be
+//  NB: Since wxWindows in Mac HAVE to have parents we need this to be

 //  a top level window...
 //-----------------------------------------------------------------------------
 
 class wxTaskBarIconWindow : public wxTopLevelWindow
 {
 public:
 //  a top level window...
 //-----------------------------------------------------------------------------
 
 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, 
-                wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent)
-               );
+        Connect(
+            -1, wxEVT_COMMAND_MENU_SELECTED,
+            wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent) );

     }
 
     }
 

-    void OnMenuEvent(wxCommandEvent& event) 
+    void OnMenuEvent(wxCommandEvent& event)

     {
         m_impl->m_parent->ProcessEvent(event);
     }
 
 private:
     {
         m_impl->m_parent->ProcessEvent(event);
     }
 
 private:

-    wxTaskBarIconImpl* m_impl;
+    wxTaskBarIconImpl *m_impl;

 };
 
 };
 

-//-----------------------------------------------------------------------------
-//
-//  wxDockBarIconImpl
-//
-//-----------------------------------------------------------------------------
-

 class wxDockTaskBarIcon : public wxTaskBarIconImpl
 {
 public:
     wxDockTaskBarIcon(wxTaskBarIcon* parent);
     virtual ~wxDockTaskBarIcon();
 class wxDockTaskBarIcon : public wxTaskBarIconImpl
 {
 public:
     wxDockTaskBarIcon(wxTaskBarIcon* parent);
     virtual ~wxDockTaskBarIcon();

-    
+

     virtual bool IsIconInstalled() const;
     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip);
     virtual bool RemoveIcon();
     virtual bool IsIconInstalled() const;
     virtual bool SetIcon(const wxIcon& icon, const wxString& tooltip);
     virtual bool RemoveIcon();


@@ -103,23 +85,18 @@ public:
 
     EventHandlerRef     m_eventHandlerRef;
     EventHandlerUPP     m_eventupp;
 
     EventHandlerRef     m_eventHandlerRef;
     EventHandlerUPP     m_eventupp;

-    wxMenu*             m_pMenu;
+    wxWindow           *m_eventWindow;
+    wxMenu             *m_pMenu;

     MenuRef             m_theLastMenu;
     bool                m_iconAdded;
     MenuRef             m_theLastMenu;
     bool                m_iconAdded;

-    wxWindow*           m_eventWindow;

 };
 
 // Forward declarations for utility functions for dock implementation
 };
 
 // Forward declarations for utility functions for dock implementation

-pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
-                                    EventRef inEvent, void* pData);
-wxMenu* wxDeepCopyMenu(wxMenu* menu);
-                                    
+pascal OSStatus wxDockEventHandler(
+    EventHandlerCallRef inHandlerCallRef,
+    EventRef inEvent, void* pData );
+wxMenu * wxDeepCopyMenu( wxMenu *menu );

 
 

-//=============================================================================
-//
-// Implementation
-//
-//=============================================================================

 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //
 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //


@@ -127,21 +104,11 @@ wxMenu* wxDeepCopyMenu(wxMenu* menu);
 //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 

-//-----------------------------------------------------------------------------
-// wxTaskBarIconImpl Constructor
-//
-// Initializes members and creates the event window
-//-----------------------------------------------------------------------------
-wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent) 
+wxTaskBarIconImpl::wxTaskBarIconImpl(wxTaskBarIcon* parent)

     : m_parent(parent), m_menuEventWindow(new wxTaskBarIconWindow(this))
 {
 }
 
     : m_parent(parent), m_menuEventWindow(new wxTaskBarIconWindow(this))
 {
 }
 

-//-----------------------------------------------------------------------------
-// wxTaskBarIconImpl Destructor
-//
-// Cleans up the event window
-//-----------------------------------------------------------------------------

 wxTaskBarIconImpl::~wxTaskBarIconImpl()
 {
     delete m_menuEventWindow;
 wxTaskBarIconImpl::~wxTaskBarIconImpl()
 {
     delete m_menuEventWindow;


@@ -151,141 +118,133 @@ wxTaskBarIconImpl::~wxTaskBarIconImpl()
 //
 //  wxDockTaskBarIcon
 //
 //
 //  wxDockTaskBarIcon
 //

-//  OS X DOCK implementation of wxTaskBarIcon using carbon
+//  OS X Dock implementation of wxTaskBarIcon using Carbon

 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 

-//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+//-----------------------------------------------------------------------------

 // wxDockEventHandler
 //
 // wxDockEventHandler
 //

-// This is the global mac/carbon event handler for the dock.
+// This is the global Mac/Carbon event handler for the dock.

 // We need this for two reasons:
 // 1) To handle wxTaskBarIcon menu events (see below for why)
 // 2) To handle events from the dock when it requests a menu
 // We need this for two reasons:
 // 1) To handle wxTaskBarIcon menu events (see below for why)
 // 2) To handle events from the dock when it requests a menu

-//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+//-----------------------------------------------------------------------------

 pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
 pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,

-                                    EventRef inEvent, void* pData)
+                                    EventRef inEvent, void *pData )

 {
     // Get the parameters we want from the event
     wxDockTaskBarIcon* pTB = (wxDockTaskBarIcon*) pData;
     const UInt32 eventClass = GetEventClass(inEvent);
     const UInt32 eventKind = GetEventKind(inEvent);
 {
     // Get the parameters we want from the event
     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)
     // 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 we have no taskbar menu quickly pass it back to wxApp

-        if (! pTB->m_pMenu )
-        {
+        if (pTB->m_pMenu == NULL)

             return eventNotHandledErr;
             return eventNotHandledErr;

-        }
-                
-        //
+

         // This is the real reason why we need this. Normally menus
         // get handled in wxMacAppEventHandler
         //
         // 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)
         //
         //                                      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.
         // command.menu.menuRef IS NULL!
         // Which causes the wxApp handler just to skip it.

-        //

         MenuRef taskbarMenuRef = MAC_WXHMENU(pTB->m_pMenu->GetHMenu());
         MenuRef taskbarMenuRef = MAC_WXHMENU(pTB->m_pMenu->GetHMenu());

-        OSStatus result = eventNotHandledErr;
-        OSErr err;
-    
+        OSStatus err;
+

         // get the HICommand from the event
         HICommand command;
         // get the HICommand from the event
         HICommand command;

-        err = GetEventParameter(inEvent, kEventParamDirectObject,
-                                typeHICommand, NULL, 
-                                sizeof(HICommand), NULL, &command);
+        err = GetEventParameter(
+            inEvent, kEventParamDirectObject,
+            typeHICommand, NULL,
+            sizeof(HICommand), NULL, &command );

         if (err == noErr)
         if (err == noErr)

-        {       
-            //
+        {

             // Obtain the REAL menuRef and the menuItemIndex in the real menuRef
             //
             // 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
             // just the top level wxTaskBar menu

-            //

             MenuItemIndex menuItemIndex;
             MenuRef menuRef;
 
             MenuItemIndex menuItemIndex;
             MenuRef menuRef;
 

-            err = GetIndMenuItemWithCommandID(taskbarMenuRef, 
-                                              command.commandID, 
-                                              1, &menuRef, &menuItemIndex);
+            err = GetIndMenuItemWithCommandID(
+                taskbarMenuRef,
+                command.commandID,
+                1, &menuRef, &menuItemIndex );

             if (err == noErr)
             {
                 MenuCommand id = command.commandID;
             if (err == noErr)
             {
                 MenuCommand id = command.commandID;

-                wxMenuItem* item = NULL;
-        
+                wxMenuItem *item = NULL;
+

                 if (id != 0) // get the wxMenuItem reference from the MenuRef
                 if (id != 0) // get the wxMenuItem reference from the MenuRef

-                    GetMenuItemRefCon(menuRef, menuItemIndex, (UInt32*) &item);
-            
+                    GetMenuItemRefCon( menuRef, menuItemIndex, (UInt32*) &item );
+

                 if (item)
                 {
                     // Handle items that are checkable
                     // FIXME: Doesn't work (at least on 10.2)!
                     if (item->IsCheckable())
                 if (item)
                 {
                     // Handle items that are checkable
                     // FIXME: Doesn't work (at least on 10.2)!
                     if (item->IsCheckable())

-                        item->Check( !item->IsChecked() ) ;
+                        item->Check( !item->IsChecked() );

 
                     // send the wxEvent to the wxMenu
 
                     // send the wxEvent to the wxMenu

-                    item->GetMenu()->SendEvent(id, 
-                               item->IsCheckable() ? 
-                               item->IsChecked() : -1 
-                               );
-                    err = noErr; // successfully handled the event
+                    item->GetMenu()->SendEvent( id, item->IsCheckable() ? item->IsChecked() : -1 );
+
+                    // successfully handled the event
+                    err = noErr;

                 }
             }
                 }
             }

-        } //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,
     }
 
     // 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
     // NB: This may result in double or even triple-creation of the menus
     // We need to do this for 2.4 compat, however
              eventKind == kEventAppGetDockTileMenu);
 
     // process the right click events
     // NB: This may result in double or even triple-creation of the menus
     // We need to do this for 2.4 compat, however

-    wxTaskBarIconEvent downevt(wxEVT_TASKBAR_RIGHT_DOWN,NULL);
+    wxTaskBarIconEvent downevt(wxEVT_TASKBAR_RIGHT_DOWN, NULL);

     pTB->m_parent->ProcessEvent(downevt);
 
     pTB->m_parent->ProcessEvent(downevt);
 

-    wxTaskBarIconEvent upevt(wxEVT_TASKBAR_RIGHT_UP,NULL);
+    wxTaskBarIconEvent upevt(wxEVT_TASKBAR_RIGHT_UP, NULL);

     pTB->m_parent->ProcessEvent(upevt);
 
     pTB->m_parent->ProcessEvent(upevt);
 

-    //create popup menu
+    // create popup menu

     wxMenu* menu = pTB->DoCreatePopupMenu();
     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());
 
         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
         // 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, 
-                    typeMenuRef, sizeof(MenuRef), &hMenu);
-        wxASSERT(err == noErr);
-
-        return err;
+        err = SetEventParameter(
+            inEvent, kEventParamMenuRef,
+            typeMenuRef, sizeof(MenuRef), &hMenu );
+        verify_noerr( err );

     }
     }

-    else
-        return eventNotHandledErr;
+
+    return err;

 }
 
 }
 

-//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+//-----------------------------------------------------------------------------

 // wxDeepCopyMenu
 //
 // Performs a top-to-bottom copy of the input menu and all of its
 // wxDeepCopyMenu
 //
 // Performs a top-to-bottom copy of the input menu and all of its


@@ -293,79 +252,79 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
 //
 // This is mostly needed for 2.4 compatability. However wxPython and others
 // still use this way of setting the taskbarmenu.
 //
 // This is mostly needed for 2.4 compatability. However wxPython and others
 // still use this way of setting the taskbarmenu.

-//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-wxMenu* wxDeepCopyMenu(wxMenu* menu)
+//-----------------------------------------------------------------------------
+wxMenu * wxDeepCopyMenu( wxMenu *menu )

 {
 {

-    if (!menu)
+    if (menu == NULL)

         return NULL;
 
         return NULL;
 

-    //

     // NB:  Here we have to perform a deep copy of the menu,
     // copying each and every menu item from menu to m_pMenu.
     // 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,
     // 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
     // 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).
     //
     // 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.
     // 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();
 
     // perform a deep copy of the menu
     wxMenuItemList& theList = menu->GetMenuItems();
     wxMenuItemList::compatibility_iterator theNode = theList.GetFirst();

-    
+

     // create the main menu
     // create the main menu

-    wxMenu* m_pMenu = new wxMenu(menu->GetTitle());
+    wxMenu *m_pMenu = new wxMenu(menu->GetTitle());

 
     while (theNode != NULL)
     {
         wxMenuItem* theItem = theNode->GetData();
 
     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();
     }
         theNode = theNode->GetNext();
     }

-    
+

     return m_pMenu;
 }
 
 //-----------------------------------------------------------------------------
     return m_pMenu;
 }
 
 //-----------------------------------------------------------------------------

-// wxDockTaskBarIcon Constructor
+// wxDockTaskBarIcon ctor

 //
 // Initializes the dock implementation of wxTaskBarIcon.
 //
 //
 // Initializes the dock implementation of wxTaskBarIcon.
 //

-// Here we create some mac-specific event handlers and UPPs.
+// Here we create some Mac-specific event handlers and UPPs.

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent) 
+wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)

     :   wxTaskBarIconImpl(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
 {
     // 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);
     m_eventupp = NewEventHandlerUPP(wxDockEventHandler);
     wxASSERT(m_eventupp != NULL);

-                                              
-#ifdef __WXDEBUG__
-    OSStatus err =
-#endif
-    InstallApplicationEventHandler(
+
+    OSStatus err = InstallApplicationEventHandler(

             m_eventupp,
             m_eventupp,

-            GetEventTypeCount(tbEventList), tbEventList, 
+            GetEventTypeCount(tbEventList), tbEventList,

             this, &m_eventHandlerRef);
             this, &m_eventHandlerRef);

-    wxASSERT(err == noErr);
+    verify_noerr( err );

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -380,20 +339,20 @@ wxDockTaskBarIcon::~wxDockTaskBarIcon()
     DisposeEventHandlerUPP(m_eventupp);
 
     // restore old icon and menu to the dock
     DisposeEventHandlerUPP(m_eventupp);
 
     // restore old icon and menu to the dock

-    RemoveIcon();    
+    RemoveIcon();

 }
 
 //-----------------------------------------------------------------------------
 // wxDockTaskBarIcon::DoCreatePopupMenu
 //
 }
 
 //-----------------------------------------------------------------------------
 // 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
 //-----------------------------------------------------------------------------
 // to get the menu for the dock
 //-----------------------------------------------------------------------------

-wxMenu* wxDockTaskBarIcon::DoCreatePopupMenu()
+wxMenu * wxDockTaskBarIcon::DoCreatePopupMenu()

 {
     // get the menu from the parent
     wxMenu* theNewMenu = CreatePopupMenu();
 {
     // get the menu from the parent
     wxMenu* theNewMenu = CreatePopupMenu();

-    
+

     if (theNewMenu)
     {
         if (m_pMenu)
     if (theNewMenu)
     {
         if (m_pMenu)


@@ -401,8 +360,8 @@ wxMenu* wxDockTaskBarIcon::DoCreatePopupMenu()
         m_pMenu = theNewMenu;
         m_pMenu->SetInvokingWindow(m_menuEventWindow);
     }
         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
     // (in order of priority):
     // 1) User passed a menu from CreatePopupMenu override
     // 2) menu sent to and copied from PopupMenu


@@ -417,8 +376,8 @@ wxMenu* wxDockTaskBarIcon::DoCreatePopupMenu()
 // Returns whether or not the dock is not using the default image
 //-----------------------------------------------------------------------------
 bool wxDockTaskBarIcon::IsIconInstalled() const
 // Returns whether or not the dock is not using the default image
 //-----------------------------------------------------------------------------
 bool wxDockTaskBarIcon::IsIconInstalled() const

-{   
-    return m_iconAdded; 
+{
+    return m_iconAdded;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -428,51 +387,30 @@ bool wxDockTaskBarIcon::IsIconInstalled() const
 //-----------------------------------------------------------------------------
 bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
 {
 //-----------------------------------------------------------------------------
 bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
 {

-    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(pImage != NULL);
-    err = SetApplicationDockTileImage(pImage);
-    
-    wxASSERT(err == 0);
-    
+    // convert the wxIcon into a wxBitmap so we can perform some
+    // wxBitmap operations with it
+    wxBitmap bmp( icon );
+    wxASSERT( bmp.Ok() );
+
+    // 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 );
+    verify_noerr( err );
+
+    // free the CGImage, now that it's referenced by the dock

     if (pImage != NULL)
     if (pImage != NULL)

-        CGImageRelease(pImage);
-    
-    return m_iconAdded = err == noErr;
+        CGImageRelease( pImage );
+
+    bool success = (err == noErr);
+    m_iconAdded = success;
+
+    return success;

 }
 }

-    
+

 //-----------------------------------------------------------------------------
 // wxDockTaskBarIcon::RemoveIcon
 //
 //-----------------------------------------------------------------------------
 // wxDockTaskBarIcon::RemoveIcon
 //


@@ -485,23 +423,26 @@ bool wxDockTaskBarIcon::RemoveIcon()
         delete m_pMenu;
         m_pMenu = NULL;
     }
         delete m_pMenu;
         m_pMenu = NULL;
     }

-    
+

     // restore old icon to the dock
     OSStatus err = RestoreApplicationDockTileImage();
     // restore old icon to the dock
     OSStatus err = RestoreApplicationDockTileImage();

-    wxASSERT(err == noErr);
-    
+    verify_noerr( err );
+

     // restore the old menu to the dock
     // restore the old menu to the dock

-    SetApplicationDockTileMenu(m_theLastMenu);
+    SetApplicationDockTileMenu( m_theLastMenu );
+
+    bool success = (err == noErr);
+    m_iconAdded = !success;

 
 

-    return !(m_iconAdded = !(err == noErr));
+    return success;

 }
 }

-    
+

 //-----------------------------------------------------------------------------
 // wxDockTaskBarIcon::PopupMenu
 //
 // 2.4 and wxPython method that "pops of the menu in the taskbar".
 //
 //-----------------------------------------------------------------------------
 // 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.
 //-----------------------------------------------------------------------------
 // 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.
 //-----------------------------------------------------------------------------


@@ -511,24 +452,24 @@ bool wxDockTaskBarIcon::PopupMenu(wxMenu *menu)
 
     if (m_pMenu)
         delete m_pMenu;
 
     if (m_pMenu)
         delete m_pMenu;

-    
-    //start copy of menu
+
+    // start copy of menu

     m_pMenu = wxDeepCopyMenu(menu);
     m_pMenu = wxDeepCopyMenu(menu);

-   
-    //finish up
+
+    // finish up

     m_pMenu->SetInvokingWindow(m_menuEventWindow);
 
     return true;
 }
     m_pMenu->SetInvokingWindow(m_menuEventWindow);
 
     return true;
 }

-    
+

 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //
 //  wxTaskBarIcon
 //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //
 //  wxTaskBarIcon
 //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

-    
+

 IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)
 IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)

-    
+

 //-----------------------------------------------------------------------------
 // wxTaskBarIcon Constructor
 //
 //-----------------------------------------------------------------------------
 // wxTaskBarIcon Constructor
 //


@@ -536,14 +477,15 @@ IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)
 //
 // Note that we only support DOCK currently as others require cocoa and
 // also some require hacks and other such things. (MenuExtras are
 //
 // 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)
 {
 // hack and other such fun stuff).
 //-----------------------------------------------------------------------------
 wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType nType)
 {

-    wxASSERT_MSG(nType == DOCK, 
-                       wxT("Only the DOCK implementation of wxTaskBarIcon")
-                       wxT("on mac carbon is currently supported!"));
+    wxASSERT_MSG(
+        nType == DOCK,
+        wxT("Only the DOCK implementation of wxTaskBarIcon on Mac-Carbon is currently supported!") );
+

     m_impl = new wxDockTaskBarIcon(this);
 }
 
     m_impl = new wxDockTaskBarIcon(this);
 }
 


@@ -566,11 +508,14 @@ wxTaskBarIcon::~wxTaskBarIcon()
 //-----------------------------------------------------------------------------
 bool wxTaskBarIcon::IsIconInstalled() const
 { return m_impl->IsIconInstalled(); }
 //-----------------------------------------------------------------------------
 bool wxTaskBarIcon::IsIconInstalled() const
 { return m_impl->IsIconInstalled(); }

+

 bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
 { return m_impl->SetIcon(icon, tooltip); }
 bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
 { return m_impl->SetIcon(icon, tooltip); }

+

 bool wxTaskBarIcon::RemoveIcon()
 bool wxTaskBarIcon::RemoveIcon()

-{ return m_impl->RemoveIcon(); }    
+{ return m_impl->RemoveIcon(); }
+

 bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
 { return m_impl->PopupMenu(menu); }
 
 bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
 { return m_impl->PopupMenu(menu); }
 

-#endif //wxHAS_TASK_BAR_ICON
+#endif // wxHAS_TASK_BAR_ICON