qt 6.5.1 original

tests/manual/findfiles/CMakeLists.txt

@@ -0,0 +1,37 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.16)
+project(findfiles LANGUAGES CXX)
+
+if(NOT DEFINED INSTALL_EXAMPLESDIR)
+    set(INSTALL_EXAMPLESDIR "examples")
+endif()
+
+set(INSTALL_EXAMPLEDIR "${INSTALL_EXAMPLESDIR}/widgets/dialogs/findfiles")
+
+find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
+
+qt_standard_project_setup()
+
+qt_add_executable(findfiles
+    main.cpp
+    window.cpp window.h
+)
+
+set_target_properties(findfiles PROPERTIES
+    WIN32_EXECUTABLE TRUE
+    MACOSX_BUNDLE TRUE
+)
+
+target_link_libraries(findfiles PRIVATE
+    Qt6::Core
+    Qt6::Gui
+    Qt6::Widgets
+)
+
+install(TARGETS findfiles
+    RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
+    BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
+    LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
+)

tests/manual/findfiles/findfiles.pro

@@ -0,0 +1,10 @@
+QT += widgets
+requires(qtConfig(filedialog))
+
+HEADERS       = window.h
+SOURCES       = main.cpp \
+                window.cpp
+
+# install
+target.path = $$[QT_INSTALL_EXAMPLES]/widgets/dialogs/findfiles
+INSTALLS += target

tests/manual/findfiles/findfiles.qdoc

