20
May
10

Flex+Bison+Qt4 2

Bueno, hoy quiero extender un poco lo que es el uso de flex y bison en Qt4, gracias a la petición de un lector. En esta ocasión lo que se quiere es poder conocer el valor semántico de un identificador, ejemplo:

int variableEntera;

Con código anterior ademas de saber que es una variable, queremos saber cual es su nombre, en este caso “variableEntera”.

Así como el primer artículo, he investigado bastante para encontrar la mejor manera de hacer eso, pero no hay mucha info, así que lo que les propongo me lo invente según lo que pude observar a la hora de estar trabajando con estas herramientas.

Proyecto de de ejemplo: QtFlexBison2.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 QtFlexBison.pro con Qt Creator y lo compilamos.

Explicación:

El programa consiste en poder reconocer un grupo de variables en un grupo especifico, no tiene nada que ver con algún lenguaje, solo me lo invente para ejemplificar el caso.

La estructura del texto es el siguiente:

principal

{

grupo:nombre

{

var:uno

var:dos

}

grupo:otro_grupo

{

var:tres

var:cuatro

var:cinco

var:seis

}

}

Tenemos 2 grupos, cada uno con sus variables. El programa es capaz de recorrer el texto, saber cuales son los grupos y que variables tienen. Las salida del programa es el siguiente:

grupo: nombre

variable: ‘uno’

variable: ‘dos’

grupo: otro_grupo

variable: ‘tres’

variable: ‘cuatro’

variable: ‘cinco’

variable: ‘seis’

Con esto podemos saber el nombre del grupo y que variables tiene con su respectivo nombre.

Las reglas semánticas se encuentran en el archivo parser.y, en ella se encuentra la manera de poder obtener el nombre del identificador. Algo que quiero resaltar es la manera que se van cumpliendo las reglas, si no se entiende eso no podemos ir obteniendo los valores. En este ejemplo el orden en que se cumplen las reglas es el siguiente:

(Las reglas tienen qDebug() para que se vea el orden en que se cumplieron las reglas)

identificador:  “nombre”     //se encontro el nombre del grupo uno
identificador:  “uno”           //se encontro el nombre de la primera variable
variable: identificador         //se cumplio la regla de variable
identificador:  “dos”           //se encontro el nombre de la segunda variable
variable: identificador         //se cumplio la regla de variable para la segunda
variables: variable               //se cumplio la regla de variables en conjunto
variable variable
grupo                         //se cumple la regla de grupo ( hasta ahora se cumplió esta regla y su nombre fue lo primero que se obtuvo arriba )
identificador:  “otro_grupo”  //se encontro el nombre del grupo dos
identificador:  “tres”
variable: identificador
identificador:  “cuatro”     //se encontro el nombre de la cuarta variable
variable: identificador       //se cumplio la regla de variable para la cuarta
identificador:  “cinco”
variable: identificador
identificador:  “seis”
variable: identificador
variables: variable
variable variable
variable variable
variable variable
grupo                 //se cumple la regla de grupo 2 ( hasta ahora se cumplió esta regla y su nombre fue lo primero que se obtuvo después de terminar el primer grupo )
grupos: grupo
grupo grupo
regla principal      //se cumple la regla principal, se cumple hasta que todo lo demás se haya cumplido

Si se dan cuenta primero encontramos el nombre del grupo o variable y hasta después se cumple la regla que le pertenece, eso hace que tengamos que guardar el nombre en algún lado hasta que se cumpla la regla. Para ese fin use un pila, en la que se ingresan los identificadores y cuando se vayan cumpliendo reglas se van sacando. ejemplo:

Imaginemos

grupo: uno{

var: variable_uno

var: variable_dos

}

La pila se llena asi:

se encuentra el nombre del grupo: uno                                  pila:    uno

se encuentra el nombre del la var1:  variable_uno                           uno

pila:    variable_uno

se cumple la regla de variable: se saca de la pila                   pila:    uno

se encuentra el nombre del la var2:  variable_dos                  uno

pila:    variable_dos

se cumple la regla de variable 2: se saca de la pila          pila:    uno

se cumple la regla de grupo: se saca de la pila            pila:

Como se puede ver se tiene que estar guardando el nombre de los elementos que queremos hasta que se cumpla con la regla que le corresponde.

Es la manera que encontrado para hacer esto, si alguien tiene una mejor manera de hacerlo que nos haga el favor de compartirlo para que aprendamos todos.

Espero que les sirva. =)

12
Jun
09

Flex+Bison+Qt4

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. =)

03
Sep
08

GNU/Linux + Qt4 + MS SQL Server

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)

05
Jul
08

Internacionalización de aplicaciones Qt

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

03
Jul
08

Aplicaciones Qt4 multiplataforma que se integran al escritorio (KDE,Windows)

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.

26
Jun
08

Bandeja del sistema con Qt4

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.

10
Jun
08

QT4 y SQLite

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

QT4 y SQLite

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

QDevelop y SQLite

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/




CGSOL 2008

Publicidad CGSOL 2008