Compile Qt Applications with custom Makefile

Hi folks, this is a quick post to "Compile Qt application using your own Makefile".
[ I am sure there is no link which explains about this !!! ]

Stuffs I have used:
[*] Qt 4.8.1 compiled and installed in my machine [how to do that?], with Visual C++ 10 compiler.
[*] Windows-7 operating system, 64-Bit.
[*] Knowledge about writing Makefile [ref] [I am not discussing how to write Makefiles here with this post]

So, our first step is to have one Qt application. For testing purpose you can use mine  [download-in-zip].
In my test application I have used all the stuffs that a common Qt developer needs to, like UI components, CPP files, H files and QRC files.
I will be referring to same test application shared above.

Before I start discussion, let me put all the codes in here first,


/* ----------------------------------------- */
/* File Name: main.cpp        */
/* ----------------------------------------- */

1. #include <QtGui/QApplication>
2. #include "mainwindow.h"
3. 
   
4. int main(int argc, char *argv[])
5. {
6.     QApplication a(argc, argv);
7.     MainWindow w;
8.     w.show();    
9.     return a.exec();
10. }

/* ----------------------------------------- */
/* File Name: mainwindow.cpp        */
/* ----------------------------------------- */

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
3. #include <QPixmap>
4. 
   
5. MainWindow::MainWindow(QWidget *parent) :
6.     QMainWindow(parent),
7.     ui(new Ui::MainWindow)
8. {
9.     ui->setupUi(this);
10. }
11. 
    
12. MainWindow::~MainWindow()
13. {
14.     delete ui;
15. }
16. 
    
17. void MainWindow::on_pushButtonShow_clicked()
18. {
19.     QPixmap pixmap(":/Image/butterfly.jpg");
20.     ui->imageLabel->setPixmap(pixmap);
21. }

/* ----------------------------------------- */
/* File Name: mainwindow.h        */
/* ----------------------------------------- */

1. #ifndef MAINWINDOW_H
2. #define MAINWINDOW_H
3. 
   
4. #include <QMainWindow>
5. 
   
6. namespace Ui {
7. class MainWindow;
8. }
9. 
   
10. class MainWindow : public QMainWindow
11. {
12.     Q_OBJECT
13.     
14. public:
15.     explicit MainWindow(QWidget *parent = 0);
16.     ~MainWindow();
17.     
18. private slots:
19.     void on_pushButtonShow_clicked();
20. 
    
21. private:
22.     Ui::MainWindow *ui;
23. };
24. 
    
25. #endif // MAINWINDOW_H

And UI file, mainwindow.ui has one QLabel named as "imageLabel" and one QPushButton named, "pushButtonShow".

And QRC file, "TestRsrc.qrc" has butterfly.jpg under one prefix name "/Image".

Now, let's look into Custom Makefiles.

I have divided Makefiles into 2 different parts, with respect to their operation.
First Makefile, under source main directory, defines rules for building Object files.
Second Makefile, under build directory defines rules for linking object files with Qt shared libraries, in general resolves symbol definition in objects.
And, Config file under build directory, as name indicates, has some of the common configuration definitions for compilation.
Below are the Makefiles and Config files,

1. ####### Config file
2. 
   
3. CXX           = cl
4. 
   
5. QT_DEFINES  = -DUNICODE -DQT_LARGEFILE_SUPPORT -DQT_DLL -DQT_GUI_LIB -DQT_CORE_LIB -DQT_HAVE_MMX -DQT_HAVE_3DNOW -DQT_HAVE_SSE -DQT_HAVE_MMXEXT -DQT_HAVE_SSE2 -DQT_THREAD_SUPPORT 
6. 
   
7. DEFINES       = $(QT_DEFINES) -D"WIN32" -D"WINVER=0x0601" -DINTERNAL -DMEASURE_TIME=0 -DMEASURE_POWER=0 
8. 
   
9. CXXFLAGS      = -nologo -Zc:wchar_t- -GR -EHsc -MDd -W3 -w34100 -w34189 /Od $(DEFINES) -c
10. 
    
11. QT_PATH  = C:\QtSDK\Desktop\Qt\4.8.0\msvc2010
12. 
    
13. INCPATH       = -I"$(QT_PATH)\include" -I"$(QT_PATH)\include\QtCore" -I"$(QT_PATH)\include\QtGui" -I"." -I"..\..\Sources" -I"." -I"$(QT_PATH)\mkspecs\win32-msvc2010" 
14. 
    