@@ -0,0 +1,269 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
+
+/*!
+    \example dialogs/findfiles
+    \title Find Files Example
+    \ingroup examples-dialogs
+
+    \brief A dialog for finding files in a specified folder.
+
+    The Find Files application allows the user to search for files in a
+    specified directory, matching a given file name or wildcard,
+    and containing a specified string (if filled in). The search
+    result is displayed in a table containing the names of the files
+    and their sizes. The application also shows the number of files found.
+
+    The Find Files example illustrates the use of several classes:
+
+    \table
+    \row
+       \li QProgressDialog
+       \li Provide feedback on the progress of a search operation
+    \row
+       \li QFileDialog
+       \li Browse through a file list
+    \row
+       \li QTextStream
+       \li Use stream operators to read a file
+    \row
+       \li QTableWidget
+       \li Browse through the search results in a table
+    \row
+       \li QDesktopServices
+       \li Open files in the result list in a suitable application
+    \endtable
+
+    \image findfiles-example.png Screenshot of the Find Files example
+
+
+    \section1 Window Class Definition
+
+    The \c Window class inherits QWidget, and is the main application
+    widget. It shows the search options and displays the search
+    results.
+
+    \snippet dialogs/findfiles/window.h 0
+
+    The application has two private slots:
+    \table
+    \row
+        \li The \c browse() slot
+        \li Called whenever the user wants to browse for a directory to search in
+    \row
+        \li The \c find() slot
+        \li Called whenever the user launches a search with the \uicontrol Find button
+    \endtable
+
+    In addition we declare several private functions:
+
+    \table
+        \row
+            \li findFiles()
+            \li Search for files matching the search parameters
+        \row
+            \li showFiles()
+            \li Display the search result
+        \row
+            \li ceateButton()
+            \li Construct the widget
+        \row
+            \li createComboBox()
+            \li Construct the widget
+        \row
+            \li createFilesTable()
+            \li Construct the widget
+    \endtable
+
+    \section1 Window Class Implementation
+
+    In the constructor we first create the application's widgets.
+
+    \snippet dialogs/findfiles/window.cpp 0
+
+    We create the widgets to build up the UI, and we add them to a main layout
+    using QGridLayout. We have, however, put the \c Find and \c Quit buttons
+    and a stretchable space in a separate \l QHBoxLayout first, to make the
+    buttons appear in the \c Window widget's bottom right corner.
+
+    Alternatively, we could have used Qt Designer to construct a UI file,
+    and \l {uic} to generate this code.
+
+    \snippet dialogs/findfiles/window.cpp 1
+
+    We did not create a \l QMenuBar with a \uicontrol Quit menu item; but we
+    would still like to have a keyboard shortcut for quitting. Since we
+    construct a \l QShortcut with \l QKeySequence::Quit, and connect it to
+    \l QApplication::quit(), on most platforms it will be possible to press
+    Control-Q to quit (or whichever standard Quit key is configured on that platform).
+    (On \macos, this is redundant, because every application gets a
+    \uicontrol Quit menu item automatically; but it helps to make the application portable.)
+
+    \snippet dialogs/findfiles/window.cpp 2
+
+    The \c browse() slot presents a file dialog to the user, using the
+    QFileDialog class. QFileDialog enables a user to traverse the file
+    system in order to select one or many files or a directory. The
+    easiest way to create a QFileDialog is to use the convenience
+    static functions.
+
+    Here we use the static QFileDialog::getExistingDirectory()
+    function which returns an existing directory selected by the
+    user. Then we display the directory in the directory combobox
+    using the QComboBox::addItem() function and update the current
+    index.
+
+    QComboBox::addItem() adds an item to the combobox with the given
+    text (if not already present in the list), and containing
+    the specified userData. The item is appended to the list of
+    existing items.
+
+    \snippet dialogs/findfiles/window.cpp 3
+
+    The \c find() slot is called whenever the user requests a new
+    search by pressing the \uicontrol Find button.
+
+    First we eliminate any previous search results by setting the
+    table widgets row count to zero. Then we retrieve the
+    specified file name, text, and directory path from the respective
+    comboboxes.
+
+    \snippet dialogs/findfiles/window.cpp 4
+
+    We use the directory's path to create a QDir; the QDir class
+    provides access to the directory structure and its contents.
+
+    We use QDirIterator to iterate over the files that match the
+    specified file name and build a QStringList of paths.
+
+    Then we search through all the files in the list, using the private
+    \c findFiles() function, eliminating the ones that don't contain the
+    specified text. We sort them (because QDirIterator did not). And finally,
+    we display the results using the private \c showFiles() function.
+
+    If the user didn't specify any text, there is no reason to search
+    through the files, so we sort and display the results immediately.
+
+    \image findfiles_progress_dialog.png Screenshot of the Progress Dialog
+
+    \snippet dialogs/findfiles/window.cpp 5
+
+    In the private \c findFiles() function we search through a list of
+    files, looking for the ones that contain a specified text. This
+    can be a very slow operation depending on the number of files as
+    well as their sizes. QProgressDialog displays a progress dialog
+    if the application has to search through a large number of files,
+    or if some of the files have a large size. QProgressDialog can
+    also allow the user to abort the operation if it takes too much
+    time.
+
+    \snippet dialogs/findfiles/window.cpp 6
+
+    We run through the files, one at a time, and for each file we
+    update the QProgressDialog value. This property holds the current
+    amount of progress made. We also update the progress dialog's
+    label.
+
+    Then we call the QCoreApplication::processEvents() function using
+    the QApplication object. In this way we interleave the display of
+    the progress made with the process of searching through the files
+    so the application doesn't appear to be frozen.
+
+    The QApplication class manages the GUI application's control flow
+    and main settings. It contains the main event loop, where all
+    events from the window system and other sources are processed and
+    dispatched. QApplication inherits QCoreApplication.  The
+    QCoreApplication::processEvents() function processes all pending
+    events according to the specified QEventLoop::ProcessEventFlags
+    until there are no more events to process. The default flags are
+    QEventLoop::AllEvents.
+
+    \snippet dialogs/findfiles/window.cpp 7
+
+    After updating the QProgressDialog, we open the file in read-only
+    mode, and read one line at a time using QTextStream.
+
+    The QTextStream class provides a convenient interface for reading
+    and writing text. Using QTextStream's streaming operators, you can
+    conveniently read and write words, lines and numbers.
+
+    For each line we read we check if the QProgressDialog has been
+    canceled. If it has, we abort the operation, otherwise we check if
+    the line contains the specified text. When we find the text within
+    one of the files, we add the file's name to a list of found files
+    that contain the specified text, and start searching a new file.
+
+    Finally, we return the list of the files found.
+
+    \snippet dialogs/findfiles/window.cpp 8
+
+    Both the \c findFiles() and \c showFiles() functions are called from
+    the \c find() slot. In the \c showFiles() function we run through
+    the provided list of file names, adding each relative file name to the
+    first column in the table widget and retrieving the file's size using
+    QFileInfo for the second column. We use \l QLocale::formattedDataSize()
+    to format the file size in a human-readable form. For later use, we set
+    the absolute path as a data on the QTableWidget using the
+    the role absoluteFileNameRole defined to be Qt::UserRole + 1.
+
+    \snippet dialogs/findfiles/window.cpp 17
+
+    This allows for retrieving the name of an item using a
+    convenience function:
+
+    \snippet dialogs/findfiles/window.cpp 18
+
+    We also update the total number of files found.
+
+    \snippet dialogs/findfiles/window.cpp 10
+
+    The private \c createComboBox() function is also called from the
+    constructor. We create a QComboBox with the given text, and make it
+    editable.
+
+    When the user enters a new string in an editable combobox, the
+    widget may or may not insert it, and it can insert it in several
+    locations, depending on the QComboBox::InsertPolicy. The default
+    policy is is QComboBox::InsertAtBottom.
+
+    Then we add the provided text to the combobox, and specify the
+    widget's size policies, before we return a pointer to the
+    combobox.
+
+    \snippet dialogs/findfiles/window.cpp 11
+
+    The private \c createFilesTable() function is called from the
+    constructor. In this function we create the QTableWidget that
+    will display the search results. We set its horizontal headers and
+    their resize mode.
+
+    QTableWidget inherits QTableView which provides a default
+    model/view implementation of a table view. The
+    QTableView::horizontalHeader() function returns the table view's
+    horizontal header as a QHeaderView. The QHeaderView class provides
+    a header row or header column for item views, and the
+    QHeaderView::setResizeMode() function sets the constraints on how
+    the section in the header can be resized.
+
+    Finally, we hide the QTableWidget's vertical headers using the
+    QWidget::hide() function, and remove the default grid drawn for
+    the table using the QTableView::setShowGrid() function.
+
+    \snippet dialogs/findfiles/window.cpp 12
+
+    \snippet dialogs/findfiles/window.cpp 14
+
+    The \c openFileOfItem() slot is invoked when the user double
+    clicks on a cell in the table. The QDesktopServices::openUrl()
+    knows how to open a file given the file name.
+
+    \snippet dialogs/findfiles/window.cpp 15
+    \snippet dialogs/findfiles/window.cpp 16
+
+    We set the context menu policy to of the table view to Qt::CustomContextMenu
+    and connect a slot contextMenu() to its signal
+    customContextMenuRequested(). We retrieve the absolute file name
+    from the data of the QTableWidgetItem and populate the context menu
+    with actions offering to copy the file name and to open the file.
+*/
+

