Opensource QT4/QT5 and IDE Tools on Windows


Introduction: the choice of toolset

Up until now I have been developing software on Linux with its great variety of excellent opensource software development tools. When at last I came to an application for a real purpose, it was important to run it on Windows and to use a GUI that was rich in features. This application was to be an extension to a commercial Church Membership database that was developed in the Microsoft Access environment. As with most closed source software, it lacked adequate configurability for our needs. We extended it gradually with add-ons written within the Access environment, but quickly discovered Access's limitations.  I wanted to do some real software development using a modern object-oriented language, and balked at the necessity to learn Visual Basic and to remain tied into Access. Finding a good language, IDE and GUI framework for both platforms has been a somewhat difficult process.

GUI Frameworks

The three main GUI frameworks available for multiple platforms are
GTK+, WxWidgets and QT. After trying out the first two, I felt I could not go past QT. It is very complex but very well documented and provides an immensely rich set of C++ classes for all sorts of tasks.

QT4 is a significant upgrade from QT3, involving a large number of naming changes and concept changes. This meant a significant rewrite of QT3 applications. The IDE provided with QT3 has been dropped and QT4 is designed instead to be integrated into other existing IDEs. Other changes have occurred in moving to QT4.2, so the framework appears to be a moveable feast. A big plus for QT4 is that it has been made opensource on Windows and Macintosh as well as  Linux. QT5 is a smaller but significant upgrade of QT4 and requires a small number of changes to QT4 programs.


GTK+ and WxWidgets are simple to use and great for rapid development work. I feel that they do not have the richness of QT for larger projects where greater control over the GUI is desired. This may be a little unjust as I didn't go deeply into them, but I believe that they are excellent frameworks for Rapid Application Development of smaller projects or those that have only basic requirements for the GUI.

Language

My first thought was to use Python; after all someone will have to take over after me. In the end the need to install a runtime environment and Python-C++ wrappers, as well as facing potential performance hits with an interpreted language, led me to fall back on QT's natural language C++. The complexity of the application would be mainly in the QT implementations. Though C++ is a bit heavyweight and showing signs of excessive modification over the years, it is still of excellent value as a modern OO language. I also feel more comfortable with the strict typing that it enforces.

IDE

I used QT3 and KDevelop on Linux quite happily for some time. These work reasonably well together. To use QT on Windows with some sort of C++ IDE, I drifted naturally to the MinGW port of gnu gcc, and the Dev-C++ IDE provided as opensource by Bloodshed Software.
Dev-C++ is a basic IDE, easy to learn and use, but appears somewhat unfinished, and development appears to have stalled for over 18 months as of this writing. It has an integrated code editor, class browser, and convenience buttons to compile and run the application. I was not able to get the integrated debugger to work most likely because I hadn't built QT on Windows with debug support enabled (see below). It also has some other annoying quirks that are bound to build your character. QT is not integrated with it in any way. While it seems possible to make it work a bit better than I could, the amount of effort required could be better expended on a more advanced IDE.

Another free but not opensource Windows IDE is Microsoft's Visual Studio Express. This appears to require extensive work: patching and compiling of QT. You can find information at Quantum GIS (slightly outdated) and PsiWiki. This would have required me to drift too far into the Windows universe so I didn't try it out.

Eclipse is based on Java and is available for both Windows and Linux. It has a bit of a steep learning curve and can be slow loading and running, but it also has a large user base and is growing continuously. This appears by far to be the best multiplatform opensource IDE available and is well worth the effort to learn how to use it. It works on the basis of a framework written in Java, coupled with plugins to support various languages and environments. The primary language support is for Java, but there are plugins to support development in Python and C/C++ among others. As well as some QT support in Eclipse, there are a couple of plugins to integrate QT into the framework: an embryonic offering http://artis.imag.fr/~Xavier.Decoret/resources/qt/eclipse/, and an Eclipse plugin for KDE (which is based on QT): http://kde-eclipse.pwsp.net/.

QIde is an IDE built for making more effective use of QT.


Installation and Configuration on Windows

