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

1. small dnd compilation fixes (no attempt to make icon setting work though)

Browse Source 
2. wxMenuItemBase appears
3. more key combinations handled by wxGTK for menu accels


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4184 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-10-25 15:51:37 +00:00
parent 84a3fe2c9b
commit 974e8d946f
17 changed files with 621 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/wx/dnd.h
View File

@@ -17,6 +17,7 @@
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
#include "wx/cursor.h"
// ----------------------------------------------------------------------------
// constants

6
include/wx/gtk/menu.h
View File

@@ -29,12 +29,6 @@ class wxMenuBar;
class wxMenuItem;
class wxMenu;
//-----------------------------------------------------------------------------
// const
//-----------------------------------------------------------------------------
#define ID_SEPARATOR (-1)
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------

82
include/wx/gtk/menuitem.h
View File

@@ -14,83 +14,43 @@
#pragma interface
#endif
#include "wx/defs.h"
#include "wx/string.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
#define ID_SEPARATOR (-1)
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxMenuItem;
class wxMenu;
//-----------------------------------------------------------------------------
// wxMenuItem
//-----------------------------------------------------------------------------
class wxMenuItem : public wxObject
class wxMenuItem : public wxMenuItemBase
{
DECLARE_DYNAMIC_CLASS(wxMenuItem)
public:
wxMenuItem();
wxMenuItem(wxMenu *parentMenu = (wxMenu *)NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
bool isCheckable = FALSE,
wxMenu *subMenu = (wxMenu *)NULL);
~wxMenuItem();
// accessors
// id
void SetId(int id) { m_id = id; }
int GetId() const { return m_id; }
bool IsSeparator() const { return m_id == ID_SEPARATOR; }
// the item's text = name
void SetName(const wxString& str);
void SetText(const wxString& str) { SetName(str); } // compatibility
const wxString& GetName() const { return m_text; }
const wxString& GetText() const { return GetName(); }
// what kind of menu item we are
void SetCheckable(bool checkable) { m_isCheckMenu = checkable; }
bool IsCheckable() const { return m_isCheckMenu; }
void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
wxMenu *GetSubMenu() const { return m_subMenu; }
bool IsSubMenu() const { return m_subMenu != NULL; }
// state
void Enable( bool enable = TRUE );
bool IsEnabled() const { return m_isEnabled; }
void Check( bool check = TRUE );
bool IsChecked() const;
// help string (displayed in the status bar by default)
void SetHelp(const wxString& str) { m_helpStr = str; }
const wxString& GetHelp() const { return m_helpStr; }
// implement base class virtuals
virtual void SetText( const wxString& str ) { DoSetText(str); }
virtual void Enable( bool enable = TRUE );
virtual void Check( bool check = TRUE );
virtual bool IsChecked() const;
// implementation
void SetMenuItem(GtkWidget *menuItem) { m_menuItem = menuItem; }
GtkWidget *GetMenuItem() const { return m_menuItem; }
wxString GetHotKey() const { return m_hotKey; }
void SetCheckedFlag(bool checked) { m_isChecked = checked; }
bool GetCheckedFlag() const { return m_isChecked; }
private:
int m_id;
wxString m_text;
wxString m_hotKey;
bool m_isCheckMenu;
bool m_isChecked;
bool m_isEnabled;
wxMenu *m_subMenu;
wxString m_helpStr;
// DoSetText() transforms the accel mnemonics in our label from MSW/wxWin
// style to GTK+ and is called from ctor and SetText()
void DoSetText(const wxString& text);
GtkWidget *m_menuItem; // GtkMenuItem
wxString m_hotKey;
GtkWidget *m_menuItem; // GtkMenuItem
DECLARE_DYNAMIC_CLASS(wxMenuItem)
};

6
include/wx/gtk1/menu.h
View File

@@ -29,12 +29,6 @@ class wxMenuBar;
class wxMenuItem;
class wxMenu;
//-----------------------------------------------------------------------------
// const
//-----------------------------------------------------------------------------
#define ID_SEPARATOR (-1)
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------

82
include/wx/gtk1/menuitem.h
View File

