[wxWidgets.git] / src / x11 / menu.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        menu.cpp
// Purpose:     wxMenu, wxMenuBar, wxMenuItem
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


// ============================================================================
// declarations
// ============================================================================

#ifdef __GNUG__
    #pragma implementation "menu.h"
#endif

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/defs.h"

#include "wx/menu.h"
#include "wx/menuitem.h"
#include "wx/log.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/frame.h"
#include "wx/settings.h"

#ifdef __VMS__
#pragma message disable nosimpint
#define XtDisplay XTDISPLAY
#define XtWindow XTWINDOW
#endif
#include <Xm/Label.h>
#include <Xm/LabelG.h>
#include <Xm/CascadeBG.h>
#include <Xm/CascadeB.h>
#include <Xm/SeparatoG.h>
#include <Xm/PushBG.h>
#include <Xm/ToggleB.h>
#include <Xm/ToggleBG.h>
#include <Xm/RowColumn.h>
#ifdef __VMS__
#pragma message enable nosimpint
#endif

#include "wx/motif/private.h"

// other standard headers
#include <string.h>

IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// Menus
// ----------------------------------------------------------------------------

// Construct a menu with optional title (then use append)
void wxMenu::Init()
{
    // Motif-specific members
    m_numColumns = 1;
    m_menuWidget = (WXWidget) NULL;
    m_popupShell = (WXWidget) NULL;
    m_buttonWidget = (WXWidget) NULL;
    m_menuId = 0;
    m_topLevelMenu  = (wxMenu*) NULL;
    m_ownedByMenuBar = FALSE;

    if ( !!m_title )
    {
        Append(wxID_SEPARATOR, m_title) ;
        AppendSeparator() ;
    }

    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
    m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUTEXT);
    m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
}

// The wxWindow destructor will take care of deleting the submenus.
wxMenu::~wxMenu()
{
    if (m_menuWidget)
    {
        if (m_menuParent)
            DestroyMenu(TRUE);
        else
            DestroyMenu(FALSE);
    }

    // Not sure if this is right
    if (m_menuParent && m_menuBar)
    {
        m_menuParent = NULL;
        //      m_menuBar = NULL;
    }
}

void wxMenu::Break()
{
    m_numColumns++;
}

// function appends a new item or submenu to the menu
bool wxMenu::DoAppend(wxMenuItem *pItem)
{
    if (m_menuWidget)
    {
        // this is a dynamic Append
        pItem->CreateItem(m_menuWidget, m_menuBar, m_topLevelMenu);
    }

    if ( pItem->IsSubMenu() )
    {
        pItem->GetSubMenu()->m_topLevelMenu = m_topLevelMenu;
    }

    return wxMenuBase::DoAppend(pItem);
}

wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
{
    item->DestroyItem(TRUE);

    return wxMenuBase::DoRemove(item);
}

bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
{
    if ( !wxMenuBase::DoInsert(pos, item) )
        return FALSE;

    wxFAIL_MSG(wxT("not implemented"));

    return FALSE;
}

void wxMenu::SetTitle(const wxString& label)
{
    m_title = label;

    wxMenuItemList::Node *node = GetMenuItems().GetFirst();
    if ( !node )
        return;

    wxMenuItem *item = node->GetData ();
    Widget widget = (Widget) item->GetButtonWidget();
    if ( !widget )
        return;

    wxXmString title_str(label);
    XtVaSetValues(widget,
                  XmNlabelString, title_str(),
                  NULL);
}

bool wxMenu::ProcessCommand(wxCommandEvent & event)
{
    bool processed = FALSE;

#if wxUSE_MENU_CALLBACK
    // Try a callback
    if (m_callback)
    {
        (void) (*(m_callback)) (*this, event);
        processed = TRUE;
    }
#endif // wxUSE_MENU_CALLBACK

    // Try the menu's event handler
    if ( !processed && GetEventHandler())
    {
        processed = GetEventHandler()->ProcessEvent(event);
    }
    // Try the window the menu was popped up from (and up
    // through the hierarchy)
    if ( !processed && GetInvokingWindow())
        processed = GetInvokingWindow()->ProcessEvent(event);

    return processed;
}

// ----------------------------------------------------------------------------
// Menu Bar
// ----------------------------------------------------------------------------

void wxMenuBar::Init()
{
    m_eventHandler = this;
    m_menuBarFrame = NULL;
    m_mainWidget = (WXWidget) NULL;
    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
    m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUTEXT);
    m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
}

wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
{
    Init();

    for ( int i = 0; i < n; i++ )
    {
        m_menus.Append(menus[i]);
        m_titles.Add(titles[i]);
    }
}

wxMenuBar::~wxMenuBar()
{
    // nothing to do: wxMenuBarBase will delete the menus
}

void wxMenuBar::EnableTop(size_t WXUNUSED(pos), bool WXUNUSED(flag))
{
  //    wxFAIL_MSG("TODO");
//  wxLogWarning("wxMenuBar::EnableTop not yet implemented.");
}

void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
{
    wxMenu *menu = GetMenu(pos);
    if ( !menu )
        return;

    Widget w = (Widget)menu->GetButtonWidget();
    if (w)
    {
        wxXmString label_str(label);

        XtVaSetValues(w,
                      XmNlabelString, label_str(),
                      NULL);
    }
}

