GUI codificada a mano versus GUI de Qt Designer [cerrado]

Estoy pasando estas vacaciones aprendiendo a escribir aplicaciones Qt. Estaba leyendo sobre Qt Designer hace unas horas, lo que me hizo preguntarme: ¿qué usan las personas que escriben aplicaciones del mundo real en Qt para diseñar sus GUI? De hecho, ¿cómo diseña la gente las GUI en general?

Yo, por mi parte, descubrí que escribir el código a mano era conceptualmente más simple que usar Qt Designer, aunque para las GUI complejas, Designer podría tener sentido. Las GUI grandes pueden ser posibles usando Designer, pero con el tiempo pueden volverse muy difíciles de administrar a medida que aumenta la complejidad (esta es solo mi opinión). También descargué el código fuente de AmaroK para echar un vistazo a lo que estaban haciendo esos tipos, y encontré muchas llamadas a addWidget () y amigos, pero ninguno de esos archivos XML creados por Designer (aparte: AmaroK tiene que ser mi aplicación favorita. cualquier plataforma).

Entonces, ¿cuál es la forma "correcta" de crear una GUI? ¿Diseñador o código? Para esta discusión, consideremos los siguientes tipos de GUI:

1. Diálogos simples que solo necesitan tomar entrada, mostrar algún resultado y salir. Supongamos una aplicación que toma una URL de YouTube y descarga el video al disco duro del usuario. El tipo de aplicaciones con las que es probable que comience un novato.
2. GUI de nivel intermedio como, por ejemplo, un editor de notas adhesivas con algunos elementos de barra de herramientas / menú. Tomemos xPad por ejemplo ( http://getxpad.com/ ). Yo diría que la mayoría de las aplicaciones entran en la categoría de "utilidades".
3. GUI muy complejas, como AmaroK u OpenOffice. Los reconoces cuando los ves porque te hacen sangrar los ojos.

Nuestra experiencia con Designer comenzó en Qt3.

Qt3

En ese momento, Designer fue útil principalmente para generar código que luego compilaría en su aplicación. Comenzamos a usar para ese propósito, pero con todo el código generado, una vez que lo edita, ya no puede volver atrás y regenerarlo sin perder sus ediciones. Terminamos simplemente tomando el código generado y haciendo todo a mano de ahora en adelante.

Qt4

Qt4 ha mejorado significativamente en Designer. Ya no solo genera código, sino que puede cargar dinámicamente sus archivos de Designer (en xml) y conectarlos dinámicamente a los objetos en ejecución en su programa ; sin embargo, no se genera código, debe nombrar los elementos en Designer y pegar con los nombres para no romper tu código.

Mi evaluación es que no es tan útil como Interface Builder en Mac OS X, pero en este punto, pude ver el uso de los archivos del diseñador directamente en un programa.

No hemos vuelto a Designer desde Qt3, pero todavía lo usamos para crear prototipos y depurar diseños.

Por tus problemas:

1. Probablemente podría salirse con la suya usando los diálogos estándar que ofrece Qt. QInputDialog o si tiene una subclase de QDialog, asegúrese de usar QButtonDialogBox para asegurarse de que sus botones tengan el diseño de plataforma adecuado.

2. Probablemente podría hacer algo más limitado como xPad con una funcionalidad de diseñador limitada.

3. No creo que puedas escribir algo como OpenOffice únicamente con Designer, pero tal vez ese no sea el punto.

Usaría Designer como otra herramienta, al igual que su editor de texto. Una vez que encuentre las limitaciones, pruebe una herramienta diferente para ese nuevo problema. Estoy totalmente de acuerdo con Steve S en que una de las ventajas de Designer es que otra persona que no sea un programador puede hacer el diseño.

En mi experiencia con Qt Designer y otros conjuntos de herramientas / herramientas de interfaz de usuario:

• Las herramientas de interfaz de usuario aceleran el trabajo.
• Las herramientas de la interfaz de usuario facilitan la modificación del diseño más adelante.
• Las herramientas de IU facilitan / hacen posible que los no programadores trabajen en el diseño de IU.

La complejidad a menudo se puede tratar en una herramienta de interfaz de usuario dividiendo el diseño en varios archivos de interfaz de usuario. Incluya pequeños grupos lógicos de componentes en cada archivo y trate cada grupo como un único widget que se utiliza para construir la interfaz de usuario completa. El concepto de widgets promocionados de Qt Designer puede ayudar con esto.

No he encontrado que la escala del proyecto marque la diferencia. Tu experiencia puede variar.

Los archivos creados con herramientas de IU (supongo que podría escribirlos a mano si realmente quisiera) a menudo se pueden cargar dinámicamente en tiempo de ejecución (Qt y GTK + proporcionan esta característica). Esto significa que puede realizar cambios de diseño y probarlos sin volver a compilar.

En última instancia, creo que tanto el código sin formato como las herramientas de interfaz de usuario pueden ser efectivas. Probablemente depende mucho del entorno, el kit de herramientas / herramienta de interfaz de usuario y, por supuesto, las preferencias personales. Me gustan las herramientas de interfaz de usuario porque me permiten ponerme en marcha rápidamente y permitir cambios fáciles más adelante.

La organización para la que trabajo ha portado su aplicación GUI a Qt hace varios años. Creo que hay varios aspectos que vale la pena mencionar:

• Trabajar con Qt Designer, al menos en ese momento, no era una opción realista: había demasiadas funciones que no se podían hacer con Qt Designer;
• Las convenciones y la estructura que debían conservarse impidieron el uso de Qt Designer;
• Una vez que haya comenzado sin Designer, probablemente sea difícil volver a él;
• El aspecto más importante, sin embargo, fue que los programadores estaban muy acostumbrados a programar usando vi o emacs, en lugar de usar una GUI IDE.

Mi propia experiencia, que se remonta aprox. 4 años, usando Qt3.3, es que el comportamiento dinámico en los diálogos no fue posible realizar en Designer.

Solo para decir que he escrito y mantenido GUI complejas en Qt sin usar Qt Designer, no porque no me guste Qt Designer, sino porque nunca llegué a trabajar de esa manera.

Es en parte una cuestión de estilo y de dónde vienes: cuando comencé con Qt, tuve experiencias horribles con Dreamweaver y Frontpage y otras herramientas HTML visuales, y preferí escribir código con HomeSite y recurrir a Photoshop para un diseño complicado. problemas.

Existe un peligro con los IDE de código visual que intenta mantener dentro de las herramientas visuales, pero termina teniendo que modificar el código también, de formas que no se comprenden bien.

Aprendiendo el desarrollo de iPhone, por ejemplo, me ha resultado frustrante presionar elementos visuales 'mágicos' ('arrastrar desde el círculo vacío en el inspector de conexiones al objeto en la ventana de Interface Builder ...') que sería más simple (por yo) para entender en código simple y antiguo.

Buena suerte con Qt: es un gran conjunto de herramientas, independientemente de cómo lo use, y Qt Creator parece ser un gran IDE.

Agregaría que una de las razones para usar el diseñador gráfico fue la falta de administradores de diseño en Win32, por ejemplo. Solo el posicionamiento absoluto era posible, y hacerlo a mano hubiera sido una mierda.

Desde que cambié de Delphi a Java para aplicaciones GUI (en 2002), nunca más he usado diseñadores. Me gustan mucho más los administradores de diseño. Y sí, obtiene código repetitivo, pero mover objetos en un diseñador de interfaz de usuario puede llevar tanto tiempo como cambiarlo. Además, me quedaría atrapado con un IDE lento; eso es para el caso de Java / C #, está bien, mientras que para Qt (especialmente Qt4) no se aplica. Para Qt3, me pregunto por qué debería editarse el código generado, ¿no fue posible agregar código en otros archivos? ¿Por qué motivo?

Acerca de los casos discutidos: 1) Es probable que la GUI codificada a mano sea más rápida de escribir, al menos si conoce sus bibliotecas. Si es un novato y no los conoce, puede ahorrar tiempo y aprender menos con un diseñador, ya que no necesita aprender las API que usa. Pero "aprender menos" es el factor clave, por lo que en ambos casos diría GUI codificada a mano.

