Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. wxMenu{Item|Bar} modifications for wxMotif

Browse Source 
2. corrected a crash on startup if wxDataObject is used in Motif


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4212 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-10-27 13:19:07 +00:00
parent d537080184
commit 9874b4ee83
6 changed files with 263 additions and 464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/wx/menu.h
View File

@@ -115,7 +115,9 @@ public:
void SetHelpString(int id, const wxString& helpString); void SetHelpString(int id, const wxString& helpString);
wxString GetHelpString(int id) const; wxString GetHelpString(int id) const;
// need to override this one to avoid virtual function hiding // need to override these ones to avoid virtual function hiding
virtual bool Enable(bool enable = TRUE) { return wxWindow::Enable(enable); }
virtual void SetLabel(const wxString& s) { wxWindow::SetLabel(s); }
virtual wxString GetLabel() const { return wxWindow::GetLabel(); } virtual wxString GetLabel() const { return wxWindow::GetLabel(); }
// compatibility only: these functions are deprecated, use the new ones // compatibility only: these functions are deprecated, use the new ones

94
include/wx/motif/menu.h
View File

@@ -9,28 +9,23 @@
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MENU_H_ #ifndef _WX_MOTIF_MENU_H_
#define _WX_MENU_H_ #define _WX_MOTIF_MENU_H_
#ifdef __GNUG__ #ifdef __GNUG__
#pragma interface "menu.h" #pragma interface "menu.h"
#endif #endif
#include "wx/defs.h" #include "wx/colour.h"
#include "wx/event.h"
#include "wx/font.h" #include "wx/font.h"
#include "wx/gdicmn.h"
class WXDLLEXPORT wxMenuItem; class wxFrame;
class WXDLLEXPORT wxMenuBar;
class WXDLLEXPORT wxMenu;
WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Menu // Menu
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenu: public wxEvtHandler
class wxMenu : public wxEvtHandler
{ {
DECLARE_DYNAMIC_CLASS(wxMenu) DECLARE_DYNAMIC_CLASS(wxMenu)
@@ -106,7 +101,6 @@ public:
void Callback(const wxFunction func) { m_callback = func; } void Callback(const wxFunction func) { m_callback = func; }
#endif // WXWIN_COMPATIBILITY #endif // WXWIN_COMPATIBILITY
virtual void SetParent(wxEvtHandler *parent) { m_parent = parent; }
void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; } void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
wxEvtHandler *GetEventHandler() { return m_eventHandler; } wxEvtHandler *GetEventHandler() { return m_eventHandler; }
@@ -160,7 +154,6 @@ public:
wxString m_title; wxString m_title;
wxMenuBar * m_menuBar; wxMenuBar * m_menuBar;
wxList m_menuItems; wxList m_menuItems;
wxEvtHandler * m_parent;
wxEvtHandler * m_eventHandler; wxEvtHandler * m_eventHandler;
void* m_clientData; void* m_clientData;
wxWindow* m_pInvokingWindow; wxWindow* m_pInvokingWindow;
@@ -191,54 +184,36 @@ private:
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Menu Bar (a la Windows) // Menu Bar
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxFrame; class wxMenuBar : public wxMenuBarBase
class WXDLLEXPORT wxMenuBar : public wxEvtHandler
{ {
DECLARE_DYNAMIC_CLASS(wxMenuBar)
public: public:
wxMenuBar( long style ); wxMenuBar() { Init(); }
wxMenuBar(); wxMenuBar(long WXUNUSED(style)) { Init(); }
wxMenuBar(int n, wxMenu *menus[], const wxString titles[]); wxMenuBar(int n, wxMenu *menus[], const wxString titles[]);
~wxMenuBar(); virtual ~wxMenuBar();
void Append(wxMenu *menu, const wxString& title); // implement base class (pure) virtuals
// Must only be used AFTER menu has been attached to frame, // ------------------------------------
// otherwise use individual menus to enable/disable items
void Enable(int Id, bool Flag);
bool Enabled(int Id) const ;
bool IsEnabled(int Id) const { return Enabled(Id); };
void EnableTop(int pos, bool Flag);
void Check(int id, bool Flag);
bool Checked(int id) const ;
bool IsChecked(int Id) const { return Checked(Id); };
void SetLabel(int id, const wxString& label) ;
wxString GetLabel(int id) const ;
void SetLabelTop(int pos, const wxString& label) ;
wxString GetLabelTop(int pos) const ;
virtual void Delete(wxMenu *menu, int index = 0); /* Menu not destroyed */
virtual bool OnAppend(wxMenu *menu, const char *title);
virtual bool OnDelete(wxMenu *menu, int index);
virtual void SetHelpString(int Id, const wxString& helpString); virtual bool Append( wxMenu *menu, const wxString &title );
virtual wxString GetHelpString(int Id) const ; virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Remove(size_t pos);
virtual int FindMenuItem(const wxString& menuString, const wxString& itemString) const ; virtual int FindMenuItem(const wxString& menuString,
const wxString& itemString) const;
virtual wxMenuItem* FindItem( int id, wxMenu **menu = NULL ) const;
// Find wxMenuItem for item ID, and return item's virtual void EnableTop( size_t pos, bool flag );
// menu too if itemMenu is non-NULL. virtual void SetLabelTop( size_t pos, const wxString& label );
wxMenuItem *FindItemForId(int itemId, wxMenu **menuForItem = NULL) const ; virtual wxString GetLabelTop( size_t pos ) const;
void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; } // implementation only from now on
wxEvtHandler *GetEventHandler() { return m_eventHandler; } // -------------------------------
int GetMenuCount() const { return m_menuCount; }
wxMenu* GetMenu(int i) const { return m_menus[i]; }
//// Motif-specific
wxFrame* GetMenuBarFrame() const { return m_menuBarFrame; } wxFrame* GetMenuBarFrame() const { return m_menuBarFrame; }
void SetMenuBarFrame(wxFrame* frame) { m_menuBarFrame = frame; } void SetMenuBarFrame(wxFrame* frame) { m_menuBarFrame = frame; }
WXWidget GetMainWidget() const { return m_mainWidget; } WXWidget GetMainWidget() const { return m_mainWidget; }
@@ -254,24 +229,25 @@ public:
const wxColour& GetForegroundColour() const { return m_foregroundColour; } const wxColour& GetForegroundColour() const { return m_foregroundColour; }
const wxFont& GetFont() const { return m_font; } const wxFont& GetFont() const { return m_font; }
void SetBackgroundColour(const wxColour& colour); virtual bool SetBackgroundColour(const wxColour& colour);
void SetForegroundColour(const wxColour& colour); virtual bool SetForegroundColour(const wxColour& colour);
void SetFont(const wxFont& colour); virtual bool SetFont(const wxFont& colour);
void ChangeFont(bool keepOriginalSize = FALSE); void ChangeFont(bool keepOriginalSize = FALSE);
public: public:
wxEvtHandler * m_eventHandler; // common part of all ctors
int m_menuCount; void Init();
wxMenu ** m_menus;
wxString * m_titles; wxArrayString m_titles;
wxFrame *m_menuBarFrame; wxFrame *m_menuBarFrame;
//// Motif-specific
WXWidget m_mainWidget; WXWidget m_mainWidget;
wxColour m_foregroundColour; wxColour m_foregroundColour;
wxColour m_backgroundColour; wxColour m_backgroundColour;
wxFont m_font; wxFont m_font;
DECLARE_DYNAMIC_CLASS(wxMenuBar)
}; };
#endif // _WX_MENU_H_ #endif // _WX_MOTIF_MENU_H_

