GUI codificado à mão versus GUI do Qt Designer [fechado]

Estou passando essas férias aprendendo a escrever aplicativos Qt. Eu estava lendo sobre o Qt Designer há apenas algumas horas, o que me fez pensar: o que as pessoas que escrevem aplicativos do mundo real em Qt usam para projetar suas GUIs? Na verdade, como as pessoas projetam GUIs em geral?

Eu, por exemplo, descobri que escrever o código manualmente era conceitualmente mais simples do que usar o Qt Designer, embora para GUIs complexas o Designer possa fazer sentido. Grandes GUIs podem ser possíveis usando o Designer, mas com o tempo elas podem se tornar muito difíceis de gerenciar conforme a complexidade aumenta (esta é apenas minha opinião). Eu também baixei o código-fonte do AmaroK para dar uma olhada no que aqueles caras estavam fazendo, e encontrei muitas chamadas para addWidget () e amigos, mas nenhum desses arquivos XML criados pelo Designer (à parte: AmaroK tem que ser meu aplicativo favorito desde sempre qualquer plataforma).

Qual é, então, a maneira "certa" de criar uma GUI? Designer ou código? Vamos, para esta discussão, considerar os seguintes tipos de GUIs:

1. Diálogos simples que precisam apenas de entrada, mostrar algum resultado e sair. Vamos supor um aplicativo que pega um URL do YouTube e baixa o vídeo para o disco rígido do usuário. O tipo de aplicativo com o qual um novato provavelmente deve começar.
2. GUIs de nível intermediário como, digamos, um editor de notas adesivas com alguns itens de barra de ferramentas / menu. Vamos pegar o xPad por exemplo ( http://getxpad.com/ ). Eu diria que a maioria dos aplicativos se enquadra na categoria de "utilitários".
3. GUIs muito complexos, como AmaroK ou OpenOffice. Você os reconhece quando os vê porque eles fazem seus olhos sangrarem.

Nossa experiência com o Designer começou no Qt3.

Qt3

Nesse ponto, o Designer foi útil principalmente para gerar código que você compilaria em seu aplicativo. Começamos a usar para isso, mas com todo o código gerado, uma vez editado, não é mais possível voltar e regenerá-lo sem perder suas edições. Acabamos pegando o código gerado e fazendo tudo manualmente daqui em diante.

Qt4

Qt4 melhorou significativamente no Designer. Ele não mais apenas gera código, mas você pode carregar dinamicamente em seus arquivos do Designer (em xml) e conectá-los dinamicamente aos objetos em execução no seu programa - sem código gerado, no entanto, você tem que nomear os itens no Designer e colar com os nomes para não quebrar seu código.

Minha avaliação é que ele está longe de ser tão útil quanto o Interface Builder no Mac OS X, mas, neste ponto, eu podia ver o uso dos arquivos do Designer diretamente em um programa.

Não voltamos ao Designer desde o Qt3, mas ainda o usamos para prototipar e depurar layouts.

Para seus problemas:

1. Você provavelmente poderia usar as caixas de diálogo padrão que o Qt oferece. QInputDialog ou se você subclasse QDialog, certifique-se de usar QButtonDialogBox para garantir que seus botões tenham o layout de plataforma adequado.

2. Você provavelmente poderia fazer algo mais limitado como o xPad com funcionalidade limitada do Designer.

3. Eu não acho que você poderia escrever algo como o OpenOffice apenas com o Designer, mas talvez esse não seja o ponto.

Eu usaria o Designer como outra ferramenta, assim como seu editor de texto. Depois de encontrar as limitações, tente uma ferramenta diferente para esse novo problema. Eu concordo totalmente com Steve S que uma vantagem do Designer é que outra pessoa que não seja um programador pode fazer o layout.

Na minha experiência com o Qt Designer e outros kits de ferramentas / ferramentas de IU:

• As ferramentas de IU aceleram o trabalho.
• As ferramentas da IU tornam mais fácil ajustar o layout posteriormente.
• As ferramentas da IU tornam mais fácil / possível para não-programadores trabalhar no design da IU.

A complexidade geralmente pode ser tratada em uma ferramenta de IU, dividindo o design em vários arquivos de IU. Inclua pequenos grupos lógicos de componentes em cada arquivo e trate cada grupo como um único widget que é usado para construir a IU completa. O conceito de widgets promovidos do Qt Designer pode ajudar com isso.

Não achei que a escala do projeto faça alguma diferença. Sua experiência pode variar.

Os arquivos criados com ferramentas de IU (eu acho que você poderia escrevê-los à mão se realmente quisesse) podem frequentemente ser carregados dinamicamente em tempo de execução (Qt e GTK + fornecem esse recurso). Isso significa que você pode fazer alterações no layout e testá-los sem recompilar.

Em última análise, acho que o código bruto e as ferramentas de IU podem ser eficazes. Provavelmente depende muito do ambiente, do kit de ferramentas / ferramenta de interface do usuário e, claro, das preferências pessoais. Eu gosto de ferramentas de IU porque elas me colocam em funcionamento rapidamente e permitem mudanças fáceis mais tarde.

A organização para a qual trabalho portou seu aplicativo GUI para o Qt há vários anos. Acho que há vários aspectos que valem a pena mencionar:

• Trabalhar com o Qt Designer, pelo menos naquele ponto, não era uma opção realista: havia muitos recursos que não podiam ser feitos com o Qt Designer;
• Convenções e estrutura que tiveram que ser preservadas impediram o uso do Qt Designer;
• Depois de começar sem o Designer, provavelmente será difícil voltar a ele;
• o aspecto mais importante, porém, é que os programadores estavam muito acostumados a programar usando vi ou emacs, em vez de usar um IDE GUI.

Minha própria experiência, que remonta a aprox. 4 anos, usando Qt3.3, é que o comportamento dinâmico em diálogos não foi possível perceber no Designer.

Só para dizer que escrevi e mantive GUIs complexas no Qt sem usar o Qt Designer - não porque eu não goste do Qt Designer, mas porque nunca tive a oportunidade de trabalhar dessa forma.

Em parte, é uma questão de estilo e de onde você vem: quando comecei no Qt, tive experiências horríveis com Dreamweaver e Frontpage e outras ferramentas HTML visuais, e preferia escrever código com HomeSite e recorrer ao Photoshop para layouts complicados problemas.

Há um perigo com IDEs de código visual que você tenta manter dentro das ferramentas visuais, mas acaba tendo que ajustar o código também - de maneiras que não são bem compreendidas.

Ao aprender o desenvolvimento do iPhone, por exemplo, achei frustrante acertar coisas visuais 'mágicas' ('arrastar do círculo vazio no inspetor de conexões para o objeto na janela do Interface Builder ...') que seria mais simples (para me) para entender no código antigo simples.

Boa sorte com o Qt - é um ótimo kit de ferramentas, independentemente de como você o usa, e o Qt Creator parece ser um ótimo IDE.

Eu acrescentaria que uma das razões para usar designer gráfico foi a falta de gerenciadores de layout no Win32, por exemplo. Apenas o posicionamento absoluto era possível, e fazer isso manualmente teria sido uma merda.

Desde que mudei do Delphi para o Java para aplicativos GUI (em 2002), nunca mais usei designers. Gosto muito mais dos gerenciadores de layout. E sim, você obtém código clichê, mas mover objetos em um designer de IU pode levar tanto tempo quanto mudar o clichê. Além disso, ficaria preso com uma IDE lenta; isso é para o caso Java / C #, OK, enquanto para Qt (especialmente Qt4) não se aplica. Para Qt3, eu me pergunto por que se deve editar o código gerado - não era possível adicionar código em outros arquivos? Por qual razão?

Sobre os casos discutidos: 1) GUI codificado manualmente é provavelmente mais rápido de escrever, pelo menos se você conhece suas bibliotecas. Se você é um novato e não os conhece, pode economizar tempo e aprender menos com um designer, já que não precisa aprender as APIs que usa. Mas "aprender menos" é o fator-chave, então em ambos os casos eu diria GUI codificado manualmente.

