1. 创建和使用wxPython菜单

本章内容包括：

创建菜单 使用菜单项工作 添加子菜单、弹出菜单和自定义菜单 菜单的设计准则

难以想象一个应用程序的顶部没有我们常见的以File和Edit开头，以Help结尾的栏目。这太糟糕了。菜单是那些隐藏在背后并不太重视绘制的标准界面工具的一个公共的部分，由于菜单使得用户能够快速而容易地访问所有的功能，所以它实实在在是一个革命。

在wxPython中有三个主要的类，它们管理菜单的功能。类wx.MenuBar管理菜单栏自身，而wx.Menu管理一个单独的下拉或弹出菜单。当然，一个wx.MenuBar实例可以包含多个wx.Menu实例。类wx.MenuItem代表一个wx.Menu中的一个特定项目。

在第二章中我们对菜单作了一个简要的介绍，在例5.5中我们提供了一个容易创建菜单项的机制，在第7章中我对特殊的菜单效果作了一些介绍。在这一章，我们将对wxPython菜单的创建和使用提供更多的细节。

1.1. 创建菜单

首先，我们将讨论菜单栏。要使用一个菜单栏，就要执行下面这些行动：

·创建菜单栏 ·把菜单栏附加给框架 ·创建单个的菜单 ·把菜单附加给菜单栏或一个父菜单 ·创建单个的菜单项 ·把这些菜单项附加给适当的菜单 ·为每个菜单项创建一个事件绑定

上面行动的执行顺序可以灵活点，只要你在使用之前创建所有项目，并且所有行动在框架的初始化方法中完成就可以了。在这个过程中你可以以后来处理菜单，但是在框架可见后，你的执行顺序将影响用户所见到的东西。例如，如果你在框架创建后将菜单栏附加给框架，或等到直到所有其它的过程完成了。考虑到可读性和维护的目的，我们推荐你将相关的部分分整理在一起。对于如何组织菜单的创建的建议，请看第5章的重构。在接下来的部分，我们将涉及基本的菜单任务。

1.1.1. 如何创建一个菜单栏并把它附加到一个框架？

要创建一个菜单栏，使用wx.MenuBar构造函数，它没有参数：

   1 wx.MenuBar()

一旦菜单栏被创建了，使用SetMenuBar()方法将它附加给一个wx.Frame（或其子类）。通常这些都在框架的__init__或OnInit()方法中实施：

   1 menubar = wx.MenuBar()
   2 self.SetMenuBar

你不必为菜单栏维护一个临时变量，但是这样做将使得添加菜单到菜单栏多少更简单点。要掌握程序中的其它地方的菜单栏，使用wx.Frame.GetMenuBar()。

1.1.2. 如何创建一个菜单并把它附加到菜单栏？

wxPython菜单栏由一个个的菜单组成，其中的每个菜单都需要分别被创建。下面显示了wx.Menu的构造函数：

   1 wx.Menu(title="", style=0)

对于wx.Menu只有一个有效的样式。在GTK下，样式wx.MENU_TEAROFF使得菜单栏上的菜单能够被分开并作为独立的选择器。在其它平台下，这个样式没有作用。如果平台支持，那么菜单被创建时可以有一个标题。图10.1显示了一个带有三个菜单的空白窗口。例10.1显示了被添到一个菜单栏上的一系列菜单，这些菜单没有被添加菜单项。

图10.1

例10.1 添加菜单到一个菜单栏

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1, "Simple Menu Example")
   6         p = wx.Panel(self)
   7         menuBar = wx.MenuBar()# 创建一个菜单栏
   8         menu = wx.Menu()# 创建一个菜单
   9         menuBar.Append(menu, "Left Menu")# 添加菜单到菜单栏
  10         menu2 = wx.Menu()
  11         menuBar.Append(menu2, "Middle Menu")
  12         menu3 = wx.Menu()
  13         menuBar.Append(menu3, "Right Menu")
  14         self.SetMenuBar(menuBar)
  15 
  16 if __name__ == "__main__":
  17     app = wx.PySimpleApp()
  18     frame = MyFrame()
  19     frame.Show()
  20     app.MainLoop()

在wxPython的菜单API中，一个对象的大部分处理是由它的容器类来管理的。在本章的后面，我们将讨论wx.Menu的特定的方法，因为这些方法的大多数涉及到菜单中的菜单项的处理。在这一节的剩余部分，由于我们正在谈论处理wx.Menu对象，所以我们将列出wx.MenuBar的那些涉及到菜单的方法。表10.1显示了wx.MenuBar中的四个方法，它们处理菜单栏的内容。

表10.1 在菜单栏处理菜单的wx.MenuBar的方法

wx.MenuBar包含一些其它的方法。它们用另外的方式处理菜单栏中的菜单，如表10.2所示。

表10.2 wx.MenuBar的菜单属性方法

1.1.3. 如何给下拉菜单填加项目？

这里有一对机制用于将新的菜单项添加给一个下拉菜单。较容易的是使用wx.Menu的Append()方法：

   1 Append(id, string, helpStr="", kind=wx.ITEM_NORMAL)

参数id是一个wxPython ID。参数string是将被显示在菜单上的字符串。当某个菜单高亮时，如果设置了参数helpStr，那么该参数将被显示在框架的状态栏中。kind参数使你能够设置菜单项的类型，通过该参数可以将菜单项设置为开关类型。在这一章的后面，我们将讨论管理开关项的更好的方法。Append方法把新的项放到菜单的尾部。

例10.2 显示了一个使用Append()方法来建立一个有两个项链和一个分隔符的菜单。

