Qt in bestehendem Makefile-Projekt nutzen

[Oliver (Gast)]

Morgen zusammen,

ich hab hier ein eigenes C++ Projekt, dessen Funktionalität recht 
vollständig ist.
Der Buildprozess wurde noch per Hand als makefile geschrieben, weil ich 
aus der (embedded-) C-Ecke komme.
D.h. Compiler- und Linkeraufrufe sind irgendwo im makefile enthalten, 
ebenfalls die zu kompilierenden Sourcen und die zu linkenden 
zusätzlichen Libs (ncurses, etc.)

Die "GUI" ist momentan noch mittels ncurses umgesetzt. Allerdings ist 
sie recht locker an die "Geschäftslogik" angeflanscht, so dass man sie 
relativ einfach gegen eine andere GUI tauschen kann.
Die GUI enthält kaum Logik, sondern zeigt nur Daten an die über 
Schnittstellen von der Geschäftslogik geholt werden, oder gibt 
Nutzereingaben an diese weiter.

Nun würd ich gerne eine richtige GUI mittels Qt spendieren.
Die technische Umsetzung sollte weniger das Problem sein, wie gesagt, 
die GUI ist stark von der Logik abstrahiert.

Der Buildprozess stellt mich vor größeren Problemen.
Ich würde nur ungern alles komplett neu aufsetzen.
Allerdings verwendet ja Qt einen recht speziellen Buildprozess.
Makefiles werden dort eher weniger benutzt, stattdessen kommt qmake und 
der "moc" zum Einsatz.
Das sind Dinge, um die will man sich eher nicht selbst kümmern.
Ich hab zwar mal probeweise den moc händisch aufgerufen, aber schön ist 
das nicht.

Wie würdet ihr das Ganze angehen?
Wie kann ich Qt in mein bestehendes Projekt einbinden, ohne nur wegen Qt 
alles übern Haufen schmeissen zu müssen?

Gruß, Olli

[Klaus W. (mfgkw)]

Es ist schon ein paar Jahre her, aber Qt habe ich immer mit eigenen 
makefiles kompiliert.

Es müssen halt Regeln rein, wie der moc aufzurufen ist und was er liest 
und erzeugt, dann die Includepfade und die Libs zum Linken.
Eigentlich recht geradlinig...

[A. H. (ah8)]

Kein Problem. Ich habe Dir mal ein paar Regeln aus einem alten Makefile 
kopiert. Das sollte schon genügen. (Es war übrigens ein Projekt, bei dem 
das Executable wahlweise mit Qt- oder ncurses‑GUI gestartet werden 
konnte. Also auch das funktioniert.)

Wundere Dich nicht über einige Pfade. Ich lege Wert darauf, dass alles 
was gebaut wird, in einem eigenen Verzeichnis landet. Das erleichtert 
das Aufräumen und das Backup.

Den Backup-Teil habe ich mal drin gelassen. Wie Du siehst fahre ich nach 
jedem erfolgreichen Link ein einfaches Backup. Das dauert nur Sekunden, 
kostet meist auch nur einige Dutzend Kilobyte und ist das Backup, was 
mir bisher mit Abstand die meisten Kopfschmerzen erspart hat. Nur so als 
Anregung.

# how to make backups
define backup
        if test -f $(build)/.backup; then \
                find ./* -xdev -depth -follow -newer $(build)/.backup; \
                echo `date +%Y%m%d.%H%M%S`.diff >$(build)/.backup; \
        else \
                find . -xdev -depth; \
                echo `date +%Y%m%d.%H%M%S`.full >$(build)/.backup; \
                echo '### no backup timestamp found, full backup forced' 1>&2;\
        fi \
        | grep -v -e ^./$(build) -e ^./$(exec) >$(build)/.newfiles; \
        if test -s $(build)/.newfiles; then \
                backupfile=`cat $(build)/.backup`; \
                backupfile=$(backupdir)/$(backupname).cpio.$$backupfile.gz; \
                cat $(build)/.newfiles | cpio -o -a | gzip >$$backupfile; \
                echo '### backup:' `ls -sh $$backupfile` ;\
        else \
                echo '### no backup neccessary' 1>&2; \
        fi
endef


# by default build the executable and run an incremental backup if successful
all: $(exec)
        @$(backup)

# just build executable (no backup)
exec: $(exec)

# just compile (no linking and no backup)
compile: $(objects)

# run a full backup
backup:
        rm $(build)/.backup
        @$(backup)


# how to build the executable
$(exec): $(objects)
        $(cc) -o $@ $^ $(lflags)

# how to compile objects
$(objects): $(build)/%.o: %.cpp
        $(cc) -c $(cflags) $(incl) -o $@ $<

# how to create moc sources
$(qtsources): $(build)/%.moc.cpp: %.h
        $(moc) -o $@ $<


# how to build dependencies
$(depends): $(build)/%.dep: %.cpp
        @$(builddir)
        @echo 'creating $@'
        @$(cc) -MM $(cppflags) $(incl) $< >$@.tmp
        @sed 's/^$*.o/$(build)\/$*.dep $(build)\/$*.o/' $@.tmp >$@
        @rm $@.tmp


include $(depends)