Development/Tutorials/Saving and loading (es)

Jump to: navigation, search


Cargar y guardar archivos
Serie   Tutorial para principiantes
Requisitos previos   Tutorial 3 - KActions
Siguiente   Tutorial 5 - Usar KCmdLineArgs
Lectura avanzada   KIO::NetAccess QFile

Contents

Resumen

Ahora que tenemos una interfaz básica del editor de textos, es hora de añadirle funcionalidad. Básicamente, un editor de textos debe abrir archivos desde disco, guardar archivos que has creado/editado y crear nuevos archivos.

KDE proporciona algunas clases para trabajar con archivos que hacen la vida mucho mas fácil a los desarrolladores. La biblioteca KIO te permite fácilmente tener acceso a archivos a través de protocolos de red transparentes, así como mediante cuadros de dialogo estándar.

Introtokdetutorial4 es.png

El código

main.cpp

  1. #include <KApplication>
  2. #include <KAboutData>
  3. #include <KCmdLineArgs>
  4.  
  5. #include "mainwindow.h"
  6.  
  7. int main (int argc, char *argv[])
  8. {
  9.   KAboutData aboutData( "tutorial4", "tutorial4",
  10.       ki18n("Tutorial 4"), "1.0",
  11.       ki18n("A simple text area which can load and save."),
  12.       KAboutData::License_GPL,
  13.       ki18n("Copyright (c) 2008 Developer") );
  14.   KCmdLineArgs::init( argc, argv, &aboutData );
  15.   KApplication app;
  16.  
  17.   MainWindow* window = new MainWindow();
  18.   window->show();
  19.   return app.exec();
  20. }

main.cpp no ha cambiado desde el tutorial 3, excepto el cambio de cualquier referencia de tutorial 3 a tutorial 4.

mainwindow.h

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3.  
  4. #include <KXmlGuiWindow>
  5. #include <KTextEdit>
  6.  
  7. class MainWindow : public KXmlGuiWindow
  8. {
  9. 	Q_OBJECT //nuevo respecto al tutorial3
  10.  
  11. 	public:
  12. 		MainWindow(QWidget *parent=0);
  13.  
  14. 	private:
  15. 		KTextEdit* textArea;
  16. 		void setupActions();
  17. 		QString fileName; //nuevo
  18.  
  19. 	private slots: //nuevo
  20. 		void newFile(); //nuevo
  21. 		void openFile(); //nuevo
  22. 		void saveFile(); //nuevo
  23. 		void saveFileAs(); //nuevo
  24. 		void saveFileAs(const QString &outputFileName); //nuevo 
  25. };
  26.  
  27. #endif

Como queremos añadir la posibilidad de cargar y guardar archivos, debemos añadir las funciones que realizarán el trabajo. Ya que invocaremos a las funciones mediante el mecanismo de Qt signal/slot, debemos especificar que dichas funciones son slots, por lo que lo hacemos en la linea 19. Como estamos usando slots en el archivo cabecera, debemos también añadir la macro Q_OBJECT.

También queremos llevar un registro del nombre del archivo abierto actual, por lo que declaramos QString fileName.

mainwindow.cpp

  1. #include "mainwindow.h"
  2.  
  3. #include <KApplication>
  4. #include <KAction>
  5. #include <KLocale>
  6. #include <KActionCollection>
  7. #include <KStandardAction>
  8. #include <KFileDialog> //nuevo
  9. #include <KMessageBox> //nuevo
  10. #include <KIO/NetAccess> //nuevo
  11. #include <KSaveFile> //nuevo
  12. #include <QTextStream> //nuevo
  13.  
  14. MainWindow::MainWindow(QWidget *parent)
  15. 	: KXmlGuiWindow(parent),
  16. 		fileName(QString()) //nuevo
  17. {
  18. 	textArea = new KTextEdit;
  19. 	setCentralWidget(textArea);
  20.  
  21. 	setupActions();
  22. }
  23.  
  24. void MainWindow::setupActions()
  25. {
  26. 	KAction* clearAction = new KAction(this);
  27. 	clearAction->setText(i18n("Limpiar"));
  28. 	clearAction->setIcon(KIcon("document-new"));
  29. 	clearAction->setShortcut(Qt::CTRL + Qt::Key_W);
  30. 	actionCollection()->addAction("limpiar", clearAction);
  31. 	connect(clearAction, SIGNAL(triggered(bool)), 
  32. 			textArea, SLOT(clear()));
  33.  
  34. 	KStandardAction::quit(kapp, SLOT(quit()), 
  35. 						actionCollection());
  36.  
  37. 	KStandardAction::open(this, SLOT(openFile()),
  38. 						actionCollection()); //nuevo
  39.  
  40. 	KStandardAction::save(this, SLOT(saveFile()),
  41. 						actionCollection()); //nuevo
  42.  
  43. 	KStandardAction::saveAs(this, SLOT(saveFileAs()),
  44. 						actionCollection()); //nuevo
  45.  
  46. 	KStandardAction::openNew(this, SLOT(newFile()),
  47. 						actionCollection()); //nuevo
  48.  
  49. 	setupGUI();
  50. }
  51.  
  52. //Nuevo de aqui en adelante
  53.  
  54. void MainWindow::newFile()
  55. {
  56. 	fileName.clear();
  57. 	textArea->clear();
  58. }
  59.  
  60. void MainWindow::saveFileAs(const QString &outputFileName)
  61. {
  62. 	KSaveFile file(outputFileName);
  63. 	file.open();
  64.  
  65. 	QByteArray outputByteArray;
  66. 	outputByteArray.append(textArea->toPlainText().toUtf8());
  67. 	file.write(outputByteArray);
  68. 	file.finalize();
  69. 	file.close();
  70.  
  71. 	fileName = outputFileName;
  72. }
  73.  
  74. void MainWindow::saveFileAs()
  75. {
  76. 	saveFileAs(KFileDialog::getSaveFileName());
  77. }
  78.  
  79. void MainWindow::saveFile()
  80. {
  81. 	if(!fileName.isEmpty())
  82. 	{
  83. 		saveFileAs(fileName);
  84. 	}
  85. 	else
  86. 	{
  87. 		saveFileAs();
  88. 	}
  89. }
  90.  
  91. void MainWindow::openFile()
  92. {
  93. 	QString fileNameFromDialog = KFileDialog::getOpenFileName();
  94.  
  95. 	QString tmpFile;
  96. 	if(KIO::NetAccess::download(fileNameFromDialog, tmpFile, this))
  97. 	{
  98. 		QFile file(tmpFile);
  99. 		file.open(QIODevice::ReadOnly);
  100. 		textArea->setPlainText(QTextStream(&file).readAll());
  101. 		fileName = fileNameFromDialog;
  102.  
  103. 		KIO::NetAccess::removeTempFile(tmpFile);
  104. 	}
  105. 	else
  106. 	{
  107. 		KMessageBox::error(this, KIO::NetAccess::lastErrorString());
  108. 	}
  109. }

