Programacion Con QT PDF

Tutorial de desarrollo utilizando la librería QT 3.
Hola, mi nombre es Martin Hernan Algañaraz, y debido a la falta de documentación referente a esta librería,
me decidí a escribir un pequeño tutorial, que espero les sea de utilidad.
Requisitos:
Obviamente la librería.
Serán necesarios conocimientos (al menos básicos de la STL), y programación orientada a
objetos.
Requisito indispensable, GANAS DE APRENDER.
Antes que nada, me gustaría aclarar, que si lo que están buscando es aprender a utilizar el QtDesigner, o el
KDevelop, dejenme decirles que se equivocaron de tuto, este tutorial, no va más alla de lo que dice el titulo,
DESARROLLO UTILIZANDO LA LIBRERIA QT 3.2. Por ese motivo, lo único que explicare es como utilizar la
librería en si, (los widgets, las señales, la herencia, los tipos etc...) algo, que considero necesario saber antes
de lanzarse sobre los poderosos IDES. Si lo que pretenden es aprender a programar en KDevelop o utilizar el
QTdesigner, les recomiendo leer el tutorial de Martin Sande, que para algo se quemo los dedos tecleando :).
Otra cosa, yo trato de explicar el uso "a mano" de esta librería, si bien en mi caso utilizo como editor el emacs
y una consola para compilar, no quiero decir que este demás utilizar los IDEs, puesto que para algo están, yo
personalmente prefiero hacerlo a mano, pero es solamente una cuestión de gustos (no me juzguen, soy
amante del Slackware).
Primero que nada, dare un ejemplo pequeño, sencillo y sin ninguna utilidad práctica, pero que para comenzar
estará bien:
Ej:
#include <qapplication.h>
#include <qpushbutton.h>
#include <qfont.h>
class CFormulario : public QWidget

{
public:
CFormulario(QWidget *parent = 0, const char *name = 0);
};
CFormulario::CFormulario(QWidget *parent, const char *name) : QWidget( parent , name )

{
QPushButton *boton = new QPushButton ("boton", this , "Terminar aplicacion");
connect (boton, SIGNAL(clicked() ), qApp , SLOT (quit() ) );
boton->setFont(QFont("times", 18, QFont::Bold) );
}
int main (int argc, char **argv)

{
QApplication Main ( argc , argv );
CFormulario *Form = new CFormulario();
Form->setCaption("Mi Primer Programa");
Form->show();
Main.setMainWidget( Form );
return Main.exec();
}
Mmmm. Seguramente después de esto, los Gurus de las QT me querrán asesinar, pero bueno, (son riesgos).
Primero que nada, quiero aclarar que el ejemplo dado, no es del todo básico, y pudo haber sido, mucho más
sencillo, pero debido a que la librería QT, esta íntimamente diseñada, para utilizarse con lenguajes orientados
a objetos, me pareció una buena manera de comenzar.
Bien, ahora el paso que más duele, la Explicación.
Lo primero que hago, es declarar tres ficheros de cabecera, que serán utilizados por la librería (notar que no
hace falta incluir el fichero iostream).
El fichero llamado qapplication.h, es la base de la librería, y con el cual la inicializamos, este fichero es
SIEMPRE NECESARIO.
El fichero llamado qpushbutton.h, es necesario, para la creación y utilización del widget boton.
El fichero llamado qfont.h, no fue necesario incluirlo en este ejemplo pero tampoco complica tanto las cosas,
este fichero, es el encargado de manejar las fuentes de los widgets que tengamos en la aplicación.
Bien, primero que nada me gustaría aclarar que en la librería QT, NO EXISTE el Formulario en si, (no hay
nada llamado QForm, o algo por el estilo), porque sencillamente somos nosotros los que tenemos que crear
los widgets, esto lo haremos todo el tiempo, especificando las propiedades y eventos que queremos que
nuestro widget reciba, y como los procese (gasearía: pulsación de un botón, cambio de tamaño del widget,
etc,etc..).
Como se ve en ejemplo anterior creamos una clase llamada CFormulario, que deriva directamente de otra
llamada QWidget, (la cual es la base de todos los widgets), y creamos un constructor con dos argumentos,
por defecto los cuales son QWidget *parent y const char *name. El primero es un puntero al widget que llamó
al objeto, (en este caso ninguno, por eso lo inicializamos a 0), y el segundo no es más que una cadena de
caracteres conteniendo el nombre, (también lo inicializamos siempre a 0). (Notar que en la implementación
del constructor, no es necesario inicializarlo).
Luego, creamos un botón y lo posicionamos dentro del formulario, de la siguiente manera:
1. Primero declaro el objeto botón de la siguiente manera QPushButton *boton.
2. Luego, lo inicializo pasándole como argumento el nombre del widget (en este caso botón), y el widget que
lo contendrá, (en este caso nuestro widget llamado CFormulario), por ultimo le asigno el texto que tendrá el
botón por defecto.
3. El tercer paso, por el momento lo saltaremos, como para no complicar las cosas, pero lo veremos más
adelante.
4. En el cuarto paso, sencillamente llamo a una función miembro llamada setFont de la clase QWidget, que
es la de cambiar la fuente (recordar, que la clase QWidget es la base de todos los widgets) , y le paso como
parámetros, el nombre de la fuente que tendrá, (puede ser cualquiera, "times,", "arial", "gotic" etc..), el
tamaño de la fuente, y por ultimo establezco la fuente en negrita. Para esto, no es necesario crear
previamente un objeto de la clase QFont, sino que llamo directamente al constructor y le paso los
parámetros.
5. En la función principal, la primera linea, que salta a la vista es QApplication Main ( argc , argv ), esta
función, es la encargada de inicializar la librería, y se le debe pasar los argumentos de main, para (en caso
que existan) procesar los argumentos de la linea de comando. No necesariamente debe llamarse Main,
podríamos haberle puesto programa, prueba, pepito, lo que se nos cante. Yo le suele llamar Main, por simple
preferencia.
6. Luego de inicializar la librería, lo que hago es crear una instancia de la clase que creamos previamente, y
le cambio el título con la función setCaption, de la clase QWidget.
7. Posteriormente muestro el formulario, con la función show() de la clase QWidget.
8. Luego le digo a la librería, con la función setMainWidget de la clase QApplication, cual es el widget
principal, (el que tiene que actuar como formulario). y procesar según los eventos recibidos. Para esto, le
tengo que pasar como argumento la DIRECCIÓN DE MEMORIA del widget, (en este caso Form).
9. Y finalmente lo que hago con la función exec, es que la aplicacion se quede procesando los mensajes
recibidos, (los eventos), para luego poder manejarlos a nuestro antojo, es como un bucle de mensajes,
(bastante conocidos por los programadores de windows, y más especialmente los de visual c++).
Si bien la forma de trabajo de la librería, puede parecer un poco confusa en un primer momento, no debemos
olvidarnos, que la librería esta íntimamente asociada a la POO, y lo que nos puede parecer extraño en un
primer momento, pronto se torna tan natural, que sencillamente lo haces de reflejo.
Clases, Objetos y propiedades:
Como dije en un primer momento de este tutorial, es indispensable saber programar con lenguajes orientados
a objetos (dígase c++, object pascal, java) preferentemente c++, que sera el lenguaje utilizado para este
tutorial.
Cualquier widget de la librería QT, es una clase, derivada de QWidget, y es por eso, que la mayoría de los
widgets tienen métodos y propiedades en común, como el ancho, y el alto (width, height) , el título
(setCaption) y la posición (pos) entre muchas otras. Además muchos widgets de la librería, pueden derivar de
otros, como por ejemplo el widget QComboBox, que esta formado por varios widgets (QListBox, QLineEdit,
QValidator etc..), esto, da una flexibilidad tremenda a la librería.
________________________________________________________________________________________
Tipos de datos:
________________________________________________________________________________________
Veamos ahora, la clase QString, que como se habrán dado cuenta no es más que una clase, de las QT, para
el tratamiento de las cadenas.
QString
Constructores:
QString ()
QString ( QChar ch )
QString ( const QString & s )
QString ( const QByteArray & ba )
QString ( const QChar * unicode, uint length )
QString ( const char * str )
QString ( const std::string & str )
Destructores:
~QString();
Normalmente, las clases de la librería QT, tienen sobrecargados el operador "=", y esta no es la excepción.
QString & operator= ( const QString & s )

QString & operator= ( const char * str )
QString & operator= ( const std::string & s )
QString & operator= ( const QCString & cstr )
QString & operator= ( QChar c )
QString & operator= ( char c )
Tambien, mostraremos algunos miembros públicos, de la clase, muchos de ellos están sobrecargados
(overloading).
Esta función, retorna TRUE, si la cadena es NULA (NULL), o FALSE en caso contrario.
bool isNull () const
Esta función retorna TRUE, si la cadena esta vacía o FALSE en caso contrario
bool isEmpty () const
Esta función retorna un entero sin signo (uint o unsigned int), conteniendo la longitud de la cadena
uint length () const
Esta función trunca la cadena, ej:
QString s = "truncate la cadena";

s.truncate( 5 ); // s == "trunc"
void truncate ( uint newLen )
Esta función rellena la cadena, con el carácter especificado, el numero de veces especificado ej:
QString cadena;
cadena.fill( 'H' , 10 ); //cadena = "HHHHHHHHHH"
QString & fill ( QChar c, int len = -1 )
Esta función es una de las más utilizadas, y agradecidas, (al menos por mi), sirve para combinar números,
con cadenas de caracteres ej:
QString str;
str = QString( "El decimal 63 es %1 en hexadecimal" ).arg( 63, 0, 16 );
// str == "El decimal 63 es 3f en hexadecimal"
QString arg ( long a, int fieldWidth = 0, int base = 10 ) const
Las siguientes funciones, hacen lo mismo, pero con distintos números o tipos, puesto que están
sobrecargadas.
QString arg ( ulong a, int fieldWidth = 0, int base = 10 ) const

QString arg ( Q_LLONG a, int fieldWidth = 0, int base = 10 ) const
QString arg ( Q_ULLONG a, int fieldWidth = 0, int base = 10 ) const
QString arg ( int a, int fieldWidth = 0, int base = 10 ) const
QString arg ( uint a, int fieldWidth = 0, int base = 10 ) const
QString arg ( short a, int fieldWidth = 0, int base = 10 ) const
QString arg ( ushort a, int fieldWidth = 0, int base = 10 ) const
QString arg ( double a, int fieldWidth = 0, char fmt = 'g', int prec = -1 ) const
QString arg ( char a, int fieldWidth = 0 ) const
QString arg ( QChar a, int fieldWidth = 0 ) const
QString arg ( const QString & a, int fieldWidth = 0 ) const
QString arg ( const QString & a1, const QString & a2 ) const
QString arg ( const QString & a1, const QString & a2, const QString & a3 ) const
QString arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4 ) const
Esta función, busca el carácter o la subcadena especificada dentro de la cadena, y retorna un entero, que
contiene la posición del carácter o la posición de la subcadena dentro de la cadena ej
QString cadena = "Hola, esto es una prueba"

int num = cadena.find("esto", cadena.length,TRUE); // num = 7
int find ( QChar c, int index = 0, bool cs = TRUE ) const
El resto de las funciones, están sobrecargadas.
int find ( char c, int index = 0, bool cs = TRUE ) const

int find ( const QString & str, int index = 0, bool cs = TRUE ) const
int find ( const QRegExp & rx, int index = 0 ) const
int find ( const char * str, int index = 0 ) const
Esta función retorna la posición de el carácter o cadena especificado, comenzando por el final ej:
QString cadena("Bananas");
int i = cadena.findRev( ' a ' ); // i = 5
int findRev ( QChar c, int index = -1, bool cs = TRUE ) const
El resto de las funciones, hacen lo mismo, solamente están sobrecargadas
int findRev ( char c, int index = -1, bool cs = TRUE ) const

int findRev ( const QString & str, int index = -1, bool cs = TRUE ) const
int findRev ( const QRegExp & rx, int index = -1 ) const
int findRev ( const char * str, int index = -1 ) const
Esta función, retorna el numero de veces, que el carácter o la subcadena especificada aparece dentro de la
cadena Ej:
QString cadena ("Cadena de prueba");

int num = cadena.contains( 'a' , FALSE ) // num = 3
int contains ( QChar c, bool cs = TRUE ) const

El resto de las funciones están sobrecargadas
int contains ( char c, bool cs = TRUE ) const

int contains ( const char * str, bool cs = TRUE ) const
int contains ( const QString & str, bool cs = TRUE ) const
int contains ( const QRegExp & rx ) const
Esta función, retorna un QString, conteniendo una seccion de la cadena Ej:
QString cadena ( "cadena1,cadena2,cadena3,cadena4" );

