Programación en KDE/Qt

Una barra de estado permite mostrar de manera disimulada información referente a nuestra aplicación. Si nuestro programa hace alguna actividad en segundo plano, el usuario puede ser notificado viendo la barra de estado; si el archivo ha sido modificado y debe ser guardado, la barra de estado puede indicarlo; en un editor de textos también puede mostrar información como la línea y la columna actual. En este artículo tomaremos el código desarrollado en Un Editor Sencillo De Documentos y le añadiremos la barra de estado para que muestre el nombre del archivo abierto por poner algo, y un widget de la clase KProgress que puede ser usado para mostrar el avance al cargar el archivo a editar (no se incluirá el código para esta función dejándoselo de tarea al lector); cualquier otra cosa la puede añadir el lector usando el mismo procedimiento que con la barra de progreso.

La barra de estado es manejada por la clase KStatusBar la cual corresponde a la biblioteca libkdeui. Si el widget principal de la aplicación es derivado de KMainWindow ya disponemos de una barra de estado automáticamente, a la cual tenemos acceso mediante el método statusbar() que devuelve un puntero a dicha barra perteneciente a la ventana principal. Si queremos usar otra barra u otro método, se debe ubicar de forma manual, por ejemplo usando un layout. En nuestro caso, como dijimos, tenemos un objeto principal derivado de KMainWindow, así que esta clase hará el trabajo de ubicarla por nosotros. El código de nuestra clase principal quedaría así:

Archivo KMiMainWindow.cpp

#include "KMiMainWindow.h"
// Encabezados KDE
#include <kaction.h>
#include <kmenubar.h>
#include <kpopupmenu.h>
#include <kstdaction.h>
#include <ktoolbar.h>
#include <kfiledialog.h>
#include <ktextedit.h>
// Encabezados Qt
#include <qfile.h>
#include <qtextstream.h>
// Encabezados añadidos
#include <kprogress.h>
#include <kstatusbar.h>

/******************************************************************************
 * Constructor de la clase.                                                   *
 ******************************************************************************/
KMiMainWindow::KMiMainWindow(QWidget *parent, const char *name)
             : KMainWindow(parent, name) {
  setGeometry(0, 0, 400, 400);
  setCaption("MiMainWindow");
  CrearStatusBar();
  CrearAcciones();
  CrearMenu();
  CrearToolbar();
  txtEditor = new KTextEdit(this, "txtEditor");
  setCentralWidget(txtEditor);
}
/******************************************************************************
 * 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());
  actGuardar = KStdAction::save (this, SLOT(slotGuardar()), actionCollection());
  actPegar   = KStdAction::paste(this, SLOT(slotPegar()),   actionCollection());
  actSalir   = KStdAction::quit (this, SLOT(slotSalir()),   actionCollection());
  actAbrir->setToolTip  ("Abre un archivo en el editor");
  actCopiar->setToolTip ("Copia el texto seleccionado al portapapeles");
  actCortar->setToolTip ("Elimina el texto seleccionado y lo copia al portapapeles");
  actGuardar->setToolTip("Guarda el texto actual en un archivo");
  actPegar->setToolTip  ("Pega el texto del portapapeles");
  actSalir->setToolTip  ("Termina el programa");
  actionCollection()->setHighlightingEnabled(true);
  connect(actionCollection(), SIGNAL(actionStatusText(const QString &)),
          statusBar(),        SLOT  (message(const QString &)));
  connect(actionCollection(), SIGNAL(clearStatusText()),
          statusBar(),        SLOT  (clear()));
}
/******************************************************************************
 * Procedimiento para crear el menú y añadir las acciones                     *
 ******************************************************************************/
