原文： http://zetcode.com/gui/qtjambi/menustoolbars/

在 QtJambi 编程教程的这一部分中，我们将使用菜单和工具栏。

菜单栏是 GUI 应用中最可见的部分之一。 它是位于各个菜单中的一组命令。 在控制台应用中，您必须记住所有这些神秘命令，在这里，我们将大多数命令分组为逻辑部分。 有公认的标准可以进一步减少学习新应用的时间。 菜单将我们可以在应用中使用的命令分组。 使用工具栏可以快速访问最常用的命令。

简单菜单

第一个示例将显示一个简单的菜单。

  1. package com.zetcode;
  3. import com.trolltech.qt.gui.QAction;
  4. import com.trolltech.qt.gui.QApplication;
  5. import com.trolltech.qt.gui.QMainWindow;
  6. import com.trolltech.qt.gui.QMenu;
  8. /**
  9.  * ZetCode QtJambi tutorial
  10.  *
  11.  * This program shows a simple
  12.  * menu. It has one action, which
  13.  * will terminate the program, when
  14.  * selected. 
  15.  *
  16.  * @author jan bodnar
  17.  * website zetcode.com
  18.  * last modified March 2009
  19.  */
  21. public class JambiApp extends QMainWindow {
  23.     public JambiApp() {
  25.         setWindowTitle("Simple menu");
  27.         initUI();
  29.         resize(250, 200);
  30.         move(300, 300);
  31.         show();
  32.     }
  34.     private void initUI() {
  36.         QAction quit = new QAction("&Quit", this);
  38.         QMenu file = menuBar().addMenu("&File");
  39.         file.addAction(quit);
  41.         quit.triggered.connect(QApplication.instance(), "quit()");
  42.     }
  44.     public static void main(String[] args) {
  45.         QApplication.initialize(args);
  46.         new JambiApp();
  47.         QApplication.exec();
  48.     }
  49. }

我们有一个菜单栏，一个菜单和一个动作。 为了使用菜单，我们必须继承QMainWindow小部件。

  1. QAction quit = new QAction("&Quit", this);

此代码行创建一个QAction。 每个QMenu具有一个或多个动作对象。 注意 AND 字符（&）。 它为以下项目创建快捷方式： Alt + Q 。 它还强调了Q字符。 下拉菜单中的文件时，该快捷方式处于活动状态。

  1. QMenu file = menuBar().addMenu("&File");
  2. file.addAction(quit);

我们创建一个QMenu对象。 ＆字符创建快捷方式： Alt + F 。 连续的快捷键 Alt + F ， Alt + Q 退出了应用。

  1. quit.triggered.connect(QApplication.instance(), "quit()");

当我们从菜单中选择此选项时，应用退出。

QtJambi 中的菜单和工具栏 - 图1

图：简单菜单

创建一个子菜单

子菜单是插入另一个菜单对象的菜单。 下一个示例对此进行了演示。

  1. package com.zetcode;
  3. import com.trolltech.qt.gui.QAction;
  4. import com.trolltech.qt.gui.QApplication;
  5. import com.trolltech.qt.gui.QMainWindow;
  6. import com.trolltech.qt.gui.QMenu;
  8. /**
  9.  * ZetCode QtJambi tutorial
  10.  *
  11.  * This program creates a
  12.  * submenu
  13.  *
  14.  * @author jan bodnar
  15.  * website zetcode.com
  16.  * last modified March 2009
  17.  */
  19. public class JambiApp extends QMainWindow {
  21.     public JambiApp() {
  23.         setWindowTitle("Submenu");
  25.         initUI();
  27.         resize(250, 200);
  28.         move(300, 300);
  29.         show();
  30.     }
  32.     private void initUI() {
  34.         QAction quit = new QAction("&Quit", this);
  36.         QMenu file = menuBar().addMenu("&File");
  37.         QMenu impm = new QMenu("Import");
  39.         QAction seeds = new QAction("Import news feed...", this);
  40.         QAction marks = new QAction("Import bookmarks...", this);
  41.         QAction mail = new QAction("Import mail...", this);
  42.         impm.addAction(seeds);
  43.         impm.addAction(marks);
  44.         impm.addAction(mail);
  46.         file.addMenu(impm);
  47.         file.addAction(quit);
  49.         quit.triggered.connect(QApplication.instance(), "quit()");
  50.     }
  52.     public static void main(String[] args) {
  53.         QApplication.initialize(args);
  54.         new JambiApp();
  55.         QApplication.exec();
  56.     }
  57. }

在示例中，文件菜单的子菜单中有三个选项。

  1. QMenu file = menuBar().addMenu("&File");
  2. QMenu impm = new QMenu("Import");

我们有两个QMenu对象。 文件菜单和导入菜单。

  1. QAction seeds = new QAction("Import news feed...", this);
  2. QAction marks = new QAction("Import bookmarks...", this);
  3. QAction mail = new QAction("Import mail...", this);