例10.2 添加项目到一个菜单的示例代码

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1, "Simple Menu Example")
   6         p = wx.Panel(self)
   7         self.CreateStatusBar()
   8         menu = wx.Menu()
   9         simple = menu.Append(-1, "Simple menu item", "This is some help text")
  10         menu.AppendSeparator()
  11         exit = menu.Append(-1, "Exit")
  12         self.Bind(wx.EVT_MENU, self.OnSimple, simple)
  13         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  14         menuBar = wx.MenuBar()
  15         menuBar.Append(menu, "Simple Menu")
  16         self.SetMenuBar(menuBar)
  17 
  18     def OnSimple(self, event):
  19         wx.MessageBox("You selected the simple menu item")
  20 
  21     def OnExit(self, event):
  22         self.Close()
  23 
  24 if __name__ == "__main__":
  25     app = wx.PySimpleApp()
  26     frame = MyFrame()
  27     frame.Show()
  28     app.MainLoop()

图10.2 显示了一个带有分隔符和状态文本的菜单。

图10.2

连同Append()一起，这里还有两个另外的用于菜单项插入的方法。要把一个菜单项放在菜单的开头，使用下面两个方法之一：

·Prepend(id, string, helpStr="", kind=wx.ITEM_NORMAL) ·PrependSeparator()

要把新的项放入菜单中的任一位置，使用这下面的insert方法之一：

·Insert(pos, id, string, helpStr="", kind=wx.ITEM_NORMAL) ·InsertSeparator(pos)

参数pos是菜单项要插入的位置的索引，所以如果索引为0，则新的项被放置在开头，如果索引值为菜单的尺寸，那么新的项被放置在尾部。所以在插入点后的菜单项将被向下移动。

所有的这些插入方法都隐含地创建一个wx.MenuItem类的实例。你也可以使用该类的构造函数显式地创建该类的一个实例，以便设置该菜单项的除了标签以外的其它的属性。比如你可以设置自定义的字体或颜色。wx.MenuItem的构造函数如下：

wx.MenuItem(parentMenu=None, id=ID_ANY, text="",

• helpString="", kind=wx.ITEM_NORMAL, subMenu=None)

参数parentMenu必须是一个wx.Menu实例（如果设置了的话）。当构造时，这个新的菜单项不是自动被添加到父菜单上显示的。你必须自己来实现。这个行为与wxPython窗口部件和它们的容器的通常的行为不同。参数id是新项的标识符。参数text是新项显示在菜单中的字符串，参数helpString是当该菜单项高亮时显示在状态栏中的字符串。kind是菜单项的类型，wx.ITEM_NORMAL代表纯菜单项；我们以后会看到开关菜单项有不同的类型值。如果参数subMenu的值不是null，那么这个新的菜单项实际上就是一个子菜单。我们不推荐你使用这个机制来创建子菜单；替而代之，可以使用在10.3节中说明的机制来装扮你的菜单。

不像大多数窗口部件，创建菜单项并不将它添加到指定的父菜单。要将新的菜单项添加到一个菜单中，使用下面的wx.Menu方法之一：

·AppendItem(aMenuItem) ·InsertItem(pos, aMenuItem) ·PrependItem(aMenuItem)

要从菜单中删除一个菜单项，使用方法Remove(id)，它要求一个wxPython ID，或RemoveItem(item)，它要求一个菜单项作为参数。删除一个菜单项后，后面的菜单项将上移。Remove()方法将返回所删除的实际的菜单项。这使你能够存储该菜单项以备后用。与菜单栏不同，菜单没有直接替换菜单项的方法。替换必须通过先删除再插入来实现。

wx.Menu类也有两个用来获取它的菜单项的信息的get*方法。GetMenuItemCount()返回菜单中项目的数量，GetMenuItems()返回菜单中项目的一个列表，项目在列表中的顺序与菜单中的位置相一致。这个列表是菜单中实际列表的一个拷贝，意味着改变所返回的列表，不会改变菜单本身。

对于有效的菜单，你可以在运行时继续添加或删除菜单项。例10.3显示了在运行时添加菜单的示例代码。当按钮被按下时，调用OnAddItem()的方法来插入一个新的项到菜单的尾部。

例10.3 运行时添加菜单项

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Add Menu Items")
   7         p = wx.Panel(self)
   8         self.txt = wx.TextCtrl(p, -1, "new item")
   9         btn = wx.Button(p, -1, "Add Menu Item")
  10         self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)# 绑定按钮的事件
  11 
  12         sizer = wx.BoxSizer(wx.HORIZONTAL)
  13         sizer.Add(self.txt, 0, wx.ALL, 20)
  14         sizer.Add(btn, 0, wx.TOP|wx.RIGHT, 20)
  15         p.SetSizer(sizer)
  16 
  17         self.menu = menu = wx.Menu()
  18         simple = menu.Append(-1, "Simple menu item")
  19         menu.AppendSeparator()
  20         exit = menu.Append(-1, "Exit")
  21         self.Bind(wx.EVT_MENU, self.OnSimple, simple)
  22         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  23 
  24         menuBar = wx.MenuBar()
  25         menuBar.Append(menu, "Menu")
  26         self.SetMenuBar(menuBar)
  27 
  28 
  29     def OnSimple(self, event):
  30         wx.MessageBox("You selected the simple menu item")
  31 
  32     def OnExit(self, event):
  33         self.Close()
  34 
  35     def OnAddItem(self, event):
  36         item = self.menu.Append(-1, self.txt.GetValue())# 添加菜单项
  37         self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)# 绑定一个菜单事件
  38 
  39     def OnNewItemSelected(self, event):
  40         wx.MessageBox("You selected a new item")
  41 
  42 
  43 
  44 if __name__ == "__main__":
  45     app = wx.PySimpleApp()
  46     frame = MyFrame()
  47     frame.Show()
  48     app.MainLoop()

在这个例子中，OnAddItem()读取文本域中的文本，并使用Append()来添加一个新的项到菜单中。另外，它绑定了一个菜单事件，以便这个新的菜单项有相应的功能。在下一节，我们将讨论菜单事件。

1.1.4. 如何响应一个菜单事件？

在最后这一小节，我们展示两个响应菜单选择的例子代码。像我们在第8章见过的许多窗口部件一样，选择一个菜单项将触发一个特定类型的wx.CommandEvent的一个实例。在此处，该类型是wx.EVT_MENU。