15. LNK           = link.exe
16. 
    
17. LFLAGS        = /NOLOGO /DEBUG /SUBSYSTEM:WINDOWS /INCREMENTAL:NO 
18. 
    
19. QT_LIBS       = $(QT_PATH)\lib\qtmaind.lib $(QT_PATH)\lib\QtGuid4.lib $(QT_PATH)\lib\QtCored4.lib 
20. 
    
21. ADD_LIB  = 
22. 
    
23. MFLAGS  = -D_MSC_VER=1500 -DWIN32
24. 
    
25. QMOC  = $(QT_PATH)\bin\moc.exe
26. 
    
27. QRCC  = $(QT_PATH)\bin\rcc.exe
28. 
    
29. ####### Output format
30. 
    
31. PATH_SEP  = ^\
32. SRCDIR  = ..$(PATH_SEP)
33. OBJDIR    = .$(PATH_SEP)
34. OBJECT_SUFIX  = obj
35. DESTDIR       = .$(PATH_SEP)
36. TARGET        = TestApp
37. TARGET_SUFIX  = exe
38. OUTPUT  = TestApp.$(TARGET_SUFIX)

Makefile, which resides under Build directory,

1. ####### Makefile for Linking apps #######
2. ####### Reside under Build directory #######
3. ####### Basically resolves symbol definitions for objects #######
4. 
   
5. ####### Includes
6. 
   
7. include Config
8. include ..\Makefile
9. 
   
10. ####### Main Build rules
11. 
    
12. all: $(OBJECTS) $(TARGET)
13. 
    
14. $(TARGET): $(OBJECTS) 
15. $(LNK) $(OBJECTS) $(ADD_LIB) $(QT_LIBS) $(LFLAGS) /out:$(OUTPUT)
17. clean:
18. del *.$(OBJECT_SUFIX) *.$(TARGET_SUFIX) moc_*.cpp qrc_*.cpp *.pdb *.manifest 

Makefile, which resides under main source directory,

1. ####### Makefile for building objects #######
2. ####### Reside under main source directory #######
3. ####### Rules and definitions for building objects and other dependencies #######
4. 
   
5. default:all
6. 
   
7. ####### Source Files
8. 
   
9. SOURCES       = $(SRCDIR)main.cpp \
10. $(SRCDIR)mainwindow.cpp
11. 
    
12. MOC_SRC  = moc_mainwindow.cpp 
14. QRC_SRC  = qrc_TestRsrc.cpp
16. ####### Object Files
18. CORE_OBJ      = main.$(OBJECT_SUFIX) \
19. mainwindow.$(OBJECT_SUFIX)
20. 
    
21. MOC_OBJ  = moc_mainwindow.$(OBJECT_SUFIX)
23. QRC_OBJ  = qrc_TestRsrc.$(OBJECT_SUFIX)
24. 
    
25. OBJECTS  = $(MOC_OBJ) $(QRC_OBJ) $(CORE_OBJ)
26. 
    
27. ####### MOC Source Build rules
28. 
    
29. moc_mainwindow.cpp: $(SRCDIR)mainwindow.h
30. $(QMOC) $(DEFINES) $(INCPATH) $(MFLAGS) $(SRCDIR)mainwindow.h -o moc_mainwindow.cpp
31. 
    
32. ####### QRC Source Build rules
33. 
    
34. qrc_TestRsrc.cpp: $(SRCDIR)TestRsrc.qrc
35. $(QRCC) -name TestRsrc $(SRCDIR)TestRsrc.qrc -o qrc_TestRsrc.cpp
36. 
    
37. ####### Core Object Build rules
38. 
    
39. main.$(OBJECT_SUFIX): $(SRCDIR)main.cpp
40. $(CXX) $(SRCDIR)main.cpp $(INCPATH) $(CXXFLAGS) main.$(OBJECT_SUFIX)
41. 
    
42. mainwindow.$(OBJECT_SUFIX): $(SRCDIR)mainwindow.cpp
43. $(CXX) $(SRCDIR)mainwindow.cpp $(INCPATH) $(CXXFLAGS) mainwindow.$(OBJECT_SUFIX)
45. ####### MOC Object Build rules
46. 
    