2) Las barras de menú son bastante molestas para escribir código. Además, piense en detalles como aceleradores, etc. Aún así, depende de a qué estés acostumbrado. Después de un tiempo, puede ser más rápido escribir ese texto estándar que apuntar y hacer clic en el diseñador para corregir todas esas propiedades, pero solo si realmente puede escribir como en una máquina de escribir (como aquellos administradores para los que escribir comandos Unix es más rápido que usando cualquier GUI).

3) Extendería la respuesta para el caso n. ° 2 a este. Tenga en cuenta que, para las plataformas Win32, es posible que el uso de diseñadores que generen recursos Win32 sea más rápido de cargar (no tengo idea de eso).

Sin embargo, me gustaría mencionar un problema potencial al usar Qt Designer allí. Caso del mundo real: tomó algunos segundos (digamos 10) cargar un cuadro de diálogo Java complejo (el cuadro de diálogo Preferencias para el editor de texto de un programador) con muchas opciones. La solución correcta habría sido cargar cada una de las pestañas solo cuando el programador quisiera verlas (me di cuenta de eso después), agregando un método separado a cada conjunto de preferencias para construir su GUI.

Si diseña todas las pestañas y el conmutador de pestañas junto con un diseñador, ¿puede hacerlo con la misma facilidad? Supongo que podría haber un ejemplo similar en el que una GUI codificada a mano le brinde más flexibilidad, y en una aplicación tan grande, es probable que la necesite, incluso si solo es con fines de optimización.