菜单项事件在两个方面与系统中其它的命令事件不同。首先，用于关联菜单项事件与特定回调函数的Bind()函数是在包含菜单栏的框架上的。第二，由于框架通常有多个与wx.EVT_MENU触发相对应的菜单项，所以Bind()方法需要第三个参数，它就是菜单项本身。这使得框架能区分不同的菜单项事件。

一个典型的绑定一个菜单事件的调用如下所示：

   1 self.Bind(wx.EVT_MENU, self.OnExit, exit_menu_item)

self是框架，self.OnExit是处理方法，exit_menu_item是菜单项自身。

尽管通过框架绑定菜单事件的主意似乎有一点古怪，但是它是有原因的。通过框架绑定事件使你能够透明地绑定一个工具栏按钮到与菜单项相同的处理器。如果该工具栏按钮有与一个菜单项相同的wxPython ID的话，那么这个单个的对wx.EVT_MENU的Bind()调用将同时绑定该菜单选择和该工具栏按钮敲击。这是可行的，因为菜单项事件与工具事件都经由该框架得到。如果菜单项事件在菜单栏中被处理，那么菜单栏将不会看到工具栏事件。

有时，你会有多个菜单项需要被绑定到同一个处理器。例如，一套单选按钮开关菜单（它们本质上作相同的事情）可能被绑定给同一处理器。如果菜单项有连续的标识符号的话，为了避免分别的一一绑定，可以使用wx.EVT_MENU_RANGE事件类型：

   1 self.Bind(wx.EVT_MENU_RANGE, function, id=menu1, id2=menu2)

在这种情况下，所有标识号位于[menu1,menu2]间菜单项都将绑定到给定的函数。

尽管通常你只关心菜单项命令事件，但是这儿有你能够响应的另外的菜单事件。在wxPython中，类wx.MenuEvent管理菜单的绘制和高亮事件。表10.3说明了wx.MenuEvent的四个事件类型。

表10.3 wx.MenuEvent的事件类型

现在我们已经讨论了创建菜单的基础知识，我们将开始说明如何使用菜单项来工作。

1.2. 使用菜单项工作

尽管菜单和菜单栏对于一个菜单系统很明显是至关重要的，但是你的大部分时间和工作将化在处理菜单项上。在下面的几节中，我们将谈论通常的菜单项函数，如查找一个项目，使一个菜单项有效或无效，创建开关菜单项和分配快捷键。

1.2.1. 如何在一个菜单中找到一个特定的菜单项？

在wxPython中有许多方法用于查找一个特定的菜单或给定了标签或标识符的菜单项。你经常在事件处理器中使用这些方法，尤其是当你想修改一个菜单项或在另一个位置显示它的标签文本时。例10.1对先前的动态菜单例子作了补充，它通过使用FindItemById()得到菜单项以显示。

例10.4 发现一个特定的菜单项

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Find Item Example")
   7         p = wx.Panel(self)
   8         self.txt = wx.TextCtrl(p, -1, "new item")
   9         btn = wx.Button(p, -1, "Add Menu Item")
  10         self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)
  11 
  12         sizer = wx.BoxSizer(wx.HORIZONTAL)
  13         sizer.Add(self.txt, 0, wx.ALL, 20)
  14         sizer.Add(btn, 0, wx.TOP|wx.RIGHT, 20)
  15         p.SetSizer(sizer)
  16 
  17         self.menu = menu = wx.Menu()
  18         simple = menu.Append(-1, "Simple menu item")
  19         menu.AppendSeparator()
  20         exit = menu.Append(-1, "Exit")
  21         self.Bind(wx.EVT_MENU, self.OnSimple, simple)
  22         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  23 
  24         menuBar = wx.MenuBar()
  25         menuBar.Append(menu, "Menu")
  26         self.SetMenuBar(menuBar)
  27 
  28     def OnSimple(self, event):
  29         wx.MessageBox("You selected the simple menu item")
  30 
  31     def OnExit(self, event):
  32         self.Close()
  33 
  34     def OnAddItem(self, event):
  35         item = self.menu.Append(-1, self.txt.GetValue())
  36         self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)
  37 
  38     def OnNewItemSelected(self, event):
  39         item = self.GetMenuBar().FindItemById(event.GetId()) #得到菜单项   
  40         text = item.GetText()
  41         wx.MessageBox("You selected the '%s' item" % text)
  42 
  43 
  44 if __name__ == "__main__":
  45     app = wx.PySimpleApp()
  46     frame = MyFrame()
  47     frame.Show()
  48     app.MainLoop()

在这个例子中，FindItemById()被用来得到一个菜单项的标签文本以便显示。

wx.MenuBar和wx.Menu对于查找特定的菜单项有着本质上相同的方法。其主要的区别是，wx.MenuBar的方法将查找整个菜单栏上的菜单项，而wx.Menu只查找特定的菜单。大多数情况下，推荐使用wx.MenuBar的方法，因为菜单栏容易使用wx.Frame.GetMenuBar()方法来访问。

要从一个菜单栏查找一个顶级的菜单，使用菜单栏方法FindMenu(title)。这个方法返回相应菜单的索引或常量wx.NOT_FOUND。要得到实际的菜单，使用GetMenu()：

   1 def FindMenuInMenuBar(menuBar, title):
   2     pos = menuBar.FindMenu(title)
   3     if pos == wx.NOT_FOUND:
   4         return None
   5     return menuBar.GetMenu(pos)

FindMenu方法的title参数匹配菜单的标题（不管菜单的标题有无修饰标签字符）。例如，即使菜单的标题是 ，FindMenu("File")仍将匹配该菜单项。在菜单类中的所有基于标签字符串发现一个菜单项的方法都有这个功能。

表10.4指出了wx.MenuBar的这些方法，它们能够被用于查找或处理一个特定的菜单项。

表10.4 wx.MenuBar的菜单项处理方法

