The Model-View design pattern in Qt separates data management from its visual representation. This architecture enables flexible and reusable components by decoupling how data is stored (model) from how its presented (view).

Core Principles of the Model-View Pattern

• Model Interface: Defines a standard API for accessing data. For example, methods like data() or index() are used to retrieve information.
• View Rendering: Uses the model’s interface to fetch data and determine how to display it.
• Data Change Notification: Models emit signals (via Qt’s signal-slot mechanism) to inform views when underlying data changes, enabling dynamic updates.
• Hierarchical Data Structure: All data in a model is conceptually organized as a tree, even for linear structures like lists or tables.

Understanding QModelIndex

QModelIndex is the cornerstone of data access in Qt’s model system. It acts as a lightweight handle to a specific item within the model.

• Each index uniquely identifies a piece of data using a combination of row, column, and parent index.
• An index contains internal information about how to retrieve the actual data and holds a pointer back to its originating model.
• Indexes are created on-demand by the model and should not be stored long-term, as they may become invalid after model changes.

Indexing in Hierarchical Models

Qt models treat all data as a tree:

• The root is a null (QModelIndex()) parent representing the top level.
• Child items under the same parent are indexed by increasing row numbers.
• A full item reference is defined by the triplet: (row, column, parentIndex).

Even flat structures like file lists use this scheme—each file is a child of the root directory index. Practical Example: Exploring QFileSystemModel

The following code demonstrates how to use QFileSystemModel and QModelIndex to inspect directory contents:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QFileSystemModel>
#include <QPlainTextEdit>

class MainWindow : public QMainWindow
{
    Q_OBJECT

    QFileSystemModel m_fileModel;
    QPlainTextEdit m_logView;

private slots:
    void onDirectoryLoaded(const QString& path);

public:
    MainWindow(QWidget* parent = nullptr);
    ~MainWindow();
};

#endif // MAINWINDOW_H

#include "MainWindow.h"
#include <QBuffer>
#include <QDir>
#include <QTextStream>
#include <QModelIndex>

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
{
    m_logView.setParent(this);
    m_logView.resize(600, 300);
    m_logView.move(10, 10);

    m_fileModel.setRootPath(QDir::currentPath());
    connect(&m_fileModel, &QFileSystemModel::directoryLoaded,
            this, &MainWindow::onDirectoryLoaded);
}

void MainWindow::onDirectoryLoaded(const QString& path)
{
    QModelIndex rootIndex = m_fileModel.index(path);

    QByteArray outputBuffer;
    QBuffer buffer(&outputBuffer);
    if (buffer.open(QIODevice::WriteOnly)) {
        QTextStream stream(&buffer);

        stream << m_fileModel.isDir(rootIndex) << Qt::endl;
        stream << m_fileModel.data(rootIndex).toString() << Qt::endl;
        stream << rootIndex.data().toString() << Qt::endl;
        stream << m_fileModel.filePath(rootIndex) << Qt::endl;
        stream << m_fileModel.fileName(rootIndex) << Qt::endl;
        stream << Qt::endl;

        int childCount = m_fileModel.rowCount(rootIndex);
        for (int row = 0; row < childCount; ++row) {
            QModelIndex childIndex = m_fileModel.index(row, 0, rootIndex);
            stream << childIndex.data().toString() << Qt::endl;
        }

        buffer.close();

        if (buffer.open(QIODevice::ReadOnly)) {
            QTextStream reader(&buffer);
            m_logView.appendPlainText(reader.readAll());
        }
    }
}

MainWindow::~MainWindow() = default;

When executed, this program outputs metadata about the current working directory and lists its immediate children (e.g., debug, release, Makefile, etc.), demonstrating how indexes provide uniform access to heirarchical data.

Key Takeaways

• Data in Qt models is accessed exclusively through QModelIndex instances.
• The standard way to request an index is via model.index(row, column, parent).
• A default-constructed QModelIndex() represents the root (top-level) parent.
• While most models follow the generic indexing scheme, custom models can implement specialized indexing logic if needed.