wxString wxMenuBar::GetLabelTop(size_t pos) const
{
    wxString str;

    wxMenu *menu = GetMenu(pos);
    if ( menu )
    {
        Widget w = (Widget)menu->GetButtonWidget();
        if (w)
        {
            XmString text;
            XtVaGetValues(w,
                          XmNlabelString, &text,
                          NULL);

            char *s;
            if ( XmStringGetLtoR(text, XmSTRING_DEFAULT_CHARSET, &s) )
            {
                str = s;

                XtFree(s);
            }
        }
    }

    return str;
}

bool wxMenuBar::Append(wxMenu * menu, const wxString& title)
{
    wxCHECK_MSG( menu, FALSE, wxT("invalid menu") );
    wxCHECK_MSG( !menu->GetParent() && !menu->GetButtonWidget(), FALSE,
                 wxT("menu already appended") );

    if ( m_menuBarFrame )
    {
        WXWidget w = menu->CreateMenu(this, GetMainWidget(), menu, title, TRUE);
        wxCHECK_MSG( w, FALSE, wxT("failed to create menu") );
        menu->SetButtonWidget(w);
    }

    //menu->SetMenuBar(this);

    m_titles.Add(title);

    return wxMenuBarBase::Append(menu, title);
}

bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
{
    if ( !wxMenuBarBase::Insert(pos, menu, title) )
        return FALSE;

    wxFAIL_MSG(wxT("TODO"));

    return FALSE;
}

wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
{
    if ( !wxMenuBarBase::Replace(pos, menu, title) )
        return FALSE;

    wxFAIL_MSG(wxT("TODO"));

    return NULL;
}

wxMenu *wxMenuBar::Remove(size_t pos)
{
    wxMenu *menu = wxMenuBarBase::Remove(pos);
    if ( !menu )
        return NULL;

    if ( m_menuBarFrame )
        menu->DestroyMenu(TRUE);

    menu->SetMenuBar(NULL);

    m_titles.Remove(pos);

    return menu;
}

// Find the menu menuString, item itemString, and return the item id.
// Returns -1 if none found.
int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
{
    char buf1[200];
    char buf2[200];
    wxStripMenuCodes ((char *)(const char *)menuString, buf1);

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
    {
        wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
        if (strcmp (buf1, buf2) == 0)
            return m_menus[i]->FindItem (itemString);
    }
    return -1;
}

wxMenuItem *wxMenuBar::FindItem(int id, wxMenu ** itemMenu) const
{
    if (itemMenu)
        *itemMenu = NULL;

    wxMenuItem *item = NULL;
    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
        if ((item = m_menus[i]->FindItem(id, itemMenu)))
            return item;
        return NULL;
}

// Create menubar
bool wxMenuBar::CreateMenuBar(wxFrame* parent)
{
    if (m_mainWidget)
    {
        XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
        /*
        if (!XtIsManaged((Widget) m_mainWidget))
        XtManageChild((Widget) m_mainWidget);
        */
        XtMapWidget((Widget) m_mainWidget);
        return TRUE;
    }

    Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWidget(), "MenuBar", NULL, 0);
    m_mainWidget = (WXWidget) menuBarW;

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
    {
        wxMenu *menu = GetMenu(i);
        wxString title(m_titles[i]);
        menu->SetButtonWidget(menu->CreateMenu (this, menuBarW, menu, title, TRUE));

        if (strcmp (wxStripMenuCodes(title), "Help") == 0)
            XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);

        // tear off menu support
#if (XmVersion >= 1002)
        if ( menu->IsTearOff() )
        {
            XtVaSetValues(GetWidget(menu),
                          XmNtearOffModel, XmTEAR_OFF_ENABLED,
                          NULL);
            Widget tearOff = XmGetTearOffControl(GetWidget(menu));
            wxDoChangeForegroundColour((Widget) tearOff, m_foregroundColour);
            wxDoChangeBackgroundColour((Widget) tearOff, m_backgroundColour, TRUE);
#endif
        }
    }

    SetBackgroundColour(m_backgroundColour);
    SetForegroundColour(m_foregroundColour);
    SetFont(m_font);

    XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
    XtRealizeWidget ((Widget) menuBarW);
    XtManageChild ((Widget) menuBarW);
    SetMenuBarFrame(parent);

    return TRUE;
}

// Destroy menubar, but keep data structures intact so we can recreate it.
bool wxMenuBar::DestroyMenuBar()
{
    if (!m_mainWidget)
    {
        SetMenuBarFrame((wxFrame*) NULL);
        return FALSE;
    }

    XtUnmanageChild ((Widget) m_mainWidget);
    XtUnrealizeWidget ((Widget) m_mainWidget);

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
    {
        wxMenu *menu = GetMenu(i);
        menu->DestroyMenu(TRUE);

    }
    XtDestroyWidget((Widget) m_mainWidget);
    m_mainWidget = (WXWidget) 0;

    SetMenuBarFrame((wxFrame*) NULL);

    return TRUE;
}

//// Motif-specific
static XtWorkProcId WorkProcMenuId;

/* Since PopupMenu under Motif stills grab right mouse button events
* after it was closed, we need to delete the associated widgets to
* allow next PopUpMenu to appear...
*/

