Dynamically use QGLWidget or QOpenGLWidget depending on Qt version - c++

Question

My code is supposed to compile and run on platforms before and after Qt 5.4 where QOpenGLWidget was introduced, superseding QGLWidget. I thought I could write code like this to support both:
#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
# define USE_Q_OPEN_GL_WIDGET
#endif
#ifdef USE_Q_OPEN_GL_WIDGET
# include <QOpenGLWidget>
#else
# include <QGLWidget>
#endif
class GLWidget :
#ifdef USE_Q_OPEN_GL_WIDGET
public QOpenGLWidget
#else
public QGLWidget
#endif
{
Q_OBJECT
public:
[...]
But that will not fly because moc does not seem to understand the preprocessor directives and will generate code for the wrong class.
I tried to work around the problem by adding a add_custom_command directive to my CMakeLists.txt which would run ${CMAKE_CXX_COMPILER}" -E -P -x c++-header ... on the file before passing it to moc. But that doesn't seem to work either as the preprocessor will remove the magic Q_OBJECT line, indicating that indeed moc must be run before the C preprocessor is run.
What other options do I have?
Must I resort to having two nearly identical header files (except for two lines) and then choose the right one at build time in cmake?
EDIT
To test this problem, try out the following:
on a Ubuntu trusty system which comes with qt 5.2.1 (you can create a chroot using sudo debootstrap trusty ubuntu-trusty) do:
apt-get install libqt5opengl5-dev build-essential qttools5-dev qt5-default
then create glwidget.h containing:
#ifndef GLWIDGET_H
#define GLWIDGET_H
#include <QtGlobal>
#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
# define USE_Q_OPEN_GL_WIDGET
#endif
#ifdef USE_Q_OPEN_GL_WIDGET
# include <QOpenGLWidget>
#else
# include <QGLWidget>
#endif
class GLWidget :
#ifdef USE_Q_OPEN_GL_WIDGET
public QOpenGLWidget
#else
public QGLWidget
#endif
{
Q_OBJECT
};
#endif
then run:
$ moc -v
moc 5.2.1
$ moc glwidget.h | grep QGL || echo "not found"
not found
$ moc glwidget.h | grep QOpenGL >/dev/null && echo "found!"
found!
so you see that even though qt 5.2.1 does not have QOpenGL, moc interpretes the preprocessor directive that way
we can change the version check to the much simpler
#if QT_VERSION >= 0x050400
if we try again with that check, then moc in qt 5.2.1 in Ubuntu trusty generates the right results
so we think that we found the solution and try running moc from a more recent qt distribution on the same code. This time I'm using moc from qt 5.5.1 in Debian unstable and I get:
$ moc -v
moc 5.5.1
$ moc glwidget.h | grep QOpen || echo "not found"
not found
$ moc foo.h | grep QGL > /dev/null && echo "found"
found
most funnily, if under qt 5.5.1 I turn the version check macro mack to using
#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
then it does work!
So in summary, moc does understand some preprocessor directives but the ones it does understand are different between versions before and after qt 5.4. There does not seem to exist a common preprocessor directive that is understood by both. Thus I do not see a way to solve this problem using preprocessor directives.

Answer 1

You can use CMake to generate this header. Put this code into it:
#include <#GL_CLASS#>
class GLWidget : #GL_CLASS#
{
Q_OBJECT
public:
[...]
And then do this in CMakeLists.txt:
set(GL_CLASS <depending on Qt version>)
include_directories(${CMAKE_CURRENT_BINARY_DIR}) #this is because configure_file produces its output in the build dir
configure_file(yourheader.h output.h #ONLY)
Finally, use #include "output.h" in your code.