@@ -14,83 +14,43 @@
#pragma interface
#endif
#include "wx/defs.h"
#include "wx/string.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
#define ID_SEPARATOR (-1)
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxMenuItem;
class wxMenu;
//-----------------------------------------------------------------------------
// wxMenuItem
//-----------------------------------------------------------------------------
class wxMenuItem : public wxObject
class wxMenuItem : public wxMenuItemBase
{
DECLARE_DYNAMIC_CLASS(wxMenuItem)
public:
wxMenuItem();
wxMenuItem(wxMenu *parentMenu = (wxMenu *)NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
bool isCheckable = FALSE,
wxMenu *subMenu = (wxMenu *)NULL);
~wxMenuItem();
// accessors
// id
void SetId(int id) { m_id = id; }
int GetId() const { return m_id; }
bool IsSeparator() const { return m_id == ID_SEPARATOR; }
// the item's text = name
void SetName(const wxString& str);
void SetText(const wxString& str) { SetName(str); } // compatibility
const wxString& GetName() const { return m_text; }
const wxString& GetText() const { return GetName(); }
// what kind of menu item we are
void SetCheckable(bool checkable) { m_isCheckMenu = checkable; }
bool IsCheckable() const { return m_isCheckMenu; }
void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
wxMenu *GetSubMenu() const { return m_subMenu; }
bool IsSubMenu() const { return m_subMenu != NULL; }
// state
void Enable( bool enable = TRUE );
bool IsEnabled() const { return m_isEnabled; }
void Check( bool check = TRUE );
bool IsChecked() const;
// help string (displayed in the status bar by default)
void SetHelp(const wxString& str) { m_helpStr = str; }
const wxString& GetHelp() const { return m_helpStr; }
// implement base class virtuals
virtual void SetText( const wxString& str ) { DoSetText(str); }
virtual void Enable( bool enable = TRUE );
virtual void Check( bool check = TRUE );
virtual bool IsChecked() const;
// implementation
void SetMenuItem(GtkWidget *menuItem) { m_menuItem = menuItem; }
GtkWidget *GetMenuItem() const { return m_menuItem; }
wxString GetHotKey() const { return m_hotKey; }
void SetCheckedFlag(bool checked) { m_isChecked = checked; }
bool GetCheckedFlag() const { return m_isChecked; }
private:
int m_id;
wxString m_text;
wxString m_hotKey;
bool m_isCheckMenu;
bool m_isChecked;
bool m_isEnabled;
wxMenu *m_subMenu;
wxString m_helpStr;
// DoSetText() transforms the accel mnemonics in our label from MSW/wxWin
// style to GTK+ and is called from ctor and SetText()
void DoSetText(const wxString& text);
GtkWidget *m_menuItem; // GtkMenuItem
wxString m_hotKey;
GtkWidget *m_menuItem; // GtkMenuItem
DECLARE_DYNAMIC_CLASS(wxMenuItem)
};

129
include/wx/menuitem.h
View File

@@ -1,21 +1,122 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/menuitem.h
// Purpose: wxMenuItem class
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.10.99
// RCS-ID: $Id$
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MENUITEM_H_BASE_
#define _WX_MENUITEM_H_BASE_
#if defined(__WXMSW__)
#include "wx/msw/menuitem.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/menuitem.h"
#elif defined(__WXGTK__)
#include "wx/gtk/menuitem.h"
#elif defined(__WXQT__)
#include "wx/qt/menuitem.h"
#elif defined(__WXMAC__)
#include "wx/mac/menuitem.h"
#elif defined(__WXPM__)
#include "wx/os2/menuitem.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/menuitem.h"
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/object.h" // base class
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// id for a separator line in the menu (invalid for normal item)
#define wxID_SEPARATOR (-1)
#ifndef ID_SEPARATOR // for compatibility only, don't use in new code
#define ID_SEPARATOR wxID_SEPARATOR
#endif
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenuItem;
class WXDLLEXPORT wxMenu;
// ----------------------------------------------------------------------------
// wxMenuItem is an item in the menu which may be either a normal item, a sub
// menu or a separator
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenuItemBase : public wxObject
{
public:
// creation
static wxMenuItem *New(wxMenu *parentMenu = (wxMenu *)NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
bool isCheckable = FALSE,
wxMenu *subMenu = (wxMenu *)NULL);
// get/set id
void SetId(int id) { m_id = id; }
int GetId() const { return m_id; }
bool IsSeparator() const { return m_id == wxID_SEPARATOR; }
// the item's text (or name, or label...)
virtual void SetText(const wxString& str) { m_text = str; }
const wxString& GetText() const { return m_text; }
// what kind of menu item we are
virtual void SetCheckable(bool checkable) { m_isCheckable = checkable; }
bool IsCheckable() const { return m_isCheckable; }
bool IsSubMenu() const { return m_subMenu != NULL; }
void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
wxMenu *GetSubMenu() const { return m_subMenu; }
// state
virtual void Enable(bool enable = TRUE) { m_isEnabled = enable; }
virtual bool IsEnabled() const { return m_isEnabled; }
virtual void Check(bool check = TRUE) { m_isChecked = check; }
virtual bool IsChecked() const { return m_isChecked; }
// help string (displayed in the status bar by default)
void SetHelp(const wxString& str) { m_help = str; }
const wxString& GetHelp() const { return m_help; }
// compatibility only, use new functions in the new code
void SetName(const wxString& str) { SetText(str); }
const wxString& GetName() const { return GetText(); }
protected:
int m_id; // numeric id of the item >= 0 or -1
wxMenu *m_parentMenu, // the menu we belong to
*m_subMenu; // our sub menu or NULL
wxString m_text, // label of the item
m_help; // the help string for the item
bool m_isCheckable; // can be checked?
bool m_isChecked; // is checked?
bool m_isEnabled; // is enabled?
};
// ----------------------------------------------------------------------------
// include the real class declaration
// ----------------------------------------------------------------------------
#ifdef wxUSE_BASE_CLASSES_ONLY
#define wxMenuItem wxMenuItemBase
#else // !wxUSE_BASE_CLASSES_ONLY
#if defined(__WXMSW__)
#include "wx/msw/menuitem.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/menuitem.h"
#elif defined(__WXGTK__)
#include "wx/gtk/menuitem.h"
#elif defined(__WXQT__)
#include "wx/qt/menuitem.h"
#elif defined(__WXMAC__)
#include "wx/mac/menuitem.h"
#elif defined(__WXPM__)
#include "wx/os2/menuitem.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/menuitem.h"
#endif
#endif // wxUSE_BASE_CLASSES_ONLY/!wxUSE_BASE_CLASSES_ONLY
#endif
// _WX_MENUITEM_H_BASE_