int PostDeletionOfMenu( XtPointer* clientData )
{
    XtRemoveWorkProc(WorkProcMenuId);
    wxMenu *menu = (wxMenu *)clientData;

    if (menu->GetMainWidget())
    {
        wxMenu *menuParent = menu->GetParent();
        if ( menuParent )
        {
            wxMenuItemList::Node *node = menuParent->GetMenuItems().GetFirst();
            while ( node )
            {
                if ( node->GetData()->GetSubMenu() == menu )
                {
                    menuParent->GetMenuItems().DeleteNode(node);

                    break;
                }

                node = node->GetNext();
            }
        }

        menu->DestroyMenu(TRUE);
    }

    // Mark as no longer popped up
    menu->m_menuId = -1;

    return TRUE;
}

void
wxMenuPopdownCallback(Widget WXUNUSED(w), XtPointer clientData,
                      XtPointer WXUNUSED(ptr))
{
    wxMenu *menu = (wxMenu *)clientData;

    // Added by JOREL Jean-Charles <jjorel@silr.ireste.fr>
    /* Since Callbacks of MenuItems are not yet processed, we put a
    * background job which will be done when system will be idle.
    * What awful hack!! :(
    */

    WorkProcMenuId = XtAppAddWorkProc(
        (XtAppContext) wxTheApp->GetAppContext(),
        (XtWorkProc) PostDeletionOfMenu,
        (XtPointer) menu );
    // Apparently not found in Motif headers
    //  XtVaSetValues( w, XmNpopupEnabled, XmPOPUP_DISABLED, NULL );
}

/*
* Create a popup or pulldown menu.
* Submenus of a popup will be pulldown.
*
*/

WXWidget wxMenu::CreateMenu (wxMenuBar * menuBar, WXWidget parent, wxMenu * topMenu, const wxString& title, bool pullDown)
{
    Widget menu = (Widget) 0;
    Widget buttonWidget = (Widget) 0;
    Arg args[5];
    XtSetArg (args[0], XmNnumColumns, m_numColumns);
    XtSetArg (args[1], XmNpacking, XmPACK_COLUMN);

    if (!pullDown)
    {
        menu = XmCreatePopupMenu ((Widget) parent, "popup", args, 2);
        XtAddCallback(menu,
            XmNunmapCallback,
            (XtCallbackProc)wxMenuPopdownCallback,
            (XtPointer)this);
    }
    else
    {
        char mnem = wxFindMnemonic (title);
        wxStripMenuCodes ((char*) (const char*) title, wxBuffer);

        menu = XmCreatePulldownMenu ((Widget) parent, "pulldown", args, 2);

        wxString title2(wxStripMenuCodes(title));
        wxXmString label_str(title2);
        buttonWidget = XtVaCreateManagedWidget(title2,
#if wxUSE_GADGETS
            xmCascadeButtonGadgetClass, (Widget) parent,
#else
            xmCascadeButtonWidgetClass, (Widget) parent,
#endif
            XmNlabelString, label_str(),
            XmNsubMenuId, menu,
            NULL);

        if (mnem != 0)
            XtVaSetValues (buttonWidget, XmNmnemonic, mnem, NULL);
    }

    m_menuWidget = (WXWidget) menu;

    m_menuBar = menuBar;
    m_topLevelMenu = topMenu;

    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem *item = node->GetData();

        item->CreateItem(menu, menuBar, topMenu);
    }

    SetBackgroundColour(m_backgroundColour);
    SetForegroundColour(m_foregroundColour);
    SetFont(m_font);

    return buttonWidget;
}

// Destroys the Motif implementation of the menu,
// but maintains the wxWindows data structures so we can
// do a CreateMenu again.
void wxMenu::DestroyMenu (bool full)
{
    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem *item = node->GetData();
        item->SetMenuBar((wxMenuBar*) NULL);

        item->DestroyItem(full);
    }

    if (m_buttonWidget)
    {
        if (full)
        {
            XtVaSetValues((Widget) m_buttonWidget, XmNsubMenuId, NULL, NULL);
            XtDestroyWidget ((Widget) m_buttonWidget);
            m_buttonWidget = (WXWidget) 0;
        }
    }
    if (m_menuWidget && full)
    {
        XtDestroyWidget((Widget) m_menuWidget);
        m_menuWidget = (WXWidget) NULL;
    }
}

WXWidget wxMenu::FindMenuItem (int id, wxMenuItem ** it) const
{
    if (id == m_menuId)
    {
        if (it)
            *it = (wxMenuItem*) NULL;
        return m_buttonWidget;
    }

    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem *item = node->GetData ();
        if (item->GetId() == id)
        {
            if (it)
                *it = item;
            return item->GetButtonWidget();
        }

        if (item->GetSubMenu())
        {
            WXWidget w = item->GetSubMenu()->FindMenuItem (id, it);
            if (w)
            {
                return w;
            }
        }
    }

    if (it)
        *it = (wxMenuItem*) NULL;
    return (WXWidget) NULL;
}

void wxMenu::SetBackgroundColour(const wxColour& col)
{
    m_backgroundColour = col;
    if (m_menuWidget)
        wxDoChangeBackgroundColour(m_menuWidget, (wxColour&) col);
    if (m_buttonWidget)
        wxDoChangeBackgroundColour(m_buttonWidget, (wxColour&) col, TRUE);

    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem* item = node->GetData();
        if (item->GetButtonWidget())
        {
            // This crashes because it uses gadgets
            //            wxDoChangeBackgroundColour(item->GetButtonWidget(), (wxColour&) col, TRUE);
        }
        if (item->GetSubMenu())
            item->GetSubMenu()->SetBackgroundColour((wxColour&) col);
    }
}

