Inicio » Forums » Desarrollo de KDE y Qt

Introducción a la programación en KDE4 - Tutorial 4 - Cargar y guardar archivos

Diciembre 23, 2008 por edumardo
Enviado en

Esta serie de tutoriales son una copia de lo ya traducido en TechBase por mi. En dicha página puedes encontrar la versión original y la versión traducida al español.

Contenido

  1. Resumen
  2. El código
    1. main.cpp
    2. mainwindow.h
    3. mainwindow.cpp
    4. tutorial4ui.rc
  3. Explicación
    1. Añadir las acciones
    2. Crear un nuevo documento
    3. Guardar un archivo
      1. saveFileAs(QString)
      2. saveFileAs()
      3. saveFile()
    4. Cargar un archivo
  4. Make, instalar y ejecutar
    1. CMakeLists.txt
  5. Avanzando

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.

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.rx

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
  3. <gui name="tutorial4" version="1">
  4.   <ToolBar name="mainToolBar" >
  5.     <text>Main Toolbar</text>
  6.     <Action name="limpiar" />
  7.   </ToolBar>
  8.   <MenuBar>
  9.     <Menu name="file" >
  10.       <Action name="limpiar" />
  11.     </Menu>
  12.   </MenuBar>
  13. </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.

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

Avanzando
Ahora puedes continuar con el Tutorial 5 - KCmdLineArgs.

‹ Personalizar tus ventanas en Qt: Ventanas sin marcos (con movilidad en el escritorio) Problema con signals/slots en una aplicacion PyKDE4 [SOLUCIONADO] ›

Gracias por vuestro trabajo.

Enviado por kAnónimo el Mar, 12/30/2008 - 07:45.

Se que todo cuesta tiempo y trabajo, y que muchas veces pedimos más y más.
Ahora quería hacer una sugerencia: podeis poner los tutoriales tambien en pdf, así se pueden descargar y guardar, quizás con el tiempo se podría hacer un libro con los diversos capítulos. Guardarlo tal como sale en la pantalla (versión html) no es muy estético si posteriormente se encuaderna como libro.

Gracias por todo.

Buena idea, €18 el libro de

Enviado por elpreto el Mar, 12/30/2008 - 09:35.

Buena idea, €18 el libro de KDE Hispano, con guias de programación, un cd y un calendario con fotos de edumardo semi desnudo.

Puede funcionar

Enviado por kAnónimo el Mié, 12/31/2008 - 10:36.

Siempre hay gente (yo uno de ellos) que prefiere tener documentación escrita, y creo que sobre programación KDE4 en español no debe haber nada o casi nada.

Depende del libro, puede ser una buena opción.

Se puede hacer

Enviado por edumardo el Mié, 12/31/2008 - 14:55.

No es muy difícil una vez hecho el tutorial exportarlo a pdf. Creo que drupal tiene la opción "Ver para impresión" o algo parecido.

Gracias por la idea.

Un saludo.

PD: elpreto, lo de las fotos mejor lo dejamos para el calendario de KDEHispano ;).

Y...

Enviado por Annubis el Mar, 12/30/2008 - 11:22.

Un DVD de Mandriva, para que aprendan a usar un SO de verdad [/flame]

Buenisimo viejo, gracias por

Enviado por elpreto el Mié, 12/24/2008 - 16:38.

Buenisimo viejo, gracias por tu trabajo.
Por ahora esto de ver a la familia solo en navidad y ocasiones asi, hace que no puedo empezar a probar los tutoriales, pero ya, en unos dias empiezo.