tutorial4ui.rc

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <gui name="tutorial4"
  3.      version="1"
  4.      xmlns="http://www.kde.org/standards/kxmlgui/1.0"
  5.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.      xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0
  7.                          http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd" >
  8.  
  9.   <MenuBar>
  10.     <Menu name="file" >
  11.       <Action name="limpiar" />
  12.     </Menu>
  13.   </MenuBar>
  14.  
  15.   <ToolBar name="mainToolBar" >
  16.     <text>Main Toolbar</text>
  17.     <Action name="limpiar" />
  18.   </ToolBar>
  19.  
  20. </gui>

Es idéntico a tutorial3ui.rc del tutorial 3 excepto name, que ha cambiado a 'tutorial4'. No necesitamos añadir ninguna información de las KStandardAction ya que la posición de esas acciones las maneja KDE automaticamente.

Explicación

Bien, ahora vamos a implementar el código que realizará el trabajo de cargar y guardar. Esto se lleva a cabo en mainwindow.cpp

Lo primero que hacemos es añadir

fileName(QString())

al constructor de MainWindow en la linea 16. Esto asegura que fileName esté vacio desde el principio.

Añadir las acciones

La primera cosa que vamos a hacer es proporcionar al usuario la interfaz para decirle a la aplicación que cargue o guarde un archivo. Como ya hicimos con la acción quit en el tutorial 3, usaremos KStandardActions. En las lineas 37-47 añadimos las acciones de la misma manera que la acción quit. Para cada una de ellas, la conectamos que el slot apropiado que hemos declarado en el archivo cabecera.

Crear un nuevo documento

La primera función que hemos definido es newFile().

void MainWindow::newFile()
{
	fileName.clear();
	textArea->clear();
}

Con fileName.clear() ponemos la QString como "vacia" para reflejar el hecho de que el documento aún no está presente en disco. A continuación, textArea->clear() limpia el area de texto usando la misma función que conectaba con la KAction clear en el tutorial 3.

Guardar un archivo

saveFileAs(QString)

Ahora vamos a escribir nuestro primer código que maneje archivos. Vamos a implementar una función que guardará el contenido del área de texto en un archivo con un nombre pasado como parámetro. KDE proporciona una clase llamada KSaveFile para guardar archivos de manera segura, que hereda de la clase de Qt QFile.

El prototipo de la función es:

void MainWindow::saveFileAs(const QString &outputFileName)

A continuación creamos nuestro objeto KSaveFile y lo abrimos con:

KSaveFile file(outputFileName);
file.open();

Ahora que tenemos nuestro "file" para escribir, necesitamos convertir el texto del area de texto a un formato que pueda ser escrito en el archivo. Para hacer esto, creamos un QByteArray y lo rellenamos con la versión en texto plano de lo que haya en el area de texto:

QByteArray outputByteArray;
outputByteArray.append(textArea->toPlainText().toUtf8());

Ahora que tenemos nuestro QByteArray, lo usamos para escribir el archivo con KSaveFile::write(). Si estuvieramos usando un QFile, los cambios se reflejarían inmediatamente. Sin embargo, si se ha producido un problema parcial en la escritura, el archivo podría estar corrupto. Por esta razón, KSaveFile escribe primero en un archivo temporal y luego, en la llamada KSaveFile::Finalize, refleja los cambios en el archivo actual.

