Bueno, hoy quiero compartir algo con todos, como trabajar con flex y bison en Qt4. Tenia un proyecto en la universidad, investigue e investigue y no encontre casi nada de información acerca de este tema, encontraba muchos ejemplos comunes del uso de flex y bison pero no como usarlo con Qt4. Encontre algunas cositas como QLALR pero me dio hueva estudiarlo asi que mejor le entre solo a flex y bison. Encontré otros que primero creaban el ejecutable del analizador y luego con un QProcess usaban ese ejecutable, pero no me gusto, creo que es mejor generar el código de los analizadores y luego integrarlos con el proyecto de Qt4, asi que eso vamos a hacer.

Antes que nada quiero decirles que no es la gran cosa el ejemplo, ni se si será la mejor manera de hacerlo, pero me funciono muy bien.

En este ejemplo haremos una calculadora, en el código se muestra como trabajar con archivos para mandarselo como parametro al parser y un objeto Acciones que sirve de intermediario por asi decirlo entre el proyecto Qt4 y el parser. Este no es un turorial de flex y bison asi que solo me voy a limitar en la union con Qt4. Estoy utilizando flex 2.5.35 y bison++ 1.21-8 en GNU/Linux.

Proyecto de ejemplo: prueba_qt4_flex_bison.tar.gz

En el archivo scanner.l estan las reglas del analizador léxico. Para generar el código en C++ ejecutamos lo siguiente en la carpeta donde esta el archivo:

flex -d -o scanner.cc scanner.l

Ese comando nos crea el archivo scanner.cc.

En el archivo parser.y estan las reglas del analizador sintactico y semantico. Para generar el código C++ ejecutamos lo siguiente en la carpeta donde esta el archivo:

bison++ -d -hparser.h -o parser.cc parser.y

Ese comando nos crear dos archivos: parser.cc y parser.h

Ahora abrimos el archivo prueba_qt4_flex_bison.pro con Qt Creator y lo compilamos.

Ya con eso tenemos una sencilla calculadora, ahora solo falta probarla: escribir “2+3*4“, tiene que salir 14

Si se necesita tambien para Windows, pues, el mismo código generado por flex y bison funciona. No se porque el código que genera flex para DOS/Windows no compila, tampoco he tenido tiempo para investigarlo asi que simplemete copie FlexLexer.h que esta en /usr/include y lo pegue en la carpeta de las cabeceras de mingw32, con eso compila nitido en Windows y nuestro programa es multiplataforma.

Espero que les sirva. =)

A veces vamos a necesitar que nuestras aplicaciones desarrolladas con Qt se puedan conectar con el SQL Server de Microsoft, esto puede ser por muchas razones, la mia en esta ocasión fue porque eso estamos estudiando en la universidad y sinceramente es muy bueno y mucho mas fácil de utilizar, a pesar de ser un linuxero safado.

Nuestra apliacación corriendo en Windows no nos presenta ningún problema, simplemente configuramos en el panel de control, herramientas administrativas, origenes de datos (ODBC) una conexión con SQL Server y ya esta, en Linux es donde se pone fea la cosa, asi que entremosle.

Los pasos aqui presentados son para Mandriva 2008.1 Spring, pero puede aplicarse a cualquier distribución con unos pequeños cambios.

Los necesario para lograr esto es unixODBC y freeTDS que seria como el driver de MS SQL Server para unixODBC, el problema es que que este driver no soporta unicode, entonces en la aplicación Qt nos dará el siguiente error:

qGetStringData: Error while fetching data (-1), y ese error ni a patadas se compone,
solamente modificando las fuentes de Qt y compilarlo.

unixODBC y freeTDS

Para lograr la comunicación con el SQL Server vamos a necesitar el unixODBC, Mandriva ya lo trae y en los repositorios podemos encontrar todo lo necesario, PERO el problema es que si compilamos nosotros mismos Qt no funcionará con ese unixODBC, da un monton de violaciones al segmento, lei por ahi que el driver ODBC de Qt puede dar problemas con unixODBC si estos no estan compilados con la misma version del compilador o algo asi, no recuerdo bien como era, asi que lo primero que hacemos es bajarnos el unixODBC de http://www.unixodbc.org/. Para no complicarnos la vida vamos a usar los paquetes de Mandriva y luego a instalar encima el unixODBC que vamos a compilar, asi que los paquetes que necesitamos instalar son los siguientes:

unixODBC, unixODBC-gui-qt, lib, libunixODBC1-devel, libunixODBC1, libunixODBC-qt

el freeTDS tambien:

libfreetds-devel, libfreetds_mssql-devel, libfreetds0, libfreetds0-unixodbc, libfreetds_mssql0, libfreetds_mssql0-unixodbc

ahora descomprimimos las fuentes de unixODBC, lo configuramos asi:

./configure –sysconfdir=/etc –disable-gui –prefix=/usr

lo instalamos en /usr para que reemplace el paquete de Mandriva, deshabilitamos el gui ya que se vuelve un relajo compilarlo en Mandriva con la mezcla rara de qt3 y la 4 que hay, de todos modos ya tenemos el unixODBC-gui-qt y ese vamos a usar.

luego make y make install, y listo.

Compilar Qt

ahora nos bajamos las fuentes de Qt de http://trolltech.com/downloads ahorita esta la version 4.4.1, descomprimimos las fuentes y buscamos el archivo “qsql_odbc.h”, este esta aqui:

<directorio donde descomprimieron>/qt-x11-opensource-src-4.4.1/src/sql/drivers/odbc/

editamos este archivo y buscamos #ifdef Q_OS_UNIX y le vamos a agregar # define Q_ODBC_VERSION_2, entonces lo dejamos asi:

#ifdef Q_OS_UNIX
#define HAVE_LONG_LONG 1 // force UnixODBC NOT to fall back to a struct for BIGINTs

// le pongo esto para que funcione con los drivers que no son compatibles
// con unicode
# define Q_ODBC_VERSION_2 //linea que agregamos

#endif

lo guardamos y a compilar, todo lo hacemos desde <directorio donde descomprimieron>/qt-x11-opensource-src-4.4.1/:

./configure -prefix /usr/lib/qt4 -plugin-sql-odbc -plugin-sql-sqlite -plugin-sql-mysql -plugin-sql-oci -assistant-webkit -v

configuramos la compilación de Qt, importante indicarle los plugins para las bases de datos, en este caso el importante es el -plugin-sql-odbc, de ahi otras extras que puse, en prefix el puse /usr/lib/qt4 para que reemplace el que trae Mandriva y asi ya esta todo configurado y funciona al chilazo.

gmake y gmake install

con esto hecho ya casi estamos listos para que nuestra aplicación se conecte con SQL Server.

Configurando unixODBC y freeTDS

configuramos odbc con el archivo /etc/odbc.ini y agregamos lo siguiente:

[MSSQLJDBC]
Description        = FreeTDS MSSQL Server
Driver        = FreeTDS MSSQL Server
Servername        = MSJDBC
Database        = Universidad
UID        = <usuario de la bd>
PWD        = <clave del usuario>
Port        = <puerto por lo general 1433>
Trace        = Yes

en /etc/odbcinst.ini agregamos lo siguiente:

[FreeTDS MSSQL Server]
Description    = TDS MSSQL JDBC Server
Driver          = /usr/lib/libtdsodbc_mssql.so.0
Setup           = /usr/lib/libtdsS.so.1
FileUsage    = 1

[ODBC]
Trace     = yes
TraceFile = /tmp/odbc.log

en /etc/freetds_mssql.conf agregamos lo siguiente:

[MSJDBC]
host = <host del servidor SQL Server, en el mio 192.168.2.2>
port = <puesto, en el mio 1433>
tds version = 8.0
client charset = UTF-8

si ejecutamos /usr/bin/ODBCConfig-root podremos configurar el ODBC facilito.

Con esto hecho ya podemos usar nuestra aplicacion Qt4 con SQL Server

QSqlDatabase defaultDB = &QSqlDatabase::addDatabase ( “QODBC” );
if ( ! defaultDB )
{
QMessageBox::critical ( this, “error” , “No se pudo conectar con el driver”);
return;
}

defaultDB->setDatabaseName ( “MSSQLJDBC” );  //el que configuramos en odbc.ini
defaultDB->setUserName ( “usuario” );
defaultDB->setPassword ( “clave” );

algo muy importante es que el todos los querys tienen que estar en modo Fordward only, ya con eso podemos hacer consultas y todo eso:

QSqlQuery *query = new QSqlQuery( defaultDB );
query->setForwardOnly ( true );
query->exec( “select nombre_alumno from Alumno” );
query->first();
label->setText(“Nombre: ” + query->value(0).toString() );

ahora si nos devolverá los valores que queremos, no como antes que nos salia “qGetStringData: Error while fetching data (-1)”

Para obtener los parámetros de salida de un procedimiento almacenado podemos hacerlo asi:

QString ejecutar=”DECLARE @nombre nvarchar(80)”;
ejecutar+=”; DECLARE @apellido nvarchar(80)”;
ejecutar+=”; execute buscarlumno 200308064, @nombre OUTPUT, @apellido OUTPUT”;
ejecutar+=”; select @nombre, @apellido”;
query->exec( eje );
query->first();
label->setText(“Nombre: ” + query->value(0).toString() + ” Apellido: ” + query->value(1).toString() );

el procedimiento que llamamos arriba es el siguiente en la base de datos:

CREATE PROCEDURE buscarlumno ( @car bigint, @nombre nvarchar(80) output, @apell nvarchar(80) output )
AS
BEGIN
select @nombre=nombre_alumno,@apell=apellido_alumno from Alumno where carnet=@car
END;

Es la única manera que he podido obtener los parámetros de salida en Qt, si alguien sabe una mejor manera que nos lo comparta, jejeje.

Espero que les sirva. =0)

Algo muy importante es que nuestras aplicaciones estén preparadas para la traducción a otros idiomas, un ejemplo muy bueno son las lenguas indígenas de Guatemala, para no ir tan lejos, tal vez se necesite que nuestra aplicación la pueda usar una persona que no sabe español, alemanes, ingleses, etc. etc. jejeje.

Para poder traducir fácilmente nuestra aplicación lo primero que hacemos es usar el objeto QTranslator, este tiene que ir en el main.cpp, ejemplo

Q_INIT_RESOURCE(application);
QTranslator translator;
QApplication app(argc, argv);
translator.load(“qt4_internacional_en”);
app.installTranslator(&translator);

El translator.load lo que hace es abrir el archivo de traducción que queramos usar, en este ejemplo es qt4_internacional_en (en este ejemplo el archivo tiene que estar en la misma carpeta que el ejecutable), como se puede ver vamos a traducir nuestra aplicación al ingles, este archivo tiene la extención “qm” -> “qt4_internacional_en.qm”, estos archivos qm se generan a traves de un archivo “ts”, asi que vamos a ver el proceso para crear el archivo “ts”, traducir el texto del “ts” y generar el archivo “qm”.

Primero tenemos que preparar nuestro código fuente para crear el archivo “ts” ya que la aplicación que crea este archivo lo que hace es sacar del código fuente de nuestro programa lo que se va a traducir.

Nota: Antes de empezar quiero hacer una observación, a la hora de crear los archivos cpp y h para un formulario creado con el diseñador de qt, KDevelop lo deja asi:

i_ventana::i_ventana(QWidget* parent, Qt::WFlags fl)
: QDialog( parent, fl ), Ui::Dialog()

QDevelop lo deja asi:

i_ventana::i_ventana( QWidget * parent, Qt::WFlags f)
: QDialog(parent, f)

Lo generado por KDevelop tiene algo de mas comparado con el de QDevelop, el Ui::Dialog(), si creamos el archivo “ts” con eso a la hora de traducir veremos algo asi:

Se puede ver que el grupo por así decirlo es Ui, si lo hacemos así no funcionará ni a patadas, lo mejor es quitarle esa parte, no le pasa nada al programa, si trabajamos con QDevelop pues no tenemos que hacer nada.

Codificar

Antes de crear el archivo “ts” tenemos que indicar en el código fuente de nuestro programa que es lo que se va a traducir, eso lo hacemos con la función ‘tr’ ejemplo:

Label->setText( tr(“Texto a traducir”) );

Es como el i18n que se usa con KLocale de KDE. Algo muy importante es que no debemos hacer lo siguiente:

tr( ” Los ” + variable_puntos + ” puntos del examen, ” + variable_nombre + ” fue el que los obtuvo” )

No podemos concatenar cadenas de esa manera ya que el orden de las palabras no son el mismo en otros idiomas, la traducción de esa frase en ingles es la siguiente ( lo traducí con google ):

the 5 points of the review, which was Pedro won

Si concatenamos las cadenas así la traducción podría quedar algo así:

the 5 points of the review,Pedro which was won

Tal vez no sea muy bueno el ejemplo pero se puede ver que las palabras cambiaron de lugar y eso no es bueno, la manera correcta de hacerlo es la siguiente:

tr(“Los %1 puntos del examen, %2 fue el que los obtuvo”,”Este es un comentario”).arg(“5″).arg(“pedro”)

En el texto se usa %1 y %2 (se puede usar los que se quiera, %3, %4, etc), estos serán reemplazados por lo que contenga los argumentos, arg(“5″) y arg(“Pedro”), el %1 será reemplazado por 5 y %2 por Pedro, el segundo parámetro es un comentario, este comentario es para ayudar al traductor a saber de que se trata el mensaje, puede ser necesario utilizarlo o no, tal vez se necesite traducir solo la palabra “save”, puede que sea salvar, o guardar un archivo, etc. en estos casos es bueno usar el comentario, este comentario lo podrá ver el traductor cuando este utilizando Qt Linguist pero no será visible para el usuario del programa.

Crear el archivo ‘ts’ y traducir

Cuando ya tenemos preparado nuestro código fuente, utilizamos la consola y nos vamos a la carpeta que contenga los archivos cpp de nuestro programa y ejecutamos:

lupdate *.cpp -ts qt4_internacional_en.ts