101
include/wx/motif/menuitem.h
View File

@@ -9,107 +9,54 @@
// Licence: wxWindows license // Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#ifndef _MENUITEM_H #ifndef _WX_MOTIF_MENUITEM_H
#define _MENUITEM_H #define _WX_MOTIF_MENUITEM_H
#ifdef __GNUG__ #ifdef __GNUG__
#pragma interface "menuitem.h" #pragma interface "menuitem.h"
#endif #endif
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/setup.h"
// an exception to the general rule that a normal header doesn't include other
// headers - only because ownerdrw.h is not always included and I don't want
// to write #ifdef's everywhere...
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
#endif
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// id for a separator line in the menu (invalid for normal item)
// #define ID_SEPARATOR (-1)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour // wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenuItem: public wxObject
#if wxUSE_OWNER_DRAWN
, public wxOwnerDrawn
#endif
{
DECLARE_DYNAMIC_CLASS(wxMenuItem)
class WXDLLEXPORT wxMenuItem: public wxMenuItemBase
{
public: public:
// ctor & dtor // ctor & dtor
wxMenuItem(wxMenu *pParentMenu = NULL, int id = ID_SEPARATOR, wxMenuItem(wxMenu *parentMenu = (wxMenu *)NULL,
const wxString& strName = "", const wxString& wxHelp = "", int id = wxID_SEPARATOR,
bool bCheckable = FALSE, wxMenu *pSubMenu = NULL); const wxString& text = wxEmptyString,
virtual ~wxMenuItem(); const wxString& help = wxEmptyString,
bool isCheckable = FALSE,
wxMenu *subMenu = (wxMenu *)NULL);
~wxMenuItem();
// accessors (some more are inherited from wxOwnerDrawn or are below) // accessors (some more are inherited from wxOwnerDrawn or are below)
bool IsSeparator() const { return m_idItem == ID_SEPARATOR; } virtual void SetText(const wxString& label);
bool IsEnabled() const { return m_bEnabled; } virtual void Enable(bool enable = TRUE);
bool IsChecked() const { return m_bChecked; } virtual void Check(bool check = TRUE);
int GetId() const { return m_idItem; }
const wxString& GetHelp() const { return m_strHelp; }
wxMenu *GetSubMenu() const { return m_pSubMenu; }
// operations
void SetName(const wxString& strName) { m_strName = strName; }
void SetHelp(const wxString& strHelp) { m_strHelp = strHelp; }
void Enable(bool bDoEnable = TRUE);
void Check(bool bDoCheck = TRUE);
void DeleteSubMenu(); void DeleteSubMenu();
//// Motif-specific // implementation from now on
// These two should probably exist for all ports
void SetLabel(const wxString& label);
wxString GetLabel() const { return m_strName; }
void CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMenu); void CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMenu);
void DestroyItem(bool full); void DestroyItem(bool full);
inline WXWidget GetButtonWidget() const { return m_buttonWidget; } WXWidget GetButtonWidget() const { return m_buttonWidget; }
inline void SetChecked(bool check) { m_bChecked = check; }
inline wxMenuBar* GetMenuBar() const { return m_menuBar; } wxMenuBar* GetMenuBar() const { return m_menuBar; }
inline void SetMenuBar(wxMenuBar* menuBar) { m_menuBar = menuBar; } void SetMenuBar(wxMenuBar* menuBar) { m_menuBar = menuBar; }
inline wxMenu* GetTopMenu() const { return m_topMenu; }
inline void SetTopMenu(wxMenu* menu) { m_topMenu = menu; } wxMenu* GetTopMenu() const { return m_topMenu; }
void SetTopMenu(wxMenu* menu) { m_topMenu = menu; }
private: private:
int m_idItem; // numeric id of the item
wxString m_strHelp; // associated help string
wxMenu *m_pSubMenu, // may be NULL
*m_pParentMenu; // menu this item is contained in
bool m_bEnabled, // enabled or greyed?
m_bChecked; // checked? (only if checkable)
//// Motif-specific
WXWidget m_buttonWidget; WXWidget m_buttonWidget;
wxMenuBar* m_menuBar; wxMenuBar* m_menuBar;
wxMenu* m_topMenu; // Top-level menu e.g. popup-menu wxMenu* m_topMenu; // Top-level menu e.g. popup-menu
#if wxUSE_OWNER_DRAWN DECLARE_DYNAMIC_CLASS(wxMenuItem)
// wxOwnerDrawn base class already has these variables - nothing to do
#else //!owner drawn
bool m_bCheckable; // can be checked?
wxString m_strName; // name or label of the item
public:
const wxString& GetName() const { return m_strName; }
bool IsCheckable() const { return m_bCheckable; }
#endif //owner drawn
}; };
#endif //_MENUITEM_H #endif // _WX_MOTIF_MENUITEM_H

