Development/Tutorials/Saving and loading/pt-br
| Tutorial Series | Tutorial para Iniciantes |
| Previous | Tutorial 3 - Actions |
| What's Next | Tutorial 5 - Using Command Line Arguments |
| Further Reading | Tutorial: Using KIO Slaves in your Program KIO::NetAccess QFile |
Resumo
Agora que temos uma interface básica de editor de texto, é hora de fazer algo útil. No mais básico, um editor de texto precisa ser capaz de carregar arquivos do armazenamento de dados, salvar arquivos que você criou/editou e criar novos arquivos.
O KDE Frameworks fornece várias classes para trabalhar com arquivos que facilitam muito a vida dos desenvolvedores. A KIO framework permite que você acesse arquivos facilmente através de protocolos transparentes de rede. Ao mesmo tempo, o Qt também fornece caixas de diálogo de arquivo padrão para abrir e salvar arquivos.
O Código
main.cpp
#include <cstdlib>
#include <QApplication>
#include <QCommandLineParser>
#include <KAboutData>
#include <KLocalizedString>
#include "mainwindow.h"
int main (int argc, char *argv[])
{
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("tutorial4");
KAboutData aboutData(
// The program name used internally. (componentName)
QStringLiteral("tutorial4"),
// A displayable program name string. (displayName)
i18n("Tutorial 4"),
// The program version string. (version)
QStringLiteral("1.0"),
// Short description of what the app does. (shortDescription)
i18n("A simple text area which can load and save."),
// The license this code is released under
KAboutLicense::GPL,
// Copyright Statement (copyrightStatement = QString())
i18n("(c) 2015"),
// Optional text shown in the About box.
// Can contain any information desired. (otherText)
i18n("Some text..."),
// The program homepage string. (homePageAddress = QString())
QStringLiteral("http://example.com/"),
// The bug report email address
// (bugsEmailAddress = QLatin1String("[email protected]")
QStringLiteral("[email protected]"));
aboutData.addAuthor(i18n("Name"), i18n("Task"), QStringLiteral("[email protected]"),
QStringLiteral("http://your.website.com"), QStringLiteral("OSC Username"));
KAboutData::setApplicationData(aboutData);
QCommandLineParser parser;
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
MainWindow* window = new MainWindow();
window->show();
return app.exec();
}main.cpp não mudou do tutorial 3, exceto para alterar qualquer referência do tutorial 3 para o tutorial 4.
mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <KXmlGuiWindow>
class KTextEdit;
class KJob;
class MainWindow : public KXmlGuiWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = nullptr);
private:
void setupActions();
private slots:
void newFile();
void openFile();
void saveFile();
void saveFileAs();
void saveFileAs(const QString &outputFileName);
void downloadFinished(KJob* job);
private:
KTextEdit* textArea;
QString fileName;
};
#endifComo queremos adicionar a capacidade de carregar e salvar arquivos, precisamos adicionar as funções que farão o trabalho. Como as funções serão chamadas pelo mecanismo do Qt signal/slot, devemos especificar que essas funções são slots. Como estamos usando slots neste arquivo de cabeçalho, também devemos adicionar a macro Q_OBJECT.
Também queremos acompanhar o nome de arquivo do arquivo aberto no momento, por isso declaramos umQString fileName.
mainwindow.cpp
#include <QApplication>
#include <QAction>
#include <QSaveFile>
#include <QFileDialog>
#include <QTextStream>
#include <QByteArray>
#include <KTextEdit>
#include <KLocalizedString>
#include <KActionCollection>
#include <KStandardAction>
#include <KMessageBox>
#include <KIO/Job>
#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent) : KXmlGuiWindow(parent), fileName(QString())
{
textArea = new KTextEdit();
setCentralWidget(textArea);
setupActions();
}
void MainWindow::setupActions()
{
QAction* clearAction = new QAction(this);
clearAction->setText(i18n("&Clear"));
clearAction->setIcon(QIcon::fromTheme("document-new"));
actionCollection()->setDefaultShortcut(clearAction, Qt::CTRL + Qt::Key_W);
actionCollection()->addAction("clear", clearAction);
connect(clearAction, SIGNAL(triggered(bool)), textArea, SLOT(clear()));
KStandardAction::quit(qApp, SLOT(quit()), actionCollection());
KStandardAction::open(this, SLOT(openFile()), actionCollection());
KStandardAction::save(this, SLOT(saveFile()), actionCollection());
KStandardAction::saveAs(this, SLOT(saveFileAs()), actionCollection());
KStandardAction::openNew(this, SLOT(newFile()), actionCollection());
setupGUI(Default, "tutorial4ui.rc");
}
void MainWindow::newFile()
{
fileName.clear();
textArea->clear();
}
void MainWindow::saveFileAs(const QString &outputFileName)
{
if (!outputFileName.isNull())
{
QSaveFile file(outputFileName);
file.open(QIODevice::WriteOnly);
QByteArray outputByteArray;
outputByteArray.append(textArea->toPlainText().toUtf8());
file.write(outputByteArray);
file.commit();
fileName = outputFileName;
}
}
void MainWindow::saveFileAs()
{
saveFileAs(QFileDialog::getSaveFileName(this, i18n("Save File As")));
}
void MainWindow::saveFile()
{
if (!fileName.isEmpty())
{
saveFileAs(fileName);
}
else
{
saveFileAs();
}
}
void MainWindow::openFile()
{
QUrl fileNameFromDialog = QFileDialog::getOpenFileUrl(this, i18n("Open File"));
if (!fileNameFromDialog.isEmpty())
{
KIO::Job* job = KIO::storedGet(fileNameFromDialog);
fileName = fileNameFromDialog.toLocalFile();
connect(job, SIGNAL(result(KJob*)), this, SLOT(downloadFinished(KJob*)));
job->exec();
}
}
void MainWindow::downloadFinished(KJob* job)
{
if (job->error())
{
KMessageBox::error(this, job->errorString());
fileName.clear();
return;
}
KIO::StoredTransferJob* storedJob = (KIO::StoredTransferJob*)job;
textArea->setPlainText(QTextStream(storedJob->data(), QIODevice::ReadOnly).readAll());
}Entraremos em detalhes do mainwindow.cpp daqui a pouco.
tutorial4ui.rc
<?xml version="1.0" encoding="UTF-8"?>
<gui name="tutorial4"
version="1"
xmlns="http://www.kde.org/standards/kxmlgui/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0
http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd" >
<MenuBar>
<Menu name="file" >
<Action name="clear" />
</Menu>
</MenuBar>
<ToolBar name="mainToolBar" >
<text>Main Toolbar</text>
<Action name="clear" />
</ToolBar>
</gui>
Isso é idêntico ao tutorial3ui.rc do tutorial 3, exceto que o name foi alterado para 'tutorial4'. Não precisamos adicionar nenhuma informação sobre nenhum dos KStandardActions, pois o posicionamento dessas actions é tratado automaticamente pelo KDE.
Explicação
Ok, agora para implementar o código que fará o carregamento e o salvamento. Tudo isso estará acontecendo em mainwindow.cpp
A primeira coisa que fazemos é adicionar fileName(QString()) à lista de construtores MainWindow para garantir que fileName esteja vazio desde o início.
Adicionando os actions
A primeira coisa que faremos é fornecer a interface externa para o usuário, para que ele possa dizer ao aplicativo para carregar e salvar. Assim como na action quit no tutorial 3, usaremos KStandardActions. Nós adicionamos as actions da mesma maneira que para a action quit e, para cada uma, nós a conectamos ao slot apropriado que declaramos no arquivo de cabeçalho.
Criando um novo documento
A primeira função que criamos é a função newFile().
void MainWindow::newFile()
{
fileName.clear();
textArea->clear();
}fileName.clear() define a QString fileName como vazio para refletir o fato de que este documento ainda não tem presença no armazenamento. textArea->clear() limpa a área de texto central usando a mesma função à qual conectamos o clear KQction no tutorial 3.
Salvando um arquivo
saveFileAs(QString)
Agora chegamos a nossa primeira manipulação de código de arquivos. Vamos implementar uma função que salvará o conteúdo da área de texto no arquivo de nome fornecido como parâmetro. O Qt fornece uma classe para salvar com segurança um arquivo chamada QSaveFile.
O protótipo da função é
void MainWindow::saveFileAs(const QString &outputFileName)Em seguida, criamos nosso objeto QSaveFile e o abrimos com
QSaveFile file(outputFileName);
file.open(QIODevice::WriteOnly);Agora que temos nosso arquivo para gravar, precisamos formatar o texto na área de texto para um formato que possa ser gravado em arquivo. Para isso, criamos um QByteArray e o preenchemos com a versão em texto sem formatação do que estiver na área de texto:
QByteArray outputByteArray;
outputByteArray.append(textArea->toPlainText().toUtf8());Agora que temos nosso QByteArray, usamos o para gravar no arquivo com QSaveFile::write(). Se estivéssemos usando um QFile normal, isso faria as alterações imediatamente. No entanto, se um problema ocorresse parcialmente durante a gravação, o arquivo seria corrompido. Por esse motivo, QSaveFile funciona primeiro escrevendo em um arquivo temporário e, em seguida, quando você chama QSaveFile::commit() as alterações são feitas no arquivo real. commit() também fecha o arquivo.
file.write(outputByteArray);
file.commit();Por fim, definimos fileName do membro MainWindows para apontar para o nome do arquivo no qual acabamos de salvar.
fileName = outputFileName;saveFileAs()
Esta é a função à qual o slot saveAs está conectado. Ele simplesmente chama a função genérica saveFileAs(QString) e passa o nome do arquivo retornado por QFileDialog::getSaveFileName().
void MainWindow::saveFileAs()
{
saveFileAs(QFileDialog::getSaveFileName(this, i18n("Save File As")));
}QFileDialog fornece várias funções estáticas para exibir a caixa de diálogo de arquivo comum usada por todos os aplicativos do KDE. Chamar QFileDialog::getSaveFileName() exibirá uma caixa de diálogo onde o usuário pode selecionar o nome do arquivo para salvar ou escolher um novo nome. A função retorna o nome completo do arquivo, que passamos para saveFileAs(QString).
saveFile()
void MainWindow::saveFile()
{
if(!fileName.isEmpty())
{
saveFileAs(fileName);
}
else
{
saveFileAs();
}
}Não há nada interessante ou novo nessa função, apenas a lógica para decidir se deve ou não mostrar a caixa de diálogo Salvar. Se fileName não estiver vazio, o arquivo será salvo em fileName. Mas, se estiver, a caixa de diálogo é mostrada para permitir que o usuário selecione um nome de arquivo.
Carregando um arquivo
Por fim, somos capazes de carregar um arquivo, do armazenamento local ou de um local remoto como um servidor FTP. O código para isso está todo contido em MainWindow::openFile().
Primeiro, devemos solicitar ao usuário o nome do arquivo que ele deseja abrir. Fazemos isso usando outra das funções QFileDialog, desta vez getOpenFileName():
QUrl fileNameFromDialog = QFileDialog::getOpenFileUrl(this, i18n("Open File"));Aqui usamos a classe QUrl para manipular arquivos de locais remotos.
Em seguida, usamos a biblioteca KIO para recuperar nosso arquivo. Isso nos permite abrir o arquivo normalmente, mesmo se ele estiver armazenado em um local remoto, como um site FTP. Fazemos a seguinte chamada para a função KIO::storedGet() com um argumento para o arquivo que você deseja abrir ou baixar:
KIO::Job* job = KIO::storedGet(fileNameFromDialog);A função retorna um manipulador para um KIO::Job, que primeiro conectamos ao nosso slot downloadFinished() antes de "executar" o trabalho.
connect(job, SIGNAL(result(KJob*)), this, SLOT(downloadFinished(KJob*)));
job->exec();O restante do trabalho acontece no slot downloadFinished(). Primeiro, o job é verificado quanto a erros. Se ele falhar, exibimos uma caixa de mensagem indicando o erro. Também limpamos o fileName, pois o arquivo não foi aberto com sucesso:
KMessageBox::error(this, job->errorString());
fileName.clear();Caso contrário, continuamos com a abertura do arquivo.
Os dados que o storedGet() baixou com sucesso, neste caso o conteúdo do nosso arquivo de texto, são armazenados no membro data de um KIO::StoredTransferJob. Mas, para exibir o conteúdo do arquivo em texto, devemos usar um QTextStream. Criamos um passando os dados do StoredTransferJob para seu construtor e, em seguida, chamamos sua função readAll() para obter o texto do arquivo. Isso é passado para a função setPlainText() da nossa área de texto.
KIO::StoredTransferJob* storedJob = (KIO::StoredTransferJob*)job;
textArea->setPlainText(QTextStream(storedJob->data(), QIODevice::ReadOnly).readAll());Make, Install, e Run
CMakeLists.txt
cmake_minimum_required(VERSION 3.0)
project (tutorial4)
set(QT_MIN_VERSION "5.3.0")
set(KF5_MIN_VERSION "5.2.0")
find_package(ECM 1.0.0 REQUIRED NO_MODULE)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)
include(FeatureSummary)
find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
Core # QCommandLineParser, QStringLiteral, QSaveFile, QTextStream, QByteArray
Widgets # QApplication, QAction, QFileDialog
)
find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
CoreAddons # KAboutData
I18n # KLocalizedString
XmlGui # KXmlGuiWindow, KActionCollection
TextWidgets # KTextEdit
ConfigWidgets # KStandardActions
WidgetsAddons # KMessageBox
KIO # KIO
)
feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
set(tutorial4_SRCS main.cpp mainwindow.cpp)
add_executable(tutorial4 ${tutorial4_SRCS})
target_link_libraries(tutorial4
Qt5::Widgets
KF5::CoreAddons
KF5::I18n
KF5::XmlGui
KF5::TextWidgets
KF5::ConfigWidgets
KF5::WidgetsAddons
KF5::KIOCore
)
install(TARGETS tutorial4 ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
install(FILES tutorial4ui.rc DESTINATION ${KDE_INSTALL_KXMLGUI5DIR}/tutorial4)
Como agora estamos usando a biblioteca KIO, precisamos dizer ao CMake para linkar-se a ela. Fazemos isso passando KIO para a função find_package() e KF5::KIOCore para target_link_libraries() .
Com esse arquivo, o tutorial pode ser construído e executado da mesma maneira que o tutorial 3. Para obter mais informações, consulte o tutorial 3.
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=$HOME
make install
XDG_DATA_DIRS=$HOME/share:$XDG_DATA_DIRS $HOME/bin/tutorial4
Adiante
Agora você pode seguir para tutorial command line arguments.