我们创建三个动作对象。

  1. impm.addAction(seeds);
  2. impm.addAction(marks);
  3. impm.addAction(mail);

我们将动作对象添加到导入菜单中。

  1. file.addMenu(impm);

最后，我们将导入菜单添加到文件菜单中。

QtJambi 中的菜单和工具栏 - 图2

图：子菜单

图像，菜单，分隔符

在以下示例中，我们将进一步增强以前的应用。 我们将在菜单中添加图标，使用快捷方式和分隔符。

  1. package com.zetcode;
  3. import com.trolltech.qt.gui.QAction;
  4. import com.trolltech.qt.gui.QApplication;
  5. import com.trolltech.qt.gui.QIcon;
  6. import com.trolltech.qt.gui.QMainWindow;
  7. import com.trolltech.qt.gui.QMenu;
  9. /**
  10.  * ZetCode QtJambi tutorial
  11.  *
  12.  * This program shows image
  13.  * menus, shortcuts and a separator
  14.  *
  15.  * @author jan bodnar
  16.  * website zetcode.com
  17.  * last modified March 2009
  18.  */
  20. public class JambiApp extends QMainWindow {
  22.     public JambiApp() {
  24.         setWindowTitle("Image menu");
  26.         initUI();
  28.         resize(250, 200);
  29.         move(300, 300);
  30.         show();
  31.     }
  33.     private void initUI() {
  35.           QIcon newpix = new QIcon("new.png");
  36.           QIcon openpix = new QIcon("open.png");
  37.           QIcon quitpix = new QIcon("quit.png");
  39.           QAction newa = new QAction(newpix, "&New", this);
  40.           QAction open = new QAction(openpix, "&Open", this);
  41.           QAction quit = new QAction(quitpix, "&Quit", this);
  42.           quit.setShortcut("Ctrl+Q");
  44.           QMenu file;
  45.           file = menuBar().addMenu("&File");
  46.           file.addAction(newa);
  47.           file.addAction(open);
  48.           file.addSeparator();
  49.           file.addAction(quit);
  51.           quit.triggered.connect(QApplication.instance(), "quit()");
  52.     }
  54.     public static void main(String[] args) {
  55.         QApplication.initialize(args);
  56.         new JambiApp();
  57.         QApplication.exec();
  58.     }
  59. }

在我们的示例中，我们有一个包含三个动作的菜单。 如果我们选择退出操作，则实际上只有退出操作才可以执行某些操作。 我们还创建了分隔符和 Ctrl + Q 快捷方式，它们将终止应用。

  1. QIcon newpix = new QIcon("new.png");
  2. QIcon openpix = new QIcon("open.png");
  3. QIcon quitpix = new QIcon("quit.png");

这些是我们将在应用中使用的 PNG 图像。

  1. QAction newa = new QAction(newpix, "&New", this);
  2. QAction open = new QAction(openpix, "&Open", this);
  3. QAction quit = new QAction(quitpix, "&Quit", this);

在这里，我们创建三个动作对象。 第一个参数是QIcon。

  1. quit.setShortcut("Ctrl+Q");

这行创建一个快捷方式。 通过按下此快捷方式，我们将运行退出操作，这将退出应用。

  1. file.addSeparator();

我们创建一个分隔符。 分隔符是一条水平线，它使我们能够将菜单操作分组为一些逻辑部分。

QtJambi 中的菜单和工具栏 - 图3

图：图像 s, shortcut and a separator

工具栏

QToolBar类提供了一个可移动面板，其中包含一组控件，这些控件提供对应用操作的快速访问。

  1. package com.zetcode;
  3. import com.trolltech.qt.gui.QAction;
  4. import com.trolltech.qt.gui.QApplication;
  5. import com.trolltech.qt.gui.QIcon;
  6. import com.trolltech.qt.gui.QMainWindow;
  7. import com.trolltech.qt.gui.QToolBar;
  9. /**
  10.  * ZetCode QtJambi tutorial
  11.  *
  12.  * This program creates a 
  13.  * toolbar
  14.  *
  15.  * @author jan bodnar
  16.  * website zetcode.com
  17.  * last modified April 2009
  18.  */
  20. public class JambiApp extends QMainWindow {
  22.     public JambiApp() {
  24.         setWindowTitle("Toolbar");
  26.         initUI();
  28.         resize(250, 200);
  29.         move(300, 300);
  30.         show();
  31.     }
  33.     private void initUI() {
  35.         QIcon newpi = new QIcon("new.png");
  36.         QIcon openpi = new QIcon("open.png");
  37.         QIcon quitpi = new QIcon("quit.png");
  39.         QToolBar toolbar = addToolBar("main toolbar");
  40.         toolbar.addAction(newpi, "New File");
  41.         toolbar.addAction(openpi, "Open File");
  42.         toolbar.addSeparator();
  43.         QAction quit = toolbar.addAction(quitpi,
  44.             "Quit Application");
  46.         quit.triggered.connect(QApplication.instance(), "quit()");
  48.     }
  50.     public static void main(String[] args) {
  51.         QApplication.initialize(args);
  52.         new JambiApp();
  53.         QApplication.exec();
  54.     }
  55. }