This is for QT4. A similar approach would be needed for QT5. To begin, download the following packages:
  1. MinGW from Sourceforge MinGW. It can also be downloaded during the QT4 install process. This may be preferable to ensure that QT4 has the correct version of MinGW. The installer does not add a path variable pointing to the MinGW bin directory. Make sure that you add this (Windows XP: Control Panel/System/Advanced/ Environment Variables, and edit your personal path or system path). I put it in D:\Development\MinGW. There is another package called MinGW-utilities that you may find useful. Install this and any other MinGW packages over the MinGW installation root directory.
  2. MSYS from Sourceforge MinGW. This provides a Unix shell environment for building native Windows applications. Install this in a separate directory, but make sure you have already installed MinGW. A post-install procedure requires you to locate the latter to ensure good integration of the two.
  3. QT4 from Trolltech Downloads. The QT/Windows Open Source LGPL Edition, current version at this time is 4.5.1. You should get theDevelopment libraries for Windows, which is the version for MinGW (in my case it was qt-win-opensource-4.5.1-mingw.exe). This installs easily enough and a path variable is added automatically. I put it in D:\Development\QT4. The binary package for QT does not appear to include any debug libraries so it should be built from source to include these and any other plugins you need.
  4. A few other useful utilities:
    • Dependency Walker from here that shows what each application depends on.
    • Advancedinstaller from here. A basic but freeware windows installer packager.
QT Compilation

It is best to build QT from source to obtain the benefits of various debug features. You will also need to build QT statically if you intend to statically compile applications with QT. Note that many developers recommend against this practice with fanatical vigour, but some people consider it simpler to work with on Windows as only one (bulky) executable needs to be distributed. You may also need to add other types of support such as for SQL drivers. Read the various configure options carefully.

QT's deployment advice  tells us that we just need to run configure -debug-and-release from a command line, followed by mingw32-make The process can take several hours. For static build use configure
-debug-and-release -static. If you just want to build the basic libraries and binaries and are not interested in the examples etc, then use mingw32-make sub-src (which builds only the source). There is additional advice at qtnode.