file.write(outputByteArray);
file.finalize();
file.close();

Por último, establecemos que fileName apunte al nombre del archivo que acabamos de guardar.

fileName = outputFileName;

saveFileAs()

Esta es la función a la que está conectado el slot saveAs. Simplemente llama a la función genérica saveFileAs(QString) pasandole el nombre del fichero devuelto por KFileDialog::getSaveFileName().

void MainWindow::saveFileAs()
{
  saveFileAs(KFileDialog::getSaveFileName());
}

Este es nuestro primer uso de la biblioteca KIO. La clase KFileDialog proporciona diferentes funciones estáticas para mostrar cuadros de dialgo estandar, usados en todas las aplicaciones de KDE. La llamada a KFileDialog::getSaveFileName() mostrará un diálogo donde el usuario puede seleccionar en nombre del archivo a guardar o elegir un nuevo nombre. La función devuelve el nombre del archivo, con el cual luego llamamos a saveFileAs(QString).

saveFile()

void MainWindow::saveFile()
{
	if(!fileName.isEmpty())
	{
		saveFileAs(fileName);
	}
	else
	{
		saveFileAs();
	}
}

No hay nada destacable o nuevo en esta función, solamente la lógica para decidir si se muestra el dialogo para guardar el archivo. Si fileName no está vacio, el archivo es guardado como fileName. Si lo está, se muestra el diálogo para permitir al usuario elegir el nombre del archivo.

Cargar un archivo

Por último, el tutorial 4 debe ser capaz de cargar archivos desde disco. El código para llevarlo a cabo se encuentra en la función MainWindow::openFile().

Primero debemos preguntar al usuario por en nombre del archivo que desea abrir. Esto lo hacemos usando otra de las funciones de KFileDialog, getOpenFileName():

QString fileNameFromDialog = KFileDialog::getOpenFileName();

Luego usamos la biblioteca KIO para recuperar nuestro archivo. Esto nos permite abrir el archivo con QFile incluso si está almacenado en una ubicación remota, como un sitio FTP. Hacemos la siguiente llamada a la función download() de la clase NetAccess:

KIO::NetAccess::download(fileNameFromDialog, tmpFile, this)

El primer argumento es el nombre del archivo que queremos descargar. El segundo es un QString el cual, una vez se haya completado la descarga, contendrá la localización de la copia temporal del archivo. Es con tmpFile con quien trabajaremos a partir de ahora.

La función devuelve true o false dependiendo si la transferencia tuvo exito. Si falló, mostraremos un mensaje informando del error:

KMessageBox::error(this, KIO::NetAccess::lastErrorString());

En caso contrario, continuamos con la apertura del archivo.

Creamos un QFile pasando a su constructor el archivo temporal creado por NetAccess::download() y lo abrirmos en modo de solo lectura:

QFile file(tmpFile);
file.open(QIODevice::ReadOnly);

Para mostrar el contenido del archivo debemos usar un QTextStream. Creamos uno pasandole el contenido de nuestro archivo a su constructor, y llamamos a la función de QFile readAll() para obtener el texto del archivo. Luego este texto se le pasa a la función setPlainText() de nuestra área de texto.

textArea->setPlainText(QTextStream(&file).readAll());

A continuación almacenamos la ruta de acceso del archivo que acabamos de abrir:

fileName = fileNameFromDialog;

y por último, eliminamos el archivo temporal que fué creado por NetAccess::download():

KIO::NetAccess::removeTempFile(tmpFile);

Make, instalar y ejecutar

CMakeLists.txt

  1. project(tutorial4)
  2.  
  3. find_package(KDE4 REQUIRED)
  4. include_directories(${KDE4_INCLUDES})
  5.  
  6. set(tutorial4_SRCS 
  7.   main.cpp
  8.   mainwindow.cpp
  9. )
  10.  
  11. kde4_add_executable(tutorial4 ${tutorial4_SRCS})
  12.  
  13. target_link_libraries(tutorial4 ${KDE4_KDEUI_LIBS} 
  14.                                 ${KDE4_KIO_LIBS})
  15.  
  16. install(TARGETS tutorial4 DESTINATION ${BIN_INSTALL_DIR})
  17. install(FILES tutorial4ui.rc 
  18.         DESTINATION ${DATA_INSTALL_DIR}/tutorial4)

Como ahora estamos usando la biblioteca KIO, debemos decirselo a CMAKE para que la enlace. Hacemos esto pasándole ${KDE4_KIO_LIBS} a la función target_link_libraries()

Con este archivo, puede construirse y ejecutar el tutorial de la misma forma que el tutorial 3. Para mas información, ve al tutorial 3.

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

Avanzando

Ahora puedes continuar con el Tutorial 5 - KCmdLineArgs


This page was last modified on 15 July 2012, at 19:30. This page has been accessed 5,026 times. Content is available under Creative Commons License SA 3.0 as well as the GNU Free Documentation License 1.2.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V.Legal