void wxMenu::SetForegroundColour(const wxColour& col)
{
    m_foregroundColour = col;
    if (m_menuWidget)
        wxDoChangeForegroundColour(m_menuWidget, (wxColour&) col);
    if (m_buttonWidget)
        wxDoChangeForegroundColour(m_buttonWidget, (wxColour&) col);

    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem* item = node->GetData();
        if (item->GetButtonWidget())
        {
            // This crashes because it uses gadgets
            //            wxDoChangeForegroundColour(item->GetButtonWidget(), (wxColour&) col);
        }
        if (item->GetSubMenu())
            item->GetSubMenu()->SetForegroundColour((wxColour&) col);
    }
}

void wxMenu::ChangeFont(bool keepOriginalSize)
{
    // lesstif 0.87 hangs when setting XmNfontList
#ifndef LESSTIF_VERSION
    if (!m_font.Ok() || !m_menuWidget)
        return;

    XmFontList fontList = (XmFontList) m_font.GetFontList(1.0, XtDisplay((Widget) m_menuWidget));

    XtVaSetValues ((Widget) m_menuWidget,
        XmNfontList, fontList,
        NULL);
    if (m_buttonWidget)
    {
        XtVaSetValues ((Widget) m_buttonWidget,
            XmNfontList, fontList,
            NULL);
    }

    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxMenuItem* item = node->GetData();
        if (m_menuWidget && item->GetButtonWidget() && m_font.Ok())
        {
            XtVaSetValues ((Widget) item->GetButtonWidget(),
                XmNfontList, fontList,
                NULL);
        }
        if (item->GetSubMenu())
            item->GetSubMenu()->ChangeFont(keepOriginalSize);
    }
#endif
}

void wxMenu::SetFont(const wxFont& font)
{
    m_font = font;
    ChangeFont();
}

bool wxMenuBar::SetBackgroundColour(const wxColour& col)
{
    m_backgroundColour = col;
    if (m_mainWidget)
        wxDoChangeBackgroundColour(m_mainWidget, (wxColour&) col);

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
        m_menus[i]->SetBackgroundColour((wxColour&) col);

    return TRUE;
}

bool wxMenuBar::SetForegroundColour(const wxColour& col)
{
    m_foregroundColour = col;
    if (m_mainWidget)
        wxDoChangeForegroundColour(m_mainWidget, (wxColour&) col);

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
        m_menus[i]->SetForegroundColour((wxColour&) col);

    return TRUE;
}

void wxMenuBar::ChangeFont(bool WXUNUSED(keepOriginalSize))
{
    // Nothing to do for menubar, fonts are kept in wxMenus
}

bool wxMenuBar::SetFont(const wxFont& font)
{
    m_font = font;
    ChangeFont();

    size_t menuCount = GetMenuCount();
    for (size_t i = 0; i < menuCount; i++)
        m_menus[i]->SetFont(font);

    return TRUE;
}
Commit	Line	Data
83df96d6 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: menu.cpp
	3	// Purpose: wxMenu, wxMenuBar, wxMenuItem
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12
	13	// ============================================================================
	14	// declarations
	15	// ============================================================================
	16
	17	#ifdef __GNUG__
	18	#pragma implementation "menu.h"
	19	#endif
	20
	21	// ----------------------------------------------------------------------------
	22	// headers
	23	// ----------------------------------------------------------------------------
	24
	25	#include "wx/defs.h"
	26
	27	#include "wx/menu.h"
	28	#include "wx/menuitem.h"
	29	#include "wx/log.h"
	30	#include "wx/utils.h"
	31	#include "wx/app.h"
	32	#include "wx/frame.h"
	33	#include "wx/settings.h"
	34
	35	#ifdef __VMS__
	36	#pragma message disable nosimpint
	37	#define XtDisplay XTDISPLAY
	38	#define XtWindow XTWINDOW
	39	#endif
	40	#include <Xm/Label.h>
	41	#include <Xm/LabelG.h>
	42	#include <Xm/CascadeBG.h>
	43	#include <Xm/CascadeB.h>
	44	#include <Xm/SeparatoG.h>
	45	#include <Xm/PushBG.h>
	46	#include <Xm/ToggleB.h>
	47	#include <Xm/ToggleBG.h>
	48	#include <Xm/RowColumn.h>
	49	#ifdef __VMS__
	50	#pragma message enable nosimpint
	51	#endif
	52
	53	#include "wx/motif/private.h"
	54
	55	// other standard headers
	56	#include <string.h>
	57
	58	IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
	59	IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
	60
	61	// ============================================================================
	62	// implementation
	63	// ============================================================================
	64