Eclipse
  1. Download the package for your platform and make sure that the Java environment is installed. This should be provided with more recent Windows and Linux versions.
  2. On Linux I simply untarred it to a directory in my home directory, although it is possible as root to make it more globally accessible. Most distributions should have an install package for it (Fedora maintains a compiled Java version that does not need the Java environment and is a bit faster). For Windows again it can just be unzipped to a local directory. No installation is needed. The version at this time is 3.2.1.
  3. Start up the Eclipse executable. You are asked to nominate your workspace which I set as D:\Development. Projects will be formed in subdirectories of this workspace root.
  4. To get the C/C++ plugin, go to Help->Software Updates->Find and Install. Select "Search for New Features to Install" and click "New Remote Site". There you can add the URLs for sites with the C/C++ plugins CDT (http://download.eclipse.org/tools/cdt/releases/callisto), or Python Development PyDev (http://pydev.sf.net/updates/). Click finish and follow the prompts through. The plugins are found and you are invited to select the ones you want. Just select all of them and get it over with. These sites are arranged so that Eclipse downloads the plugins for you, but if you have many machines to setup, you can just download the packages and untar them so that the jar files end up in the plugins directory. For some plugins this is the only way to do it. When Eclipse is restarted they will be found and used.
  5. Now go to Window->Preferences. Here the fun starts as most of the options will require some reading and experience to be understood.
    • Expand the entry "General" and select Workspace. The top three checkboxes can be ticked; the third one saves files when a build is initiated, which is convenient.
    • If CDT is installed, you will see a C/C++ entry. Expand this entry and the entry for Make. Select "New Make Projects". I selected "Build on Resource Save". You should remove the "all" make option in both option boxes if you haven't built QT to include debugging. Uncheck the top checkbox "Use Default" and enter the FULL PATH to the MinGW executable mingw32-make rather than the default make. If you get errors saying that Eclipse is unable to launch make, this is most likely the reason. You can also change this under Project Preferences for individual projects.
    • Beware of the feature called "code completion" in the Eclipse editor. This can cause Eclipse to apparently hang. What happens is that when you type a character such as ".", "->" or "::" the editor will search for a class to match, and present a selection of valid classes and members. In Window->Preferences->C/C++->Editor->Content Assist, you will see radio buttons at the top which may offer to perform the search through all included files. This can save a lot of manual searching for an appropriate member function, but if you have a large number of classes, as a QT application may have, the search can take a very long time.
  6. Go to Window->Open Perspective->Other... You can select C/C++ to place the IDE into a state that is oriented better for the development of C/C++ projects.
  7. Go to Window->Views->Navigator. This is very convenient for finding and loading files to be edited. The other views could be closed until needed to leave more room on the screen for the editor window.
  8. Creating a new project is simple enough. Go to File->New->Project and select the project type you want. Enter the project name and click "Next" (not "Finish"). You then get a range of options. Just check the Make tab to ensure that the default settings made above have been selected. I have only used the Standard Make C/C++ project, which assumes a Makefile is provided. This is provided by qmake in my case, which I run from the command line outside Eclipse. It is likely that Eclipse could be coaxed to run qmake automatically before a build as there are utilities to create special builds. The Managed Make projects will have their Makefile created automatically by Eclipse.
  9. If you already have a project underway, copy it into a directory in your workspace and again go to File->New->Project. Give it the same name as the directory. It should then appear in the navigator panel (left side of screen) with all the files in the directory organised according to their purposes. I found that unless Eclipse had been used on this project before, I had to build the project before Eclipse sorted things out.
  10. Build the project by choosing Project->Clean in case there are old object files etc around. You can select if you want it to rebuild immediately afterwards. To run the project select Run->Run... and enter the location of the executable. On Windows this will be under the release or debug subdirectory depending on which one you want to run. Make sure that the project name is correct. After that has been configured, you can build and run by clicking an icon on the Toolbar. There is a "build all" icon also.
  11. On Windows, make sure the paths are defined (use a command window and type path to see the path settings) that point to the QT and MinGW bin directories. The latter does not seem to be set on install so you need to add it manually. You will need to set the QT one if you build from source.
Dev-C++

Many people have found difficulties with using Dev-C++ with QT. Dev-C++ needs some pampering to work effectively with QT. Here are the steps I took to get it going:
  1. Dev-Cpp from Sourceforge DevCpp. The latest version, currently 4.9.9.2 beta, is over 18 months old. The package installs easily. I put it in D:\Development\DevCpp (I like my root directory uncluttered).
  2. Decide on a directory to use for your code. In my case I used D:\Development\ChurchRoll. In there place all your source code files and the QT .ui files. You can play around with a better organization but I recommend this simple flat structure to start off.
  3. Use QT to create a simple window example called MainWindow, and save it in the D:\Development\ChurchRoll directory. You should have a file MainWindow.ui, which is an XML file containing all information about the window and anything you put on it.
  4. Now open up Dev-C++. Create a new project of type "Windows Application", and save the .dev file with an appropriate name in the D:\Development\ChurchRoll directory.
  5. You can now create the .cpp and .h files for the QT example you have created. This is heaps of fun but give yourself plenty of time to learn QT and C++. You only need some basic do-nothing files to start with, check out some of the examples provided with QT.
  6. When the source and header files are ready, open a DOS Command window and navigate to the D:\Development\ChurchRoll directory. Then type "qmake -project" to create a QT project file. This searches through the directory and all subdirectories under D:\Development\ChurchRoll to find any .h, .cpp and .ui files. You can put code in subdirectories if you like provided you run this command in the top directory. You really only need to do this once, but you can do it whenever new files are added if you don't want to edit the .pro file yourself. The .pro files are very simple in structure, and only need to have any new files added to the appropriate lines. If qmake can't be found, then the path is probably wrong.
  7. Then run "qmake". This creates a Makefile for compilation of the entire project. This needs to be done whenever the .pro file is changed.
  8. Unlike the Linux version, three Makefiles are created: Makefile, Makefile.release and Makefile.debug.
  9. To compile you should be able to run the command "make" or "mingw32-make" to compile the project. This uses Makefile.release. Makefile.debug will have difficulties if you have not compiled QT for debug support.
  10. To compile in Dev-Cpp you need to make the following settings in Project/Project Options:
    • Under "General" make sure it is a Win32 GUI type.
    • Under "Directories" add the QT lib directory and the QT include directory under the appropriate tabs.
    • If in "Build Options" you add the D:\Development\ChurchRoll\Resources directory as the executable output directory, you can then use Dev-C++ buttons to run the application. This directory is where the source code ends up. I find this very convenient, however Dev-C++ seems to try to create this directory and throws up error messages on startup.
    • Finally under "Makefile", make sure that you have changed the makefile to use the custom Makefile.release. The default is Makefile.win, and if it does't exist, Dev-C++ will create one which knows nothing about QT. If you get linker errors, always check first that the checkbox on this screen is ticked. It seems to turn itself off at odd times after any options are changed.
  11. Note that I abandoned Dev-C++ before I got around to checking out the debug features.
Acknowledgements

Many thanks to Trolltech for releasing this very powerful GUI development tool, and to Microsoft for releasing Visual Studio. Also to the developers of Dev-C++, Eclipse, CDT and MinGW and other utilities and packages mentioned here. All of these efforts are much appreciated as are those of all opensource developers.



Contact: My email address can be constructed from the username "ksarkies" and the ISP DNS address internode.on.net in the usual way.


First created 28 September 2006
Last modified
25 November 2006
Minor changes 14 February 2016
Ken Sarkies 2006