12
include/wx/msw/menu.h
View File

@@ -22,7 +22,7 @@
#include "wx/string.h"
#if wxUSE_ACCEL
#include "wx/accel.h"
#include "wx/accel.h"
#endif // wxUSE_ACCEL
class WXDLLEXPORT wxMenuItem;
@@ -32,6 +32,8 @@ class WXDLLEXPORT wxFrame;
WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
WX_DEFINE_ARRAY(wxAcceleratorEntry *, wxAcceleratorArray);
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
@@ -50,7 +52,7 @@ public:
wxMenu( long WXUNUSED(style) )
{
Init( wxEmptyString );
Init( wxEmptyString );
}
wxMenu(const wxString& title = wxEmptyString, long WXUNUSED(style) = 0)
@@ -147,7 +149,7 @@ public:
void Detach();
#if wxUSE_ACCEL
size_t GetAccelCount() const { return m_accelKeyCodes.GetCount(); }
size_t GetAccelCount() const { return m_accels.GetCount(); }
size_t CopyAccels(wxAcceleratorEntry *accels) const;
#endif // wxUSE_ACCEL
@@ -186,8 +188,8 @@ private:
void* m_clientData;
#if wxUSE_ACCEL
// the accelerators data
wxArrayInt m_accelKeyCodes, m_accelFlags, m_accelIds;
// the accelerators for our menu items
wxAcceleratorArray m_accels;
#endif // wxUSE_ACCEL
};

85
include/wx/msw/menuitem.h
View File

@@ -20,81 +20,50 @@
// 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"
#include "wx/ownerdrw.h" // base class
#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
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenuItem: public wxObject
class WXDLLEXPORT wxMenuItem : public wxMenuItemBase
#if wxUSE_OWNER_DRAWN
, public wxOwnerDrawn
, public wxOwnerDrawn
#endif
{
DECLARE_DYNAMIC_CLASS(wxMenuItem)
public:
// ctor & dtor
wxMenuItem(wxMenu *pParentMenu = NULL, int id = ID_SEPARATOR,
const wxString& strName = "", const wxString& wxHelp = "",
bool bCheckable = FALSE, wxMenu *pSubMenu = NULL);
virtual ~wxMenuItem();
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = (wxMenu *)NULL,
int id = wxID_SEPARATOR,
const wxString& name = wxEmptyString,
const wxString& help = wxEmptyString,
bool isCheckable = FALSE,
wxMenu *subMenu = (wxMenu *)NULL);
virtual ~wxMenuItem();
// accessors (some more are inherited from wxOwnerDrawn or are below)
bool IsSeparator() const { return m_idItem == ID_SEPARATOR; }
bool IsEnabled() const { return m_bEnabled; }
bool IsChecked() const { return m_bChecked; }
bool IsSubMenu() const { return GetSubMenu() != NULL; }
// override base class virtuals
virtual void SetText(const wxString& strName);
virtual void SetCheckable(bool checkable);
int GetId() const { return m_idItem; }
const wxString& GetHelp() const { return m_strHelp; }
wxMenu *GetSubMenu() const { return m_pSubMenu; }
virtual void Enable(bool bDoEnable = TRUE);
virtual void Check(bool bDoCheck = TRUE);
// the id for a popup menu is really its menu handle (as required by
// ::AppendMenu() API)
int GetRealId() const;
// unfortunately needed to resolve ambiguity between
// wxMenuItemBase::IsCheckable() and wxOwnerDrawn::IsCheckable()
bool IsCheckable() const { return wxMenuItemBase::IsCheckable(); }
// operations
void SetName(const wxString& strName);
void SetHelp(const wxString& strHelp) { m_strHelp = strHelp; }
// the id for a popup menu is really its menu handle (as required by
// ::AppendMenu() API), so this function will return either the id or the
// menu handle depending on what we're
int GetRealId() const;
void Enable(bool bDoEnable = TRUE);
void Check(bool bDoCheck = TRUE);
void DeleteSubMenu();
// delete the submenu
void DeleteSubMenu();
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)
#if wxUSE_OWNER_DRAWN
// 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
DECLARE_DYNAMIC_CLASS(wxMenuItem)
};
#endif //_MENUITEM_H

