QT 4.4.0 + Visual Studio Integration

Nach langer Zeit kommt nun wieder ein Blogeintrag von mir. Im heutigen Artikel werde ich über die bekannte QT Bibliothek von Trolltech schreiben. Viele von uns sind aus finanziellen Gründen gezwungen die Open Source Version zu nutzen.

Die kommerzielle Version bringt zwar die automatische Integration in Visual Studio mit sich, dafür kostet diese Version einiges und ist nicht jedermanns Sache. Mit diesem Artikel will ich die Integration Schritt für Schritt so einfach wie möglich erklären.

Vorbereitung

Bevor wir mit der Integration überhaupt beginnen, wollen wir uns erstmal Vorbereiten. Falls sie schon das SP1 für Visual Studio installiert haben oder es demnächst installieren wollen benötigen wir das Hotfix KB930198. Der direkte Bezug von Microsoft ist nur bei der englischen Version von VS möglich. Nutzer der deutschen Version sind auf andere Quellen angewiesen. Unten in meinen Referenzen werdet ihr einen Link finden, wo ihr das Hotfix runterladen könnt. Als nächstes besorgt ihr euch QT. Achtet darauf, dass es die Open Source Version ohne Mingw ist e.g. qt-win-opensource-src-4.4.0.zip. Entpackt nun das runtergeladene Qt-Paket in ein Verzeichnis eurer Wahl e.g. D:\QT4.

Umgebungsvariablen

Jetzt wollen wir unserem Betriebssystem QT bekannt machen. Dafür müssen wir bestimmte Umgebungsvariablen setzen.

Dafür gehen wir zunächst in System rein. Erreichbar mit Superkey (Windowstaste) + Pause oder über die Systemsteuerung. Danach wechseln wir über den Erweitert-Reiter zu den Umgebungsvariablen. Unter Systemvariablen erstellen wir nun unsere Variablen mit den dazugehörigen Werten.

Hier verwende ich als Beispiel den Pfad D:\QT4, den müsst ihr bei euch natürlich anpassen.

QTDIR       D:\QT4
INCLUDE   %QTDIR%\include
LIB            %QTDIR%\lib
PATH        %QTDIR%\bin

QT Installation

Nachdem ihr QT entpackt und die Umgebungsvariablen gesetzt habt müsst ihr die “Visual Studio Command Prompt” öffnen. Das ist nichts anderes als die normale Windows Konsole nur angepasst an die Anforderungen von VS.

Die Konsole erreicht ihr über:

Startmenü -> Programme -> Microsoft Visual Studio 2005 ->
Visual Studio Tools

Nun wechselt ihr in euer QT Verzeichnis (cd %QTDIR%). Als nächstes müssen wir die Quelldateien konfigurieren bevor wir sie kompilieren können.

Dafür geben wir folgenden Befehl ein:

configure -platform win32-msvc2005 -no-qt3support
-qt-sql-odbc -qt-sql-sqlite -qt-zlib -qt-libpng;

Hier sagen wir configure, dass er die Dateien für eine win32 Platform mit VS2005 erzeugen soll. Ich verzichte absichtlich auf QT3. Falls ihr es brauchen solltet lasst einfach “-no-qt3support” weg. Die folgenden Parameter sind optional, daher könnt ihr sie auch weglassen.

Diese Konfiguration dauert nun ein Weilchen, holt euch währenddessen einen Kaffee……

So..ihr seid nun mit der Konfiguration fertig. Freut euch nicht zu früh, denn jetzt kommt nmake. Damit wird der Kompilierungsvorgang angestoßen. Dieser Vorgang wird viel länger dauern, daher empfehle ich euch währenddessen was anderes zu machen…
So..damit seid ihr also auch fertig. Schön!

Macht euch nun am besten zwei Verknüpfungen auf euer Desktop. Diese zwei werdet ihr öfters brauchen. Zum einen gibt es da den QT Designer und die QT Hilfe. Beide werden euch ein QT-Leben lang begleiten.

%QTDIR%\bin\designer.exe

;%QTDIR%\doc\html\index.html

Beispielprojekt

Erzeugt euch zunächst ein neues leeres Win32-Projekt. Im Assistenten wählt ihr “leeres Projekt” und “Windows Anwendung”.  Als erstes erzeugen wir uns die main.cpp, da sie unser Einstiegspunkt sein wird. Den Inhalt können wir zunächst leer lassen.

In diesem Beispiel soll unsere Anwendung  ein einfaches Fenster erzeugen, mehr nicht! Dies dürfte als Demonstration ausreichend sein.

Dafür legen wir nun eine C++ Klasse an. Wir nennen sie mywindow. Die Basisklasse ist die QMainWindow. Da VS QMainWindow noch nicht kennt, wird er meckern. Ignoriert einfach diese Meldung und klickt auf Ja. Nun habt ihr drei Dateien in eurem Projekt die main.cpp, mywindow.cpp und die mywindow.h.

Als nächstes wechselt ihr in die Projekteigenschaften. Hier wählt ihr als Konfiguration “Alle Konfigurationen” (linke obere Kombobox). Im linken Bereich des Fensters wechselt ihr zu C/C++ und fügt auf der rechten Seite bei “Zusätzliche Includeverzeichnisse”
die Werte “$(QTDIR)\include”;”$(QTDIR)\include\Qt”;

