Está en la página 1de 99

Tutorial de desarrollo utilizando la librería QT 3.2

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

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

)

algo, que considero necesario saber antes

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

), el

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.

Constructores:

QString

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("

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

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.

Constructor por defecto QCString ()

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 bool isNull () const

Función que retorna TRUE, si la variable esta vacía bool isEmpty () const

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.

Constructor por defecto 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

Constructor por defecto 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

Constructor por defecto QPtrList ()

Constructor copia con otro tipo QPtrList ( const QPtrList<type> & list )

Destructor

~QPtrList ()

QPtrList

Operadores sobrecargados 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 bool isEmpty () const

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 ()

Constructor por defecto 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.

Constructor por defecto 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 bool isNull () const

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 ()

Operadores sobrecargados 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 }

Constructor por defecto 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 bool isNull () const

Función que retorna TRUE si el objeto esta vacío bool isEmpty () const

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 ()

Operadores sobrecargados 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

Constructor por defecto 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 **

Constructor por defecto QStrList ( bool deepCopies = TRUE )

Constructor copia QStrList ( const QStrList & list )

Destructor

~QStrList ()

QStrList

operador sobrecargado QStrList & operator= ( const QStrList & list )

Función que crea un Iterador. typedef type * Iterator

Función que crea un Iterador constante. typedef const type * ConstIterator

Constructor por defecto QMemArray ()

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 bool isEmpty () const

Función que retorna TRUE si el dato es nulo bool isNull () const

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

Operadores sobrecargados 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.

Miembros públicos:

QWidget:

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 nuevo estilo QStyle * setStyle ( const QString & style )

)

y retorna un puntero con el

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.

e l tipico e s q u e m a d e las señales. Como vemos,

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 <qpushbutton.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 #include "cabecera.h"

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:

Constructor por defecto 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. QString text () const

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 virtual QSize sizeHint () const

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. virtual void setText ( const QString & )

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 }

Constructor por defecto 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. QString text () const

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 )