Understanding QAction Signals

When building text editor applications with Qt, QAction objects serve as the primary mechanism for handling user commands. Each QAction emits a triggered() signal when activated through menus, toolbars, or keyboard shortcuts. This signal can be connected to custom slot functions to implement specific functionality. A key advantage is that multiple QAction instances can share the same slot, enabling consistent behavior across different UI elements.

File Operations Architecture

The core file management features—open, save, and save as—require careful state tracking. The application must maintain the current document path to distinguish between new files and existing files. This state determines whether the save operation writes directly to disk or prompts for a location.

1. Document Opening Process

The open operation uses QFileDialog to retrieve a file path, then reads the content using QFile and QTextStream. After successful loading, the UI updates to display the file path in the window title.

2. Document Saving Logic

The save operation checks if a file path exists. For untitled documents, it delegates to the save-as routine. When a path is available, it writes the editor's content to disk using text streaming.

3. Save As Implementation

The save-as function always prompts for a new location, then updates the application's current path after successful writing.

Implementation Code

Header File Declaration

#ifndef EDITOR_WINDOW_H
#define EDITOR_WINDOW_H

#include <QMainWindow>
#include <QString>

class QPlainTextEdit;
class QLabel;
class QMenuBar;
class QMenu;
class QAction;
class QToolBar;
class QFileDialog;

class EditorWindow : public QMainWindow
{
    Q_OBJECT

private:
    QPlainTextEdit* documentEditor;
    QLabel* cursorPositionDisplay;
    QString currentDocumentPath;

    explicit EditorWindow(QWidget* parent = nullptr);
    EditorWindow(const EditorWindow&) = delete;
    EditorWindow& operator=(const EditorWindow&) = delete;
    
    bool initializeWindow();
    bool setupMenuBar();
    bool setupToolBar();
    bool setupStatusBar();
    bool setupEditor();

    bool constructFileMenu(QMenuBar* menuBar);
    bool constructEditMenu(QMenuBar* menuBar);
    bool constructFormatMenu(QMenuBar* menuBar);
    bool constructViewMenu(QMenuBar* menuBar);
    bool constructHelpMenu(QMenuBar* menuBar);

    bool populateFileTools(QToolBar* toolBar);
    bool populateEditTools(QToolBar* toolBar);
    bool populateFormatTools(QToolBar* toolBar);
    bool populateViewTools(QToolBar* toolBar);

    bool createAction(QAction*& action, QMenu* menu, QString text, int shortcutKey);
    bool createAction(QAction*& action, QToolBar* toolBar, QString tooltip, QString iconResource);

    QString requestFilePath(QFileDialog::AcceptMode mode, QString dialogTitle);
    void displayError(QString errorMessage);

private slots:
    void openDocument();
    void saveDocument();
    void saveDocumentAs();

public:
    static EditorWindow* createInstance();
    ~EditorWindow();
};

#endif

UI Initialization Implementation

#include "EditorWindow.h"
#include <QDebug>
#include <QPlainTextEdit>
#include <QLabel>
#include <QMenuBar>
#include <QMenu>
#include <QAction>
#include <QToolBar>
#include <QStatusBar>
#include <QIcon>
#include <QSize>

EditorWindow::EditorWindow(QWidget* parent)
    : QMainWindow(parent), documentEditor(nullptr), cursorPositionDisplay(nullptr)
{
    currentDocumentPath.clear();
}

bool EditorWindow::initializeWindow()
{
    if (!setupMenuBar()) return false;
    if (!setupToolBar()) return false;
    if (!setupStatusBar()) return false;
    if (!setupEditor()) return false;
    
    return true;
}

EditorWindow* EditorWindow::createInstance()
{
    EditorWindow* window = new EditorWindow();
    
    if (!window || !window->initializeWindow())
    {
        delete window;
        return nullptr;
    }
    
    return window;
}

bool EditorWindow::setupMenuBar()
{
    QMenuBar* menuBar = this->menuBar();
    if (!menuBar) return false;

    return constructFileMenu(menuBar) && 
           constructEditMenu(menuBar) && 
           constructFormatMenu(menuBar) && 
           constructViewMenu(menuBar) && 
           constructHelpMenu(menuBar);
}