QString s = cadena.section( ',' , 2 , 2 ); //s = cadena3
QString section ( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
El resto de las funciones, hacen lo mismo, solamente están sobrecargadas
QString section ( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
QString section ( const char * sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
QString section ( const QString & sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
QString section ( const QRegExp & reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const
Esta función retorna la subcadena, contenida dentro de la cadena a partir de la posición indicada
comenzando por la derecha Ej:
QString cadena ( "ejemplo de cadenas" );

QString subcad = cadena.left ( 11 ); //subcad = cadenas
QString left ( uint len ) const
Esta función retorna una subcadena dentro de una cadena, a partir de la posición indicada comenzando por
la izquierda.
QString right ( uint len ) const
Esta función retorna la subcadena contenida dentro de la cadena, desde la posición 1 hasta la posición 2 Ej:
QString cadena ( "ejemplo de cadenas" );
QString cade = cadena.mid(11, cadena.length); //cade = cadenas
QString mid ( uint index, uint len = 0xffffffff ) const
Esta función, retorna la cadena un minúsculas
QString lower () const
Esta función, retorna la cadena un mayúsculas
QString upper () const
Esta función, retorna la cadena borra los espacios dentro de la cadena Ej:
QString cadena(" ejemplo de cadenas " );

QString cade = cadena.stripWhiteSpace(); //cade = ejemplo de cadenas
QString stripWhiteSpace () const

Esta función, inserta una cadena dentro de otra, a partir de la posición dada
QString & insert ( uint index, const QString & s )

QString & insert ( uint index, const QByteArray & s )
QString & insert ( uint index, const char * s )
QString & insert ( uint index, const QChar * s, uint len )
QString & insert ( uint index, QChar c )
QString & insert ( uint index, char c )
Esta función, concatena una cadena o un carácter con otra cadena o carácter
QString & append ( char ch )

QString & append ( QChar ch )
QString & append ( const QString & str )
QString & append ( const QByteArray & str )
QString & append ( const char * str )
QString & append ( const std::string & str )
Esta función, añade una cadena o carácter dentro de otra, comenzando por el principio de la cadena es
similar a poner insert (0,carácter)
QString & prepend ( char ch )

QString & prepend ( QChar ch )
QString & prepend ( const QString & s )
QString & prepend ( const QByteArray & s )
QString & prepend ( const char * s )
QString & prepend ( const std::string & s )
Esta función, remueve x cantidad de caracteres dentro de una cadena , y retorna una referencia a un
QString , con los datos removidos Ej:
QString cadena( "Montreal" );

cadena.remove( 1, 4 ); // cadena == "Meal"
QString & remove ( uint index, uint len )

QString & remove ( const QString & str, bool cs = TRUE )
QString & remove ( QChar c )
QString & remove ( char c )
QString & remove ( const char * str )
QString & remove ( const QRegExp & rx )
Esta función, remplaza los caracteres de la cadena, a partir de una posición dada ej:
QString string( "Say yes!" );

string = string.replace( 4, 3, "NO" );
// string == "Say NO!"
QString & replace ( uint index, uint len, const QString & s )
QString & replace ( uint index, uint len, const QChar * s, uint slen )
QString & replace ( uint index, uint len, QChar c )
QString & replace ( uint index, uint len, char c )
QString & replace ( QChar c, const QString & after, bool cs = TRUE )
QString & replace ( char c, const QString & after, bool cs = TRUE )
QString & replace ( const QString & before, const QString & after, bool cs = TRUE )
QString & replace ( const QRegExp & rx, const QString & after )
QString & replace ( QChar c1, QChar c2 )
Estas funciones, son de conversión, pongo un ejemplo de un short, como para mostrar pero todas trabajan de
similar manera ej:
QString cadena ( "5" );

bool result;
short num = cadena.toShort ( &result, 10 ) //base 10
//num = 5
si la conversión, fue realizada con éxito, result retorna TRUE, en caso contrario retorna FALSE.
short toShort ( bool * ok = 0, int base = 10 ) const

ushort toUShort ( bool * ok = 0, int base = 10 ) const
int toInt ( bool * ok = 0, int base = 10 ) const
uint toUInt ( bool * ok = 0, int base = 10 ) const
long toLong ( bool * ok = 0, int base = 10 ) const
ulong toULong ( bool * ok = 0, int base = 10 ) const
Q_LLONG toLongLong ( bool * ok = 0, int base = 10 ) const
Q_ULLONG toULongLong ( bool * ok = 0, int base = 10 ) const
float toFloat ( bool * ok = 0 ) const
double toDouble ( bool * ok = 0 ) const
Esta función, agrega a la cadena un numero, ej:

int numero = 25
QString cadena;
cadena.setNum ( 25 , 10 ); //cadena = 25
QString & setNum ( short n, int base = 10 )

QString & setNum ( ushort n, int base = 10 )
QString & setNum ( int n, int base = 10 )
QString & setNum ( uint n, int base = 10 )
QString & setNum ( long n, int base = 10 )
QString & setNum ( ulong n, int base = 10 )
QString & setNum ( Q_LLONG n, int base = 10 )
QString & setNum ( Q_ULLONG n, int base = 10 )
QString & setNum ( float n, char f = 'g', int prec = 6 )
QString & setNum ( double n, char f = 'g', int prec = 6 )
Operador sobrecargado +=
QString & operator+= ( const QString & str )

QString & operator+= ( const QByteArray & str )
QString & operator+= ( const char * str )
QString & operator+= ( const std::string & str )
QString & operator+= ( QChar c )
QString & operator+= ( char c )
Esta función, retorna el carácter contenido en la cadena, a partir de la posición dada ej:
const QString string( "abcdefgh" );

QChar ch = string.at( 4 );
// ch == 'e'
QChar at ( uint i ) const
Esta función retorna retorna un puntero a un QChar, conteniendo la cadena
const QChar * unicode () const
Esta función retorna retorna un puntero a un const char, conteniendo la cadena
const char * ascii () const
Esta función retorna retorna un puntero a un const char, conteniendo la cadena
const char * latin1 () const
Estas funciones, retornan una referencia a un QString, a partir de otra cadena de tipo const char * Ej:
QString cade;
const char *cadena = "ejemplo de cadenas";
cade.setLatin1(cadena, strlen ( cadena ) );
QString & setAscii ( const char * str, int len = -1 )

QString & setLatin1 ( const char * str, int len = -1 )
Esta función, simplemente redimensiona el tamaño de la cadena.
void setLength ( uint newLen )
Miembros públicos estáticos:
QString number ( long n, int base = 10 )

QString number ( ulong n, int base = 10 )
QString number ( Q_LLONG n, int base = 10 )
QString number ( Q_ULLONG n, int base = 10 )
QString number ( int n, int base = 10 )
QString number ( uint n, int base = 10 )
QString number ( double n, char f = 'g', int prec = 6 )
QString fromAscii ( const char * ascii, int len = -1 )
QString fromLatin1 ( const char * chars, int len = -1 )
QString fromUtf8 ( const char * utf8, int len = -1 )
QString fromLocal8Bit ( const char * local8Bit, int len = -1 )
QString fromUcs2 ( const unsigned short * str )
int compare ( const QString & s1, const QString & s2 )
int localeAwareCompare ( const QString & s1, const QString & s2 )
Funciones relacionales:
bool operator== ( const QString & s1, const QString & s2 )

bool operator== ( const QString & s1, const char * s2 )
bool operator== ( const char * s1, const QString & s2 )
bool operator!= ( const QString & s1, const QString & s2 )
bool operator!= ( const QString & s1, const char * s2 )
bool operator!= ( const char * s1, const QString & s2 )
bool operator< ( const QString & s1, const char * s2 )
bool operator< ( const char * s1, const QString & s2 )
bool operator<= ( const QString & s1, const char * s2 )
bool operator<= ( const char * s1, const QString & s2 )
bool operator> ( const QString & s1, const char * s2 )
bool operator> ( const char * s1, const QString & s2 )
bool operator>= ( const QString & s1, const char * s2 )
bool operator>= ( const char * s1, const QString & s2 )
const QString operator+ ( const QString & s1, const QString & s2 )
const QString operator+ ( const QString & s1, const char * s2 )
const QString operator+ ( const char * s1, const QString & s2 )
const QString operator+ ( const QString & s, char c )
const QString operator+ ( char c, const QString & s )
QDataStream & operator<< ( QDataStream & s, const QString & str )
QDataStream & operator>> ( QDataStream & s, QString
Bueno, espero que con estas funciones puedan manipular las cadenas a gusto, lamentablemente no puse
todas las funciones, por una cuestión de salud (prevención contra la artritis deformante) , pero si las más
necesarias y utilizadas.
También, tenemos otra clase para el manejo de cadenas la clase QCString, lo único que difiere con la
anterior es que esta más orientada a las cadenas en C.
QCString:
Constructor por defecto
QCString ()
Constructor con el tamaño de la letra por defecto

QCString ( int size )
Constructor copia
QCString ( const QCString & s )
Constructor sobrecargado para contener datos del tipo const char *

QCString ( const char * str )
Constructor sobrecargado para contener datos del tipo const char *, y el tamaño máximo de la cadena
QCString ( const char * str, uint maxsize )
Función que retorna TRUE, si el dato es NULO

Función que retorna TRUE, si la variable esta vacía

Función que retorna el largo de la cadena

uint length () const
Función que dimensionaren la variable, para contener más caracteres dentro, y retorna TRUE si fue posible
bool resine ( uint len )
Función que retorna TRUE, si se pudo truncar el dato a la posición indicada

bool truncate ( uint pos )
Función que retorna TRUE, si se pudo rellenar la variable con la letra especificada el numero de veces
especificado
bool fill ( char c, int len = -1 )
Función que retorna un QCString, con el formato de la cadena pasada como argumento.
QCString & sprintf ( const char * format, ... )
Función que retorna la posición de la letra pasada como argumento

int find ( char c, int index = 0, bool cs = TRUE ) const
int find ( const char * str, int index = 0, bool cs = TRUE ) const
Función que retorna la posición de la letra buscada a trasves de una expresión regular
int find ( const QRegExp & rx, int index = 0 ) const
Función que retorna la posición de la letra pasada como argumento, la búsqueda comienza desde el final de
la cadena.
int findRev ( char c, int index = -1, bool cs = TRUE ) const
int findRev ( const char * str, int index = -1, bool cs = TRUE ) const
int findRev ( const QRegExp & rx, int index = -1 ) const
Función que retorna el numero de veces, que el carácter fue encontrado en la cadena.
int contains ( char c, bool cs = TRUE ) const
int contains ( const char * str, bool cs = TRUE ) const
int contains ( const QRegExp & rx ) const
QCString left ( uint len ) const

QCString right ( uint len ) const
QCString mid ( uint index, uint len = 0xffffffff ) const
Función que transforma la cadena a minúsculas.

QCString lower () const
Función que transforma la cadena a mayúsculas.

QCString upper () const
Función que borra los espacios de la cadena

QCString stripWhiteSpace () const
Función que inserta una cadena dentro de otra, a partir de la posición pasada como argumento.
QCString & insert ( uint index, const char * s )
QCString & insert ( uint index, char c )
Función que agrega una cadena al final de otra

QCString & append ( const char * str )
Función que agrega una cadena dentro de otra comenzando desde el principio
QCString & prepend ( const char * s )
Función que remueve x cantidad de caracteres pasados como argumento

QCString & remove ( uint index, uint len )
Función que remplaza x cantidad de caracteres por la cadena pasada como argumento
QCString & replace ( uint index, uint len, const char * str )
QCString & replace ( const QRegExp & rx, const char * str )
QCString & replace ( char c, const char * after )
QCString & replace ( const char * before, const char * after )
QCString & replace ( char c1, char c2 )
Función que convierte la cadena a un short (entero corto) y retorna la cadena convertida
short toShort ( bool * ok = 0 ) const
Función que convierte la cadena a un ushort (entero corto sin signo) y retorna la cadena convertida
ushort toUShort ( bool * ok = 0 ) const
Función que convierte la cadena a un int (entero) y retorna la cadena convertida

int toInt ( bool * ok = 0 ) const
Función que convierte la cadena a un uint (entero sin signo) y retorna la cadena convertida
uint toUInt ( bool * ok = 0 ) const
Función que convierte la cadena a un long (entero largo) y retorna la cadena convertida
long toLong ( bool * ok = 0 ) const
Función que convierte la cadena a un ulong (entero largo sin signo) y retorna la cadena convertida
ulong toULong ( bool * ok = 0 ) const
Función que convierte la cadena a un float (real) y retorna la cadena convertida

float toFloat ( bool * ok = 0 ) const
Función que convierte la cadena a un double (doble presidencia) y retorna la cadena convertida
double toDouble ( bool * ok = 0 ) const
Función que cambia el contenido de la cadena, por otro pasado como argumento
QCString & setStr ( const char * str )
Función que convierte la cadena a un numero (sobrecargada)

QCString & setNum ( short n )
QCString & setNum ( ushort n )
QCString & setNum ( int n )
QCString & setNum ( uint n )
QCString & setNum ( long n )
QCString & setNum ( ulong n )
QCString & setNum ( float n, char f = 'g', int prec = 6 )
QCString & setNum ( double n, char f = 'g', int prec = 6 )
Función que cambia la posición del carácter pasado como argumento y expande la cadena si es necesario.
bool setExpand ( uint index, char c )
Funciones que se ofrecen por razones de compatibilidad.

void * qmemmove ( void * dst, const void * src, uint len )
char * qstrdup ( const char * src )
char * qstrcpy ( char * dst, const char * src )
char * qstrncpy ( char * dst, const char * src, uint len )
uint qstrlen ( const char * str )
int qstrcmp ( const char * str1, const char * str2 )
int qstrncmp ( const char * str1, const char * str2, uint len )
int qstricmp ( const char * str1, const char * str2 )
int qstrnicmp ( const char * str1, const char * str2, uint len )
Operadores sobrecargados
QDataStream & operator<< ( QDataStream & s, const QCString & str )
QDataStream & operator>> ( QDataStream & s, QCString & str )
bool operator== ( const QCString & s1, const QCString & s2 )
bool operator== ( const QCString & s1, const char * s2 )
bool operator== ( const char * s1, const QCString & s2 )
bool operator!= ( const QCString & s1, const QCString & s2 )
bool operator!= ( const QCString & s1, const char * s2 )
bool operator!= ( const char * s1, const QCString & s2 )
bool operator< ( const QCString & s1, const char * s2 )
bool operator< ( const char * s1, const QCString & s2 )
bool operator<= ( const QCString & s1, const char * s2 )
bool operator<= ( const char * s1, const QCString & s2 )
bool operator> ( const QCString & s1, const char * s2 )
bool operator> ( const char * s1, const QCString & s2 )
bool operator>= ( const QCString & s1, const char * s2 )
bool operator>= ( const char * s1, const QCString & s2 )
QCString & operator+= ( const char * str )
QCString & operator+= ( char c )
const QCString operator+ ( const QCString & s1, const QCString & s2 )
const QCString operator+ ( const QCString & s1, const char * s2 )
const QCString operator+ ( const char * s1, const QCString & s2 )
const QCString operator+ ( const QCString & s, char c )
const QCString operator+ ( char c, const QCString & s )
Veremos ahora, el tipo QByteArray, que no es más que un array de bytes, como su nombre lo indica.
QByteArray
QByteArray ()
Constructor con el tamaño del array como argumento

QByteArray ( int size )
Función que comprime el array, y retorna el array comprimido usando zlib

QByteArray qCompress ( const QByteArray & data )
QByteArray qCompress ( const uchar * data, int nbytes )
QByteArray qUncompress ( const QByteArray & data )
QByteArray qUncompress ( const uchar * data, int nbytes
Continuamos con la clase QPtrCollection, que define varias función para las listas
QPrtCollection
Función, que retorna TRUE, si la opción deletrearos esta activa
bool papeleteemos () const
Función, que habilita la opción deletrearos

void setAutoDelete ( bool enable )
Función, que retorna la cantidad de items en la lista
virtual uint count () const = 0
Función, que borra la lista

virtual void clear () = 0
Función, que retorna un ítem de la lista

typedef void * ítem

QPtrCollection ()
Constructor copia
QPtrCollection ( const QPtrCollection & source )
Destructor
virtual ~QPtrCollection ()
Función que crea una copia del ítem, y lo inserta dentro de la clase
virtual ítem newItem ( ítem d )
Función que busca un ítem dentro de la lista, y lo borra si lo encuentra.

virtual void deleteItem ( ítem d ) = 0
Seguiremos ahora, con la clase QPtrList, que no es más que una lista de la STL, pero mejorada
QPtrList
QPtrList ()
Constructor copia con otro tipo

QPtrList ( const QPtrList<type> & list )
Destructor
~QPtrList ()
QPtrList<type> & operator= ( const QPtrList<type> & list )
bool operator== ( const QPtrList<type> & list ) const
bool operator!= ( const QPtrList<type> & list ) const
Función que retorna la cantidad de datos que contiene la lista

virtual uint count () const
Función que retorna TRUE, si la lista se encuentra vacía

Función que inserta un ítem en la lista

bool insert ( uint index, const type * ítem )
Función que inserta un ítem en la lista en una posición aleatoria

void inSort ( const type * ítem )
Función que inserta un ítem en la lista al comienzo
void prepend ( const type * ítem )
Función que añade un ítem en la lista al final

void append ( const type * ítem )
Función que remueve un ítem de la lista, por su índice, si el ítem fue borrado, retorna TRUE
bool remove ( uint index )
Función que remueve el ítem actual de la lista, y retorna TRUE si el ítem fue borrado
bool remove ()
Función que remueve la primera ocurrencia del ítem en la lista

bool remove ( const type * ítem )
Función que remueve un nodo de la lista

void removeNode ( QLNode * node )
Función que remueve el primer ítem de la lista

bool removeFirst ()
Función que remueve el ultimo ítem de la lista

bool removeLast ()
Función que borra la lista completa.

virtual void clear ()
Función que ordena la lista, utilizando el método de ordenación QSort (este es de los 70 )
void sort ()
Función que busca un ítem en la lista

int find ( const type * ítem )
Función que busca la siguiente ocurrencia del ítem en la lista

int findNext ( const type * ítem )
Función que retorna el numero de ocurrencias de ítem en la lista

uint contains ( const type * ítem ) const
Función que remplaza el ítem en la posición index, por el nuevo ítem

bool replace ( uint index, const type * ítem )
Función que retorna un puntero al ítem, en el índice seleccionado

type * at ( uint index )
Función que retorna el índice del ítem en la lista

int at () const
Función que retorna un puntero al ítem seleccionado

type * current () const
Función que retorna un puntero al primer ítem de la lista

type * getFirst () const
Función que retorna un puntero al ultimo ítem de la lista
type * getLast () const
Funciones de movimiento dentro de la lista

type * first ()
type * last ()
type * next ()
type * prev ()
Veamos ahora, el widget QTextStream, que sirve para crear stream de texto
QTextStream
Enumeración con el modo de encode que tendrá el stream
enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder, UnicodeReverse, RawUnicode,
UnicodeUTF8 }
Función que cambia con el modo de encode que tendrá el stream

void setEncoding ( Encoding e )
Función que cambia con el modo de QTextCodec que tendrá el stream

void setCodec ( QTextCodec * codec )
Función que retorna el modo de codec que tendrá el stream

QTextCodec * codec ()

QTextStream ()
Constructor por que asocia el stream a un QIODevice (dispositivo de entrada ¿lindo no?)
QTextStream ( QIODevice * iod )
Constructor por que asocia el stream a QString y se le puede especificar el tipo de acceso (enumeración de
la clase QFile)
QTextStream ( QString * str, int filemode )
Constructor por que asocia el stream a un QByteArray

QTextStream ( QByteArray a, int mode )
Constructor por que asocia el stream a una estructura FILE * de c (no recomendado)
QTextStream ( FILE * fh, int mode )
Destructor
virtual ~QTextStream ()
Función que retorna el dispositivo asociado al stream

QIODevice * device () const
Función que cambia el dispositivo asociado al stream

void setDevice ( QIODevice * iod )
Función que cambia el dispositivo asociado al stream (equivalente a setDevice(0) )

void unsetDevice ()
Función que retorna TRUE si se llego al final del fichero
bool atEnd () const
Operadores sobrecargados (no los explico, porque son bastante autoexplicativos)

QTextStream & operator>> ( QChar & c )
QTextStream & operator>> ( char & c )
QTextStream & operator>> ( signed short & i )
QTextStream & operator>> ( unsigned short & i )
QTextStream & operator>> ( signed int & i )
QTextStream & operator>> ( unsigned int & i )
QTextStream & operator>> ( signed long & i )
QTextStream & operator>> ( unsigned long & i )
QTextStream & operator>> ( float & f )
QTextStream & operator>> ( double & f )
QTextStream & operator>> ( char * s )
QTextStream & operator>> ( QString & str )
QTextStream & operator>> ( QCString & str )
QTextStream & operator<< ( QChar c )
QTextStream & operator<< ( char c )
QTextStream & operator<< ( signed short i )
QTextStream & operator<< ( unsigned short i )
QTextStream & operator<< ( signed int i )
QTextStream & operator<< ( unsigned int i )
QTextStream & operator<< ( signed long i )
QTextStream & operator<< ( unsigned long i )
QTextStream & operator<< ( float f )
QTextStream & operator<< ( double f )
QTextStream & operator<< ( const char * s )
QTextStream & operator<< ( const QString & s )
QTextStream & operator<< ( const QCString & s )
QTextStream & operator<< ( void * ptr )
Función que lee una cantidad especifica de bytes de un stream, y retorna una referencia a otro stream
QTextStream & readRawBytes ( char * s, uint len )
Función que escribe una cantidad especifica de bytes de un stream, y retorna una referencia a otro stream
QTextStream & writeRawBytes ( const char * s, uint len )
Función que lee una linea del stream

QString readLine ()
Función que lee el stream

QString read ()
Función que establece si se tiene que saltar los espacios.

void skipWhiteSpace ()
Función que retorna un int, con el estado del stream.

int flags () const
Función que resetea es stream

void reset ()
Seguiremos con la clase QPoint, que es una de las encargadas de manejar puntos y coordenadas.
QPoint:
QPoint ()
Constructor con las coordenadas del objeto como argumento

QPoint ( int xpos, int ypos )
Función que retorna TRUE si el objeto s NULL

Función que retorna la coordenada x del objeto

int x () const
Función que retorna la coordenada y del objeto

int y () const
Función que cambia la coordenada x del objeto

void setX ( int x )
Función que cambia la coordenada y del objeto

void setY ( int y )
Función que retorna la suma total de los valores X e Y

int manhattanLength () const
Función que retorna una referencia a la coordenada x

QCOORD & rx ()
Función que retorna una referencia a la coordenada y

QCOORD & ry ()
QPoint & operator+= ( const QPoint & p )
QPoint & operator-= ( const QPoint & p )
QPoint & operator*= ( int c )
QPoint & operator*= ( double c )
QPoint & operator/= ( int c )
QPoint & operator/= ( double c )
bool operator== ( const QPoint & p1, const QPoint & p2 )
bool operator!= ( const QPoint & p1, const QPoint & p2 )
const QPoint operator+ ( const QPoint & p1, const QPoint & p2 )
const QPoint operator- ( const QPoint & p1, const QPoint & p2 )
const QPoint operator* ( const QPoint & p, int c )
const QPoint operator* ( int c, const QPoint & p )
const QPoint operator* ( const QPoint & p, double c )
const QPoint operator* ( double c, const QPoint & p )
const QPoint operator- ( const QPoint & p )
const QPoint operator/ ( const QPoint & p, int c )
const QPoint operator/ ( const QPoint & p, double c )
QDataStream & operator<< ( QDataStream & s, const QPoint & p )
QDataStream & operator>> ( QDataStream & s, QPoint & p )
Tambien veamos ahora la clase QSize

QSize
Enumeración que contiene el modo de escala
enum ScaleMode { ScaleFree, ScaleMin, ScaleMax }

QSize ()
Constructor con el ancho y el alto por defecto

QSize ( int w, int h )
Función que retorna TRUE si el objeto es NULL

Función que retorna TRUE si el objeto esta vacío

Función que retorna TRUE si el objeto es valido

bool isValid () const
Función que retorna el ancho del objeto

int width () const
Función que retorna el alto del objeto

int height () const
Función que cambia el ancho del objeto

void setWidth ( int w )
Función que cambia el alto del objeto

void setHeight ( int h )
Función que escala el objeto

void scale ( int w, int h, ScaleMode mode )
Función que escala el objeto con otro QSize como argumento

void scale ( const QSize & s, ScaleMode mode )
Función que retorna el ancho y alto máximo del QSize pasado como argumento
QSize expandedTo ( const QSize & otherSize ) const
Función que retorna el ancho y alto mínimo del QSize pasado como argumento
QSize boundedTo ( const QSize & otherSize ) const
Función que retorna una referencia al ancho del objeto

QCOORD & rwidth ()
Función que retorna una referencia al alto del objeto

QCOORD & rheight ()
QSize & operator+= ( const QSize & s )
QSize & operator-= ( const QSize & s )
QSize & operator*= ( int c )
QSize & operator*= ( double c )
QSize & operator/= ( int c )
QSize & operator/= ( double c )
Ahora mostraremos la clase QValidator, que sirve para validar datos dentro de los widgets.
QValidator
QValidator ( QObject * parent, const char * name = 0 )
Destructor
~QValidator ()
Enumeración con el estado de la comprobación

enum State { Invalid, Intermediate, Valid = Intermediate, Acceptable }
Esta función valida los datos y retorna Invalid si la entrada es incorrecta o Acceptable si es correcta.
virtual State validate ( QString & input, int & pos ) const = 0
Esta función establece el tipo de validación que queremos darle a los datos.
virtual void fixup ( QString & input ) const
Veremos a continuación la clase QStrList, que sirve para el manejo de arrays de cadenas de tipo char **
QStrList
QStrList ( bool deepCopies = TRUE )
Constructor copia
QStrList ( const QStrList & list )
Destructor
~QStrList ()
operador sobrecargado
QStrList & operator= ( const QStrList & list )
QMemArray
Función que crea un Iterador.
typedef type * Iterator
Función que crea un Iterador constante.

typedef const type * ConstIterator

QMemArray ()
Constructor con la cantidad de objetos que tendrá como argumento

QMemArray ( int size )
Constructor con la cantidad de objetos que tendrá y el tipo como argumentos

QMemArray ( const QMemArray<type> & a )
Destructor
~QMemArray ()
Operador sobrecargado
QMemArray<type> & operator= ( const QMemArray<type> & a )
Función que retorna un puntero al tipo actualmente seleccionado en el array.

type * data () const
Función que retorna una referencia a la cantidad de datos que contiene el array.
uint nrefs () const
Función que retorna el tamaño del array

uint size () const
Función que retorna la cantidad de items en el array

uint count () const
Función que retorna TRUE si el array esta vacío

Función que retorna TRUE si el dato es nulo

Función que redimensiona el array

bool resine ( uint size )
Función que redimensiona el array, pasándole el tipo de optimización requerido, la optimización puede ser
QGArray::MemOptim (optimiza la memoria) QGArray::SpeedOptim (optimiza la velocidad).
bool resine ( uint size, Optimization optim )
Función que retorna TRUE si el dato en la posición pos es truncado

bool truncate ( uint pos )
Función que rellena el array con el valor V

bool fill ( const type & v, int size = -1 )
Función que retorna una copia del array

QMemArray<type> copy () const
Función que busca un dato en el array.

int find ( const type & v, uint index = 0 ) const
Función que retorna el numero de veces que V aparece en el array

int contains ( const type & v ) const
Función que ordena el array.

void sort ()
Función que (si el array esta ordenado) realiza una búsqueda binaria de V en el array.
int bsearch ( const type & v ) const
Operador sobrecargado
type & operator[] ( int index ) const
Función que retorna una referencia al elemento en el índice especificado

type & at ( uint index ) const
operator const type * () const
bool operator== ( const QMemArray<type> & a ) const
bool operator!= ( const QMemArray<type> & a ) const
Función que retorna un puntero al Iterador del array, con el primer dato del array.
Iterator begin ()
Función que retorna un puntero al Iterador del array, con el ultimo dato del array.
Iterator end ()
Función que retorna un puntero al Iterador constante del array, con el primer dato del array.
ConstIterator begin () const
Función que retorna un puntero al Iterador constante del array, con el ultimo dato del array.
ConstIterator end () const
Si bien esto de mostrar unos cuantos tipos de datos y clases de entrada, puede parecer algo pesado, no lo
hago a propósito ni tampoco es necesario que se los conozcan al pie de la letra, solamente los pongo aquí, a
modo de referencia. Noten que puse estos datos ANTES de comenzar a "tirar código", ya que sino no sabrían
que es cada cosa, ni para que sirve, ni mucho menos como trabaja.
Pondre ahora, las enumeraciones que contiene la clase QT, no es interesante leerlo, pero si tenerlo como
referencia, puesto que las usaremos bastante.
QT Enumeraciònes
Enumeración, que contiene el estado de los botones.

enum ButtonState { NoButton = 0x0000, LeftButton = 0x0001, RightButton = 0x0002, MidButton = 0x0004,
MouseButtonMask = 0x0007, ShiftButton = 0x0100, ControlButton = 0x0200, AltButton = 0x0400, MetaButton
= 0x0800, KeyButtonMask = 0x0f00, Keypad = 0x4000 }
Enumeración, que contiene la orientación

enum Orientation { Horizontal = 0, Vertical }
Enumeración, que contiene el orden

enum SortOrder { Ascending, Descending }
Enumeración, que contiene los flags de alineación

enum AlignmentFlags { AlignAuto = 0x0000, AlignLeft = 0x0001, AlignRight = 0x0002, AlignHCenter =
0x0004, AlignJustify = 0x0008, AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify,
AlignTop = 0x0010, AlignBottom = 0x0020, AlignVCenter = 0x0040, AlignVertical_Mask = AlignTop |
AlignBottom | AlignVCenter, AlignCenter = AlignVCenter | AlignHCenter }
Enumeración, que contiene los flags de alineación del texto

enum TextFlags { SingleLine = 0x0080, DontClip = 0x0100, ExpandTabs = 0x0200, ShowPrefix = 0x0400,
WordBreak = 0x0800, BreakAnywhere = 0x1000, NoAccel = 0x4000 }
Enumeración, que contiene los estados del widget

enum WidgetState { WState_Created = 0x00000001, WState_Disabled = 0x00000002, WState_Visible =
0x00000004, WState_ForceHide = 0x00000008, WState_OwnCursor = 0x00000010, WState_MouseTracking
= 0x00000020, WState_CompressKeys = 0x00000040, WState_BlockUpdates = 0x00000080,
WState_InPaintEvent = 0x00000100, WState_Reparented = 0x00000200, WState_ConfigPending =
0x00000400, WState_Resized = 0x00000800, WState_AutoMask = 0x00001000, WState_Polished =
0x00002000, WState_DND = 0x00004000, WState_Reserved0 = 0x00008000, WState_Reserved1 =
0x00010000, WState_OwnSizePolicy = 0x00020000, WState_CreatedHidden = 0x00040000,
WState_Maximized = 0x00080000, WState_Minimized = 0x00100000, WState_ForceDisabled = 0x00200000,
WState_Exposed = 0x00400000, WState_HasMouse = 0x00800000 }
Enumeración, que contiene los flags de creacion de los widget (tipos)

enum WidgetFlags { WType_TopLevel = 0x00000001, WType_Dialog = 0x00000002, WType_Popup =
0x00000004, WType_Desktop = 0x00000008, WType_Mask = 0x0000000f, WStyle_Customize =
0x00000010, WStyle_NormalBorder = 0x00000020, WStyle_DialogBorder = 0x00000040, WStyle_NoBorder =
0x00002000, WStyle_Title = 0x00000080, WStyle_SysMenu = 0x00000100, WStyle_Minimize = 0x00000200,
WStyle_Maximize = 0x00000400, WStyle_MinMax = WStyle_Minimize | WStyle_Maximize, WStyle_Tool =
0x00000800, WStyle_StaysOnTop = 0x00001000, WStyle_ContextHelp = 0x00004000, WStyle_Reserved =
0x00008000, WStyle_Mask = 0x0000fff0, WDestructiveClose = 0x00010000, WPaintDesktop = 0x00020000,
WPaintUnclipped = 0x00040000, WPaintClever = 0x00080000, WResizeNoErase = 0x00100000,
WMouseNoMask = 0x00200000, WStaticContents = 0x00400000, WRepaintNoErase = 0x00800000,
WX11BypassWM = 0x01000000, WWinOwnDC = 0x00000000, WMacNoSheet = 0x00000000, WMacDrawer
= 0x00000000, WX11BypassWM = 0x00000000, WWinOwnDC = 0x01000000, WMacNoSheet =
0x00000000, WMacDrawer = 0x00000000, WGroupLeader = 0x02000000, WShowModal = 0x04000000,
WNoMousePropagation = 0x08000000, WSubWindow = 0x10000000, WStyle_Splash = 0x20000000,
WNoAutoErase = WRepaintNoErase | WResizeNoErase, WNorthWestGravity = WStaticContents,
WType_Modal = WType_Dialog | WShowModal, WStyle_Dialog = WType_Dialog, WStyle_NoBorderEx =
WStyle_NoBorder } (obsolete)
Enumeración, que contiene los tipos de conversión de las imagenes.

enum ImageConversionFlags { ColorMode_Mask = 0x00000003, AutoColor = 0x00000000, ColorOnly =
0x00000003, MonoOnly = 0x00000002, AlphaDither_Mask = 0x0000000c, ThresholdAlphaDither =
0x00000000, OrderedAlphaDither = 0x00000004, DiffuseAlphaDither = 0x00000008, NoAlpha = 0x0000000c,
Dither_Mask = 0x00000030, DiffuseDither = 0x00000000, OrderedDither = 0x00000010, ThresholdDither =
0x00000020, DitherMode_Mask = 0x000000c0, AutoDither = 0x00000000, PreferDither = 0x00000040,
AvoidDither = 0x00000080 }
Enumeración, que contiene los modos de fondo

enum BGMode { TransparentMode, OpaqueMode }
Enumeración, que contiene las medidas de pintado (pixeles, twips mitric etc...)
enum PaintUnit { PixelUnit, LoMetricUnit, HiMetricUnit, LoEnglishUnit, HiEnglishUnit, TwipsUnit }
Enumeración, que contiene los modos de secuencia

enum SequenceMatch { NoMatch, PartialMatch, Identical }
Enumeración, que contiene los modos de tecla de modificación

enum Modifier { META = 0x00100000, SHIFT = 0x00200000, CTRL = 0x00400000, ALT = 0x00800000,
MODIFIER_MASK = 0x00f00000, UNICODE_ACCEL = 0x10000000, ASCII_ACCEL = UNICODE_ACCEL }
Enumeración, que contiene los tipos de tecla
enum Key { Key_Escape = 0x1000, Key_Tab = 0x1001, Key_Backtab = 0x1002, Key_BackTab =
Key_Backtab, Key_Backspace = 0x1003, Key_BackSpace = Key_Backspace, Key_Return = 0x1004,
Key_Enter = 0x1005, Key_Insert = 0x1006, Key_Delete = 0x1007, Key_Pause = 0x1008, Key_Print = 0x1009,
Key_SysReq = 0x100a, Key_Clear = 0x100b, Key_Home = 0x1010, Key_End = 0x1011, Key_Left = 0x1012,
Key_Up = 0x1013, Key_Right = 0x1014, Key_Down = 0x1015, Key_Prior = 0x1016, Key_PageUp =
Key_Prior, Key_Next = 0x1017, Key_PageDown = Key_Next, Key_Shift = 0x1020, Key_Control = 0x1021,
Key_Meta = 0x1022, Key_Alt = 0x1023, Key_CapsLock = 0x1024, Key_NumLock = 0x1025, Key_ScrollLock
= 0x1026, Key_F1 = 0x1030, Key_F2 = 0x1031, Key_F3 = 0x1032, Key_F4 = 0x1033, Key_F5 = 0x1034,
Key_F6 = 0x1035, Key_F7 = 0x1036, Key_F8 = 0x1037, Key_F9 = 0x1038, Key_F10 = 0x1039, Key_F11 =
0x103a, Key_F12 = 0x103b, Key_F13 = 0x103c, Key_F14 = 0x103d, Key_F15 = 0x103e, Key_F16 = 0x103f,
Key_F17 = 0x1040, Key_F18 = 0x1041, Key_F19 = 0x1042, Key_F20 = 0x1043, Key_F21 = 0x1044,
Key_F22 = 0x1045, Key_F23 = 0x1046, Key_F24 = 0x1047, Key_F25 = 0x1048, Key_F26 = 0x1049,
Key_F27 = 0x104a, Key_F28 = 0x104b, Key_F29 = 0x104c, Key_F30 = 0x104d, Key_F31 = 0x104e,
Key_F32 = 0x104f, Key_F33 = 0x1050, Key_F34 = 0x1051, Key_F35 = 0x1052, Key_Super_L = 0x1053,
Key_Super_R = 0x1054, Key_Menu = 0x1055, Key_Hyper_L = 0x1056, Key_Hyper_R = 0x1057, Key_Help =
0x1058, Key_Direction_L = 0x1059, Key_Direction_R = 0x1060, Key_Space = 0x20, Key_Any = Key_Space,
Key_Exclam = 0x21, Key_QuoteDbl = 0x22, Key_NumberSign = 0x23, Key_Dollar = 0x24, Key_Percent =
0x25, Key_Ampersand = 0x26, Key_Apostrophe = 0x27, Key_ParenLeft = 0x28, Key_ParenRight = 0x29,
Key_Asterisk = 0x2a, Key_Plus = 0x2b, Key_Comma = 0x2c, Key_Minus = 0x2d, Key_Period = 0x2e,
Key_Slash = 0x2f, Key_0 = 0x30, Key_1 = 0x31, Key_2 = 0x32, Key_3 = 0x33, Key_4 = 0x34, Key_5 = 0x35,
Key_6 = 0x36, Key_7 = 0x37, Key_8 = 0x38, Key_9 = 0x39, Key_Colon = 0x3a, Key_Semicolon = 0x3b,
Key_Less = 0x3c, Key_Equal = 0x3d, Key_Greater = 0x3e, Key_Question = 0x3f, Key_At = 0x40, Key_A =
0x41, Key_B = 0x42, Key_C = 0x43, Key_D = 0x44, Key_E = 0x45, Key_F = 0x46, Key_G = 0x47, Key_H =
0x48, Key_I = 0x49, Key_J = 0x4a, Key_K = 0x4b, Key_L = 0x4c, Key_M = 0x4d, Key_N = 0x4e, Key_O =
0x4f, Key_P = 0x50, Key_Q = 0x51, Key_R = 0x52, Key_S = 0x53, Key_T = 0x54, Key_U = 0x55, Key_V =
0x56, Key_W = 0x57, Key_X = 0x58, Key_Y = 0x59, Key_Z = 0x5a, Key_BracketLeft = 0x5b, Key_Backslash
= 0x5c, Key_BracketRight = 0x5d, Key_AsciiCircum = 0x5e, Key_Underscore = 0x5f, Key_QuoteLeft = 0x60,
Key_BraceLeft = 0x7b, Key_Bar = 0x7c, Key_BraceRight = 0x7d, Key_AsciiTilde = 0x7e, Key_nobreakspace
= 0x0a0, Key_exclamdown = 0x0a1, Key_cent = 0x0a2, Key_sterling = 0x0a3, Key_currency = 0x0a4,
Key_yen = 0x0a5, Key_brokenbar = 0x0a6, Key_section = 0x0a7, Key_diaeresis = 0x0a8, Key_copyright =
0x0a9, Key_ordfeminine = 0x0aa, Key_guillemotleft = 0x0ab, Key_notsign = 0x0ac, Key_hyphen = 0x0ad,
Key_registered = 0x0ae, Key_macron = 0x0af, Key_degree = 0x0b0, Key_plusminus = 0x0b1,
Key_twosuperior = 0x0b2, Key_threesuperior = 0x0b3, Key_acute = 0x0b4, Key_mu = 0x0b5, Key_paragraph
= 0x0b6, Key_periodcentered = 0x0b7, Key_cedilla = 0x0b8, Key_onesuperior = 0x0b9, Key_masculine =
0x0ba, Key_guillemotright = 0x0bb, Key_onequarter = 0x0bc, Key_onehalf = 0x0bd, Key_threequarters =
0x0be, Key_questiondown = 0x0bf, Key_Agrave = 0x0c0, Key_Aacute = 0x0c1, Key_Acircumflex = 0x0c2,
Key_Atilde = 0x0c3, Key_Adiaeresis = 0x0c4, Key_Aring = 0x0c5, Key_AE = 0x0c6, Key_Ccedilla = 0x0c7,
Key_Egrave = 0x0c8, Key_Eacute = 0x0c9, Key_Ecircumflex = 0x0ca, Key_Ediaeresis = 0x0cb, Key_Igrave =
0x0cc, Key_Iacute = 0x0cd, Key_Icircumflex = 0x0ce, Key_Idiaeresis = 0x0cf, Key_ETH = 0x0d0, Key_Ntilde
= 0x0d1, Key_Ograve = 0x0d2, Key_Oacute = 0x0d3, Key_Ocircumflex = 0x0d4, Key_Otilde = 0x0d5,
Key_Odiaeresis = 0x0d6, Key_multiply = 0x0d7, Key_Ooblique = 0x0d8, Key_Ugrave = 0x0d9, Key_Uacute =
0x0da, Key_Ucircumflex = 0x0db, Key_Udiaeresis = 0x0dc, Key_Yacute = 0x0dd, Key_THORN = 0x0de,
Key_ssharp = 0x0df, Key_agrave = 0x0e0, Key_aacute = 0x0e1, Key_acircumflex = 0x0e2, Key_atilde =
0x0e3, Key_adiaeresis = 0x0e4, Key_aring = 0x0e5, Key_ae = 0x0e6, Key_ccedilla = 0x0e7, Key_egrave =
0x0e8, Key_eacute = 0x0e9, Key_ecircumflex = 0x0ea, Key_ediaeresis = 0x0eb, Key_igrave = 0x0ec,
Key_iacute = 0x0ed, Key_icircumflex = 0x0ee, Key_idiaeresis = 0x0ef, Key_eth = 0x0f0, Key_ntilde = 0x0f1,
Key_ograve = 0x0f2, Key_oacute = 0x0f3, Key_ocircumflex = 0x0f4, Key_otilde = 0x0f5, Key_odiaeresis =
0x0f6, Key_division = 0x0f7, Key_oslash = 0x0f8, Key_ugrave = 0x0f9, Key_uacute = 0x0fa, Key_ucircumflex
= 0x0fb, Key_udiaeresis = 0x0fc, Key_yacute = 0x0fd, Key_thorn = 0x0fe, Key_ydiaeresis = 0x0ff, Key_Back
= 0x1061, Key_Forward = 0x1062, Key_Stop = 0x1063, Key_Refresh = 0x1064, Key_VolumeDown = 0x1070,
Key_VolumeMute = 0x1071, Key_VolumeUp = 0x1072, Key_BassBoost = 0x1073, Key_BassUp = 0x1074,
Key_BassDown = 0x1075, Key_TrebleUp = 0x1076, Key_TrebleDown = 0x1077, Key_MediaPlay = 0x1080,
Key_MediaStop = 0x1081, Key_MediaPrev = 0x1082, Key_MediaNext = 0x1083, Key_MediaRecord =
0x1084, Key_HomePage = 0x1090, Key_Favorites = 0x1091, Key_Search = 0x1092, Key_Standby = 0x1093,
Key_OpenUrl = 0x1094, Key_LaunchMail = 0x10a0, Key_LaunchMedia = 0x10a1, Key_Launch0 = 0x10a2,
Key_Launch1 = 0x10a3, Key_Launch2 = 0x10a4, Key_Launch3 = 0x10a5, Key_Launch4 = 0x10a6,
Key_Launch5 = 0x10a7, Key_Launch6 = 0x10a8, Key_Launch7 = 0x10a9, Key_Launch8 = 0x10aa,
Key_Launch9 = 0x10ab, Key_LaunchA = 0x10ac, Key_LaunchB = 0x10ad, Key_LaunchC = 0x10ae,
Key_LaunchD = 0x10af, Key_LaunchE = 0x10b0, Key_LaunchF = 0x10b1, Key_MediaLast = 0x1fff,
Key_unknown = 0xffff }
Enumeración, que contiene los tipos de flechas.

enum ArrowType { UpArrow, DownArrow, LeftArrow, RightArrow }
Enumeración, que contiene los modos de el dispositivo de pintado

enum RasterOp { CopyROP, OrROP, XorROP, NotAndROP, EraseROP = NotAndROP, NotCopyROP,
NotOrROP, NotXorROP, AndROP, NotEraseROP = AndROP, NotROP, ClearROP, SetROP, NopROP,
AndNotROP, OrNotROP, NandROP, NorROP, LastROP = NorROP }
Enumeración, que contiene los tipos de lápiz

enum PenStyle { NoPen, SolidLine, DashLine, DotLine, DashDotLine, DashDotDotLine, MPenStyle = 0x0f }
Enumeración, que contiene los tipos de forma que usara el lápiz

enum PenCapStyle { FlatCap = 0x00, SquareCap = 0x10, RoundCap = 0x20, MPenCapStyle = 0x30 }
Enumeración, que contiene el estilo de los tipos de lápiz

enum PenJoinStyle { MiterJoin = 0x00, BevelJoin = 0x40, RoundJoin = 0x80, MPenJoinStyle = 0xc0 }
Enumeración, que contiene los tipos de brocha

enum BrushStyle { NoBrush, SolidPattern, Dense1Pattern, Dense2Pattern, Dense3Pattern, Dense4Pattern,
Dense5Pattern, Dense6Pattern, Dense7Pattern, HorPattern, VerPattern, CrossPattern, BDiagPattern,
FDiagPattern, DiagCrossPattern, CustomPattern = 24 }
Enumeración, que contiene el tipo de plataforma MAC que usamos.

enum MacintoshVersion { MV_Unknown = 0x0000, MV_9 = 0x0001, MV_10_DOT_0 = 0x0002,
MV_10_DOT_1 = 0x0003, MV_10_DOT_2 = 0x0004, MV_10_DOT_3 = 0x0005, MV_CHEETAH =
MV_10_DOT_0, MV_PUMA = MV_10_DOT_1, MV_JAGUAR = MV_10_DOT_2, MV_PANTHER =
MV_10_DOT_3 }
Enumeración, que contiene el tipo de plataforma windows que usamos. (que triste)
enum WindowsVersion { WV_32s = 0x0001, WV_95 = 0x0002, WV_98 = 0x0003, WV_Me = 0x0004,
WV_DOS_based = 0x000f, WV_NT = 0x0010, WV_2000 = 0x0020, WV_XP = 0x0030, WV_NT_based =
0x00f0 }
Enumeración, que contiene los efectos de la interfaz gráfica

enum UIEffect { UI_General, UI_AnimateMenu, UI_FadeMenu, UI_AnimateCombo, UI_AnimateTooltip,
UI_FadeTooltip, UI_AnimateToolBox }
Enumeración, que contiene el tipo de puntero. (cursor)

enum CursorShape { ArrowCursor, UpArrowCursor, CrossCursor, WaitCursor, IbeamCursor, SizeVerCursor,
SizeHorCursor, SizeBDiagCursor, SizeFDiagCursor, SizeAllCursor, BlankCursor, SplitVCursor, SplitHCursor,
PointingHandCursor, ForbiddenCursor, WhatsThisCursor, LastCursor = WhatsThisCursor, BitmapCursor = 24
}
Enumeración, que contiene el formato del texto

enum TextFormat { PlainText, RichText, AutoText, LogText }
Enumeración, que contiene el tipo de ancho
enum AnchorAttribute { AnchorName, AnchorHref }
Enumeración, que contiene la posición de la ventana

enum Dock { DockUnmanaged, DockTornOff, DockTop, DockBottom, DockRight, DockLeft, DockMinimized,
Unmanaged = DockUnmanaged, TornOff = DockTornOff, Top = DockTop, Bottom = DockBottom, Right =
DockRight, Left = DockLeft, Minimized = DockMinimized }
Enumeración, que contiene el tipo de fecha

enum DateFormat { TextDate, ISODate, LocalDate }
Enumeración, que contiene el tipo de hora

enum TimeSpec { LocalTime, UTC }
Enumeración, que contiene el modo de fondo

enum BackgroundMode { FixedColor, FixedPixmap, NoBackground, PaletteForeground, PaletteButton,
PaletteLight, PaletteMidlight, PaletteDark, PaletteMid, PaletteText, PaletteBrightText, PaletteBase,
PaletteBackground, PaletteShadow, PaletteHighlight, PaletteHighlightedText, PaletteButtonText, PaletteLink,
PaletteLinkVisited, X11ParentRelative }
Enumeración, que contiene el tipo de comparacion de las cadenas.

enum StringComparisonMode { CaseSensitive = 0x00001, BeginsWith = 0x00002, EndsWith = 0x00004,
Contains = 0x00008, ExactMatch = 0x00010 }
Enumeración, que contiene los bordes de un rectángulo

enum Corner { TopLeft = 0x00000, TopRight = 0x00001, BottomLeft = 0x00002, BottomRight = 0x00003 }
para usar estas enumeraciones y tipos, tenemos que hacerlo de esta manera ej:
QLabel *label =
new QLabel (...);
label-
>setTextFormat (Qt::PlainText);
________________________________________________
Widgets propios de la librería

________________________________________________
Veamos ahora, el padre de la mayoría de los widgets de la librería, el QWidget.
QWidget:
Miembros públicos:
Constructor por defecto:

los argumentos son:
1): QWidget *parent. Es el widget sobre el cual descansara nuestro widget ej this.
2): const char name. Es el nombre que tendrá el widget.
3): WFlags. Es el estilo de widget que queremos construir.
Este parámetro, lo podemos usar para la construcción de ventanas (aunque no es necesario) por ejemplo:
1): Qt::WType_TopLevel , que crea una ventana del tipo TopLevel
2): Qt::WType_Dialog , que crea una ventana del tipo Dialog
3): Qt::WType_Popup , que crea una ventana del tipo PopUp
4): Qt::WType_Desktop , que indica que el widget es el escritorio.
explicit QWidget ( QWidget * parent = 0, const char * name = 0, WFlags f = 0 )
Destructor.
~QWidget ()
Función que retorna el ID de la ventana o el widget.

