In the systems that use the command-line interface, the user may be presented with a list of commands that will be displayed as help text to the user. The users can then choose from the list to perform their desired action. In GUI systems, this is replaced with a set of text and symbols to represent choices. By clicking on the text/symbol, the user executes their desired action. This collection is called a menu.

A menu bar is a region of a screen or application that consists of a list of pull-down menu items. A common use of the menu bar is to provide convenient access to various operations, such as opening a new or an existing file, saving the file, printing options, manipulating data, providing help windows, closing the application, and so on. In this section, we introduce the concept of adding a menu bar to our application. Before that, we define the central widget of the application, which will aid the usage of menus.

  def SetupComponents(self):
    """ Setting the central widget
        """
        textEdit = QTextEdit()
		        self.setCentralWidget(textEdit)

We will now add the menu bar to our application. We use the PySide.QtGui.QMenuBar class to create a menu bar. This class provides a horizontal menu bar to which the menu items can be added. You don't have to set a layout for the menu bar. Different platforms use different layouts for the menu bar. In a Windows system, the menu bar is usually anchored at the top of a window under the title bar. In the Macintosh system, the menu bar is usually anchored at the top of the screen. Linux systems have both these display formats depending on the GUI style. QMenuBar automatically sets its own geometry to the top of the parent widget and changes it appropriately whenever the parent is resized.

In the main window style applications, we use the PySide.QtGui.QMainWindow.menuBar() function to create a menu bar. This function will return an empty menu bar, which has QMainWindow as its parent. In the Mac application, if you want all to share a single common menu bar, use PySide.QtGui.QMenuBar and don't use a function to create it, because the menu bar that is created this way will have QMainWindow as its parent with no parent by directly instantiating the QMenuBar class. The menu bar can also be set in the main window using the PySide.QtGui.QMainWindow.setMenuBar(menubar) function, which takes a menu bar object as its parameter.

Once the menu bar is set, a menu list can be added to it. The PySide.QtGui.QMenu class provides a menu widget for use in menu bars, context menus, and other pop-up menus. A menu widget is a selection menu, which can be either a pull-down menu in a menu bar or it can be a context menu. Pull-down menus are shown by the menu bar when the user clicks on the respective item or presses the specified shortcut key. Context menus are invoked by some special keyboard key or by right-clicking on it.

In the menu bar, we add menus with the QMenuBar.addMenu(menu) function. For the example application, we add three menus namely, File, Edit, and About. Inside each of these menus, we create two actions, each that connects to a specified slot. As defined, a menu consists of a list of action items when triggered by a click or a keyboard shortcut key combination. The PySide.QtGui.QAction class provides an abstract user interface action that can be inserted into widgets. Actions are common for a combination of menu items, toolbars, and keyboard shortcuts. So, we create an action and attach it to different components that are expected to perform the same functionality. Usually, when an action is created, it should be added to the relevant menu and toolbar, and then connected to the slot that will perform the action. Actions are added to the menus with the QMenu.addAction(), QMenu.addActions(), and QMenu.insertAction() functions. An action is rendered vertically under the menu, and can have a text label, an optional icon drawn on the left, and a shortcut key sequence.

The following example demonstrates the creation of the menu bar in the main window application. This program is a shortened version of what we will be developing as a fully working Simple Text Editor application at the end of this chapter:

# Import required modules
import sys
from PySide.QtGui import QApplication, QMainWindow, QStatusBar, QTextEdit, 
    QAction, QIcon, QKeySequence

class MainWindow(QMainWindow):
  """ Our Main Window class
  """

  def __init__(self):
    """ Constructor Function
    """
    super(MainWindow,self).__init__()
    self.initGUI()

def initGUI(self):
    self.setWindowTitle("A Simple Text Editor")
    self.setWindowIcon(QIcon('appicon.png'))
    self.setGeometry(300, 250, 400, 300)
    self.SetupComponents()
    self.show()
  
  def SetupComponents(self):
    """ Function to setup status bar, central widget, menu bar
    """
    self.myStatusBar = QStatusBar()
    self.setStatusBar(self.myStatusBar)
    self.myStatusBar.showMessage('Ready', 10000)
    self.textEdit = QTextEdit()
    self.setCentralWidget(self.textEdit)
    self.CreateActions()
    self.CreateMenus()
    self.fileMenu.addAction(self.newAction)
    self.fileMenu.addSeparator()
    self.fileMenu.addAction(self.exitAction)
    self.editMenu.addAction(self.copyAction)
    self.fileMenu.addSeparator()
    self.editMenu.addAction(self.pasteAction)
    self.helpMenu.addAction(self.aboutAction)


  # Slots called when the menu actions are triggered
  def newFile(self):
    self.textEdit.setText('')

  def exitFile(self):
    self.close()
  
  def aboutHelp(self):
    QMessageBox.about(self, "About Simple Text Editor",
        "This example demonstrates the use "
        "of Menu Bar")

  def CreateActions(self):
    """ Function to create actions for menus
    """
    self.newAction = QAction( QIcon('new.png'), '&New',
                self, shortcut=QKeySequence.New,
                statusTip="Create a New File",
                triggered=self.newFile)
    self.exitAction = QAction( QIcon('exit.png'), 'E&xit',
                self, shortcut="Ctrl+Q",
                statusTip="Exit the Application",
                triggered=self.exitFile)
    self.copyAction = QAction( QIcon('copy.png'), 'C&opy',
                self, shortcut="Ctrl+C",
                statusTip="Copy",
                triggered=self.textEdit.copy)
    self.pasteAction = QAction( QIcon('paste.png'), '&Paste',
                self, shortcut="Ctrl+V",
                statusTip="Paste",
                triggered=self.textEdit.paste)
    self.aboutAction = QAction( QIcon('about.png'), 'A&bout',
                self, statusTip="Displays info about text editor",
                triggered=self.aboutHelp)

  # Actual­ menu bar item creation
  def CreateMenus(self):
    """ Function to create actual menu bar
    """
    self.fileMenu = self.menuBar().addMenu("&File")
    self.editMenu = self.menuBar().addMenu("&Edit")
    self.helpMenu = self.menuBar().addMenu("&Help")
    
if __name__ == '__main__':
  # Exception Handling
  try:
    #QApplication.setStyle('plastique')
    myApp = QApplication(sys.argv)
    mainWindow = MainWindow()
    myApp.exec_()
    sys.exit(0)
  except NameError:
    print("Name Error:", sys.exc_info()[1])
  except SystemExit:
    print("Closing Window...")
  except Exception:
    print(sys.exc_info()[1])

In the preceding example, the actions are created in the CreateActions() function. Each of the menu items is created as a separate action:

self.newAction = QAction( QIcon('new.png'), '&New',
  self, shortcut=QKeySequence.New,
  statusTip="Create a New File",
  triggered=self.newFile)

The New item under the File menu has the action instantiated as the preceding code snippet. Its parameters are explained as follows:

Once the actions are created, we add these actions to the menu items. The top-level menu bar is created in the CreateMenus() function and the actions of the menu items are added, as follows:

self.fileMenu.addAction(self.newAction)

The menu items can be grouped by adding a separator between the items, which is done as given in the following code line:

self.fileMenu.addSeparator()

Execute the program and witness how menus work.