47. moc_mainwindow.$(OBJECT_SUFIX): moc_mainwindow.cpp
48. $(CXX) moc_mainwindow.cpp $(INCPATH) $(CXXFLAGS) moc_mainwindow.$(OBJECT_SUFIX)
50. ####### QRC Object Build rules
51. 
    
52. qrc_TestRsrc.$(OBJECT_SUFIX): qrc_TestRsrc.cpp
53. $(CXX) qrc_TestRsrc.cpp $(INCPATH) $(CXXFLAGS) qrc_TestRsrc.$(OBJECT_SUFIX)

If you have used command line compilation for VC++, by this time you must have understood above Config and Makefiles. I cannot explain command line compilation and other basic stuffs here, but will try to clarify as much as possible.

If you look into Config file,
Line number 3: says compiler we going to use is CL (VC++ command line compiler).
Line number 5: gives some of the Qt standard definitions needed for compilation. -D<definition> or /D<definition> is a flag to define them in CL.
Line number 7: is custom definitions or user definitions. If you have any specific pre-compilation definitions, then you can define them here with flag -D or /D.
Line number 9: is standard CPP and Qt flags used to compile CPP application in CL.
Line number 11: says compiler where to refer for Qt related stuffs compilation. This is where my Qt was installed, you have to change this path to your Qt installation path before you compile.
Line Number 13: is reference path for include files you have used in your application. If you have included any specific files in your program other than mentioned here, you have to include them here.
Line number 15 and 17: says our linking application is link.exe and some standard flags for linking.
Line number 19: says Qt shared libraries (lib files) required to resolve symbols and definitions used in application. If you have referenced any other Qt libraries, for example QtNetwork, you have to include that library here.
Line number 21: is for further development, which gives you option to include and link additional libraries or 3rd party libraries you have referenced in your application.
Line number 23: is flag for generating MOC objects.
Line number 25 and 27: this defines path for moc and rcc apps, which is required to build moc objects and objects out from q-resource files. This apps are part of your Qt installation.
Line 31 to 38 define some of the relative path for where to find elements and output format.

The Makefile under build directory, is quite simple.
It includes definitions and rules from Config and other Makefile. It has 3 rules viz., which builds Objects first and then Target exe will be linked with libs and objects. These are the general Makefile rules I have used and nothing much to say about them.

Now, let me brief some about Makefile under main source directory.
This Makefile contains basic rules to build objects out from standard CPP files, MOC files and QRC files.
Remember steps to build the objects,
> MOC objects and QRC objects should be built before you build CPP objects.
> Header files (.h files), having Q_OBJECT macro definition in their class, needs only be generated MOC files. Other header files can be treated as normal CPP headers.
> Before you build MOC and QRC objects, you have to use moc.exe and rcc.exe apps to build their corresponding CPP files.
So look into Makefile, Line number 9, 12 and 14 says we have 4 CPP source files need to be compiled into Objects.
Line number 25 says we have 3 types of objects, need to be built in order specified.
If you look into Moc source build rules, that is line number 29 and 30, it uses moc.exe app to generate moc_mainwindow.cpp source file corresponding header "mainwindow.h". To know more about building Moc objects in Qt, refer here.
Line number 34 and 35 says standard rules to build QRC source file.
Refer naming conventions for building Moc and QRC files; they have moc_<filename>.cpp and qrc_<filename>.cpp; and their corresponding object files will be moc_<filename>.obj and qrc_<filename>.obj after built. This is how it has to be, and follow the same convention for better understanding.
At this point we have all 4 source files ready to build into objects. Use CPP standard method to build all source files into objects. Don't forget to specify proper paths for your build.

That is all about your custom Makefiles, used to build your Qt application.

If you have downloaded my sample application, which I have shared above, try to build it with Visual C++ command line.
Unzip the file into safe location (say c:\testapp)
Open Config file, inside build directory, with any text editor and change "Qt_PATH" definition to corresponding Qt installation path in your machine.
Go to Start > All Programs > Microsoft Visual Studio 2010 > Visual Studio Tools, and open "Visual Studio Command Prompt 2010".
Navigate to the location c:\testapp and then navigate inside "build" directory.
Give command "nmake all"
This should build your exe. In order to run the exe, you have to keep corresponding runtime DLLs inside the directory where exe is executing from. So copy two files QtCored4.dll and QtGuid4.dll from your Qt installation path into build directory and run the application.
To clen the build, execute command "nmake clean".

Hope this is helpful.