2) Barras de menu são muito chatas para escrever código. Além disso, pense em detalhes como aceleradores e assim por diante. Ainda assim, depende do que você está acostumado. Depois de algum tempo, pode ser mais rápido digitar esse clichê do que apontar e clicar no designer para corrigir todas essas propriedades, mas apenas se você realmente puder digitar como em uma máquina de escrever (como aqueles administradores para os quais digitar comandos Unix é mais rápido do que usando qualquer GUI).

3) Eu estenderia a resposta do caso nº 2 a este. Observe que, para plataformas Win32, pode ser possível que usar designers que geram recursos Win32 seja mais rápido para carregar (não tenho ideia sobre isso).

No entanto, gostaria de mencionar um problema potencial com o uso do Qt Designer ali. Caso do mundo real: demorou alguns segundos (digamos 10) para carregar uma caixa de diálogo Java complexa (a caixa de diálogo Preferências para o editor de texto de um programador) com várias opções. A correção correta seria carregar cada uma das guias apenas quando o programador queria vê-las (percebi isso depois), adicionando um método separado a cada conjunto de preferências para construir sua GUI.

Se você projetar todas as guias e o alternador de guias junto com um designer, poderá fazer isso com a mesma facilidade? Acho que pode haver um exemplo semelhante em que uma GUI codificada à mão oferece mais flexibilidade e, em um aplicativo tão grande, você provavelmente precisará disso, mesmo que apenas para fins de otimização.

