Difference between revisions of "Development/Tutorials/Saving and loading (de)"

Jump to: navigation, search
(Using xsd instead of dtd (not state of the art) / MenuBar tag _before_ ToolBar tag as requested by xsd)
m (Text replace - "<code cppqt>" to "<syntaxhighlight lang="cpp-qt">")
Line 228: Line 228:
  
 
Als erstes fügen wir
 
Als erstes fügen wir
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
fileName(QString())
 
fileName(QString())
 
</code>
 
</code>
Line 241: Line 241:
 
Die erste Funktion die wir erstellen ist <tt>newFile()</tt>.
 
Die erste Funktion die wir erstellen ist <tt>newFile()</tt>.
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
void MainWindow::newFile()
 
void MainWindow::newFile()
 
{
 
{
Line 258: Line 258:
  
 
Der Prototyp für unsere Funktion ist
 
Der Prototyp für unsere Funktion ist
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
void MainWindow::saveFileAs(const QString &outputFileName)
 
void MainWindow::saveFileAs(const QString &outputFileName)
 
</code>
 
</code>
 
Wir erstellen dann unser <tt>KSaveFile</tt> Objekt und öffnen es mit
 
Wir erstellen dann unser <tt>KSaveFile</tt> Objekt und öffnen es mit
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
KSaveFile file(outputFileName);
 
KSaveFile file(outputFileName);
 
file.open();
 
file.open();
Line 269: Line 269:
  
 
Nun da wir unsere Datei zum Beschreiben haben, müssen wir den Text im Textfeld so formatieren, dass er in eine Datei geschrieben werden kann. Dazu erstellen wir ein {{qt|QByteArray}} und füllen es mit der einfachen Text Version von was auch immer im Textfeld ist:
 
Nun da wir unsere Datei zum Beschreiben haben, müssen wir den Text im Textfeld so formatieren, dass er in eine Datei geschrieben werden kann. Dazu erstellen wir ein {{qt|QByteArray}} und füllen es mit der einfachen Text Version von was auch immer im Textfeld ist:
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
QByteArray outputByteArray;
 
QByteArray outputByteArray;
 
outputByteArray.append(textArea->toPlainText());
 
outputByteArray.append(textArea->toPlainText());
 
</code>
 
</code>
 
Jetzt haben wir unser <tt>QByteArray</tt>, das wir dazu verwenden mit <tt>KSaveFile::write()</tt> in die Datei zu schreiben. Wenn wir ein normales <tt>QFile</tt> benutzen würden, würde dies die Änderungen sofort ausführen. Falls aber während dem Schreiben ein Fehler passieren würde, würde die Datei beschädigt werden. Darum speichert <tt>KSaveFile</tt> zuerst in eine temporäre Datei und dann, wenn man <tt>KSaveFile::finalize()</tt> aufruft, werden die Änderungen in die eigentliche Datei geschrieben.
 
Jetzt haben wir unser <tt>QByteArray</tt>, das wir dazu verwenden mit <tt>KSaveFile::write()</tt> in die Datei zu schreiben. Wenn wir ein normales <tt>QFile</tt> benutzen würden, würde dies die Änderungen sofort ausführen. Falls aber während dem Schreiben ein Fehler passieren würde, würde die Datei beschädigt werden. Darum speichert <tt>KSaveFile</tt> zuerst in eine temporäre Datei und dann, wenn man <tt>KSaveFile::finalize()</tt> aufruft, werden die Änderungen in die eigentliche Datei geschrieben.
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
file.write(outputByteArray);
 
file.write(outputByteArray);
 
file.finalize();
 
file.finalize();
Line 280: Line 280:
 
</code>
 
</code>
 
Schliesslich setzen wir <tt>MainWindows</tt>'s <tt>fileName</tt> Element dazu auf den Dateinamen zu zeigen, in den wir gerade geschrieben haben.
 
Schliesslich setzen wir <tt>MainWindows</tt>'s <tt>fileName</tt> Element dazu auf den Dateinamen zu zeigen, in den wir gerade geschrieben haben.
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
fileName = outputFileName;
 
fileName = outputFileName;
 
</code>
 
</code>
Line 288: Line 288:
 
Dies ist die Funktion mit der der <tt>saveAs</tt> Slot verbunden ist. Sie ruft einfach eine normale <tt>saveFileAs(QString)</tt> Funktion auf und übergibt den Dateinamen der von <tt>{{class|KFileDialog}}::[http://api.kde.org/4.0-api/kdelibs-apidocs/kio/html/classKFileDialog.html#8891356c249c5911e1ab15cc2739a89b getSaveFileName()]</tt> zurückgegeben wird.
 
Dies ist die Funktion mit der der <tt>saveAs</tt> Slot verbunden ist. Sie ruft einfach eine normale <tt>saveFileAs(QString)</tt> Funktion auf und übergibt den Dateinamen der von <tt>{{class|KFileDialog}}::[http://api.kde.org/4.0-api/kdelibs-apidocs/kio/html/classKFileDialog.html#8891356c249c5911e1ab15cc2739a89b getSaveFileName()]</tt> zurückgegeben wird.
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
void MainWindow::saveFileAs()
 
void MainWindow::saveFileAs()
 
{
 
{
Line 301: Line 301:
 
====saveFile()====
 
====saveFile()====
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
void MainWindow::saveFile()
 
void MainWindow::saveFile()
 
{
 
{
Line 323: Line 323:
 
Als erstes müssen wir den Benutzer nach dem Namen der Datei fragen, die er öffnen möchte. Dazu benutzen wir eine weitere <tt>KFileDialog</tt> Funktion diesmal <tt>getOpenFileName()</tt>:
 
Als erstes müssen wir den Benutzer nach dem Namen der Datei fragen, die er öffnen möchte. Dazu benutzen wir eine weitere <tt>KFileDialog</tt> Funktion diesmal <tt>getOpenFileName()</tt>:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
QString fileNameFromDialog = KFileDialog::getOpenFileName();
 
QString fileNameFromDialog = KFileDialog::getOpenFileName();
 
</code>
 
</code>
Line 329: Line 329:
 
Dann nutzen wir die KIO Bibliothek, um unsere Datei aufzurufen. Das ermöglicht es uns die Datei mit QFile zu öffnen, selbst wenn sie sich auf einem externen Speicherort befindet, wie auf einer FTP-Seite. Wir machen den folgenden Aufruf an die  {{class|NetAccess}} <tt>download()</tt> Funktion:
 
Dann nutzen wir die KIO Bibliothek, um unsere Datei aufzurufen. Das ermöglicht es uns die Datei mit QFile zu öffnen, selbst wenn sie sich auf einem externen Speicherort befindet, wie auf einer FTP-Seite. Wir machen den folgenden Aufruf an die  {{class|NetAccess}} <tt>download()</tt> Funktion:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
KIO::NetAccess::download(fileNameFromDialog, tmpFile, this)
 
KIO::NetAccess::download(fileNameFromDialog, tmpFile, this)
 
</code>
 
</code>
Line 338: Line 338:
 
Die Funktion gibt <tt>true</tt> oder <tt>false</tt> zurück, je nachdem ob die Übertragung erfolgreich war oder nicht. Falls sie fehlgeschlagen ist, wird eine Fehlermeldung angezeigt:
 
Die Funktion gibt <tt>true</tt> oder <tt>false</tt> zurück, je nachdem ob die Übertragung erfolgreich war oder nicht. Falls sie fehlgeschlagen ist, wird eine Fehlermeldung angezeigt:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
KMessageBox::error(this, KIO::NetAccess::lastErrorString());
 
KMessageBox::error(this, KIO::NetAccess::lastErrorString());
 
</code>
 
</code>
Line 346: Line 346:
 
Wir erstellen ein QFile indem wir die temporäre Datei die durch <tt>NetAccess::download()</tt> erzeugt wurde ihrem Konstruktor übergeben und dann in schreibgeschütztem Modus öffnen:
 
Wir erstellen ein QFile indem wir die temporäre Datei die durch <tt>NetAccess::download()</tt> erzeugt wurde ihrem Konstruktor übergeben und dann in schreibgeschütztem Modus öffnen:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
QFile file(tmpFile);
 
QFile file(tmpFile);
 
file.open(QIODevice::ReadOnly);
 
file.open(QIODevice::ReadOnly);
Line 353: Line 353:
 
Um den Inhalt der Datei anzuzeigen, müssen wir Gebrauch von einem {{class|QTextStream}} machen. Wir erstellen einen, indem wir den Inhalt unserer Datei seinem Konstruktor übergeben und dann QFile's <tt>readAll()</tt> Funktion aufrufen um den Text von der Datei zu erhalten. Dieser wird dann zu der <tt>setPlainText()</tt> Funktion unseres Textfelds übergeben:
 
Um den Inhalt der Datei anzuzeigen, müssen wir Gebrauch von einem {{class|QTextStream}} machen. Wir erstellen einen, indem wir den Inhalt unserer Datei seinem Konstruktor übergeben und dann QFile's <tt>readAll()</tt> Funktion aufrufen um den Text von der Datei zu erhalten. Dieser wird dann zu der <tt>setPlainText()</tt> Funktion unseres Textfelds übergeben:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
textArea->setPlainText(QTextStream(&file).readAll());
 
textArea->setPlainText(QTextStream(&file).readAll());
 
</code>
 
</code>
Line 359: Line 359:
 
Wir speichern dann den Pfad der Datei, die wir gerade geöffnet haben:
 
Wir speichern dann den Pfad der Datei, die wir gerade geöffnet haben:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
fileName = fileNameFromDialog;
 
fileName = fileNameFromDialog;
 
</code>
 
</code>
Line 365: Line 365:
 
Und schliesslich entfernen wir die temporäre Datei, die durch <tt>NetAccess::download()</tt> erstellt wurde:
 
Und schliesslich entfernen wir die temporäre Datei, die durch <tt>NetAccess::download()</tt> erstellt wurde:
  
<code cppqt>
+
<syntaxhighlight lang="cpp-qt">
 
KIO::NetAccess::removeTempFile(tmpFile);
 
KIO::NetAccess::removeTempFile(tmpFile);
 
</code>
 
</code>

Revision as of 20:30, 29 June 2011


Development/Tutorials/Saving_and_loading


Laden und Speichern von Dateien
Anleitungsserie   Anleitung für Anfänger
Voriges Kapitel   Anleitung 3 - KActions benutzen
Nächstes Kapitel   Anleitung 5 - KCmdLineArgs benutzen
Weiterführende Texte   KIO::NetAccess QFile
Navigation   Deutsche Startseite

Zusammenfassung

In diesem Kapitel werden Sie lernen, wie man grundsätzliche Datei-Aktionen wie Laden und Speichern mithilfe der KIO Bibliothek einbindet.

KDE stellt eine Anzahl von Klassen bereit um das Arbeiten mit Dateien für die Entwickler deutlich zu vereinfachen. Die KIO Bibliothek ermöglicht es Dateien auf einfache Weise über Netzwerk-transparente Protokolle anzusteuern und stellt auch Standard Dateidialoge bereit.

Introtokdetutorial4.png

Der Code

main.cpp

  1. include <KApplication>
  2. include <KAboutData>
  3. include <KCmdLineArgs>
  1. include "mainwindow.h"

int main (int argc, char *argv[]) {

 KAboutData aboutData( "tutorial4", "tutorial4",
     ki18n("Tutorial 4"), "1.0",
     ki18n("A simple text area which can load and save."),
     KAboutData::License_GPL,
     ki18n("Copyright (c) 2007 Developer") );
 KCmdLineArgs::init( argc, argv, &aboutData );
 KApplication app;

 MainWindow* window = new MainWindow();
 window->show();
 return app.exec();

} main.cpp hat sich seit der dritten Anleitung nicht verändert, ausser das jeder Bezug zu 'tutorial 3' zu 'tutorial 4' geändert wurde.

mainwindow.h

  1. ifndef MAINWINDOW_H
  2. define MAINWINDOW_H
  1. include <KXmlGuiWindow>
  2. include <KTextEdit>

class MainWindow : public KXmlGuiWindow {

 Q_OBJECT //neu seit Anleitung 3
 
 public:
   MainWindow(QWidget *parent=0);
 
 private:
   KTextEdit* textArea;
   void setupActions();
   QString fileName; //neu
 private slots: //neu
   void newFile(); //neu
   void openFile(); //neu
   void saveFile(); //neu
   void saveFileAs(); //neu
   void saveFileAs(const QString &outputFileName); //neu

};

  1. endif

Da wir unserem Programm die Fähigkeit geben wollen, Dateien zu laden und zu speichern müssen wir Funktionen hinzufügen, die diese Arbeit erledigen werden. Da die Funktionen durch Qt's signal/slot-Mechanismus aufgerufen werden, müssen wir definieren, dass diese Funktionen Slots sind, wie wir dies auf Zeile 19 machen. Da wir Slots in diesem Header-File benutzen, müssen wir auch das Q_OBJECT Makro hinzufügen.

Wir werden auch den Dateinamen der momentan geöffneten Datei verfügbar haben wollen, also definieren wir einen QString fileName.

mainwindow.cpp

  1. include "mainwindow.h"
  1. include <KApplication>
  2. include <KAction>
  3. include <KLocale>
  4. include <KActionCollection>
  5. include <KStandardAction>
  6. include <KFileDialog> //neu
  7. include <KMessageBox> //neu
  8. include <KIO/NetAccess> //neu
  9. include <KSaveFile> //neu
  10. include <QTextStream> //neu

MainWindow::MainWindow(QWidget *parent)

   : KXmlGuiWindow(parent),
     fileName(QString()) //neu

{

 textArea = new KTextEdit;
 setCentralWidget(textArea);

 setupActions();

}

void MainWindow::setupActions() {

 KAction* clearAction = new KAction(this);
 clearAction->setText(i18n("Clear"));
 clearAction->setIcon(KIcon("document-new"));
 clearAction->setShortcut(Qt::CTRL + Qt::Key_W);
 actionCollection()->addAction("clear", clearAction);
 connect(clearAction, SIGNAL(triggered(bool)),
         textArea, SLOT(clear()));

 KStandardAction::quit(kapp, SLOT(quit()),
                       actionCollection());

 KStandardAction::open(this, SLOT(openFile()),
                       actionCollection()); //neu

 KStandardAction::save(this, SLOT(saveFile()),
                       actionCollection()); //neu

 KStandardAction::saveAs(this, SLOT(saveFileAs()),
                       actionCollection()); //neu

 KStandardAction::openNew(this, SLOT(newFile()),
                       actionCollection()); //neu

 setupGUI();

}

//Neu ab hier

void MainWindow::newFile() {

 fileName.clear();
 textArea->clear();

}

void MainWindow::saveFileAs(const QString &outputFileName) {

 KSaveFile file(outputFileName);
 file.open();
 
 QByteArray outputByteArray;
 outputByteArray.append(textArea->toPlainText());
 file.write(outputByteArray);
 file.finalize();
 file.close();
 
 fileName = outputFileName;

}

void MainWindow::saveFileAs() {

 saveFileAs(KFileDialog::getSaveFileName());

}

void MainWindow::saveFile() {

 if(!fileName.isEmpty())
 {
   saveFileAs(fileName);
 }
 else
 {
   saveFileAs();
 }

}

void MainWindow::openFile() {

 QString fileNameFromDialog = KFileDialog::getOpenFileName();
 QString tmpFile;
 if(KIO::NetAccess::download(fileNameFromDialog, tmpFile, 
        this))
 {
   QFile file(tmpFile);
   file.open(QIODevice::ReadOnly);
   textArea->setPlainText(QTextStream(&file).readAll());
   fileName = fileNameFromDialog;
   KIO::NetAccess::removeTempFile(tmpFile);
 }
 else
 {
   KMessageBox::error(this, 
       KIO::NetAccess::lastErrorString());
 }

}

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> Dies ist identisch mit tutorial3ui.rc aus Anleitung 3 ausser dass name zu 'tutorial4' geändert wurde. Wir müssen keine Informationen über irgendeine der KStandardActions hinzuzufügen da die Platzierung dieser Aktionen automatisch durch KDE erfolgt.

Erklärung

Nun kommen wir zum Code, der das Laden und Speichern erledigen wird. Das wird alles in mainwindow.cpp passieren.

Als erstes fügen wir <syntaxhighlight lang="cpp-qt"> fileName(QString()) der MainWindow Konstruktor-Liste auf Zeile 16 hinzu. Das stellt sicher, dass fileName von Anfang an leer ist.

Hinzufügen der Aktionen

Als nächstes werden wir das äusserliche Interface für den Benutzer bereitstellen, so dass er der Anwendung mitteilen kann zu laden und zu speichern. Wie mit der quit Aktion in Anleitung 3 werden wir KStandardActions verwenden. Auf Zeilen 37 bis 47 werden wir die Aktionen auf die selbe Weise hinzufügen wie für die quit Aktion. Für jedes einzelne werden wir es mit dem richtigen Slot verbinden den wir in der Header Datei definiert haben.

Erstellen eines neuen Dokuments

Die erste Funktion die wir erstellen ist newFile().

<syntaxhighlight lang="cpp-qt"> void MainWindow::newFile() {

 fileName.clear();
 textArea->clear();

} fileName.clear() setzt den fileName QString auf leer um zu zeigen, dass dieses Dokument noch keine Präsenz auf der Festplatte hat. textArea->clear() leert dann das zentrale Textfeld unter Verwendung der gleichen Funktion mit der wir die clear KAction in Anleitung 3 verbunden haben.

Speichern einer Datei

saveFileAs(QString)

Jetzt kommen wir zum ersten Datei-Handhabungs-Code. Wir werden eine Funktion einführen, die die Inhalte des Textfeldes in den Dateinamen, der als Parameter gegeben ist, speichert. KDE stellt die KSaveFile Klasse bereit, mit der man sicher Dateien speichern kann. Sie ist von Qt's QFile abgeleitet.


Der Prototyp für unsere Funktion ist <syntaxhighlight lang="cpp-qt"> void MainWindow::saveFileAs(const QString &outputFileName) Wir erstellen dann unser KSaveFile Objekt und öffnen es mit <syntaxhighlight lang="cpp-qt"> KSaveFile file(outputFileName); file.open();


Nun da wir unsere Datei zum Beschreiben haben, müssen wir den Text im Textfeld so formatieren, dass er in eine Datei geschrieben werden kann. Dazu erstellen wir ein QByteArray und füllen es mit der einfachen Text Version von was auch immer im Textfeld ist: <syntaxhighlight lang="cpp-qt"> QByteArray outputByteArray; outputByteArray.append(textArea->toPlainText()); Jetzt haben wir unser QByteArray, das wir dazu verwenden mit KSaveFile::write() in die Datei zu schreiben. Wenn wir ein normales QFile benutzen würden, würde dies die Änderungen sofort ausführen. Falls aber während dem Schreiben ein Fehler passieren würde, würde die Datei beschädigt werden. Darum speichert KSaveFile zuerst in eine temporäre Datei und dann, wenn man KSaveFile::finalize() aufruft, werden die Änderungen in die eigentliche Datei geschrieben. <syntaxhighlight lang="cpp-qt"> file.write(outputByteArray); file.finalize(); file.close(); Schliesslich setzen wir MainWindows's fileName Element dazu auf den Dateinamen zu zeigen, in den wir gerade geschrieben haben. <syntaxhighlight lang="cpp-qt"> fileName = outputFileName;

saveFileAs()

Dies ist die Funktion mit der der saveAs Slot verbunden ist. Sie ruft einfach eine normale saveFileAs(QString) Funktion auf und übergibt den Dateinamen der von KFileDialog::getSaveFileName() zurückgegeben wird.

<syntaxhighlight lang="cpp-qt"> void MainWindow::saveFileAs() {

 saveFileAs(KFileDialog::getSaveFileName());

}


Dies ist unser erster eigentlicher Gebrauch der KIO Bibliothek. KFileDialog Stellt eine Anzahl statischer Funktionen bereit um den gemeinsamen Dateidialog, der von allen KDE Anwendungen genutzt wird, anzuzeigen. KFileDialog::getSaveFileName() aufzurufen wird einen Dialog anzeigen wo der Benutzer den Namen der Datei eingeben kann in die er speichern will oder einen neuen Namen angeben. Diese Funktion gibt den vollständigen Dateinamen zurück, den wir dann saveFileAs(QString) übergeben.

saveFile()

<syntaxhighlight lang="cpp-qt"> void MainWindow::saveFile() {

 if(!fileName.isEmpty())
 {
   saveFileAs(fileName);
 }
 else
 {
   saveFileAs();
 }

}

Es gibt nichts neues oder aufregendes an dieser Funktion, nur die Logik zu entscheiden den Speicher-Dialog zu zeigen, oder nicht. Wenn fileName nicht leer ist, dann wird die Datei zu fileName gespeichert. Andernfalls wird der Dialog angezeigt damit der Benutzer einen Dateinamen bestimmen kann.

Laden einer Datei

Endlich werden wir in der Lage sein eine Datei zu öffnen. Der ganze Code hierfür ist in MainWindow::openFile() enthalten.

Als erstes müssen wir den Benutzer nach dem Namen der Datei fragen, die er öffnen möchte. Dazu benutzen wir eine weitere KFileDialog Funktion diesmal getOpenFileName():

<syntaxhighlight lang="cpp-qt"> QString fileNameFromDialog = KFileDialog::getOpenFileName();

Dann nutzen wir die KIO Bibliothek, um unsere Datei aufzurufen. Das ermöglicht es uns die Datei mit QFile zu öffnen, selbst wenn sie sich auf einem externen Speicherort befindet, wie auf einer FTP-Seite. Wir machen den folgenden Aufruf an die NetAccess download() Funktion:

<syntaxhighlight lang="cpp-qt"> KIO::NetAccess::download(fileNameFromDialog, tmpFile, this)

Diese Funktion speichert die Datei temporär auf der Festplatte. Das erste Argument ist der Name der Datei, die man öffnen möchte. Das zweite ist ein QString der, nachdem der Download abgeschlossen ist den Speicherort der temporären Datei enthalten wird. Es ist mit diesem tmpFile, mit dem wir von nun an arbeiten werden.


Die Funktion gibt true oder false zurück, je nachdem ob die Übertragung erfolgreich war oder nicht. Falls sie fehlgeschlagen ist, wird eine Fehlermeldung angezeigt:

<syntaxhighlight lang="cpp-qt"> KMessageBox::error(this, KIO::NetAccess::lastErrorString());

Ansonsten fahren wir fort, die Datei zu öffnen.

Wir erstellen ein QFile indem wir die temporäre Datei die durch NetAccess::download() erzeugt wurde ihrem Konstruktor übergeben und dann in schreibgeschütztem Modus öffnen:

<syntaxhighlight lang="cpp-qt"> QFile file(tmpFile); file.open(QIODevice::ReadOnly);

Um den Inhalt der Datei anzuzeigen, müssen wir Gebrauch von einem QTextStream machen. Wir erstellen einen, indem wir den Inhalt unserer Datei seinem Konstruktor übergeben und dann QFile's readAll() Funktion aufrufen um den Text von der Datei zu erhalten. Dieser wird dann zu der setPlainText() Funktion unseres Textfelds übergeben:

<syntaxhighlight lang="cpp-qt"> textArea->setPlainText(QTextStream(&file).readAll());

Wir speichern dann den Pfad der Datei, die wir gerade geöffnet haben:

<syntaxhighlight lang="cpp-qt"> fileName = fileNameFromDialog;

Und schliesslich entfernen wir die temporäre Datei, die durch NetAccess::download() erstellt wurde:

<syntaxhighlight lang="cpp-qt"> KIO::NetAccess::removeTempFile(tmpFile);

Erzeugen, Installieren und Ausführen

CMakeLists.txt

project(tutorial4)

find_package(KDE4 REQUIRED) include_directories(${KDE4_INCLUDES})

set(tutorial4_SRCS

 main.cpp
 mainwindow.cpp

)

kde4_add_executable(tutorial4 ${tutorial4_SRCS})

target_link_libraries(tutorial4 ${KDE4_KDEUI_LIBS}

                               ${KDE4_KIO_LIBS})

install(TARGETS tutorial4 DESTINATION ${BIN_INSTALL_DIR}) install(FILES tutorial4ui.rc

       DESTINATION ${DATA_INSTALL_DIR}/tutorial4)

Da wir nun die KIO Bibliothek verwenden, müssen wir CMake mitteilen es einzubinden. Wir machen das indem wir ${KDE4_KIO_LIBS} der target_link_libraries() Funktion übergeben.

Mit dieser Datei kann die Anleitung auf die selbe Weise erzeugt und ausgeführt werden wie in Anleitung 3. Für weitere Informationen, siehe Anleitung 3.

mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=$HOME
make install
$HOME/bin/tutorial4

Weiter geht's

Jetzt können sie mit dem Kapitel KCmdLineArgs forfahren.


Content is available under Creative Commons License SA 4.0 unless otherwise noted.