65	// ----------------------------------------------------------------------------
66	// Menus
67	// ----------------------------------------------------------------------------
68
69	// Construct a menu with optional title (then use append)
70	void wxMenu::Init()
71	{
72	// Motif-specific members
73	m_numColumns = 1;
74	m_menuWidget = (WXWidget) NULL;
75	m_popupShell = (WXWidget) NULL;
76	m_buttonWidget = (WXWidget) NULL;
77	m_menuId = 0;
78	m_topLevelMenu = (wxMenu*) NULL;
79	m_ownedByMenuBar = FALSE;
80
81	if ( !!m_title )
82	{
83	Append(wxID_SEPARATOR, m_title) ;
84	AppendSeparator() ;
85	}
86
87	m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
88	m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUTEXT);
89	m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
90	}
91
92	// The wxWindow destructor will take care of deleting the submenus.
93	wxMenu::~wxMenu()
94	{
95	if (m_menuWidget)
96	{
97	if (m_menuParent)
98	DestroyMenu(TRUE);
99	else
100	DestroyMenu(FALSE);
101	}
102
103	// Not sure if this is right
104	if (m_menuParent && m_menuBar)
105	{
106	m_menuParent = NULL;
107	// m_menuBar = NULL;
108	}
109	}
110
111	void wxMenu::Break()
112	{
113	m_numColumns++;
114	}
115
116	// function appends a new item or submenu to the menu
117	bool wxMenu::DoAppend(wxMenuItem *pItem)
118	{
119	if (m_menuWidget)
120	{
121	// this is a dynamic Append
122	pItem->CreateItem(m_menuWidget, m_menuBar, m_topLevelMenu);
123	}
124
125	if ( pItem->IsSubMenu() )
126	{
127	pItem->GetSubMenu()->m_topLevelMenu = m_topLevelMenu;
128	}
129
130	return wxMenuBase::DoAppend(pItem);
131	}
132
133	wxMenuItem wxMenu::DoRemove(wxMenuItem item)
134	{
135	item->DestroyItem(TRUE);
136
137	return wxMenuBase::DoRemove(item);
138	}
139
140	bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
141	{
142	if ( !wxMenuBase::DoInsert(pos, item) )
143	return FALSE;
144
145	wxFAIL_MSG(wxT("not implemented"));
146
147	return FALSE;
148	}
149
150	void wxMenu::SetTitle(const wxString& label)
151	{
152	m_title = label;
153
154	wxMenuItemList::Node *node = GetMenuItems().GetFirst();
155	if ( !node )
156	return;
157
158	wxMenuItem *item = node->GetData ();
159	Widget widget = (Widget) item->GetButtonWidget();
160	if ( !widget )
161	return;
162
163	wxXmString title_str(label);
164	XtVaSetValues(widget,
165	XmNlabelString, title_str(),
166	NULL);
167	}
168
169	bool wxMenu::ProcessCommand(wxCommandEvent & event)
170	{
171	bool processed = FALSE;
172
173	#if wxUSE_MENU_CALLBACK
174	// Try a callback
175	if (m_callback)
176	{
177	(void) ((m_callback)) (this, event);
178	processed = TRUE;
179	}
180	#endif // wxUSE_MENU_CALLBACK
181
182	// Try the menu's event handler
183	if ( !processed && GetEventHandler())
184	{
185	processed = GetEventHandler()->ProcessEvent(event);
186	}
187	// Try the window the menu was popped up from (and up
188	// through the hierarchy)
189	if ( !processed && GetInvokingWindow())
190	processed = GetInvokingWindow()->ProcessEvent(event);
191
192	return processed;
193	}
194
195	// ----------------------------------------------------------------------------
196	// Menu Bar
197	// ----------------------------------------------------------------------------
198
199	void wxMenuBar::Init()
200	{
201	m_eventHandler = this;
202	m_menuBarFrame = NULL;
203	m_mainWidget = (WXWidget) NULL;
204	m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
205	m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUTEXT);
206	m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
207	}
208
209	wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
210	{
211	Init();
212
213	for ( int i = 0; i < n; i++ )
214	{
215	m_menus.Append(menus[i]);
216	m_titles.Add(titles[i]);
217	}
218	}
219
220	wxMenuBar::~wxMenuBar()
221	{
222	// nothing to do: wxMenuBarBase will delete the menus
223	}
224
225	void wxMenuBar::EnableTop(size_t WXUNUSED(pos), bool WXUNUSED(flag))
226	{
227	// wxFAIL_MSG("TODO");
228	// wxLogWarning("wxMenuBar::EnableTop not yet implemented.");
229	}
230
231	void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
232	{
233	wxMenu *menu = GetMenu(pos);
234	if ( !menu )
235	return;
236
237	Widget w = (Widget)menu->GetButtonWidget();
238	if (w)
239	{
240	wxXmString label_str(label);
241
242	XtVaSetValues(w,
243	XmNlabelString, label_str(),
244	NULL);
245	}
246	}
247
248	wxString wxMenuBar::GetLabelTop(size_t pos) const
249	{
250	wxString str;
251
252	wxMenu *menu = GetMenu(pos);
253	if ( menu )
254	{
255	Widget w = (Widget)menu->GetButtonWidget();
256	if (w)
257	{
258	XmString text;
259	XtVaGetValues(w,
260	XmNlabelString, &text,
261	NULL);
262
263	char *s;
264	if ( XmStringGetLtoR(text, XmSTRING_DEFAULT_CHARSET, &s) )
265	{
266	str = s;
267
268	XtFree(s);
269	}
270	}
271	}
272
273	return str;
274	}
275
276	bool wxMenuBar::Append(wxMenu * menu, const wxString& title)
277	{
278	wxCHECK_MSG( menu, FALSE, wxT("invalid menu") );
279	wxCHECK_MSG( !menu->GetParent() && !menu->GetButtonWidget(), FALSE,
280	wxT("menu already appended") );
281
282	if ( m_menuBarFrame )
283	{
284	WXWidget w = menu->CreateMenu(this, GetMainWidget(), menu, title, TRUE);
285	wxCHECK_MSG( w, FALSE, wxT("failed to create menu") );
286	menu->SetButtonWidget(w);
287	}
288
289	//menu->SetMenuBar(this);
290
291	m_titles.Add(title);
292
293	return wxMenuBarBase::Append(menu, title);
294	}
295
296	bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
297	{
298	if ( !wxMenuBarBase::Insert(pos, menu, title) )
299	return FALSE;
300
301	wxFAIL_MSG(wxT("TODO"));
302
303	return FALSE;
304	}
305
306	wxMenu wxMenuBar::Replace(size_t pos, wxMenu menu, const wxString& title)
307	{
308	if ( !wxMenuBarBase::Replace(pos, menu, title) )
309	return FALSE;
310
311	wxFAIL_MSG(wxT("TODO"));
312
313	return NULL;
314	}
315
316	wxMenu *wxMenuBar::Remove(size_t pos)
317	{
318	wxMenu *menu = wxMenuBarBase::Remove(pos);
319	if ( !menu )
320	return NULL;
321
322	if ( m_menuBarFrame )
323	menu->DestroyMenu(TRUE);
324
325	menu->SetMenuBar(NULL);
326
327	m_titles.Remove(pos);
328
329	return menu;
330	}
331
332	// Find the menu menuString, item itemString, and return the item id.
333	// Returns -1 if none found.
334	int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
335	{
336	char buf1[200];
337	char buf2[200];
338	wxStripMenuCodes ((char )(const char )menuString, buf1);
339
340	size_t menuCount = GetMenuCount();
341	for (size_t i = 0; i < menuCount; i++)
342	{
343	wxStripMenuCodes ((char )(const char )m_titles[i], buf2);
344	if (strcmp (buf1, buf2) == 0)
345	return m_menus[i]->FindItem (itemString);
346	}
347	return -1;
348	}
349
350	wxMenuItem wxMenuBar::FindItem(int id, wxMenu * itemMenu) const
351	{
352	if (itemMenu)
353	*itemMenu = NULL;
354
355	wxMenuItem *item = NULL;
356	size_t menuCount = GetMenuCount();
357	for (size_t i = 0; i < menuCount; i++)
358	if ((item = m_menus[i]->FindItem(id, itemMenu)))
359	return item;
360	return NULL;
361	}
362
363	// Create menubar
364	bool wxMenuBar::CreateMenuBar(wxFrame* parent)
365	{
366	if (m_mainWidget)
367	{
368	XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
369	/*
370	if (!XtIsManaged((Widget) m_mainWidget))
371	XtManageChild((Widget) m_mainWidget);
372	*/
373	XtMapWidget((Widget) m_mainWidget);
374	return TRUE;
375	}
376
377	Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWidget(), "MenuBar", NULL, 0);
378	m_mainWidget = (WXWidget) menuBarW;
379
380	size_t menuCount = GetMenuCount();
381	for (size_t i = 0; i < menuCount; i++)
382	{
383	wxMenu *menu = GetMenu(i);
384	wxString title(m_titles[i]);
385	menu->SetButtonWidget(menu->CreateMenu (this, menuBarW, menu, title, TRUE));
386
387	if (strcmp (wxStripMenuCodes(title), "Help") == 0)
388	XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);
389
390	// tear off menu support
391	#if (XmVersion >= 1002)
392	if ( menu->IsTearOff() )
393	{
394	XtVaSetValues(GetWidget(menu),
395	XmNtearOffModel, XmTEAR_OFF_ENABLED,
396	NULL);
397	Widget tearOff = XmGetTearOffControl(GetWidget(menu));
398	wxDoChangeForegroundColour((Widget) tearOff, m_foregroundColour);
399	wxDoChangeBackgroundColour((Widget) tearOff, m_backgroundColour, TRUE);
400	#endif
401	}
402	}
403
404	SetBackgroundColour(m_backgroundColour);
405	SetForegroundColour(m_foregroundColour);
406	SetFont(m_font);
407
408	XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
409	XtRealizeWidget ((Widget) menuBarW);
410	XtManageChild ((Widget) menuBarW);
411	SetMenuBarFrame(parent);
412
413	return TRUE;
414	}
415
416	// Destroy menubar, but keep data structures intact so we can recreate it.
417	bool wxMenuBar::DestroyMenuBar()
418	{
419	if (!m_mainWidget)
420	{
421	SetMenuBarFrame((wxFrame*) NULL);
422	return FALSE;
423	}
424
425	XtUnmanageChild ((Widget) m_mainWidget);
426	XtUnrealizeWidget ((Widget) m_mainWidget);
427
428	size_t menuCount = GetMenuCount();
429	for (size_t i = 0; i < menuCount; i++)
430	{
431	wxMenu *menu = GetMenu(i);
432	menu->DestroyMenu(TRUE);
433
434	}
435	XtDestroyWidget((Widget) m_mainWidget);
436	m_mainWidget = (WXWidget) 0;
437
438	SetMenuBarFrame((wxFrame*) NULL);
439
440	return TRUE;
441	}
442
443	//// Motif-specific
444	static XtWorkProcId WorkProcMenuId;
445
446	/* Since PopupMenu under Motif stills grab right mouse button events
447	* after it was closed, we need to delete the associated widgets to
448	* allow next PopUpMenu to appear...
449	*/
450
451	int PostDeletionOfMenu( XtPointer* clientData )
452	{
453	XtRemoveWorkProc(WorkProcMenuId);
454	wxMenu menu = (wxMenu )clientData;
455
456	if (menu->GetMainWidget())
457	{
458	wxMenu *menuParent = menu->GetParent();
459	if ( menuParent )
460	{
461	wxMenuItemList::Node *node = menuParent->GetMenuItems().GetFirst();
462	while ( node )
463	{
464	if ( node->GetData()->GetSubMenu() == menu )
465	{
466	menuParent->GetMenuItems().DeleteNode(node);
467
468	break;
469	}
470
471	node = node->GetNext();
472	}
473	}
474
475	menu->DestroyMenu(TRUE);
476	}
477
478	// Mark as no longer popped up
479	menu->m_menuId = -1;
480
481	return TRUE;
482	}
483
484	void
485	wxMenuPopdownCallback(Widget WXUNUSED(w), XtPointer clientData,
486	XtPointer WXUNUSED(ptr))
487	{
488	wxMenu menu = (wxMenu )clientData;
489
490	// Added by JOREL Jean-Charles <jjorel@silr.ireste.fr>
491	/* Since Callbacks of MenuItems are not yet processed, we put a
492	* background job which will be done when system will be idle.
493	* What awful hack!! :(
494	*/
495
496	WorkProcMenuId = XtAppAddWorkProc(
497	(XtAppContext) wxTheApp->GetAppContext(),
498	(XtWorkProc) PostDeletionOfMenu,
499	(XtPointer) menu );
500	// Apparently not found in Motif headers
501	// XtVaSetValues( w, XmNpopupEnabled, XmPOPUP_DISABLED, NULL );
502	}
503
504	/*
505	* Create a popup or pulldown menu.
506	* Submenus of a popup will be pulldown.
507	*
508	*/
509
510	WXWidget wxMenu::CreateMenu (wxMenuBar * menuBar, WXWidget parent, wxMenu * topMenu, const wxString& title, bool pullDown)
511	{
512	Widget menu = (Widget) 0;
513	Widget buttonWidget = (Widget) 0;
514	Arg args[5];
515	XtSetArg (args[0], XmNnumColumns, m_numColumns);
516	XtSetArg (args[1], XmNpacking, XmPACK_COLUMN);
517
518	if (!pullDown)
519	{
520	menu = XmCreatePopupMenu ((Widget) parent, "popup", args, 2);
521	XtAddCallback(menu,
522	XmNunmapCallback,
523	(XtCallbackProc)wxMenuPopdownCallback,
524	(XtPointer)this);
525	}
526	else
527	{
528	char mnem = wxFindMnemonic (title);
529	wxStripMenuCodes ((char) (const char) title, wxBuffer);
530
531	menu = XmCreatePulldownMenu ((Widget) parent, "pulldown", args, 2);
532
533	wxString title2(wxStripMenuCodes(title));
534	wxXmString label_str(title2);
535	buttonWidget = XtVaCreateManagedWidget(title2,
536	#if wxUSE_GADGETS
537	xmCascadeButtonGadgetClass, (Widget) parent,
538	#else
539	xmCascadeButtonWidgetClass, (Widget) parent,
540	#endif
541	XmNlabelString, label_str(),
542	XmNsubMenuId, menu,
543	NULL);
544
545	if (mnem != 0)
546	XtVaSetValues (buttonWidget, XmNmnemonic, mnem, NULL);
547	}
548
549	m_menuWidget = (WXWidget) menu;
550
551	m_menuBar = menuBar;
552	m_topLevelMenu = topMenu;
553
554	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
555	node;
556	node = node->GetNext() )
557	{
558	wxMenuItem *item = node->GetData();
559
560	item->CreateItem(menu, menuBar, topMenu);
561	}
562
563	SetBackgroundColour(m_backgroundColour);
564	SetForegroundColour(m_foregroundColour);
565	SetFont(m_font);
566
567	return buttonWidget;
568	}
569
570	// Destroys the Motif implementation of the menu,
571	// but maintains the wxWindows data structures so we can
572	// do a CreateMenu again.
573	void wxMenu::DestroyMenu (bool full)
574	{
575	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
576	node;
577	node = node->GetNext() )
578	{
579	wxMenuItem *item = node->GetData();
580	item->SetMenuBar((wxMenuBar*) NULL);
581
582	item->DestroyItem(full);
583	}
584
585	if (m_buttonWidget)
586	{
587	if (full)
588	{
589	XtVaSetValues((Widget) m_buttonWidget, XmNsubMenuId, NULL, NULL);
590	XtDestroyWidget ((Widget) m_buttonWidget);
591	m_buttonWidget = (WXWidget) 0;
592	}
593	}
594	if (m_menuWidget && full)
595	{
596	XtDestroyWidget((Widget) m_menuWidget);
597	m_menuWidget = (WXWidget) NULL;
598	}
599	}
600
601	WXWidget wxMenu::FindMenuItem (int id, wxMenuItem ** it) const
602	{
603	if (id == m_menuId)
604	{
605	if (it)
606	it = (wxMenuItem) NULL;
607	return m_buttonWidget;
608	}
609
610	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
611	node;
612	node = node->GetNext() )
613	{
614	wxMenuItem *item = node->GetData ();
615	if (item->GetId() == id)
616	{
617	if (it)
618	*it = item;
619	return item->GetButtonWidget();
620	}
621
622	if (item->GetSubMenu())
623	{
624	WXWidget w = item->GetSubMenu()->FindMenuItem (id, it);
625	if (w)
626	{
627	return w;
628	}
629	}
630	}
631
632	if (it)
633	it = (wxMenuItem) NULL;
634	return (WXWidget) NULL;
635	}
636
637	void wxMenu::SetBackgroundColour(const wxColour& col)
638	{
639	m_backgroundColour = col;
640	if (m_menuWidget)
641	wxDoChangeBackgroundColour(m_menuWidget, (wxColour&) col);
642	if (m_buttonWidget)
643	wxDoChangeBackgroundColour(m_buttonWidget, (wxColour&) col, TRUE);
644
645	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
646	node;
647	node = node->GetNext() )
648	{
649	wxMenuItem* item = node->GetData();
650	if (item->GetButtonWidget())
651	{
652	// This crashes because it uses gadgets
653	// wxDoChangeBackgroundColour(item->GetButtonWidget(), (wxColour&) col, TRUE);
654	}
655	if (item->GetSubMenu())
656	item->GetSubMenu()->SetBackgroundColour((wxColour&) col);
657	}
658	}
659
660	void wxMenu::SetForegroundColour(const wxColour& col)
661	{
662	m_foregroundColour = col;
663	if (m_menuWidget)
664	wxDoChangeForegroundColour(m_menuWidget, (wxColour&) col);
665	if (m_buttonWidget)
666	wxDoChangeForegroundColour(m_buttonWidget, (wxColour&) col);
667
668	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
669	node;
670	node = node->GetNext() )
671	{
672	wxMenuItem* item = node->GetData();
673	if (item->GetButtonWidget())
674	{
675	// This crashes because it uses gadgets
676	// wxDoChangeForegroundColour(item->GetButtonWidget(), (wxColour&) col);
677	}
678	if (item->GetSubMenu())
679	item->GetSubMenu()->SetForegroundColour((wxColour&) col);
680	}
681	}
682
683	void wxMenu::ChangeFont(bool keepOriginalSize)
684	{
685	// lesstif 0.87 hangs when setting XmNfontList
686	#ifndef LESSTIF_VERSION
687	if (!m_font.Ok() \|\| !m_menuWidget)
688	return;
689
690	XmFontList fontList = (XmFontList) m_font.GetFontList(1.0, XtDisplay((Widget) m_menuWidget));
691
692	XtVaSetValues ((Widget) m_menuWidget,
693	XmNfontList, fontList,
694	NULL);
695	if (m_buttonWidget)
696	{
697	XtVaSetValues ((Widget) m_buttonWidget,
698	XmNfontList, fontList,
699	NULL);
700	}
701
702	for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
703	node;
704	node = node->GetNext() )
705	{
706	wxMenuItem* item = node->GetData();
707	if (m_menuWidget && item->GetButtonWidget() && m_font.Ok())
708	{
709	XtVaSetValues ((Widget) item->GetButtonWidget(),
710	XmNfontList, fontList,
711	NULL);
712	}
713	if (item->GetSubMenu())
714	item->GetSubMenu()->ChangeFont(keepOriginalSize);
715	}
716	#endif
717	}
718
719	void wxMenu::SetFont(const wxFont& font)
720	{
721	m_font = font;
722	ChangeFont();
723	}
724
725	bool wxMenuBar::SetBackgroundColour(const wxColour& col)
726	{
727	m_backgroundColour = col;
728	if (m_mainWidget)
729	wxDoChangeBackgroundColour(m_mainWidget, (wxColour&) col);
730
731	size_t menuCount = GetMenuCount();
732	for (size_t i = 0; i < menuCount; i++)
733	m_menus[i]->SetBackgroundColour((wxColour&) col);
734
735	return TRUE;
736	}
737
738	bool wxMenuBar::SetForegroundColour(const wxColour& col)
739	{
740	m_foregroundColour = col;
741	if (m_mainWidget)
742	wxDoChangeForegroundColour(m_mainWidget, (wxColour&) col);
743
744	size_t menuCount = GetMenuCount();
745	for (size_t i = 0; i < menuCount; i++)
746	m_menus[i]->SetForegroundColour((wxColour&) col);
747
748	return TRUE;
749	}
750
751	void wxMenuBar::ChangeFont(bool WXUNUSED(keepOriginalSize))
752	{
753	// Nothing to do for menubar, fonts are kept in wxMenus
754	}
755
756	bool wxMenuBar::SetFont(const wxFont& font)
757	{
758	m_font = font;
759	ChangeFont();
760
761	size_t menuCount = GetMenuCount();
762	for (size_t i = 0; i < menuCount; i++)
763	m_menus[i]->SetFont(font);
764
765	return TRUE;
766	}
767