Warning

This section contains snippets that were automatically translated from C++ to Python and may contain errors.

Widgets Tutorial

This tutorial covers basic usage of widgets and layouts, showing how they are used to build GUI applications.

Introduction

Widgets are the basic building blocks for graphical user interface (GUI) applications built with Qt. Each GUI component (e.g. buttons, labels, text editors) is a widget that is placed somewhere within a user interface window, or is displayed as an independent window. Each type of widget is provided by a subclass of QWidget , which is itself a subclass of QObject.

QWidget is not an abstract class. It can be used as a container for other widgets, and it can be subclassed with minimal effort to create new, custom widgets. QWidget is often used to create a window inside which other QWidget s are placed.

As with QObjects, QWidget s can be created with parent objects to indicate ownership, ensuring that objects are deleted when they are no longer used. With widgets, these parent-child relationships have an additional meaning: each child widget is displayed within the screen area occupied by its parent widget. This means that when you delete a window widget, all the child widgets it contains are also deleted.

Writing a Main Function

Many of the GUI examples provided with Qt follow the pattern of having a main.cpp file, which contains the standard code to initialize the application, plus any number of other source/header files that contain the application logic and custom GUI components.

A typical main() function in main.cpp looks like this:

from PySide6 import QtWidgets
# Include header files for application components.
# ...
if __name__ == "__main__":

    app = QApplication([])
    # Set up and show widgets.
    # ...
    sys.exit(app.exec())

First, a QApplication object is constructed, which can be configured with arguments passed in from the command line. After the widgets have been created and shown, exec() is called to start Qt’s event loop. Control passes to Qt until this function returns. Finally, main() returns the value returned by exec() .

Simple Widget Examples

Each of these simple widget examples is written entirely within the main() function.

  • Creating a window

  • Creating child widgets

  • Using layouts

  • Nested layouts

Real World Widget Examples

In these more advanced examples , the code that creates the widgets and layouts is stored in other files. For example, the GUI for a main window may be created in the constructor of a QMainWindow subclass.

Building The Examples

If you installed a binary package to get Qt, or if you compiled Qt yourself, the examples described in this tutorial should already be built and ready to run. If you wish to modify and recompile them, follow these steps:

  1. From a command prompt, enter the directory containing the example you have modified.

  2. Type qmake and press Return. If this doesn’t work, make sure that the executable is on your path, or enter its full location.

  3. On Linux/Unix and macOS, type make and press Return; on Windows with Visual Studio, type nmake and press Return.

An executable file is created in the current directory. On Windows, this file may be located in a debug or release subdirectory. You can run this executable to see the example code at work.