bool EditorWindow::setupToolBar()
{
    QToolBar* toolBar = addToolBar("Primary Toolbar");
    if (!toolBar) return false;

    toolBar->setIconSize(QSize(16, 16));
    toolBar->setFloatable(false);

    return populateFileTools(toolBar) && 
           populateEditTools(toolBar) && 
           populateFormatTools(toolBar) && 
           populateViewTools(toolBar);
}

bool EditorWindow::setupStatusBar()
{
    QStatusBar* statusBar = this->statusBar();
    if (!statusBar) return false;

    cursorPositionDisplay = new QLabel("Line: 1, Col: 1", this);
    QLabel* infoLabel = new QLabel("Simple Text Editor", this);

    if (!cursorPositionDisplay || !infoLabel) return false;

    cursorPositionDisplay->setMinimumWidth(180);
    cursorPositionDisplay->setAlignment(Qt::AlignCenter);
    infoLabel->setMinimumWidth(180);
    infoLabel->setAlignment(Qt::AlignCenter);

    statusBar->addPermanentWidget(new QLabel());
    statusBar->addPermanentWidget(cursorPositionDisplay);
    statusBar->addPermanentWidget(infoLabel);

    return true;
}

bool EditorWindow::setupEditor()
{
    documentEditor = new QPlainTextEdit(this);
    if (!documentEditor) return false;

    setCentralWidget(documentEditor);
    return true;
}

bool EditorWindow::constructFileMenu(QMenuBar* menuBar)
{
    QMenu* fileMenu = new QMenu("File(&F)");
    if (!fileMenu) return false;

    QAction* newAction = nullptr;
    if (!createAction(newAction, fileMenu, "New(&N)", Qt::CTRL | Qt::Key_N)) return false;
    fileMenu->addAction(newAction);

    fileMenu->addSeparator();

    QAction* openAction = nullptr;
    if (!createAction(openAction, fileMenu, "Open(&O)...", Qt::CTRL | Qt::Key_O)) return false;
    connect(openAction, SIGNAL(triggered()), this, SLOT(openDocument()));
    fileMenu->addAction(openAction);

    fileMenu->addSeparator();

    QAction* saveAction = nullptr;
    if (!createAction(saveAction, fileMenu, "Save(&S)", Qt::CTRL | Qt::Key_S)) return false;
    connect(saveAction, SIGNAL(triggered()), this, SLOT(saveDocument()));
    fileMenu->addAction(saveAction);

    fileMenu->addSeparator();

    QAction* saveAsAction = nullptr;
    if (!createAction(saveAsAction, fileMenu, "Save As(&A)...", 0)) return false;
    connect(saveAsAction, SIGNAL(triggered()), this, SLOT(saveDocumentAs()));
    fileMenu->addAction(saveAsAction);

    fileMenu->addSeparator();

    QAction* printAction = nullptr;
    if (!createAction(printAction, fileMenu, "Print(&P)...", Qt::CTRL | Qt::Key_P)) return false;
    fileMenu->addAction(printAction);

    fileMenu->addSeparator();

    QAction* exitAction = nullptr;
    if (!createAction(exitAction, fileMenu, "Exit(&X)", 0)) return false;
    fileMenu->addAction(exitAction);

    menuBar->addMenu(fileMenu);
    return true;
}

bool EditorWindow::createAction(QAction*& action, QMenu* menu, QString text, int shortcutKey)
{
    action = new QAction(text, menu);
    if (!action) return false;
    
    if (shortcutKey != 0)
    {
        action->setShortcut(QKeySequence(shortcutKey));
    }
    
    return true;
}

bool EditorWindow::createAction(QAction*& action, QToolBar* toolBar, QString tooltip, QString iconResource)
{
    action = new QAction(tooltip, toolBar);
    if (!action) return false;
    
    action->setToolTip(tooltip);
    action->setIcon(QIcon(iconResource));
    
    return true;
}