void KMiMainWindow::CrearMenu(void) {
  mb = new KMenuBar(this, "MenuBar");
  p  = new KPopupMenu(this, "PopupArchivo");
  actAbrir->plug(p);
  actGuardar->plug(p);
  p->insertSeparator();
  actSalir->plug(p);
  mb->insertItem("&Archivo", p);
  p = new KPopupMenu(this, "PopupEdicion");
  actCopiar->plug(p);
  actCortar->plug(p);
  actPegar->plug(p);
  mb->insertItem(QString::fromUtf8("&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);
  actGuardar->plug(tb);
  tb->insertLineSeparator();
  actCopiar->plug(tb);
  actCortar->plug(tb);
  actPegar->plug(tb);
  tb->insertLineSeparator();
  actSalir->plug(tb);
}
/******************************************************************************
 * Procedimiento para crear la barra de estado.                               *
 ******************************************************************************/
void KMiMainWindow::CrearStatusBar(void) {
  statusBar()->show();
  pbar = new KProgress(this, "ProgressBar");
  pbar->setFixedHeight(18);
  // Añadimos la etiqueta para indicar lo que hace el programa
  statusBar()->insertItem("Archivo en blanco", 0, 1);
  // Insertamos la barra de progreso en la barra de estado
  statusBar()->addWidget(pbar);
  statusBar()->setItemAlignment(0, Qt::AlignLeft | Qt::AlignVCenter);
}
/******************************************************************************
 * SLOT para procesar la acción Abrir                                         *
 ******************************************************************************/
void KMiMainWindow::slotAbrir(void) {
  // Primero obtenemos el nombre del archivo a abrir.
  Archivo = KFileDialog::getOpenFileName();
  QFile ArchEntr(Archivo);
  // Lo abrimos en modo lectura
  if (ArchEntr.open(IO_ReadOnly)) {
    // Lo leemos
    QTextStream ts(&ArchEntr);
    // Llenamos el txtEditor con el contenido del archivo
    txtEditor->setText(ts.read());
    statusBar()->changeItem(Archivo, 0);
    setCaption("MiMainWindow - " + Archivo);
  }
}
/******************************************************************************
 * SLOT para procesar la acción Copiar                                        *
 ******************************************************************************/
void KMiMainWindow::slotCopiar(void) {
  txtEditor->copy();
}
/******************************************************************************
 * SLOT para procesar la acción Cortar                                        *
 ******************************************************************************/
void KMiMainWindow::slotCortar(void) {
  txtEditor->cut();
}
/******************************************************************************
 * SLOT para procesar la acción Guardar                                       *
 ******************************************************************************/
void KMiMainWindow::slotGuardar(void) {
  // Abrimos el archivo en modo escritura
  QFile ArchSal(Archivo);
  if (ArchSal.open(IO_WriteOnly)) {
    // Asignamos el stream de salida al archivo
    QTextStream ts(&ArchSal);
    // Guardamos en el archivo el contenido de txtEditor
    ts << txtEditor->text();
  }
}
/******************************************************************************
 * SLOT para procesar la acción Pegar                                         *
 ******************************************************************************/
void KMiMainWindow::slotPegar(void) {
  txtEditor->paste();
}
/******************************************************************************
 * SLOT para procesar la acción Salir                                         *
 ******************************************************************************/
void KMiMainWindow::slotSalir(void) {
  close();
}

Archivo KMiMainWindow.h

#include <kmainwindow.h>

class KAction;
class KMenuBar;
class KPopupMenu;
class KProgress;
class KTextEdit;
class QString;

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    *actGuardar;
    KAction    *actPegar;
    KAction    *actSalir;
    KMenuBar   *mb;
    KPopupMenu *p;
    KProgress  *pbar;
    KTextEdit  *txtEditor;
    QString    Archivo;
    // Funciones Privadas
    void CrearAcciones(void);
    void CrearMenu(void);
    void CrearStatusBar(void);
    void CrearToolbar(void);

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

Esta vez hemos añadido el método CrearStatusBar() para manejar lo referente a la inicialización de la barra de estado. Durante la creación de las acciones, se conectan las señales emitidas por los KAction a través de actionCollection() con los slots de la barra de estado. Con ésto logramos que cada vez que se seleccione un menú y se resalte un item, se muestre en la barra de estado el tooltip asociado con el item resaltado. A continuación los pantallazos de nuestra aplicación recién creada.

 

Podemos observar en el primero cómo se muestra en la barra de estado el tooltip referente a la acción seleccionada Abrir, mientras que el segundo muestra el tooltip como tal al posicionar el mouse sobre el botón de la barra de herramientas que corresponde con la acción Abrir. Esta vez hemos usado un nuevo método llamado QString::fromUtf8() el cual permite mostar un texto escrito en UTF-8 independientemente de la configuración del sistema donde se ejecute nuestro programa, a partir de ahora todo nuestro código será escrito en formato UTF-8 por lo que haremos uso de esta función constantemente.