este comando extrae las cadenas que se tengan que traducir y los guarda en el archivo “qt4_internacional_en.ts”, ahora abrimos ese archivo con Qt Linguist, especificamos el idioma al que traduciremos en el menú de “edit” y en “Translation File Settings”, en este caso le puse que lo voy a traducir al ingles de Estados Unidos.

Como se puede ver ahora ya el grupo no es Ui, como se muestraba en la imagen anterior, ahora si funcionará la traducción, se puede ver el comentario que aparece para que el traductor sepa de que se trata, el traductor traduce el texto y mueve el %1 y %2 a las posiciones que le corresponden en el nuevo idioma, cuando esta lista esa traducción hacemos click en “Done and Next” para pasar a la siguiente frase a traducir.

Generando el archivo ‘qm’

Cuando terminamos de traducir guardamos el archivo y vamos al menú “File” y hacemos click en “Release”, esto nos generará el archivo ‘qm’, ahora solo es de copiar este archivo a la carpeta donde esta el ejecutable para que funcione, claro esta que a la hora de especificar el archivo ‘qm’ a usar por el programa le podemos decir la dirección donde esta para no tener que copiarlo a la misma carpeta donde esta el ejecutable, imagínense el /usr/bin lleno de archivos ‘qm’, jejeje,

Así quedaría la aplicación con la traducción al ingles, este también funciona para Windows, les dejo el código fuente para que lo trateen: qt4_internacional.tar.gz

Para que el usuario tenga una buena experiencia con una aplicación es necesario que esta este integrada al escritorio que esta utilizando, por lo menos así lo veo yo, las aplicaciones desarrolladas con Qt4 se integran muy bien con Windows, pero con Linux no es tan bueno, ¿por que?, un ejemplo son los diálogos para abrir y guardar archivos, de eso se trata este tema, miremos los diálogos en Windows:

Dialogo nativo de Windows:

Al usar este diálogo nuestros usuarios no sentirán nada extraño al usar la aplicación, este diálogo es el que se abre por defecto cuando utilizamos QFileDialog.

Dialogo no nativo de Windows (Diálogo de Qt):

Este diálogo es el original de Qt, la verdad no hay mucho problema con este tipo de diálogo en Windows pero en Linux si tenemos una pequeña desventaja, en Linux solo vamos a tener el diálogo de Qt pero no tenemos uno nativo como en Windows:

La desventaja es que este dialogo no puede manejar los dispositivos extraibles como memorias USB, CDs, DVDs, etc. etc. ( bueno, eso es lo que yo me he podido dar cuenta ), si queremos abrir o guardar un archivo en una memoria USB primero tenemos que montar esa memoria, ya sea por la consola, utilizando los servicios de KDE, etc. y después ir en el diálogo Qt al lugar donde la montamos, ejemplo /media/memoriaUSB, en Windows no sucede eso, si abrimos un diálogo y luego metemos nuestra memoria automáticamente se crea una nueva unidad, digamos la unidad E: , y ya abrimos o guardamos archivos, sencillo, entonces en Linux no hay diálogos nativos como en Windows, la verdad no es nada extraño ya que en Linux no solo hay un escritorio como en Windows, entonces no se puede tomar los diálogos de GNOME, de KDE u otros como nativos, en unas distribuciones van a estar disponibles algunos diálogos, en otros otros y en otras distribuciones están disponibles todos, ejemplo, es cierto que no importa nuestra distribución, vamos a poder instalar lo que nos haga falta, pero a lo que voy es que no puede existir un diálogo nativo para Linux, a menos que KDE, GNOME y los demás se pongan de acuerdo para usar un solo tipo de diálogo para abrir y guardar archivos.

En este pequeño ejemplo se muestra como integrar nuestra aplicación a KDE 4 y utilizar su diálogos para abrir y guardar archivos si estamos en Linux, si estamos en Windows entonces usamos los nativos de Windows, esto para que siga siendo multiplataforma:

Al usar los diálogos de KDE tenemos la ventaja de trabajar los dispositivos extraibles de una manera muy fácil, montamos, desmontamos, etc. así que el usuario de nuestro programa no tiene que montar en otro lado su memoria y luego regresar al diálogo para trabajar con ella.

Código

Para poder hacer que nuestra aplicación se pueda compilar en Linux y en Windows vamos a utilizar el preprocesador de C++

#ifdef Q_WS_X11
#include <KFileDialog>
#else
#include <QFileDialog>
#endif

#ifdef Q_WS_X11 nos sirve para saber si estamos en Linux, si ese es el caso es incluyen la cabecera del diálogo de KDE para nuestra aplicación, si no se incluye la normales de Qt

#ifdef Q_WS_X11

direccion=KFileDialog::getOpenFileName(KUrl::fromPath(dir),filter,parent,caption);
#else

direccion=QFileDialog::getOpenFileName ( parent,caption,dir,filter);
#endif