表10.5 显示了用于wx.Menu的菜单项处理方法。它们分别与菜单栏中的方法相类似，除了所返回的菜单项必须在所调用的菜单实例中。

在菜单项返回后，你可能想做些有用的事情，如使该菜单项有效或无效。在下一节，我们将讨论使用菜单项有效或无效。

表10.5 wx.Menu的菜单项方法

1.2.2. 如何使一个菜单项有效或无效？

类似于其它的窗口部件，菜单和菜单项也可以有有效或无效状态。一个无效的菜单或菜单项通常显示为灰色文本，而非黑色。无效的菜单或菜单项不触发高亮或选择事件，它对于系统来说是不可见的。

例10.5显示了开关菜单项的有效状态的示例代码，其中在按钮的事件处理器中使用了菜单栏的IsEnabled()和Enable()方法。

例10.5

   1 import wx
   2 
   3 ID_SIMPLE = wx.NewId()
   4 
   5 class MyFrame(wx.Frame):
   6     def __init__(self):
   7         wx.Frame.__init__(self, None, -1,
   8                           "Enable/Disable Menu Example")
   9         p = wx.Panel(self)
  10         self.btn = wx.Button(p, -1, "Disable Item", (20,20))
  11         self.Bind(wx.EVT_BUTTON, self.OnToggleItem, self.btn)
  12 
  13         menu = wx.Menu()
  14         menu.Append(ID_SIMPLE, "Simple menu item")
  15         self.Bind(wx.EVT_MENU, self.OnSimple, id=ID_SIMPLE)
  16 
  17         menu.AppendSeparator()
  18         menu.Append(wx.ID_EXIT, "Exit")
  19         self.Bind(wx.EVT_MENU, self.OnExit, id=wx.ID_EXIT)
  20 
  21         menuBar = wx.MenuBar()
  22         menuBar.Append(menu, "Menu")
  23         self.SetMenuBar(menuBar)
  24 
  25     def OnSimple(self, event):
  26         wx.MessageBox("You selected the simple menu item")
  27 
  28     def OnExit(self, event):
  29         self.Close()
  30 
  31     def OnToggleItem(self, event):
  32         menubar = self.GetMenuBar()
  33         enabled = menubar.IsEnabled(ID_SIMPLE)
  34         menubar.Enable(ID_SIMPLE, not enabled)
  35         self.btn.SetLabel(
  36             (enabled and "Enable" o "Disable") + " Item")
  37 
  38 if __name__ == "__main__":
  39     app = wx.PySimpleApp()
  40     frame = MyFrame()
  41     frame.Show()
  42     app.MainLoop()

要查看或改变菜单项自身或菜单栏上的，或特定菜单上的一个菜单项的有效状态，调用 wx.MenuItem.IsEnabled()、wx.MenuBar.IsEnabled(id)或wx.Menu.IsEnabled(id)方法。菜单栏和菜单方法都要求一个菜单项的wxPython标识符。如果该菜单项存在且有效，那么这两个方法都返回True，如果该菜单项不存在或无效，那么这两个方法都返回False。唯一的区别是wx.Menu的方法只在特定的菜单中搜索，而菜单栏方法搜索整个菜单栏。wx.MenuItem方法不要求参数，它返回特定菜单项的状态。

要改变有效状态，使用wx.MenuBar.Enable(id, enable), wx.Menu.Enable(id,enable), 或 wx.MenuItem.Enable(enable)。enable参数是布尔值。如果为True，相关菜单项有效，如果为False，相关菜单项无效。Enable()方法的作用域和IsEnabled()方法相同。你也可以使用wx.MenuBarEnableTop(pos,enable)方法来让整个顶级菜单有效或无效。在这里，pos参数是菜单栏中菜单的整数位置，enable参数是个布尔值。

1.2.3. 如何将一个菜单项与一个快捷键关联起来？

图10.3显示了一个示例菜单。注意该菜单的菜单名中有一个带下划线的字符，其中的标签为Accelerated的菜单项的快捷键是Ctrl-A。

图10.3

研究表明快捷键并不总是能够节省时间。但是它们是标准的界面元素，并且你的用户也希望它们的存在。 例10.6显示了给菜单项添加快捷键的代码。

例10.6

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Accelerator Example")
   7         p = wx.Panel(self)
   8         menu = wx.Menu()
   9         simple = menu.Append(-1, "Simple   item")    # Creating a mnemonic
  10         accel  = menu.Append(-1, " \tCtrl-A") # Creating an accelerator
  11 
  12         menu.AppendSeparator()
  13         exit = menu.Append(-1, "E ")
  14 
  15         self.Bind(wx.EVT_MENU, self.OnSimple, simple)
  16         self.Bind(wx.EVT_MENU, self.OnAccelerated, accel)
  17         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  18 
  19         menuBar = wx.MenuBar()
  20         menuBar.Append(menu, " ")
  21         self.SetMenuBar(menuBar)
  22 
  23         acceltbl = wx.AcceleratorTable( [ #Using an accelerator table
  24                 (wx.ACCEL_CTRL, od('Q'), exit.GetId())
  25             ])
  26         self.SetAcceleratorTable(acceltbl)
  27 
  28 
  29     def OnSimple(self, event):
  30         wx.MessageBox("You selected the simple menu item")
  31 
  32     def OnAccelerated(self, event):
  33         wx.MessageBox("You selected the accelerated menu item")
  34 
  35 
  36     def OnExit(self, event):
  37         self.Close()
  38 
  39 
  40 if __name__ == "__main__":
  41     app = wx.PySimpleApp()
  42     frame = MyFrame()
  43     frame.Show()
  44     app.MainLoop()

在wxPython中有两种快捷键；mnemonics（助记符）和accelerator（加速器）。下面，我们将讨论这两种的区别。

使用助记符快捷方式