WId winId () const
Función que retorna el estilo de GUI, (Motif, Motif plus, Marmol, Plastic etc..)
QStyle & style () const
Función que cambia el estilo de GUI, (Motif, Motif plus, Marmol, Plastic etc..)
void setStyle ( QStyle * style )
Función que cambia el estilo de GUI, (Motif, Motif plus, Marmol, Plastic etc..) y retorna un puntero con el
nuevo estilo
QStyle * setStyle ( const QString & style )
Función que retorna TRUE, si el widget es el tipo TopLevel

bool isTopLevel () const
Función que retorna TRUE, si el widget es el tipo Dialog

bool isDialog () const
Función que retorna TRUE, si el widget es el tipo PopUp

bool isPopup () const
Función que retorna TRUE, si el widget es el tipo Desktop (escritorio)

bool isDesktop () const
Función que retorna TRUE, si el widget es modal

bool isModal () const
Función que retorna TRUE, si el widget esta abilitado

bool isEnabled () const
Función que retorna TRUE, si el widget esta abilitado, y el widget antecesor, esta abilitado también
bool isEnabledTo ( QWidget * ancestor ) const
Función que retorna la geometría relativa del widget, incluyendo el frame de la ventana
QRect frameGeometry () const
Función que retorna la geometría relativa del widget, excluyendo el frame de la ventana.
const QRect & geometry () const
Función que retorna la coordenada x (horizontal) del widget dentro del widget antecesor ,incluyendo el frame
de la ventana
int x () const
Función que retorna la coordenada y (vertical) del widget dentro del widget antecesor ,incluyendo el frame de
la ventana
int y () const
Función que retorna un QPoint, conteniendo las coordenadas de la posición del widget
QPoint pos () const
Función que retorna un QSize, conteniendo el tamaño del widget, incluyendo el frame
QSize frameSize () const
Función que retorna un QSize, conteniendo el tamaño del widget, excluyendo el frame
QSize size () const
Función que retorna el ancho del widget, excluyendo el frame.

int width () const
Función que retorna el alto del widget, excluyendo el frame.

int height () const
Función que retorna un QRect con la geometría interna del widget, excluyendo el frame
QRect rect () const
Función que retorna la región combinada dentro del widget.

QRegion childrenRegion () const
Función que retorna el tamaño mínimo del widget

QSize minimumSize () const
Función que retorna el tamaño máximo del widget

QSize maximumSize () const
Función que retorna el ancho mínimo del widget.

int minimumWidth () const
Función que retorna el alto mínimo del widget.

int minimumHeight () const
Función que retorna el ancho máximo del widget.

int maximumWidth () const
Función que retorna el alto máximo del widget.

int maximumHeight () const
Función que establece el tamaño mínimo del widget, a traves de un QSize.

void setMinimumSize ( const QSize & )
Función que establece el tamaño mínimo del widget

virtual void setMinimumSize ( int minw, int minh )
Función que establece el tamaño máximo del widget, a traves de un QSize.

void setMaximumSize ( const QSize & )
Función que establece el tamaño máximo del widget.

virtual void setMaximumSize ( int maxw, int maxh )
Función que establece el ancho mínimo del widget.

void setMinimumWidth ( int minw )
Función que establece el alto mínimo del widget.

void setMinimumHeight ( int minh )
Función que establece el ancho máximo del widget.

void setMaximumWidth ( int maxw )
Función que establece el alto máximo del widget.

void setMaximumHeight ( int maxh )
Función que retorna un QSize, con el tamaño incrementado del widget.

QSize sizeIncrement () const
Función que establece el incremento del widget (lo agranda), a trabes de un QSize
void setSizeIncrement ( const QSize & )
Función que establece el incremento del widget (lo agranda).

virtual void setSizeIncrement ( int w, int h )
Función que retorna un QSize, con el tamaño base del widget.

QSize baseSize () const
Función que establece el tamaño base del widget, a traves de un QSize.

void setBaseSize ( const QSize & )
Función que establece el tamaño base del widget.

void setBaseSize ( int basew, int baseh )
Función que retorna un BackgroundMode, conteniendo el color del fondo del widget.
BackgroundMode backgroundMode () const
Función que cambia el color del fondo del widget.

virtual void setBackgroundMode ( BackgroundMode )
Función que retorna un QColor, conteniendo el color de frente del widget

const QColor & foregroundColor () const
Función que retorna un QColor, con el color de borrado del widget.

const QColor & eraseColor () const
Función que cambia el color de borrado del widget

virtual void setEraseColor ( const QColor & color )
Función que retorna el pixmap de borrado del widget

const QPixmap * erasePixmap () const
Función que cambia el pixmap de borrado del widget

virtual void setErasePixmap ( const QPixmap & pixmap )
Función que retorna un Qpalette, con la paleta de colores usada por el widget
const QPalette & palette () const
Función que cambia la paleta de colores usada por el widget

virtual void setPalette ( const QPalette & )
Función que resetea la paleta de colores usada por el widget

void unsetPalette ()
Función que retorna un QColor, con el color de frente del widget
const QColor & paletteForegroundColor () const
Función que establece el color de frente del widget

void setPaletteForegroundColor ( const QColor & )
Función que retorna un QColor, con el color de fondo del widget

const QColor & paletteBackgroundColor () const
Función que cambia el color de fondo del widget

virtual void setPaletteBackgroundColor ( const QColor & )
Función que retorna un QBrush, conteniendo la brocha usada para dibujar el widget
const QBrush & backgroundBrush () const
Función que retorna un QFont, conteniendo el estilo de fuente usada por el widget.
QFont font () const
Función que cambia el estilo de fuente usada por el widget.

virtual void setFont ( const QFont & )
Función que resetea el estilo de fuente del widget.

void unsetFont ()
Función que retorna un QCursor, conteniendo la imagen del cursor

const QCursor & cursor () const
Función que cambia la imagen del cursor

virtual void setCursor ( const QCursor & )
Función que resetea la imagen del cursor.

virtual void unsetCursor ()
Función que retorna un QString conteniendo el titulo del widget

QString caption () const
Función que retorna un QPixmap conteniendo el icono del widget

const QPixmap * icon () const
Función que retorna TRUE, si el MouseTracking esta abilitado para el widget, si no retorna FALSE.
bool hasMouseTracking () const
Función que causa que solamente los pixeles del widget del ancho del bitmap que correspondan a un bit
sean visibles
virtual void setMask ( const QBitmap & bitmap )
Función que causa que solamente los pixeles del widget del ancho de la región que correspondan a un bit
sean visibles
virtual void setMask ( const QRegion & región )
Función que borra la mascara

void clearMask ()
Enumeracion, que contiene el estilo de foco.

enum FocusPolicy { NoFocus = 0, TabFocus = 0x1, ClickFocus = 0x2, StrongFocus = TabFocus |
ClickFocus | 0x8, WheelFocus = StrongFocus | 0x4 }
Función que retorna TRUE si la ventana esta activa

bool isActiveWindow () const
Función que establece el widget, como ventana activa

virtual void setActiveWindow ()
Función que retorna TRUE, si el foco para el widget, esta abilitado

bool isFocusEnabled () const
Función que retorna un FocusPolicy conteniendo la política del foco.

FocusPolicy focusPolicy () const
Función que establece el la política del foco

virtual void setFocusPolicy ( FocusPolicy )
Función que retorna TRUE, si el widget tiene el foco

bool hasFocus () const
Función que establece que widget tendrá el foco.

virtual void setFocusProxy ( QWidget * w )
Función que retorna un QWidget, conteniendo el widget que tiene el foco actualmente.
QWidget * focusProxy () const
Función que RETORNA true, si las actualizaciones (refrescos) están habilitados.

bool isUpdatesEnabled () const
Función que cierra el widget.

virtual bool close ( bool alsoDelete )
Función que retorna TRUE, si el widget es visible

bool isVisible () const
Función que retorna TRUE, si el widget pasado como argumento es visible

bool isVisibleTo ( QWidget * ancestor ) const
Función que retorna TRUE, si el widget no esta visible

bool isHidden () const
Función que retorna TRUE, si el widget esta visible

bool isShown () const
Función que retorna TRUE, si la ventana esta minimizada

bool isMinimized () const
Función que retorna TRUE, si la ventana esta maximizada

bool isMaximized () const
Función que retorna TRUE, si la ventana esta a pantalla completa

bool isFullScreen () const
Función que retorna el tamaño recomendado para el widget