Als nächstes ist der Linker dran. Wie eben wechseln wir nun links zu Linker und fügen auf der rechten Seite bei “Zusätzliche Bibliotheksverzeichnisse” den Wert $(QTDIR)\lib ein. Wir bleiben kurz noch bei Linker. Bevor wir fortfahren wechseln sie wieder die Auswahl in der Kombobox. Diesmal auf Debug.

Unter Linker werden sie “Eingabe” sehen. Wechseln sie dorthin und geben sie auf der rechten Seite bei “Zusätzliche Abhängigkeiten”
die Werte qtmaind.lib QtGuid4.lib QtCored4.lib ein.

Genau die Selbe Option setzen wir auch für Release. Wechseln sie dafür die Auswahl in der Kombobox und wie eben unter Linker in Eingabe reingehen. Auf der rechten Seite bei “Zusätzliche Abhängigkeiten” die Werte qtmain.lib QtGui4.lib QtCore4.lib einfügen.

Bevor wir fortfahren, wollen wir zuerst mit dem QT Designer eine *.ui Datei erstellen. Diese enthält das zu erzeugende Fenster in XML Form. Erzeugen sie mit dem Designer ein einfaches Mainwindow aus der Vorlage und speichern es als z.B. mywindow.ui in das Projektverzeichnis.

Danach gehen wir in die Projektmappe und fügen die eben erzeugte ui Datei in unsere Ressourcen. Das bewältigen wir mit einem einfachen Rechtsklick auf Ressourcen und Hinzufügen -> vorhandenes Element.

Da VS *.ui Dateien noch nicht kennt, müssen wir ihm sagen was er damit machen soll. Deshalb erzeugen wir eine Buildregel.

Beispiel:

Anzeigename: ui_regel
Dateiname:     ui_regel
Verzeichnis:   ..\..\Eigene Dateien\Visual Studio 2005\Regeln

Im gleichen Fenster klicken sie nun auf Buildregel hinzufügen. Im erscheinenden Fenster geben sie folgendes ein:

Befehlszeile:
$(QTDIR)/bin/uic.exe "$(InputPath)" -o ui_$(InputName).h
Dateierw.:  
*.ui
Name:
UI
Anzeigename:      
Kompiliere UI Datei (*.ui)
Ausführungsbe.:  
Erzeuge UI Datei ui\_\$(InputName).h
Ausgaben:
$(InputDir)ui_$(InputName).h

Solche Regeln sollten sie in ein Regelverzeichnis abspeichern und es VS verfügbar machen, damit es dauerhaft an der definierten Stelle nach Regeln suchen kann.

Extras -> Optionen -> Projekte und Projektmappen -> [VC++-Projekteinstellungen]

Auf der rechten Seite geben sie bei “Regeldatei-Suchpfade” das Verzeichnis an, wo VS nach Regeln suchen soll.

Beispiel Source

//main.cpp

#include <QApplication.h>
#include “mywindow.h”

int main(int argc,char **argv)
{
QApplication app(argc,argv);
mywindow win;
win.show();

return app.exec();
}

//mywindow.h
#pragma once
#include “ui_mywindow.h”

class mywindow :
public QMainWindow,Ui::MainWindow
{
Q_OBJECT
public:
mywindow(void);
~mywindow(void);
};

//myindow.cpp
#include “mywindow.h”

mywindow::mywindow(void)
{
setupUi(this);
}

mywindow::~mywindow(void)
{
}

MOC

Bevor das Projekt gelinkt werden kann, sollten sie voher den Meta Object Compiler über unsere Header-Dateien laufen lassen. Zur Zeit müssen wir dies über einen unangenehmen Weg machen. Wir müssen in die Eigenschaften der jeweiligen Datei rein um einen Buildschritt zu definieren.

Befehlszeile:
$(QTDIR)\bin\moc.exe “$(InputPath)” -o
“$(InputDir)moc_$(InputName).cpp”

Beschreibung:
moc läuft auf $(InputName).h

Ausgaben:
$(InputDir)moc_$(InputName).cpp

Nach Fertigstellung kompilieren sie die jeweilige Datei mit einem Rechtsklick über die Projektmappe. Nach der Kompilierung sollte in unserem Projektverzeichnis nun eine neue Datei erscheinen. Die neue e.g. moc_mywindow.cpp fügen wir unserem Projekt hinzu.

Erst jetzt kann das Projekt erfolgreich gelinkt werden.

Wichtig: Achtet bitte, dass sich die Gänsefüßchen von WordPress und VS unterscheiden.
Wenn ihr Teile aus diesem Artikel kopiert, achtet bitte auf die Gänsefüßchen.

Download:
http://www.megaupload.com/?d=N29TLMFM

http://rapidshare.com/files/233221115/myfirstproj.7z.html

Schlusswort

Anhand dieses Artikels müssten sie nun in der Lage sein, die Integration erfolgreich durchzuführen. Demnächst werde ich paar nützliche Addins vorstellen und den Schritt mit dem moc etwas erleichtern (mit PREmoc automatisieren). Ausserdem kommt noch ein Artikel über die Bibliothek qwt, welche man zum plotten von Graphen nutzen kann.

Referenzen

QT 4.x Integration in Visual Studio 2005

QTFORUM

~ by Ferhat Akgün on 14.July 2008.