助记符是一个用来访问菜单项的单个字符，以一个带有下划线的字母表示。助记符可以通过为菜单或菜单项指定显示的文本来创建，并在你想用来作为助记符的字符前面放置一个&符号，例如 , 或Ma 。如果你希望在你的菜单文本中有一个&符号，那么你必须输入两个&&符号，例如&&。

助记符是作为在菜单树中选择的一个备用的方法。它仅在被用户显式地调用时被激活；在微软Windows下，通过按下alt键来激活它。一旦助记符被激活，下一步按下顶级菜单的助记符来打开顶级菜单。这样一步打开菜单，直到一个菜单项被选择，此时一个菜单事件被触发。助记符在菜单中必须是独一无二的，但在整个菜单栏中可以不是独一无二。通常菜单文本的第一个字符被用作助记符。如果你有多个菜单项有相同的开头字母，那么就没有特定的准则来决定那个字符用作助记符（最常用的选择是第二个和最后一个，这要看哪个更合理）。菜单文本清晰的含义比有一个好的助记符更重要。

使用加速器快捷方式

在wxPython中加速器是一个更加典型的键盘快捷方式，它意味能够随时调用的按键组合，这些按键组合直接触发菜单项。加速器可以用两种方法创建。最简单的方法是，在菜单或菜单项的显示文本中包括加速器按键组合（当菜单或菜单项被添加到其父中时）。实现的方法是，在你的菜单项的文本后放置一个\t。在\t之后定义组合键。组合键的第一部分是一个或多个Alt, Ctrl, 或Shift，由一个+或一个-分隔，随后是实际的加速器按键。例如：New\tctrl-n, SaveAs\tctrl-shift-s。即使在第一部分你只有一个专用的键，你仍可使用+或-来将该部分与实际的按键分隔。这不区分按键组合的大小写。

实际的键可以是任何数字、字母或功能键（如F1~F12），还有表10.6所列出的专用词。

wxPython的方法在通过名字查找一个菜单或菜单项时忽略助记符和加速器。换句话说，对menubar.FindMenuItem("File", "SaveAs")的调用将仍匹配Save as菜单项，即使菜单项的显示名是以Save \tctrl-shift-s形式输入的。

加速器也可能使用加速器表被直接创建，加速器表是类wx.AccleratorTable的一个实例。一个加速器表由wx.AccelratorEntry对象的一个列表组成。wx.AcceleratorTable的构造函数要求一个加速器项的列表，或不带参数。在例10.6中，我们利用了wxPython将隐式使用参数(wx.ACCEL_CTRL, od('Q')，exit.GetId())调用wx.AcceleratorEntry构造函数的事实。wx.AcceleratorEntry的构造函数如下：

wx.AcceleratorEntry(flags, keyCode, cmd)

flags参数是一个使用了一个或多个下列常量的位掩码：wx.ACCEL_ALT, wx.ACCEL_CTRL, wxACCEL_NORMAL , 或wx.ACCEL_SHIFT。该参数表明哪个控制键需要被按下来触发该加速器。keyCode参数代表按下来触发加速器的常规键，它是对应于一个字符的ASCII数字，或在wxWidgets文本中的Keycodes下的一个专用字符。cmd参数是菜单项的wxPython标识符，该菜单项当加速器被调用时触发其命令事件。正如你从例10.6所能看到的，使用这种方法声明一个加速器，不会在这个带菜单项显示名的菜单上列出组合键。你仍需要单独实现它。

表10.6 非字母顺序的加速器键

加速器 键

delDelete deleteDelete downDown arrow endEnd enterEnter escEscape escapeEscape homeHome insInsert insertInsert leftLeft arrow pgdnPage down pgupPage Up returnEnter rightRight arrow spaceSpace bar tabTab upUp arrow

1.2.4. 如何创建一个复选或单选开关菜单项？

菜单项不仅用于从选择表单中得到用户的输入，它们也被用于显示应用程序的状态。经由菜单项来显示状 态的最常用的机制是开关菜单项的使用，开关菜单项仿效一个复选框或单选按钮（你只能够通过改变该菜 单项的文本或使用有效或无效状态来反映应用程序的状态）。图10.4显示了复选和单选菜单项的例子。

图10.4

顾名思义，一个复选开关菜单项在它每次被选择时，它在开和关状态间转换。在一个组中，一次只允许一 个单选菜单项处于开的状态。当同一组中的另一个菜单项被选择时，先前的菜单项改变为关状态。例10.7 显示了如何创建复选和单选菜单项。

例10.7 建造开关菜单项

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Toggle Items Example")
   7         p = wx.Panel(self)
   8         menuBar = wx.MenuBar()
   9         menu = wx.Menu()
  10         exit = menu.Append(-1, "Exit")
  11         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  12         menuBar.Append(menu, "Menu")
  13 
  14         menu = wx.Menu()
  15         menu.AppendCheckItem(-1, "Check Item 1")
  16         menu.AppendCheckItem(-1, "Check Item 2")
  17         menu.AppendCheckItem(-1, "Check Item 3")
  18         menu.AppendSeparator()
  19         menu.AppendRadioItem(-1, "Radio Item 1")
  20         menu.AppendRadioItem(-1, "Radio Item 2")
  21         menu.AppendRadioItem(-1, "Radio Item 3")
  22         menuBar.Append(menu, "Toggle Items")
  23 
  24         self.SetMenuBar(menuBar)
  25 
  26     def OnExit(self, event):
  27         self.Close()
  28 
  29 
  30 if __name__ == "__main__":
  31     app = wx.PySimpleApp()
  32     frame = MyFrame()
  33     frame.Show()
  34     app.MainLoop()

正如你从例子所见到的，通过使用方法AppendCheckItem(id, item, helpString="")来添加一个复选框菜 单项，该方法类似于Append()。该方法的参数是wxPython标识符、显示在菜单中的名字、显示在状态栏听 帮助字符串。同样，你可以使用PrependCheckItem(id,item, helpString="")和InsertCheckItem(pos, id, item, helpString="")，这两个方法的行为与它们的无复选框的版本相同。