virtual QSize sizeHint () const
Función que establece el tamaño mínimo recomendado para el widget y retorna un QSize conteniendo este
tamaño
virtual QSize minimumSizeHint () const
Función que actualiza la geometría del widget

void updateGeometry ()
Función que borra el widget entero

void erase ()
void erase ( int x, int y, int w, int h )
void erase ( const QRect & r )
void erase ( const QRegion & reg )
Función que muestra una cadena, en la posición especificada

void drawText ( int x, int y, const QString & str )
Función que muestra una cadena, en la posición especificada por un QPoint

void drawText ( const QPoint & pos, const QString & str )
Función que retorna el widget que contiene el foco

QWidget * focusWidget () const
Función que retorna TRUE, si el widget acepta drops

bool acceptDrops () const
Función que establece si el widget acepta drops

virtual void setAcceptDrops ( bool on )
enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin }

virtual void setBackgroundOrigin ( BackgroundOrigin )
Función que retorna el backgroundOrigin

BackgroundOrigin backgroundOrigin () const
Función que retorna un QWidget, conteniendo el widget padre.

QWidget * parentWidget ( bool sameWindow = FALSE ) const
Slots públicos:
Función, que establece si el widget estará abilitado o no

virtual void setEnabled ( bool )
Función, que establece si los eventos de entrada del widget estarán deshabilitados o no
void setDisabled ( bool disable )
Función, que cambia el titulo de widget (no el nombre)

virtual void setCaption ( const QString & )
Función, que cambia el icono de widget

virtual void setIcon ( const QPixmap & )
Función, que cambia el foco al widget

virtual void setFocus ()
Función, que borra el foco del widget
void clearFocus ()
Función, que establece si el widget es actualizable

virtual void setUpdatesEnabled ( bool enable )
Función, actualiza el widget

void update ()
Función, actualiza una región del widget

void update ( int x, int y, int w, int h )
void update ( const QRect & r )
Función, borra y dibuja el widget entero (es el tipico refresh)

void repaint ()
Función, borra y dibuja el un área del widget si erase es true, no borra el widget
void repaint ( int x, int y, int w, int h, bool erase = TRUE )
void repaint ( const QRect & r, bool erase = TRUE )
void repaint ( const QRegion & reg, bool erase = TRUE )
Función, muestra el widget (usado para las ventanas)

virtual void show ()
Función, oculta el widget (usado para las ventanas)

virtual void hide ()
Función, que establece si el widget puede ser mostrado o no

void setShown ( bool show )
Función, que establece si el widget puede ser ocultado o no

void setHidden ( bool hide )
Función, que muestra el widget minimizado

virtual void showMinimized ()
Función, que muestra el widget maximizado

virtual void showMaximized ()
Función, que muestra el widget a pantalla completa

void showFullScreen ()
Función, que muestra el widget normalmente

virtual void showNormal ()
Función, que cierra el widget

bool close ()
Función, que mueve el widget a la posición x,y

virtual void move ( int x, int y )
Función, que mueve el widget a la traves de un QPoint.

void move ( const QPoint & )
Función, que redimensiona el widget
virtual void resize ( int w, int h )
Función, que redimensiona el widget a traves de un QSize

void resize ( const QSize & )
Función, que cambia la geometría del widget

virtual void setGeometry ( int x, int y, int w, int h )
Función, que cambia la geometría del widget a traves de un QRect

virtual void setGeometry ( const QRect & )
Función, que ajusta el tamaño del widget.

virtual void adjustSize ()
Estos, no son todas las funciones miembro y slots públicos, que contiene esta clase, pero si las más usadas
o necesitadas, no pude ponerlas todas, sencillamente porque no me dan los dedos para teclear tanto.
Explicación sobre las señales y eventos:

En el programa de ejemplo, que realizamos al comienzo de este tutorial, les quede debiendo una explicación
sobre las señales, y creo que ha llegado el momento de explicarlas.
Mostrare un gráfico, en el cual esta representado el tipico esquema de las señales.
Como vemos, no es algo complicado, mostrare un ejemplo como para simplificar un poco las cosas:
ej:
Fichero cabecera.h:
#ifndef CABECERA_H
#define CABECERA_H
#include <qvbox.h>
#include <qstringlist.h>
class QPushButton; //esto es para no tener que poner aqui el archivo de cabecera del widget, (una mentirilla
piadosa para el enlazador)
class QLineEdit;
class CPrincipal : public QVBox //clase derivada de QVBox (para ordenar los widgets dentro de la aplicacion)
{
Q_OBJECT
public:
CPrincipal (QWidget *parent = 0, const char *name = 0); //constructor
public slots: //Funciones de respuesta para las señales de la aplicacion

void GetNombre();
void AlmacenarNombre();
private:
QStringList *lstNombres; //los widgets de la aplicacion

QPushButton *cmd_nombre;
QLineEdit *txt_nombre;
};
#endif
Fichero cabecera.cpp:
/**************** Archivos de cabecera necesarios para la aplicacion***********************/
#include "cabecera.h"
#include <qlabel.h>
#include <qmessagebox.h>
#include <qlineedit.h>
/***************************************************************************************/
CPrincipal::CPrincipal(QWidget *parent, const char *name) //Constructor, aqui es donde se crean e inicializan
los widgets que tendrá la aplicacion
: QVBox(parent,name)
{
/***************************************************************************************/
/*Creo los widgets*/
/***************************************************************************************/
QLabel *titulo = new QLabel(this, "titulo");

lstNombres = new QStringList();
txt_nombre = new QLineEdit(this, "txt_nombre");
cmd_nombre = new QPushButton (this, "cmd_nombre");
QPushButton *cmd_mostrar = new QPushButton (this, "cmd_mostrar");
QPushButton *cmd_salir = new QPushButton(this, "cmd_salir");
/***************************************************************************************/
/*Les asigno las propiedades que tendrán*/
/***************************************************************************************/
titulo->setText("Ingrese su nombre: ");

cmd_salir->setText("Terminar Aplicacion");
cmd_mostrar->setText("Mostrar nombres almacenados");
cmd_nombre->setText("Almacenar nombre");
/***************************************************************************************/
/*Conecto las señales a las que deberán responder*/
/***************************************************************************************/
connect (cmd_nombre, SIGNAL (clicked () ), this, SLOT (AlmacenarNombre () ) );

connect (txt_nombre, SIGNAL (returnPressed()), this, SLOT (AlmacenarNombre() ) );
connect (cmd_mostrar, SIGNAL (clicked() ), this, SLOT (GetNombre()) );
connect (cmd_salir, SIGNAL (clicked() ), this, SLOT (close() ) );
/***************************************************************************************/
/*Estas funciones, son los llamados SLOTS, que definimos para responder a las señales que los widgets
emiten.*/
/***************************************************************************************/
void CPrincipal::GetNombre()
{
for ( QStringList::Iterator it = lstNombres->begin(); it != lstNombres->end(); ++it )
{
QMessageBox::information(this, "Ejemplo 1", *it);
}
}
void CPrincipal::AlmacenarNombre()
{
lstNombres->append(txt_nombre->text() );
txt_nombre->clear();
}
Fichero main.cpp:
#include <qapplication.h> //Si o Si tiene que estar, porque es el esqueleto de toda la aplicacion
int main (int argc , char **argv )
{
QApplication Main(argc, argv); //Inicializo la librería
CPrincipal Form; //creo una instancia de la clase CPrincipal
Form.setCaption("Ejemplo 1"); //sencillamente le cambio el texto al formulario
Form.show(); //lo muestro
/*
le digo a la aplicacion que este sera el widget principal, y que aquí se deberán procesar todos los eventos
*/
Main.setMainWidget(&Form); /
return Main.exec(); //el famosisimo bucle de mensajes (Morite de envidia MSVC++)
}
Espero que no les resulte muy complicado de entender (cosa que no creo), pasemos a explicarlo un poco.
El primer fichero que comenzaremos a explicar sera cabecera.h
en el, definimos dos ficheros de cabecera, los cuales son qvbox.h y qstringlist.h
1): el primero es un widget especial, que nos provee la librería QT, para ordenar de una manera vertical los
widgets de la aplicacion, y el segundo es un widget invisible, ( solamente para uso interno ) que sirve para
crear un array de objetos QString ( widget para las cadenas ). Los métodos y propiedades, ya los explicare a
su tiempo.
2): luego, se ve claramente que creamos dos clases distintas una llamada QPushButton, y otra llamada
QLineEdit, estas clases, no son realmente necesarias, se hace para que el compilador encuentre ese tipo de
dato, y no de error en tiempo de compilación, los ficheros de cabecera de esos widgets, serán implementados
luego en al fichero cabecera.cpp, que es realmente donde se necesitan.
3): Aquí, creamos la clase CPrincipal, que sera la que usaremos a lo largo del programa, esta deriva como
vemos de una clase de la librería QT, que como ya dijimos sirve para alinear los widgets verticalmente.
4): La linea Q_OBJECT, sirve para que la librería QT, identifique la clase, y permita crear "secciones
especiales" para definir funciones de respuesta o crearnos nuestras propias señales, como veremos más
adelante.
5): Como la clase CPrincipal es derivada de la clase QVBox, y esta a su ves de la clase QWidget, deberemos
CASI SIEMPRE crear un constructor de esta manera. El parámetro QWidget *parent = 0, sirve para saber de
donde se deriva la clase, y el parámetro const char *name = 0, es el nombre, que por defecto es 0 (o sea
NULL). Esto es útil, para cuando creamos varias instancias de la clase, y la mayoría de los constructores de
los widgets suelen estar definidos de esta manera, pondré un ejemplo.
QPushButton *boton = new QPushButton ( this , "boton" );

QLineEdit *edit = new QLineedit ( this, "edit" );
QLCDNumber *lcd = new QLCDNumber ( this, "lcd" );
como vemos, this es la clase sobre la cual descansara el widget, y nombre es el nombre de la instancia que
le hemos dado, en realidad this representa otra cosa, pero asumo que eso ya lo saben.
6): La seccion public slots: sirve para poder definir funciones de respuesta para las señales que emitirán los
widgets que tengamos, los parámetros que podemos pasarles a estas funciones TIENEN QUE COINCIDIR
EXACTAMENTE CON LOS PARAMETROS DE LA SEÑAL A LA QUE ATENDERAN. Esto es un requisito
indispensable para que las señales sean atendidas correctamente, si no se cumple este requisito la
aplicacion no funcionara correctamente. Las señales de los distintos widgets, las mostrare más adelante.
7): Luego simplemente creo instancias de los widgets que tendrá la aplicación, notar que no es necesario
definir todos los widgets, sino solamente aquellos a los que llamaremos desde las distintas funciones de
respuesta o funciones internas de la clase (osea aquellos que compartiremos entre las distintas funciones).
Luego de analizar el fichero de cabecera, seguiremos con el fichero de implementación, cabecera.cpp
1): Lo primero que hacemos aqui, es incluir los ficheros de cabecera necesarios para poder utilizar los
distintos widgets de la aplicacion.
2): Luego creamos el constructor que es derivado (en este caso) de la clase QVBox.
3): Lo siguiente que hacemos sera reservar memoria para los widgets e inicializarlos.
4): Acto seguido, les asigno las distintas propiedades que tendrán, en este caso el texto del label y los
botones, notar que el nombre de la propiedad es igual para todos los widget mostrados, pero esta propiedad
es interna de cada widget y no es heredada a traves de la clase QWidget de la cual derivan todos los widgets.
5): Luego conecto las señales que me interesan a las funciones de respuesta que implementaremos más
adelante, los parámetros de la función connect son los siguientes:
connect ( "nombre del widget que queremos conectar", SIGNAL( "el nombre de la señal que queremos
atender" ), "el widget que posee la función de respuesta para esta señal" , SLOT ( "la función de respuesta en
si (definida por nosotros o no)" ) );
la función de respuesta no tiene que ser si o si una función de respuesta, sino que también puede ser una
señal que hayamos implementado o alguna señal interna de algún widget. Mostrare un ejemplo:
connect (&cmd_boton, SIGNAL (clicked() ), &cmd_boton, SIGNAL (pressed() ) );
esto, lanzaría la señal pressed cuando la señal clicked sea emitida.
también podemos definir varias funciones de respuesta para una misma señal, las cuales serán procesadas
en el orden en el que fueron definidas.
6): Ahora solamente creamos las funciones de respuesta como si fueran funciones miembro normales de la
clase, no hay nada especial en esto. Las propiedades y funciones que intervienen en este caso serán
explicadas a lo largo del tutorial (sean pacientes).
Ya explicado la parte más difícil, solo nos resta explicar el fichero main.cpp
1): Lo primero que hacemos es incluir el fichero de cabecera qapplication.h, que es necesario para poder
utilizar la librería, y luego incluimos nuestro fichero de cabecera llamado cabecera.h, en el cual tenemos ya
nuestro widget preparado.
2): La función QApplication, sirve para inicializar la librería, y sin esta no podremos ejecutar el programa.
3): luego creamos una instancia de nuestro widget, definimos el nombre que se vera en la barra de titulo (esta
linea no es necesaria) y lo mostramos .
4): Aquí lo que se hace es "vincular" nuestro widget con la aplicacion y de ese modo, ponerlo como widget
principal, el cual sera el primero que veamos cuando iniciemos la aplicacion.
5): Luego, en en retorno llamo a la función exec de la clase QApplication, para que se encargue de procesar
todos los eventos (señales) que serán emitidos por la aplicacion. (reitero morite de envidia MSVC++).
6): Se acabo la historia.
Para compilar tenemos que abrir una consola e ir dentro del directorio donde están los ficheros de la
aplicacion que queramos crear y tipear qmake -project, esto hace que se cree un fichero de proyecto, el
nombre que tendrá la aplicación sera el mismo que el nombre del directorio, luego tipeamos qmake a secas
para que se cree el fichero Makefile automáticamente, y finalmente typeamos make para compilar.
Espero que no les haya quedado ninguna duda, (sacando la de las propiedades y eventos), pero si no
entendieron algo o simplemente desean preguntar algo relacionado con el tuto, no duden en escribirme a
martin_alganaraz@yahoo.com.ar
Veamos ahora, las propiedades y eventos de los widgets que hemos usado en esta aplicacion,
comenzaremos con el widget más popular o más usado el QPushButton.
El widget QPushButton, es el tipico boton que existe en todas las aplicaciones (al menos las que yo conozco)
QPushButton:
Constructor por defecto:

QPushButton ( QWidget * parent, const char * name = 0 )
Constructor con el texto del boton como argumento.

QPushButton ( const QString & text, QWidget * parent, const char * name = 0 )
Constructor con un icono y el texto que tendrá como argumento.

QPushButton ( const QIconSet & icon, const QString & text, QWidget * parent, const char * name = 0 )
Destructor
~QPushButton ()
Función para crear un boton toogle (se queda presionado si le hacemos click() ).
void setToggleButton ( bool )
Función que retorna TRUE si el boton es un boton por defecto automático

bool autoDefault () const
Función que cambia la propiedad AutoDefault del boton haciendo que no sea un boton automático por
defecto.
virtual void setAutoDefault ( bool autoDef )
Función que retorna TRUE si el boton es un boton por defecto.

bool isDefault () const
Función que cambia el estado del boton haciendo que este sea o no por defecto.
virtual void setDefault ( bool def )
Función que inserta un menú del tipo pop-up (desplegable) en el boton.
void setPopup ( QPopupMenu * popup )
Función que retorna el menú pop-up asociado al boton.

QPopupMenu * popup () const
Función que cambia el icono del boton.

void setIconSet ( const QIconSet & )
Función que retorna el icono del boton.

QIconSet * iconSet () const
Función que hace que el boton sea un boton flotante (sin borde).
void setFlat ( bool )
Función que retorna TRUE, si el boton es un boton flotante.

bool isFlat () const
Función que retorna el texto del boton.

QString text () const
Función que cambia el texto del boton.

virtual void setText ( const QString & )
Función que retorna un pixmap asociado al boton.

const QPixmap * pixmap () const
Función que inserta un pixmap en el boton.

virtual void setPixmap ( const QPixmap & )
Función que retorna una tecla aceleradora (ejemplo Alt+x) asociada al boton.
QKeySequence accel () const
Función que asocia una tecla aceleradora al boton.

virtual void setAccel ( const QKeySequence & )
Función que retorna TRUE si el boton es un boton toogle.

bool isToggleButton () const
Función que deja el boton presionado

virtual void setDown ( bool )
Función que retorna TRUE si el boton esta presionado

bool isDown () const
Función que retorna TRUE si el boton es toogled

bool isOn () const
Función que retorna el estado del boton toogled

ToggleState state () const
Función que retorna TRUE si la propiedad autoRepeat se encuentra activada.

bool autoRepeat () const
Función que emite la señal clicked() del boton varias veces mientras el boton permanezca pulsado, no tiene
efecto si el boton es toogled.
virtual void setAutoRepeat ( bool )
Función que retorna TRUE si el boton es un boton Toogle exclusivo.

bool isExclusiveToggle () const
Función que retorna el ButtonGroup, al cual pertenece el boton.

QButtonGroup * group () const
Función que cambia el estado del boton a toogled.

void toggle ()
Señal que es emitida cuando el boton se encuentra presionado.

void pressed ()
Señal que es emitida cuando se suelta el puntero del mouse dentro de los limites del boton.
void released ()
Señal que es emitida cuando se hace click en el boton.

void clicked ()
Señal que es emitida cuando el boton cambia de estado, si TRUE es pasado como argumento el boton estará
toogled o FALSE en caso contrario.
void toggled ( bool on )
Señal que es emitida cuando el boton cambia de estado toogled o no.

void stateChanged ( int state )
Esta propiedad hace que el boton sea seleccionado por defecto

bool autoDefault - whether the push button is the auto default button
Esta propiedad hace que el boton sea automáticamente enmascarado.

bool autoMask - whether the button is automatically masked (read only)
Esta propiedad hace que el boton sea el por defecto

bool default - whether the push button is the default button
Esta propiedad hace que el boton sea flotante (sin bordes)

bool flat - whether the border is disabled
Esta propiedad establece el icono del boton.

QIconSet iconSet - the icon set on the push button
Esta propiedad hace que si el boton es toogledbutton este pulsado o no

bool on - whether the push button is toggled
Esta propiedad hace que el boton sea un toogledbutton o no

bool toggleButton - whether the button is a toggle button
Continuamos con el Widget QLineEdit, el cual es el tipico cuadro de texto, que también se suele encontrar en
la mayoría de las aplicaciones.
QLineEdit:
QLineEdit ( QWidget * parent, const char * name = 0 )
Constructor con un texto por defecto

QLineEdit ( const QString & contents, QWidget * parent, const char * name = 0 )
Constructor con un texto enmascarado por defecto

QLineEdit ( const QString & contents, const QString & inputMask, QWidget * parent, const char * name = 0 )
Destructor
~QLineEdit ()
Función que retorna el texto.

Función que retorna el largo de la cadena dentro del QLineEdit

int maxLength () const
Función que retorna TRUE si el QLineEdit es frame

bool frame () const
Enumeracion que contiene el modo de enmascaramiento del QLineEdit

enum EchoMode { Normal, NoEcho, Password }
Función que retorna el modo de enmascaramiento actualmente seleccionado

EchoMode echoMode () const
Función que retorna TRUE si el QLineEdit es de solo lectura

bool isReadOnly () const
Función que retorna el validator del QLineEdit

const QValidator * validator () const
Función que retorna el tamaño recomendado para el widget

Función que retorna el tamaño mínimo recomendado para el widget

virtual QSize minimumSizeHint () const
Función que retorna la posición del cursor dentro del QLineEdit. cursor de texto, no mouse :)
int cursorPosition () const
Función que retorna el tipo de alineación que tendrá el texto

int alignment () const
Función que mueve el cursor la cantidad de caracteres contenida en steps, si mark es TRUE, selecciona los
caracteres que estén detrás del cursor
void cursorForward ( bool mark, int steps = 1 )
Función que mueve el cursor la cantidad de caracteres contenida en steps, si mark es TRUE, selecciona los
caracteres que estén delante del cursor
void cursorBackward ( bool mark, int steps = 1 )
Función que hace que si el texto no esta seleccionado borra el carácter que esta a la derecha del cursor, y
mueve el siguiente carácter un carácter más atrás (es el backspace del teclado)
void backspace ()
Función que actúa como la tecla delete o supr del teclado

void del ()
Función que actúa como la tecla home del teclado, si mark es TRUE, selecciona el texto.
void home ( bool mark )
Función que actúa como la tecla fin o end del teclado, si mark es TRUE, selecciona el texto.
void end ( bool mark )
Función que retorna TRUE si el texto contenido en el QLineEdit fue modificado por el usuario.
bool isModified () const
Función que borra las modificaciones echas por el usuario

void clearModified ()
Función que retorna TRUE si el texto esta seleccionado

bool hasSelectedText () const
Función que retorna el texto actualmente seleccionado.

QString selectedText () const
Función que retorna el índice del primer carácter seleccionado

int selectionStart () const
Función que retorna TRUE si esta permitido usar la función undo del QLineEdit.
bool isUndoAvailable () const
Función que retorna TRUE si esta permitido utilizar drag en el QLineEdit

bool dragEnabled () const
Función que retorna el tipo de mascara utilizado

QString inputMask () const
Función que cambia el tipo de mascara utilizado por el QLineEdit.

void setInputMask ( const QString & inputMask )
Función que retorna TRUE si el texto contenido en el QLineEdit satisface la mascara.

bool hasAcceptableInput () const
SLOTS PUBLICOS:
Función que cambia el texto.

Función que selecciona todo el texto

virtual void selectAll ()
Función que deselecciona todo el texto.

virtual void deselect ()
Función que borra el validator del QLineEdit

virtual void clearValidator ()
Función que inserta una nueva cadena dentro del QLineEdit

virtual void insert ( const QString & newText )
Función que borra el texto del QLineEdit

virtual void clear ()
Función que aplica la función undo (desacer) dentro del QLIneEdit (morite de envidia MSVC++)
virtual void undo ()
Función que aplica la función redo (rehacer) dentro del QLIneEdit (morite de envidia MSVC++)
virtual void redo ()
Función que establece el máximo de caracteres que podrá tener el QLineEdit.

virtual void setMaxLength ( int )
Función que pone un frame alrededor del QLineEdit