En otra parte del código utilizamos otra vez el preprocesador para saber que linea se va a compilar, si estamos en Linux se usa el KFileDialog, si estamos en Windows se usa QFileDialog.

No podemos hacer esto:

#ifdef Q_WS_X11
#define Linux TRUE
#else
#define Linux FALSE

if ( Linux )
direccion=KFileDialog::getOpenFileName(KUrl::fromPath(dir),filter,parent,caption);
else
direccion=QFileDialog::getOpenFileName ( parent,caption,dir,filter);

Podemos usar eso para otra cosa pero no para este caso ya que si compilamos eso en Windows nos va a dar error ya que no va a encontrar KFileDialog, en Linux si compilaría, entonces tenemos que usar el preprocesador dentro de nuestro código, esto para que a la hora de compilar en windows solo entre a las partes que si puede compilar WIndows y viceversa.

No se puede explicar todo el código aquí así que les dejo el ejemplo qt4_dialogos.tar.gz

Este esta desarrollado en KDevelop, yo tengo KDE 3 y KDE 4 asi que lo necesario para compilar cosas de KDE 4 lo tengo en /opt/kde4/include, /opt/kde4/lib, si lo tienen en otra parte solo hay que cambiarlo en “Opciones del subproyecto”, en las pestañas “Cabeceras” y “Bibliotecas”.

Para compilarlo en Windows solo hay cambiar el archivo /src/src.pro, antes de pasarlo a Windows hay que cambiarle el fin de linea para que podamos editarlo bien en Windows, digamos en KWrite en el menú Herramientas -> Fin de línea -> Windows/DOS y lo guardamos, ya con eso lo podemos editar sin problema en Windows, ahora le quitamos lo siguiente a /src/src.pro:

INCLUDEPATH += /opt/kde4/include/KDE \
/usr/lib/qt4/include \
/usr/lib/qt4/include/QtGui \
/usr/lib/qt4/include/QtCore \
/usr/lib/qt4/include/Qt \
/usr/lib/qt4/mkspecs/linux-g++ \
/opt/kde4/include/

LIBS += -L/opt/kde4/lib/kde4 \
-L/usr/lib/qt4/lib \
-L/opt/kde4/lib \
-lkutils \
-lkio \
-lkfile \
-lkdecore \
-lkdeui

Eso que le quitamos son las cabeceras y bibliotecas que se necesitan para compilar lo de KDE 4, si no se lo quitamos no compilará en Windows, eso es lo único que tenemos que cambiar así que no es la gran cosa.

La aplicación se mira asi:

Una aplicación multiplataforma que se integra al escritorio según el sistema operativo, aquí lo único que le faltaría al preprocesador de C++ es verificar si esta disponible las librerías de KDE 4, si no lo estuviera que usara los diálogos de Qt.

La bandeja del sistema es útil para tener una aplicación ejecutándose en segundo plano por así decirlo, es útil para una aplicación que se encarga de verificar nuestro correo electrónico, se queda minimizado en la bandeja del sistema y cuando recibimos un correo nos notificará de este correo, como por ejemplo KMail, o también muy útil para aplicaciones que no queremos que nos estén estorbando en la barra de tareas, como por ejemplo Amarok.

Esta aplicación que se desarrollo utilizando Qt4 puede compilarse para GNU/Linux como para Windows y el resultado es este:

Código principal

#include <QSystemTrayIcon>

.

QSystemTrayIcon *systemtray;

.

Aquí construimos nuestro nuevo objeto, el primer parámetro es el icono que queremos ponerle, si estamos en Linux lo recomendable es uno de 22×22, si es para Windows el de 16×16. el preprocesador de C++ nos puede servir para identificar si se esta compilando para Linux o para Windows, en el código completo que se entrega se puede ver eso, en este caso es para Linux. El segundo parámentro es el “widget papa” asi como le llamo yo.

QSystemTrayIcon *systemtraysystemtray = new QSystemTrayIcon(QPixmap(QDir::toNativeSeparators(QApplication::applicationDirPath()+”/emacs.png” )), this);

Aquí creamos una nueva acción, esta acción la utilizaremos para incluirla en el menú, este menú es el que sale cuando hacemos click derecho en el icono. El primer parámetro es el icono que queremos ponerle, el segundo el texto que se va a mostrar y el tercero el “widget papa”.

newAct = new QAction(QIcon(QDir::toNativeSeparators(QApplication::applicationDirPath()+”/filenew.png”)), tr(“Mostrar texto”), this);

Para establecer el ayuda rapidita que se muestra al poner el puntero del ratón encima del icono lo hacemos asi:

systemtray->setToolTip ( “tooltip del icono” );

Para crear el menú y asignarle la acción recién creada lo hacemos así:

QMenu *sysmenu; = new QMenu(this);
sysmenu->addAction(newAct);