单选按钮菜单项可以使用AppendRadioItem(id,item,helpString="")方法来添加，你也可以使用 PrependRadioItem(id,item, helpString="")和InsertRadioItem(pos, id, item, helpString="") 方法。一系列连续的单选菜单项被作为一组，一组中一次只能有一个成员被触发。组以第一个非单选菜单 项或菜单分隔符为界。默认情况下，当单选组被创建时，该组中的第一个成员处于选中状态。

开关菜单项可以通过使用Append()来创建。Append()的kind参数要求下列常量值之一：wx.ITEM_CHECK, wx.ITEM_NORMAL, wx.ITEM_RADIO或wx.ITEM_SEPARATOR，其中的每个值创建一个适当类型的菜单项。这是有用的，如果你正在使用某种数据驱动过程自动创建这些菜单项的话。所有类型的菜单项都可以使用这同种方法来创建，尽管指定kind为wx.ITEM_SEPARATOR来生成一个分隔符必须给id参数传递wx.ID_SEPARATOR。

当你使用wx.MenuItem构造函数时你也可以创建一个开关菜单项（给参数kind一个相应的常量值）。所得 的菜单项可以使用AppendItem(), PrependItem(), InsertItem()之一的方法被添加到一个菜单。

要确定一个菜单项的开关状态，使用IsCheckable()，如果该项是一个复选或单选项，函数返回True，使 用IsChecked()，如果该项是可开关的且处于选中状态，那么返回True。你也可以使用Check(check)方法 来设置一个菜单项的开关状态，check是一个布尔参数。使用Check(check)方法设置时，被设置的菜单项 是单选的，那么将影响同一组别的项。

你也可以使用IsChecked(id)从菜单或菜单栏得到一个菜单项的开关状态，它要求相应菜单项的id。你也 可以使用Check(id, check)来设置菜单栏或菜单中的菜单项，参数check是布尔值。

1.3. 进一步构建菜单

在接下来的几节，我们将通过使你的菜单更杂化来让它更有用。首先我们将讨论嵌套的子菜单，然后是在你的程序中加入弹出菜单。最后是构建喜爱样式的菜单项。

1.3.1. 如何创建一个子菜单？

如果你的应用程序变得太复杂，你可以在顶级菜单中创建子菜单，这使你能够在一个项级菜单中嵌套菜单项且装入更多的项目。对于将一系列的属于同一逻辑的选项组成一组，子菜单是十分有用的，尤其是要将太多的选项地放入顶级菜单的时候。图10.5显示了一个使用子菜单的示例。

图10.5

例10.8显示了产生图10.5的代码。

例10.8 建造一个嵌套的子菜单

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Sub-menu Example")
   7         p = wx.Panel(self)
   8         menu = wx.Menu()
   9 
  10         submenu = wx.Menu()
  11         submenu.Append(-1, "Sub-item 1")
  12         submenu.Append(-1, "Sub-item 2")
  13         menu.AppendMenu(-1, "Sub-menu", submenu)#添加子菜单
  14 
  15         menu.AppendSeparator()
  16         exit = menu.Append(-1, "Exit")
  17         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  18 
  19         menuBar = wx.MenuBar()
  20         menuBar.Append(menu, "Menu")
  21         self.SetMenuBar(menuBar)
  22 
  23 
  24     def OnExit(self, event):
  25         self.Close()
  26 
  27 
  28 if __name__ == "__main__":
  29     app = wx.PySimpleApp()
  30     frame = MyFrame()
  31     frame.Show()
  32     app.MainLoop()

你从例10.8会注意到，子菜单的创建方法与顶级菜单的相同。你创建类wx.Menu的一个实例，然后以相同的方法给子菜单增加菜单项。不同的是子菜单没有被添加到顶级菜单栏，而是使用AppendMenu(id,

• text, submenu, helpStr)把它添加给另一个菜单。该函数的参数类似于Append()的。参数id是要添加到的菜单的wxPython标识符。参数text是子菜单显示在父菜单中的字符串。参数submenu是子菜单自身，helpStr是显示在状态栏中的文本。另外还有子菜单的插入方法：PrependMenu(id,text, submenu, helpStr)和InsertMenu(pos, text, submenu, helpStr)。这些方法的行为与这章前面我们所讨论的菜单项的插入方法的行为类似。

记住，子菜单创建的步骤的顺序相对于单纯的菜单项来说是较为重要的，我们推荐你先将项目添加给子菜单，然后将子菜单附加给父菜单。这使得wxPython能够正确地为菜单注册快捷键。你可以嵌套子菜单到任意深度，这通过给已有的子菜单添加子菜单来实现，而非将子菜单添加到顶级菜单，在添加新的子菜单之前，你仍需要创建创建它。

1.3.2. 如何创建弹出式菜单？

菜单不仅能够从框架顶部的菜单栏向下拉，而且它们也可以在框架的任一处弹出。多数情况下，一个弹出菜单用于根据上下文和用户所敲击位置的对象来提供相应的行为。图10.6显示了一个弹出式菜单的例子。

图10.6

弹出菜单的创建是非常类似于标准菜单的，但是它们不附加到菜单栏。例10.9显示了一个弹出菜单的示例代码。