virtual void setFrame ( bool )
Función que establece si los caracteres contenidos dentro del QLineEdit serán visibles o no (Que tipo de
mascara usara: Normal || NoEcho (oculta los caracteres) || Password (oculta los caracteres tras asteriscos)
virtual void setEchoMode ( EchoMode )
Función que cambia la propiedad de solo lectura a TRUE o FALSE

virtual void setReadOnly ( bool )
Función que cambia el validator para el QLineEdit

virtual void setValidator ( const QValidator * v )
Función que selecciona el texto desde start hasta length

virtual void setSelection ( int start, int length )
Función que cambia la posición del cursor dentro del QLineEdit

virtual void setCursorPosition ( int )
Función que cambia la alineación dentro del QLineEdit, los posibles valores son: Qt::AlignAuto, Qt::AlignLeft,
Qt::AlignRight, Qt::AlignHCenter.
virtual void setAlignment ( int flag )
Función que corta el texto dentro del QLineEdit.

virtual void cut ()
Función que copia el texto dentro del QLineEdit.

virtual void copy () const
Función que pega el texto dentro del QLineEdit.

virtual void paste ()
Función que habilita o no la función Drag del QLineEdit.

virtual void setDragEnabled ( bool b )
Señales:
Señal emitida cuando la cadena contenida dentro del QLineEdit es cambiada

void textChanged ( const QString & )
Señal emitida cuando la tecla enter return o intro es presionada.

void returnPressed ()
Señal emitida cuando el widget pierde el foco.

void lostFocus ()
Señal emitida cuando la seleccion del texto dentro del QLineEdit cambia.
void selectionChanged ()
Continuemos ahora, con el widget QMessageBox, que es el tipico cuadro de dialogo de toda aplicación.
QMessageBox:
Enumeracion que contiene el tipo de icono que tendrá el cuadro de dialogo
enum Icon { NoIcon = 0, Information = 1, Warning = 2, Critical = 3, Question = 4 }

QMessageBox ( QWidget * parent = 0, const char * name = 0 )
Constructor con el titulo, el texto, el icono, la cantidad de botones que tendrá, si es modal o no, y el borde.
QMessageBox ( const QString & caption, const QString & text, Icon icon, int button0, int button1, int button2,
QWidget * parent = 0, const char * name = 0, bool modal = TRUE, WFlags f = WStyle_DialogBorder )
Destructor
~QMessageBox ()
Función que retorna el texto del QMessageBox.

Función que cambia el texto del QMessageBox.

void setText ( const QString & )
Función que retorna el icono del QMessageBox.

Icon icon () const
Función que cambia el icono del QMessageBox.

void setIcon ( Icon )
Función que retorna el pixmap del QMessageBox.

const QPixmap * iconPixmap () const
Función que cambia el icono del QMessageBox.

void setIconPixmap ( const QPixmap & )
Función que retorna el texto de un boton pasado como argumento.

QString buttonText ( int button ) const
Función que cambia el texto del boton pasado como argumento

void setButtonText ( int button, const QString & text )
Función que ajusta el tamaño del QMessageBox al texto contenido.

virtual void adjustSize ()
Función que retorna el formato del texto contenido dentro del QMessageBox.
TextFormat textFormat () const
Función que cambia el formato del texto contenido dentro del QMessageBox.
void setTextFormat ( TextFormat )
Tipos de cuadros de dialogo:
int information ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1 = 0,
int button2 = 0 )
int information ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text
= QString::null, const QString & button1Text = QString::null, const QString & button2Text = QString::null,
int defaultButtonNumber = 0, int escapeButtonNumber = -1 )
int question ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1 = 0,
int button2 = 0 )
int question ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text =
QString::null, const QString & button1Text = QString::null, const QString & button2Text = QString::null,
int warning ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1,
int button2 = 0 )
int warning ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text =
int critical ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1,
int button2 = 0 )
int critical ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text =
void about ( QWidget * parent, const QString & caption, const QString & text )
void aboutQt ( QWidget * parent, const QString & caption = QString::null )
QPixmap standardIcon ( Icon icon )
Ejemplo de uso:
Cuadro de dialogo tipo = información:

QMessageBox::information(this, "Nombre de la aplicacion", "Mensaje del cuadro de dialogo");
Cuadro de dialogo tipo = pregunta:

QMessageBox::question(this,"Nombre de la aplicacion", "Aquí realizo la pregunta", "Si", "No", "default", 0,1);
Cuadro de dialogo tipo = advertencia:

QMessagebox::warning (this, "Nombre de la aplicacion", "Aquí relizo el aviso",QMessageBox::Retry |
QMessageBox::Default , QMessageBox::Abort | QMessageBox::Escape)
Cuadro de dialogo tipo = Error:

QMessagebox::critical (this, "Nombre de la aplicacion", "Aquí DETALLO el error");
Cuadro de dialogo tipo = ayuda:
QMessagebox::about (this, "Nombre de la aplicacion", "Aquí pongo los datos de la aplicacion.");
QMessageBox mensaje ( "Nombre de la aplicacion", "Mensaje que se quiera hacer",

QMessageBox::Information,
QMessageBox::Yes | QMessageBox::Default,
QMessageBox::No,
QMessageBox::Cancel | QMessageBox::Escape );
mb.setButtonText (QMessageBox::Yes, "texto para el boton yes");

mb.setButtonText (QMessageBox::No, "texto para el boton no");
switch ( mb.exec() )
{
case QMessageBox::Yes:
//acciones
break;
case QMessageBox::No:
//acciones
break;
case QMessageBox::Cancel:
//acciones
break;
}
Y llegamos al ultimo widget usado en nuestra aplicacion, aunque no es un widget en realidad, (el objeto
QStringList es un tipo de dato propio de la librería QT).
QStringList:
QStringList ()
Constructor copia
QStringList ( const QStringList & l )
Constructor con un QValueList como argumento

QStringList ( const QValueList<QString> & l )
Constructor con un QString como argumento

QStringList ( const QString & i )
Constructor con un const char * como argumento

QStringList ( const char * i )
Función que ordena la lista.

void sort ()
Función que retorna un elemento de la lista

QString join ( const QString & sep ) const
Función que busca y retorna un elemento de la lista

QStringList grep ( const QString & str, bool cs = TRUE ) const
Función que busca y retorna un elemento de la lista según una expresión regular
QStringList grep ( const QRegExp & rx ) const
Función que busca y cambia una cadena o carácter en la lista reemplazándolo por otro pasado como
argumento.
QStringList & gres ( const QString & before, const QString & after, bool cs = TRUE )
Función que busca y cambia una cadena o carácter en la lista que coincida con una expresión regular
remplazándolo por otro pasado como argumento.
QStringList & gres ( const QRegExp & rx, const QString & after )
Función que convierte una lista de caracteres ascii (QStrList) a una QStringList (unicode)
QStringList fromStrList ( const QStrList & ascii )
Bueno, parece que terminamos con las propiedades y los métodos, aunque faltan algunos, (que no los pude
incluir por falta de tiempo), la gran mayoría y los más utilizados se encuentran traducidos. Mostrare el resto
de los widgets más adelante.
Veamos un ejemplo más, un poquito más avanzado, y veremos otro widget bastante útil el QTable, para
estudiarlo después.
Ejemplo 2:
Fichero cabecera.h
#ifndef CABECERA_H
#define CABECERA_H
#include <qvbox.h>
class QPushButton;
class QLineEdit;
class QTable;
class CPrincipal : public QVBox

{
Q_OBJECT
public:
public slots: //funciones de respuesta a las señales que emiten los widgets
void GetNombre();
private:
QStringList *lstNombres; //los widget que tendrá la aplicacion
QTable *rejilla;
};
#endif
Fichero cabecera.cpp:
#include <qlabel.h>
#include <qtable.h>
#include <qheader.h>
CPrincipal::CPrincipal(QWidget *parent, const char *name)

{

/**************************************************************************/
/*Creo los widgets de la aplicacion*/
/**************************************************************************/
rejilla = new QTable(this,"rejilla");
QHeader *cabecera = rejilla->horizontalHeader();
/**************************************************************************/
/**************************************************************************/
/* Los preparo*/
/**************************************************************************/
rejilla->setNumCols(1);
rejilla->setNumRows(0);
cabecera->setLabel(0,"Nombres almacenados",180);
cabecera->setResizeEnabled(FALSE,0);
this->setMinimumSize(500,500);
this->setMaximumSize(1000,1000);
/**************************************************************************/
/**************************************************************************/
/*conecto sus señales */
/**************************************************************************/
/**************************************************************************/
}
{
int i = 0;
if (rejilla->numRows() != static_cast<int> (lstNombres->count()) )

rejilla->setNumRows(lstNombres->count());

{
rejilla->setItem( i-1 , 1,
new QTableItem (rejilla, QTableItem::Never,
*it ) );
i++;
}
}
{
}
Fichero main.cpp:
int main(int argc, char **argv)

{
QApplication Main(argc,argv);
CPrincipal programa;
programa.setCaption("Ejemplo 2");
Main.setMainWidget(&programa);
programa.show();
return Main.exec();
}
Como verán se trata del primer ejemplo de este tutorial, pero levemente modificado (tuneado como dirían en
mi barrio).
Pasemos a explicarlo, solamente explicare las nuevas características:
1): En el fichero de cabecera (cabecera.h) agregamos una definición de la clase QTable (para engañar al
enlazador) y definimos un nuevo objeto llamado rejilla, del tipo QTable. Hasta aqui nada nuevo.
2): El segundo fichero que analizaremos sera cabecera.cpp.
Primero, incluimos 2 ficheros de cabecera, llamados qtable.h, que contiene la definición de la clase QTable y
el otro llamado qheader.h, que contiene la definición de la clase QHeader necesaria para poder manejar las
celdas que sean fixed, o sea las que contienen un titulo y sirven para mostrar información sobre una
determinada columna o fila.
Luego creamos la rejilla usando un constructor por defecto de la siguiente manera:

rejilla = new QTable( this, "rejilla" );
Y acto seguido creamos un objeto de la clase QHeader de la siguiente manera:

QHeader *cabecera = Qtable->horizontalHeader();
la diferencia de esta clase de widgets, es que utiliza como constructor una función miembro de otros widgets,
en este caso horizontalHeader() de la clase QTable, pero también pudo haber sido verticalHeader(), también
de la clase QTable.
Después de unas lineas, vemos que al objeto rejilla y cabecera les asignamos algunas propiedades.
Otras lineas que resaltan, son las siguientes:

this->setMinimumSize ( 500 , 500 );
this->setMaximumSize ( 1000 , 1000 );
Estas lineas, lo que hacen es establecer algunas propiedades de la clase en si, (el tamaño mínimo y máximo
que tendrá nuestro widget en cuestion) y como verán no fueron definidas por nosotros, ya que al ser nuestro
widget (CPrincipal) derivado de la clase QWidget, este las hereda de forma automática.
Una ves visto el constructor, pasemos a ver la función de respuesta GetNombre() definida por nosotros.
Sin duda de todo el código, la linea que más resalta es:

rejilla->setItem ( i-1 , 1 , new QTableItem (rejilla, QTableItem::Never, *it ) );
en la cual nos damos cuenta, de que creamos y a la ves asignamos un nuevo ítem a la tabla de manera
automática.
Expliquemos este proceso:
1): La función mimbro setItem, de la tabla lo que hace (como se habrán dado cuenta) es asignar un nuevo
ítem a la tabla en la fila y columna especificadas.
2): Como vemos el fichero de cabecera de QTableItem no aparece por ningún lado, y esto es así porque este
widget, esta incluido en el fichero de cabecera qtable.h, ya que se trata de un widget especial de la clase
QTable, el cual se encarga de asignar nuevos items a la tabla. Sus parámetros son los siguientes:
El parámetro rejilla (como se habrán dado cuenta) es el widget al que hará referencia (sobre el cual va a
trabajar).
El parámetro QTableItem::Never lo que hace es decirle a la tabla, que los items no podrán ser modificados,
también podríamos haber seleccionado QTableItem::Always, que es para que los ítem de la tabla puedan ser
modificados a gusto, o QTableItem::WhenCurrent, que sirve para que los items puedan ser modificados,
solamente si el foco del teclado esta sobre ellos, y el ultimo es QTableItem::OnTyping, que sirve para que el
ítem pueda ser modificado solamente si se hace doble-click sobre el.
El resto del código, no lo explicare, porque creo que no merece la pena, solo basta con decir que los
iteradores no son algo exclusivo de la librería QT, sino que es algo propio de la STL, la cual es un requisito
comprender para leer y entender este tuto.
QTable:
QTable ( QWidget * parent = 0, const char * name = 0 )
Constructor con el numero de filas y columnas como argumento

QTable ( int numRows, int numCols, QWidget * parent = 0, const char * name = 0 )
Destructor
~QTable ()
Función que retorna un QHeader, conteniendo datos de la cabecera horizontal de la tabla

QHeader * horizontalHeader () const
Función que retorna un QHeader, conteniendo datos de la cabecera vertical de la tabla

QHeader * verticalHeader () const
Enumeracion, que contiene el tipo de seleccion que soportara la tabla

enum SelectionMode { Single, Multi, SingleRow, MultiRow, NoSelection }
Función que cambia el tipo de seleccion que soportara la tabla

virtual void setSelectionMode ( SelectionMode mode )
Función que retorna una enumeración con el tipo de seleccion usado actualmente
SelectionMode selectionMode () const
Función que agrega un QTableItem (ítem) en la tabla, en la fila y la columna especificadas.

virtual void setItem ( int row, int col, QTableItem * ítem )
Función que agrega un texto en la tabla, en la fila y la columna especificadas.

virtual void setText ( int row, int col, const QString & text )
Función que agrega una imagen en la tabla, en la fila y la columna especificadas.

virtual void setPixmap ( int row, int col, const QPixmap & pix )
Función que retorna un QTableItem, con el ítem en la fila y columna especificadas.

virtual QTableItem * ítem ( int row, int col ) const
Función que retorna el texto en la fila y columna especificadas.

virtual QString text ( int row, int col ) const
Función que retorna un QPixmap con la imagen en la fila y columna especificadas.

virtual QPixmap pixmap ( int row, int col ) const
Función que borra el contenido de la fila y la columna especificada

virtual void clearCell ( int row, int col )
Función que retorna un QRect con la geometría de una celda, en la fila y la columna especificada
virtual QRect cellGeometry ( int row, int col ) const
Función que retorna un entero con el ancho de la columna especificada

virtual int columnWidth ( int col ) const
Función que retorna un entero con el alto de la fila especificada

virtual int rowHeight ( int row ) const
Función que retorna un entero con la coordenada X de la columna pasada como argumento
virtual int columnPos ( int col ) const
Función que retorna un entero con la coordenada Y de la columna pasada como argumento
virtual int rowPos ( int row ) const
Función que retorna un entero con el numero de columna en la coordenada X

virtual int columnAt ( int x ) const
Función que retorna un entero con el numero de fila en la coordenada Y

virtual int rowAt ( int y ) const
Función que retorna un entero con el numero de filas en la tabla.

virtual int numRows () const
Función que retorna un entero con el numero de columnas en la tabla.

virtual int numCols () const
Función que refresca el dato en la fila y la columna especificada

void updateCell ( int row, int col )
Función que retorna un entero, con el numero de fila donde estamos actualmente posicionados
int currentRow () const
Función que retorna un entero, con el numero de columna donde estamos actualmente posicionados
int currentColumn () const
Función que retorna TRUE si la fila y la columna pasadas como argumento se encuentran actualmente
seleccionadas.
bool isSelected ( int row, int col ) const
Función que retorna TRUE si la fila se encuentra actualmente seleccionada

bool isRowSelected ( int row, bool full = FALSE ) const
Función que retorna TRUE si la columna se encuentra actualmente seleccionada

bool isColumnSelected ( int col, bool full = FALSE ) const
Función que retorna un entero con el numero de celdas seleccionadas

int numSelections () const
Función que remueve una seleccion.

virtual void removeSelection ( int num )
Función que retorna un entero con la seleccion actual

virtual int currentSelection () const
Función que selecciona un rango de celdas

void selectCells ( int start_row, int start_col, int end_row, int end_col )
Función que selecciona un fila.

void selectRow ( int row )
Función que selecciona un columna
void selectColumn ( int col )
Función que retorna TRUE, si la rejilla (las celdas) están visibles o FALSE en caso contrario
bool showGrid () const
Función que retorna TRUE, si las columnas pueden ser movidas por el usuario.
bool columnMovingEnabled () const
Función que retorna TRUE, si las filas pueden ser movidas por el usuario.
bool rowMovingEnabled () const
Función que ordena las columnas.

virtual void sortColumn ( int col, bool ascending = TRUE, bool wholeRows = FALSE )
Función que retorna TRUE, si cuando se le hace click en la cabecera de la columna, se selecciona toda la
columna, si no retorna FALSE.
bool sorting () const
Función que sirve para mover un ítem, (sin borrarlo) indicado por el parámetro QTableItem de un lugar a otro,
puede ser a otra celda o a otra tabla.
virtual void takeItem ( QTableItem * i )
Función que agrega un QWIDGET (o sea cualquier widget!!!!) dentro de una celda en la tabla. jeje
virtual void setCellWidget ( int row, int col, QWidget * e )
Función que retorna un QWidget, con el widget en la celda especificada

virtual QWidget * cellWidget ( int row, int col ) const
Función que borra un objeto QWidget en la celda especificada

virtual void clearCellWidget ( int row, int col )
Función que retorna un QRect, con el tamaño de la celda pasada como argumento.
virtual QRect cellRect ( int row, int col ) const
Esta función, y como pintar lo explicare un un segundo tutorial, puesto que el Canvas de QT es más que
complejo.
virtual void paintCell ( QPainter * p, int row, int col, const QRect & cr, bool selected )
complejo.
virtual void paintCell ( QPainter * p, int row, int col, const QRect & cr, bool selected,
complejo.
const QColorGroup & cg )
complejo.
virtual void paintFocus ( QPainter * p, const QRect & cr )
Función que retorna TRUE, si la tabla es de solo lectura

bool isReadOnly () const
Función que retorna TRUE, si la fila es de solo lectura
bool isRowReadOnly ( int row ) const
Función que retorna TRUE, si la columna es de solo lectura

bool isColumnReadOnly ( int col ) const
Función que redibuja (refresh) la seleccion

void repaintSelections ()
Enumeracion que contiene el estilo de foco.

enum FocusStyle { FollowStyle, SpreadSheet }
Función que cambia el tipo de foco

virtual void setFocusStyle ( FocusStyle fs )
Función que retorna el tipo de foco actualmente usado por la tabla.

FocusStyle focusStyle () const
Función que actualiza los encabezados de la tabla, y los sincroniza con la seleccion actual.
void updateHeaderStates ()
Slots:
Función que cambia el numero de filas en la tabla.

virtual void setNumRows ( int r )
Función que cambia el numero de columnas en la tabla.

virtual void setNumCols ( int r )
Función que establece si rejilla (las filas y las columnas) serán visibles o no
virtual void setShowGrid ( bool b )
Función que esconde una fila.

virtual void hideRow ( int row )
Función que esconde una columna.

virtual void hideColumn ( int col )
Función que muestra una fila.

virtual void showRow ( int row )
Función que muestra una columna.

virtual void showColumn ( int col )
Función que cambia el ancho de la columna

virtual void setColumnWidth ( int col, int w )
Función que cambia el alto de una fila

virtual void setRowHeight ( int row, int h )
Función que ajusta el tamaño de la columna, al contenido de la misma

virtual void adjustColumn ( int col )
Función que ajusta el tamaño de una fila, al contenido de la misma.
virtual void adjustRow ( int row )
Función que establece si la columna puede ser redimencionada por el usuario

virtual void setColumnStretchable ( int col, bool stretch )
Función que establece si la fila puede ser redimencionada por el usuario

virtual void setRowStretchable ( int row, bool stretch )
Función que retorna TRUE si la columna puede ser redimencionada por el usuario
bool isColumnStretchable ( int col ) const
Funcion que retorna TRUE si la fila puede ser redimencionada por el usuario
bool isRowStretchable ( int row ) const
Funcion que establece si los datos seran ordenados o no

virtual void setSorting ( bool b )
Funcion que combina los datos de las filas 1 y 2 (pasadas como argumento)
virtual void swapRows ( int row1, int row2, bool swapHeader = FALSE )
Funcion que combina los datos de las columnas 1 y 2 (pasadas como argumento)
virtual void swapColumns ( int col1, int col2, bool swapHeader = FALSE )
Funcion que combina los datos de las celdas 1 y 2 (pasadas como argumento)
virtual void swapCells ( int row1, int col1, int row2, int col2 )
Funcion que cambia el tamaño del margen derecho en m pixeles

virtual void setLeftMargin ( int m )
Funcion que cambia el tamaño del margen superior en m pixeles

virtual void setTopMargin ( int m )
Funcion que posiciona el cursor en la celda especificada

virtual void setCurrentCell ( int row, int col )
Funcion que borra la seleccion actual

void clearSelection ( bool repaint = TRUE )
Funcion que establecce si la columna se podra mover o no

virtual void setColumnMovingEnabled ( bool b )
Funcion que establece si la fila se podra mover o no

virtual void setRowMovingEnabled ( bool b )
Funcion que establecce si la tabla sera de solo lectura o no

virtual void setReadOnly ( bool b )
Funcion que establecce si la fila sera de solo lectura o no

virtual void setRowReadOnly ( int row, bool ro )
Funcion que establecce si la columna sera de solo lectura o no

virtual void setColumnReadOnly ( int col, bool ro )
Funcion que establecce si sera soportado el draganddrop (si llego lo explico)
virtual void setDragEnabled ( bool b )
Funcion que retorna TRUE, si el draganddrop esta soportado por la tabla.

bool dragEnabled () const
Funcion que inserta filas en la posicion indicada (no recomendable)

virtual void insertRows ( int row, int count = 1 )
Funcion que inserta columnas en la posicion indicada (no recomendable)

virtual void insertColumns ( int col, int count = 1 )
Funcion que remueve filas

virtual void removeRow ( int row )
Funcion que remueve filas segun el QMemArray pasado como argumento.

virtual void removeRows ( const QMemArray<int> & rows )
Funcion que remueve columnas.

virtual void removeColumn ( int col )
Funcion que remueve columnas segun el QMemArray pasado como argumento.

virtual void removeColumns ( const QMemArray<int> & cols )
Funcion que establece, que se comience la edicion en la celda especificada, si replace es TRUE, el dato que
haya previamente sera borrado
virtual void editCell ( int row, int col, bool replace = FALSE )
Funcion que cambia la los labels del VerticalHeader (ya lo explicare)

void setRowLabels ( const QStringList & labels )
Funcion que cambia la los labels del HorizontalHerader (ya lo explicare)

void setColumnLabels ( const QStringList & labels )
Señales:
Señal que se lanza cuando se cambia de celda

void currentChanged ( int row, int col )
Señal que se lanza cuando se hace click en una celda

void clicked ( int row, int col, int button, const QPoint & mousePos )
Señal que se lanza cuando se hace dobleclick en una celda

void doubleClicked ( int row, int col, int button, const QPoint & mousePos )
Señal que se lanza cuando se hace presiona un boton en una celda

void pressed ( int row, int col, int button, const QPoint & mousePos )
Señal que se lanza cuando se cambia la seleccion

void selectionChanged ()
Señal que se lanza cuando se cambia el valor del dato contenido en una celda
void valueChanged ( int row, int col )
Señal que se lanza cuando se despliega un menu contextual (ya lo veremos)

void contextMenuRequested ( int row, int col, const QPoint & pos )
Señal que se lanza cuando se hace un drag and drop

void dropped ( QDropEvent * e )
QHeader
Constructor por defecto.

QHeader ( QWidget * parent = 0, const char * name = 0 )
Constructor que construye un encabezado Horizontal con N secciones.

QHeader ( int n, QWidget * parent = 0, const char * name = 0 )
Destructor
~QHeader ()
Funcion que añade una nueva seccion con el nombre pasado como argumento y retorna un entero con la
posicion de la nueva seccion para agregarla a la tabla.
int addLabel ( const QString & s, int size = -1 )
Funcion que añade una nueva seccion con el nombre y el icono pasado como argumento y retorna un entero
con la posicion de la nueva seccion para agregarla a la tabla.
int addLabel ( const QIconSet & iconset, const QString & s, int size = -1 )
Funcion que remueve una seccion.

void removeLabel ( int section )
Funcion que cambia el texto de la seccion pasada como argumento

virtual void setLabel ( int section, const QString & s, int size = -1 )
Funcion que cambia el texto y el icono de la seccion pasada como argumento

virtual void setLabel ( int section, const QIconSet & iconset, const QString & s, int size = -1 )
Funcion que retorna el texto de la seccion pasada como argumento

QString label ( int section ) const
Funcion que retorna el icono de la seccion pasada como argumento

QIconSet * iconSet ( int section ) const
Funcion que cambia la horientacion en la tabla (Horizontal o Vertical)

virtual void setOrientation ( Orientation )
Funcion que retorna el tipo de horientacion.

Orientation orientation () const
Funcion que establece si de debe procesar la señal clicked de la tabla, si enable es FALSE, no le dara pelota.
virtual void setClickEnabled ( bool enable, int section = -1 )
Funcion que establece si de debe procesar la señal clicked de la tabla, si enable es FALSE, no le dara pelota.
Funcion que redimenciona el tamaño de una seccion.

void resizeSection ( int section, int s )
Funcion que retorna el tamaño de una seccion.

int sectionSize ( int section ) const
Funcion que retorna la posicion de una seccion.

