Getting Started Programming with Qt

Hello Notepad

In this first example, we simply create and show a text edit in a window frame on the desktop. This represents the simplest possible Qt program that has a GUI.

Here is the code:

  1        #include <QApplication>
  2        #include <QTextEdit>
  3
  4        int main(int argv, char **args)
  5        {
  6            QApplication app(argv, args);
  7
  8            QTextEdit textEdit;
  9            textEdit.show();
 10
 11            return app.exec();
 12        }

Let us go through the code line by line. In the first two lines, we include the header files for QApplication and QTextEdit, which are the two classes that we need for this example. All Qt classes have a header file named after them.

Line 6 creates a QApplication object. This object manages application-wide resources and is necessary to run any Qt program that has a GUI. It needs argv and args because Qt accepts a few command line arguments.

Line 8 creates a QTextEdit object. A text edit is a visual element in the GUI. In Qt, we call such elements widgets. Examples of other widgets are scroll bars, labels, and radio buttons. A widget can also be a container for other widgets; a dialog or a main application window, for example.

Line 9 shows the text edit on the screen in its own window frame. Since widgets also function as containers (for instance a QMainWindow, which has toolbars, menus, a status bar, and a few other widgets), it is possible to show a single widget in its own window. Widgets are not visible by default; the function show() makes the widget visible.

Line 11 makes the QApplication enter its event loop. When a Qt application is running, events are generated and sent to the widgets of the application. Examples of events are mouse presses and key strokes. When you type text in the text edit widget, it receives key pressed events and responds by drawing the text typed.

To run the application, open a command prompt, and enter the directory in which you have the .cpp file of the program. The following shell commands build the program.

         qmake -project
         qmake
         make

This will leave an executable in the part1 directory (note that on Windows, you may have to use nmake instead of make. Also, the executable will be placed in part1\debug or part1\release (these directories are created when you run make). qmake is Qt's build tool, which takes a configuration file. qmake generates this for us when given the -project argument. Given the configuration file (suffixed .pro), qmake produces a make file that will build the program for you. We will look into writing our own .pro files later.

  1      #include <QtGui>
  2
  3      int main(int argv, char **args)
  4      {
  5          QApplication app(argv, args);
  6
  7          QTextEdit *textEdit = new QTextEdit;
  8          QPushButton *quitButton = new QPushButton("&Quit");
  9
 10          QObject::connect(quitButton, SIGNAL(clicked()), qApp, SLOT(quit()));
 11
 12          QVBoxLayout *layout = new QVBoxLayout;
 13          layout->addWidget(textEdit);
 14          layout->addWidget(quitButton);
 15
 16          QWidget window;
 17          window.setLayout(layout);
 18
 19          window.show();
 20
 21          return app.exec();
 22      }

  5        class Notepad : public QWidget
  6        {
  7            Q_OBJECT
  8
  9        public:
 10            Notepad();
 11
 12        private slots:
 13            void quit();
 14
 15        private:
 16            QTextEdit *textEdit;
 17            QPushButton *quitButton;
 18        };

 20        Notepad::Notepad()
 21        {
 22            textEdit = new QTextEdit;
 23            quitButton = new QPushButton(tr("Quit"));
 24
 25            connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));
 26
 27            QVBoxLayout *layout = new QVBoxLayout;
 28            layout->addWidget(textEdit);
 29            layout->addWidget(quitButton);
 30
 31            setLayout(layout);
 32
 33            setWindowTitle(tr("Notepad"));
 34        }

 75      void Notepad::quit()
 76      {
 77          QMessageBox messageBox;
 78          messageBox.setWindowTitle(tr("Notepad"));
 79          messageBox.setText(tr("Do you really want to quit?"));
 80          messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
 81          messageBox.setDefaultButton(QMessageBox::No);
 82          if (messageBox.exec() == QMessageBox::Yes)
 83              qApp->quit();
 84      }

  1        HEADERS =  notepad.h
  2        SOURCES =  notepad.cpp \
  3                   main.cpp

         qmake
         make

  2        #include <QtGui>
  3
  4        class Notepad : public QMainWindow
  5        {
  6            Q_OBJECT
  7
  8        public:
  9            Notepad();
 10
 11        private slots:
 12            void open();
 13            void save();
 14            void quit();
 15
 16        private:
 17            QTextEdit *textEdit;
 18
 19            QAction *openAction;
 20            QAction *saveAction;
 21            QAction *exitAction;
 22
 23            QMenu *fileMenu;
 24        };

 25        Notepad::Notepad()
 26        {
 27            openAction = new QAction(tr("&Open"), this);
 28            saveAction = new QAction(tr("&Save"), this);
 29            exitAction = new QAction(tr("E&xit"), this);
 30
 31            connect(openAction, SIGNAL(triggered()), this, SLOT(open()));
 32            connect(saveAction, SIGNAL(triggered()), this, SLOT(save()));
 33            connect(exitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
 34
 35            fileMenu = menuBar()->addMenu(tr("&File"));
 36            fileMenu->addAction(openAction);
 37            fileMenu->addAction(saveAction);
 38            fileMenu->addSeparator();
 39            fileMenu->addAction(exitAction);
 40
 41            textEdit = new QTextEdit;
 42            setCentralWidget(textEdit);
 43
 44            setWindowTitle(tr("Notepad"));
 45        }

 48    void Notepad::open()
 49    {
 50        QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "",
 51            tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
 52
 53        if (fileName != "") {
 54            QFile file(fileName);
 55            if (!file.open(QIODevice::ReadOnly)) {
 56                QMessageBox::critical(this, tr("Error"), tr("Could not open file"));
 57                return;
 58            }
 59            QTextStream in(&file);
 60            textEdit->setText(in.readAll());
 61            file.close();
 62        }
 63    }

 65    void Notepad::save()
 66    {
 67        QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"), "",
 68        tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
 69
 70        if (fileName != "") {
 71            QFile file(fileName);
 72            if (!file.open(QIODevice::WriteOnly)) {
 73                // error message
 74            } else {
 75                QTextStream stream(&file);
 76                stream << textEdit->toPlainText();
 77                stream.flush();
 78                file.close();
 79            }
 80        }
 81    }