Programación en KDE/Qt

La barra de herramientas es un control que además de darle vistosidad a nuestro programa le permite al usuario ejecutar las acciones más usada de manera rápida. KDE facilita mucho su codificación al permitir incrustar una acción usada en el menú en una barra de herramientas con solo usar una línea de código, llamando al método plug(). En nuestro caso, usaremos las cinco acciones ya creadas y las colocaremos también en la barra de herramientas, también modificaremos el procedimiento void slotSalir(void) para que termine la aplicación al hacer clic en el menú salir o en la barra de herramientas. Esto a manera de ejemplo para que se entienda el uso de los slots, pues el programador decidirá qué código colocar en el slot según las necesidades de su programa.

A partir de ahora cambiaremos un poco el código hecho para tratar de ser más ordenado con el código pues a medida que un programa o módulo va creciendo, el desorden es causa de errores. Por eso se ha creado un procedimiento para cada cosa: crear las acciones, crear los menúes y crear la barra de herramientas. También se tratará de comentar más el código para que se entiendan algunas cosas incluidas en el mismo; lo que no se entienda y no aparezca explicado en el artículo deberá ser consultado en las documentación de KDE, pues no es el objetivo de este blog sustituir dicha documentación sino explicar como usarla de manera sencilla. Para usar la barra de herramientas debemos añadir el encabezado ktoolbar.h. Aquí solo se muestra el caso más sencillo: añadir la barra, colocar una acción y usar el slot, suficiente para la mayoría de los programas. Como se dijo, para otras cosas se debe revisar la documentación de la API de KDE, referenciada en la sección de enlaces de este blog. Los archivos modificados quedarían de la siguiente manera:

Archivo KMiMainWindow.h

#include <kmainwindow.h>

class KAction;

class KMiMainWindow : public KMainWindow {
  Q_OBJECT

  public:
    KMiMainWindow(QWidget *parent = 0, const char *name = 0);

  private:
    // Variables privadas
    KAction    *actAbrir;
    KAction    *actCopiar;
    KAction    *actCortar;
    KAction    *actPegar;
    KAction    *actSalir;
    // Funciones Privadas
    void CrearAcciones(void);
    void CrearMenu(void);
    void CrearToolbar(void);

  private slots:
    void slotAbrir(void);
    void slotCopiar(void);
    void slotCortar(void);
    void slotPegar(void);
    void slotSalir(void);
};

Ahora hemos tenido que modificar la declaración de la clase para incluir las acciones y los procedimientos añadidos. Antes no hizo falta porque se procesaban directamente; ahora una acción va a ser incluida en dos objetos, por lo que se necesita almacenar su dirección al ser creada para luego poder llamar al procedimiento plug() de la clase, que se encarga de añadir la acción al objeto deseado.

Archivo KMiMainWindow.cpp

#include "KMiMainWindow.h"
#include <kaction.h>
#include <kmenubar.h>
#include <kmessagebox.h>
#include <kpopupmenu.h>
#include <kstdaction.h>
// Encabezados añadidos
#include <ktoolbar.h>

KMiMainWindow::KMiMainWindow(QWidget *parent, const char *name)
             : KMainWindow(parent, name) {
  setGeometry(0, 0, 400, 400);
  setCaption("MiMainWindow");
  CrearAcciones();
  CrearMenu();
  CrearToolbar();
}
// Procedimiento encargado de crear las acciones que usaremos en el programa
void KMiMainWindow::CrearAcciones(void) {
  actAbrir  = KStdAction::open (this, SLOT(slotAbrir()),  actionCollection());
  actCopiar = KStdAction::copy (this, SLOT(slotCopiar()), actionCollection());
  actCortar = KStdAction::cut  (this, SLOT(slotCortar()), actionCollection());
  actPegar  = KStdAction::paste(this, SLOT(slotPegar()),  actionCollection());
  actSalir  = KStdAction::quit (this, SLOT(slotSalir()),  actionCollection());
}
// Procedimiento para crear el menú y añadir las acciones
void KMiMainWindow::CrearMenu(void) {
  // Creamos la barra de menú
  KMenuBar *mb = new KMenuBar(this, "MenuBar");
  // Creamos el menú Archivo, lo llenamos y lo añadimos a la barra de menú
  KPopupMenu *p = new KPopupMenu(this, "PopupArchivo");
  actAbrir->plug(p);
  p->insertSeparator();
  actSalir->plug(p);
  mb->insertItem("&Archivo", p);
  // Creamos el menú Edición, lo llenamos y lo añadimos a la barra de menú
  p = new KPopupMenu(this, "PopupEdicion");
  actCopiar->plug(p);
  actCortar->plug(p);
  actPegar->plug(p);
  mb->insertItem("&Edición", p);
}
// Procedimiento para crear la barra de herramientas y añadir las acciones
void KMiMainWindow::CrearToolbar(void) {
  KToolBar *tb = new KToolBar(this, QMainWindow::Top, false, "Toolbar", true, false);
  actAbrir->plug(tb);
  tb->insertLineSeparator();
  actCopiar->plug(tb);
  actCortar->plug(tb);
  actPegar->plug(tb);
  tb->insertLineSeparator();
  actSalir->plug(tb);
}
// SLOT para procesar la acción Abrir
void KMiMainWindow::slotAbrir(void) {
  KMessageBox::information(this, "Se ha presionado Abrir", "KMiMainWindow");
}
// SLOT para procesar la acción Copiar
void KMiMainWindow::slotCopiar(void) {
  KMessageBox::information(this, "Se ha presionado Copiar", "KMiMainWindow");
}
// SLOT para procesar la acción Cortar
void KMiMainWindow::slotCortar(void) {
  KMessageBox::information(this, "Se ha presionado Cortar", "KMiMainWindow");
}
// SLOT para procesar la acción Pegar
void KMiMainWindow::slotPegar(void) {
  KMessageBox::information(this, "Se ha presionado Pegar", "KMiMainWindow");
}
// SLOT para procesar la acción Salir
void KMiMainWindow::slotSalir(void) {
  close();
}

Aquí vemos como el constructor de la clase ha sido modificado para incluir tres procedimientos que llevan a cabo una tarea específica, haciendo más estructurado nuestro programa y más fácil de ser modificado. Cuando se crea la barra de herramientas se debe indicar si vas a estar acoplada en la parte superior, inferior, derecha o izquierda. En nuestro caso estará en la parte superior, lo cual se le indica al constructor con la constante QMainWindow::Top. Los dos últimos parámetros pasados al constructor de KToolBar indican si se debe respetar la configuración global para los iconos y textos de las barras de herramienta, y para indicar si se debe obtener la configuración de la barra de herramientas de un archivo de configuración específico de nuestra aplicación KDE creada.

Ahora lo compilamos y lo ejecutamos como de costumbre:

make && ./kaplicacion

A continuación el screenshot de nuestra aplicación, ahora con una barra herramientas añadida.