int sectionPos ( int section ) const
Funcion que retorna el numero de secciones que hay

int count () const
Funcion que retorna el ancho.

int headerWidth () const
Funcion que retorna unQRect, con el ancho de una seccion pasada como argumento
QRect sectionRect ( int section ) const
Funcion que mueve una seccion al indice especificado

void moveSection ( int section, int toIndex )
Funcion que ajusta el tamaño del QHeader, al contenido de las secciones.

void adjustHeaderSize ()
Slots:
Funcion que se ejecuta cuando se cambia a otra posicion.

virtual void setOffset ( int pos )
Señales:
Esto me parece que ya no tiene sentido explicarlo, porque parece bastante autoexplicativo.
void clicked ( int section )

void pressed ( int section )
void released ( int section )
void sizeChange ( int section, int oldSize, int newSize )
void indexChange ( int section, int fromIndex, int toIndex )
void sectionHandleDoubleClicked ( int section )
Combinar varios formularios en nuestra aplicacion:
Veamos ahora un ejemplo un poco màs completo, de como podemos combinar varios formularios en
nuestras aplicaciones, y compartir los widgets entre ellos.
ejemplo:
cabecera.h
#ifndef CABECERA_H
#define CABECERA_H
#include <qvbox.h>
class QPushButton;
class QLineEdit;
class QTable;
class QComboBox;
class QFileDialog;
class CDatos : public QVBox

{
Q_OBJECT
public:
CDatos(QWidget *parent = 0, const char *name = 0);
friend class CPrincipal;

public slots:
void AgregarDato();
void SalvarEnFichero();
private:
QComboBox *cmb_nombres;
QPushButton *cmd_seleccionar;
QPushButton *cmd_salvar;
QFileDialog *archivo;
QTable *tabla;
QStringList *lstNombres;
int indice;
};
class CPrincipal : public QVBox

{
Q_OBJECT
public:
public slots: //funciones de respuesta a las seniales que emiten los widgets
void GetNombre();
void EnviarDatos(int,int,int, const QPoint &);
protected:
QStringList *lstNombres; //los widget que tendra la aplicacion
QStringList *lstAlmacena;
QPushButton *cmd_salvarDatos;
QTable *rejilla;
CDatos *frm_datos;
};
#endif
cabecera.cpp
#include <qlabel.h>
#include <qtable.h>
#include <qcombobox.h>
#include <qgrid.h>
#include <qfiledialog.h>
#include <qfile.h>
#include <qtextstream.h>
CPrincipal::CPrincipal(QWidget *parent, const char *name)

{


lstAlmacena = new QStringList();
/**************************************************************************/
/*Creo los widgets de la aplicacion*/
/**************************************************************************/
cmd_salvarDatos = new QPushButton(this, "cmd_salvarDatos");
rejilla = new QTable(this,"rejilla");
QHeader *cabecera = rejilla->horizontalHeader();
frm_datos = new CDatos();
/**************************************************************************/
/**************************************************************************/
/* Les asigno las propiedades*/
/**************************************************************************/
cmd_salvarDatos->setText("Salvar los datos");
rejilla->setNumCols(1);
rejilla->setNumRows(0);
cabecera->setLabel(0,"Nombres almacenados",180);
cabecera->setResizeEnabled(FALSE,0);
this->setMinimumSize(500,500);
this->setMaximumSize(1000,1000);
/**************************************************************************/
/**************************************************************************/
/*conecto sus seniales */
/**************************************************************************/
connect (cmd_salvarDatos, SIGNAL (clicked() ), frm_datos, SLOT (show() ) );
connect (rejilla , SIGNAL (doubleClicked ( int ,int , int , const QPoint & ) ) , this , SLOT ( EnviarDatos ( int , int ,
int , const QPoint & ) ) );
/**************************************************************************/
}
{
int i = 0;
if (rejilla->numRows() != static_cast<int> (lstNombres->count()) )

rejilla->setNumRows(lstNombres->count());

{
rejilla->setItem( i-1 , 1,
new QTableItem (rejilla, QTableItem::Never,
*it ) );
i++;
}
}
{
}
void CPrincipal::EnviarDatos(int row,int col,int boton,const QPoint &mousePosicion)

{
QString dato = rejilla->text(row,col);

for (QStringList::Iterator it = lstAlmacena->begin(); it != lstAlmacena->end(); it ++)
if ( *it == dato ) return;
lstAlmacena->append(dato);
frm_datos->indice++;
if (frm_datos->isShown() )
{
frm_datos->cmb_nombres->clear();
frm_datos->cmb_nombres->insertStringList(*lstAlmacena);
}
}
/************************************************************************************************/
/*Implementacion de la clase CDatos*/
/************************************************************************************************/
CDatos::CDatos ( QWidget *parent, const char *name ) : QVBox ( parent , name )

{
/****************************Creo los objetos *************************************/

QGrid *rejilla = new QGrid ( 3 , this , "rejilla");
QLabel *titulo = new QLabel(rejilla, "titulo");
cmb_nombres = new QComboBox(rejilla, "cmb_nombres");
cmd_seleccionar = new QPushButton (rejilla, "cmd_seleccionar");
tabla = new QTable (rejilla, "tabla");
QHeader *cabecera = tabla->horizontalHeader();
cmd_salvar = new QPushButton (rejilla, "cmd_salvar");
QPushButton *cerrar = new QPushButton (rejilla, "cerrar");
/****************************Les asigno sus propiedades ***************************/
titulo->setText("Nombres seleccionados");
cmd_seleccionar->setText("Seleccionar item");
tabla->setNumCols(1);
tabla->setNumRows(1);
cabecera->setLabel( 1 , "Nombres" , 100 );
cmd_salvar->setText("Salvar en archivo");
cerrar->setText("Cerrar");
cmb_nombres->setEditable(TRUE);
indice = 0;
/*****************************Conecto sus seniales*************************************/
connect (cmd_seleccionar, SIGNAL (clicked() ), this , SLOT (AgregarDato () ) );

connect (cmd_salvar, SIGNAL (clicked() ), this, SLOT (SalvarEnFichero () ) );
//un viejo truco de las QT, que todavia funciona
QLineEdit *edit = cmb_nombres->lineEdit();
connect (edit, SIGNAL (returnPressed() ), this, SLOT (AgregarDato () ) );
connect (cerrar, SIGNAL (clicked() ), this , SLOT (close() ) );
void CDatos::AgregarDato()
{
QString dato = cmb_nombres->currentText();
lstNombres->append(dato);
QStringList::Iterator it = lstNombres->begin();
if (indice >= static_cast<unsigned int> (tabla->numRows() )) tabla->insertRows (1);
for ( unsigned int i = 0; i <= indice; i++ )
{
tabla->setItem ( i-1 , 1 , new QTableItem ( tabla , QTableItem::Never , *it ) );
it++;
}
}
void CDatos::SalvarEnFichero()
{
archivo = new QFileDialog(this);
QStringList *lstSalvar = new QStringList();
archivo->addFilter ( "Archivo de nombres (*.nom *.nombre)" );
archivo->show();
QFile dat ( archivo->selectedFile () );
if (dat.open ( IO_Append ) )
{
QTextStream stream (&dat);
for (unsigned int i = 0; i <= static_cast<unsigned int> (tabla->numRows()) -1; i++ )
{
QString cade = tabla->text(i,1);
lstSalvar->append(cade);
}
for ( QStringList::Iterator it = lstSalvar->begin(); it != lstSalvar->end(); it++ )
stream <<"Nombre: " << *it << endl;
}
dat.close();
}
Bueno, espero no haberme excedido con el codigo, el archivo main.cpp, no lo muestro simplemente porque
no ha sido modificado.
En el codigo anterior hay algunos bugs, que luego iremos depurando una vez que mostremos los widgets que
intervienen en el codigo, y lo hayamos estudiado.
Comenzaremos viendo el widget QLabel.h, que sirve para mostrar una etiqueta de texto en la pantalla.
QLabel
Constructores:
constructor por defecto

QLabel ( QWidget * parent, const char * name = 0, WFlags f = 0 )
constructor con el texto de QLabel como argumento

QLabel ( const QString & text, QWidget * parent, const char * name = 0, WFlags f = 0 )
Destructores
~QLabel ()
Funciones miembro
Funcion que retorna el texto del label
Funcion que retorna el pixmap del label (si tiene)

QPixmap * pixmap () const
Funcion que retorna el formato del texto que tiene le label

TextFormat textFormat () const
Funcion que cambia el formato del texto del label

void setTextFormat ( TextFormat )
Funcion que retorna el tipo de alineacion que tiene el texto del label
int alignment () const
Funcion que cambia el tiepo de alineacion del texto del label

virtual void setAlignment ( int )
Funcion que retorna el texto del label indentado en pixeles

int indent () const
Funcion que cambia el texto del label, indentado en pixeles

void setIndent ( int )
Funcion que retorna TRUE si el label se redimenciona al contenido

bool hasScaledContents () const
Funcion que establece si el label debe o no escalarse al contenido

void setScaledContents ( bool )
Funcion que cambia la fuente del texto que tendra el label

virtual void setFont ( const QFont & f )
Slots
Funcion que cambia el texto del label

Funcion que cambia el pixmap del label

virtual void setPixmap ( const QPixmap & )
Funcion que cambia el la imagen del label

virtual void setPicture ( const QPicture & picture )
Funcion que trata de cambiar el texto del label, por un numero entero (es como QString::setNum() )
virtual void setNum ( int num )
Funcion que trata de cambiar el texto del label, por un numero doble (es como QString::setNum() )
virtual void setNum ( double num )
Funcion que borra el texto del label

void clear ()
El segundo widget que veremos, sera el

QComboBox
Constructores

QComboBox ( QWidget * parent = 0, const char * name = 0 )
Constructor por con un argumento de solo lectura (TRUE solo lectura) (FALSE lectura y escritura)
QComboBox ( bool rw, QWidget * parent = 0, const char * name = 0 )
Destructor
~QComboBox ()
Funcion que retorna la cantidad de items dentro del combo

int count () const
Funcion que rellena el combo, con los datos de un QStringList

void insertStringList ( const QStringList & list, int index = -1 )
Funcion que rellena el combo, con los datos de un QStrList

void insertStrList ( const QStrList & list, int index = -1 )
Funcion que rellena el combo, con los datos de array de punteros a cadenas del tipo char **
void insertStrList ( const char ** strings, int numStrings = -1, int index = -1 )
Funcion que inserta un item

void insertItem ( const QString & t, int index = -1 )
Funcion que inserta un item como pixmap

void insertItem ( const QPixmap & pixmap, int index = -1 )
Funcion que inserta un item como pixmap y texto

void insertItem ( const QPixmap & pixmap, const QString & text, int index = -1 )
Funcion que remueve un item del combo

void removeItem ( int index )
Funcion que retorna el indice del item actualmente seleccionado

int currentItem () const
Funcion que selecciona un item, segun su indice

virtual void setCurrentItem ( int index )
Funcion que retorna el texto del item actualmente seleccionado

QString currentText () const
Funcion que cambia el texto del item

virtual void setCurrentText ( const QString & )
Funcion que retorna el texto del combo, segun el indice seleccionado

QString text ( int index ) const
Funcion que retorna el pixmap del combo, segun el indice seleccionado

const QPixmap * pixmap ( int index ) const
Funcion que remplaza el texto del item segun el indice seleccionado
void changeItem ( const QString & t, int index )
Funcion que remplaza el pixmap del item segun el indice seleccionado

void changeItem ( const QPixmap & im, int index )
Funcion que remplaza el texto y el pixmap del item segun el indice seleccionado
void changeItem ( const QPixmap & im, const QString & t, int index )
Funcion que cambia la paleta de colores del combo

virtual void setPalette ( const QPalette & palette )
Funcion que cambia la fuente del combo

virtual void setFont ( const QFont & font )
Funcion que cambia el tamaño maximo de caracteres por item que soportara el combo
virtual void setSizeLimit ( int )
Funcion que retorna el tamaño maximo de caracteres por item que soportara el combo
int sizeLimit () const
Funcion que establece el tamaño maximo de items que soportara el combo

virtual void setMaxCount ( int )
Funcion que retorna el tamaño maximo de items que soportara el combo

int maxCount () const
Enumeracion que contiene la politica de insercion que tendra el combo

enum Policy { NoInsertion, AtTop, AtCurrent, AtBottom, AfterCurrent, BeforeCurrent }
Funcion que cambia la politica de insercion que tendra el combo

virtual void setInsertionPolicy ( Policy policy )
Funcion que retorna la politica de insercion que tiene el combo

Policy insertionPolicy () const
Funcion que cambia el validator del combo

virtual void setValidator ( const QValidator * v )
Funcion que retorna el validator del combo

const QValidator * validator () const
Funcion que cambia el contenido, segun el QListBox pasado como argumento

virtual void setListBox ( QListBox * newListBox )
Funcion que retorna el QListBox del combo

QListBox * listBox () const
Funcion que cambia el QLineEdit que tiene el combo

virtual void setLineEdit ( QLineEdit * edit )
Funcion que retorna el QLineEdit que tiene el combo

QLineEdit * lineEdit () const
Funcion que establece, si el autocompletado estara activado o no

virtual void setAutoCompletion ( bool )
Funcion que retorna TRUE si el autocompletado esta activo
bool autoCompletion () const
Funcion que establece si los items repetidos seran soportados o no

void setDuplicatesEnabled ( bool enable )
Funcion que retorna TRUE, si la opcion de los items repetidos esta activa o FALSE en caso contrario
bool duplicatesEnabled () const
Funcion que retorna TRUE, si el combo es editable

bool editable () const
Funcion que establece si el combo es de solo lectura o no

void setEditable ( bool )
Slots:
funcion que borra todo el contenido del combo

void clear ()
funcion que borra el validator del combo

void clearValidator ()
funcion que borra el texto del combo

void clearEdit ()
funcion que cambia el texto del combo

virtual void setEditText ( const QString & newText )
Señales:
Señal que se activa, cuando el combo es desplegado

void activated ( int index )
Señal que se activa, cuando el combo es desplegado (igual que la anterior, pero esta soporta el texto)
void activated ( const QString & string )
Señal que se activa, cuando un item del combo esta seleccionado

void highlighted ( int index )
Señal que se activa, cuando un item del combo esta seleccionado (igual que la anterior, pero esta soporta el
texto)
void highlighted ( const QString & string )
Señal que se activa, cuando el texto del combo cambia

void textChanged ( const QString & string )
Continuaremos ahora, con el widget QGrid, que sirve para ordenar los objetos dentro de nuestra aplicacion.
QGrid
Constructores
Constructor por defecto, que establece el numero de celdas que tendra, horizontal y verticalmente.
QGrid ( int n, QWidget * parent = 0, const char * name = 0, WFlags f = 0 )
Constructor que establece el numero de celdas que tendra, y si seran verticales o horizontales
QGrid ( int n, Orientation orient, QWidget * parent = 0, const char * name = 0, WFlags f = 0 )
Funcion que cambia el espacio entre los widgets.

void setSpacing ( int space )
Continuamos con el widget QFileDialog, que es un cuadro de dialogo, para salvar archivos, cargarlos etc...
QFileDialog
Constructores
Constructor con el nombre del directorio por defecto

QFileDialog ( const QString & dirName, const QString & filter = QString::null, QWidget * parent = 0,
const char * name = 0, bool modal = FALSE )

QFileDialog ( QWidget * parent = 0, const char * name = 0, bool modal = FALSE )
Destructor
~QFileDialog ()
Funcion que retorna el archivo seleccionado

QString selectedFile () const
Funcion que retorna el filtro seleccionado

QString selectedFilter () const
Funcion que modifica el filtro seleccionado (*.bmp, *.txt *.c etc...)

virtual void setSelectedFilter ( const QString & mask )
Funcion que modifica el filtro seleccionado (*.bmp, *.txt *.c etc...) segun el indice de este
virtual void setSelectedFilter ( int n )
Funcion que cambia la seleccion del usuario por un nombre de archivo que especifiquemos
void setSelection ( const QString & filename )
Funcion que establece si se pueden seleccionar todos los archivos o no

void selectAll ( bool b )
Funcion que retorna un QStrignList, con los archivos seleccionados

QStringList selectedFiles () const
Funcion que retorna el directorio actual

QString dirPath () const
Funcion que cambia el directorio actual

void setDir ( const QDir & dir )
Funcion que retorna un QDir, con el directorio actual
const QDir * dir () const
Funcion que establece si los archivos ocultos seran visibles o no

void setShowHiddenFiles ( bool s )
Funcion que retorna TRUE si los archivos visibles estan activos o no

bool showHiddenFiles () const
Enumeracion que contiene la forma en que el usuario podra selecionar o ver los archivos o directorios
enum Mode { AnyFile, ExistingFile, Directory, ExistingFiles, DirectoryOnly }
Funcion que cambia la forma en que el usuario podra selecionar o ver los archivos o directorios
void setMode ( Mode )
Funcion que retorna la forma en que el usuario podra selecionar o ver los archivos o directorios
Mode mode () const
Enumeracion que contiene la forma en que se vera la informacion de los archivos.

enum ViewMode { Detail, List }
Enumeracion que contiene la forma en que se vera el preview de los archivos

enum PreviewMode { NoPreview, Contents, Info }
Funcion que cambia el modo ViewMode

void setViewMode ( ViewMode m )
Funcion que retorna el modo ViewMode

ViewMode viewMode () const
Funcion que cambia el modo PreviewMode

void setPreviewMode ( PreviewMode m )
Funcion que retorna el modo PreviewMode

PreviewMode previewMode () const
Funcion que retorna TRUE, si el PreviewMode esta activo

bool isInfoPreviewEnabled () const
Funcion que retorna TRUE, si el ContentsPreviewMode esta activo

bool isContentsPreviewEnabled () const
Funcion que establece si el InfoPreviewMode estara abilitado

void setInfoPreviewEnabled ( bool )
Funcion que establece si el ContentsPreviewMode estara abilitado

void setContentsPreviewEnabled ( bool )
Funcion que retorna una direccion de internet en un widget del tipo QUrl.
QUrl url () const
Funcion que establece el filtro (extencion) que se vera.

void addFilter ( const QString & filter )
Slots:
Funcion que cambia el directorio
void setDir ( const QString & pathstr )
Funcion que cambia la direccion de internet

void setUrl ( const QUrlOperator & url )
Funcion que cambia el filtro

void setFilter ( const QString & newFilter )
Funcion que cambia los filtros (podemos tener màs de uno)

void setFilters ( const QString & filters )
Funcion que cambia el filtro, siendo este un array de punteros a cadenas de caracteres char **
void setFilters ( const char ** types )
Funcion que cambia el filtro, siendo este un QstringList.

void setFilters ( const QStringList )
El siguiente widget que veremos, sera el widget QFile usado para el manejo de ficheros en QT
QFile
Constructores
¿Esto merece explicaciòn?

QFile ()
QFile ( const QString & name )
Destructor
~QFile ()
Funcion que retorna el nombre del archivo

QString name () const
Funcion que cambia el nombre del archivo

void setName ( const QString & name )
Funcion que retorna TRUE si el archivo existe

bool exists () const
Funcion que borra el archivo

bool remove ()
Funcion que abre un archivo donde el modo puede ser:
IO_Raw Formato crudo sin buffer intermedio

IO_ReadOnly Solo lectura
IO_WriteOnly Solo escritura
IO_Append modo Append, añade datos a un archivo existente, y si no existe lo crea
IO_ReadWrite Lectura / escritura
virtual bool open ( int m )

Funcion que abre un archivo con una esctructura FILE * (de c, no recomendado)
bool open ( int m, FILE * f )
Funcion que abre un archivo con un filedescriptor como argumento

bool open ( int m, int f )
Funcion que cierra el archivo

virtual void close ()
¿Necesita explicacion?
virtual void flush ()
Funcion que retorna el tamaño del archivo

virtual Offset size () const
Funcion que retorna TRUE si se llego al final del archivo (es el EOF)
virtual bool atEnd () const
Funcion que lee una linea de caracteres del tipo char *

virtual Q_LONG readLine ( char * p, Q_ULONG maxlen )
Funcion que lee una linea de caracteres del tipo QString

Q_LONG readLine ( QString & s, Q_ULONG maxlen )
Funcion que lee un unico byte del archivo

virtual int getch ()
Funcion que escribe un unico byte del archivo

virtual int putch ( int ch )
Funcion que retorna el handle del archivo

int handle () const
Funcion que retorna un QString, con el mensaje de error.

QString errorString () const
Funcion que cambia el mensaje de error.

void setErrorString ( const QString & str )
Bueno, parece que terminamos con los widgets, pasemos ahora a explicar el ejemplo nº 3 de este tuto.
Fichero cabecera.h
1):Primero que nada, en el fichero de cabecera cabecera.h, vemos que hemos definido la clase CDatos antes
que la clase CPrincipal, esto es asi, porque necesito que el enlazador tenga una referencia a esta clase para
poder instanciarla desde el formulario principal.
2): En el fichero de cabecera cabecera.h, vemos que en la clase CPrincipal, agregamos un slot nuevo, este
slot (o funcion de respuesta) sirve para cuando en la tabla hagamos dobleclick, se envien los datos al nuevo
formulario.
3): Tambien vemos que hemos cambiado el estado de private a protegido, (protected) esto como sabran es
para que podamos accesar a estos datos desde la otra clase llamada CDatos.
4): Vemos tambien, que hemos agregado otro boton, que sera el que llame al otro formulario, y tambien, dos
lineas màs abajo definimos una instancia de la clase CDatos.
5): He aqui lo nuevo, la clase CDatos, (como se habran dado cuenta ) es una clase para otro formulario.
6): Lo primero que salta a la vista, es que definimos a la clase CPrincipal como amiga de esta, eso es asi,
para de querer poder acceder a los datos de la clase CPrincipal podamos hacerlo.
7): Luego vemos que tenemos 2 slots nuevos, que son para cuando se precione ENTER en el combo o se
haga click en el boton cmd_seleccionar, este slot mandara el dato seleccionado del combo a la tabla.
8): El otro slot, (SalverEnFichero () ) sire como sabran para poder salvar los datos de la tabla en un archivo.
9) Luego simplemente definimos algunos widgets que estaran presentes en el formulario.
Fichero cabecera.cpp
1): La primera modificacion que tenemos aqui, es la creacion de un boton llamado cmd_salvarDatos, que es
para llamar al otro formulario, luego, vemos que hemos creado una instancia de la clase CDatos, para poder
referenciarla desde el form.
2): Luego de unas lineas, vemos que hemos conectado la señal clicked() del boton cmd_salvarDatos al
formulario frm_datos, y que establecemos como señal de respuesta la funcion show(), esta funcion la
podemos usar tranquilamente (aunque no haya sido previamente definida) gracias a que la clase CDatos,
deriva de QVBox, y este es un widget. Esto significa que la clase CDatos hereda todos los miembros publicos
de la clase QWidget, incluyendo este.
3): Despues conectamos la señal doubleClicked (...) de la rejilla, al slot EnviarDatos (...), que como ya
explique envia los datos al otro formulario. Lo que hay que tener en cuenta, es que los parametros tanto de la
señal, como de la funcion de respuesta (slot) tienen que ser exactamente iguales. Màs adelante explicare
como poder crear nuestras propias señales, derivandolas de otras ya existentes, evitando asi este tipo de
problemas.
4): La funcion de respuesta EnviarDatos(...) no la explicare completa, solamente hay que saver que la funcion
isShown() de la clase QWidget, sirve para saver si el formulario se encuentra visible o no.
5):En el constructor de la clase CDatos, vemos algo muy nuevo, y esto es el QGrid, este widget sirve para
ordenar los widgets de la aplicacion. Todos los widgets que tengamos en el formulario, tendran que
descansar dentro del widget QGrid, para que este pueda acomodarlos.
6): Despues, creamos algunos objetos, y les modificamos las propiedades (nada nuevo).
7): Luego de conectar algunas señales, vemos que creamos un QLineEdit, que contiene el QLineEdit del
combo, y le conectamos la señal returnPressed() al slot AgregarDato (), esto lo hicimos, porque el
QComboBox no tiene ninguna señal, returnPressed, y ya que el combo tiene un widget QLineEdit asociado,
aprovechamos la señal de este, para usarla en nuestro form (ingenioso ¿no?).
8): La funcion AgregarDato, no la explicare porque creo que no merece la pena, ahun asi si tienen alguna
duda, manden un mail, y tratare de ayudarlos en lo que pueda.
9): Y llegamos a la ultima funcion, esta funcion, como se habran dado cuenta (NO FUNCA!!!), eso se los dejo
como tarea para que investiguen un poco, y aprendan. (Ya escucho los insultos jeje). Una pista, si se fijan
bien, el problema es una pavada, y esta asociado con el nombre del archivo.
Demos ahora un ejemplo de las señales, estas se encuentran en el fichero de cabecera qsignal.h, que a su
vez, esta heredado por QWidget, osea por casi todos los widgets.
#include <qobject.h>
class MiClase : public QObject

