Nokia libera Qt 4.5 y Qt Creator 1.0 - Qt Extended bolsa de pro
La noticia es vieja, pero todavía está caliente. En el último día Martes 03 de marzo, Nokia anunció la versión tan esperada 4.5 de Qt, dio una orden en Qt Extended y también lanzó la primera versión de Qt Creator.
La instalación y la integración de Eclipse CDT, Qt, Subversion, Perl, Herramientas Web de Vim y sólo con el ratón
Hace mucho tiempo en un puesto no muy lejos de aquí, nos mostrará cómo instalar plugins para Eclipse con el desarrollo de Qt y la integración con Subversion. Pero pasa el tiempo, el cambio de versiones y todo es diferente, y esta vez vamos a mostrar cómo hacer esto sólo con unos pocos clics y un Eee PC.
Eclipse + Qt + svn
Más bien como diario personal de un tutorial, sentí la necesidad de salir de un lugar fácilmente accesible, los pasos de configuración del eclipse para mi propio uso, o la instalación de Eclipse y los plugins que normalmente utilizan (svn y cuarto de galón) .
Los comandos que afectan a los directorios fuera de su hogar, necesita el permiso de superusuario.
Si decide instalar el eclipse a partir de paquetes disponibles en su distribución, se puede saltar directamente al paso # 2.
# Paso 0: Instalar Java
Para el trabajo de eclipse, lo que necesita el Java Runtime Environment (JRE) instalado * E * configurado.
El JRE se pueden descargar directamente desde el sitio de Sun http://java.sun.com/javase/downloads/index.jsp . Las instrucciones completas para la instalación y configuración se puede encontrar en http://java.sun.com/javase/6/webnotes/install/index.html , para el caso de Java 6.
Paso # 1: descargar e instalar Eclipse
El eclipse se puede descargar fácilmente desde la zona de descargas en su web oficial: http://www.eclipse.org/downloads . Después de descargar, basta con descomprimirlo y dejar de usar. En mi caso he utilizado:
-xvzf eclipse-cpp-europa-winter-linux-gtk.tar.gz -C / usr / local user @ host $ tar-xvzf eclipse-cpp-europa-invierno-linux-gtk.tar.gz-C / usr / local
Si todo funcionó el eclipse será ejecutable en / usr / local / eclipse / eclipse, entonces basta con crear un enlace / acceso directo / lo que sea en su entorno gráfico favorito.
Paso # 2: Descargar e instalar el plugin de la integración con QT
El plug-in que utiliza actualmente es proporcionado por Trolltech propia. Allí usted puede administrar sus archivos de proyecto de un pequeño editor de gráficos, e incluso si lo prefiere, tienen acceso directo al archivo. Pro.
La puede descargar desde http://trolltech.com/developer/downloads/qt/eclipse-integration-download , e instrucciones completas de instalación que se puede encontrar en http://trolltech.com/developer/downloads/qt / qteclipse-installmanual es muy complicado:
-xvzf qt-eclipse-integration-linux.x86-gcc3.3-1.4.0.tar.gz -C / usr / local user @ host $ tar-xvzf qt-eclipse-la integración-linux.x86-gcc3.3-1.4.0.tar.gz-C / usr / local
Si todo ha ido bien, los archivos del plugin se copian en el directorio / usr / local / eclipse / plugins.
Nota: Para los que optaron por la instalación del eclipse a través del paquete de distribución, atención! Dentro del archivo comprimido, el directorio es eclipse / plugins / y dentales él los archivos del plugin, que se deben copiar al directorio de plugins de tu instalación de Eclipse, normalmente / usr / lib / eclipse / plugins.
Después de la instalación, inicie Eclipse con el comando:
usr / local / eclipse / eclipse -clean user @ host $ / usr / local / eclipse / eclipse de limpieza
Ahora, vaya a Ventana> Preferencias> y establecer la versión de Qt y "Pathes", de acuerdo con la instalación de Qt
Para ser más conveniente si se invoca el eclipse directamente desde la línea de comandos, agregue el directorio de su archivo ejecutable en la variable de entorno $ PATH en alguno de los scripts de inicio (. Bash_profile)
= $PATH : / usr / local / eclipse export PATH = $ PATH: / usr / local / eclipse
Paso # 3: Subversion
En Eclipse vaya a Ayuda> Actualizaciones de software> Buscar e instalar. Madonna di Campagna la opción Buscar nuevas características para instalar y haga clic en Siguiente. Ahora agregue los sitios remotos:
Buckminster
http://download.eclipse.org/tools/buckminster/updates
Subclipse
http://subclipse.tigris.org/update_1.2.x
Marque las casillas correspondientes y haga clic en Finalizar. Después de una breve consulta a Internet, basta con activar el plug-in y las dependencias y corre a abrazarlo.
A partir de QT, Parte III - qmake y Pro.
En este tercer post vamos a hablar de QT archivos de proyecto de servicios públicos y * qmake. Pro. Vamos a entender lo que es para qmake y cómo configurar diferentes tipos de proyectos.
El qmake
El qmake es una utilidad que viene con el marco del intervalo QT. Su función es analizar un archivo de proyecto (*. Pro) y generar un Makefile ya con las reglas del moc , uic y las opciones de QT incrustados. Sin ella, por ejemplo, tendría que llamar explícitamente al Ministerio de Comercio para crear archivos y moc_ * explícita pasar a las opciones del compilador y enlazador de incluir la QT correcta a nuestros proyectos.
La documentación oficial acerca de los archivos qmake y el proyecto se puede encontrar aquí .
* Los archivos de proyecto. Pro
Para crear un proyecto simple de la línea de comandos, escriba el directorio del proyecto y escribiendo:
user @ host $ qmake-project
Una vez hecho esto, se creará un archivo con el mismo nombre que el directorio actual, seguido de la extensión. Pro. Si ya existen archivos de este directorio reconocidos por qmake, como archivos de código fuente (. H. CPP), formas (. Ui), etc, que se agregan automáticamente al archivo del proyecto.
Creado el archivo. Pro, para ejecutar qmake sin argumentos que tratará de analizar un archivo. Pro con el mismo nombre que el directorio actual. Usted puede incluso especificar un archivo de proyecto alternativo como un argumento para qmake. Si todo funcionó, fue creado un Makefile, y con una marca sencilla, podemos construir el proyecto.
Los archivos de proyecto son los archivos normales de texto que contienen macros y directivas que serán interpretados por qmake para crear el Makefile. La lista completa de opciones se puede encontrar en la documentación en línea . Los más comunes son:
PLANTILLA: Indicar el tipo de proyecto. Use 'app' para ejecutables proramas o 'lib' para crear bibliotecas.
CONFIG: Añadir varias opciones para el proyecto. Entre ellos, la información de 'depuración' de depuración para añadir, "staticlib" junto con "lib" de la plantilla, que se crea abiblioteca estática (. Que en linux).
OBJETIVO: El nombre y la ubicación de la meta, es decir, la aplicación o una biblioteca.
MOC_DIR: directorio donde los archivos serán graduados moc_ *. Útil para no contaminar el directorio del código fuente.
OBJECTS_DIR: Como complemento a la opción anterior indica que el directorio donde los archivos que va a generar código objeto (* S)..
IncludePath: directorios externos en las cabeceras se van a utilizar en el proyecto, como los encabezados de librerías externas.
DEPENDPATH: externos directorios de código fuente que se utilizarán en el proyecto.
ENCABEZADOS: Los archivos de cabecera del proyecto (* H.).
FORMAS: Los archivos generados con la interfaz de QtDesigner (* Ui.).
FUENTES: Los archivos de la aplicación del código fuente del proyecto (* CPP.).
LIBS: bibliotecas externas utilizadas por el proyecto. -L indica el camino a la biblioteca, e-l dice que el nombre de la biblioteca.
QT: los módulos de QT para ser añadido / eliminado del proyecto. Si el pasado "QT = '(QT es igual a vacío), QT hay ningún módulo utilizado en el proyecto.
SUBDIRS: Se utiliza en conjunción con 'subdirectorios' de la plantilla indica el qmake subdirectorios complementos deben buscar otros archivos de proyecto.
Con esta mano en el que podemos crear diseños simples ALGUNOS.
Una aplicación sencilla:
# La primera línea crea un personaje de este comentario # El nombre de este archivo es 'app.pro' Nuestra plantilla # = plantilla de aplicación es una aplicación llamada TARGET = / bin # myapp.bin myapp.bin en el directorio. / Bin MOC_DIR = tmp / moc # Directorio para MOC, opcional OBJECTS_DIR = tmp / obj # directorio de código objeto, opcional HEADERS + = MyClass.h Header # class MiClase FUENTES + = main.cpp # Se utiliza para organizar los archivos en # MyClass.cpp líneas múltiples.
Una biblioteca muy simple:
# El nombre de este archivo es 'lib.pro' Nuestra plantilla # = plantilla lib es una biblioteca CONFIG + dll = # dinámica llamada TARGET = lib / mylib # mylib en el directorio. / Lib MOC_DIR = tmp / moc # Directorio para MOC, opcional OBJECTS_DIR = tmp / obj # directorio de código objeto, opcional HEADERS + = MyClass.h Header # class MiClase FUENTES + = MyClass.cpp # Implementación de clase MyClass
Una aplicación que utiliza una biblioteca externa:
# El nombre de este archivo es el # 'mixed.pro' TEMPLATE = app Nuestra plantilla es una aplicación llamada TARGET = / bin # myapp.lkd myapp.lkd en el directorio. / Bin MOC_DIR = tmp / moc # Directorio para MOC, opcional OBJECTS_DIR = tmp / obj # Directorio para el código objeto, IncludePath opcional + =. # Dir, donde se encuentran las cabeceras de las Fuentes externas lib + = main.cpp # Implementación de la aplicación.
Directorios anidados:
Para utilizar directorios anidados, necesitamos un archivo de proyecto en el directorio actual, y el subdirectorio a otro.
En el directorio actual, utilice las opciones:
Template = subdirectorios SUBDIRS = [lista de subdirectorios que se construirán en la secuencia]
Si se les da sólo el nombre del directorio, debe contener un archivo de proyecto con su propio nombre. ¿Es posible en entando, reportará directamente a la lista de subdirectorios, un directorio seguido de un archivo de proyecto con el nombre de los cuáqueros.
El código fuente completo de los ejemplos en este tutorial se puede encontrar aquí .
En conclusión
El qmake es una herramienta sencilla y muy potente que facilita enormemente la vida de uno que tiene para manejar árboles de proyectos complejos, incluso si el proyecto no utiliza QT (sólo tiene que añadir al final de la 'QT ='). Añadir a esto el hecho de que los archivos de proyecto tienen una sintaxis muy sencilla e intuitiva en cierta medida. Si necesita realizar ajustes más precisos, la documentación en línea le dará una docena de opciones para la diversión.
Con o sin QT QT qmake es siempre una buena opción para el manejo de árbol de construcción.
A partir de QT, Parte II - Señales, Tragaperras y temporizadores
En este post he seguido con el juego para hacer pequeños tutoriales para principiantes en el intervalo QT. Esta vez voy a mostrar cómo crear sus propias señales y ranuras y cómo manejar un temporizador.
El código fuente se puede encontrar en este enlace .
El programa de ejemplo es un contador de tiempo que va a utilizar la clase QTimer , una de las principales clases de la QT, y se mostrará la hora con un estilo de LCD de calculadora de pantalla con la clase QLCDNumber .
QT y temporizadores
Los temporizadores de apoyo más básicas en el intervalo QT se encuentra disponible en la clase que proporciona métodos QObject startTimer :: QObject () y QObject :: KillTimer () . El primer método devuelve un identificador único y el segundo temporizador finaliza el temporizador a través de esta identificación.
Para que esto funcione, sin embargo, el fragmento de código que utiliza este mecanismo tiene que ser dentro de un "bucle de eventos". Desde el momento en que el temporizador se comenzó de vez en cuando (tiempo de espera) hace que una aplicación dispate QTimerEvent , lo cual interrumpe el flujo normal del programa hasta que el evento se procesa.
El tiempo de espera máximo no está definido, y se pueden crear temporizadores con tiempo de espera de años, sin embargo, el tiempo mínimo que puede variar de sistema a sistema. En Windows Vista, el contador de tiempo mínimo es de 10 ms, mientras que en Linux 2.6.x esto es configurable (por defecto es 4 ms). El intervalo QT intentará entregar todos los eventos, conforme a lo solicitado, pero si el sistema no permite que se deseche el "excedente".
Los temporizadores también puede ser utilizado en los hilos, pero debe cumplir con el requisito de estar dentro de un ciclo de eventos. Temas merece un artículo aparte, como siempre ...
Las clases QTimer temporizadores implementa un nivel más alto, lo que permite algunas funciones. Uno es el QTimer :: SingleShot () , que dispara un evento una vez.
Lea la documentación extensa y repetitiva, aburrida, pero créanme, se ahorrará una gran cantidad de QDorDeCabeca ...
Más sobre Señales y Rastros
Las señales y ranuras se utilizan para la comunicación entre objetos, una de las partes fundamentales de la QT. En este sistema, en lugar de aplicar las devoluciones de llamada para controlar los eventos, se utiliza el concepto de conexión de las señales a las franjas horarias, lo que hace la programación más intuitiva.
Señales y slots son los métodos de clase que son manejados por el compilador Meta-Objeto (MOC) antes del código de fuente que se compila. Tienen declaraciones especiales que no forman parte de C + + estándar, por lo que fazum moc analizar el código fuente y genera compilable.
Cuando se ejecuta el Ministerio de Comercio de cualquier clase que implemente las señales y ranuras, una cierta cantidad de código fuente se genera. Con el programa qmake , moc la llamada al programa es asumido por el Makefile, por lo que es transparente para el programador.
Para una clase puede implementar señales y slots, es necesario el acceso al Sistema de Meta-Objeto . Por lo tanto, debe heredar de la clase QObject y sus subclases, y la necesidad de que la macro Q_OBJECT en su declaración de privacidad área. Terminado los preparativos, las señales se declaran en una sección de "señales" en las secciones y las franjas horarias "[public | | protegidas privadas] slots".
Una ranura después de declarada, se define como cualquier otro método común, puede ser llamado explícitamente como cualquier otro. Ya los signos son un poco más delicado, y sólo alguna vez definido y declarado por el programador. ¿La razón? Este mensaje al final del intento de construir:
tmp / moc_mydisplay.o: En la función `MyDisplay :: signalPlay () ': ~ / Cronómetro / tmp / moc_mydisplay.cpp: 89: definición múltiple de `signalPlay MyDisplay :: () ' tmp / mydisplay.o: ~ / cronómetro / mydisplay.cpp: 169: en primer lugar se define aquí collect2: ld devolvió el estado de salida 1 hacer: ** [cronómetro] Error 1
Dentro del archivo se genera moc_mydisplay.cpp el siguiente código:
/ / 0 SEÑAL signalPlay ( ) MyDisplay vacío :: signalPlay () { activate ( this , & staticMetaObject , 0 , 0 ) ; QMetaObject :: Activate (esto, y staticMetaObject, 0, 0); }
Sí, moc genera señales con la definición de los llamados meta-métodos de QT. Por lo tanto, la definición del cuerpo de un signo es ilegal en la TC y generará un error de compilación para el método de reposición. Que moc se encarga de la ejecución de la señal para usted.
Conectar
No es de utilizar sólo las señales establecidas y las franjas horarias. Se debe definir cómo van a interactuar. La forma de hacerlo es mediante la conexión a través del método connect () a través de este heredero de QObject . Esto moc poner en práctica la señal para que una llamada a que da lugar a la llamada (s) ranura (s) de conexión (s) con los mismos parámetros.
Dependiendo de la conexión, la señal puede incluso devolver el mismo valor que la última plaza volvió a llamar. Nótese que esto no es muy seguro para señales conectadas a varias ranuras, por lo tanto, nada garantiza el orden de llamada.
Una señal dada se puede conectar a una segunda señal directamente. Un emiten () en la primera señal es entonces equivalente a emitir () en la segunda señal, mientras que después de la etapa de creación de las MOCs, los resultados de llamadas en la primera a la segunda llamada, lo que resulta en la llamada conectada a otro método, y así sucesivamente .
Formas de conectar
Hay básicamente tres formas de conectar señales y slots, y si no se utiliza correctamente puede ser una fuente de errores terriblemente difíciles de descubrir. Estas formas de conexión se pasan como parámetro adicional al método connect (). Ellos son:
Conexión directa : La ranura se llama inmediatamente la señal se ha emitido en el hilo donde se emitió la señal. Esto actúa como una llamada directa a la ranura.
En cola de conexión : La señal es enviada y la llamada a la ranura va a una lista interna de la QT, y la señal regresa inmediatamente, independientemente de la ranura se han llamado o no. El lazo entonces EVENTE el procesamiento de esta lista y sólo después de la ranura se invoca en el subproceso donde reside el objeto de la ranura.
Conexión automática : Este es el tipo usado por defecto si no se especifica el tipo de conexión. Es una de las "semillas del mal" , presenta dos comportamientos diferentes: si la señal y la ranura se encuentra en el mismo hilo, funciona como una conexión directa, pero por lo demás funciona de conexión como en la cola.
Bloqueo de conexiones en cola : Hey!? no eran sólo tres? Bueno, esta es una de las ventajas de leer este artículo: le ahorra la documentación inconsistente! Esta conexión es similar a la conexión en cola, excepto que el hilo de la señal se bloquea hasta que la señal sea debidamente ejecutado. Tenga en cuenta que sólo debe utilizarse con mucho cuidado, y las señales y ranuras en diferentes hilos. El mal uso también puede causar bloqueos. Usted sabrá cuando vea algo como esto:
user @ host: ~ / cronómetro $ / cronómetro. Qt: bloqueo de la muerte detectada, mientras que la activación de la BlockingQueuedConnection: El remitente es QPushButton (0x807e2d8), el receptor es MyDisplay (0x8076ac0)
Para resolver las dudas sobre qué se entiende por "hilo donde se encuentra un objeto" se refieren a la rosca del intervalo QT arespeito.
Siempre tener mucho cuidado con las señales, las ranuras, hilos y temporizadores. Estas son las principales características de QT, pero su mal uso puede llevar a errores muy difíciles de localizar. Ver toda la documentación al respecto.
Abajo a la fuente
Nuestro ejemplo es componer de dos clases de archivos y MyDisplay Cronómetro y un principal común. El principal y único crea un objeto QApplication Cronómetro. La clase se encarga de la parte MyDisplay visual del programa, que consiste en un cuadro de diálogo con botones y una pantalla LCD de estilo. La clase Stopwatch va a crear un widget para mostrar y poner en práctica el temporizador. Tenga en cuenta que esta arquitectura no es la más elegente, más interesante para heredar de la clase Stopwatch MyDisplay. Pero eso sería estropear el juego eliminando virtualmente la necesidad de usar señales y slots.
El uso de las señales y las ranuras se hace más clara cuando queremos objetos para comunicar con el exterior. En general, las clases no saben lo que está fuera. Pasar punteros a los objetos externos dentro de ellos, me duele la encapsulación y hace que el código sea menos genérico. En nuestro ejemplo, el más interesante de usar señales y slots es myDisplay al objeto (el cronómetro interno) reportar los eventos desde / hasta el cronómetro objeto (MyDisplay externa), sin que ello se pierde en la generalidad o la encapsulación.
Con la ayuda de Qt Designer (en otro artículo voy a hablar de ella), he creado el cuadro de diálogo, los botones y la pantalla LCD. Después de simplificar el código para adaptarse a nuestros propósitos. ¿Cómo se hereda de myDisplay QDialog, y esto se hereda de forma indirecta QObject, usar señales y slots fue suficiente para agregar la macro Q_OBJECT en la sección privada de la declaración de la clase. Después de que, entre otras auxiliar añadido, los métodos:
public slots: long ) ; slotDisplayValue vacío (de largo); espacios privados: slotPlay vacío (); void slotStop (); señales: signalPlay vacío (); void signalPause (); void signalStop (); void signalReset ();
Las señales de comunicación a los eventos externos relacionados con pulsaciones de botón. Ya los espacios privados harán un procedimiento de pre-procesamiento, mientras que el público tiene derecho a pasos de temporizador desde el exterior. Por lo tanto, la clase envía información al exterior y recibe información desde el exterior, sin saber lo que está en el otro lado. El contrato de buena interfaz de edad.
public slots: slotPlay vacío (); void slotPause (); void slotStop (); void slotReset (); espacios privados: void slotTick (); señales: long ) ; signalTicks vacío (de largo);
Analógica y por el contrario la clase Stopwatch implementa las ranuras que reciben la clase MyDisplay señales, y declara que la señal que envía la información al público su ranura.
También implementa un QTimer que se activará cada 10 milisegundos (para que nuestros amigos pueden seguir lerdinhos Vista!), Incrementando un contador. Este contador es enviado de vuelta a los formatos de visualización y pantallas.
El temporizador se puede detener, pausar y reiniciar en cualquier momento haciendo clic en el botón apropiado.
Los Finalmentes
El mismo ejemplo, no es mucho código, pero ilustra el uso más básico de los temporizadores y la construcción de las señales de medida y las franjas horarias. Una atención muy especial, sin embargo, se debe dar a los detalles que implican el uso de estos recursos, que pueden convertirse en trampas mortales.
Enlaces importantes
Señales y Rastros
QTimer
Temas en el intervalo QT
La documentación en línea de la QT
A partir de QT, Parte I
Previa solicitud, me decidí a hacer un breve artículo que muestra para empezar a aventurarse con la QT.
En Apanas 20 líneas, con el espacio (sí, el espacio es su amigo, que no deje) y las cabeceras extra, podemos hacer un "Hola Mundo" gráfico, que ya utiliza las características principales del marco.
Como no tengo manera de probar en otras plataformas, estoy asumiendo que la plataforma utilizada es un * nix, y que las bibliotecas de desarrollo de QT se han instalado ya, así como las herramientas estándar de la construcción. Si el intervalo QT no está instalado, es hora de echar un vistazo a este enlace .
El código fuente completo se puede descargar desde el ejemplo aquí , pero si usted prefiere hacerlo a mano, crear un directorio en cualquier parte qthello y dentro de un archivo llamado main.cpp con el siguiente contenido:
01 # include <qapplication> 02 # include <qwidget> 03 # include <qpushButton> 04 main ( int argc , char ** argv ) 05 int main (int argc, char ** argv) 06 { app ( argc , argv ) ; 07 QApplication app (argc, argv); window ; 08 QWidget ventana; button ( "Hello World!" , & window ) ; 09 QPushButton botón ("Hello World!", Y ventanas); 10 ( 300 , 200 ) ; Cambiar el tamaño de ventana de 11 (300, 200).; ( 100 , 85 , 100 , 30 ) ; . 12 Botón setGeometry (100, 85, 100, 30); 13 :: connect ( & button , SIGNAL ( clicked ( ) ) , 14 QObject :: connect (y botón, SIGNAL (clicked ()), SLOT ( quit ( ) ) ) ; Y aplicación, SLOT (dejar de fumar ())); 15 ( ) ; 16 ventana de Show ().; app. exec ( ) ; 17. Retorno aplicación Exec (); 19} 20
Ahora ve a través de un terminal de ese directorio y el tipo de qmake-project.
Si todo está instalado correctamente, un archivo llamado qthello.pro debe haber sido creado. Si no hay un directorio de qthello.pro, a continuación, revise el paso anterior.
Con todo resuelto en un && qmake de terminales de tipo hacen. Esto compilará el ejemplo y todo salió bien, un archivo ejecutable llamado qthello fue creado.
Ejecutar con. / Qthello y una ventana con un botón debería aparecer.
Ok, ahora vamos a la parte divertida: el código fuente.
Las tres primeras líneas contienen únicamente encabezados pertenecientes a las clases que vamos a usar Qt.
La línea 7 declara una aplicación QT y lo pasa a los parámetros recibidos por el programa de shell. La clase QApplication maneja el flujo principal del programa y su configuración. Contiene el bucle principal de eventos, donde todos los eventos de la interfaz y otras fuentes son procesadas y enviadas. También gestiona el inicio y el cierre del programa, entre otras cosas.
La línea 8 se declara un widget que será nuestro elemento gráfico principal.
La línea 9 se declara un botón con el texto "Hello World!" Y hace que sea un "hijo" de nuestro widget principal. Esto hará que el botón aparezca en el widget principal.
Las líneas de 11:12 configurar los componentes de la forma y posición.
La línea 14 muestra una de las principales características de la estructura, el sistema de señales-Slot.
Señales y slots son usados para realizar la comunicación entre objetos. A través de este sistema puede disparar un objeto (emiten) un evento (señal) que pueden ser capturados y procesados por una (o más) objeto (s). Señales y slots son métodos especiales de la clase. Básicamente, la emisión de una señal se traduce en una llamada a la ranura a través de la moc (meta-objeto compilador) , que preprocesa el código fuente antes de la compilación. Para cada clase que implementa las señales y las ranuras, se genera un archivo llamado moc_nomedaclasse.cpp, que luego se compila junto con el resto del código. Todo esto se hace de forma transparente y por lo general el programador no tiene que preocuparse por estos detalles. En términos prácticos, emiten una señal de signigica la ranura asociada a ella a través de una llamada de conexión es de alguna manera con los mismos parámetros que se pasan a la señal. Más información se puede comprobar en la documentación en línea.
En nuestro ejemplo, los enlaces que conectan la señal de hacer clic en el botón () objeto, con la ranura para dejar de fumar () la ejecución del objeto. Esto significa que al hacer clic en el botón, se activa una señal y posteriormente capturado por el objeto de la aplicación, y luego termina el proceso.
En la línea 16, llame al método show () del widget para que sea visible.
En la línea 17, que finalmente controlar el programa de la QT. El método exec () se activará el bucle principal y todos sus mecanismos, y sólo volverá cuando la aplicación haya terminado, en nuestro caso, cuando app.quit () es llamado por el sistema de señal de la ranura.
Este simple "Hello World" puede sonar tonto, pero es suficiente para demostrar algunas de las características clave de QT, ya que el bucle principal, la creación de objetos gráficos y el uso de señales y slots.
En el próximo post voy a mostrar para crear nuestras propias señales y ranuras y el uso de temporizadores.
Referencias:
QApplication
QWidget
QPushButton
Sinais e Slots
Construindo um gerenciador de interface simples para sistemas multi-janelas com QT
Em diversas ocasiões acabei tendo que dar manutenção em interfaces de sistemas com muitas telas, sejam elas gráficas ou em modo texto. Muitas vezes, a quantidade de telas foi crescendo junto com o sistema sem um planejamento prévio, o que sempre levava a um emaranhado de chamadas obscuras, #ifndefs, switches, entre outros monstrinhos.
A primeira vez que eu me deparei com um problema do gênero, foi quando eu estava fazendo a primeira versão de um jogo parecido com o saudoso Elifoot para uma feira no CEFETES. Na época eu me deparei com um conjunto de funções onde elas chamavam umas às outras e só retornavam quando acontecia o gol. Resultado: haja pilha!!! (Não se preocupem, na nova versão isso foi corrigido!)
No caso das interfaces, com várias janelas, e em sistemas onde o planejamento ocorre on-the-fly, é comum termos janelas que chamam outras janelas que fecham as janelas anteriores e assim por diante, deixando pra trás um rastro de destruição e terror. Acredite, você não vai querer nunca dar manutenção num treco desses.
Do pó ao pó…
No meu caso, resovi o problema criando um gerenciador de interface. Um objeto centralizador que controla a criação e destruição dos objetos de interface. Cada objeto, ao terminar suas tarefas, sinaliza para o gerenciador e ele cuida de limpar a sujeira. Assim, um objeto sempre nasce, realiza suas tarefas e morre sem passar o controle do programa para frente, ele sempre volta para o gerenciador.
Tenga en cuenta que yo no he dicho que el gerente va a destruir el objeto, sino que va a hacer la limpieza. Cada objeto tiene que ser construido con el fin de avisar al administrador de cada vez que haya terminado, ya sea con éxito o no. A menudo, el objeto en sí mismo es capaz de "matar" y que por sí sola es muy útil, teniendo algunos de los gestor de trabajo, pero no el control.
Antes de comenzar
No pretendo que este simple post cubre todas las características de QT o todos los aspectos de las interfaces de administración. Sólo voy a hablar de cómo he resuelto un problema para el que lo hice. Este post es también un homenaje a un amigo Janeiro Paulo-Río de que ha tenido que pelar una piña de esa manera!
Manos sobre
Yo soy, en la mayoría de los casos, un programador de abajo hacia arriba, pero un analista de arriba hacia abajo. Esto puede parecer confuso, pero no hay motivo de pánico, o casi ...
Los objetos tienen que intercambiar mensajes. Para ello, el sistema de señal de la ranura de QT será de gran ayuda. Los objetos se envían señales (emiten (señal)) y el director va a escuchar a ellos (las ranuras ()).
Sorprendentemente, el constructor de la gerente, de ahora en adelante llamada la UIM no tiene una sola línea de código. Sólo se inicializa el puntero a 0, sólo por la paranoia (o no) ...
La UIM implementa ranuras para la creación de objetos y limpiar el desorden. Cuando se crea un objeto, la UIM se conecta este objeto para su limpieza respectiva ranura. Cuando el objeto se muere, se activa la ranura de limpieza en la UIM. Las ranuras estarán vinculados a la creación de los menús gráfico de objetos principales de este ejemplo, una ventana.
Los otros objetos son pequeñas ventanas, cuadros de diálogo de configuración de la aplicación de uno y de dos a hablar de sí mismo (aproximadamente), después de todo, el marketing es importante ...
Todos los objetos gráficos que hacer clic y arrastrar el Qt Designer y luego se ajusta para llegar a mi manera. Nada de lo que la alineación de píxeles en la mano, después de todo no es una obra de arte es sólo una prueba de concepto.
Los objetos gráficos
La pantalla de configuración es un diálogo común con un cuadro combinado, cuando se trate de una lista de parámetros que se pasan a la página de widget. Los detalles que he añadido el código generado por Qt Designer tiene un destructor, y un par de señales de la ranura para enviar los datos seleccionados de nuevo a la gerente. No me molesté en hacer un seguimiento de la configuración actual. Este chat es para otro post.
El paradero era básicamente el mismo código, más destructores.
La ventana principal tiene un menú que llama a las otras ventanas y un completo widget de locos de las plazas que están intermitentes. El cuadrado es la cantidad de información que va a cambiar la configuración de la ventana.
El intervalo QT Magic
Todos los objetos gráficos utilizados son también QWidgets debido a que sus clases se heredan de la clase QWidget, y utilizo el siguiente constructor en cada método heredado:
this-> setAttribute (Qt :: WA_DeleteOnClose, true); De acuerdo con la documentación en línea , esto le dice a Qt que se debe eliminar el widget cuando está cerrado. De lo contrario, se acaba de ocultar.
"... Cuando un widget acepta el evento de cierre, que está escondido ..."
"... Si quieres que el widget se eliminará cuando se cierra, se crea con el Qt :: WA_DeleteOnClose bandera. Esto es muy útil para el control independiente de nivel superior de Windows en una aplicación multi-ventana ... "
Las rutinas que hacen que los objetos finales en el fracaso, como hacer clic en Cancelar o en Cerrar, se conectan directamente a su fin propio ranuras (). Esto desencadena una serie de eventos que culminan en la destrucción del objeto.
Las rutinas que son el objeto se completa con éxito, como hacer clic en Aceptar y enviar los datos, se dirigieron a volver a la UIM, por lo que puede encaminarlos. Después de conseguir los datos, la ranura de tarjeta UIM llama directamente a cerca del objeto ().
Cuando un objeto es destruido, le envía su último aliento, por ejemplo, una señal de que se destruye (). Literalmente, le grita "YO FUI".
Desde "afuera" del objeto, la UIM está a la escucha, la conexión de esta señal a la limpieza de rutina y TADÃM! listo.
En el ejemplo que he utilizado, la cantidad de plazas en la pantalla viene MyConf de un objeto, y pasa a través de la UIM se dirige a la MyApplication. Esto a su vez la remite al widget locura interna.
Para obtener aún más interesante, mientras que una ventana más pequeña que se abre, el control deja de parpadear, regresando cuando la escotilla está cerrada. Suena tonto, pero eso era sólo para mostrar que la UIM tiene el control total sobreo lo que sucede en cada ventana, mientras ella estaba en el foco o no.
Conclusión
El marco del intervalo QT es inmenso y ofrece una serie de características del área de distribución grandes. Uno de ellos es capaz de controlar cómo los objetos son destruidos. El uso de este, junto con un poco de planificación y, junto con el sistema de señal de la ranura se puede construir una interfaz muy compleja, sin convertirlo en un Tarrasque tiempo para mantener.
Fuente:
PD: El ejemplo de código fuente completo se encuentra bajo la licencia GPL y puede ser descargado a través de este enlace . Un día me puse comentarios sobre el mismo ...
Arreglado
El insecto desafortunado se escondió en la ausencia de propiedades de inicialización en el constructor de la clase MySquares. La mascota, aunque pequeña era venenoso, debido a que causa un "Segmentation Fault '. Al iniciar el programa, si yo fuera en cualquier lugar alrededor, y se cierra, se disparó una secuencia de eventos que surgieron de la suposición de que la pantalla ya estaba configurado correctamente. El código corregido se encuentra en el enlace de arriba, y recuerde:
"Siempre inicializar las variables"
Traductor