30
include/wx/ownerdrw.h
View File

@@ -12,11 +12,13 @@
#ifndef _OWNERDRW_H
#define _OWNERDRW_H
#ifdef __GNUG__
#pragma interface "ownerdrw.h"
#endif
#include "wx/setup.h"
#include <stddef.h>
#if wxUSE_OWNER_DRAWN
#ifdef __GNUG__
#pragma interface "ownerdrw.h"
#endif
// ----------------------------------------------------------------------------
// wxOwnerDrawn - a mix-in base class, derive from it to implement owner-drawn
@@ -26,11 +28,12 @@
// also supports 3 bitmaps: either a checked/unchecked bitmap for a checkable
// element or one unchangeable bitmap otherwise.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxOwnerDrawn
{
public:
// ctor & dtor
wxOwnerDrawn(const wxString& str = "",
wxOwnerDrawn(const wxString& str = wxEmptyString,
bool bCheckable = FALSE,
bool bMenuItem = FALSE); // FIXME kludge for colors
virtual ~wxOwnerDrawn() { }
@@ -78,17 +81,18 @@ public:
static int GetDefaultMarginWidth() { return (int) ms_nDefaultMarginWidth; }
// accessors
void SetName(const wxString& strName) { m_strName = strName; }
const wxString& GetName() const { return m_strName; }
bool IsCheckable() const { return m_bCheckable; }
void SetName(const wxString& strName) { m_strName = strName; }
const wxString& GetName() const { return m_strName; }
void SetCheckable(bool checkable) { m_bCheckable = checkable; }
bool IsCheckable() const { return m_bCheckable; }
// this function might seem strange, but if it returns FALSE it means that
// no non-standard attribute are set, so there is no need for this control
// to be owner-drawn. Moreover, you can force owner-drawn to FALSE if you
// want to change, say, the color for the item but only if it is owner-drawn
// (see wxMenuItem::wxMenuItem for example)
bool IsOwnerDrawn() const { return m_bOwnerDrawn; }
void ResetOwnerDrawn() { m_bOwnerDrawn = FALSE; }
bool IsOwnerDrawn() const { return m_bOwnerDrawn; }
void ResetOwnerDrawn() { m_bOwnerDrawn = FALSE; }
public:
// constants used in OnDrawItem
@@ -125,14 +129,16 @@ private:
m_bOwnerDrawn; // true if something is non standard
wxFont m_font; // font to use for drawing
wxColour m_colText, // color ----"---"---"----
wxColour m_colText, // color ----"---"---"----
m_colBack; // background color
wxBitmap m_bmpChecked, // bitmap to put near the item
m_bmpUnchecked; // (checked is used also for 'uncheckable' items)
size_t m_nHeight, // font height
size_t m_nHeight, // font height
m_nMarginWidth; // space occupied by bitmap to the left of the item
};
#endif // wxUSE_OWNER_DRAWN
#endif
// _OWNERDRW_H

7
include/wx/utils.h
View File

@@ -221,12 +221,17 @@ WXDLLEXPORT wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
#if wxUSE_GUI // GUI only things from now on
// ----------------------------------------------------------------------------
// Strip out any menu codes
// Menu accelerators related things
// ----------------------------------------------------------------------------
WXDLLEXPORT wxChar* wxStripMenuCodes(wxChar *in, wxChar *out = (wxChar *) NULL);
WXDLLEXPORT wxString wxStripMenuCodes(const wxString& str);
#if wxUSE_ACCEL
class WXDLLEXPORT wxAcceleratorEntry;
WXDLLEXPORT wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);
#endif // wxUSE_ACCEL
// ----------------------------------------------------------------------------
// Window search
// ----------------------------------------------------------------------------