summaryrefslogtreecommitdiffstats
path: root/tests/manual/findfiles
diff options
context:
space:
mode:
Diffstat (limited to 'tests/manual/findfiles')
-rw-r--r--tests/manual/findfiles/CMakeLists.txt37
-rw-r--r--tests/manual/findfiles/findfiles.pro10
-rw-r--r--tests/manual/findfiles/findfiles.qdoc269
-rw-r--r--tests/manual/findfiles/main.cpp14
-rw-r--r--tests/manual/findfiles/window.cpp264
-rw-r--r--tests/manual/findfiles/window.h50
6 files changed, 644 insertions, 0 deletions
diff --git a/tests/manual/findfiles/CMakeLists.txt b/tests/manual/findfiles/CMakeLists.txt
new file mode 100644
index 0000000000..db27300b1e
--- /dev/null
+++ b/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}"
+)
diff --git a/tests/manual/findfiles/findfiles.pro b/tests/manual/findfiles/findfiles.pro
new file mode 100644
index 0000000000..4fb77f0dd7
--- /dev/null
+++ b/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
diff --git a/tests/manual/findfiles/findfiles.qdoc b/tests/manual/findfiles/findfiles.qdoc
new file mode 100644
index 0000000000..ec00698703
--- /dev/null
+++ b/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 \QD 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.
+*/
+
diff --git a/tests/manual/findfiles/main.cpp b/tests/manual/findfiles/main.cpp
new file mode 100644
index 0000000000..8c25b7e031
--- /dev/null
+++ b/tests/manual/findfiles/main.cpp
@@ -0,0 +1,14 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+
+#include <QApplication>
+
+#include "window.h"
+
+int main(int argc, char *argv[])
+{
+ QApplication app(argc, argv);
+ Window window;
+ window.show();
+ return app.exec();
+}
diff --git a/tests/manual/findfiles/window.cpp b/tests/manual/findfiles/window.cpp
new file mode 100644
index 0000000000..278fb7dd62
--- /dev/null
+++ b/tests/manual/findfiles/window.cpp
@@ -0,0 +1,264 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+
+#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]
diff --git a/tests/manual/findfiles/window.h b/tests/manual/findfiles/window.h
new file mode 100644
index 0000000000..ff166bf63d
--- /dev/null
+++ b/tests/manual/findfiles/window.h
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+
+#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