{
Q_OBJECT
public:
MiClase();
int valor() const { return val ;}
public slots:
void setValor (int);
signals:
CambiaValor(int);
private:
int val;
};
void MiClase::setValor (int v )

{
if ( v != val ) //si el valor cambio
{
val = v; //asigno el nuevo valor
emit CambiaValor (v); //con esto lanzo la senial.
}
}
Este pequeño ejemplo, define una clase llamada MiClase, y crea una señal, que sera emitida cuando la
funcion de respuesta setValor sea llamada, y luego de comprobar una condicion critica. Para emitir una señal,
se usa (logico) la funcion emit. Atencion: es altamente recomendable, separar la definicion de la clase que
creamos (archivo .h) de la implementacion (archivo .cpp), para que funcione correctamente
Sabiendo esto, nosotros podemos definir tantas señales como queramos dentro de nuestra clase, para luego
poder utilizarlas a nuestro antojo (Llora el VC++ y visual script).
pongamos un ejemplo un poco màs claro, y de paso mostrare otro widget, màs que interesante el
QGridLayout.
ejemplo:
cabecera.h.
#ifndef CABECERA_H
#define CABECERA_H
#include <qwidget.h>
class QPushButton;
class QLabel;
class CVentana : public QWidget
{
Q_OBJECT
public:
CVentana (QWidget *parent = 0, const char *name = 0);
public slots:
void Mensaje ();
signals:
void Sig_Mensaje(const QString & );
private:
QPushButton *boton;
QLabel *label;
QString contador;
int i;
};
#endif
cabecera.cpp.
#include <qlabel.h>
#include <qlayout.h> //este fichero nunca lo vimos :)
CVentana::CVentana(QWidget *parent, const char *name) : QWidget (parent,name)

{
QGridLayout *rejilla = new QGridLayout (this, 2 ,2 , 6);
boton = new QPushButton ("Pulsame", this, "boton");
label = new QLabel("Fijate el texto", this, "label");
QPushButton *salir = new QPushButton("Salir",this, "salir");
/*Widget nuevo ya lo explicaremos, por el momento ignorarlo */
rejilla->addWidget(label, 0 , 0 ); //primero pongo el label
rejilla->addWidget(boton, 0 , 1 ); //segundo pongo el boton al lado
salir->setMinimumWidth(this->width() );
rejilla->addWidget(salir, 1, 0 );
/*******************************************************************/
i = 0;
connect (this, SIGNAL (Sig_Mensaje(const QString &) ), label, SLOT(setText(const QString &) ) );
connect (boton,SIGNAL(clicked() ), this, SLOT (Mensaje() ) );
connect (salir,SIGNAL(clicked() ), this, SLOT (close () ));
}
void CVentana::Mensaje()
{
static const QString msg = "Veces que se pulso el boton = ";
i++;
contador = contador.setNum(i,10);
emit Sig_Mensaje( msg + contador );
El fichero principal, no lo muestro, porque por ahora sigue siendo siempre lo mismo. Pasemos a ver como
funciona la cosa, por ahora recomiendo olvidarse de QGridLayout, este widget ya lo veremos.
1): En el fichero cabecera.h, lo primero que salta a la vista, es la funcion de respueste Mensaje(), este no es
màs que un slot, que lo asociaremos a la señal clicked() del boton salir.
2): Lo segundo que se ve "raro", es la definicion de la seccion signals, esta seccion, (al contrario de lo que
pueden decir muchos), no es nada especial, solamente tenemos que tener en cuenta, que NO esta permitido
especificarle un tipo de acceso, (public, private, friend etc..), y que los parametros pasados tienen que ser
IGUALES a las funciones de respuesta. Aqui, definimos las señales propias, que queremos conectar a los
diferentes widgets de la aplicacion, es este caso, conectamos la señal Sig_Mensaje(const QString &) al slot
setText(const QString &) del widget QLabel, para que este muestre el texto, que luego le pasaremos como
argumento a la señal.
Los slots pueden ser de otros widgets, o nuestros, mientras que tengan los mismos parametros no hay
problema.
3): Luego, en el fichero cabecera.cpp, vemos que conectamos la señal Sig_Mensaje(...) de esta manera:
connect ( this, SIGNAL (Sig_Mensaje(const QString & ) ), label, SLOT (setText (const QString & ) ) );
Lo primero que tenemos que decirle a connect, es donde esta definida la señal que queremos conectar, en
este caso, es en nuestra clase, si estuviese en otra clase, tendriamos que especificarlo.
4): Luego, en la funcion de respuesta Mensaje(), vemos la funcion emit, esta funcion simplemente lanza la
señal con los parametros que tenga, para que el widget que este conectado a ella, la procese.
Tenemos que ver esto, como si fuera algo simple, ya que no tiene mayores complicaciones. Puesto que el
compilador lo unico que hace internamente es remplazar los parametros de la funcion de respuesta asociado
a la señal, por los parametros pasados como argumentos al momento de emitirse la señal (con emit ).
(remplaza una funcion por otra :) )
espero, que no se les complique, aunque es muy facil, aun asi, si hay dudas escriban y los ayudare.
Expliquemos ahora, que es eso de QGridLayout, este widget es uno que vamos a usar bastante, ya que nos
permite alinear los items de manera ordenada y facil
QGridLayout
Constructores

QGridLayout ( QWidget * parent, int nRows = 1, int nCols = 1, int margin = 0, int space = -1,
const char * name = 0 )
Constructor con argumentos, los cuales son el numero de filas y columnas que tendra, y el espaciado entre
ellas, y finalmente el nombre del widget.
QGridLayout ( int nRows = 1, int nCols = 1, int spacing = -1, const char * name = 0 )
Constructor con argumentos, los cuales son parentLayout, es el widget padre, (sobre el cual descansara), el
resto de los parametros son los mismos que antes.
QGridLayout ( QLayout * parentLayout, int nRows = 1, int nCols = 1, int spacing = -1, const char * name = 0 )
Destructor
~QGridLayout ()
Funcion que retorna un QSize, con el tamaño recomendado para la rejilla.

Funcion que retorna un QSize, con el tamaño minimo necesitado por la rejilla.
virtual QSize minimumSize () const
Funcion que retorna un QSize, con el tamaño maximo necesitado por la rejilla.
virtual QSize maximumSize () const
Funcion que establece el estrecho de una fila los parametros son la fila, y el tmaño que queramos
virtual void setRowStretch ( int row, int stretch )
Funcion que establece el estrecho de una columna los parametros son la columna, y el tmaño que queramos
virtual void setColStretch ( int col, int stretch )
Funcion que retorna el ancho (estrecho) de una fila, los argumentos son el numero de fila
int rowStretch ( int row ) const
Funcion que retorna el ancho (estrecho) de una columna, los argumentos son el numero de columna
int colStretch ( int col ) const
Funcion que establace el alto de una fila, los parametros son la fila, y el tamaño minimo especificado.
void setRowSpacing ( int row, int minSize )
Funcion que establace el alto de una columna, los parametros son la columna, y el tamaño minimo
especificado.
void setColSpacing ( int col, int minSize )
Funcion que retorna el alto (estrecho) de una fila, el parametro es la fila.

int rowSpacing ( int row ) const
Funcion que retorna el alto (estrecho) de una columna, el parametro es la columna.

int colSpacing ( int col ) const
Funcion que retorna el numero de filas que hay en el QGridLayout.

int numRows () const
Funcion que retorna el numero de columnas que hay en el QGridLayout.

int numCols () const
Funcion que retorna un QRect, con la geometria de la celda, entre la fila y la columna especificada.
QRect cellGeometry ( int row, int col ) const
Funcion que resetea la informacion de la cache.

virtual void invalidate ()
Funcion que inserta items, en la siguiente posicion libre del QGridLayout.

virtual void addItem ( QLayoutItem * item )
Funcion que inserta items, en la fila y columna espeficidadas.

void addItem ( QLayoutItem * item, int row, int col )
Funcion que inserta widgets en la fila y la columna especificadas.
void addWidget ( QWidget * w, int row, int col, int alignment = 0 )
Funcion para poder combinar un rango de filas o columnas o ambos. (Muy recomendable) los parametros
son:
QWidget *w = El wiget que queremos acomodar
int fromRow = desde la fila
int toRow = hasta la fila
int fromCol = desde la columna
int toCol = hasta la columna
int alignment = 0 (centrado) = contiene los valores de Qt::AlignmentFlags.
void addMultiCellWidget ( QWidget * w, int fromRow, int toRow, int fromCol, int toCol, int alignment = 0 )
Funcion que expande el QGridLayout con el numero de filas / columnas especificadas.

void expand ( int nRows, int nCols )
Enumeracion que contiene el tipo de alineacion que queramos. Los tipos son:
QGridLayout::TopLeft -
QGridLayout::TopRight -
QGridLayout::BottomLeft -
QGridLayout::BottomRight -
¿Necesita explicacion?
enum Corner { TopLeft, TopRight, BottomLeft, BottomRight }
Funcion que alinea, los widget dentro del QGridLayout, con la alineacion previamente vista.
void setOrigin ( Corner c )
Funcion que retorna una enumeracion Corner, con la alineacion que estamos usando actualmente.
Corner origin () const
Funcion que cambia la geometria del QGridLayout.

virtual void setGeometry ( const QRect & r )
Vamos a ver ahora, un ejemplo un poco màs avanzado, tratemos de combinar las funciones de la libreria QT,
con las funciones de alguna otra libreria, (esto es como para recalcar un poco la compatibilidad de datos de
QT) en este caso Postgresql. No es realmente necesario hacer esto, ya que la libreria trae incorporado los
drivers y las clases para el proceso de las bases de datos màs conocidas y utilizadas, pero aun asi, lo
haremos para mostrar como combinar las funciones y mostrar un poco màs sobre las señales.
Como vamos a utilizar otras librerias, para no complicarnos las cosas he decidido entregar los fuentes,
utilizando el kdevelop.
Ejemplo:
Fichero bdatos.h
#ifndef BDATOS_H
#define BDATOS_H
#include <pgsql/libpq-fe.h>
class QStringList;
class BDatos : public QWidget
{
Q_OBJECT
public:
BDatos(QWidget *parent = 0, const char *name = 0);
BDatos(QString dbName, QWidget *parent = 0, const char *name = 0);
~BDatos() { desconecta(); }
signals:
void Mensaje (const QString &);
void ConeccionCerrada();
void EnviarDatos(QStringList &);
public slots:
void GetDatos();
void desconecta ();
void conecta(QString dbname);
void conecta();
private:
/*variables privadas de la clase*/

PGconn *pConeccion;
PGresult *pResultado;
QString nBase;
QStringList Datos;
};
#endif
Fichero bdatos.cpp
#include "bdatos.h"
/**************************************Constructor **********************************/
BDatos::BDatos(QWidget *parent, const char *name ) : QWidget (parent,name)
{
nBase = (nBase != "oxygen" && nBase != "") ? nBase : "oxygen";
conecta (nBase);
}
/*************************************Constructor con argumentos ******************/

BDatos::BDatos(QString dbName, QWidget *parent, const char *name ) : QWidget (parent,name)
{
if ( dbName != "" )
{
conecta (dbName);
nBase = dbName;
}
else
emit Mensaje ( "Nombre de la base de datos invalido o vacio" );
}
/********Funcion para conectar a la base de datos***************************/
void BDatos::conecta(QString nombre)
{
PGconn *con;
con = PQsetdbLogin(NULL,NULL,NULL,NULL,nombre.latin1(), NULL, NULL );
if ( PQstatus ( con ) != CONNECTION_OK )
{
emit Mensaje ("Error al conectarse");
return;
}
else
{
nBase = nombre;
pConeccion = con;
emit Mensaje( "Coneccion establecida con la base de datos ");
}
}
/********Funcion sobrecargada para conectar a la base de datos***************************/

void BDatos::conecta()
{
conecta("oxygen");
}
/********************************Funcion para seleccionar los datos de la base de datos *************/
void BDatos::GetDatos()
{
PGresult *res;
QString csql = "select * from amigos";
if (PQstatus (pConeccion ) == CONNECTION_OK )
{
res = PQexec (pConeccion, csql.latin1() );
if ( PQresultStatus( res ) != PGRES_TUPLES_OK )
{
emit Mensaje ("Error al tratar de recivir los datos de la tabla amigos");
return;
}
else
{
int nDatos = PQntuples(res);
int nCampos = PQnfields(res) -1;
for (signed int i = 0; i <= nDatos; i++ )
{
if (Datos.count() != 0 )
{
emit EnviarDatos(Datos);
Datos.clear();
}
for (signed int j = 0; j <= nCampos; j++)

Datos.append(PQgetvalue(res , i , j ) );
pResultado = res;
}
}
}
else
emit Mensaje ("No se encuentra conectado a la base de datos, debe conectarse antes de ejecutar una
consulta");
}
/**************Funcion para desconectarse de la base de datos***********************/

void BDatos::desconecta()
{
if (PQstatus (pConeccion) != CONNECTION_BAD )
{
PQfinish(pConeccion) ;
emit ConeccionCerrada();
}
else
emit Mensaje ("Error al desconectarse de la base de datos");
}
Fichero interface.h
#ifndef INTERFACE_H
#define INTERFACE_H
#include "bdatos.h"
class QTable;
class CVentana : public QWidget
{
Q_OBJECT
public:
CVentana( QWidget *parent = 0, const char *name = 0 );
public slots:
void RellenarLista(QStringList &);
void Msg(const QString &);
void LimpiarRejilla();
private:
BDatos *dat;
QTable *tabla;
signed int indice;
};
#endif
Fichero interface.cpp
#include <qlayout.h>
#include <qtable.h>
#include "interface.h"
CVentana::CVentana (QWidget *parent, const char *name) : QWidget ( parent , name )

{
/* **************************Creo los objetos******************************************************/
QGridLayout *grid = new QGridLayout(this, 10 , 3 , 6);
QPushButton *salir = new QPushButton ("salir",this, "salir");

QPushButton *juntarDatos = new QPushButton("juntar datos", this, "juntarDatos");
QPushButton *cerrarConeccion = new QPushButton("Cerrar la coneccion", this, "cerrarConeccion");
QPushButton *conectar = new QPushButton ("Conectar", this, "conectar");
QPushButton *limpiarRejilla = new QPushButton ("Limpiar celdas", this, "limpiarRejilla");
tabla = new QTable(this, "tabla");

dat = new BDatos(this, "dat");
/**************************************************************************************************/
/***************************Establezco las propiedades*********************************************/

tabla->setNumCols( 5 );
grid->addWidget (conectar, 0, 0);
grid->addWidget (juntarDatos, 0, 1);
grid->addWidget (cerrarConeccion, 0 , 2 );
grid->addWidget (salir, 0 , 3 );
grid->addMultiCellWidget (limpiarRejilla, 2 , 2 , 0 , 3 );
grid->addWidget (dat, 1, 0); //tengo que aderir el widget dat, porque sino se superpone con el resto.
grid->addMultiCellWidget (tabla, 3, 9 , 0, 3 ); //El resto de la ventana es de la tabla
//Establezco el ancho del formulario

setMinimumWidth(800);
setMaximumWidth(800);
//Tengo que crear el QHeader aqui, para que quede correctamente alineado con la tabla
QHeader *cabecera = tabla->horizontalHeader();
cabecera->setLabel(0,"Nombre");
cabecera->setLabel(1,"Apellido");
cabecera->setLabel(2,"Direccion");
cabecera->setLabel(3,"Telefono");
cabecera->setLabel(4,"E-mail");
//Establezco el ancho de las columnas de la tabla

tabla->setColumnWidth(0,100);
indice = 0; //inicializo el contador de registros de la tabla a 0

/**************************************************************************************************/
/*************************************Conecto sus seniales*****************************************/
connect (dat , SIGNAL (Mensaje(const QString &) ), this, SLOT ( Msg (const QString &) ) );
connect (cerrarConeccion, SIGNAL ( clicked () ) , dat, SLOT (desconecta() ) );
connect (limpiarRejilla, SIGNAL (clicked() ), this, SLOT (LimpiarRejilla() ) );
connect (conectar, SIGNAL (clicked() ), dat, SLOT (conecta() ) );
connect (juntarDatos, SIGNAL (clicked() ), dat, SLOT (GetDatos( ) ) );
connect (dat, SIGNAL (EnviarDatos(QStringList& )), this, SLOT (RellenarLista(QStringList& ) ) );
connect (salir, SIGNAL (clicked() ), this, SLOT (close() ) );
/***************************************************************************************************/
void CVentana::Msg(const QString &men)

{
QMessageBox::information(this, "Ejemplo 5", men );
}
void CVentana::RellenarLista( QStringList &lista )

{
int columna = 0;
if (indice >= tabla->numRows() )
tabla->setNumRows(indice +1);
for (QStringList::Iterator it = lista.begin(); it != lista.end(); it ++ )

{
tabla->setItem( indice, columna, new QTableItem ( tabla,
QTableItem::WhenCurrent, *it ) );
columna++;
}
tabla->repaint();
indice ++;
}
void CVentana::LimpiarRejilla( )
{
indice = 0;
tabla->setNumRows (0);
Fichero main.cpp
#include "interface.h"
int main(int argc, char *argv[])

{
QApplication Main ( argc , argv );
CVentana *ventana = new CVentana();
ventana->setCaption("Ejemplo 5" );
Main.setMainWidget ( ventana );
ventana->show();
return Main.exec();
}
Salida del ejemplo 5:

Explicacion:
Como vemos hemos creado un widget llamado BDatos, para el manejo de las funciones basicas de la libreria
postgresql. Pasemos a analizar el fichero bdata.h
bdata.h
1): el primer paso, es incluir los archivos de cabecera, que necesitemos, en este caso incluimos qwidget, para
derivar la clase BDatos directamente de ella, y luego incluimos el archivo de cabecera pgsql/libpq-fe.h, para
poder utilizar las funciones basicas de la libreria.
2): Luego, lo que resalta es que hemos definido 2 constructores diferentes, esto es posible de hacer, con
cualquier clase que derivemos de QWidget, lo unico que tenemos que tener en cuenta es que los parametros
que queramos agregarles tienen que ser puestos primero, y luego pasarle los parametros por defecto
(Qwidget *parent = 0, const char *name = 0) .
3): luego vemos que hemos definido un area para las señales, las cuales son:
void Mensaje (const QString &) que sirve para enviar un mensaje con los estados de la coneccion y demas.
void ConeccionCerrada() que sera emitida, ni bien nos desconectemos de la base de datos.
void EnviarDatos(QStringList &) que servira, para enviarnos los datos extraidos de la base de datos.
4):Despues, vemos que hemos definido varios slots, que sirven para:
void GetDatos(); cuando lo llamemos, este slot, lanzara la señal, con los datos extraidos
void desconecta (); este slot, nos desconecta de la base de datos
void conecta(QString dbname); este slot, nos conecta con la base de datos
void conecta(); Y este slot, tambien sirve para conectarnos, solamente esta sobrecargado.
5): Luego en la seccion private, solamente nos queda declarar las variables que usaremos en la clase.
bdata.cpp
Aqui, no explicare todo el codigo, puesto que este pretende ser un tutorial de QT, no de postgresql, pero si
las funciones màs relevantes.
1): primero que nada, declaramos los ficheros de cabecera.

2): Luego, en el constructor sin argumentos, asignamos ul nombre de la base de datos, y nos conectamos.
3): En el constructor con argumentos, vemos que hemos lanzado la señal Mensaje, con un mensaje
personalizado, esto lo podemos hacer cuantas veces sea necesario, y c0on el texto que querramos.
4):Luego en la funcion de respuesta GetDatos, vemos que emos emitido la señal EnviarDatos, con los datos
extraidos de la base de datos, esta señal, luego la conectaremos a un slot que los procese.
Pasemos ahora, a ver el fichero de cabecera Interface.h
inteface.h
a esta altura, no me parece interesante explicar este fichero solamente diremos para que son los slots que
contiene.
void RellenarLista(QStringList &); este slot, simplemente muestra los datos en la tabla.
void Msg(const QString &); el el slot, que mostrara los mensajes de la clase BDatos.
void LimpiarRejilla(); simplemente limpia la rejilla.
Hora solamente nos falta ver el fichero interface.cpp
inteface.cpp
1): primero que nada, vemos que en el constructor cramos un QGridLayout, para ordenar los widgets dentro
del formulario, y luego creamos algunos botones e iniciamos el objeto dat, que es nuestro widget antes
creado.
2): luego, vemos que posicionamos los widgets dentro del formulario, con la ayuda de un QGridLayout.
3): Luego preparo la rejilla, asignando los nombres a las columnas, y el ancho de las mismas.
4): Luego vemos, que las señales, las conectamos como siempre. El resto de las funciones, no las explicare,
porque creo que no merecen una mayor explicacion.
Algo a lo que deberemos acostumbrarnos, es a crear siempre dos ficheros por clase, ya que de esta manera,
sera màs facil manejar el codigo.
Tratamiento de imagenes
Veamos ahora, como podemos cargar y modificar imagenes en nuestros programas, primero veremos el
widget QPixmap. Pondre un ejemplo bastante basico, y luego lo explicare paso a paso.
Ejemplo:
Fichero cabecera.h
#ifndef IMAGENES.H
#define IMAGENES_H
class QPixmap;
class QLabel;
class QPushButton;
class Ventana : public QWidget

{
Q_OBJECT
public:
Ventana(QWidget *parent = 0, const char *name = 0);
public slots:
void cargaImagen();
void muestraImagen();
private:
QLabel *label;
QPixmap *imagen;
QPushButton *cargarImagen, *mostrarImagen, *salir;
QString *nombre_imagen;
};
#endif
Fichero cabecera.cpp
#include <qpixmap.h>
#include <qfiledialog.h>
#include <qlabel.h>
#include "imagenes.h"
Ventana::Ventana (QWidget *parent, const char *name) : QWidget (parent,name)

{
QGridLayout *rejilla = new QGridLayout(this, 3 , 5 );
label = new QLabel("La imagen se cargara aqui", this, "label");
cargarImagen = new QPushButton("Cargar Imagen", this, "cargarImagen");
mostrarImagen = new QPushButton("Mostrar Imagen", this, "mostrarImagen");
salir = new QPushButton("Salir ", this, "salir");
rejilla->addWidget (cargarImagen,0, 0 );
rejilla->addWidget (mostrarImagen, 0, 1);
rejilla->addWidget (salir, 0, 2 );
rejilla->addMultiCellWidget (label, 1 , 2 , 0 , 4 );
connect (this->cargarImagen , SIGNAL (clicked() ), this, SLOT (cargaImagen() ) );

connect (this->mostrarImagen, SIGNAL (clicked() ), this, SLOT (muestraImagen() ) );
connect (this->salir, SIGNAL (clicked() ), this, SLOT (close() ) );
}
void Ventana::cargaImagen()
{
*nombre_imagen = QFileDialog::getOpenFileName ("/home",
"imagenes (*.png *.jpg *.xpm)",
this,
"Abrir imagen",
"seleccionar archivo");
imagen = new QPixmap(*nombre_imagen);
}
void Ventana::muestraImagen()
{
label->setPixmap (*imagen);
}
Fichero main.cpp
#include "imagenes.h"
int main (int argc,char **argv)