tests/manual/findfiles/main.cpp

@@ -0,0 +1,14 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include <QApplication>
+
+#include "window.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    Window window;
+    window.show();
+    return app.exec();
+}

tests/manual/findfiles/window.cpp

@@ -0,0 +1,264 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include <QtWidgets>
+
+#include "window.h"
+
+//! [17]
+enum { absoluteFileNameRole = Qt::UserRole + 1 };
+//! [17]
+
+//! [18]
+static inline QString fileNameOfItem(const QTableWidgetItem *item)
+{
+    return item->data(absoluteFileNameRole).toString();
+}
+//! [18]
+
+//! [14]
+static inline void openFile(const QString &fileName)
+{
+    QDesktopServices::openUrl(QUrl::fromLocalFile(fileName));
+}
+//! [14]
+
+//! [0]
+Window::Window(QWidget *parent)
+    : QWidget(parent)
+{
+    setWindowTitle(tr("Find Files"));
+    QPushButton *browseButton = new QPushButton(tr("&Browse..."), this);
+    connect(browseButton, &QAbstractButton::clicked, this, &Window::browse);
+    findButton = new QPushButton(tr("&Find"), this);
+    connect(findButton, &QAbstractButton::clicked, this, &Window::find);
+
+    fileComboBox = createComboBox(tr("*"));
+    connect(fileComboBox->lineEdit(), &QLineEdit::returnPressed,
+            this, &Window::animateFindClick);
+    textComboBox = createComboBox();
+    connect(textComboBox->lineEdit(), &QLineEdit::returnPressed,
+            this, &Window::animateFindClick);
+    directoryComboBox = createComboBox(QDir::toNativeSeparators(QDir::currentPath()));
+    connect(directoryComboBox->lineEdit(), &QLineEdit::returnPressed,
+            this, &Window::animateFindClick);
+
+    filesFoundLabel = new QLabel;
+
+    createFilesTable();
+
+    QGridLayout *mainLayout = new QGridLayout(this);
+    mainLayout->addWidget(new QLabel(tr("Named:")), 0, 0);
+    mainLayout->addWidget(fileComboBox, 0, 1, 1, 2);
+    mainLayout->addWidget(new QLabel(tr("Containing text:")), 1, 0);
+    mainLayout->addWidget(textComboBox, 1, 1, 1, 2);
+    mainLayout->addWidget(new QLabel(tr("In directory:")), 2, 0);
+    mainLayout->addWidget(directoryComboBox, 2, 1);
+    mainLayout->addWidget(browseButton, 2, 2);
+    mainLayout->addWidget(filesTable, 3, 0, 1, 3);
+    mainLayout->addWidget(filesFoundLabel, 4, 0, 1, 2);
+    mainLayout->addWidget(findButton, 4, 2);
+//! [0]
+
+//! [1]
+    connect(new QShortcut(QKeySequence::Quit, this), &QShortcut::activated,
+        qApp, &QApplication::quit);
+//! [1]
+}
+
+//! [2]
+void Window::browse()
+{
+    QString directory =
+        QDir::toNativeSeparators(QFileDialog::getExistingDirectory(this, tr("Find Files"), QDir::currentPath()));
+
+    if (!directory.isEmpty()) {
+        if (directoryComboBox->findText(directory) == -1)
+            directoryComboBox->addItem(directory);
+        directoryComboBox->setCurrentIndex(directoryComboBox->findText(directory));
+    }
+}
+//! [2]
+
+static void updateComboBox(QComboBox *comboBox)
+{
+    if (comboBox->findText(comboBox->currentText()) == -1)
+        comboBox->addItem(comboBox->currentText());
+}
+
+//! [3]
+void Window::find()
+{
+    filesTable->setRowCount(0);
+
+    QString fileName = fileComboBox->currentText();
+    QString text = textComboBox->currentText();
+    QString path = QDir::cleanPath(directoryComboBox->currentText());
+    currentDir = QDir(path);
+//! [3]
+
+    updateComboBox(fileComboBox);
+    updateComboBox(textComboBox);
+    updateComboBox(directoryComboBox);
+
+//! [4]
+    QStringList filter;
+    if (!fileName.isEmpty())
+        filter << fileName;
+    QDirIterator it(path, filter, QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
+    QStringList files;
+    while (it.hasNext())
+        files << it.next();
+    if (!text.isEmpty())
+        files = findFiles(files, text);
+    files.sort();
+    showFiles(files);
+}
+//! [4]
+
+void Window::animateFindClick()
+{
+    findButton->animateClick();
+}
+
+//! [5]
+QStringList Window::findFiles(const QStringList &files, const QString &text)
+{
+    QProgressDialog progressDialog(this);
+    progressDialog.setCancelButtonText(tr("&Cancel"));
+    progressDialog.setRange(0, files.size());
+    progressDialog.setWindowTitle(tr("Find Files"));
+
+//! [5] //! [6]
+    QMimeDatabase mimeDatabase;
+    QStringList foundFiles;
+
+    for (int i = 0; i < files.size(); ++i) {
+        progressDialog.setValue(i);
+        progressDialog.setLabelText(tr("Searching file number %1 of %n...", nullptr, files.size()).arg(i));
+        QCoreApplication::processEvents();
+//! [6]
+
+        if (progressDialog.wasCanceled())
+            break;
+
+//! [7]
+        const QString fileName = files.at(i);
+        const QMimeType mimeType = mimeDatabase.mimeTypeForFile(fileName);
+        if (mimeType.isValid() && !mimeType.inherits(QStringLiteral("text/plain"))) {
+            qWarning() << "Not searching binary file " << QDir::toNativeSeparators(fileName);
+            continue;
+        }
+        QFile file(fileName);
+        if (file.open(QIODevice::ReadOnly)) {
+            QString line;
+            QTextStream in(&file);
+            while (!in.atEnd()) {
+                if (progressDialog.wasCanceled())
+                    break;
+                line = in.readLine();
+                if (line.contains(text, Qt::CaseInsensitive)) {
+                    foundFiles << files[i];
+                    break;
+                }
+            }
+        }
+    }
+    return foundFiles;
+}
+//! [7]
+
+//! [8]
+void Window::showFiles(const QStringList &paths)
+{
+    for (const QString &filePath : paths) {
+        const QString toolTip = QDir::toNativeSeparators(filePath);
+        const QString relativePath = QDir::toNativeSeparators(currentDir.relativeFilePath(filePath));
+        const qint64 size = QFileInfo(filePath).size();
+        QTableWidgetItem *fileNameItem = new QTableWidgetItem(relativePath);
+        fileNameItem->setData(absoluteFileNameRole, QVariant(filePath));
+        fileNameItem->setToolTip(toolTip);
+        fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
+        QTableWidgetItem *sizeItem = new QTableWidgetItem(QLocale().formattedDataSize(size));
+        sizeItem->setData(absoluteFileNameRole, QVariant(filePath));
+        sizeItem->setToolTip(toolTip);
+        sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
+        sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
+
+        int row = filesTable->rowCount();
+        filesTable->insertRow(row);
+        filesTable->setItem(row, 0, fileNameItem);
+        filesTable->setItem(row, 1, sizeItem);
+    }
+    filesFoundLabel->setText(tr("%n file(s) found (Double click on a file to open it)", nullptr, paths.size()));
+    filesFoundLabel->setWordWrap(true);
+}
+//! [8]
+
+//! [10]
+QComboBox *Window::createComboBox(const QString &text)
+{
+    QComboBox *comboBox = new QComboBox;
+    comboBox->setEditable(true);
+    comboBox->addItem(text);
+    comboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+    return comboBox;
+}
+//! [10]
+
+//! [11]
+void Window::createFilesTable()
+{
+    filesTable = new QTableWidget(0, 2);
+    filesTable->setSelectionBehavior(QAbstractItemView::SelectRows);
+
+    QStringList labels;
+    labels << tr("Filename") << tr("Size");
+    filesTable->setHorizontalHeaderLabels(labels);
+    filesTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+    filesTable->verticalHeader()->hide();
+    filesTable->setShowGrid(false);
+//! [15]
+    filesTable->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(filesTable, &QTableWidget::customContextMenuRequested,
+            this, &Window::contextMenu);
+    connect(filesTable, &QTableWidget::cellActivated,
+            this, &Window::openFileOfItem);
+//! [15]
+}
+//! [11]
+
+
+//! [12]
+
+void Window::openFileOfItem(int row, int /* column */)
+{
+    const QTableWidgetItem *item = filesTable->item(row, 0);
+    openFile(fileNameOfItem(item));
+}
+
+//! [12]
+
+//! [16]
+void Window::contextMenu(const QPoint &pos)
+{
+    const QTableWidgetItem *item = filesTable->itemAt(pos);
+    if (!item)
+        return;
+    QMenu menu;
+#ifndef QT_NO_CLIPBOARD
+    QAction *copyAction = menu.addAction("Copy Name");
+#endif
+    QAction *openAction = menu.addAction("Open");
+    QAction *action = menu.exec(filesTable->mapToGlobal(pos));
+    if (!action)
+        return;
+    const QString fileName = fileNameOfItem(item);
+    if (action == openAction)
+        openFile(fileName);
+#ifndef QT_NO_CLIPBOARD
+    else if (action == copyAction)
+        QGuiApplication::clipboard()->setText(QDir::toNativeSeparators(fileName));
+#endif
+}
+//! [16]

tests/manual/findfiles/window.h

@@ -0,0 +1,50 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#ifndef WINDOW_H
+#define WINDOW_H
+
+#include <QWidget>
+#include <QDir>
+
+QT_BEGIN_NAMESPACE
+class QComboBox;
+class QLabel;
+class QPushButton;
+class QTableWidget;
+class QTableWidgetItem;
+QT_END_NAMESPACE
+
+//! [0]
+class Window : public QWidget
+{
+    Q_OBJECT
+
+public:
+    Window(QWidget *parent = nullptr);
+
+private slots:
+    void browse();
+    void find();
+    void animateFindClick();
+    void openFileOfItem(int row, int column);
+    void contextMenu(const QPoint &pos);
+
+private:
+    QStringList findFiles(const QStringList &files, const QString &text);
+    void showFiles(const QStringList &paths);
+    QComboBox *createComboBox(const QString &text = QString());
+    void createFilesTable();
+
+    QComboBox *fileComboBox;
+    QComboBox *textComboBox;
+    QComboBox *directoryComboBox;
+    QLabel *filesFoundLabel;
+    QPushButton *findButton;
+    QTableWidget *filesTable;
+
+    QDir currentDir;
+};
+//! [0]
+
+#endif