Um dos principais benefícios de usar o designer para criar GUIs é que outros programadores podem alterar ou manter formulários e widgets facilmente, sem a necessidade de se aprofundar em um código complexo.

É estranho que você esteja dizendo que escrever código é mais simples do que manipular objetos em um ambiente gráfico. É um acéfalo.
O designer está lá para tornar sua vida mais fácil e, a longo prazo, torna seu código mais sustentável. É mais fácil olhar no designer para ver a aparência de sua IU do que ler o código e tentar imaginar como ela seria.
Com o Qt atual, você pode fazer quase tudo de dentro do designer e as poucas coisas que você não pode fazer, você pode consertar com muito poucas linhas de código no construtor. Tome por exemplo o exemplo mais simples - adicionar uma conexão de slot de sinal. Usar o designer é tão simples quanto um clique duplo. Sem o designer, você precisa pesquisar a assinatura correta do sinal, editar o arquivo .h e, em seguida, editar e gravar seu código no arquivo .cpp. O designer permite que você esteja acima desses detalhes e se concentre no que realmente importa - a funcionalidade de seu aplicativo.

Eu gosto de recorrer primeiro ao designer para desenvolver widgets de GUI. Conforme mencionado em outros posts, é mais rápido. Você também obtém feedback imediato para ver se "parece certo" e se não confunde o usuário. O designer é um dos principais motivos pelos quais escolhi o Qt em vez de outros kits de ferramentas. Eu uso principalmente o designer para fazer os diálogos únicos.

Dito isso, eu faço a janela principal e quaisquer widgets complexos manualmente. Acho que é assim que a Trolltech pretendia. QFormLayout é uma classe que eles fornecem para criar de maneira fácil e programática um diálogo de entrada.

A propósito, o designer no Qt 4 não é um IDE como o que eles tinham no Qt 3. É apenas um editor para editar arquivos .ui. Eu gosto assim. O novo IDE de plataforma cruzada vai se chamar Qt Creator.

É um post antigo, mas aconselho você a dar uma olhada no Clementine - um reprodutor de música que (acho) deriva do Amarok. Eles usam Qt4 e pelo que posso ver, há uma pasta ui na pasta src do projeto. Na pasta ui, como era de se esperar, há todos os tipos de arquivos .ui. Se você compilar e iniciar o Clementine, verá que a GUI é bastante complexa e agradável.

Para mim, depende de quanta lógica está encapsulada no widget / GUI. Se for apenas sobre formulários simples, prefiro usar o QtDesigner.

Se ele contém verificações complexas ou interação, tendo a programá-lo.

Estamos usando o Qt Designer se alguém precisar criar um Gui.
O importante é criar apenas pequenos Widgets para certas tarefas (como você faria em um design de classe) e, em seguida, colocá-los juntos em um "pai-gui".

Desta forma, seus widgets são altamente reutilizáveis ​​e podem ser usados ​​para Guis de forma modular. Você só precisa especificar quais sinais cada widget está enviando e quais slots eles fornecem.

Além disso, estamos criando arquivos .ui que podem ser gerados durante o processo de construção. Até agora, não havia necessidade de editar esses arquivos manualmente.

Crie diferentes partes de sua IU
em diferentes arquivos .ui usando o QtDesigner e, em
seguida , reúna-os (e adicione complicações) no código.

Existem coisas que você não pode fazer no Qt Designer, você só pode fazer em código,
então o Qt Designer é apenas uma (grande) parte da cadeia de ferramentas .