y por último agregamos el menú a nuestro icono y lo mostramos

systemtray->setContextMenu(sysmenu);
systemtray->show();

Se puede hacer que despliegue mensajes, podemos controlar si se hace click en ese globo de mensajes, se puede controlar cuando se hace click izquierdo, derecho, central y doble click, solamente es de ver la documentación de Qt4, en este caso se pueden descargar qt4_systemtray.tar.gz como ejemplo para que puedan trastearlo, trasteando código se aprende mas rápido.

SQLite es una pequeña librería multiplataforma escrita en C que contiene un sistema gestor de bases de datos. SQLite no trabaja como las usuales Bases de Datos, con infraestructura cliente/servidor, en cambio SQLite se integra directamente en la aplicación utilizando un archivo para guardar la información.

SQLite puede utilizarse para guardar datos que no requieran gran cantidad de datos como configuraciones, logs, historiales, etc. Actualmente SQLite 3 soporta hasta 2 Terabytes, pero hay que tener en cuenta que SQLite consume al rededor de 256 bytes de memoria por cada 1 MiB de la base de datos.

Qt4 provee integración directa con SQLite, la conexión es bastante sencilla, tanto que es difícil encontrar información sobre el tema .

Activando SQLite

Lo primero es crear un proyecto de QT4 ya sea usando KDevelop, QDevelop o generándolo uno mismo.

Dentro de KDevelop tenemos que ir a Opciones del Sub Proyecto -> Configuración

En QDevelop debemos ir al menú Proyecto -> propiedades del proyecto y buscar la opción Bibliotecas Qt

En ambos debemos seleccionar las librerías SQL.

Si es un proyecto echo sin una IDE se puede añadir al archivo .pro la variable

QT += sql

Conexión a SQLite

La conexión es de las mas sencillas, no se colocara host ni contraseña, solamente el nombre del archivo que se utilizará para guardar los datos:

#include <QSqlDatabase>

…

QSqlDatabase baseDatos = QSqlDatabase::addDatabase(“QSQLITE”);

baseDatos.setDatabaseName(“bd.db”);

Si Qt no encuentra el archivo creará uno.

De ahora en adelanta ya podemos utilizar SQLite como si fuese cualquier base de datos, teniendo en cuenta las sentencias que soporta.

Creando la estructura de la Base de Datos

Para crear la estructura de la Base de Datos podemos utilizar una interface como SQLite Data Base Browser o phSQliteAdmin, o bien hacerlo mediante su interfáz de consola:

Creamos una tabla dentro de la base de datos con sus respectivos campos

$ sqlite3 bd.db
SQLite version 3.5.6
Enter “.help” for instructions
sqlite> CREATE TABLE usuarios (
…> id INTEGER PRIMARY KEY,
…> usuario TEXT,
…> clave TEXT);

Podemos verificar lo creado con la instrucción .schema

sqlite> .schema usuarios
CREATE TABLE usuarios (
id INTEGER PRIMARY KEY,
usuario TEXT,
clave TEXT);

También podemos ingresar un dato de prueba para nuestro programa y verificar que se ha insertado correctamente.

sqlite> INSERT INTO usuarios (usuario, clave) VALUES (‘administrador’, ‘administrador’);
sqlite> SELECT * FROM usuarios;
1|administrador|administrador

Para salir utilizamos la instrucción .exit

sqlite> .exit

Ejemplo de utilizacion

Para ejemplo pueden descargar el archivo ejemplo.tar.gz el cual trae un ejemplo minimo de como acceder y leer los datos de una base de datos SQLite con QT4 configurado tanto para compilarse en Linux como en Windows

Enlaces:
SQLite -> SQLite Home Page
Documentacion de SQLite -> http://www.sqlite.org/docs.html
QT4 -> http://trolltech.com/products/qt/

Así se inicia el primer post de este blog, con el tradicional Hola Mundo.

Por estos lados me conocerán con el nick de dhabyx, en este espacio me dedicaré a compartir los conocimientos de desarrollo de software utilizando herramientas libres que utilizamos el grupo de amigos que conformamos este blog.

Mas adelante cada miembro de este lugar se presentará, a su debido tiempo

En lo personal me enfocaré mas a el mundo de PHP, y a otras cosillas de interés.

Saludos y Bienvenidos!!

Ahora toca el turno de generar el archivo XML, anteriormente habíamos visto como leer un archivo en formato XML, en el cual habíamos utilizado las librerías proporcionadas por Free Pascal, ahora usaremos otras que son nativas para Lazarus, y aprenderemos como añadir paquetes

Primero creemos la Interfaz, colocando los siguientes componentes:

Ahora necesitamos ingresar el código, pero antes llamamos a las librerías que necesitamos para que podamos escribir en XML, que en este caso serán las librerías para lazarus: Laz_DOM y Laz_XMLWrite, para ello debemos añadir un paquete a los requeridos del proyecto, esto lo logramos pulsando el menú Proyecto -> Inspector de Proyecto, con esto nos mostrará una ventana con todos los archivos y paquetes con que se compila nuestra aplicación, pulsamos sobre el botón añadir y luego a la pestaña Nuevo Requerimiento:

Y seleccionamos CodeTools, que es el paquete que contiene las cabeceras que necesitamos (laz_dom.pas y laz_xmlwrite.pas), esto lo pueden verificar si van a la carpeta components/codetools en donde este instalado lazarus.

Luego de esto, debemos verificar que en la ventana del inspector del proyecto aparezca CodeTools, en la lista de paquetes requeridos:

Ahora debemos agregar Laz_DOM y Laz_XMLWrite a la clausula Uses e ingresamos el código para el evento OnClick del BtnCrear:

procedure TForm1.BtnCrearClick(Sender: TObject);
var
  Doc : TXMLDocument;
  DomNodo, DomRaiz, DomDato : TDOMNode;
begin
  //Creamos un documento
  Doc:=TXMLDocument.Create;
  //Creamos la raiz del documento
  //nombrandolo "ejemplo"
  DomRaiz:=Doc.CreateElement('ejemplo');
  //despues de añadir un nodo al documento este es vaciado
  Doc.AppendChild(DomRaiz);
  //por lo tanto recuperamos el puntero
  DomRaiz:=Doc.DocumentElement;
  //Creamos el primer Nodo del documento
  DomNodo:=Doc.CreateElement('PrimerDato');
  //Hacemos un casting a la variable DomNodo
  //de tipo TDOMElement para poder
  //colocarle atributos.
  TDOMElement(DomNodo)['atributo']:='algunvalor';
  //agregamos el nodo al nodo raiz
  DomRaiz.AppendChild(DomNodo);
  //Como la variable DomNodo ha sido vaciada
  //podemos crear otro nodo con la misma
  //variable
  DomNodo:=Doc.CreateElement('segundoDato');
  //creamos tambien un nodo de texto
  DomDato:=Doc.CreateTextNode('contenido');
  //asignacion de parametro al nodo
  TDOMElement(DomNodo)['tipo']:='cadena';
  //Añadimos el nodo de texto al nodo DOMNodo
  DomNodo.AppendChild(DomDato);
  //Al primer nodo hijo (PrimerDato) de la raiz
  //le añadimos el nodo contenido en DomNodo
  DomRaiz.ChildNodes.Item[0].AppendChild(DomNodo);
  //creamos otro nodo pero de comentario
  //con el texto del TEdit
  DomDato:=Doc.CreateComment(EdComentario.Text);
  //añadimos directamente el nodo de comentario
  //al mismo nivel que "PrimerDato"
  DomRaiz.AppendChild(DomDato);
  //Escribimos el archivo
  WriteXMLFile(Doc,'prueba.xml');
  //Liberamos Memoria.
  Doc.Free;
end;

Compilamos, y estamos listos.

Esto nos creará un archivo prueba.xml como este:

<?xml version="1.0"?>
<ejemplo>
  <PrimerDato atributo="algunvalor">
    <segundoDato tipo="cadena">contenido</segundoDato>
  </PrimerDato>
  <!--Escriba su comentario-->
</ejemplo>

Ahora puede probar abrirlo con el proyecto que hicimos anteriormente

Después de hacer una búsqueda intensiva, he encontrado algunos fallos con lecturas de archivos xml, especialmente cuando contienen caracteres como “ñ” o vocales tildadas.

Simplemente es cuestión de crear un archivo que le indique a las librerías gtk en que codificación deben leer los archivos.

Deben crear o modificar un archivo en su home, llamado .gtkrc.mine si usan gtk y .gtkrc-2.0 si usan gtk2 para Lazarus.

style “default-text” {
fontset = “-*-arial-medium-r-normal–*-100-*-*-*-*-iso8859-1,\
-*-helvetica-medium-r-normal–*-100-*-*-*-*-*-*”
}

class “GtkWidget” style “default-text”

Luego puede compilar de nuevo su código y verán los resultados.

XML es un formato de archivo bastante entendible para guardar documentos estructurados o pasar información de programa a programa, por lo que se hace necesario conocerlo, Free Pascal tiene librerías necesarias para poder leer y escribir en este formato, fáciles de aprender e igualmente de aplicar, en este primer post solo veremos como acceder y leer los archivos XML obteniendo los datos fácilmente.

Abrimos Lazarus y creamos un nuevo proyecto. Luego en el formulario colocamos estos componentes y les colocamos las propiedades siguientes:

Componente	Nombre(Name)	Caption
TForm	FLMXL	Lector XML
TButton	BtnLeer	&Leer XML
TButton	BtnCerrar	&Cerrar
TMemo	Memo