例10.9 在任意一个窗口部件中创建一个弹出式菜单

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Popup Menu Example")
   7         self.panel = p = wx.Panel(self)
   8         menu = wx.Menu()
   9         exit = menu.Append(-1, "Exit")
  10         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  11 
  12         menuBar = wx.MenuBar()
  13         menuBar.Append(menu, "Menu")
  14         self.SetMenuBar(menuBar)
  15 
  16         wx.StaticText(p, -1,
  17             "Right-click on the panel to show a popup menu",
  18             (25,25))
  19 
  20         self.popupmenu = wx.Menu()#创建一个菜单
  21         for text in "one two three four five".split():#填充菜单
  22             item = self.popupmenu.Append(-1, text)
  23             self.Bind(wx.EVT_MENU, self.OnPopupItemSelected, item)
  24         p.Bind(wx.EVT_CONTEXT_MENU, self.OnShowPopup)#绑定一个显示菜单事件
  25 
  26 
  27     def OnShowPopup(self, event):#弹出显示
  28         pos = event.GetPosition()
  29         pos = self.panel.ScreenToClient(pos)
  30         self.panel.PopupMenu(self.popupmenu, pos)
  31 
  32 
  33     def OnPopupItemSelected(self, event):
  34         item = self.popupmenu.FindItemById(event.GetId())
  35         text = item.GetText()
  36         wx.MessageBox("You selected item '%s'" % text)
  37 
  38 
  39     def OnExit(self, event):
  40         self.Close()
  41 
  42 
  43 if __name__ == "__main__":
  44     app = wx.PySimpleApp()
  45     frame = MyFrame()
  46     frame.Show()
  47     app.MainLoop()

弹出菜单像任一其它菜单一样被创建（注意for循环对于快速创建菜单项的用法）。它没有被添加到菜单栏，它被存储在实例变量self.popupmenu中。然后，框架将方法OnShowPopup()绑定到事件wx.EVT_CONTEXT_MENU。该事件被操作系统的触发弹出菜单的标准机制所触发。在微软Windows和GTK下，这个机制是鼠标右键敲击，在Mac OS下，它是一个control敲击。

当用户在框架上执行一个弹出触发敲击的时候，处理器OnShowPopup()被调用。该方法所做的第一件事是确定显示菜单的位置。传递给该方法的事件的位置（在wx.EVT_CONTEXT_MENU的实例中）是以屏幕的绝对坐标存储的，所以我们需要将位置坐标转换为相对于包含弹出菜单的面板的坐标，我们使用方法ScreenToClient()。

此后，使用方法PopupMenu(menu, pos)调用弹出菜单，你也可以使用相关的方法PopupMenuXY(menu, x, y)。PopupMenu函数不返回，直到一个菜单项被选择或通过按下Esc或在该弹出菜单之外敲击使该弹出菜单消失。如果一个菜单项被选择，那么它的事件被正常处理（这意味它必须有一个方法与事件EVT_MENU绑定），并且在PopupMenu方法返回前该事件也被完成。PopupMenu的返回值是布尔值，没什么意思。

弹出菜单可以有一个标题，当弹出菜单被激活时它显示在弹出菜单的顶部。这个标题使用属性wx.Menu.SetTitle(title)和wx.Menu.GetTitle()来处理。

1.3.3. 如何创建自己个性的菜单？

如果普通的菜单项引不起你足够的兴趣，你可以添加自定义的位图到菜单项的旁边（或用作自定义的检查符号）。在微软Windows下，你也可以调整菜单项的字体和颜色。图10.7显示了一个个性菜单的例子。

图10.7

例10.10显示了产生这种菜单的代码。要确定程序是否运行在Windows下，你可以检查‘wxMSW’是否在wx.PlatformInfo元组中。

例10.10 个性菜单项的示例代码

   1 import wx
   2 
   3 class MyFrame(wx.Frame):
   4     def __init__(self):
   5         wx.Frame.__init__(self, None, -1,
   6                           "Fancier Menu Example")
   7         p = wx.Panel(self)
   8         menu = wx.Menu()
   9 
  10         bmp = wx.Bitmap("open.png", wx.BITMAP_TYPE_PNG)
  11         item = wx.MenuItem(menu, -1, "Has Open Bitmap")
  12         item.SetBitmap(bmp)#增加一个自定义的位图
  13         menu.AppendItem(item)
  14 
  15         if True o 'wxMSW' in wx.PlatformInfo:
  16             font = wx.SystemSettings.GetFont(
  17                 wx.SYS_DEFAULT_GUI_FONT)
  18             font.SetWeight(wx.BOLD)
  19             item = wx.MenuItem(menu, -1, "Has Bold Font")
  20             item.SetFont(font)#改变字体
  21             menu.AppendItem(item)
  22 
  23             item = wx.MenuItem(menu, -1, "Has Red Text")
  24             item.SetTextColour("red")#改变文本颜色
  25             menu.AppendItem(item)
  26 
  27 
  28         menu.AppendSeparator()
  29         exit = menu.Append(-1, "Exit")
  30         self.Bind(wx.EVT_MENU, self.OnExit, exit)
  31 
  32         menuBar = wx.MenuBar()
  33         menuBar.Append(menu, "Menu")
  34         self.SetMenuBar(menuBar)
  35 
  36 
  37     def OnExit(self, event):
  38         self.Close()
  39 
  40 
  41 if __name__ == "__main__":
  42     app = wx.PySimpleApp()
  43     frame = MyFrame()
  44     frame.Show()
  45     app.MainLoop()

处理控制显示属性的主要的内容是给一个菜单项添加颜色或样式。适合除了Windows外（包括Windows)的平台的唯一的属性是bitmap，由GetBitmap()管理，该函数返回一个wx.Bitmap类型的项。这儿有两个set*方法。第一个是SetBitmap(bmp)，它工作于所有的平台上。它总是在菜单项的旁边设置一个显示的位图。如果你是在微软Windows上，并且你想为一个开关菜单设置一个自定义的位图，你可以使用SetBitmaps(checked, unchecked=wx.NullBitmap)，它使得当该项被选中时显示一个位图，该项未选中时显示另一个位图。如果该菜单项不是一个开关菜单项，那么checked参数是没有用的。

在微软Windws下，有三个另外的属性，你可以用来改变菜单项的外观，如表10.7所示。我们建议你谨慎地使用它们，并且仅在它们能够明显地增强用户的体验的情况下。

表10.7 菜单项的外观属性

目前我们已经讨论了使用菜单功能方面的内容，接下来我们将对如何更好的使用菜单以及如何使你的应用程序对用户来说更容易使用的问题作一个纲要性的说明，以结束本章。

1.4. 菜单设计的适用性准则