{
QApplication Main (argc,argv);
Ventana *form = new Ventana();
form->setCaption("Ejemplo de carga y renderizado de imagenes");
Main.setMainWidget (form);
form->show();
return Main.exec();
}
Explicaciòn: (la merece?)
Como podemos ver, todo el codigo mostrado aqui, es realmente relevante, solamente nos tenemos que
enfocar en la declaracion de QPixmap *imagen en la definicion de la clase Ventana, y en imagen = new
QPixmap (*nombre_imagen), que carga una imagen pasada como argumento en el constructor, luego
simplemente en la funcion muestraImagen(), le asigno la imagen antes cargada al label, como buena noticia
es que las imagenes se pueden asignar a casi CUALQUIER WIDGET DE LA LIBRERIA.
Mostrare ahora, la clase QPixmap
QPixmap
Enumeracion que contiene el modo de color de la imagen

enum ColorMode { Auto, Color, Mono }
Enumeracion que contiene el modo de optimizacion de la imagen

enum Optimization { DefaultOptim, NoOptim, MemoryOptim = NoOptim, NormalOptim, BestOptim }

QPixmap ()
Constructor con un QImage por defecto

QPixmap ( const QImage & image )
Constructor con el ancho, el alto, la profundidad de colores (8,16 o 32 BYTES), y el modo de optimizacion
QPixmap ( int w, int h, int depth = -1, Optimization optimization = DefaultOptim )
Constructor con un QSize, para el tamaño de la imagen, la profundidad de colores, y la optimizacion

QPixmap ( const QSize & size, int depth = -1, Optimization optimization = DefaultOptim )
Constructor con el nombre de la imagen, el formato por defecto, y el modo de colores

QPixmap ( const QString & fileName, const char * format = 0, ColorMode mode = Auto )
Constructor con el nombre de la imagen, el formato por defecto, y el modo de conversion (ya lo veremos)
QPixmap ( const QString & fileName, const char * format, int conversion_flags )
Constructor con un const char *[], que contiene la imagen en si en formato crudo.
QPixmap ( const char * xpm[] )
Constructor copia
QPixmap ( const QPixmap & pixmap )
Destructor
~QPixmap ()
Funcion que retorna TRUE, si la imagen es nula

Funcion que retorna el ancho de la imagen

int width () const
Funcion que retorna el alto de la imagen

int height () const
Funcion que retorna un QSize, con el tamaño de la imagen

QSize size () const
Funcion que retorna un QRect, con los datos de la imagen

QRect rect () const
Funcion que retorna la profundidad de colores seleccionada

int depth () const
Funcion que pinta la imagen con el color especificado con un QColor

void fill ( const QColor & fillColor = Qt::white )
Funcion que pinta la imagen en el widget especificado., xofs e yofs son las coordenadas ( ¡que funcion!
¿no? )
void fill ( const QWidget * widget, int xofs, int yofs )
Funcion que pinta la imagen en el widget especificado, en las coordenadas pasadas por QPoint
void fill ( const QWidget * widget, const QPoint & ofs )
Funcion que redimenciona el tamaño de la imagen

void resize ( int w, int h )
Funcion que redimenciona el tamaño de la imagen segun el QSize pasado como argumento
void resize ( const QSize & size )
Funcion que retorna un QBitmap con la mascara de bits de la imagen

const QBitmap * mask () const
Funcion que cambia la mascara de bit de la imagen, por un QBitmap pasado como argumento.
void setMask ( const QBitmap & newmask )
Funcion que retorna TRUE, si la imagen tiene activado un canal alfa on una mascara
bool hasAlpha () const
Funcion que retorna TRUE, si la imagen tiene activado un canal alfa

bool hasAlphaChannel () const
Funcion que crea y retorna la heuristica de la mascara a un bitmap

QBitmap createHeuristicMask ( bool clipTight = TRUE ) const
Funcion que retorna un QImage.

QImage convertToImage () const
Funcion que retorna TRUE si la conversion a QImage fue realizada con exito
bool convertFromImage ( const QImage & image, ColorMode mode = Auto )
bool convertFromImage ( const QImage & img, int conversion_flags )
Funcion que carga la imagen

bool load ( const QString & fileName, const char * format = 0, ColorMode mode = Auto )
bool load ( const QString & fileName, const char * format, int conversion_flags )
Funcion que carga la imagen contenida en un unsigned char *.

bool loadFromData ( const uchar * buf, uint len, const char * format = 0, ColorMode mode = Auto )
bool loadFromData ( const uchar * buf, uint len, const char * format, int conversion_flags )
Funcion que guarda la imagen en el disco

bool save ( const QString & fileName, const char * format, int quality = -1 ) const
bool save ( QIODevice * device, const char * format, int quality = -1 ) const
Funcion que retorna un numero unico, que identifica el contenido del pixmap
int serialNumber () const
Funcion que retorna el tipo de optimizacion que contiene la imagen

Optimization optimization () const
Funcion que cambia el tipo de optimizacion de la imagen

void setOptimization ( Optimization optimization )
Funcion que retorna TRUE, si la imagen es un QBitmap

bool isQBitmap () const
Funcion que retorna la profundidad de colores por defecto que tiene la imagen
int defaultDepth ()
Funcion que retorna un QPixmap, con la imagen seleccionada como argumento, (la imagen seleccionada
tiene que estar en formato texto)
QPixmap fromMimeSource ( const QString & abs_name )
Funcion que graba el contenido de la ventana, y retorna un QPixmap con el contenido recien grabado.
QPixmap grabWindow ( WId window, int x = 0, int y = 0, int w = -1, int h = -1 )
Funcion que graba el contenido del widget, y retorna un QPixmap con el contenido recien grabado.
QPixmap grabWidget ( QWidget * widget, int x = 0, int y = 0, int w = -1, int h = -1 )
Funcion que retorna un const char *, con los datos de la imagen pasada como argumento
const char * imageFormat ( const QString & fileName )
Por el momento no mostrare ningun otro ejemplo de tratamiento de imagenes, porque llevaria varias paginas
de este tutorial, pero si las iremos viendo y explicando a traves de otros ejemplos y en futuros tutoriales.
Menues:
Los famosos menues, existieron desde el comienzo de las aplicaciones como todos sabemos representan
una forma ordenada de crear botones con un argumento en comun. Podemos distinguir dos tipos de menues
diferentes en las aplicaciones, los primeros son los "PopupMenus", que existen en casi todas las
aplicaciones, y los segundos son los "ContextMenus", que son los famosos menues contextuales que salen
por ejemplo cuando pulsamos el boton derecho del mouse sobre un area de la aplicacion. Pondre un ejemplo
de como crear algunos menues, y luego lo explicaremos.
Ejemplo:
Fichero formulario.h
#ifndef FORMULARIO_H
#define FORMULARIO_H
#include <qmenubar.h>
class QTable;
class QPixmap;
class QLabel;
class QLCDNumber;
class QProgressBar;
class QTimeEdit;
class QDial;
class QListView;
class CFormulario : public QWidget

{
Q_OBJECT
public:
CFormulario (QWidget *parent = 0, const char *name = 0);

~CFormulario();
public slots:
void InsertarImagen();
void InsertarCombo();
void InsertarCheck();
void InsertarTexto();
/*----------------------------------------> Tipos de widgets a insertar*/
void InsertarLabel();
void InsertarLCD();
void InsertarProgressBar();
void InsertarTimeEdit();
void InsertarDial();
void InsertarListView();
/************************************************************************/
private:
QMenuBar *Menu;
QTable *tabla;
QPixmap *imagen;
int indice;
/*declaraciones de los widgets que podemos insertar*/

QLabel *label;
QLCDNumber *lcd;
QProgressBar *barra;
QTimeEdit *timeedit;
QDial *dial;
QListView *lista;
/*Slot privado de la clase, para limpiar la tabla de items */

private slots:
void LimpiarCeldas();
};
#endif
Fichero formulario.cpp
#include <qpopupmenu.h>
#include <qtable.h>
#include <qpixmap.h>
/************para InsertarWidget()***************/
#include <qdial.h>
#include <qlistview.h>
#include <qdatetimeedit.h>
#include <qprogressbar.h>
#include <qlcdnumber.h>
#include <qlabel.h>
/***********************************************/
#include "formulario.h"
CFormulario::CFormulario ( QWidget *parent , const char *name ) : QWidget ( parent , name )

{
imagen = new QPixmap ("Imagenes/cerveza.xpm");

indice = 0;
/*****inicializo el menu ( le reservo memoria )****/

Menu = new QMenuBar ( this );
/**************************************************/
/* Creo el menu archivo, con los datos que tendra y defino tambien los slots que usara*/
QPopupMenu *archivo = new QPopupMenu;
archivo->insertItem("Limpiar rejilla", this , SLOT (LimpiarCeldas() ) );
archivo->insertSeparator();
archivo->insertItem ("Salir", this , SLOT (close() ) , CTRL+Key_S );
/*************************************************************************************/
/*Creo el submenu de los widgets que podemos insertar */

QPopupMenu *widgets = new QPopupMenu;
widgets->insertTearOffHandle(); //con esto le digo que es un submenu de una opcion del menu widgets
widgets->insertItem("Insertar un Q&Label", this , SLOT (InsertarLabel () ) );
widgets->insertItem("Insertar un QL&cd", this , SLOT (InsertarLCD () ) );
widgets->insertItem("Insertar un ProgressBar", this , SLOT (InsertarProgressBar () ) );
widgets->insertItem("Insertar un TimeEdit", this , SLOT (InsertarTimeEdit () ) );
widgets->insertItem("Insertar un Dial", this , SLOT (InsertarDial () ) );
widgets->insertItem("Insertar un ListView", this , SLOT (InsertarListView () ) );
/*******************************************************/
/***** Ahora creo el menu insertar, de la misma manera que lo hice anteriormente *****/
QPopupMenu *insertar = new QPopupMenu;
insertar->insertItem ("&Imagen", this, SLOT (InsertarImagen () ), CTRL+Key_I );
insertar->insertItem ("&ComboBox", this, SLOT (InsertarCombo () ), CTRL+Key_C );
insertar->insertItem ("C&heckBox", this, SLOT (InsertarCheck () ), CTRL+Key_H );
insertar->insertItem ("Un &Texto", this, SLOT (InsertarTexto () ), CTRL+Key_T );
insertar->insertItem ("Un Widget->", widgets, CTRL+Key_W );
/*************************************************************************************/
/*********Ahora inserto todos los submenues ( archivo y insertar ) al Menu principal ( Menu )********/
Menu->insertItem ("&Archivo", archivo );
Menu->insertItem ("&Insertar cosas", insertar );
/****************************************************************************************************/
QGridLayout *rejilla = new QGridLayout (this, 20 , 2 );
tabla = new QTable ( 10 , 1 , this );

QHeader *cab = tabla->horizontalHeader();
cab->setLabel(0,"Cosas insertadas");
setMinimumSize (500,500);
cab->resizeSection ( 0, 200 );
cab->setResizeEnabled ( FALSE , 0 );
rejilla->addMultiCellWidget ( tabla, 1 , 19 , 0 , 0 );
void CFormulario::InsertarImagen()
{
{
tabla->setNumRows(indice + 1 );
tabla->repaint();
}
tabla->setPixmap ( indice , 0 , *imagen );
tabla->adjustRow(indice);
indice ++;
}
void CFormulario::InsertarCombo()
{
QStringList *lista = new QStringList();

lista->append("Martin Alganaraz");
lista->append("Sergio Valdez");
lista->append("Bruno Escalera");
lista->append("Lo que se les ocurra primero");

{
tabla->repaint();
}
tabla->setItem ( indice , 0 , new QComboTableItem (tabla, *lista , TRUE ) );

indice ++;
void CFormulario::InsertarCheck()
{
{
tabla->repaint();
}
tabla->setItem ( indice , 0 , new QCheckTableItem (tabla, "Checkeame") );

indice ++;
void CFormulario::InsertarTexto()
{
{
tabla->repaint();
}
tabla->setItem ( indice , 0 , new QTableItem ( tabla, QTableItem::Never , "texto insertado") );

indice ++;
}
/*Creo los slots, de los distintos widgets que insertaremos en la tabla*/
void CFormulario::InsertarLabel()
{
{
tabla->repaint();
}
label = new QLabel("<font color=#0000ff face=Akaash>Texto del label</font>", this , "label");
tabla->setCellWidget (indice, 0 , label);
indice ++;
void CFormulario::InsertarLCD()
{
{
tabla->repaint();
}
lcd = new QLCDNumber(this);
tabla->setCellWidget (indice, 0 , lcd );
for (int i = 0; i <= 1000; i++ )

lcd->display ( i + indice );
tabla->updateCell( indice, 0 );
indice ++;
void CFormulario::InsertarProgressBar()
{
{
tabla->repaint();
}
barra = new QProgressBar (this, "barra");
tabla->setCellWidget (indice, 0 , barra );

for ( int i = 0; i <= 1000; i++ )
barra->setProgress ( i + indice );
tabla->updateCell ( indice, 0 );
indice ++;
}
void CFormulario::InsertarTimeEdit()
{
{
tabla->repaint();
}
timeedit = new QTimeEdit (this, "timeedit");
tabla->setCellWidget (indice, 0 , timeedit );

indice ++;
void CFormulario::InsertarDial()
{
{
tabla->repaint();
}
dial = new QDial (this, "dial");
tabla->setCellWidget (indice, 0 , dial );

dial->setValue ( indice +1 );
tabla->updateCell(indice, 0);
indice ++;
void CFormulario::InsertarListView()
{
QListViewItem *item;
{
tabla->repaint();
}
lista = new QListView(this, "lista");
lista->addColumn ("Nombre: ");
lista->addColumn ("Apellido");
item = new QListViewItem ( lista, "Martin", "Algañaraz");

lista->insertItem( item );
tabla->setCellWidget (indice, 0 , lista );

tabla->adjustRow (indice);
indice ++;
void CFormulario::LimpiarCeldas()
{
tabla->repaint();
indice = 0;
}
CFormulario::~CFormulario()
{
delete Menu;
delete tabla;
delete imagen;
delete label;
delete lcd;
delete barra;
delete timeedit;
delete dial;
delete lista;
}
El fichero principal.cpp, (el main) no lo muestro porque por el momento es el mismo siempre.
Salida del programa:
Pasemos a explicar un poco como funcionan los menues, para esto vemos la declaracion del fichero de
cabecera (en formulario.h) qmenubar.h, este fichero se encarga de "preparar los menues", es como un
contenedor, que dentro puede contener otros "submenues" llamados qpopupmenu, que es endonde
almacenaremos los datos de un ambito en particular.
ej:
Estos son los submenues o QPopupMenu dentro de los cuales agruparemos los botones que queramos.
QPopupMenu *archivo = new QPopupmenu;
QPopupMenu *edicion = new QPopupmenu;
QPopupMenu *ver = new QPopupmenu;
QPopupMenu *insertar = new QPopupmenu;
QPopupMenu *formato = new QPopupmenu;
QPopupMenu *etc = new QPopupmenu;
Este es el menu principal o QMenuBar que contendra los submenues o QPopupMenu
QMenuBar *barra_de_menu = new QMenuBar ( this );
La manera de rellenar los submenues es la siguiente:
archivo->insertItem ("Nuevo" , this , SLOT (ArchivoNuevo () ) );
donde archivo es el identificador del submenu, y insertItem es la funcion encargada de insertar un item
( logico no? ), los parametros de la funcion InsertItem son los siguientes:
1): El texto que le queremos poner (lo que queremos que diga), aqui le podemos poner el texto, o alguna
imagen, o ambos ( ya mostrare las funciones )
2): el segundo parametro es la clase donde se almacenara, como se va haciendo costumbre lo ponemos en
nuestra clase con this.
3): El tercer parametro es un poco màs dificil de explicar, pero no se preocupen que es facil. Como se daran
cuenta, al boton del menu se le asocia inmediatamente una funcion de respuesta, pero en ninguna parte del
codigo lanzamos ninguna señal. Esto se debe a que el widget QPopupMenu, solamente soporta cuatro
señales, las cuales son:
1): activated (int id ) esta señal, se lanza cuando el boton se activa (cuando es pulsado)
2): highlighted (int id ) esta señal, se lanza cuando el boton se ilumina (cuando es apuntado con el mouse o
con el teclado)
3): aboutToShow () esta señal, se lanza justo despues que el menu es desplegado
4): aboutToHide () esta señal, se lanza justo despues que el menu es ocultado
La señal que por defecto conectamos siempre es activated (int id), como se daran cuenta, tampoco le
pasamos el id en la funcion de respuesta, esto se deve a que la funcion esta sobrecargada.
El slot adone se conectara la señal logicamente lo tendremos que crear nosotros.
Les dejo como tarea, (si quieren hacerlo) el crear una funcion, para poder interactuar, y poder atender las
señales de los items del codigo anterior, es facil, sobre todo si recuerdan, que casi todos los widgets derivan
de la clase base "abstracta" QWidget.
Veamos ahora, la clase QMenuBar, que es el contenedor.

QMenuBar
Constructor por defecto.
QMenuBar ( QWidget * parent = 0, const char * name = 0 )
Destructor
~QMenuBar ()
Enumeracion que contiene el tipo de separador deseado

enum Separator { Never = 0, InWindowsStyle = 1 }
Funcion, que inserta un item por defecto.

int insertItem ( const QString & text, const QObject * receiver, const char * member,
const QKeySequence & accel = 0, int id = -1, int index = -1 )
Funcion, que inserta un item, combinando un icono con texto

int insertItem ( const QIconSet & icon, const QString & text, const QObject * receiver, const char * member,
Funcion, que inserta un item, cobinando una imagen con el texto

int insertItem ( const QPixmap & pixmap, const QObject * receiver, const char * member,
Funcion, que inserta un item, cobinando un icono con una imagen.

int insertItem ( const QIconSet & icon, const QPixmap & pixmap, const QObject * receiver,
const char * member, const QKeySequence & accel = 0, int id = -1, int index = -1 )
Funcion, que inserta un item con solamente un texto

int insertItem ( const QString & text, int id = -1, int index = -1 )
Funcion, que inserta un item, en un QPopupMenu pasado como argumento.

int insertItem ( const QString & text, QPopupMenu * popup, int id = -1, int index = -1 )
int insertItem ( const QIconSet & icon, const QString & text, QPopupMenu * popup, int id = -1, int index = -1 )
Funcion, que inserta un item, como una imagen

int insertItem ( const QPixmap & pixmap, int id = -1, int index = -1 )
Funcion, que inserta un item, como imagen, en un QPopupMenu pasado como argumento
int insertItem ( const QPixmap & pixmap, QPopupMenu * popup, int id = -1, int index = -1 )
Funcion, que inserta un item, con el icono y la imagen en el QPopupMenu pasado como argumento.
int insertItem ( const QIconSet & icon, const QPixmap & pixmap, QPopupMenu * popup, int id = -1, int index =
-1 )
Funcion, que inserta un item vacio

int insertItem ( QWidget * widget, int id = -1, int index = -1 )
Funcion, que inserta un separador para los items.

int insertSeparator ( int index = -1 )
Funcion, que borra un item del menu, segun el id pasado como argumento
void removeItem ( int id )
Funcion, que borra el menu

void clear ()
Funcion, que RETORNA true, si el item con el id pasado como argumento esta abilitado
bool isItemEnabled ( int id ) const
Funcion, que abilita un item con el id pasado como argumento.

void setItemEnabled ( int id, bool enable )
Funcion, que retorna TRUE, si el item con el id pasado como argumento es visible.
bool isItemVisible ( int id ) const
Funcion, que hace visible el item pasado como argumento.

void setItemVisible ( int id, bool visible )
Señales:
void activated ( int id )

void highlighted ( int id )
Bueno, esto fue todo por el momento, pero no crean que terminara aqui, pronto creare otro tutorial, un poco
màs avanzado, que explicara el tratamiento de las imagenes en QT, y como crear formularios midi y hablare
un poco sobre el manejo de treads y procesos.
Pos: Disculpen por las faltas de ortografia, pero la culpa la tiene mi teclado, que es yanquee y no entiende
castellano.
Si tienen alguna duda, no duden en escribirme a martin_alganaraz@yahoo.com.ar
Saludos a todos, y si alguien sabe programar en qt, y le interesa traducir la documentacion de la libreria, por
fabor avisenme que con gusto los ayudare.
Escrito por: Martin Hernan Algañaraz.

Programacion Con QT PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion Con QT PDF

Cargado por

Copyright:

Formatos disponibles

Tutorial de desarrollo utilizando la librería QT 3.

class CFormulario : public QWidget

CFormulario::CFormulario(QWidget *parent, const char *name) : QWidget( parent , name )

int main (int argc, char **argv)

Bien, ahora el paso que más duele, la Explicación.

Luego, creamos un botón y lo posicionamos dentro del formulario, de la siguiente manera:

1. Primero declaro el objeto botón de la siguiente manera QPushButton *boton.

7. Posteriormente muestro el formulario, con la función show() de la clase QWidget.

Clases, Objetos y propiedades:

QString & operator= ( const QString & s )

bool isNull () const

bool isEmpty () const

uint length () const

Esta función trunca la cadena, ej:

QString s = "truncate la cadena";

void truncate ( uint newLen )

QString & fill ( QChar c, int len = -1 )

QString arg ( long a, int fieldWidth = 0, int base = 10 ) const

QString arg ( ulong a, int fieldWidth = 0, int base = 10 ) const

QString cadena = "Hola, esto es una prueba"

int find ( QChar c, int index = 0, bool cs = TRUE ) const

El resto de las funciones, están sobrecargadas.

int find ( char c, int index = 0, bool cs = TRUE ) const

int findRev ( QChar c, int index = -1, bool cs = TRUE ) const

El resto de las funciones, hacen lo mismo, solamente están sobrecargadas

int findRev ( char c, int index = -1, bool cs = TRUE ) const

QString cadena ("Cadena de prueba");

int contains ( QChar c, bool cs = TRUE ) const

int contains ( char c, bool cs = TRUE ) const

Esta función, retorna un QString, conteniendo una seccion de la cadena Ej:

QString cadena ( "cadena1,cadena2,cadena3,cadena4" );

El resto de las funciones, hacen lo mismo, solamente están sobrecargadas

QString cadena ( "ejemplo de cadenas" );

QString left ( uint len ) const

QString right ( uint len ) const

QString mid ( uint index, uint len = 0xffffffff ) const

Esta función, retorna la cadena un minúsculas

QString lower () const

Esta función, retorna la cadena un mayúsculas

QString upper () const

QString cadena(" ejemplo de cadenas " );

QString stripWhiteSpace () const

QString & insert ( uint index, const QString & s )

QString & append ( char ch )

QString & prepend ( char ch )

QString cadena( "Montreal" );

QString & remove ( uint index, uint len )

QString string( "Say yes!" );

QString cadena ( "5" );

short toShort ( bool * ok = 0, int base = 10 ) const

Esta función, agrega a la cadena un numero, ej:

QString & setNum ( short n, int base = 10 )

QString & operator+= ( const QString & str )

const QString string( "abcdefgh" );

QChar at ( uint i ) const

Esta función retorna retorna un puntero a un QChar, conteniendo la cadena

const QChar * unicode () const

Esta función retorna retorna un puntero a un const char, conteniendo la cadena

const char * ascii () const

Esta función retorna retorna un puntero a un const char, conteniendo la cadena

const char * latin1 () const

QString & setAscii ( const char * str, int len = -1 )

Esta función, simplemente redimensiona el tamaño de la cadena.

CFormulario::CFormulario(QWidget parent, const char name) : QWidget( parent , name )