Colocando los componetes tomando como ejemplo la siguiente imágen:

Y guardamos el proyecto.

Para acceder a las funciones de manejo de XML en Lazarus o Free Pascal solamente debemos llamar a las librerías DOM y XMLRead, añadiéndolas a la lista de librerías en la clausula uses.

Ahora necesitamos un archivo XML para las pruebas, dentro del cual escribiremos lo siguiente:

<?xml version="1.0"?>
<ejemplo>
  <ejemploinfo>
    <autor>develazarus</autor>
    <fecha>1 de Julio de 2007</fecha>
    <dato>primer dato</dato>
    <dato>Segundo dato</dato>
    <dato>Tercer dato</dato>
    <dato>Cuarto dato</dato>
    <val tipo="dato cadena">inspeccionando</val>
  </ejemploinfo>
  <texto>
    <cabecera>Esto es la cabecera</cabecera>
    <linea>Esto es una linea de texto.</linea>
  </texto>
</ejemplo>

lo guardamos con el nombre “ejemplo.xml” dentro de la carpeta donde guardamos el proyecto, para que sea fácilmente accesible desde el código.

El código XML es tratado por las librerías como un conjunto de nodos, por lo que podríamos ejemplificar el archivo anterior de la siguiente manera:

En XML todo empieza con el nodo raiz, que en el caso de nuestro archivo es “ejemplo”, luego estan los nodos hijos de la raiz, que son ejemploinfo y texto, y estos a su vez son nodos padre de cada uno de los nodos que están abajo.

Cada nodo puede tener datos o atributos, los datos o valores de los nodos que vemos en el archivo ejemplo.xml, como por ejemplo el de autor (develazarus), es otro nodo, un nodo hijo del nodo autor, si obtuviésemos el valor del nodo autor no nos devolvería nada. Los datos y atributos de cada nodo son tratados como nodos hijos, esto es algo que hay que tener en cuenta.

Pero empecemos para ver como funciona ya en Lazarus:

En el evento onClick de BtnLeer colocamos:

procedure TFLXML.BtnLeerClick(Sender: TObject);
var
  //variable de tipo TXMLDocument para cargar documentos XML
  Doc :  TXMLDocument;
  i, j : integer;
begin
  Doc := TXMLDocument.Create;
  //cargando el archivo XML
  ReadXMLFile(Doc, 'ejemplo.xml');
  Memo.Lines.Clear;
  //obteniendo el nombre del nodo raiz
  Memo.Lines.Add('Archvo tipo : '+Doc.DocumentElement.NodeName);
  //trabajando con los nodos inferiores a la raiz
  with Doc.DocumentElement.ChildNodes do
  begin
    {la variable "Count", propiedad de ChildNodes
     contiene el numero total de nodos hijos que existen
     en este caso en el nodo raiz}
    for i := 0 to (Count - 1) do
    begin
      {Item[i] es el nodo al que vamos a acceder y su propiedad
       NodeName nos devuelve el nombre del nodo}
      Memo.Lines.Add(intToStr(i)+'. '+Item[i].NodeName);
      {ahora usamos la propiedad Count pero ahora de los nodos
       con los que estamos trabajando}
      for j := 0 to (Item[i].ChildNodes.Count - 1) do
      begin
        {ahora entraremos a los nodos hijos de los nodos
         anteriores}
        with Item[i].ChildNodes do
        begin
          {Item[j].FirstChild nos devuelve el primer nodo hijo y
           NodeValue es la propiedad que nos devolvera el valor
           o contenido de ese nodo}
          Memo.Lines.Add(IntToStr(i)+'.'+IntToStr(j)+' '
            + Item[j].NodeName + ' -> '
            + Item[j].FirstChild.NodeValue);
          if Item[j].NodeName = 'val' then
            Memo.Lines.Add('  Atrbuto "tipo" del nodo val = '
            + Item[j].Attributes.GetNamedItem('tipo').NodeValue);
              {Para obtener los atributos de un nodo
               utilizamos la propiedad Attributes}
        end;
      end;
    end;
  end;
  Doc.Free;
  //es necesario liberar la memoria que ocupo la variable Doc
end;

y en evento onClick de BtnCerrar colocamos:

procedure TFLXML.BtnCerrarClick(Sender: TObject);
begin
  Close;
end;

Solo nos resta compilar y ejecutar la aplicación, esto lo podemos hacer fácilmente con la tecla F9

Luego de esto ya tendremos nuestra aplicación leyendo los datos del archivo XML.

Basado en iformación de:
Homepage Von Thomas Zastrow -> FPC y XML (inglés)
XML Tutorial -> Tutorial explicativo de XML (inglés)
Document Object Model -> Especificación del modelo DOM (inglés)
Lazarus wiki -> Tutorial de Lazarus con XML (inglés)