GUI codificata a mano e GUI Qt Designer [chiusa]

Trascorro queste vacanze imparando a scrivere applicazioni Qt. Stavo leggendo di Qt Designer solo poche ore fa, il che mi ha fatto chiedere: cosa usano le persone che scrivono applicazioni del mondo reale in Qt per progettare le loro GUI? In effetti, come si progettano le GUI in generale?

Io, per esempio, ho scoperto che scrivere il codice a mano era concettualmente più semplice che usare Qt Designer, anche se per GUI complesse Designer potrebbe avere senso. Potrebbero essere possibili GUI di grandi dimensioni utilizzando Designer, ma con il tempo potrebbero diventare molto difficili da gestire con l'aumentare della complessità (questa è solo la mia opinione). Ho anche scaricato il codice sorgente di AmaroK per dare un'occhiata a quello che stavano facendo quei ragazzi e ho trovato molte chiamate ad addWidget () e amici, ma nessuno di quei file XML creati da Designer (a parte: AmaroK deve essere la mia applicazione preferita in assoluto qualsiasi piattaforma).

Qual è, allora, il modo "giusto" per creare una GUI? Designer o codice? Per questa discussione, consideriamo i seguenti tipi di GUI:

1. Finestre di dialogo semplici che richiedono solo input, mostrare alcuni risultati ed uscire. Supponiamo che un'applicazione prenda un URL di YouTube e scarichi il video sul disco rigido dell'utente. Il tipo di applicazioni con cui è probabile che un principiante inizi.
2. GUI di livello intermedio come, ad esempio, un editor di note adesive con alcune voci di menu / barra degli strumenti. Prendiamo ad esempio xPad ( http://getxpad.com/ ). Direi che la maggior parte delle applicazioni rientra nella categoria delle "utilità".
3. GUI molto complesse, come AmaroK o OpenOffice. Li conosci quando li vedi perché ti fanno sanguinare gli occhi.

La nostra esperienza con Designer è iniziata in Qt3.

Qt3

A quel punto, Designer è stato utile principalmente per generare codice da compilare poi nella tua applicazione. Abbiamo iniziato a usarlo per quello scopo ma con tutto il codice generato, una volta modificato, non puoi più tornare indietro e rigenerarlo senza perdere le modifiche. Abbiamo finito per prendere il codice generato e fare tutto a mano d'ora in poi.

Qt4

Qt4 è migliorato in modo significativo su Designer. Non genera più solo codice, ma puoi caricare dinamicamente i tuoi file Designer (in xml) e connetterli dinamicamente agli oggetti in esecuzione nel tuo programma - nessun codice generato tuttavia, devi nominare gli elementi in Designer e attaccarli con i nomi per non rompere il codice.

La mia valutazione è che non è neanche lontanamente utile come Interface Builder su Mac OS X, ma a questo punto ho potuto vedere l'utilizzo dei file Designer direttamente in un programma.

Non siamo tornati a Designer dalle Qt3, ma lo usiamo ancora per prototipare ed eseguire il debug dei layout.

Per i tuoi problemi:

1. Probabilmente potresti farla franca usando le finestre di dialogo standard offerte da Qt. QInputDialog o se si sottoclasse QDialog, assicurarsi di utilizzare QButtonDialogBox per assicurarsi che i pulsanti abbiano il layout della piattaforma appropriato.

2. Probabilmente potresti fare qualcosa di più limitato come xPad con funzionalità di Designer limitate.

3. Non penserei che potresti scrivere qualcosa come OpenOffice solo con Designer, ma forse non è questo il punto.

Userei Designer come un altro strumento, proprio come il tuo editor di testo. Una volta individuati i limiti, prova uno strumento diverso per quel nuovo problema. Sono totalmente d'accordo con Steve S sul fatto che uno dei vantaggi di Designer è che qualcun altro che non è un programmatore può fare il layout.

Nella mia esperienza con Qt Designer e altri toolkit / strumenti dell'interfaccia utente:

• Gli strumenti dell'interfaccia utente velocizzano il lavoro.
• Gli strumenti dell'interfaccia utente semplificano la modifica del layout in un secondo momento.
• Gli strumenti dell'interfaccia utente rendono più facile / possibile per i non programmatori lavorare sulla progettazione dell'interfaccia utente.

La complessità può spesso essere affrontata in uno strumento dell'interfaccia utente suddividendo il progetto in più file dell'interfaccia utente. Includere piccoli gruppi logici di componenti in ogni file e trattare ogni gruppo come un singolo widget che viene utilizzato per costruire l'interfaccia utente completa. Il concetto di widget promossi di Qt Designer può aiutare in questo.

Non ho scoperto che la scala del progetto faccia la differenza. La tua esperienza potrebbe variare.

I file creati con gli strumenti dell'interfaccia utente (immagino che potresti scriverli a mano se lo desideri) possono spesso essere caricati dinamicamente in fase di esecuzione (Qt e GTK + forniscono entrambi questa funzione). Ciò significa che è possibile apportare modifiche al layout e testarle senza ricompilare.

In definitiva, penso che sia il codice grezzo che gli strumenti dell'interfaccia utente possano essere efficaci. Probabilmente dipende molto dall'ambiente, dal toolkit / strumento UI e, naturalmente, dalle preferenze personali. Mi piacciono gli strumenti dell'interfaccia utente perché mi fanno funzionare velocemente e consentono facili modifiche in seguito.

L'organizzazione per cui lavoro ha portato la sua applicazione GUI su Qt diversi anni fa. Penso che ci siano diversi aspetti che vale la pena menzionare:

• Lavorare con Qt Designer, almeno a quel punto, non era un'opzione realistica: c'erano troppe funzionalità che non si potevano fare con Qt Designer;
• Le convenzioni e la struttura che dovevano essere preservate impedivano l'uso di Qt Designer;
• Una volta che hai iniziato senza Designer, è probabilmente difficile tornare ad esso;
• l'aspetto più importante, però, era che i programmatori erano molto abituati a programmare usando vi o emacs, piuttosto che usare un IDE GUI.

La mia esperienza, che risale a ca. 4 anni, utilizzando Qt3.3, è che il comportamento dinamico nelle finestre di dialogo non è stato possibile realizzare in Designer.

Solo per dire che ho scritto e mantenuto GUI complesse in Qt senza usare Qt Designer - non perché non mi piaccia Qt Designer, ma perché non sono mai riuscito a lavorare in quel modo.

In parte è una questione di stile e da dove vieni: quando ho iniziato con Qt, avevo avuto esperienze orribili con Dreamweaver e Frontpage e altri strumenti HTML visivi, e preferivo di gran lunga scrivere codice con HomeSite e ricorrere a Photoshop per layout complicato i problemi.

C'è un pericolo con gli IDE del codice visivo che cerchi di mantenere negli strumenti visivi, ma finisci per dover modificare anche il codice, in modi che non sono ben compresi.

Imparando lo sviluppo di iPhone, ad esempio, ho trovato frustrante fare clic su elementi visivi 'magici' ('trascina dal cerchio vuoto nell'ispettore Connessioni all'oggetto nella finestra di Interface Builder ...') che sarebbe più semplice (per me) per capire in chiaro vecchio codice.

Buona fortuna con Qt: è un ottimo toolkit, comunque lo usi, e Qt Creator sembra essere un ottimo IDE.

Aggiungerei che uno dei motivi per utilizzare il designer grafico è stata la mancanza di gestori di layout in Win32, ad esempio. Era possibile solo il posizionamento assoluto, e farlo a mano avrebbe fatto schifo.

Da quando sono passato da Delphi a Java per le app GUI (nel 2002), non ho più usato i designer. Mi piacciono molto di più i gestori di layout. E sì, ottieni il codice boilerplate, ma lo spostamento di oggetti su un designer dell'interfaccia utente potrebbe richiedere tanto tempo quanto la modifica del boilerplate. Inoltre, sarei bloccato con un IDE lento; questo è per il caso Java / C #, OK, mentre per Qt (specialmente Qt4) non si applica. Per Qt3, mi chiedo perché si dovrebbe modificare il codice generato: non era possibile aggiungere codice in altri file? Per quale motivo?

Riguardo ai casi discussi: 1) La GUI codificata a mano è probabilmente più veloce da scrivere, almeno se conosci le tue librerie. Se sei un principiante e non li conosci, puoi risparmiare tempo e imparare meno con un designer, dal momento che non hai bisogno di imparare le API che usi. Ma "imparare di meno" è il fattore chiave, quindi in entrambi i casi direi GUI codificata a mano.