Uno de los principales beneficios de usar Designer para crear GUI es que otros programadores pueden cambiar o mantener formularios y widgets fácilmente sin necesidad de profundizar en un código complejo.

Es extraño que esté diciendo que escribir código es más simple que manipular objetos en un entorno gráfico. Es una obviedad.
El diseñador está ahí para hacerte la vida más fácil y, a largo plazo, hace que tu código sea más fácil de mantener. Es más fácil buscar en el diseñador para ver cómo se ve su interfaz de usuario y luego leer el código e intentar imaginar cómo se vería.
Con Qt actual puedes hacer casi todo desde el diseñador y las pocas cosas que no puedes hacer, puedes arreglarlas con muy pocas líneas de código en el constructor. Tomemos, por ejemplo, el ejemplo más simple: agregar una conexión de ranura de señal. Usar el diseñador es tan simple como hacer doble clic. Sin el diseñador, debe buscar la firma correcta de la señal, editar el archivo .h y luego editar y escribir su código en el archivo .cpp. El diseñador le permite estar por encima de estos detalles y concentrarse en lo que realmente importa: la funcionalidad de su aplicación.

Primero me gusta recurrir al diseñador para desarrollar widgets de GUI. Como se mencionó en las otras publicaciones, es más rápido. También recibe comentarios inmediatos para ver si "se ve bien" y no confunde al usuario. El diseñador es una de las principales razones por las que elijo Qt sobre otros kits de herramientas. Utilizo principalmente al diseñador para crear los diálogos únicos.

Habiendo dicho eso, hago la ventana principal y los widgets complejos a mano. Creo que esta es la intención de Trolltech. QFormLayout es una clase que proporcionan para crear fácilmente un diálogo de entrada mediante programación.

Por cierto, el diseñador en Qt 4 no es un IDE como el que tenían en Qt 3. Es solo un editor para editar archivos .ui. Me gusta de esa forma. El nuevo IDE multiplataforma se llamará Qt Creator.

Es una publicación antigua, pero te aconsejo que mires a Clementine, un reproductor de música que (creo) deriva de Amarok. Usan Qt4 y, por lo que puedo ver, hay una carpeta ui en la carpeta src del proyecto. En la carpeta ui, como era de esperar, tienen todo tipo de archivos .ui. Si compila e inicia Clementine, verá que la GUI es bastante compleja y bastante agradable.

Para mí, depende de cuánta lógica esté encapsulada en el widget / GUI. Si se trata solo de formularios simples, prefiero usar QtDesigner.

Si contiene comprobaciones o interacciones complejas, tiendo a programarlo.

Estamos usando Qt Designer si alguien necesita crear una interfaz gráfica de usuario.
La cuestión es crear pequeños widgets para ciertas tareas (como lo haría en un diseño de clase) y luego juntarlos en un "parent-gui".

De esta manera, sus widgets son altamente reutilizables y podrían usarse para Guis de manera modular. Solo tiene que especificar qué señales está enviando cada Widget y qué ranuras proporcionan.

Además, estamos creando archivos .ui que podrían generarse durante el proceso de compilación. Hasta ahora no era necesario editar esos archivos a mano.

Cree diferentes partes de su interfaz
de usuario en diferentes archivos .ui usando QtDesigner,
luego júntelas (y agregue complicaciones) en el código.

Hay cosas que no puede hacer en Qt Designer, solo puede hacer en código,
por lo que Qt Designer es solo una (excelente) parte de la cadena de herramientas .