EditorWindow::~EditorWindow()
{
}

File Operation Slots Implementation

#include "EditorWindow.h"
#include <QFileDialog>
#include <QStringList>
#include <QFile>
#include <QTextStream>
#include <QMessageBox>

QString EditorWindow::requestFilePath(QFileDialog::AcceptMode mode, QString dialogTitle)
{
    QFileDialog dialog(this);
    dialog.setWindowTitle(dialogTitle);
    dialog.setAcceptMode(mode);
    
    QStringList filters;
    filters << "Text Documents (*.txt)" << "All Files (*.*)";
    dialog.setNameFilters(filters);
    
    if (mode == QFileDialog::AcceptOpen)
    {
        dialog.setFileMode(QFileDialog::ExistingFile);
    }
    
    if (dialog.exec() == QFileDialog::Accepted)
    {
        return dialog.selectedFiles().first();
    }
    
    return QString();
}

void EditorWindow::displayError(QString errorMessage)
{
    QMessageBox errorDialog(this);
    errorDialog.setWindowTitle("Operation Failed");
    errorDialog.setText(errorMessage);
    errorDialog.setIcon(QMessageBox::Critical);
    errorDialog.setStandardButtons(QMessageBox::Ok);
    errorDialog.exec();
}

void EditorWindow::openDocument()
{
    QString selectedPath = requestFilePath(QFileDialog::AcceptOpen, "Open Document");
    
    if (selectedPath.isEmpty()) return;
    
    QFile inputFile(selectedPath);
    if (!inputFile.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        displayError(QString("Cannot open file:\n\n%1").arg(selectedPath));
        return;
    }
    
    QTextStream stream(&inputFile);
    documentEditor->setPlainText(stream.readAll());
    inputFile.close();
    
    currentDocumentPath = selectedPath;
    setWindowTitle(QString("Editor - [%1]").arg(currentDocumentPath));
}

void EditorWindow::saveDocument()
{
    if (currentDocumentPath.isEmpty())
    {
        saveDocumentAs();
        return;
    }
    
    QFile outputFile(currentDocumentPath);
    if (!outputFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        displayError(QString("Cannot save file:\n\n%1").arg(currentDocumentPath));
        currentDocumentPath.clear();
        return;
    }
    
    QTextStream stream(&outputFile);
    stream << documentEditor->toPlainText();
    outputFile.close();
    
    setWindowTitle(QString("Editor - [%1]").arg(currentDocumentPath));
}

void EditorWindow::saveDocumentAs()
{
    QString selectedPath = requestFilePath(QFileDialog::AcceptSave, "Save Document As");
    
    if (selectedPath.isEmpty()) return;
    
    QFile outputFile(selectedPath);
    if (!outputFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        displayError(QString("Cannot create file:\n\n%1").arg(selectedPath));
        return;
    }
    
    QTextStream stream(&outputFile);
    stream << documentEditor->toPlainText();
    outputFile.close();
    
    currentDocumentPath = selectedPath;
    setWindowTitle(QString("Editor - [%1]").arg(currentDocumentPath));
}

Application Entry Point

#include <QApplication>
#include <QTextCodec>
#include "EditorWindow.h"

int main(int argc, char* argv[])
{
    // Set text codec for legacy file support
    QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
    
    QApplication app(argc, argv);
    
    EditorWindow* mainWindow = EditorWindow::createInstance();
    if (!mainWindow)
    {
        return -1;
    }
    
    mainWindow->show();
    return app.exec();
}

Key Development Principles

Qt text editor development benefits from several architectural patterns:

First, maintain clear separation between user interface configuration and business logic. This modular approach simplifies maintenance and enables independent testing of components.

Second, leverage Qt's built-in components like QPlainTextEdit, QFileDialog, and QMessageBox rather than creating custom widgets. This ensures consistent behavior across platforms and reduces development effort.

Third, implement functionality primarily through slot functions. These slots respond directly to user interactions and serve as the entry points for all application features, from file operations to text formatting.