2) Le barre dei menu sono piuttosto fastidiose per cui scrivere codice. Inoltre, pensa a dettagli come acceleratori e così via. Tuttavia, dipende da cosa sei abituato. Dopo un po 'di tempo, potrebbe essere più veloce digitare quel boilerplate piuttosto che puntare e fare clic nel designer per correggere tutte quelle proprietà, ma solo se puoi davvero digitare come in una macchina da scrivere (come quegli amministratori per i quali digitare comandi Unix è più veloce di utilizzando qualsiasi GUI).

3) Estenderei la risposta per il caso n. 2 a questo. Si noti che, per le piattaforme Win32, potrebbe essere possibile che l'utilizzo di designer che generano risorse Win32 possa essere più veloce da caricare (non ne ho idea).

Tuttavia, vorrei menzionare un potenziale problema con l'utilizzo di Qt Designer lì. Caso del mondo reale: ci sono voluti alcuni secondi (diciamo 10) per caricare una finestra di dialogo Java complessa (la finestra di dialogo Preferenze per l'editor di testo di un programmatore) con molte opzioni. La soluzione corretta sarebbe stata caricare ciascuna delle schede solo quando il programmatore voleva vederle (me ne sono reso conto dopo), aggiungendo un metodo separato a ciascuna preferenza impostata per costruire la sua GUI.