我们创建一个带有三个动作对象和一个分隔符的工具栏。

  1. QIcon newpi = new QIcon("new.png");
  2. QIcon openpi = new QIcon("open.png");
  3. QIcon quitpi = new QIcon("quit.png");

工具栏动作对象将显示这些图标。

  1. QToolBar toolbar = addToolBar("main toolbar");

QMainWindow的addToolBar()方法为应用创建一个工具栏。 文本字符串为工具栏命名。 此名称用于引用此工具栏，因为一个应用中可以有多个工具栏。 如果右键单击窗口区域，我们将看到一个可检查的选项，该选项显示/隐藏工具栏。

  1. toolbar.addSeparator();

我们创建一个垂直分隔符。

  1. quit.triggered.connect(QApplication.instance(), "quit()");

当我们单击退出操作对象时，应用终止。

QtJambi 中的菜单和工具栏 - 图4

图：工具栏

撤销重做

以下示例演示了如何停用工具栏上的工具栏按钮。 这是 GUI 编程中的常见做法。 例如，保存按钮。 如果我们将文档的所有更改都保存到磁盘上，则在大多数文本编辑器中，“保存”按钮将被停用。 这样，应用会向用户指示所有更改都已保存。

  1. package com.zetcode;
  3. import com.trolltech.qt.QSignalEmitter;
  4. import com.trolltech.qt.gui.QAction;
  5. import com.trolltech.qt.gui.QApplication;
  6. import com.trolltech.qt.gui.QIcon;
  7. import com.trolltech.qt.gui.QMainWindow;
  8. import com.trolltech.qt.gui.QToolBar;
  10. /**
  11.  * ZetCode QtJambi tutorial
  12.  *
  13.  * This program disables/enables
  14.  * actions on a toolbar
  15.  *
  16.  * @author jan bodnar
  17.  * website zetcode.com
  18.  * last modified March 2009
  19.  */
  21. public class JambiApp extends QMainWindow {
  23.     private int count = 0;
  24.     private QAction undo;
  25.     private QAction redo;
  27.     public JambiApp() {
  29.         setWindowTitle("Undo redo");
  31.         initUI();
  33.         resize(300, 200);
  34.         move(400, 300);
  35.         show();
  36.     }
  38.     private void initUI() {
  40.         QIcon undoi = new QIcon("undo.png");
  41.         QIcon redoi = new QIcon("redo.png");
  42.         QIcon quitpi = new QIcon("quit.png");
  44.         QToolBar toolbar = addToolBar("first toolbar");
  46.         undo = toolbar.addAction(undoi, "Undo");
  47.         redo = toolbar.addAction(redoi, "Redo");
  49.         undo.triggered.connect(this, "count()");
  50.         redo.triggered.connect(this, "count()");
  52.         toolbar.addSeparator();
  54.         QAction quit = toolbar.addAction(quitpi, "Quit Application");
  55.         quit.triggered.connect(QApplication.instance(), "quit()");
  57.     }
  59.     private void count() {
  61.         QAction action = (QAction) QSignalEmitter.signalSender();
  63.         if ("Undo".equals(action.text())) {
  64.             count += -1;
  65.         } else {
  66.             count += 1;
  67.         }
  69.         if (count <= 0) {
  70.             undo.setDisabled(true);
  71.             redo.setDisabled(false);
  72.         }
  74.         if (count >= 5) {
  75.             undo.setDisabled(false);
  76.             redo.setDisabled(true);
  77.         }
  78.     }
  80.     public static void main(String[] args) {
  81.         QApplication.initialize(args);
  82.         new JambiApp();
  83.         QApplication.exec();
  84.     }
  85. }

在我们的示例中，我们有三个QAction对象和一个分隔符。 在撤消或重做按钮上单击几下后，它们将被停用。 外观上，按钮显示为灰色。

  1. private int count = 0;

计数变量确定哪个按钮被激活和停用。

  1. undo.triggered.connect(this, "count()");
  2. redo.triggered.connect(this, "count()");

单击工具栏按钮，将发射triggered信号。 我们将此信号连接到count()方法。

  1. QAction action = (QAction) QSignalEmitter.signalSender();

工具栏上的两个按钮都调用count()方法。 我们需要在它们之间说出来。 这条线确定哪个动作对象实际发出信号。

  1. if ("Undo".equals(action.text())) {
  2.     count += -1;
  3. } else {
  4.     count += 1;
  5. }

撤消工具栏按钮从计数变量中减去 1。 重做添加 1.根据计数变量的值，我们启用/禁用工具栏按钮。

  1. if (count <= 0) {
  2.     undo.setDisabled(true);
  3.     redo.setDisabled(false);
  4. }

setDisabled()方法激活或停用工具栏按钮。

QtJambi 中的菜单和工具栏 - 图5

图：撤销和重做

在 QtJambi 教程的这一部分中，我们提到了菜单和工具栏。