1
src/motif/dataobj.cpp
View File

@@ -33,7 +33,6 @@ Atom g_textAtom = 0;
wxDataFormat::wxDataFormat() wxDataFormat::wxDataFormat()
{ {
if (!g_textAtom) g_textAtom = XInternAtom( (Display*) wxGetDisplay(), "STRING", FALSE );
m_type = wxDF_INVALID; m_type = wxDF_INVALID;
m_hasAtom = FALSE; m_hasAtom = FALSE;
m_atom = (Atom) 0; m_atom = (Atom) 0;

361
src/motif/menu.cpp
View File

@@ -11,17 +11,17 @@
// ============================================================================ // ============================================================================
// headers & declarations // declarations
// ============================================================================ // ============================================================================
// wxWindows headers
// -----------------
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation "menu.h" #pragma implementation "menu.h"
#pragma implementation "menuitem.h"
#endif #endif
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/menu.h" #include "wx/menu.h"
#include "wx/menuitem.h" #include "wx/menuitem.h"
#include "wx/log.h" #include "wx/log.h"
@@ -43,7 +43,6 @@
#include "wx/motif/private.h" #include "wx/motif/private.h"
// other standard headers // other standard headers
// ----------------------
#include <string.h> #include <string.h>
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY
@@ -55,7 +54,9 @@ IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
// implementation // implementation
// ============================================================================ // ============================================================================
// ----------------------------------------------------------------------------
// Menus // Menus
// ----------------------------------------------------------------------------
// Construct a menu with optional title (then use append) // Construct a menu with optional title (then use append)
void wxMenu::Init(const wxString& title, void wxMenu::Init(const wxString& title,
@@ -66,7 +67,6 @@ void wxMenu::Init(const wxString& title,
) )
{ {
m_title = title; m_title = title;
m_parent = (wxEvtHandler*) NULL;
m_eventHandler = this; m_eventHandler = this;
m_noItems = 0; m_noItems = 0;
m_menuBar = NULL; m_menuBar = NULL;
@@ -272,7 +272,7 @@ void wxMenu::SetLabel(int id, const wxString& label)
if (item == (wxMenuItem*) NULL) if (item == (wxMenuItem*) NULL)
return; return;
item->SetLabel(label); item->SetText(label);
} }
wxString wxMenu::GetLabel(int id) const wxString wxMenu::GetLabel(int id) const
@@ -434,26 +434,13 @@ void wxMenu::UpdateUI(wxEvtHandler* source)
} }
} }
// ----------------------------------------------------------------------------
// Menu Bar // Menu Bar
wxMenuBar::wxMenuBar() // ----------------------------------------------------------------------------
{
m_eventHandler = this;
m_menuCount = 0;
m_menus = NULL;
m_titles = NULL;
m_menuBarFrame = NULL;
m_mainWidget = (WXWidget) NULL;
m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
}
wxMenuBar::wxMenuBar(long WXUNUSED(style)) void wxMenuBar::Init()
{ {
m_eventHandler = this; m_eventHandler = this;
m_menuCount = 0;
m_menus = NULL;
m_titles = NULL;
m_menuBarFrame = NULL; m_menuBarFrame = NULL;
m_mainWidget = (WXWidget) NULL; m_mainWidget = (WXWidget) NULL;
m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU); m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
@@ -463,241 +450,124 @@ wxMenuBar::wxMenuBar(long WXUNUSED(style))
wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[]) wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
{ {
m_eventHandler = this; Init();
m_menuCount = n;
m_menus = menus; for ( int i = 0; i < n; i++ )
m_titles = new wxString[n]; {
int i; m_menus.Append(menus[i]);
for ( i = 0; i < n; i++ ) m_titles.Add(titles[i]);
m_titles[i] = titles[i]; }
m_menuBarFrame = NULL;
m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
} }
wxMenuBar::~wxMenuBar() wxMenuBar::~wxMenuBar()
{ {
int i; // nothing to do: wxMenuBarBase will delete the menus
for (i = 0; i < m_menuCount; i++)
{
delete m_menus[i];
}
delete[] m_menus;
delete[] m_titles;
} }
// Must only be used AFTER menu has been attached to frame, void wxMenuBar::EnableTop(size_t WXUNUSED(pos), bool WXUNUSED(flag))
// otherwise use individual menus to enable/disable items
void wxMenuBar::Enable(int id, bool flag)
{ {
wxMenu *itemMenu = NULL; wxFAIL_MSG("TODO");
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
item->Enable(flag);
} }
void wxMenuBar::EnableTop(int WXUNUSED(pos), bool WXUNUSED(flag)) void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
{ {
// TODO wxMenu *menu = GetMenu(pos);
} if ( !menu )
// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus
void wxMenuBar::Check(int id, bool flag)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return; return;
if (!item->IsCheckable()) Widget w = (Widget)menu->GetButtonWidget();
return ;
item->Check(flag);
}
bool wxMenuBar::Checked(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
return item->IsChecked();
}
bool wxMenuBar::Enabled(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
return item->IsEnabled();
}
void wxMenuBar::SetLabel(int id, const wxString& label)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
item->SetLabel(label);
}
wxString wxMenuBar::GetLabel(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return wxString("");
return item->GetLabel();
}
void wxMenuBar::SetLabelTop(int pos, const wxString& label)
{
wxASSERT( (pos < m_menuCount) );
Widget w = (Widget) m_menus[pos]->GetButtonWidget();
if (w) if (w)
{ {
XmString label_str = XmStringCreateSimple ((char*) (const char*) label); wxXmString label_str(label);
XtVaSetValues(w, XtVaSetValues(w,
XmNlabelString, label_str, XmNlabelString, label_str(),
NULL); NULL);
XmStringFree (label_str);
} }
} }
wxString wxMenuBar::GetLabelTop(int pos) const wxString wxMenuBar::GetLabelTop(size_t pos) const
{ {
wxASSERT( (pos < m_menuCount) ); wxString str;
Widget w = (Widget) m_menus[pos]->GetButtonWidget(); wxMenu *menu = GetMenu(pos);
if ( menu )
{
Widget w = (Widget)menu->GetButtonWidget();
if (w) if (w)
{ {
XmString text; XmString text;
char *s;
XtVaGetValues(w, XtVaGetValues(w,
XmNlabelString, &text, XmNlabelString, &text,
NULL); NULL);
char *s;
if ( XmStringGetLtoR(text, XmSTRING_DEFAULT_CHARSET, &s) ) if ( XmStringGetLtoR(text, XmSTRING_DEFAULT_CHARSET, &s) )
{ {
wxString str(s); str = s;
XtFree(s); XtFree(s);
}
}
}
return str; return str;
} }
else
bool wxMenuBar::Append(wxMenu * menu, const wxString& title)
{ {
return wxEmptyString; wxCHECK_MSG( menu, FALSE, wxT("invalid menu") );
} wxCHECK_MSG( !menu->GetParent() && !menu->GetButtonWidget(), FALSE,
} wxT("menu already appended") );
else
return wxEmptyString;
} if ( m_menuBarFrame )
bool wxMenuBar::OnDelete(wxMenu *menu, int WXUNUSED(pos))
{ {
// Only applies to dynamic deletion (when set in frame)
if (!m_menuBarFrame)
return TRUE;
menu->DestroyMenu(TRUE);
return TRUE;
}
bool wxMenuBar::OnAppend(wxMenu *menu, const char *title)
{
// Only applies to dynamic append (when set in frame)
if (!m_menuBarFrame)
return TRUE;
// Probably should be an assert here
if (menu->GetParent())
return FALSE;
// Has already been appended
if (menu->GetButtonWidget())
return FALSE;
WXWidget w = menu->CreateMenu(this, GetMainWidget(), menu, title, TRUE); WXWidget w = menu->CreateMenu(this, GetMainWidget(), menu, title, TRUE);
wxCHECK_MSG( w, FALSE, wxT("failed to create menu") );
menu->SetButtonWidget(w); menu->SetButtonWidget(w);
return TRUE;
} }
void wxMenuBar::Append (wxMenu * menu, const wxString& title)
{
if (!OnAppend(menu, title))
return;
m_menuCount ++;
wxMenu **new_menus = new wxMenu *[m_menuCount];
wxString *new_titles = new wxString[m_menuCount];
int i;
for (i = 0; i < m_menuCount - 1; i++)
{
new_menus[i] = m_menus[i];
m_menus[i] = NULL;
new_titles[i] = m_titles[i];
m_titles[i] = "";
}
if (m_menus)
{
delete[]m_menus;
delete[]m_titles;
}
m_menus = new_menus;
m_titles = new_titles;
m_menus[m_menuCount - 1] = (wxMenu *)menu;
m_titles[m_menuCount - 1] = title;
menu->SetMenuBar(this); menu->SetMenuBar(this);
menu->SetParent(this);
m_titles.Add(title);
return wxMenuBarBase::Append(menu, title);
} }
void wxMenuBar::Delete(wxMenu * menu, int i) bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
{ {
int j; if ( !wxMenuBarBase::Insert(pos, menu, title) )
int ii = (int) i; return FALSE;
if (menu != 0) wxFAIL_MSG(wxT("TODO"));
{
for (ii = 0; ii < m_menuCount; ii++) return FALSE;
{
if (m_menus[ii] == menu)
break;
}
if (ii >= m_menuCount)
return;
} else
{
if (ii < 0 || ii >= m_menuCount)
return;
menu = m_menus[ii];
} }
if (!OnDelete(menu, ii)) wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
return;
menu->SetParent((wxEvtHandler*) NULL);
-- m_menuCount;
for (j = ii; j < m_menuCount; j++)
{ {
m_menus[j] = m_menus[j + 1]; if ( !wxMenuBarBase::Replace(pos, menu, title) )
m_titles[j] = m_titles[j + 1]; 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. // Find the menu menuString, item itemString, and return the item id.
@@ -707,8 +577,9 @@ int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemStr
char buf1[200]; char buf1[200];
char buf2[200]; char buf2[200];
wxStripMenuCodes ((char *)(const char *)menuString, buf1); wxStripMenuCodes ((char *)(const char *)menuString, buf1);
int i;
for (i = 0; i < m_menuCount; i++) size_t menuCount = GetMenuCount();
for (size_t i = 0; i < menuCount; i++)
{ {
wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2); wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
if (strcmp (buf1, buf2) == 0) if (strcmp (buf1, buf2) == 0)
@@ -717,43 +588,19 @@ int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemStr
return -1; return -1;
} }
wxMenuItem *wxMenuBar::FindItemForId (int id, wxMenu ** itemMenu) const wxMenuItem *wxMenuBar::FindItem(int id, wxMenu ** itemMenu) const
{ {
if (itemMenu) if (itemMenu)
*itemMenu = NULL; *itemMenu = NULL;
wxMenuItem *item = NULL; wxMenuItem *item = NULL;
int i; size_t menuCount = GetMenuCount();
for (i = 0; i < m_menuCount; i++) for (size_t i = 0; i < menuCount; i++)
if ((item = m_menus[i]->FindItemForId (id, itemMenu))) if ((item = m_menus[i]->FindItemForId (id, itemMenu)))
return item; return item;
return NULL; return NULL;
} }
void wxMenuBar::SetHelpString (int id, const wxString& helpString)
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (id))
{
m_menus[i]->SetHelpString (id, helpString);
return;
}
}
}
wxString wxMenuBar::GetHelpString (int id) const
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (id))
return wxString(m_menus[i]->GetHelpString (id));
}
return wxString("");
}
// Create menubar // Create menubar
bool wxMenuBar::CreateMenuBar(wxFrame* parent) bool wxMenuBar::CreateMenuBar(wxFrame* parent)
{ {
@@ -771,8 +618,8 @@ bool wxMenuBar::CreateMenuBar(wxFrame* parent)
Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWindowWidget(), "MenuBar", NULL, 0); Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWindowWidget(), "MenuBar", NULL, 0);
m_mainWidget = (WXWidget) menuBarW; m_mainWidget = (WXWidget) menuBarW;
int i; size_t menuCount = GetMenuCount();
for (i = 0; i < GetMenuCount(); i++) for (size_t i = 0; i < menuCount; i++)
{ {
wxMenu *menu = GetMenu(i); wxMenu *menu = GetMenu(i);
wxString title(m_titles[i]); wxString title(m_titles[i]);
@@ -816,8 +663,8 @@ bool wxMenuBar::DestroyMenuBar()
XtUnmanageChild ((Widget) m_mainWidget); XtUnmanageChild ((Widget) m_mainWidget);
XtUnrealizeWidget ((Widget) m_mainWidget); XtUnrealizeWidget ((Widget) m_mainWidget);
int i; size_t menuCount = GetMenuCount();
for (i = 0; i < GetMenuCount(); i++) for (size_t i = 0; i < menuCount; i++)
{ {
wxMenu *menu = GetMenu(i); wxMenu *menu = GetMenu(i);
menu->DestroyMenu(TRUE); menu->DestroyMenu(TRUE);
@@ -832,8 +679,6 @@ bool wxMenuBar::DestroyMenuBar()
} }
//// Motif-specific //// Motif-specific
extern wxApp *wxTheApp;
static XtWorkProcId WorkProcMenuId; static XtWorkProcId WorkProcMenuId;
/* Since PopupMenu under Motif stills grab right mouse button events /* Since PopupMenu under Motif stills grab right mouse button events
@@ -1092,26 +937,30 @@ void wxMenu::SetFont(const wxFont& font)
ChangeFont(); ChangeFont();
} }
void wxMenuBar::SetBackgroundColour(const wxColour& col) bool wxMenuBar::SetBackgroundColour(const wxColour& col)
{ {
m_backgroundColour = col; m_backgroundColour = col;
if (m_mainWidget) if (m_mainWidget)
wxDoChangeBackgroundColour(m_mainWidget, (wxColour&) col); wxDoChangeBackgroundColour(m_mainWidget, (wxColour&) col);
int i;
for (i = 0; i < m_menuCount; i++) size_t menuCount = GetMenuCount();
for (size_t i = 0; i < menuCount; i++)
m_menus[i]->SetBackgroundColour((wxColour&) col); m_menus[i]->SetBackgroundColour((wxColour&) col);
return TRUE;
} }
void wxMenuBar::SetForegroundColour(const wxColour& col) bool wxMenuBar::SetForegroundColour(const wxColour& col)
{ {
m_foregroundColour = col; m_foregroundColour = col;
if (m_mainWidget) if (m_mainWidget)
wxDoChangeForegroundColour(m_mainWidget, (wxColour&) col); wxDoChangeForegroundColour(m_mainWidget, (wxColour&) col);
int i; size_t menuCount = GetMenuCount();
for (i = 0; i < m_menuCount; i++) for (size_t i = 0; i < menuCount; i++)
m_menus[i]->SetForegroundColour((wxColour&) col); m_menus[i]->SetForegroundColour((wxColour&) col);
return TRUE;
} }
void wxMenuBar::ChangeFont(bool WXUNUSED(keepOriginalSize)) void wxMenuBar::ChangeFont(bool WXUNUSED(keepOriginalSize))
@@ -1119,13 +968,15 @@ void wxMenuBar::ChangeFont(bool WXUNUSED(keepOriginalSize))
// Nothing to do for menubar, fonts are kept in wxMenus // Nothing to do for menubar, fonts are kept in wxMenus
} }
void wxMenuBar::SetFont(const wxFont& font) bool wxMenuBar::SetFont(const wxFont& font)
{ {
m_font = font; m_font = font;
ChangeFont(); ChangeFont();
int i; size_t menuCount = GetMenuCount();
for (i = 0; i < m_menuCount; i++) for (size_t i = 0; i < menuCount; i++)
m_menus[i]->SetFont(font); m_menus[i]->SetFont(font);
return TRUE;
} }

108
src/motif/menuitem.cpp
View File

@@ -10,9 +10,17 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// headers & declarations // declarations
// ============================================================================ // ============================================================================
#ifdef __GNUG__
#pragma implementation "menuitem.h"
#endif
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/menu.h" #include "wx/menu.h"
#include "wx/menuitem.h" #include "wx/menuitem.h"
#include "wx/utils.h" #include "wx/utils.h"
@@ -30,12 +38,13 @@
#include "wx/motif/private.h" #include "wx/motif/private.h"
void wxMenuItemCallback (Widget w, XtPointer clientData, // ----------------------------------------------------------------------------
XtPointer ptr); // functions prototypes
void wxMenuItemArmCallback (Widget w, XtPointer clientData, // ----------------------------------------------------------------------------
XtPointer ptr);
void wxMenuItemDisarmCallback (Widget w, XtPointer clientData, static void wxMenuItemCallback(Widget w, XtPointer clientData, XtPointer ptr);
XtPointer ptr); static void wxMenuItemArmCallback(Widget w, XtPointer clientData, XtPointer ptr);
static void wxMenuItemDisarmCallback(Widget w, XtPointer clientData, XtPointer ptr);
// ============================================================================ // ============================================================================
// implementation // implementation
@@ -59,20 +68,21 @@ IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id, wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id,
const wxString& strName, const wxString& strHelp, const wxString& strName, const wxString& strHelp,
bool bCheckable, bool bCheckable,
wxMenu *pSubMenu) : wxMenu *pSubMenu)
m_strHelp(strHelp),
m_bCheckable(bCheckable),
m_strName(strName)
{ {
wxASSERT( pParentMenu != NULL ); wxASSERT_MSG( pParentMenu != NULL, wxT("menuitem should have a menu") );
m_pParentMenu = pParentMenu; // common init
m_pSubMenu = pSubMenu; m_parentMenu = pParentMenu;
m_idItem = id; m_subMenu = pSubMenu;
m_bEnabled = TRUE; m_id = id;
m_bChecked = FALSE; m_isEnabled = TRUE;
m_isChecked = FALSE;
m_help = strHelp;
m_isCheckable = bCheckable;
m_text = strName;
//// Motif-specific // Motif-specific
m_menuBar = NULL; m_menuBar = NULL;
m_buttonWidget = (WXWidget) NULL; m_buttonWidget = (WXWidget) NULL;
m_topMenu = NULL; m_topMenu = NULL;
@@ -88,10 +98,10 @@ wxMenuItem::~wxMenuItem()
// delete the sub menu // delete the sub menu
void wxMenuItem::DeleteSubMenu() void wxMenuItem::DeleteSubMenu()
{ {
wxASSERT( m_pSubMenu != NULL ); wxASSERT( m_subMenu != NULL );
delete m_pSubMenu; delete m_subMenu;
m_pSubMenu = NULL; m_subMenu = NULL;
} }
// change item state // change item state
@@ -99,10 +109,11 @@ void wxMenuItem::DeleteSubMenu()
void wxMenuItem::Enable(bool bDoEnable) void wxMenuItem::Enable(bool bDoEnable)
{ {
if ( m_bEnabled != bDoEnable ) if ( m_isChecked != bDoEnable )
{ {
if ( m_pSubMenu == NULL ) if ( !IsSubMenu() )
{ // normal menu item {
// normal menu item
if (m_buttonWidget) if (m_buttonWidget)
XtSetSensitive( (Widget) m_buttonWidget, (Boolean) bDoEnable); XtSetSensitive( (Widget) m_buttonWidget, (Boolean) bDoEnable);
} }
@@ -114,7 +125,7 @@ void wxMenuItem::Enable(bool bDoEnable)
XtSetSensitive( (Widget) m_buttonWidget, (Boolean) bDoEnable); XtSetSensitive( (Widget) m_buttonWidget, (Boolean) bDoEnable);
} }
m_bEnabled = bDoEnable; wxMenuItemBase::Enable(bDoEnable);
} }
} }
@@ -122,13 +133,20 @@ void wxMenuItem::Check(bool bDoCheck)
{ {
wxCHECK_RET( IsCheckable(), "only checkable items may be checked" ); wxCHECK_RET( IsCheckable(), "only checkable items may be checked" );
if ( m_bChecked != bDoCheck ) if ( m_isChecked != bDoCheck )
{ {
if (m_buttonWidget && XtIsSubclass ((Widget) m_buttonWidget, xmToggleButtonGadgetClass)) if ( m_buttonWidget )
{ {
XtVaSetValues ( (Widget) m_buttonWidget, XmNset, (Boolean) bDoCheck, NULL); wxASSERT_MSG( XtIsSubclass((Widget)m_buttonWidget,
xmToggleButtonGadgetClass),
wxT("checkable menu item must be a toggle button") );
XtVaSetValues((Widget)m_buttonWidget,
XmNset, (Boolean)bDoCheck,
NULL);
} }
m_bChecked = bDoCheck;
wxMenuItemBase::Check(bDoCheck);
} }
} }
@@ -143,12 +161,12 @@ void wxMenuItem::CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMen
{ {
// Id=-2 identifies a Title item. // Id=-2 identifies a Title item.
m_buttonWidget = (WXWidget) XtVaCreateManagedWidget m_buttonWidget = (WXWidget) XtVaCreateManagedWidget
(wxStripMenuCodes(m_strName), (wxStripMenuCodes(m_text),
xmLabelGadgetClass, (Widget) menu, NULL); xmLabelGadgetClass, (Widget) menu, NULL);
} }
else if ((!m_strName.IsNull() && m_strName != "") && (!m_pSubMenu)) else if ((!m_text.IsNull() && m_text != "") && (!m_subMenu))
{ {
wxString strName = wxStripMenuCodes(m_strName); wxString strName = wxStripMenuCodes(m_text);
if (IsCheckable()) if (IsCheckable())
{ {
m_buttonWidget = (WXWidget) XtVaCreateManagedWidget (strName, m_buttonWidget = (WXWidget) XtVaCreateManagedWidget (strName,
@@ -160,13 +178,13 @@ void wxMenuItem::CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMen
m_buttonWidget = (WXWidget) XtVaCreateManagedWidget (strName, m_buttonWidget = (WXWidget) XtVaCreateManagedWidget (strName,
xmPushButtonGadgetClass, (Widget) menu, xmPushButtonGadgetClass, (Widget) menu,
NULL); NULL);
char mnem = wxFindMnemonic (m_strName); char mnem = wxFindMnemonic (m_text);
if (mnem != 0) if (mnem != 0)
XtVaSetValues ((Widget) m_buttonWidget, XmNmnemonic, mnem, NULL); XtVaSetValues ((Widget) m_buttonWidget, XmNmnemonic, mnem, NULL);
//// TODO: proper accelerator treatment. What does wxFindAccelerator //// TODO: proper accelerator treatment. What does wxFindAccelerator
//// look for? //// look for?
strName = m_strName; strName = m_text;
char *accel = wxFindAccelerator (strName); char *accel = wxFindAccelerator (strName);
if (accel) if (accel)
XtVaSetValues ((Widget) m_buttonWidget, XmNaccelerator, accel, NULL); XtVaSetValues ((Widget) m_buttonWidget, XmNaccelerator, accel, NULL);
@@ -203,10 +221,10 @@ void wxMenuItem::CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMen
m_buttonWidget = (WXWidget) XtVaCreateManagedWidget ("separator", m_buttonWidget = (WXWidget) XtVaCreateManagedWidget ("separator",
xmSeparatorGadgetClass, (Widget) menu, NULL); xmSeparatorGadgetClass, (Widget) menu, NULL);
} }
else if (m_pSubMenu) else if (m_subMenu)
{ {
m_buttonWidget = m_pSubMenu->CreateMenu (menuBar, menu, topMenu, m_strName, TRUE); m_buttonWidget = m_subMenu->CreateMenu (menuBar, menu, topMenu, m_text, TRUE);
m_pSubMenu->SetButtonWidget(m_buttonWidget); m_subMenu->SetButtonWidget(m_buttonWidget);
XtAddCallback ((Widget) m_buttonWidget, XtAddCallback ((Widget) m_buttonWidget,
XmNcascadingCallback, XmNcascadingCallback,
(XtCallbackProc) wxMenuItemArmCallback, (XtCallbackProc) wxMenuItemArmCallback,
@@ -223,7 +241,7 @@ void wxMenuItem::DestroyItem(bool full)
; // Nothing ; // Nothing
} }
else if ((!m_strName.IsNull() && (m_strName != "")) && !m_pSubMenu) else if ((!m_text.IsNull() && (m_text != "")) && !m_subMenu)
{ {
if (m_buttonWidget) if (m_buttonWidget)
{ {
@@ -251,7 +269,7 @@ void wxMenuItem::DestroyItem(bool full)
XtRemoveCallback ((Widget) m_buttonWidget, XmNcascadingCallback, XtRemoveCallback ((Widget) m_buttonWidget, XmNcascadingCallback,
wxMenuItemArmCallback, (XtPointer) this); wxMenuItemArmCallback, (XtPointer) this);
} }
m_pSubMenu->DestroyMenu(full); m_subMenu->DestroyMenu(full);
if (full) if (full)
m_buttonWidget = NULL; m_buttonWidget = NULL;
} }
@@ -263,12 +281,12 @@ void wxMenuItem::DestroyItem(bool full)
} }
} }
void wxMenuItem::SetLabel(const wxString& label) void wxMenuItem::SetText(const wxString& label)
{ {
char mnem = wxFindMnemonic (label); char mnem = wxFindMnemonic (label);
wxString label2 = wxStripMenuCodes(label); wxString label2 = wxStripMenuCodes(label);
m_strName = label; m_text = label;
if (m_buttonWidget) if (m_buttonWidget)
{ {
@@ -291,6 +309,10 @@ void wxMenuItem::SetLabel(const wxString& label)
} }
} }
// ----------------------------------------------------------------------------
// Motif callbacks
// ----------------------------------------------------------------------------
void wxMenuItemCallback (Widget WXUNUSED(w), XtPointer clientData, void wxMenuItemCallback (Widget WXUNUSED(w), XtPointer clientData,
XtPointer WXUNUSED(ptr)) XtPointer WXUNUSED(ptr))
{ {
@@ -301,7 +323,9 @@ void wxMenuItemCallback (Widget WXUNUSED(w), XtPointer clientData,
{ {
Boolean isChecked = FALSE; Boolean isChecked = FALSE;
XtVaGetValues ((Widget) item->GetButtonWidget(), XmNset, & isChecked, NULL); XtVaGetValues ((Widget) item->GetButtonWidget(), XmNset, & isChecked, NULL);
item->SetChecked(isChecked);
// only set the flag, don't actually check anything
item->wxMenuItemBase::Check(isChecked);
} }
if (item->GetMenuBar() && item->GetMenuBar()->GetMenuBarFrame()) if (item->GetMenuBar() && item->GetMenuBar()->GetMenuBarFrame())
{ {