AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

cleanup - refomatting

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@37569 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Surovell 2006-02-13 21:44:48 +00:00
parent 8f14114792
commit 51c4d2a5a0
2 changed files with 218 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
src/mac/carbon/msgdlg.cpp
View File

@ -16,10 +16,13 @@
#include "wx/intl.h" #include "wx/intl.h"
#include "wx/mac/uma.h" #include "wx/mac/uma.h"
IMPLEMENT_CLASS(wxMessageDialog, wxDialog) IMPLEMENT_CLASS(wxMessageDialog, wxDialog)
wxMessageDialog::wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption,
long style, const wxPoint& pos) wxMessageDialog::wxMessageDialog(
wxWindow *parent, const wxString& message, const wxString& caption,
long style, const wxPoint& pos )
{ {
m_caption = caption; m_caption = caption;
m_message = message; m_message = message;
@ -29,189 +32,190 @@ wxMessageDialog::wxMessageDialog(wxWindow *parent, const wxString& message, cons
int wxMessageDialog::ShowModal() int wxMessageDialog::ShowModal()
{ {
int resultbutton = wxID_CANCEL ; int resultbutton = wxID_CANCEL;
const long style = GetMessageDialogStyle(); const long style = GetMessageDialogStyle();
wxASSERT_MSG( ( style & 0x3F ) != wxYES , wxT("this style is not supported on mac") ) ; wxASSERT_MSG( (style & 0x3F) != wxYES, wxT("this style is not supported on Mac") );
AlertType alertType = kAlertPlainAlert ; AlertType alertType = kAlertPlainAlert;
if (style & wxICON_EXCLAMATION) if (style & wxICON_EXCLAMATION)
alertType = kAlertNoteAlert ; alertType = kAlertNoteAlert;
else if (style & wxICON_HAND) else if (style & wxICON_HAND)
alertType = kAlertStopAlert ; alertType = kAlertStopAlert;
else if (style & wxICON_INFORMATION) else if (style & wxICON_INFORMATION)
alertType = kAlertNoteAlert ; alertType = kAlertNoteAlert;
else if (style & wxICON_QUESTION) else if (style & wxICON_QUESTION)
alertType = kAlertCautionAlert ; alertType = kAlertCautionAlert;
#if TARGET_API_MAC_OSX #if TARGET_API_MAC_OSX
CFStringRef defaultButtonTitle = NULL ; CFStringRef defaultButtonTitle = NULL;
CFStringRef alternateButtonTitle = NULL ; CFStringRef alternateButtonTitle = NULL;
CFStringRef otherButtonTitle = NULL ; CFStringRef otherButtonTitle = NULL;
wxMacCFStringHolder cfTitle(m_caption , m_font.GetEncoding()); wxMacCFStringHolder cfTitle( m_caption, m_font.GetEncoding() );
wxMacCFStringHolder cfText(m_message , m_font.GetEncoding()); wxMacCFStringHolder cfText( m_message, m_font.GetEncoding() );
wxMacCFStringHolder cfNoString(_("No") , m_font.GetEncoding()) ; wxMacCFStringHolder cfNoString( wxT("No"), m_font.GetEncoding() );
wxMacCFStringHolder cfYesString( _("Yes") , m_font.GetEncoding()) ; wxMacCFStringHolder cfYesString( wxT("Yes"), m_font.GetEncoding() );
wxMacCFStringHolder cfCancelString( _("Cancel") , m_font.GetEncoding()) ; wxMacCFStringHolder cfCancelString( wxT("Cancel"), m_font.GetEncoding() );
int buttonId[4] = { 0 , 0 , 0 , wxID_CANCEL /* time-out */ } ; int buttonId[4] = { 0, 0, 0, wxID_CANCEL /* time-out */ };
if (style & wxYES_NO) if (style & wxYES_NO)
{ {
if ( style & wxNO_DEFAULT ) if ( style & wxNO_DEFAULT )
{ {
defaultButtonTitle = cfNoString ; defaultButtonTitle = cfNoString;
alternateButtonTitle = cfYesString ; alternateButtonTitle = cfYesString;
buttonId[0] = wxID_NO ; buttonId[0] = wxID_NO;
buttonId[1] = wxID_YES ; buttonId[1] = wxID_YES;
} }
else else
{ {
defaultButtonTitle = cfYesString ; defaultButtonTitle = cfYesString;
alternateButtonTitle = cfNoString ; alternateButtonTitle = cfNoString;
buttonId[0] = wxID_YES ; buttonId[0] = wxID_YES;
buttonId[1] = wxID_NO ; buttonId[1] = wxID_NO;
} }
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
otherButtonTitle = cfCancelString ; otherButtonTitle = cfCancelString;
buttonId[2] = wxID_CANCEL ; buttonId[2] = wxID_CANCEL;
} }
} }
else else
{ {
// the msw implementation even shows an ok button if it is not specified, we'll do the same // the MSW implementation even shows an OK button if it is not specified, we'll do the same
buttonId[0] = wxID_OK ; buttonId[0] = wxID_OK;
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
alternateButtonTitle = cfCancelString ; alternateButtonTitle = cfCancelString;
buttonId[1] = wxID_CANCEL ; buttonId[1] = wxID_CANCEL;
} }
} }
CFOptionFlags exitButton ; CFOptionFlags exitButton;
OSStatus err = CFUserNotificationDisplayAlert ( 0 , alertType , NULL , NULL , NULL , cfTitle , cfText , OSStatus err = CFUserNotificationDisplayAlert(
defaultButtonTitle , alternateButtonTitle , otherButtonTitle , &exitButton ); 0, alertType, NULL, NULL, NULL, cfTitle, cfText,
if ( err == noErr ) defaultButtonTitle, alternateButtonTitle, otherButtonTitle, &exitButton );
resultbutton = buttonId[exitButton] ; if (err == noErr)
resultbutton = buttonId[exitButton];
#else #else
short result ; short result;
#if TARGET_CARBON #if TARGET_CARBON
if ( UMAGetSystemVersion() >= 0x1000 ) if ( UMAGetSystemVersion() >= 0x1000 )
{ {
AlertStdCFStringAlertParamRec param ; AlertStdCFStringAlertParamRec param;
wxMacCFStringHolder cfNoString(_("No") , m_font.GetEncoding()) ; wxMacCFStringHolder cfNoString( wxT("No"), m_font.GetEncoding() );
wxMacCFStringHolder cfYesString( _("Yes") , m_font.GetEncoding()) ; wxMacCFStringHolder cfYesString( wxT("Yes"), m_font.GetEncoding() );
wxMacCFStringHolder cfTitle(m_caption , m_font.GetEncoding()); wxMacCFStringHolder cfTitle( m_caption, m_font.GetEncoding() );
wxMacCFStringHolder cfText(m_message , m_font.GetEncoding()); wxMacCFStringHolder cfText( m_message, m_font.GetEncoding() );
param.movable = true; param.movable = true;
param.flags = 0 ; param.flags = 0;
param.version = kStdCFStringAlertVersionOne ; param.version = kStdCFStringAlertVersionOne;
bool skipDialog = false ; bool skipDialog = false;
if (style & wxYES_NO) if (style & wxYES_NO)
{ {
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
param.defaultText = cfYesString ; param.defaultText = cfYesString;
param.cancelText = (CFStringRef) kAlertDefaultCancelText; param.cancelText = (CFStringRef) kAlertDefaultCancelText;
param.otherText = cfNoString ; param.otherText = cfNoString;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = style & wxNO_DEFAULT ? kAlertStdAlertOtherButton : kAlertStdAlertOKButton; param.defaultButton = style & wxNO_DEFAULT ? kAlertStdAlertOtherButton : kAlertStdAlertOKButton;
param.cancelButton = kAlertStdAlertCancelButton; param.cancelButton = kAlertStdAlertCancelButton;
} }
else else
{ {
param.defaultText = cfYesString ; param.defaultText = cfYesString;
param.cancelText = NULL; param.cancelText = NULL;
param.otherText = cfNoString ; param.otherText = cfNoString;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = style & wxNO_DEFAULT ? kAlertStdAlertOtherButton : kAlertStdAlertOKButton; param.defaultButton = style & wxNO_DEFAULT ? kAlertStdAlertOtherButton : kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
} }
// the msw implementation even shows an ok button if it is not specified, we'll do the same // the MSW implementation even shows an OK button if it is not specified, we'll do the same
else else
{ {
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
// thats a cancel missing // that's a cancel missing
param.defaultText = (CFStringRef) kAlertDefaultOKText ; param.defaultText = (CFStringRef) kAlertDefaultOKText;
param.cancelText = (CFStringRef) kAlertDefaultCancelText ; param.cancelText = (CFStringRef) kAlertDefaultCancelText;
param.otherText = NULL; param.otherText = NULL;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
else else
{ {
param.defaultText = (CFStringRef) kAlertDefaultOKText ; param.defaultText = (CFStringRef) kAlertDefaultOKText;
param.cancelText = NULL; param.cancelText = NULL;
param.otherText = NULL; param.otherText = NULL;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
} }
/* #if 0
else else
{ {
skipDialog = true ; skipDialog = true;
} }
*/ #endif
param.position = kWindowDefaultPosition; param.position = kWindowDefaultPosition;
if ( !skipDialog ) if ( !skipDialog )
{ {
DialogRef alertRef ; DialogRef alertRef;
CreateStandardAlert( alertType , cfTitle , cfText , &param , &alertRef ) ; CreateStandardAlert( alertType, cfTitle, cfText, &param, &alertRef );
RunStandardAlert( alertRef , NULL , &result ) ; RunStandardAlert( alertRef, NULL, &result );
}
else
{
return wxID_CANCEL;
} }
if ( skipDialog )
return wxID_CANCEL ;
} }
else else
#endif #endif
{ {
AlertStdAlertParamRec param; AlertStdAlertParamRec param;
Str255 yesPString, noPString;
Str255 pascalTitle, pascalText;
Str255 yesPString ; wxMacStringToPascal( m_caption, pascalTitle );
Str255 noPString ; wxMacStringToPascal( wxT("Yes"), yesPString );
wxMacStringToPascal( wxT("No"), noPString );
Str255 pascalTitle ; wxMacStringToPascal( m_message, pascalText );
Str255 pascalText ;
wxMacStringToPascal( m_caption , pascalTitle ) ;
wxMacStringToPascal( _("Yes") , yesPString ) ;
wxMacStringToPascal( _("No") , noPString ) ;
wxMacStringToPascal( m_message , pascalText ) ;
param.movable = true; param.movable = true;
param.filterProc = NULL ; param.filterProc = NULL;
if (style & wxYES_NO) if (style & wxYES_NO)
{ {
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
param.defaultText = yesPString ; param.defaultText = yesPString;
param.cancelText = (StringPtr) kAlertDefaultCancelText; param.cancelText = (StringPtr) kAlertDefaultCancelText;
param.otherText = noPString ; param.otherText = noPString;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = kAlertStdAlertCancelButton; param.cancelButton = kAlertStdAlertCancelButton;
} }
else else
{ {
param.defaultText = yesPString ; param.defaultText = yesPString;
param.cancelText = NULL; param.cancelText = NULL;
param.otherText = noPString ; param.otherText = noPString;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
@ -220,97 +224,74 @@ int wxMessageDialog::ShowModal()
{ {
if (style & wxCANCEL) if (style & wxCANCEL)
{ {
param.defaultText = (StringPtr) kAlertDefaultOKText ; param.defaultText = (StringPtr) kAlertDefaultOKText;
param.cancelText = (StringPtr) kAlertDefaultCancelText ; param.cancelText = (StringPtr) kAlertDefaultCancelText;
param.otherText = NULL; param.otherText = NULL;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
else else
{ {
param.defaultText = (StringPtr) kAlertDefaultOKText ; param.defaultText = (StringPtr) kAlertDefaultOKText;
param.cancelText = NULL; param.cancelText = NULL;
param.otherText = NULL; param.otherText = NULL;
param.helpButton = false ; param.helpButton = false;
param.defaultButton = kAlertStdAlertOKButton; param.defaultButton = kAlertStdAlertOKButton;
param.cancelButton = 0; param.cancelButton = 0;
} }
} }
else else
{ {
return resultbutton ; return resultbutton;
} }
param.position = 0; param.position = 0;
StandardAlert( alertType, pascalTitle, pascalText, &param, &result ); StandardAlert( alertType, pascalTitle, pascalText, &param, &result );
} }
if (style & wxOK) if (style & wxOK)
{ {
if (style & wxCANCEL) switch ( result )
{ {
//TODO add Cancelbutton case 1:
switch( result ) resultbutton = wxID_OK;
{ break;
case 1 :
resultbutton = wxID_OK ; case 2:
break ; // TODO: add Cancel button
case 2 : // if (style & wxCANCEL)
break ; // resultbutton = wxID_CANCEL;
case 3 : break;
break ;
} case 3:
} default:
else break;
{
switch( result )
{
case 1 :
resultbutton = wxID_OK ;
break ;
case 2 :
break ;
case 3 :
break ;
}
} }
} }
else if (style & wxYES_NO) else if (style & wxYES_NO)
{ {
if (style & wxCANCEL) switch ( result )
{ {
switch( result ) case 1:
{ resultbutton = wxID_YES;
case 1 : break;
resultbutton = wxID_YES ;
break ; case 2:
case 2 : if (!(style & wxCANCEL))
resultbutton = wxID_CANCEL ; resultbutton = wxID_CANCEL;
break ; break;
case 3 :
resultbutton = wxID_NO ; case 3:
break ; resultbutton = wxID_NO;
} break;
}
else default:
{ break;
switch( result )
{
case 1 :
resultbutton = wxID_YES ;
break ;
case 2 :
break ;
case 3 :
resultbutton = wxID_NO ;
break ;
}
} }
} }
#endif #endif
return resultbutton ; return resultbutton;
} }

174
src/mac/carbon/taskbar.cpp
View File

@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: taskbar.cpp // Name: src/mac/carbon/taskbar.cpp
// Purpose: wxTaskBarIcon - OSX implementation // Purpose: wxTaskBarIcon
// Author: Ryan Norton // Author: Ryan Norton
// Modified by: // Modified by:
// Created: 09/25/2004 // Created: 09/25/2004
@ -9,14 +9,6 @@
// Licence: wxWindows licence // Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
//=============================================================================
// Declarations
//=============================================================================
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef wxHAS_TASK_BAR_ICON #ifdef wxHAS_TASK_BAR_ICON
@ -28,12 +20,6 @@
#include "wx/icon.h" #include "wx/icon.h"
#include "wx/dcmemory.h" #include "wx/dcmemory.h"
//-----------------------------------------------------------------------------
//
// wxTaskBarIconImpl
//
// Superclass of wxTaskBarIcon implementations
//-----------------------------------------------------------------------------
class wxTaskBarIconImpl class wxTaskBarIconImpl
{ {
@ -46,11 +32,11 @@ public:
virtual bool RemoveIcon() = 0; virtual bool RemoveIcon() = 0;
virtual bool PopupMenu(wxMenu *menu) = 0; virtual bool PopupMenu(wxMenu *menu) = 0;
wxMenu* CreatePopupMenu() wxMenu * CreatePopupMenu()
{ return m_parent->CreatePopupMenu(); } { return m_parent->CreatePopupMenu(); }
wxTaskBarIcon* m_parent; wxTaskBarIcon *m_parent;
class wxTaskBarIconWindow* m_menuEventWindow; class wxTaskBarIconWindow *m_menuEventWindow;
DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl) DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)
}; };
@ -60,19 +46,19 @@ public:
// wxTaskBarIconWindow // wxTaskBarIconWindow
// //
// Event handler for menus // 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... // a top level window...
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxTaskBarIconWindow : public wxTopLevelWindow class wxTaskBarIconWindow : public wxTopLevelWindow
{ {
public: public:
wxTaskBarIconWindow(wxTaskBarIconImpl* impl) wxTaskBarIconWindow(wxTaskBarIconImpl *impl)
: wxTopLevelWindow(NULL, -1, wxT("")), m_impl(impl) : wxTopLevelWindow(NULL, -1, wxT("")), m_impl(impl)
{ {
Connect(-1, wxEVT_COMMAND_MENU_SELECTED, Connect(
wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent) -1, wxEVT_COMMAND_MENU_SELECTED,
); wxCommandEventHandler(wxTaskBarIconWindow::OnMenuEvent) );
} }
void OnMenuEvent(wxCommandEvent& event) void OnMenuEvent(wxCommandEvent& event)
@ -81,15 +67,9 @@ public:
} }
private: private:
wxTaskBarIconImpl* m_impl; wxTaskBarIconImpl *m_impl;
}; };
//-----------------------------------------------------------------------------
//
// wxDockBarIconImpl
//
//-----------------------------------------------------------------------------
class wxDockTaskBarIcon : public wxTaskBarIconImpl class wxDockTaskBarIcon : public wxTaskBarIconImpl
{ {
public: public:
@ -105,45 +85,30 @@ public:
EventHandlerRef m_eventHandlerRef; EventHandlerRef m_eventHandlerRef;
EventHandlerUPP m_eventupp; EventHandlerUPP m_eventupp;
wxWindow* m_eventWindow; wxWindow *m_eventWindow;
wxMenu* m_pMenu; wxMenu *m_pMenu;
MenuRef m_theLastMenu; MenuRef m_theLastMenu;
bool m_iconAdded; bool m_iconAdded;
}; };
// Forward declarations for utility functions for dock implementation // Forward declarations for utility functions for dock implementation
pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef, pascal OSStatus wxDockEventHandler(
EventRef inEvent, void* pData); EventHandlerCallRef inHandlerCallRef,
wxMenu* wxDeepCopyMenu(wxMenu* menu); EventRef inEvent, void* pData );
wxMenu * wxDeepCopyMenu( wxMenu *menu );
//=============================================================================
//
// Implementation
//
//=============================================================================
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// //
// wxTaskBarIconImpl // wxTaskBarIconImpl
// //
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-----------------------------------------------------------------------------
// 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() wxTaskBarIconImpl::~wxTaskBarIconImpl()
{ {
delete m_menuEventWindow; delete m_menuEventWindow;
@ -153,19 +118,19 @@ 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: // We need this for two reasons:
// 1) To handle wxTaskBarIcon menu events (see below for why) // 1) To handle wxTaskBarIcon menu events (see below for why)
// 2) To handle events from the dock when it requests a menu // 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 // Get the parameters we want from the event
wxDockTaskBarIcon* pTB = (wxDockTaskBarIcon*) pData; wxDockTaskBarIcon* pTB = (wxDockTaskBarIcon*) pData;
@ -174,14 +139,12 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
// Handle wxTaskBar menu events (note that this is a global event handler // Handle wxTaskBar menu events (note that this is a global event handler
// so it will actually get called by all commands/menus) // 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 == NULL) if (pTB->m_pMenu == NULL)
return eventNotHandledErr; return eventNotHandledErr;
//
// This is the real reason why we need this. Normally menus // This is the real reason why we need this. Normally menus
// get handled in wxMacAppEventHandler // get handled in wxMacAppEventHandler
// //
@ -191,15 +154,15 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
// However, in the case of a taskbar menu call // However, in the case of a taskbar menu call
// command.menu.menuRef IS NULL! // command.menu.menuRef IS NULL!
// Which causes the wxApp handler just to skip it. // 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());
OSErr err; OSStatus err;
// get the HICommand from the event // get the HICommand from the event
HICommand command; HICommand command;
err = GetEventParameter(inEvent, kEventParamDirectObject, err = GetEventParameter(
inEvent, kEventParamDirectObject,
typeHICommand, NULL, typeHICommand, NULL,
sizeof(HICommand), NULL, &command); 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
@ -207,34 +170,33 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
// NOTE: menuRef is generally used here for submenus, as // NOTE: menuRef is generally used here for submenus, as
// GetMenuItemRefCon could give an incorrect wxMenuItem if we pass // GetMenuItemRefCon could give an incorrect wxMenuItem if we pass
// just the top level wxTaskBar menu // just the top level wxTaskBar menu
//
MenuItemIndex menuItemIndex; MenuItemIndex menuItemIndex;
MenuRef menuRef; MenuRef menuRef;
err = GetIndMenuItemWithCommandID(taskbarMenuRef, err = GetIndMenuItemWithCommandID(
taskbarMenuRef,
command.commandID, command.commandID,
1, &menuRef, &menuItemIndex); 1, &menuRef, &menuItemIndex );
if (err == noErr) if (err == noErr)
{ {
MenuCommand id = command.commandID; 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) if (item)
{ {
// Handle items that are checkable // Handle items that are checkable
// FIXME: Doesn't work (at least on 10.2)! // FIXME: Doesn't work (at least on 10.2)!
if (item->IsCheckable()) 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->GetMenu()->SendEvent( id, item->IsCheckable() ? item->IsChecked() : -1 );
item->IsCheckable() ?
item->IsChecked() : -1 // successfully handled the event
); err = noErr;
err = noErr; // successfully handled the event
} }
} }
} //end if noErr on getting HICommand from event } //end if noErr on getting HICommand from event
@ -251,10 +213,10 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
// process the right click events // process the right click events
// NB: This may result in double or even triple-creation of the menus // NB: This may result in double or even triple-creation of the menus
// We need to do this for 2.4 compat, however // 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
@ -273,15 +235,16 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
RetainMenu(hMenu); RetainMenu(hMenu);
// set the actual dock menu // set the actual dock menu
err = SetEventParameter(inEvent, kEventParamMenuRef, err = SetEventParameter(
typeMenuRef, sizeof(MenuRef), &hMenu); inEvent, kEventParamMenuRef,
wxASSERT(err == noErr); typeMenuRef, sizeof(MenuRef), &hMenu );
verify_noerr( err );
} }
return err; return err;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //-----------------------------------------------------------------------------
// wxDeepCopyMenu // wxDeepCopyMenu
// //
// Performs a top-to-bottom copy of the input menu and all of its // Performs a top-to-bottom copy of the input menu and all of its
@ -289,18 +252,17 @@ pascal OSStatus wxDockEventHandler( EventHandlerCallRef inHandlerCallRef,
// //
// This is mostly needed for 2.4 compatability. However wxPython and others // This is mostly needed for 2.4 compatability. However wxPython and others
// still use this way of setting the taskbarmenu. // 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, // NB: Here we have to perform a deep copy of the menu,
// copying each and every menu item from menu to m_pMenu. // 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 // and have no way at all to idle it while the dock menu
// is being shown before menu goes out of scope (it may // is being shown before menu goes out of scope (it may
// not be on the heap, and may expire right after this function // not be on the heap, and may expire right after this function
@ -310,14 +272,13 @@ wxMenu* wxDeepCopyMenu(wxMenu* menu)
// 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 // on either wxMenu or wxMenuItem, we have to do all the
// dirty work ourselves. // dirty work ourselves.
//
// perform a deep copy of the menu // perform a deep copy of the menu
wxMenuItemList& theList = menu->GetMenuItems(); wxMenuItemList& theList = menu->GetMenuItems();
wxMenuItemList::compatibility_iterator theNode = theList.GetFirst(); 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) while (theNode != NULL)
{ {
@ -329,8 +290,8 @@ wxMenu* wxDeepCopyMenu(wxMenu* menu)
theItem->GetText(), // text label theItem->GetText(), // text label
theItem->GetHelp(), // status bar help string theItem->GetHelp(), // status bar help string
theItem->GetKind(), // menu flags - checkable, separator, etc. theItem->GetKind(), // menu flags - checkable, separator, etc.
wxDeepCopyMenu(theItem->GetSubMenu()) // submenu wxDeepCopyMenu(theItem->GetSubMenu()) )); // submenu
));
theNode = theNode->GetNext(); theNode = theNode->GetNext();
} }
@ -342,7 +303,7 @@ wxMenu* wxDeepCopyMenu(wxMenu* menu)
// //
// 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),
@ -359,14 +320,11 @@ wxDockTaskBarIcon::wxDockTaskBarIcon(wxTaskBarIcon* parent)
m_eventupp = NewEventHandlerUPP(wxDockEventHandler); m_eventupp = NewEventHandlerUPP(wxDockEventHandler);
wxASSERT(m_eventupp != NULL); wxASSERT(m_eventupp != NULL);
#ifdef __WXDEBUG__ OSStatus err = InstallApplicationEventHandler(
OSStatus err =
#endif
InstallApplicationEventHandler(
m_eventupp, m_eventupp,
GetEventTypeCount(tbEventList), tbEventList, GetEventTypeCount(tbEventList), tbEventList,
this, &m_eventHandlerRef); this, &m_eventHandlerRef);
wxASSERT( err == noErr ); verify_noerr( err );
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -390,7 +348,7 @@ wxDockTaskBarIcon::~wxDockTaskBarIcon()
// 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 // get the menu from the parent
wxMenu* theNewMenu = CreatePopupMenu(); wxMenu* theNewMenu = CreatePopupMenu();
@ -431,7 +389,7 @@ bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{ {
// convert the wxIcon into a wxBitmap so we can perform some // convert the wxIcon into a wxBitmap so we can perform some
// wxBitmap operations with it // wxBitmap operations with it
wxBitmap bmp( icon ) ; wxBitmap bmp( icon );
wxASSERT( bmp.Ok() ); wxASSERT( bmp.Ok() );
// get the CGImageRef for the wxBitmap: // get the CGImageRef for the wxBitmap:
@ -441,7 +399,7 @@ bool wxDockTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
// actually set the dock image // actually set the dock image
OSStatus err = SetApplicationDockTileImage( pImage ); OSStatus err = SetApplicationDockTileImage( pImage );
wxASSERT( err == noErr ); verify_noerr( err );
// free the CGImage, now that it's referenced by the dock // free the CGImage, now that it's referenced by the dock
if (pImage != NULL) if (pImage != NULL)
@ -468,10 +426,10 @@ bool wxDockTaskBarIcon::RemoveIcon()
// restore old icon to the dock // restore old icon to the dock
OSStatus err = RestoreApplicationDockTileImage(); 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); bool success = (err == noErr);
m_iconAdded = !success; m_iconAdded = !success;
@ -495,10 +453,10 @@ bool wxDockTaskBarIcon::PopupMenu(wxMenu *menu)
if (m_pMenu) if (m_pMenu)
delete 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); m_pMenu->SetInvokingWindow(m_menuEventWindow);
return true; return true;
@ -524,9 +482,10 @@ IMPLEMENT_DYNAMIC_CLASS(wxTaskBarIcon, wxEvtHandler)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType nType) wxTaskBarIcon::wxTaskBarIcon(wxTaskBarIconType nType)
{ {
wxASSERT_MSG(nType == DOCK, wxASSERT_MSG(
wxT("Only the DOCK implementation of wxTaskBarIcon") nType == DOCK,
wxT("on mac carbon is currently supported!")); wxT("Only the DOCK implementation of wxTaskBarIcon on Mac-Carbon is currently supported!") );
m_impl = new wxDockTaskBarIcon(this); m_impl = new wxDockTaskBarIcon(this);
} }
@ -549,11 +508,14 @@ wxTaskBarIcon::~wxTaskBarIcon()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool wxTaskBarIcon::IsIconInstalled() const bool wxTaskBarIcon::IsIconInstalled() const
{ return m_impl->IsIconInstalled(); } { return m_impl->IsIconInstalled(); }
bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip) bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{ return m_impl->SetIcon(icon, 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) bool wxTaskBarIcon::PopupMenu(wxMenu *menu)
{ return m_impl->PopupMenu(menu); } { return m_impl->PopupMenu(menu); }
#endif //wxHAS_TASK_BAR_ICON #endif // wxHAS_TASK_BAR_ICON