Gli sviluppatori Trolltech hanno sviluppato QGtkStyle, uno strumento che permette di dare uno stile GTK alle applicazioni native Qt, sotto GNOME. Il problema dell'integrazione visiva tra le applicazioni KDE e quelle GNOME, ha sempre afflitto i sistemi Gnu/Linux. In Windows e Mac OsX, Qt, ha sempre avuto stili specifici, basati sul tema nativo del sistema. Se però, gli utenti KDE, hanno a disposizione il 'GTK-Qt Theme Engine', che consente di dare alle applicazione GTK uno stile Qt, non esisteva nulla di simile per GNOME. L'unica soluzione era Qt QCleanlooks, ma non assicurava una perfetta integrazione. Con QGtkStyle, che usa direttamente il motore del tema GTK+, le applicazioni KDE diventano praticamente identiche a quelle native per GNOME, proprio come accade in Windows e Mac. QGtkStyle è veramente interessante e facile da installare.

Installazione

Per poter compilare QGtkStyle, dovete avere GTK2, QT4 e il pacchetto gtk2-x11-dev installati. In Ubuntu Hardy Heron basta dare un semplice:

sudo apt-get install libgtk2.0-dev libqt4-dev

Poi assicuratevi di avere subversion installato:

sudo apt-get install subversion

e date questa serie di comandi:

svn co svn://labs.trolltech.com/svn/styles/gtkstyle

cd gtkstyle/

qmake && make

sudo make install

Ora, se tutto va per il verso giusto, non vi resta che installare Qt Configuration, lo strumento di configurazione di Qt4, con un semplice:

sudo apt-get install qt4-qtconfig

Terminata l'installazione lo trovate nel menù Sistema-> Preferenze-> Impostazioni Qt 4, apritelo e nella scheda 'Appearance', scegliete GTK come GUI Style, salvate (Ctrl+s) e noterete subito il cambiamento.

QGtkStyle funziona con tutte le applicazioni Qt4, come Skype e Last.fm e KWord, ma non con quelle basate su Qt3. Sono quindi supportate tutte le applicazioni per KDE4. Se riscontrate problemi nell'installazione di QGtkStyle, l'errore potrebbe essere dovuto al fatto qmake non sta usando la versione 4.x di Qt, controllate con:

qmake -v

se sta usando Qt3 date:

sudo update-alternatives --config qmake

e inserte il numero corrispondente a qmake-qt4, solitamente l'uno.

QGtkStyle è veramente interessante, perché rappresenta il grado più alto dell'integrazione tra Desktop Environment.

Articoli correlati:

Registrare le chiamate di Skype con Scx Tool. Ecco come installarlo su Ubuntu

Neon, installiamo Amarok 2 su Kubuntu e SUSE

Miglioriamo l’aspetto delle applicazioni Wine

Un buon programmatore deve crearsi adeguatamente un proprio file .pro, altrimenti rischia di perdersi all'interno del progetto. La struttura di un file .pro non è difficile per niente, basta solo seguire i passi che a breve introdurrò.

Come prima cosa, un progetto Qt (o in genere un qualsiasi progetto) deve attuare un certo ordine. Non è una legge da rispettare, però seguire un certo "stile" aiuterà sicuramente il programmatore nello svolgimento delle operazioni. Ad esempio, è bene disporre i propri sorgenti all'interno di una directory "src". Così come il file binario dentro "bin", i file di compilazione dentro "build" e così via.

Prima di vedere come si crea un file .pro, bisogna introdurre alcuni concetti.

-> File per l'icona di windows (usato solo in windows)
In ambiente windows, i binari hanno in genere un'icona standard (quella per i .exe tradizionali). Per associare al binario un'icona, basta creare un file .rc e posizionarlo nella directory corrente del progetto.

Un esempio di tale file è questo:
IDI_ICON1 ICON DISCARDABLE "resources/icons/logo.ico"

-> File per le immagini (e in genere altri file)
In genere in un programma GUI sono presenti delle immagini, che vengono utilizzate per i menuitem, bottoni, oppure label. Ci sono 3 metodi per inserire un'immagine nel nostro programma:

1. usare path assoluti: questo metodo non merita neanche attenzione (scongiurato);
2. usare path relativi: in questi casi, le immagini hanno un percorso relativo all'eseguibile, e quindi si ha una certa "portabilità". E' comunque evidente che spostare il percorso del binario, implica uno sfasamento dei percorsi relativi;
3. usare path assoluti all'interno del progetto: questo modo di operare include le immagini nel binario e non si hanno modi di sbagliare.

Spiego meglio il 3° punto. Le immagini (o altri file, ad esempio file di testo) vengono convertite in file sorgenti .cpp e nello specifico, in dei vettori pieni zeppi di numeri esadecimali. Questo a noi non ci interessa... la sostanza è che le immagini verranno incluse nel binario definitivo e il loro uso nelle finestre è completamente privo di rischi.

Un file del genere specifica le "risorse" che devono essere incluse nel progetto. In genere io uso una directory "resources" e dentro di essa, posiziono il mio file di risorsa che ha un estensione .qrc. Questo file è di tipo XML e di facile utilizzo. Dentro resources, creo un'altra directory "icons" contenente tutte le immagini che userò (preferisco png a jpg). Se ad esempio, dentro "resources/icons/" ho un file immagine chiamato "logo.png", in "resources" avrò un file .qrc del genere:

<RCC>
<qresource prefix="/icons" >
<file>icons/logo.png</file>
</qresource>
</RCC>

Io considero indispensabili la configurazioni di questi 2 file. Detto questo, procediamo alla creazione del file .pro per il nostro progetto.

Il nostro file .pro si chiamerà Progetto.pro e sarà così composto:

# sorgenti
HEADERS += src/finestra.h
FORMS += ui/finestra.ui
SOURCES += src/finestra.cpp src/main.cpp

# build
OBJECTS_DIR += build/o
MOC_DIR += build/moc
RCC_DIR += build/rcc
UI_DIR += build/ui

# binario
DESTDIR += bin

# altro
RC_FILE += Progetto.rc
RESOURCES += resources/Progetto.qrc

• In HEADERS, FORMS e SOURCES abbiamo fissato il percorso fisico dei sorgenti e dei file delle finestre.
• In OBJECTS_DIR ci sono i file oggetto delle compilazioni, in MOC_DIR i file sorgenti dovuti alla connessione degli eventi, in RCC_DIR sono presenti i file sorgenti delle risorse e in UI_DIR i file headers delle finestre. Queste 4 variabili prendetele così come sono, e usatele per ogni progetto Qt.
• In DESTDIR andrà il binario risultante dalla compilazione totale.
• In RC_FILE c'è il file per l'icona di windows.
• In RESOURCES il file delle risorse.

Qua sotto, ecco la situazione attuale: avere impostato un progetto così significa partire ben ordinati!

A questo punto, scordatevi assolutamente il comando "qmake -project". Dovrete da ora in poi, usare solo "qmake" e "make".

Come prima cosa, bisogna aver installato le Qt4.x e in questa sede non farò di certo vedere come installare le librerie e impostare tutte le eventuali dipendenze (compilatore c++, make, ecc). Assumo per scontato che le liberie Qt4 (occhio alla versione) siano installate correttamente.

Il nostro intento sarà quello di creare una piccola finestra che ha diversi componenti grafici: un'area testo, un bottone e una label. Lo scopo sarà quello di far visualizzare nella label il testo che scriveremo nell'area di testo dopo aver premuto l'apposito bottone.

Chi viene dalla programmazione Java e da diversi IDE come Netbeans, inizialmente si troverà (probabilmente) un pochino a disagio.

La prima cosa da fare, è la creazione di una directory per avere un po' di pulizia. Metteremo tutto ciò che ci serve, all'interno di tale cartella.

Per disegnare la finestra, ci baseremo su designer, il magnifico programma che permette di disegnare GUI in maniera veloce e soprattutto facile... molto meglio del netbeans. Nel video qua sotto, vedremo come creare un file di finestra, che non sarà altro che un banale file XML.

Il file della finestra "finestra.ui" sarà processato in fase di compilazione in un file sorgente C++ (per l'esattezza, verrà chiamato "ui_finestra.h").

Per usare la finestra, bisogna crearsi 2 file: "finestra.h" che conterrà la definizione della classe Finestra che creeremo, e il file "finestra.cpp" che conterrà le relative implementazioni.

La classe Finestra erediterà da 2 altre classi: da QMainWindow (che è la classe per le finestre in generale) e dalla classe Ui::MainWindow (ossia la classe MainWindow all'interno del namespace Ui che sarà generato dal file finestra.ui).

class Finestra : public QMainWindow, public Ui::MainWindow

Inoltre la classe conterrà uno "slot", ossia un metodo normale che viene eseguito se un particolare "signal" viene attivato o generato. La macro Q_OBJECT è indispensabile per trattare questo tipo di cose.

public slots:
void stampaVideo();

Questi 2 concetti sono nuovi rispetto al Java, ma non è così difficile entrare nella logica. Un signal può essere paragonato ad un evento di "clicked" del mouse, oppure alla chiusura di una finestra, e così via. C'è da dire che un metodo slot può essere anche chiamato manualmente all'interno del codice, ma un signal non può far eseguire un metodo non slot.

Nel file di implementazione, verrà richiamato il metodo di inizializzazione componenti grafici della finestra, mediante la chiamata al metodo setupUi.

setupUi(this);

Per far si che il metodo venga chiamato al momento della pressione del bottone, è necessario "connettere" fisicamente il signal e lo slot, mediante il metodo "connect":

connect(pushButtonScrivi, SIGNAL(clicked()), this, SLOT(stampaVideo()));

All'interno del metodo stampaVideo() metteremo il codice per prendere il testo dall'area di testo e successivamente visualizzarla nella label appena sopra.

Fatto tutto, saremo pronti alla compilazione del progetto. I passi da fare saranno 3:

• qmake -project (Serve per la creazione del file .pro del progetto. Nelle prossime lezioni, useremo file file.pro fatti da noi);
• qmake (Serve per la generazione del Makefile);
• make (Genera i file sorgenti dai file.ui, compila i file.src e crea il binario).

Alla fine, avremo nella directory corrente, il nostro eseguibile funzionante.

Progetto completo