对于大多数复杂的应用程序，菜单栏是用户访问应用程序功能的主要入口。正确的设计菜单对你的程序的易用性有很大的帮助。本着这一想法，我们提供了一些关于菜单设计的适用性准则。

1.4.1. 使菜单有均衡的长度

建议菜单所包含的项目的最大数量在10到15之间。超过这个最大长度的菜单将会看不全。你应该学习创建长度基本一致的菜单，记住，这有时是不可能或不必要的。

1.4.2. 创建合理的项目组

你不应该创建一个没有分隔符的多于五个项目的组，除非你有非常合理的理由这样做——如一个历史列表，或一个插件列表。多于五个项目的组，用户处理起来非常困难。要有一个更大的组，项目需要被强有力地联系在一起并且要有用户期望长于五个项目的列表的原因。

菜单的顺序要遵循标准

对于菜单的顺序，你应该遵循公认的标准。最左边的菜单应该是FILE（文件），并且它包含new（新建），open（打开），save（保存），print（打印）和quit（退出）功能，所包含的功能的顺也是这样，另外的一些功能通常添加在打印和退出之间。几乎每个应用程序都要使用到这些功能。下一个菜单是EDIT（编辑），它包含undo（撤消），cut（剪切），copy（拷贝），paste（粘贴）和常用的find（查找），这些依赖于你的程序的应用范围。HELP（帮助）菜单总是在最右边，并且windows（窗口）菜单经常是挨着它的。中间的其它菜单通常由你自己来决定。

对通常使用的项目提供方便的访问

用户总是会更先访问到菜单中更上面的项目。这就说明了更常用的选项应放在顶部。有一个例外就是多数研究显示，第二项先于第一项。

使用有含义的菜单名称

记住，位于菜单栏上的菜单的宽度是与它的名称成正比的，并且当菜单打开时它的宽度与它所包含的项目的最长的名字成正比。尽量避免使顶级菜单的名字少于四个字母。除了通常的名称外，我们建议只要有可能，名字再长点，但意义要清楚。不要害怕给一个菜单项较长的文本，尽管30~40个字符可能难读。

当一个项目会调用一个对话框时，记住带有省略号

任何会导致一个对话框被显示的菜单项，都应该有一个以省略号（...）结尾的标签。

使用标准的快捷键

对快捷键，使用通常功能的公认的标准，如表10.8所示。

表10.8 快捷键功能

这里没有列出Redo（重做）的公认的快捷键，你有时会看到用于它的Ctrl-y，Alt-z或其它的组合。如果你给通常功能提供了更多的快捷键，那么建议你给用户提供一个方案来改变它们。快捷键在用户做大量的输入工作时是很有用的，例如一个文本编辑器。但是对于大部分用鼠标完成的工作，它们的作用就很少了。

反映出开关状态

当创建一个开关菜单时，有两个事情需要注意。第一，记住，一个未选中的复选菜单项看起来与一个通常的菜单项相同。如果该菜单项的文本如fancy mode on的话，那么用户就有可能不知道选择这个菜单项会改变样式。另一个要注意的是，菜单项文本要反映出当前不是被激活的状态，而非激活状态。比如菜单文本说明如果选择它会执行什么动作。例如，如果fancy样式是打开的，那么文本使用Turn fancy mode off。菜单中没有语句表明fancy样式实际是什么样的，这可以引起混淆。要避免这个问题，对于一个未被选择的菜单，使用一个自定义的位图以视觉的方式说明这个菜单是一个开关菜单，是一个好的主意（平台允许的话）。如果你的平台不支的话，使用像 toggle fancy mode或switch fancy mode (now on)这样的文本意思会更清楚。

慎重地使用嵌套

嵌套层次的菜单对于浏览来说不方便。

避免使用字体和颜色

你记得有哪一个应用程序在它的菜单项中使用了字体和颜色的。我们也不这要使用（但是用于选择字体或颜色的菜单是例外）。很明显，这种使用非常少见。

1.5. 本章小结

·在图形用户界面中，菜单是最常用来让用户触发命令的机制。在wxPython中，创建菜单使用三个主要的类：wx.MenuBar，它表示菜单栏并包含菜单，菜单使用wx.Menu。菜单由菜单项组成，菜单项使用wx.MenuItem。对于菜单部分的创建，首先创建菜单栏并将它附加到框架。然后分别创建个个菜单，并添加菜单项。再将菜单添加到菜单栏。菜单项可以被添加到菜单的任意位置。一个菜单项也可以是一个菜单分隔符，而非普通的菜单项。当菜单项被添加到其父菜单时，菜单项对象可以被显式地或隐含地创建。

·选择一个菜单将触发一个wx.EVT_MENU类型的命令事件。菜单事件经由框架绑定，而非菜单项，菜单或菜单栏。这让工具栏按钮可以触发与一个菜单项相同的wx.EVT_MENU事件。如果你有多个有着连续标识符的菜单项，它们有相同的处理器的话，那么它们可以使用wx.EVT_MENU_RANGE事件类型被绑定在一起调用。

·菜单项能够从包含它们的菜单或菜单栏使用ID或标签来查找。也可以被设置成有效或无效。

·一个菜单可以被附加给另一个菜单，而非菜单栏，从而形成一个嵌套的子菜单。wx.Menu有特定的方法使你能够添加子菜单，同样也能够添加一个菜单项。

·菜单可以用两种方法与按键关联。助记符和加速器。

·一个菜单项可以有一个开关状态。它可以是一个复选菜单项，也可以是一个单选菜单项。菜单项的选择状态可以经由包含它的菜单或菜单来查询或改变。

·可以创建弹出式菜单。这通过捕获wx.EVT_CONTEXT_MENU类型事件，并使用PopupMenu()方法来显示弹出。在弹出中的菜单项事件被正常地处理。

·你可以为一个菜单项创建一个自定义的位图，并且在Windows操作系统下，你可以改变一个菜单项的颜色和字体。