Se progetti tutte le schede e il selettore di schede insieme a un designer, puoi farlo altrettanto facilmente? Immagino che potrebbe esserci un esempio simile in cui una GUI codificata a mano ti offre maggiore flessibilità, e in un'app così grande, probabilmente ne avrai bisogno, anche se solo per scopi di ottimizzazione.

Uno dei principali vantaggi dell'utilizzo di designer per creare GUI è che altri programmatori possono modificare o gestire facilmente moduli e widget senza la necessità di approfondire un codice complesso.

È strano che tu stia dicendo che il codice di scrittura è più semplice della manipolazione di oggetti in un ambiente grafico. È un gioco da ragazzi.
Il designer è lì per semplificarti la vita e nel lungo termine rende il tuo codice più manutenibile. È più facile guardare nel designer per vedere come appare la tua interfaccia utente, quindi leggere il codice e provare a immaginare come potrebbe essere.
Con l'attuale Qt puoi fare quasi tutto dall'interno del designer e le pochissime cose che non puoi fare, puoi sistemarle con pochissime righe di codice nel costruttore. Prendiamo ad esempio l'esempio più semplice: l'aggiunta di una connessione slot di segnale. Usare il designer è semplice come un doppio clic. Senza il designer è necessario cercare la firma corretta del segnale, modificare il file .h e quindi modificare scrivere il codice nel file .cpp. Il designer ti consente di essere al di sopra di questi dettagli e di concentrarti su ciò che conta davvero: la funzionalità della tua applicazione.

Mi piace prima rivolgermi al designer per sviluppare i widget della GUI. Come accennato negli altri post, è più veloce. Ricevi anche un feedback immediato per vedere se "sembra corretto" e non crea confusione per l'utente. Il designer è uno dei motivi principali per cui scelgo Qt rispetto ad altri toolkit. Uso principalmente il designer per creare le finestre di dialogo una tantum.

Detto questo, eseguo manualmente la finestra principale e tutti i widget complessi. Penso che questo sia il modo in cui Trolltech intendeva. QFormLayout è una classe che forniscono per creare facilmente in modo programmatico una finestra di dialogo di input.

A proposito, il designer in Qt 4 non è un IDE come quello che avevano in Qt 3. È solo un editor per modificare i file .ui. Mi piace così. Il nuovo IDE multipiattaforma si chiamerà Qt Creator.

È un vecchio post ma ti consiglio di guardare Clementine, un lettore musicale che (credo) deriva da Amarok. Usano Qt4 e da quello che posso vedere c'è una cartella ui nella cartella src del progetto. Nella cartella ui, come ci si potrebbe aspettare, hanno tutti i tipi di file .ui. Se compili e avvii Clementine vedrai che la GUI è abbastanza complessa e abbastanza carina.

Per me, dipende da quanta logica è incapsulata nel widget / GUI. Se si tratta solo di moduli semplici, preferisco usare QtDesigner.

Se contiene controlli o interazioni complessi, tendo a programmarlo.

Stiamo usando Qt Designer se qualcuno ha bisogno di creare una Gui.
Il punto è creare solo piccoli widget per determinati compiti (come faresti in un design di classe) e poi metterli insieme in una "genitore-gui".

In questo modo i tuoi widget sono altamente riutilizzabili e potrebbero essere usati per Guis in modo modulare. Devi solo specificare quali segnali sta inviando ogni Widget e quali slot forniscono.

Inoltre stiamo creando file .ui che potrebbero essere generati durante il processo di compilazione. Fino ad ora non era necessario modificare manualmente quei file.

Costruisci parti diverse della tua interfaccia utente
in diversi file .ui utilizzando QtDesigner,
quindi riuniscile (e aggiungi complicazioni) nel codice.

Ci sono cose che non puoi fare in Qt Designer, puoi fare solo nel codice,
quindi Qt Designer è solo una (grande) parte della catena di strumenti .