Merge lp:~fschauk/stellarium/qopenglwidget into lp:stellarium

[Florian Schaukowitsch]

This branch removes the dependency on the deprecated QtOpenGL module by changing the main viewport to use the newer QOpenGLWidget from the QtGUI module instead of the old QGLWidget.

Additionally, it changes the way the Qt libraries are linked with CMake by using the provided imported targets, instead of the deprecated QT5_USE_MODULES. Also, the external depedencies are now built as static libraries and linked in later, this is a cleaner setup and accelerates rebuilding (especially the tests).

The OpenGL library is now only directly linked when building for an ES2-only platform. All GL access is done through the QtGUI module and QOpenGLFunctions directly. The troublesome macros from StelOpenGL have all been removed.

Many classes used the same GL calls to repeatedly set up blending modes, line smoothing, etc. This is now part of StelPainter, which tracks the current state and avoids GL calls if possible. Only very few classes now call GL directly.

QOpenGLWidget requires Qt 5.4 at a minimum. A CMake flag USE_OLD_QGLWIDGET can be used to switch back to the QGLWidget, this allows Stellarium to still be built with 5.3.
The widget change has an effect on performance. On Windows, there generally seems to be a slight FPS decrease when QOpenGLWidget is used (220 instead of 240 FPS for me), while on Linux Georg and I noticed an improved performance (in a case even ~50%!).
I'm not fully sure what causes this, but most likely the internal changes QOpenGLWidget has are at fault. It uses an explicit framebuffer object for rendering, and context sharing.

I need further help testing:
- Touch/Pinch input (Windows)
- HiDPI/Retina rendering
because I don't have the necessary hardware.

[gzotti (georg-zotti)]

Looks like a thorough cleanout of old stuff, restructuring of the CMakefile for a faster build esp of the tests, and the removal of the deprecated QGLWidgets is a clear step forwards which should ensure longevity even beyond Qt5.7.
I have tested pinch/touch now on my netbook (40min compile...), works nicely on Win10!
I don't have any HiDPI hardware to test either, sorry.
I have tested a week ago on RaspberryPi. I compiles with the old classes from its old Qt5.3.2.
The performance loss on Windows is strange, maybe we should keep the old class on Windows for a while? On 2 PC-based Linux systems I saw consistently higher framerate.
I would like to hear about Mac compatibility, but from my side, I approve.

review: Approve

[Guillaume Chereau (guillaume-chereau)]

Approve.

I agree: the cleanup of the CMakeFile.txt is very welcome!

Could we remove USE_OLD_QGLWIDGET in StelMainView now? Or is that still
needed?

[Fabien Chéreau (xalioth)]

Good patch! Fine for me.

I also don't think it makes much sense to support Qt < 5.3 as we already have too many configuration to deal with so I'd also just drop USE_OLD_QGLWIDGET to clean up the code further.

review: Approve

[gzotti (georg-zotti)]

Just FYI: There are systems still around which don't have upgraded to Qt5.4 yet. Esp. Raspbian on the Raspberry Pi 2 or 3 platform has Qt5.3.2, and I have failed so far to compile and setup Qt myself successfully in a way that wold allow Stellarium to run (I am not familiar enough with X11 and EGL to understand the error messages). I consider this platform interesting for education and low-power use, there is a new open-source OpenGL driver just being completed (actually Mesa13 has it, but I now noted a new heavy bug in it). Else Stellarium runs with 12-20fps now, that's competitive to my AMD Win10 netbook. When Raspbian (and any other platforms we can regard important) comes with Qt5.4+, we can remove USE_OLD_QGLWIDGET.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-01-03 08:56:34 +0000
+++ CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -16,6 +16,9 @@
     CMAKE_POLICY(SET CMP0054 OLD)
 ENDIF()
 
+# warn about deprecated stuff so that we may try fixing it
+SET(CMAKE_WARN_DEPRECATED 1)
+
 ########### Project name ###########
 PROJECT(Stellarium)
 # Use integer versions instead of strings for easier handling if required
@@ -37,6 +40,7 @@
 # Write version of Stellarium to Stellarium User Guide
 FILE(WRITE ${PROJECT_SOURCE_DIR}/guide/version.tex "\\newcommand{\\StelVersion}{${VERSION}}\n")
 
+# currently Qt 5.4 - 5.6 is recommended, we can still build with Qt 5.3, and 5.7 may have some bugs
 SET(MINIMAL_QT_VERSION "5.3.0")
 
 # Use customized cmake macros
@@ -58,6 +62,13 @@
     ADD_DEFINITIONS(-DQT_NO_DEBUG -DNDEBUG)
 endif()
 
+set(OPENGL_DEBUG_LOGGING 0 CACHE BOOL "Enable to log OpenGL information using the GL_KHR_debug extension/QOpenGLLogger")
+if(OPENGL_DEBUG_LOGGING)
+    add_definitions(-DOPENGL_DEBUG_LOGGING)
+    # This enables logging of QOpenGLFunctions through forced glGetError after each call
+    add_definitions(-DQ_ENABLE_OPENGL_FUNCTIONS_DEBUG)
+endif()
+
 # Use ccache if possible
 find_program(CCACHE_PROGRAM ccache)
 if(CCACHE_PROGRAM)
@@ -276,6 +287,7 @@
 ADD_PLUGIN(Exoplanets 1)
 ADD_PLUGIN(EquationOfTime 1)
 ADD_PLUGIN(FOV 1)
+# TODO: Logbook build is broken for quite some time
 ADD_PLUGIN(LogBook 0)
 ADD_PLUGIN(MeteorShowers 1)
 ADD_PLUGIN(NavStars 1)
@@ -318,8 +330,9 @@
 FIND_PACKAGE(Qt5Concurrent REQUIRED)
 FIND_PACKAGE(Qt5Gui REQUIRED)
 FIND_PACKAGE(Qt5Network REQUIRED)
-FIND_PACKAGE(Qt5OpenGL REQUIRED)
 FIND_PACKAGE(Qt5Widgets REQUIRED)
+# required for qcustomplot external dependency
+# not used elsewhere
 FIND_PACKAGE(Qt5PrintSupport REQUIRED)
 IF(USE_PLUGIN_TELESCOPECONTROL)
      FIND_PACKAGE(Qt5SerialPort REQUIRED)
@@ -355,6 +368,38 @@
      ENDIF()
 ENDIF()
 
+# when using Qt 5.3, default to using the old QGLWidget, but warn
+if(${Qt5Core_VERSION_STRING} VERSION_LESS "5.4")
+    set(USE_OLD_QGLWIDGET 1)
+    message(WARNING "You are using Qt ${Qt5Core_VERSION_STRING} to build, falling back to legacy QGLWidget rendering. Consider using at least Qt 5.4 if possible.")
+else()
+    # offer the old widget as an alternative, default off
+    set(USE_OLD_QGLWIDGET 0 CACHE BOOL "Use the legacy QGLWidget instead of the new QOpenGLWidget for the main viewport, and link to the QtOpenGL module")
+endif()
+
+if(USE_OLD_QGLWIDGET)
+    add_definitions(-DUSE_OLD_QGLWIDGET)
+    find_package(Qt5OpenGL REQUIRED)
+endif()
+
+# Since Qt 5.4, linking to OpenGL is basically not required anymore,
+# because the QtGui module re-implements the GL functions, and perhaps even
+# dispatches the calls to a dynamically selected GL library.
+#
+# The only exception where this does not work with CMake is for
+# ES2-only/ANGLE-only builds, which are seemingly not included in
+# official Qt downloads, but may be required as a custom build
+# for some embedded systems. Interestingly, this works with qmake,
+# but CMake needs an explicit link definition.
+# See also this bug: https://bugreports.qt.io/browse/QTBUG-29132
+
+# Check if we have a GLES-only build
+# On dynamic builds, this property is also "GL"
+if(${Qt5Gui_OPENGL_IMPLEMENTATION} MATCHES "GLES")
+    message(STATUS "Building an OpenGL ES build (${Qt5Gui_OPENGL_IMPLEMENTATION})")
+    set(STEL_GLES_LIBS Qt5::Gui_EGL Qt5::Gui_GLESv2)
+endif()
+
 
 # Tell CMake to run moc when necessary:
 set(CMAKE_AUTOMOC ON)
@@ -362,31 +407,38 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 IF(ENABLE_SCRIPTING)
-    SET(QT_USE_QTSCRIPT TRUE)
     FIND_PACKAGE(Qt5Script REQUIRED)
-    INCLUDE_DIRECTORIES(${Qt5Script_INCLUDE_DIRS})
 ENDIF()
 IF(ENABLE_MEDIA)
     ADD_DEFINITIONS(-DENABLE_MEDIA)
     FIND_PACKAGE(Qt5Multimedia REQUIRED)
     FIND_PACKAGE(Qt5MultimediaWidgets REQUIRED)
-    INCLUDE_DIRECTORIES(${Qt5Multimedia_INCLUDE_DIRS})
-    INCLUDE_DIRECTORIES(${Qt5MultimediaWidgets_INCLUDE_DIRS})
-ENDIF()
-
-# I add this test because on Windows with angle we should not link
-# with OpenGL.  Maybe there is a better way to do that.
-IF("${Qt5Gui_OPENGL_LIBRARIES}" MATCHES "opengl")
-    FIND_PACKAGE(OpenGL REQUIRED)
-ENDIF()
-IF(NOT WIN32)
-    FIND_PACKAGE(ZLIB)
-ELSE()
-    SET(ZLIB_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/src/core/external/zlib)
 ENDIF()
 
 FIND_PACKAGE(Qt5Test)
-INCLUDE_DIRECTORIES(${Qt5Test_INCLUDE_DIRS})
+
+### Setup external packages
+
+find_package(ZLIB QUIET) #quiet warnings about not found, we have our own version anyway
+
+# if a system zlib is found, let the user choose if to instead use our bundled version
+if(ZLIB_FOUND)
+    if(WIN32) #on win, we default to "no"
+        set(USE_SYSTEM_ZLIB 0 CACHE BOOL "Use system-provided zlib instead of the bundled version")
+    else() #else, we default to "yes"
+        set(USE_SYSTEM_ZLIB 1 CACHE BOOL "Use system-provided zlib instead of the bundled version")
+    endif()
+else()
+    set(USE_SYSTEM_ZLIB 0)
+endif()
+
+if(NOT USE_SYSTEM_ZLIB)
+    #use our own zlib
+    message(STATUS "Using bundled zlib version at ${CMAKE_SOURCE_DIR}/src/external/zlib")
+    set(ZLIB_LIBRARIES zlib_stel)
+else()
+    message(STATUS "Using system-provided zlib at ${ZLIB_LIBRARIES}")
+endif()
 
 ########### Set some global variables ###########
 IF(UNIX AND NOT WIN32)
@@ -408,7 +460,6 @@
     ADD_DEFINITIONS(-DINSTALL_LOCALEDIR_FOR_DEBUG="${CMAKE_SOURCE_DIR}")
 endif()
 
-
 ########### Get revision number for non-release builds ###########
 IF(NOT STELLARIUM_RELEASE_BUILD)
     # Hack until CMake detection for Bazaar is finished
@@ -502,12 +553,12 @@
     GET_TARGET_PROPERTY(QtConcurrent_location Qt5::Concurrent LOCATION)
     GET_TARGET_PROPERTY(QtCore_location Qt5::Core LOCATION)
     GET_TARGET_PROPERTY(QtGui_location Qt5::Gui LOCATION)
-    GET_TARGET_PROPERTY(QtOpenGL_location Qt5::OpenGL LOCATION)
     GET_TARGET_PROPERTY(QtNetwork_location Qt5::Network LOCATION)
     GET_TARGET_PROPERTY(QtWidgets_location Qt5::Widgets LOCATION)
     GET_TARGET_PROPERTY(QtSql_location Qt5::Sql LOCATION)    
     GET_TARGET_PROPERTY(QtXmlPatterns_location Qt5::XmlPatterns LOCATION)
     GET_TARGET_PROPERTY(QtPrintSupport_location Qt5::PrintSupport LOCATION)
+    SET(ISS_QT_PRINTSUPPORT "Source: \"${QtPrintSupport_location}\"; DestDir: \"{app}\";")
     IF(ENABLE_SCRIPTING)
         GET_TARGET_PROPERTY(QtScript_location Qt5::Script LOCATION)
         SET(ISS_QT_SCRIPT "Source: \"${QtScript_location}\"; DestDir: \"{app}\";")
@@ -685,16 +736,10 @@
      ${CMAKE_SOURCE_DIR}/src/core
      ${CMAKE_SOURCE_DIR}/src/core/modules
      ${CMAKE_SOURCE_DIR}/src/core/planetsephems
-     ${CMAKE_SOURCE_DIR}/src/core/external
-     ${CMAKE_SOURCE_DIR}/src/core/external/qtcompress
-     ${CMAKE_SOURCE_DIR}/src/core/external/qcustomplot
-     ${CMAKE_SOURCE_DIR}/src/core/external/glues_stel/source/
-     ${CMAKE_SOURCE_DIR}/src/core/external/glues_stel/source/libtess
      ${CMAKE_SOURCE_DIR}/src/gui
      ${CMAKE_SOURCE_DIR}/src/scripting
      ${INTL_INCLUDE_DIR}
      ${CMAKE_BINARY_DIR}/src
-     ${ZLIB_INCLUDE_DIR}
 )
 
 ########### Subdirectories ###############

=== modified file 'cmake/default_config.ini.cmake'
--- cmake/default_config.ini.cmake	2016-10-29 12:45:33 +0000
+++ cmake/default_config.ini.cmake	2017-01-12 21:08:38 +0000
@@ -22,6 +22,7 @@
 maximum_fps                         = 10000
 #viewport_effect                     = sphericMirrorDistorter
 viewport_effect                     = none
+vsync                               = true
 
 [projection]
 type                                = ProjectionStereographic

=== modified file 'cmake/stellarium.iss.cmake'
--- cmake/stellarium.iss.cmake	2017-01-03 08:56:34 +0000
+++ cmake/stellarium.iss.cmake	2017-01-12 21:08:38 +0000
@@ -47,13 +47,12 @@
 Source: "@CMAKE_SOURCE_DIR@\ChangeLog"; DestDir: "{app}"; Flags: ignoreversion; DestName: "ChangeLog.rtf"
 Source: "@QtCore_location@"; DestDir: "{app}";
 Source: "@QtGui_location@"; DestDir: "{app}";
-Source: "@QtOpenGL_location@"; DestDir: "{app}";
 Source: "@QtNetwork_location@"; DestDir: "{app}";
 Source: "@QtWidgets_location@"; DestDir: "{app}";
 Source: "@QtSql_location@"; DestDir: "{app}";
 Source: "@QtXmlPatterns_location@"; DestDir: "{app}";
 Source: "@QtConcurrent_location@"; DestDir: "{app}";
-Source: "@QtPrintSupport_location@"; DestDir: "{app}";
+@ISS_QT_PRINTSUPPORT@
 @ISS_QT_SCRIPT@
 @ISS_QT_MULTIMEDIA@
 @ISS_QT_SERIALPORT@

=== modified file 'data/shaders/s3d_pixellit.frag'
--- data/shaders/s3d_pixellit.frag	2015-09-11 16:34:17 +0000
+++ data/shaders/s3d_pixellit.frag	2017-01-12 21:08:38 +0000
@@ -32,6 +32,7 @@
 #define SHADOW_FILTER 0
 #define SHADOW_FILTER_HQ 0
 #define SINGLE_SHADOW_FRUSTUM 1
+#define HW_SHADOW_SAMPLERS 0
 #define PCSS 0
 #define MAT_DIFFUSETEX 1
 #define MAT_EMISSIVETEX 1
@@ -254,10 +255,10 @@
 #endif
 //shadow related uniforms
 uniform vec4 u_vSplits; //the frustum splits
-#if PCSS
+#if HW_SHADOW_SAMPLERS
+	#define SHADOWSAMPLER sampler2DShadow
+#else
 	#define SHADOWSAMPLER sampler2D
-#else
-	#define SHADOWSAMPLER sampler2DShadow
 #endif
 
 //for some reason, Intel does absolutely not like it if the shadowmaps are passed as an array
@@ -311,23 +312,29 @@
 	{
 		vec2 offset = poissonDisk[i] * filterRadiusUV;
 		//TODO offsets should probably depend on light ortho size?
-		#if PCSS
+		#if HW_SHADOW_SAMPLERS
+		sum+=shadow2D(tex,vec3(texC.xy + offset, texC.z)).x;
+		#else
 		//texture is a normal sampler2D because we need depth values in blocker calculation
 		//opengl does not allow to sample this texture in 2 different ways (unless sampler objects are used, but needs version >= 3.3)
 		//so we have to do comparison ourselves 
 		sum+= (texture2D(tex,texC.xy + offset).r > texC.z) ? 1.0f : 0.0f;
-		#else
-		sum+=shadow2D(tex,vec3(texC.xy + offset, texC.z)).x;
 		#endif
 	}
 	return sum / FILTER_STEPS;
-	#else
+	#elif HW_SHADOW_SAMPLERS
 	//no filtering performed, just return the sampled tex
 	return shadow2DProj(tex,coord).x;
+	#else
+	vec3 texC = coord.xyz / coord.w;
+	return texture2D(tex,texC.xy).x > texC.z ? 1.0f : 0.0f;
 	#endif
 }
 
 #if PCSS
+#if HW_SHADOW_SAMPLERS
+#error Tried to compile PCSS shader compiled with HW shadow samplers
+#endif
 //Based on the PCSS implementation of NVidia, ported to GLSL 
 //see http://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
 //Some modifications to work better with directional light are included

=== modified file 'guide/version.tex'
--- guide/version.tex	2017-01-02 14:34:22 +0000
+++ guide/version.tex	2017-01-12 21:08:38 +0000
@@ -1,1 +1,1 @@
-\newcommand{\StelVersion}{0.90.0}
+\newcommand{\StelVersion}{0.90.0}

=== modified file 'plugins/AngleMeasure/src/AngleMeasure.cpp'
--- plugins/AngleMeasure/src/AngleMeasure.cpp	2017-01-06 16:52:05 +0000
+++ plugins/AngleMeasure/src/AngleMeasure.cpp	2017-01-12 21:08:38 +0000
@@ -34,7 +34,6 @@
 #include <QDebug>
 #include <QTimer>
 #include <QPixmap>
-#include <QtNetwork>
 #include <QSettings>
 #include <QKeyEvent>
 #include <QMouseEvent>
@@ -188,9 +187,8 @@
 	const StelProjectorP prj = core->getProjection(frameType, refractionMode);
 	StelPainter painter(prj);
 	painter.setFont(font);
+	painter.setBlending(true);
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
 	if (lineVisible.getInterstate() > 0.000001f)
 	{
 		Vec3d xy;
@@ -220,12 +218,7 @@
 			}
 		}
 
-		glDisable(GL_TEXTURE_2D);
-		// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH. But it looks much better.
-		#ifdef GL_LINE_SMOOTH
-		if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-			glEnable(GL_LINE_SMOOTH);
-		#endif
+		painter.setLineSmooth(true);
 
 		// main line is a great circle
 		painter.setColor(lineColor[0], lineColor[1], lineColor[2], lineVisible.getInterstate());
@@ -245,10 +238,8 @@
 			painter.drawGreatCircleArc(perp1StartPointHor, perp1EndPointHor, NULL);
 			painter.drawGreatCircleArc(perp2StartPointHor, perp2EndPointHor, NULL);
 		}
-		#ifdef GL_LINE_SMOOTH
-		if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-			glDisable(GL_LINE_SMOOTH);
-		#endif
+
+		painter.setLineSmooth(false);
 	}
 	if (messageFader.getInterstate() > 0.000001f)
 	{
@@ -262,7 +253,7 @@
 		y -= ls;
 		painter.drawText(x, y, messageRightButton);
 	}
-	glDisable(GL_BLEND);
+	painter.setBlending(false);
 }
 
 //! Draw any parts on the screen which are for our module

=== modified file 'plugins/AngleMeasure/src/CMakeLists.txt'
--- plugins/AngleMeasure/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/AngleMeasure/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -18,12 +18,9 @@
 SET(AngleMeasure_RES ../AngleMeasure.qrc)
 QT5_ADD_RESOURCES(AngleMeasure_RES_CXX ${AngleMeasure_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(AngleMeasure-static STATIC ${AngleMeasure_SRCS} ${AngleMeasure_RES_CXX} ${AngleMeasure_UIS_H})
-QT5_USE_MODULES(AngleMeasure-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(AngleMeasure-static Qt5::Core Qt5::Widgets)
 # The library target "AngleMeasure-static" has a default OUTPUT_NAME of "AngleMeasure-static", so change it.
 SET_TARGET_PROPERTIES(AngleMeasure-static PROPERTIES OUTPUT_NAME "AngleMeasure")
-TARGET_LINK_LIBRARIES(AngleMeasure-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(AngleMeasure-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins AngleMeasure-static)

=== modified file 'plugins/ArchaeoLines/src/ArchaeoLines.cpp'
--- plugins/ArchaeoLines/src/ArchaeoLines.cpp	2016-12-24 10:33:14 +0000
+++ plugins/ArchaeoLines/src/ArchaeoLines.cpp	2017-01-12 21:08:38 +0000
@@ -37,7 +37,6 @@
 #include <QTimer>
 #include <QPixmap>
 #include <QColor>
-#include <QtNetwork>
 #include <QSettings>
 #include <QMouseEvent>
 #include <cmath>
@@ -1223,9 +1222,7 @@
 
 	d->sPainter->drawText(screenPos[0], screenPos[1], text, angleDeg, xshift, 3);
 	//d->sPainter->setColor(tmpColor[0], tmpColor[1], tmpColor[2], tmpColor[3]); // RESTORE
-	glDisable(GL_TEXTURE_2D);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	d->sPainter->setBlending(true);
 }
 
 
@@ -1324,16 +1321,8 @@
 
 	// Initialize a painter and set OpenGL state
 	StelPainter sPainter(prj);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
-	glDisable(GL_TEXTURE_2D);
-
-	// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH
-	#ifdef GL_LINE_SMOOTH
-	if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-		glEnable(GL_LINE_SMOOTH);
-	#endif
-
+	sPainter.setBlending(true);
+	sPainter.setLineSmooth(true);
 	sPainter.setColor(color[0], color[1], color[2], intensity*fader.getInterstate());
 	//Vec4f textColor(color[0], color[1], color[2], intensity*fader.getInterstate());
 
@@ -1419,22 +1408,11 @@
 			sPainter.drawSmallCircleArc(pt1, pt2, rotCenter, alViewportEdgeIntersectCallback, &userData);
 			sPainter.drawSmallCircleArc(pt2, pt3, rotCenter, alViewportEdgeIntersectCallback, &userData);
 			sPainter.drawSmallCircleArc(pt3, pt1, rotCenter, alViewportEdgeIntersectCallback, &userData);
-			#ifdef GL_LINE_SMOOTH
-			if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-				glDisable(GL_LINE_SMOOTH);
-			#endif
-			glDisable(GL_BLEND);
-			return;
-		}
-		else
-		{
-			#ifdef GL_LINE_SMOOTH
-			if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-				glDisable(GL_LINE_SMOOTH);
-			#endif
-			glDisable(GL_BLEND);
-			return;
-		}
+		}
+
+		sPainter.setLineSmooth(false);
+		sPainter.setBlending(false);
+		return;
 	}
 	// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
 	Vec3d middlePoint = p1-rotCenter+p2-rotCenter;
@@ -1451,11 +1429,6 @@
 	sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter,alViewportEdgeIntersectCallback, &userData);
 	sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, alViewportEdgeIntersectCallback, &userData);
 
-	// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH
-	#ifdef GL_LINE_SMOOTH
-	if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-		glDisable(GL_LINE_SMOOTH);
-	#endif
-
-	glDisable(GL_BLEND);
+	sPainter.setLineSmooth(false);
+	sPainter.setBlending(false);
 }

=== modified file 'plugins/ArchaeoLines/src/CMakeLists.txt'
--- plugins/ArchaeoLines/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/ArchaeoLines/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -18,12 +18,9 @@
 SET(ArchaeoLines_RES ../ArchaeoLines.qrc)
 QT5_ADD_RESOURCES(ArchaeoLines_RES_CXX ${ArchaeoLines_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(ArchaeoLines-static STATIC ${ArchaeoLines_SRCS} ${ArchaeoLines_RES_CXX} ${ArchaeoLines_UIS_H})
-QT5_USE_MODULES(ArchaeoLines-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(ArchaeoLines-static Qt5::Core Qt5::Widgets)
 # The library target "ArchaeoLines-static" has a default OUTPUT_NAME of "ArchaeoLines-static", so change it.
 SET_TARGET_PROPERTIES(ArchaeoLines-static PROPERTIES OUTPUT_NAME "ArchaeoLines")
-TARGET_LINK_LIBRARIES(ArchaeoLines-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(ArchaeoLines-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins ArchaeoLines-static)

=== modified file 'plugins/ArchaeoLines/src/gui/ArchaeoLinesDialog.cpp'
--- plugins/ArchaeoLines/src/gui/ArchaeoLinesDialog.cpp	2017-01-05 15:28:52 +0000
+++ plugins/ArchaeoLines/src/gui/ArchaeoLinesDialog.cpp	2017-01-12 21:08:38 +0000
@@ -222,8 +222,8 @@
 	#ifndef Q_OS_WIN
 	ui->switchToWindowedModeLabel->hide();
 	#else
-	QString glRenderer(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
-	if (glRenderer.startsWith("ANGLE", Qt::CaseSensitive))
+	// don't call GL functions in GUI code please
+	if (StelMainView::getInstance().getGLInformation().renderer.startsWith("ANGLE", Qt::CaseSensitive))
 		ui->switchToWindowedModeLabel->hide();
 	#endif
 	setAboutHtml();

=== modified file 'plugins/CompassMarks/src/CMakeLists.txt'
--- plugins/CompassMarks/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/CompassMarks/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -8,12 +8,10 @@
 
 SET(CompassMarks_RES ../CompassMarks.qrc)
 QT5_ADD_RESOURCES(CompassMarks_RES_CXX ${CompassMarks_RES})
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
 
 ADD_LIBRARY(CompassMarks-static STATIC ${CompassMarks_SRCS} ${CompassMarks_RES_CXX})
-QT5_USE_MODULES(CompassMarks-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(CompassMarks-static Qt5::Core Qt5::Widgets)
 # The library target "CompassMarks-static" has a default OUTPUT_NAME of "CompassMarks-static", so change it.
 SET_TARGET_PROPERTIES(CompassMarks-static PROPERTIES OUTPUT_NAME "CompassMarks")
-TARGET_LINK_LIBRARIES(CompassMarks-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(CompassMarks-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins CompassMarks-static)

=== modified file 'plugins/CompassMarks/src/CompassMarks.cpp'
--- plugins/CompassMarks/src/CompassMarks.cpp	2015-10-28 13:39:43 +0000
+++ plugins/CompassMarks/src/CompassMarks.cpp	2017-01-12 21:08:38 +0000
@@ -35,7 +35,6 @@
 #include <QPixmap>
 #include <QSettings>
 #include <QKeyEvent>
-#include <QtNetwork>
 #include <cmath>
 
 StelModule* CompassMarksStelPluginInterface::getStelModule() const
@@ -129,14 +128,8 @@
 	painter.setFont(font);
 
 	painter.setColor(markColor[0], markColor[1], markColor[2], markFader.getInterstate());
-	glDisable(GL_TEXTURE_2D);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
-	// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH. But it looks much better.
-	#ifdef GL_LINE_SMOOTH
-	if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-		glEnable(GL_LINE_SMOOTH);
-	#endif
+	painter.setBlending(true);
+	painter.setLineSmooth(true);
 
 	for(int i=0; i<360; i++)
 	{
@@ -161,20 +154,11 @@
 		// Limit arcs to those that are visible for improved performance
 		if (prj->project(pos, screenPos) && 
 		     screenPos[0]>prj->getViewportPosX() && screenPos[0] < prj->getViewportPosX() + prj->getViewportWidth()) {
-			// This has been disabled above already...
-			//glDisable(GL_TEXTURE_2D);
 			painter.drawGreatCircleArc(pos, Vec3d(pos[0], pos[1], h), NULL);
-			//glEnable(GL_TEXTURE_2D);
 		}
 	}
-	// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH
-	#ifdef GL_LINE_SMOOTH
-	if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
-		glDisable(GL_LINE_SMOOTH);
-	#endif
-	glDisable(GL_BLEND);
-	glEnable(GL_TEXTURE_2D);
-
+	painter.setBlending(false);
+	painter.setLineSmooth(false);
 }
 
 void CompassMarks::update(double deltaTime)

=== modified file 'plugins/EquationOfTime/src/CMakeLists.txt'
--- plugins/EquationOfTime/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/EquationOfTime/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(EQUATIONOFTIME_RES ../resources/EquationOfTime.qrc)
 QT5_ADD_RESOURCES(EQUATIONOFTIME_RES_CXX ${EQUATIONOFTIME_RES})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(EquationOfTime-static STATIC ${EQUATIONOFTIME_SRCS} ${EQUATIONOFTIME_RES_CXX} ${EQUATIONOFTIME_UIS_H})
-QT5_USE_MODULES(EquationOfTime-static Core Network Gui Widgets)
+TARGET_LINK_LIBRARIES(EquationOfTime-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(EquationOfTime-static PROPERTIES OUTPUT_NAME "EquationOfTime")
-TARGET_LINK_LIBRARIES(EquationOfTime-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(EquationOfTime-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins EquationOfTime-static)

=== modified file 'plugins/Exoplanets/src/CMakeLists.txt'
--- plugins/Exoplanets/src/CMakeLists.txt	2016-01-30 17:47:43 +0000
+++ plugins/Exoplanets/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -24,11 +24,8 @@
 SET(Exoplanets_RES ../resources/Exoplanets.qrc)
 QT5_ADD_RESOURCES(Exoplanets_RES_CXX ${Exoplanets_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Exoplanets-static STATIC ${Exoplanets_SRCS} ${Exoplanets_RES_CXX} ${ExoplanetsDialog_UIS_H})
-QT5_USE_MODULES(Exoplanets-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(Exoplanets-static Qt5::Core Qt5::Network Qt5::Widgets qcustomplot_stel)
 SET_TARGET_PROPERTIES(Exoplanets-static PROPERTIES OUTPUT_NAME "Exoplanets")
-TARGET_LINK_LIBRARIES(Exoplanets-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Exoplanets-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Exoplanets-static)

=== modified file 'plugins/Exoplanets/src/Exoplanet.cpp'
--- plugins/Exoplanets/src/Exoplanet.cpp	2016-11-17 17:47:59 +0000
+++ plugins/Exoplanets/src/Exoplanet.cpp	2017-01-12 21:08:38 +0000
@@ -559,8 +559,7 @@
 	StelUtils::spheToRect(RA, DE, XYZ);
 	double mag = getVMagnitudeWithExtinction(core);
 
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_ONE, GL_ONE);
+	painter->setBlending(true, GL_ONE, GL_ONE);
 	painter->setColor(color[0], color[1], color[2], 1);
 
 	if (timelineMode)

=== modified file 'plugins/Exoplanets/src/Exoplanets.cpp'
--- plugins/Exoplanets/src/Exoplanets.cpp	2016-11-18 19:24:45 +0000
+++ plugins/Exoplanets/src/Exoplanets.cpp	2017-01-12 21:08:38 +0000
@@ -252,9 +252,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		painter.setColor(c[0],c[1],c[2]);
 		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 		painter.drawSprite2dMode(screenpos[0], screenpos[1], 13.f, StelApp::getInstance().getTotalRunTime()*40.);
 	}
 }

=== modified file 'plugins/Exoplanets/src/gui/ExoplanetsDialog.cpp'
--- plugins/Exoplanets/src/gui/ExoplanetsDialog.cpp	2017-01-05 15:28:52 +0000
+++ plugins/Exoplanets/src/gui/ExoplanetsDialog.cpp	2017-01-12 21:08:38 +0000
@@ -39,7 +39,7 @@
 #include "StelTranslator.hpp"
 #include "StelLocaleMgr.hpp"
 
-#include "qcustomplot/qcustomplot.h"
+#include "external/qcustomplot/qcustomplot.h"
 
 ExoplanetsDialog::ExoplanetsDialog()
 	: StelDialog("Exoplanets")

=== modified file 'plugins/Exoplanets/src/gui/exoplanetsDialog.ui'
--- plugins/Exoplanets/src/gui/exoplanetsDialog.ui	2016-11-29 13:26:25 +0000
+++ plugins/Exoplanets/src/gui/exoplanetsDialog.ui	2017-01-12 21:08:38 +0000
@@ -606,7 +606,7 @@
   <customwidget>
    <class>QCustomPlot</class>
    <extends>QWidget</extends>
-   <header>qcustomplot.h</header>
+   <header>external/qcustomplot/qcustomplot.h</header>
   </customwidget>
  </customwidgets>
  <resources/>

=== modified file 'plugins/FOV/src/CMakeLists.txt'
--- plugins/FOV/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/FOV/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -22,11 +22,8 @@
 
 QT5_WRAP_UI(FOV_UIS_H ${FOV_UIS})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(FOV-static STATIC ${FOV_SRCS} ${FOV_RES_CXX} ${FOV_UIS_H})
-QT5_USE_MODULES(FOV-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(FOV-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(FOV-static PROPERTIES OUTPUT_NAME "FOV")
-TARGET_LINK_LIBRARIES(FOV-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(FOV-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins FOV-static)

=== modified file 'plugins/HelloStelModule/src/CMakeLists.txt'
--- plugins/HelloStelModule/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/HelloStelModule/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -7,14 +7,10 @@
      HelloStelModule.cpp
 )
 
-
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(HelloStelModule-static STATIC ${HelloStelModule_SRCS})
 # The library target "HelloStelModule-static" has a default OUTPUT_NAME of "HelloStelModule-static", so change it.
-QT5_USE_MODULES(HelloStelModule-static Core Gui)
 SET_TARGET_PROPERTIES(HelloStelModule-static PROPERTIES OUTPUT_NAME "HelloStelModule")
-TARGET_LINK_LIBRARIES(HelloStelModule-static ${extLinkerOption})
+TARGET_LINK_LIBRARIES(HelloStelModule-static Qt5::Core Qt5::Gui)
 SET_TARGET_PROPERTIES(HelloStelModule-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins HelloStelModule-static)
 

=== modified file 'plugins/MeteorShowers/src/CMakeLists.txt'
--- plugins/MeteorShowers/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/MeteorShowers/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -33,11 +33,8 @@
 SET(MeteorShowers_RES ../resources/MeteorShower.qrc)
 QT5_ADD_RESOURCES(MeteorShowers_RES_CXX ${MeteorShowers_RES})
 
-SET(extLinkerOption ${QT_LIBRARIES} ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES} ${ICONV_LIBRARIES} ${INTL_LIBRARIES})
-
 ADD_LIBRARY(MeteorShowers-static STATIC ${MeteorShowers_SRCS} ${MeteorShowers_MOC_SRCS} ${MeteorShowers_RES_CXX} ${MeteorShowersDialog_UIS_H})
-QT5_USE_MODULES(MeteorShowers-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(MeteorShowers-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(MeteorShowers-static PROPERTIES OUTPUT_NAME "MeteorShowers")
-TARGET_LINK_LIBRARIES(MeteorShowers-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(MeteorShowers-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins MeteorShowers-static)

=== modified file 'plugins/MeteorShowers/src/MeteorShower.cpp'
--- plugins/MeteorShowers/src/MeteorShower.cpp	2017-01-07 17:36:45 +0000
+++ plugins/MeteorShowers/src/MeteorShower.cpp	2017-01-12 21:08:38 +0000
@@ -333,9 +333,7 @@
 	StelUtils::spheToRect(m_radiantAlpha, m_radiantDelta, m_position);
 	painter.getProjector()->project(m_position, XY);
 
-	glEnable(GL_TEXTURE_2D);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	painter.setBlending(true, GL_SRC_ALPHA, GL_ONE);
 
 	Vec3f rgb;
 	float alpha = 0.85f + ((float) qrand() / (float) RAND_MAX) / 10.f;

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.cpp'
--- plugins/MeteorShowers/src/MeteorShowers.cpp	2016-07-03 21:58:54 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.cpp	2017-01-12 21:08:38 +0000
@@ -81,9 +81,8 @@
 	const Vec3f& c(obj->getInfoColor());
 	painter.setColor(c[0],c[1],c[2]);
 	m_mgr->getPointerTexture()->bind();
-	painter.enableTexture2d(true);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+
+	painter.setBlending(true);
 
 	float size = obj->getAngularSize(core) * M_PI / 180. * painter.getProjector()->getPixelPerRadAtCenter();
 	size += 20.f + 10.f * qSin(2.f * StelApp::getInstance().getTotalRunTime());

=== modified file 'plugins/MeteorShowers/src/MeteorShowersMgr.hpp'
--- plugins/MeteorShowers/src/MeteorShowersMgr.hpp	2016-07-10 03:16:07 +0000
+++ plugins/MeteorShowers/src/MeteorShowersMgr.hpp	2017-01-12 21:08:38 +0000
@@ -325,7 +325,7 @@
 	QString m_url;
 	QDateTime m_lastUpdate;
 	DownloadStatus m_statusOfLastUpdate;
-	QNetworkAccessManager* m_downloadMgr;
+    QNetworkAccessManager* m_downloadMgr;
 	class StelProgressController* m_progressBar;
 
 	void createActions();

=== modified file 'plugins/NavStars/src/CMakeLists.txt'
--- plugins/NavStars/src/CMakeLists.txt	2016-05-21 14:14:31 +0000
+++ plugins/NavStars/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -23,11 +23,8 @@
 SET(NavStars_RES ../resources/NavStars.qrc)
 QT5_ADD_RESOURCES(NavStars_RES_CXX ${NavStars_RES})
 
-SET(extLinkerOption ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(NavStars-static STATIC ${NavStars_SRCS} ${NavStars_RES_CXX} ${NavStars_UIS_H})
-QT5_USE_MODULES(NavStars-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(NavStars-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(NavStars-static PROPERTIES OUTPUT_NAME "NavStars")
-TARGET_LINK_LIBRARIES(NavStars-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(NavStars-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins NavStars-static)

=== modified file 'plugins/NavStars/src/NavStars.cpp'
--- plugins/NavStars/src/NavStars.cpp	2016-08-01 12:55:49 +0000
+++ plugins/NavStars/src/NavStars.cpp	2017-01-12 21:08:38 +0000
@@ -182,9 +182,7 @@
 			// ... and draw a marker around it
 			if (!markerTexture.isNull())
 			{
-				glEnable(GL_BLEND);
-				painter.enableTexture2d(true);
-				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				painter.setBlending(true);
 				painter.setColor(markerColor[0], markerColor[1], markerColor[2], markerFader.getInterstate());
 				markerTexture->bind();
 				painter.drawSprite2dMode(pos[0], pos[1], 11.f);

=== modified file 'plugins/Novae/src/CMakeLists.txt'
--- plugins/Novae/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Novae/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(Novae_RES ../resources/Novae.qrc)
 QT5_ADD_RESOURCES(Novae_RES_CXX ${Novae_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Novae-static STATIC ${Novae_SRCS} ${Novae_RES_CXX} ${NovaeDialog_UIS_H})
-QT5_USE_MODULES(Novae-static Core Network OpenGL)
+TARGET_LINK_LIBRARIES(Novae-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(Novae-static PROPERTIES OUTPUT_NAME "Novae")
-TARGET_LINK_LIBRARIES(Novae-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Novae-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Novae-static)

=== modified file 'plugins/Novae/src/Novae.cpp'
--- plugins/Novae/src/Novae.cpp	2016-09-28 13:19:24 +0000
+++ plugins/Novae/src/Novae.cpp	2017-01-12 21:08:38 +0000
@@ -224,9 +224,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		painter.setColor(c[0],c[1],c[2]);
 		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 		painter.drawSprite2dMode(screenpos[0], screenpos[1], 13.f, StelApp::getInstance().getTotalRunTime()*40.);
 	}
 }

=== modified file 'plugins/Observability/src/CMakeLists.txt'
--- plugins/Observability/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Observability/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(Observability_RES ../Observability.qrc)
 QT5_ADD_RESOURCES(Observability_RES_CXX ${Observability_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Observability-static STATIC ${Observability_SRCS} ${Observability_RES_CXX} ${ObservabilityDialog_UIS_H})
-QT5_USE_MODULES(Observability-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(Observability-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(Observability-static PROPERTIES OUTPUT_NAME "Observability")
-TARGET_LINK_LIBRARIES(Observability-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Observability-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Observability-static)

=== modified file 'plugins/Oculars/src/CMakeLists.txt'
--- plugins/Oculars/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Oculars/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -34,12 +34,8 @@
 )
 QT5_WRAP_UI(Oculars_UIS_H ${Oculars_UIS})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Oculars-static STATIC ${Oculars_SRCS} ${Oculars_RES_CXX} ${Oculars_UIS_H})
 SET_TARGET_PROPERTIES(Oculars-static PROPERTIES OUTPUT_NAME "Oculars")
-QT5_USE_MODULES(Oculars-static Core Network OpenGL Widgets)
-
-TARGET_LINK_LIBRARIES(Oculars-static ${StelMain} ${extLinkerOption})
+TARGET_LINK_LIBRARIES(Oculars-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(Oculars-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Oculars-static)

=== modified file 'plugins/Oculars/src/Oculars.cpp'
--- plugins/Oculars/src/Oculars.cpp	2017-01-10 17:21:30 +0000
+++ plugins/Oculars/src/Oculars.cpp	2017-01-12 21:08:38 +0000
@@ -50,7 +50,6 @@
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMouseEvent>
-#include <QtNetwork>
 #include <QPixmap>
 #include <QSignalMapper>
 
@@ -335,14 +334,7 @@
 					paintCrosshairs();
 				}
 			}
-			if (guiPanelEnabled)
-			{
-				// Reset the state to allow the panel to be painted normally
-				glDisable(GL_TEXTURE_2D);
-				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-				glEnable(GL_BLEND);
-			}
-			else
+			if (!guiPanelEnabled)
 			{
 				// Paint the information in the upper-right hand corner
 				paintText(core);
@@ -352,14 +344,7 @@
 	else if (flagShowCCD)
 	{
 		paintCCDBounds();
-		if (guiPanelEnabled)
-		{
-			// Reset the state to allow the panel to be painted normally
-			glDisable(GL_TEXTURE_2D);
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-			glEnable(GL_BLEND);
-		}
-		else
+		if (!guiPanelEnabled)
 		{
 			// Paint the information in the upper-right hand corner
 			paintText(core);
@@ -1768,15 +1753,13 @@
 		inner = oculars[selectedOcularIndex]->appearentFOV() * inner / maxEyepieceAngle;
 	}
 
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+	painter.setBlending(true);
 
 	Vec2i centerScreen(prj->getViewportPosX()+prj->getViewportWidth()/2, prj->getViewportPosY()+prj->getViewportHeight()/2);
 
 	// Paint the reticale, if needed
 	if (!reticleTexture.isNull())
 	{
-		painter.enableTexture2d(true);
 		painter.setColor(0.77f, 0.14f, 0.16f, 1.f);
 
 		reticleTexture->bind();
@@ -1869,9 +1852,7 @@
 
 	// set up the color and the GL state
 	painter.setColor(0.8f, 0.48f, 0.f, 1.f);
-	glDisable(GL_TEXTURE_2D);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
+	painter.setBlending(true);
 
 	// Get the X & Y positions, and the line height
 	painter.setFont(font);

=== modified file 'plugins/PointerCoordinates/src/CMakeLists.txt'
--- plugins/PointerCoordinates/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/PointerCoordinates/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(POINTERCOORDINATES_RES ../resources/PointerCoordinates.qrc)
 QT5_ADD_RESOURCES(POINTERCOORDINATES_RES_CXX ${POINTERCOORDINATES_RES})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(PointerCoordinates-static STATIC ${POINTERCOORDINATES_SRCS} ${POINTERCOORDINATES_RES_CXX} ${POINTERCOORDINATES_UIS_H})
-QT5_USE_MODULES(PointerCoordinates-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(PointerCoordinates-static Qt5::Core Qt5::Widgets)
 SET_TARGET_PROPERTIES(PointerCoordinates-static PROPERTIES OUTPUT_NAME "PointerCoordinates")
-TARGET_LINK_LIBRARIES(PointerCoordinates-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(PointerCoordinates-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins PointerCoordinates-static)

=== modified file 'plugins/Pulsars/src/CMakeLists.txt'
--- plugins/Pulsars/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Pulsars/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(Pulsars_RES ../resources/Pulsars.qrc)
 QT5_ADD_RESOURCES(Pulsars_RES_CXX ${Pulsars_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Pulsars-static STATIC ${Pulsars_SRCS} ${Pulsars_RES_CXX} ${PulsarsDialog_UIS_H})
-QT5_USE_MODULES(Pulsars-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(Pulsars-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(Pulsars-static PROPERTIES OUTPUT_NAME "Pulsars")
-TARGET_LINK_LIBRARIES(Pulsars-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Pulsars-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Pulsars-static)

=== modified file 'plugins/Pulsars/src/Pulsar.cpp'
--- plugins/Pulsars/src/Pulsar.cpp	2016-07-30 18:20:22 +0000
+++ plugins/Pulsars/src/Pulsar.cpp	2017-01-12 21:08:38 +0000
@@ -384,8 +384,8 @@
 	if (!(painter->getProjector()->projectCheck(XYZ, win)))
 		return;
 
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_ONE, GL_ONE);
+	painter->setBlending(true, GL_ONE, GL_ONE);
+
 	if (glitch>0 && glitchFlag)
 		painter->setColor(glitchColor[0], glitchColor[1], glitchColor[2], 1.f);
 	else

=== modified file 'plugins/Pulsars/src/Pulsars.cpp'
--- plugins/Pulsars/src/Pulsars.cpp	2016-07-03 21:58:54 +0000
+++ plugins/Pulsars/src/Pulsars.cpp	2017-01-12 21:08:38 +0000
@@ -259,9 +259,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		painter.setColor(c[0],c[1],c[2]);
 		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 		painter.drawSprite2dMode(screenpos[0], screenpos[1], 13.f, StelApp::getInstance().getTotalRunTime()*40.);
 	}
 }

=== modified file 'plugins/Quasars/src/CMakeLists.txt'
--- plugins/Quasars/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Quasars/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(Quasars_RES ../resources/Quasars.qrc)
 QT5_ADD_RESOURCES(Quasars_RES_CXX ${Quasars_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Quasars-static STATIC ${Quasars_SRCS} ${Quasars_RES_CXX} ${QuasarsDialog_UIS_H})
-QT5_USE_MODULES(Quasars-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(Quasars-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(Quasars-static PROPERTIES OUTPUT_NAME "Quasars")
-TARGET_LINK_LIBRARIES(Quasars-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Quasars-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Quasars-static)

=== modified file 'plugins/Quasars/src/Quasar.cpp'
--- plugins/Quasars/src/Quasar.cpp	2016-07-30 18:20:22 +0000
+++ plugins/Quasars/src/Quasar.cpp	2017-01-12 21:08:38 +0000
@@ -180,8 +180,7 @@
 
 	if (distributionMode)
 	{
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_ONE, GL_ONE);
+		painter.setBlending(true, GL_ONE, GL_ONE);
 		painter.setColor(markerColor[0], markerColor[1], markerColor[2], 1);
 
 		Quasar::markerTexture->bind();

=== modified file 'plugins/Quasars/src/Quasars.cpp'
--- plugins/Quasars/src/Quasars.cpp	2016-07-22 09:25:03 +0000
+++ plugins/Quasars/src/Quasars.cpp	2017-01-12 21:08:38 +0000
@@ -261,9 +261,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		painter.setColor(c[0],c[1],c[2]);
 		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 		painter.drawSprite2dMode(screenpos[0], screenpos[1], 13.f, StelApp::getInstance().getTotalRunTime()*40.);
 	}
 }

=== modified file 'plugins/RemoteControl/src/CMakeLists.txt'
--- plugins/RemoteControl/src/CMakeLists.txt	2016-01-18 16:55:10 +0000
+++ plugins/RemoteControl/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -67,12 +67,9 @@
 SET(RemoteControl_RES ../RemoteControl.qrc)
 QT5_ADD_RESOURCES(RemoteControl_RES_CXX ${RemoteControl_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(RemoteControl-static STATIC ${RemoteControl_SRCS} ${RemoteControl_RES_CXX} ${RemoteControl_UIS_H} ${QtWebApp_SRCS})
-QT5_USE_MODULES(RemoteControl-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(RemoteControl-static Qt5::Core Qt5::Network Qt5::Widgets)
 # The library target "RemoteControl-static" has a default OUTPUT_NAME of "RemoteControl-static", so change it.
 SET_TARGET_PROPERTIES(RemoteControl-static PROPERTIES OUTPUT_NAME "RemoteControl")
-TARGET_LINK_LIBRARIES(RemoteControl-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(RemoteControl-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins RemoteControl-static)

=== modified file 'plugins/RemoteControl/src/MainService.cpp'
--- plugins/RemoteControl/src/MainService.cpp	2017-01-11 14:13:45 +0000
+++ plugins/RemoteControl/src/MainService.cpp	2017-01-12 21:08:38 +0000
@@ -35,6 +35,8 @@
 #include "StelUtils.hpp"
 
 #include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
 
 
 MainService::MainService(const QByteArray &serviceName, QObject *parent)

=== modified file 'plugins/RemoteControl/src/ScriptService.cpp'
--- plugins/RemoteControl/src/ScriptService.cpp	2016-05-10 19:03:51 +0000
+++ plugins/RemoteControl/src/ScriptService.cpp	2017-01-12 21:08:38 +0000
@@ -24,6 +24,9 @@
 #include "StelTranslator.hpp"
 
 #include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QVariant>
 
 ScriptService::ScriptService(const QByteArray &serviceName, QObject *parent) : AbstractAPIService(serviceName,parent)
 {

=== modified file 'plugins/RemoteSync/src/CMakeLists.txt'
--- plugins/RemoteSync/src/CMakeLists.txt	2016-02-05 14:05:45 +0000
+++ plugins/RemoteSync/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -32,12 +32,9 @@
 SET(RemoteSync_RES ../RemoteSync.qrc)
 QT5_ADD_RESOURCES(RemoteSync_RES_CXX ${RemoteSync_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(RemoteSync-static STATIC ${RemoteSync_SRCS} ${RemoteSync_UIS_H} ${RemoteSync_RES_CXX})
-QT5_USE_MODULES(RemoteSync-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(RemoteSync-static Qt5::Core Qt5::Network Qt5::Widgets)
 # The library target "RemoteSync-static" has a default OUTPUT_NAME of "RemoteSync-static", so change it.
 SET_TARGET_PROPERTIES(RemoteSync-static PROPERTIES OUTPUT_NAME "RemoteSync")
-TARGET_LINK_LIBRARIES(RemoteSync-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(RemoteSync-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins RemoteSync-static)

=== modified file 'plugins/Satellites/src/CMakeLists.txt'
--- plugins/Satellites/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Satellites/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -53,23 +53,13 @@
 SET(Satellites_RES ../resources/Satellites.qrc)
 QT5_ADD_RESOURCES(Satellites_RES_CXX ${Satellites_RES})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Satellites-static STATIC ${Satellites_SRCS} ${Satellites_RES_CXX} ${SatellitesDialog_UIS_H})
-QT5_USE_MODULES(Satellites-static Core Network OpenGL)
+TARGET_LINK_LIBRARIES(Satellites-static Qt5::Core Qt5::Network Qt5::Widgets)
 # The library target "Satellites-static" has a default OUTPUT_NAME of "Satellites-static", so change it.
 SET_TARGET_PROPERTIES(Satellites-static PROPERTIES OUTPUT_NAME "Satellites")
-TARGET_LINK_LIBRARIES(Satellites-static ${StelMain} ${extLinkerOption})
 IF(MSVC)
      SET_TARGET_PROPERTIES(Satellites-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ELSE()
      SET_TARGET_PROPERTIES(Satellites-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN -Wno-unused-parameter")
 ENDIF()
 ADD_DEPENDENCIES(AllStaticPlugins Satellites-static)
-
-
-
-
-
-
-

=== modified file 'plugins/Satellites/src/Satellite.cpp'
--- plugins/Satellites/src/Satellite.cpp	2017-01-05 17:00:35 +0000
+++ plugins/Satellites/src/Satellite.cpp	2017-01-12 21:08:38 +0000
@@ -834,8 +834,7 @@
 			if (Satellite::showLabels)
 				painter.drawText(xy[0], xy[1], name, 0, 10, 10, false);
 
-			glEnable(GL_BLEND);
-			glBlendFunc(GL_ONE, GL_ONE);
+			painter.setBlending(true, GL_ONE, GL_ONE);
 
 			Satellite::hintTexture->bind();
 			painter.drawSprite2dMode(xy[0], xy[1], 11);			
@@ -851,8 +850,6 @@
 	Vec3f drawColor;
 	int size = orbitPoints.size();
 
-	glDisable(GL_TEXTURE_2D);
-
 	QList<Vec3d>::iterator it= orbitPoints.begin();
 	it++;
 
@@ -881,8 +878,6 @@
 		}
 	}
 	painter.drawPath(vertexArray, colorArray);
-
-	glEnable(GL_TEXTURE_2D);
 	painter.enableClientStates(false);
 }
 

=== modified file 'plugins/Satellites/src/Satellites.cpp'
--- plugins/Satellites/src/Satellites.cpp	2017-01-05 17:00:35 +0000
+++ plugins/Satellites/src/Satellites.cpp	2017-01-12 21:08:38 +0000
@@ -1607,9 +1607,7 @@
 	painter.setFont(labelFont);
 	Satellite::hintBrightness = hintFader.getInterstate();
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
-	glEnable(GL_TEXTURE_2D);
+	painter.setBlending(true);
 	Satellite::hintTexture->bind();
 	Satellite::viewportHalfspace = painter.getProjector()->getBoundingCap();
 	foreach (const SatelliteP& sat, satellites)
@@ -1639,9 +1637,7 @@
 		painter.setColor(0.4f,0.5f,0.8f);
 		texPointer->bind();
 
-		glEnable(GL_TEXTURE_2D);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 
 		// Size on screen
 		float size = obj->getAngularSize(core)*M_PI/180.*prj->getPixelPerRadAtCenter();

=== modified file 'plugins/Scenery3d/src/CMakeLists.txt'
--- plugins/Scenery3d/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Scenery3d/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -60,14 +60,9 @@
 )
 QT5_WRAP_UI(Scenery3d_UIS_H ${Scenery3d_UIS})
 
-SET(extLinkerOption  ${QT_LIBRARIES} ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES}  )
-
 ############### For building the static library ######################
 ADD_LIBRARY(Scenery3d-static STATIC ${Scenery3d_SRCS} ${Scenery3d_RES_CXX} ${Scenery3d_UIS_H} ${Scenery3d_MOC_SRCS} )
-QT5_USE_MODULES(Scenery3d-static Core Concurrent Gui Widgets)
+TARGET_LINK_LIBRARIES(Scenery3d-static Qt5::Core Qt5::Concurrent Qt5::Gui ${STEL_GLES_LIBS} Qt5::Widgets)
 SET_TARGET_PROPERTIES(Scenery3d-static PROPERTIES OUTPUT_NAME "Scenery3d")
-TARGET_LINK_LIBRARIES(Scenery3d-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Scenery3d-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Scenery3d-static)
-
-

=== modified file 'plugins/Scenery3d/src/OBJ.cpp'
--- plugins/Scenery3d/src/OBJ.cpp	2016-11-21 21:04:36 +0000
+++ plugins/Scenery3d/src/OBJ.cpp	2017-01-12 21:08:38 +0000
@@ -100,12 +100,16 @@
 bool OBJ::vertexArraysSupported=false;
 GLenum OBJ::indexBufferType=GL_UNSIGNED_SHORT;
 size_t OBJ::indexBufferTypeSize=0;
+QOpenGLFunctions* OBJ::gl=Q_NULLPTR;
 
 //static function
 void OBJ::setupGL()
 {
+	QOpenGLContext* ctx = QOpenGLContext::currentContext();
+	gl = ctx->functions();
+
 	//disable VAOs on Intel because of serious bugs in their implemenation...
-	QString vendor(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
+	QString vendor(reinterpret_cast<const char*>(gl->glGetString(GL_VENDOR)));
 	if(vendor.contains("Intel",Qt::CaseInsensitive))
 	{
 		OBJ::vertexArraysSupported = false;
@@ -130,7 +134,6 @@
 	}
 
 	//check if we can enable int index buffers
-	QOpenGLContext* ctx = QOpenGLContext::currentContext();
 	if(ctx->isOpenGLES())
 	{
 		//query for extension
@@ -1709,19 +1712,19 @@
 	//(but may be stored in a VAO to enable faster binding/unbinding)
 
 	//enable the attrib arrays
-	glEnableVertexAttribArray(ShaderMgr::ATTLOC_VERTEX);
-	glEnableVertexAttribArray(ShaderMgr::ATTLOC_NORMAL);
-	glEnableVertexAttribArray(ShaderMgr::ATTLOC_TEXCOORD);
-	glEnableVertexAttribArray(ShaderMgr::ATTLOC_TANGENT);
-	glEnableVertexAttribArray(ShaderMgr::ATTLOC_BITANGENT);
+	gl->glEnableVertexAttribArray(ShaderMgr::ATTLOC_VERTEX);
+	gl->glEnableVertexAttribArray(ShaderMgr::ATTLOC_NORMAL);
+	gl->glEnableVertexAttribArray(ShaderMgr::ATTLOC_TEXCOORD);
+	gl->glEnableVertexAttribArray(ShaderMgr::ATTLOC_TANGENT);
+	gl->glEnableVertexAttribArray(ShaderMgr::ATTLOC_BITANGENT);
 
 	const GLsizei stride = sizeof(Vertex);
 
-	glVertexAttribPointer(ShaderMgr::ATTLOC_VERTEX,   3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, position)));
-	glVertexAttribPointer(ShaderMgr::ATTLOC_NORMAL,   3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, normal)));
-	glVertexAttribPointer(ShaderMgr::ATTLOC_TEXCOORD, 2,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, texCoord)));
-	glVertexAttribPointer(ShaderMgr::ATTLOC_TANGENT,  4,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, tangent)));
-	glVertexAttribPointer(ShaderMgr::ATTLOC_BITANGENT,3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, bitangent)));
+	gl->glVertexAttribPointer(ShaderMgr::ATTLOC_VERTEX,   3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, position)));
+	gl->glVertexAttribPointer(ShaderMgr::ATTLOC_NORMAL,   3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, normal)));
+	gl->glVertexAttribPointer(ShaderMgr::ATTLOC_TEXCOORD, 2,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, texCoord)));
+	gl->glVertexAttribPointer(ShaderMgr::ATTLOC_TANGENT,  4,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, tangent)));
+	gl->glVertexAttribPointer(ShaderMgr::ATTLOC_BITANGENT,3,GL_FLOAT,GL_FALSE,stride,reinterpret_cast<const void *>(offsetof(struct Vertex, bitangent)));
 
 	//vertex buffer does not need to remain bound, because the binding is stored by glVertexAttribPointer
 	m_vertexBuffer.release();
@@ -1736,11 +1739,11 @@
 	m_indexBuffer.release();
 
 	//disable our attribute arrays
-	glDisableVertexAttribArray(ShaderMgr::ATTLOC_VERTEX);
-	glDisableVertexAttribArray(ShaderMgr::ATTLOC_NORMAL);
-	glDisableVertexAttribArray(ShaderMgr::ATTLOC_TEXCOORD);
-	glDisableVertexAttribArray(ShaderMgr::ATTLOC_TANGENT);
-	glDisableVertexAttribArray(ShaderMgr::ATTLOC_BITANGENT);
+	gl->glDisableVertexAttribArray(ShaderMgr::ATTLOC_VERTEX);
+	gl->glDisableVertexAttribArray(ShaderMgr::ATTLOC_NORMAL);
+	gl->glDisableVertexAttribArray(ShaderMgr::ATTLOC_TEXCOORD);
+	gl->glDisableVertexAttribArray(ShaderMgr::ATTLOC_TANGENT);
+	gl->glDisableVertexAttribArray(ShaderMgr::ATTLOC_BITANGENT);
 }
 
 void OBJ::transform(QMatrix4x4 mat)

=== modified file 'plugins/Scenery3d/src/OBJ.hpp'
--- plugins/Scenery3d/src/OBJ.hpp	2015-04-15 13:42:29 +0000
+++ plugins/Scenery3d/src/OBJ.hpp	2017-01-12 21:08:38 +0000
@@ -336,6 +336,8 @@
 	QOpenGLBuffer m_indexBuffer;
 	QOpenGLVertexArrayObject* m_vertexArrayObject;
 
+	static QOpenGLFunctions* gl;
+
 	//! Heightmap
 	friend class Heightmap;
 };

=== modified file 'plugins/Scenery3d/src/Scenery3d.cpp'
--- plugins/Scenery3d/src/Scenery3d.cpp	2016-11-24 18:15:41 +0000
+++ plugins/Scenery3d/src/Scenery3d.cpp	2017-01-12 21:08:38 +0000
@@ -20,13 +20,7 @@
 
 #include <QtGlobal>
 
-#if !defined(Q_OS_WIN)
-//exclude StelOpenGL here on windows because of conflicts with GLFuncs.hpp otherwise (uses QOpenGLFunctions_1_0 directly)
-#include "StelOpenGL.hpp"
-#endif
-//needs to be included before StelOpenGL on Windows
 #include "GLFuncs.hpp"
-
 #include "Scenery3d.hpp"
 
 #include "StelApp.hpp"
@@ -49,15 +43,8 @@
 #include <stdexcept>
 #include <cmath>
 #include <QOpenGLShaderProgram>
-#include <QOpenGLFramebufferObject>
 
-#define GET_GLERROR()                                   \
-{                                                       \
-    GLenum err = glGetError();                          \
-    if (err != GL_NO_ERROR) {                           \
-    qWarning("[line %d] GL Error: %d",__LINE__, err);   \
-    }                                                   \
-}
+#define GET_GLERROR() StelOpenGL::checkGLErrors(__FILE__,__LINE__);
 
 //macro for easier uniform setting
 #define SET_UNIFORM(shd,uni,val) shd->setUniformValue(shaderManager.uniformLocation(shd,uni),val)
@@ -112,6 +99,7 @@
 	shaderParameters.geometryShader = false;
 	shaderParameters.torchLight = false;
 	shaderParameters.frustumSplits = 0;
+	shaderParameters.hwShadowSamplers = false;
 
 	sceneBoundingBox = AABB(Vec3f(0.0f), Vec3f(0.0f));
 
@@ -253,6 +241,10 @@
 
 void Scenery3d::finalizeLoad()
 {
+	//must ensure the correct GL context is active!
+	//this is not guaranteed with the new QOpenGLWidget outside of init() and draw()!
+	StelApp::getInstance().ensureGLContextCurrent();
+
 	currentScene = loadingScene;
 
 	//move load data to current one
@@ -594,7 +586,7 @@
 		{
 			//send size of light ortho for each frustum
 			loc = shaderManager.uniformLocation(shader,ShaderMgr::UNIFORM_VEC_LIGHTORTHOSCALE);
-			shader->setUniformValueArray(loc,shadowFrustumSize.constData(),4);
+			shader->setUniformValueArray(loc,shadowFrustumSize.constData(),shaderParameters.frustumSplits);
 		}
 	}
 
@@ -802,7 +794,7 @@
 			}
 		}
 
-
+		GET_GLERROR()
 		glDrawElements(GL_TRIANGLES, pStelModel->triangleCount * 3, indexDataType, reinterpret_cast<const void*>(pStelModel->startIndex * indexDataTypeSize));
 		drawnTriangles+=pStelModel->triangleCount;
 	}
@@ -1130,7 +1122,7 @@
 
 
 	//Unbind
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
 
 	//reset viewport (see StelPainter::setProjector)
 	const Vec4i& vp = altAzProjector->getViewport();
@@ -1576,7 +1568,7 @@
 	}
 
 	//cubemap fbo must be released
-	glBindFramebuffer(GL_FRAMEBUFFER,0);
+	glBindFramebuffer(GL_FRAMEBUFFER,defaultFBO);
 
 	//reset GL state
 	glDepthMask(GL_FALSE);
@@ -2052,9 +2044,11 @@
 
 void Scenery3d::init()
 {
+	initializeOpenGLFunctions();
 	OBJ::setupGL();
 
 	QOpenGLContext* ctx = QOpenGLContext::currentContext();
+	Q_ASSERT(ctx);
 
 #ifndef QT_OPENGL_ES_2
 	//initialize additional functions needed and not provided through StelOpenGL
@@ -2369,7 +2363,7 @@
 	}
 
 	//unbind last framebuffer
-	glBindFramebuffer(GL_FRAMEBUFFER,0);
+	glBindFramebuffer(GL_FRAMEBUFFER,defaultFBO);
 
 	//initialize cube rotations... found by trial and error :)
 	QMatrix4x4 stackBase;
@@ -2633,7 +2627,23 @@
 			//for OpenGL ES2, type has to be UNSIGNED_SHORT or UNSIGNED_INT for depth textures, desktop does probably not care
 			glTexImage2D(GL_TEXTURE_2D, 0, (pcssEnabled ? depthPcss : depthNormal), shadowmapSize, shadowmapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, NULL);
 
-			GLint filter = (shaderParameters.shadowFilterQuality == S3DEnum::SFQ_HARDWARE
+			//we use hardware-accelerated depth compare mode, unless pcss is used
+			shaderParameters.hwShadowSamplers = false;
+			//NOTE: cant use depth compare mode on ES2
+			if(!pcssEnabled)
+			{
+#ifndef QT_OPENGL_ES_2
+				if(!isEs)
+				{
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
+					shaderParameters.hwShadowSamplers = true;
+				}
+#endif
+			}
+
+			//IF we support hw shadow sampling, then we may enable linear filtering, otherwise filtering depth values directly would not make much sense
+			GLint filter = shaderParameters.hwShadowSamplers && (shaderParameters.shadowFilterQuality == S3DEnum::SFQ_HARDWARE
 					|| shaderParameters.shadowFilterQuality == S3DEnum::SFQ_LOW_HARDWARE
 					|| shaderParameters.shadowFilterQuality == S3DEnum::SFQ_HIGH_HARDWARE) ? GL_LINEAR : GL_NEAREST;
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
@@ -2649,18 +2659,6 @@
 				glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, ones);
 			}
 #endif
-			//we use hardware-accelerated depth compare mode, unless pcss is used
-			//NOTE: cant use depth compare mode on ES2
-			if(!pcssEnabled)
-			{
-#ifndef QT_OPENGL_ES_2
-				if(!isEs)
-				{
-					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
-					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
-				}
-#endif
-			}
 
 			//Attach the depthmap to the Buffer
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowMapsArray[i], 0);
@@ -2689,7 +2687,7 @@
 		}
 
 		//Done. Unbind and switch to normal texture unit 0
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
 		glActiveTexture(GL_TEXTURE0);
 
 		qDebug()<<"[Scenery3D] shadowmapping initialized";
@@ -2713,6 +2711,9 @@
 	if(!objModel || !objModel->hasStelModels())
 		return;
 
+	//find out the default FBO
+	defaultFBO = StelApp::getInstance().getDefaultFBO();
+
 	//reset render statistic
 	drawnTriangles = drawnModels = materialSwitches = shaderSwitches = 0;
 

=== modified file 'plugins/Scenery3d/src/Scenery3d.hpp'
--- plugins/Scenery3d/src/Scenery3d.hpp	2016-11-24 18:15:41 +0000
+++ plugins/Scenery3d/src/Scenery3d.hpp	2017-01-12 21:08:38 +0000
@@ -38,12 +38,11 @@
 #include <QMatrix4x4>
 
 //predeclarations
-class QOpenGLFramebufferObject;
 class Scenery3dMgr;
 class LandscapeMgr;
 
 //! Representation of a complete 3D scenery
-class Scenery3d
+class Scenery3d : protected QOpenGLFunctions
 {
 public:
 	//! Initializes an empty Scenery3d object.
@@ -178,6 +177,7 @@
 	bool supportsShadowFiltering; //if shadow filtering is supported
 	bool isANGLE; //true if running on ANGLE
 	unsigned int maximumFramebufferSize;
+	GLuint defaultFBO; //the default background FBO handle
 
 	float torchBrightness; // toggle light brightness
 	float torchRange; // used to calculate attenuation like in the second form at http://framebunker.com/blog/lighting-2-attenuation/

=== modified file 'plugins/Scenery3d/src/ShaderManager.cpp'
--- plugins/Scenery3d/src/ShaderManager.cpp	2015-05-18 12:01:39 +0000
+++ plugins/Scenery3d/src/ShaderManager.cpp	2017-01-12 21:08:38 +0000
@@ -102,6 +102,7 @@
 		featureFlagsStrings["PCSS"] = PCSS;
 		featureFlagsStrings["SINGLE_SHADOW_FRUSTUM"] = SINGLE_SHADOW_FRUSTUM;
 		featureFlagsStrings["OGL_ES2"] = OGL_ES2;
+		featureFlagsStrings["HW_SHADOW_SAMPLERS"] = HW_SHADOW_SAMPLERS;
 	}
 }
 
@@ -437,8 +438,10 @@
 	//this enumerates all available uniforms of this shader, and stores their locations in a map
 	GLuint prog = program.programId();
 	GLint numUniforms=0,bufSize;
-	glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms);
-	glGetProgramiv(prog, GL_ACTIVE_UNIFORM_MAX_LENGTH, &bufSize);
+
+	QOpenGLFunctions* gl = QOpenGLContext::currentContext()->functions();
+	GL(gl->glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms));
+	GL(gl->glGetProgramiv(prog, GL_ACTIVE_UNIFORM_MAX_LENGTH, &bufSize));
 
 	QByteArray buf(bufSize,'\0');
 	GLsizei length;
@@ -450,7 +453,7 @@
 #endif
 	for(int i =0;i<numUniforms;++i)
 	{
-		glGetActiveUniform(prog,i,bufSize,&length,&size,&type,buf.data());
+		GL(gl->glGetActiveUniform(prog,i,bufSize,&length,&size,&type,buf.data()));
 		QString str(buf);
 		str = str.trimmed(); // no idea if this is required
 

=== modified file 'plugins/Scenery3d/src/ShaderManager.hpp'
--- plugins/Scenery3d/src/ShaderManager.hpp	2015-05-18 12:01:39 +0000
+++ plugins/Scenery3d/src/ShaderManager.hpp	2017-01-12 21:08:38 +0000
@@ -42,6 +42,7 @@
 	bool torchLight;
 	//for now, only 1 or 4 really supported
 	int frustumSplits;
+	bool hwShadowSamplers;
 };
 
 //! A simple shader cache class that gives us the correct shader depending on desired configuration.
@@ -199,6 +200,8 @@
 		SINGLE_SHADOW_FRUSTUM  = (1<<18),
 		//set if opengl es2
 		OGL_ES2		= (1<<19),
+		//true if shadow samplers (shadow2d) should be used for shadow maps instead of normal samplers (texture2d)
+		HW_SHADOW_SAMPLERS = (1<<20)
 	};
 
 	typedef QMap<QString,FeatureFlags> t_FeatureFlagStrings;
@@ -238,7 +241,8 @@
 		if(globals.pixelLighting && globals.shadows) flags|= SHADOWS;
 		if(globals.pixelLighting && globals.shadows && globals.shadowFilterQuality>S3DEnum::SFQ_HARDWARE) flags|= SHADOW_FILTER;
 		if(globals.pixelLighting && globals.shadows && globals.shadowFilterQuality>S3DEnum::SFQ_LOW_HARDWARE) flags|= SHADOW_FILTER_HQ;
-		if(globals.pixelLighting && globals.shadows && (globals.shadowFilterQuality == S3DEnum::SFQ_LOW || globals.shadowFilterQuality == S3DEnum::SFQ_HIGH) && globals.pcss) flags|= PCSS;
+		if(globals.pixelLighting && globals.shadows && !globals.hwShadowSamplers && (globals.shadowFilterQuality == S3DEnum::SFQ_LOW || globals.shadowFilterQuality == S3DEnum::SFQ_HIGH) && globals.pcss) flags|= PCSS;
+		if(globals.hwShadowSamplers) flags|=HW_SHADOW_SAMPLERS;
 		if(globals.geometryShader) flags|= GEOMETRY_SHADER;
 		if(globals.torchLight) flags|= TORCH;
 		if(globals.frustumSplits == 1) flags|= SINGLE_SHADOW_FRUSTUM;

=== modified file 'plugins/SimpleDrawLine/src/CMakeLists.txt'
--- plugins/SimpleDrawLine/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/SimpleDrawLine/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -7,12 +7,11 @@
      SimpleDrawLine.cpp
 )
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
+SET(SimpleDrawLine_Qt_Libraries Qt5::Core Qt5::Gui)
 
 ############### For building the dynamic library ######################
 IF(BUILD_DYNAMIC_PLUGIN)
      ADD_LIBRARY(SimpleDrawLine MODULE ${SimpleDrawLine_SRCS})
-     QT5_USE_MODULES(SimpleDrawLine-static Core OpenGL)
      IF(APPLE)
           FIND_LIBRARY(OPENGL_LIBRARY OpenGL)
           MARK_AS_ADVANCED(OPENGL_LIBRARY)
@@ -26,15 +25,14 @@
           SET(StelMain )
      ENDIF(WIN32)
 
-     TARGET_LINK_LIBRARIES(SimpleDrawLine ${StelMain} ${extLinkerOption})
+     TARGET_LINK_LIBRARIES(SimpleDrawLine ${StelMain} ${SimpleDrawLine_Qt_Libraries})
      INSTALL(TARGETS SimpleDrawLine DESTINATION "modules/SimpleDrawLine")
 ELSE()
 ############### For building the static library ######################
      ADD_LIBRARY(SimpleDrawLine-static STATIC ${SimpleDrawLine_SRCS})
      # The library target "SimpleDrawLine-static" has a default OUTPUT_NAME of "SimpleDrawLine-static", so change it.
-     QT5_USE_MODULES(SimpleDrawLine-static Core OpenGL)
      SET_TARGET_PROPERTIES(SimpleDrawLine-static PROPERTIES OUTPUT_NAME "SimpleDrawLine")
-     TARGET_LINK_LIBRARIES(SimpleDrawLine-static ${extLinkerOption})
+     TARGET_LINK_LIBRARIES(SimpleDrawLine-static ${StelMain} ${SimpleDrawLine_Qt_Libraries})
      SET_TARGET_PROPERTIES(SimpleDrawLine-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
      ADD_DEPENDENCIES(AllStaticPlugins SimpleDrawLine-static)
 ENDIF()

=== modified file 'plugins/SolarSystemEditor/src/CMakeLists.txt'
--- plugins/SolarSystemEditor/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/SolarSystemEditor/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -28,12 +28,8 @@
 
 QT5_WRAP_UI(SolarSystemEditor_UIS_H ${SolarSystemEditor_UIS})
 
-
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(SolarSystemEditor-static STATIC ${SolarSystemEditor_SRCS} ${SolarSystemEditor_RES_CXX} ${SolarSystemEditor_UIS_H})
-QT5_USE_MODULES(SolarSystemEditor-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(SolarSystemEditor-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(SolarSystemEditor-static PROPERTIES OUTPUT_NAME "SolarSystemEditor")
-TARGET_LINK_LIBRARIES(SolarSystemEditor-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(SolarSystemEditor-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins SolarSystemEditor-static)

=== modified file 'plugins/Supernovae/src/CMakeLists.txt'
--- plugins/Supernovae/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/Supernovae/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -25,11 +25,8 @@
 SET(Supernovae_RES ../resources/Supernovae.qrc)
 QT5_ADD_RESOURCES(Supernovae_RES_CXX ${Supernovae_RES})
 
-SET(extLinkerOption ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(Supernovae-static STATIC ${Supernovae_SRCS} ${Supernovae_RES_CXX} ${SupernovaeDialog_UIS_H})
-QT5_USE_MODULES(Supernovae-static Core Network Widgets)
+TARGET_LINK_LIBRARIES(Supernovae-static Qt5::Core Qt5::Network Qt5::Widgets)
 SET_TARGET_PROPERTIES(Supernovae-static PROPERTIES OUTPUT_NAME "Supernovae")
-TARGET_LINK_LIBRARIES(Supernovae-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(Supernovae-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins Supernovae-static)

=== modified file 'plugins/Supernovae/src/Supernovae.cpp'
--- plugins/Supernovae/src/Supernovae.cpp	2016-08-07 10:10:32 +0000
+++ plugins/Supernovae/src/Supernovae.cpp	2017-01-12 21:08:38 +0000
@@ -227,9 +227,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		painter.setColor(c[0],c[1],c[2]);
 		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		painter.setBlending(true);
 		painter.drawSprite2dMode(screenpos[0], screenpos[1], 13.f, StelApp::getInstance().getTotalRunTime()*40.);
 	}
 }

=== modified file 'plugins/TelescopeControl/src/CMakeLists.txt'
--- plugins/TelescopeControl/src/CMakeLists.txt	2015-11-12 12:38:13 +0000
+++ plugins/TelescopeControl/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -66,11 +66,15 @@
 SET(TelescopeControl_RES ../resources/TelescopeControl.qrc)
 QT5_ADD_RESOURCES(TelescopeControl_RES_CXX ${TelescopeControl_RES})
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
+#IF(WIN32 AND NOT MSVC)
+# TODO: Test if winsock is still necessary if the Telescope Control plug-in is disabled.
+# Because including it here seems to duplicate STELLARIUM_STATIC_PLUGINS_LIBRARIES
+#   SET(extLinkerOption ${extLinkerOption} libwinmm.a -lws2_32)
+#ENDIF()
+#
 
 ADD_LIBRARY(TelescopeControl-static STATIC ${TelescopeControl_SRCS} ${TelescopeControl_RES_CXX} ${TelescopeControl_UIS_H})
 SET_TARGET_PROPERTIES(TelescopeControl-static PROPERTIES OUTPUT_NAME "TelescopeControl")
-TARGET_LINK_LIBRARIES(TelescopeControl-static ${extLinkerOption})
-QT5_USE_MODULES(TelescopeControl-static Core Network Widgets SerialPort OpenGL)
+TARGET_LINK_LIBRARIES(TelescopeControl-static Qt5::Core Qt5::Network Qt5::Widgets Qt5::SerialPort)
 SET_TARGET_PROPERTIES(TelescopeControl-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins TelescopeControl-static)

=== modified file 'plugins/TelescopeControl/src/TelescopeControl.cpp'
--- plugins/TelescopeControl/src/TelescopeControl.cpp	2016-07-03 21:58:54 +0000
+++ plugins/TelescopeControl/src/TelescopeControl.cpp	2017-01-12 21:08:38 +0000
@@ -278,21 +278,16 @@
 				if (circleFader.getInterstate() >= 0)
 				{
 					sPainter.setColor(circleColor[0], circleColor[1], circleColor[2], circleFader.getInterstate());
-					glDisable(GL_TEXTURE_2D);
 					foreach (double circle, telescope->getOculars())
 					{
 						sPainter.drawCircle(XY[0], XY[1], 0.5 * prj->getPixelPerRadAtCenter() * (M_PI/180) * (circle));
 					}
-					glEnable(GL_TEXTURE_2D);
 				}
 				if (reticleFader.getInterstate() >= 0)
 				{
-					glEnable(GL_TEXTURE_2D);
-					glEnable(GL_BLEND);
-					glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+					sPainter.setBlending(true, GL_SRC_ALPHA, GL_ONE);
 					sPainter.setColor(reticleColor[0], reticleColor[1], reticleColor[2], reticleFader.getInterstate());
 					sPainter.drawSprite2dMode(XY[0],XY[1],15.f);
-					glDisable(GL_TEXTURE_2D);
 				}
 				if (labelFader.getInterstate() >= 0)
 				{
@@ -423,9 +418,7 @@
 		const Vec3f& c(obj->getInfoColor());
 		sPainter.setColor(c[0], c[1], c[2]);
 		selectionTexture->bind();
-		glEnable(GL_TEXTURE_2D);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+		sPainter.setBlending(true);
 		sPainter.drawSprite2dMode(screenpos[0], screenpos[1], 25., StelApp::getInstance().getTotalRunTime() * 40.);
 	}
 #endif //COMPATIBILITY_001002

=== modified file 'plugins/TextUserInterface/src/CMakeLists.txt'
--- plugins/TextUserInterface/src/CMakeLists.txt	2015-10-20 17:16:34 +0000
+++ plugins/TextUserInterface/src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -29,12 +29,9 @@
      TextUserInterface.cpp
 )
 
-SET(extLinkerOption ${OPENGL_LIBRARIES})
-
 ADD_LIBRARY(TextUserInterface-static STATIC ${TextUserInterface_SRCS})
-QT5_USE_MODULES(TextUserInterface-static Core Widgets)
+TARGET_LINK_LIBRARIES(TextUserInterface-static Qt5::Core Qt5::Widgets)
 # The library target "TextUserInterface-static" has a default OUTPUT_NAME of "TextUserInterface-static", so change it.
 SET_TARGET_PROPERTIES(TextUserInterface-static PROPERTIES OUTPUT_NAME "TextUserInterface")
-TARGET_LINK_LIBRARIES(TextUserInterface-static ${extLinkerOption})
 SET_TARGET_PROPERTIES(TextUserInterface-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
 ADD_DEPENDENCIES(AllStaticPlugins TextUserInterface-static)

=== modified file 'plugins/TextUserInterface/src/TextUserInterface.cpp'
--- plugins/TextUserInterface/src/TextUserInterface.cpp	2017-01-10 15:51:22 +0000
+++ plugins/TextUserInterface/src/TextUserInterface.cpp	2017-01-12 21:08:38 +0000
@@ -61,9 +61,7 @@
 #include <QTime>
 #include <QProcess>
 #include <QDir>
-#ifdef DISABLE_SCRIPTING
-#include "QSettings" // WTF?
-#endif
+#include <QSettings>
 
 
 /*************************************************************************

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-12-18 22:26:48 +0000
+++ src/CMakeLists.txt	2017-01-12 21:08:38 +0000
@@ -1,65 +1,9 @@
-SET(glues_lib_SRCS
-     core/external/glues_stel/source/glues_error.c
-     core/external/glues_stel/source/glues_error.h
-     core/external/glues_stel/source/glues.h
-     core/external/glues_stel/source/libtess/dict.h
-     core/external/glues_stel/source/libtess/dict.c
-     core/external/glues_stel/source/libtess/dict-list.h
-     core/external/glues_stel/source/libtess/geom.c
-     core/external/glues_stel/source/libtess/geom.h
-     core/external/glues_stel/source/libtess/memalloc.c
-     core/external/glues_stel/source/libtess/memalloc.h
-     core/external/glues_stel/source/libtess/mesh.c
-     core/external/glues_stel/source/libtess/mesh.h
-     core/external/glues_stel/source/libtess/normal.c
-     core/external/glues_stel/source/libtess/normal.h
-     core/external/glues_stel/source/libtess/priorityq.c
-     core/external/glues_stel/source/libtess/priorityq.h
-     core/external/glues_stel/source/libtess/priorityq-heap.h
-     core/external/glues_stel/source/libtess/priorityq-heap.i
-     core/external/glues_stel/source/libtess/priorityq-sort.h
-     core/external/glues_stel/source/libtess/render.c
-     core/external/glues_stel/source/libtess/render.h
-     core/external/glues_stel/source/libtess/sweep.c
-     core/external/glues_stel/source/libtess/sweep.h
-     core/external/glues_stel/source/libtess/tess.c
-     core/external/glues_stel/source/libtess/tess.h
-     core/external/glues_stel/source/libtess/tessmono.c
-     core/external/glues_stel/source/libtess/tessmono.h
-)
-
-SET(zlib_SRCS
-     core/external/zlib/adler32.c
-     core/external/zlib/compress.c
-     core/external/zlib/crc32.c
-     core/external/zlib/crc32.h
-     core/external/zlib/deflate.c
-     core/external/zlib/deflate.h
-     core/external/zlib/gzclose.c
-     core/external/zlib/gzguts.h
-     core/external/zlib/gzlib.c
-     core/external/zlib/gzread.c
-     core/external/zlib/gzwrite.c
-     core/external/zlib/infback.c
-     core/external/zlib/inffast.c
-     core/external/zlib/inffast.h
-     core/external/zlib/inffixed.h
-     core/external/zlib/inflate.c
-     core/external/zlib/inflate.h
-     core/external/zlib/inftrees.c
-     core/external/zlib/inftrees.h
-     core/external/zlib/trees.c
-     core/external/zlib/trees.h
-     core/external/zlib/uncompr.c
-     core/external/zlib/zconf.h
-     core/external/zlib/zlib.h
-     core/external/zlib/zutil.c
-     core/external/zlib/zutil.h
-)
+#add our external dependencies first
+add_subdirectory(external)
 
 IF(ENABLE_SPOUT)
     SET(spout_SRCS
-     core/external/SpoutLibrary.h
+     external/SpoutLibrary.h
      core/SpoutSender.hpp
      core/SpoutSender.cpp
 	 )
@@ -171,10 +115,6 @@
      core/StelPropertyMgr.hpp
      core/StelPropertyMgr.cpp
 
-     ${gl_lib_SRCS}
-
-     ${glues_lib_SRCS}
-	 
      ${spout_SRCS}
 
      core/planetsephems/calc_interpolated_elements.c
@@ -295,14 +235,6 @@
      )
 ENDIF()
 
-SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
-     core/external/qtcompress/qzip.cpp
-     core/external/qtcompress/qzipreader.h
-     core/external/qtcompress/qzipwriter.h
-     core/external/qcustomplot/qcustomplot.cpp
-     core/external/qcustomplot/qcustomplot.h
-)
-
 IF(ENABLE_SCRIPTING)
      SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
           scripting/StelScriptOutput.hpp
@@ -318,12 +250,6 @@
      )
 ENDIF()
 
-IF(WIN32)
-     SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
-          ${zlib_SRCS}
-     )
-ENDIF()
-
 SET(stellarium_exe_SRCS main.cpp)
 
 ################# compiles resources files ############
@@ -424,7 +350,6 @@
      SET(stellarium_gui_RES ${CMAKE_SOURCE_DIR}/data/gui/guiRes.qrc)
      QT5_ADD_RESOURCES(stellarium_gui_RES_CXX ${stellarium_gui_RES})
 
-     SET(extLinkerOption ${extLinkerOption} ${QT_QTSCRIPT_LIBRARY} ${OPENGL_LIBRARIES})
      SET(stellarium_lib_SRCS ${stellarium_lib_SRCS} ${stellarium_gui_SRCS} ${stellarium_UIS_H} ${stellarium_gui_RES_CXX})
 ENDIF()
 
@@ -467,15 +392,9 @@
 ################################ Build main program #########################################
 #############################################################################################
 
-SET(extLinkerOption ${extLinkerOption} ${OPENGL_LIBRARIES} ${ZLIB_LIBRARIES})
-IF(ENABLE_MEDIA)
-    # Forced linkage to Qt5MultimediaWidgets library when media support is enabled
-    SET(extLinkerOption ${extLinkerOption} ${Qt5MultimediaWidgets_LIBRARIES})
-ENDIF()
 IF(WIN32 AND NOT MSVC)
-# TODO: Test if winsock is still necessary if the Telescope Control plug-in is disabled.
-# Because including it here seems to duplicate STELLARIUM_STATIC_PLUGINS_LIBRARIES
-     SET(extLinkerOption ${extLinkerOption} libwinmm.a -lws2_32)
+    # This library is required on MinGW builds for some native methods used in a fix in main.cpp
+     SET(winMMLib libwinmm.a)
 ENDIF()
 
 IF(WIN32 AND ENABLE_WINDOWS_EXE_ICON)
@@ -491,51 +410,37 @@
      ENDIF()
 ENDIF()
 
+# Setup Qt5 dependencies
+SET(STELLARIUM_QT_LIBRARIES Qt5::Core Qt5::Concurrent Qt5::Gui ${STEL_GLES_LIBS} Qt5::Network Qt5::Widgets)
+IF(ENABLE_MEDIA)
+     SET(STELLARIUM_QT_LIBRARIES ${STELLARIUM_QT_LIBRARIES} Qt5::Multimedia Qt5::MultimediaWidgets)
+ENDIF()
+IF(ENABLE_SCRIPTING)
+     SET(STELLARIUM_QT_LIBRARIES ${STELLARIUM_QT_LIBRARIES} Qt5::Script)
+ENDIF()
+if(USE_OLD_QGLWIDGET)
+    # The Qt5OpenGL library is only required when using the legacy viewport
+    SET(STELLARIUM_QT_LIBRARIES ${STELLARIUM_QT_LIBRARIES} Qt5::OpenGL)
+endif()
+
 if(ENABLE_SPOUT AND SPOUT_LIBRARY_DLL)
     # automatically copy the spout .dll to the binary directory, if possible
     configure_file(${SPOUT_LIBRARY_DLL} ${CMAKE_CURRENT_BINARY_DIR} COPYONLY)
 endif()
 
+set(STELMAIN_DEPS ${ZLIB_LIBRARIES} qtcompress_stel glues_stel qcustomplot_stel ${STELLARIUM_STATIC_PLUGINS_LIBRARIES} ${STELLARIUM_QT_LIBRARIES} ${SPOUT_LIBRARY})
+
+# Main executable/library setup
 IF(GENERATE_STELMAINLIB)
      ADD_LIBRARY(stelMain SHARED ${stellarium_lib_SRCS} ${stellarium_RES_CXX})
-     TARGET_LINK_LIBRARIES(stelMain ${extLinkerOption} ${STELLARIUM_STATIC_PLUGINS_LIBRARIES})
-     QT5_USE_MODULES(stelMain Core Concurrent Gui Network OpenGL Widgets PrintSupport)
-     IF(ENABLE_MEDIA)
-          QT5_USE_MODULES(stelMain Multimedia MultimediaWidgets)
-     ENDIF()
-     IF(ENABLE_SCRIPTING)
-          QT5_USE_MODULES(stelMain Script)
-     ENDIF()
-     IF(USE_PLUGIN_TELESCOPECONTROL)
-          QT5_USE_MODULES(stelMain SerialPort)
-     ENDIF()
-     IF(ENABLE_SPOUT)
-          TARGET_LINK_LIBRARIES(stelMain ${SPOUT_LIBRARY})
-     ENDIF(ENABLE_SPOUT)
-
+     TARGET_LINK_LIBRARIES(stelMain ${STELMAIN_DEPS})
      INSTALL(TARGETS stelMain DESTINATION lib)
      ADD_EXECUTABLE(stellarium ${stellarium_exe_SRCS})
      #stelMain should be after the plug-ins, otherwise the build crashes
-     TARGET_LINK_LIBRARIES(stellarium ${STELLARIUM_STATIC_PLUGINS_LIBRARIES} stelMain ${extLinkerOption})
+     TARGET_LINK_LIBRARIES(stellarium stelMain ${winMMLib})
 ELSE()
      ADD_EXECUTABLE(stellarium ${stellarium_lib_SRCS} ${stellarium_RES_CXX} ${stellarium_exe_SRCS})
-     TARGET_LINK_LIBRARIES(stellarium ${extLinkerOption} ${STELLARIUM_STATIC_PLUGINS_LIBRARIES})
-     # This will add the ANGLE lib if the Qt version supports it.
-     TARGET_LINK_LIBRARIES(stellarium ${Qt5Gui_LIBRARIES} ${Qt5Gui_OPENGL_LIBRARIES})
-
-     QT5_USE_MODULES(stellarium Core Concurrent Gui Network OpenGL Widgets PrintSupport)
-     IF(ENABLE_MEDIA)
-          QT5_USE_MODULES(stellarium Multimedia MultimediaWidgets)
-     ENDIF()
-     IF(ENABLE_SCRIPTING)
-          QT5_USE_MODULES(stellarium Script)
-     ENDIF()
-     IF(USE_PLUGIN_TELESCOPECONTROL)
-          QT5_USE_MODULES(stellarium SerialPort)
-     ENDIF()
-     IF(ENABLE_SPOUT)
-          TARGET_LINK_LIBRARIES(stellarium ${SPOUT_LIBRARY})
-     ENDIF(ENABLE_SPOUT)
+     TARGET_LINK_LIBRARIES(stellarium ${winMMLib} ${STELMAIN_DEPS})
 
      IF(APPLE)
           SET_TARGET_PROPERTIES(stellarium PROPERTIES LINK_FLAGS " -framework Cocoa -framework OpenGL")
@@ -566,7 +471,7 @@
      SET(STELLARIUM_TESTS ${STELLARIUM_TESTS} ${NAME})
 ENDMACRO()
 
-SET(extLinkerOptionTest ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTTEST_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTOPENGL_LIBRARY} ${OPENGL_LIBRARIES} ${ZLIB_LIBRARIES})
+SET(TESTS_LIBRARIES ${ZLIB_LIBRARIES} Qt5::Core Qt5::Gui Qt5::Test)
 
 # Custom target used to build all tests at once
 ADD_CUSTOM_TARGET(buildTests)
@@ -577,13 +482,8 @@
      core/StelUtils.hpp
      core/StelUtils.cpp
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testDates_SRCS ${tests_testDates_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testDates EXCLUDE_FROM_ALL ${tests_testDates_SRCS})
-QT5_USE_MODULES(testDates Core Test)
-TARGET_LINK_LIBRARIES(testDates ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testDates ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testDates)
 ADD_TEST(testDates)
 
@@ -594,8 +494,7 @@
      core/StelFileMgr.cpp
 )
 ADD_EXECUTABLE(testStelFileMgr EXCLUDE_FROM_ALL ${tests_testStelFileMgr_SRCS})
-QT5_USE_MODULES(testStelFileMgr Core Test)
-TARGET_LINK_LIBRARIES(testStelFileMgr ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testStelFileMgr ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testStelFileMgr)
 ADD_TEST(testStelFileMgr)
 
@@ -618,50 +517,35 @@
      core/StelFileMgr.cpp
      core/StelTranslator.hpp
      core/StelTranslator.cpp
-     ${glues_lib_SRCS}
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testStelSphereGeometry_SRCS ${tests_testStelSphereGeometry_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testStelSphereGeometry EXCLUDE_FROM_ALL ${tests_testStelSphereGeometry_SRCS})
-QT5_USE_MODULES(testStelSphereGeometry Core OpenGL Test)
-TARGET_LINK_LIBRARIES(testStelSphereGeometry ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testStelSphereGeometry ${TESTS_LIBRARIES} glues_stel)
 ADD_DEPENDENCIES(buildTests testStelSphereGeometry)
 ADD_TEST(testStelSphereGeometry)
 
-SET(tests_testStelSphericalIndex_SRCS
-     tests/testStelSphericalIndex.hpp
-     tests/testStelSphericalIndex.cpp
-     core/StelSphericalIndex.hpp
-     core/StelSphericalIndex.cpp
-     core/StelSphereGeometry.hpp
-     core/StelSphereGeometry.cpp
-     core/StelVertexArray.hpp
-     core/StelVertexArray.cpp
-     core/OctahedronPolygon.hpp
-     core/OctahedronPolygon.cpp
-     core/StelJsonParser.hpp
-     core/StelJsonParser.cpp
-     core/StelUtils.cpp
-     core/StelUtils.hpp
-     core/StelProjector.cpp
-     core/StelProjector.hpp
-     core/StelTranslator.cpp
-     core/StelTranslator.hpp
-     core/StelFileMgr.cpp
-     core/StelFileMgr.hpp
-     ${glues_lib_SRCS}
-)
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testStelSphericalIndex_SRCS ${tests_testStelSphericalIndex_SRCS} ${zlib_SRCS})
-ENDIF()
-ADD_EXECUTABLE(testStelSphericalIndex EXCLUDE_FROM_ALL ${tests_testStelSphericalIndex_SRCS})
-QT5_USE_MODULES(testStelSphericalIndex Core OpenGL Test)
-TARGET_LINK_LIBRARIES(testStelSphericalIndex ${extLinkerOptionTest})
-ADD_DEPENDENCIES(buildTests testStelSphericalIndex)
-ADD_TEST(testStelSphericalIndex)
+#SET(tests_testStelSphericalIndex_SRCS
+#     tests/testStelSphericalIndex.hpp
+#     tests/testStelSphericalIndex.cpp
+#     core/StelSphericalIndex.hpp
+#     core/StelSphericalIndex.cpp
+#     core/StelSphereGeometry.hpp
+#     core/StelSphereGeometry.cpp
+#     core/StelVertexArray.hpp
+#     core/StelVertexArray.cpp
+#     core/OctahedronPolygon.hpp
+#     core/OctahedronPolygon.cpp
+#     core/StelJsonParser.hpp
+#     core/StelJsonParser.cpp
+#     core/StelUtils.cpp
+#     core/StelUtils.hpp
+#     core/StelProjector.cpp
+#     core/StelProjector.hpp
+#     core/StelTranslator.cpp
+#     core/StelTranslator.hpp
+#     ${glues_lib_SRCS})
+#ADD_EXECUTABLE(testStelSphericalIndex EXCLUDE_FROM_ALL ${tests_testStelSphericalIndex_SRCS})
+#TARGET_LINK_LIBRARIES(testStelSphericalIndex ${TESTS_LIBRARIES})
+#ADD_DEPENDENCIES(buildTests testStelSphericalIndex)
 
 SET(tests_testStelJsonParser_SRCS
      tests/testStelJsonParser.hpp
@@ -670,8 +554,7 @@
      core/StelJsonParser.cpp
 )
 ADD_EXECUTABLE(testStelJsonParser EXCLUDE_FROM_ALL ${tests_testStelJsonParser_SRCS})
-QT5_USE_MODULES(testStelJsonParser Core Test)
-TARGET_LINK_LIBRARIES(testStelJsonParser ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testStelJsonParser ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testStelJsonParser)
 ADD_TEST(testStelJsonParser)
 
@@ -681,8 +564,7 @@
      core/StelVertexArray.hpp
 )
 ADD_EXECUTABLE(testStelVertexArray EXCLUDE_FROM_ALL ${tests_testStelVertexArray_SRCS})
-QT5_USE_MODULES(testStelVertexArray Core Test OpenGL)
-TARGET_LINK_LIBRARIES(testStelVertexArray ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testStelVertexArray ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testStelVertexArray)
 ADD_TEST(testStelVertexArray)
 
@@ -692,13 +574,8 @@
      core/StelUtils.hpp
      core/StelUtils.cpp
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testDeltaT_SRCS ${tests_testDeltaT_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testDeltaT EXCLUDE_FROM_ALL ${tests_testDeltaT_SRCS})
-QT5_USE_MODULES(testDeltaT Core Test)
-TARGET_LINK_LIBRARIES(testDeltaT ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testDeltaT ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testDeltaT)
 ADD_TEST(testDeltaT)
 
@@ -708,13 +585,8 @@
      core/StelUtils.hpp
      core/StelUtils.cpp
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testConversions_SRCS ${tests_testConversions_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testConversions EXCLUDE_FROM_ALL ${tests_testConversions_SRCS})
-QT5_USE_MODULES(testConversions Core Test)
-TARGET_LINK_LIBRARIES(testConversions ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testConversions ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testConversions)
 ADD_TEST(testConversions)
 
@@ -725,8 +597,7 @@
      core/RefractionExtinction.cpp
 )
 ADD_EXECUTABLE(testExtinction EXCLUDE_FROM_ALL ${tests_testExtinction_SRCS})
-QT5_USE_MODULES(testExtinction Core Test)
-TARGET_LINK_LIBRARIES(testExtinction ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testExtinction ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testExtinction)
 ADD_TEST(testExtinction)
 
@@ -738,13 +609,8 @@
      core/StelUtils.hpp
      core/StelUtils.cpp
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testRefraction_SRCS ${tests_testRefraction_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testRefraction EXCLUDE_FROM_ALL ${tests_testRefraction_SRCS})
-QT5_USE_MODULES(testRefraction Core Test)
-TARGET_LINK_LIBRARIES(testRefraction ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testRefraction ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testRefraction)
 ADD_TEST(testRefraction)
 
@@ -756,13 +622,8 @@
      core/StelUtils.hpp
      core/StelUtils.cpp
 )
-IF(WIN32)
-     # StelUtils required zlib sources
-     SET(tests_testPrecession_SRCS ${tests_testPrecession_SRCS} ${zlib_SRCS})
-ENDIF()
 ADD_EXECUTABLE(testPrecession EXCLUDE_FROM_ALL ${tests_testPrecession_SRCS})
-QT5_USE_MODULES(testPrecession Core Test)
-TARGET_LINK_LIBRARIES(testPrecession ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testPrecession ${TESTS_LIBRARIES})
 ADD_DEPENDENCIES(buildTests testPrecession)
 ADD_TEST(testPrecession)
 
@@ -788,8 +649,7 @@
      core/planetsephems/jpleph.cpp
 )
 ADD_EXECUTABLE(testEphemeris EXCLUDE_FROM_ALL ${tests_testEphemeris_SRCS})
-QT5_USE_MODULES(testEphemeris Core Test)
-TARGET_LINK_LIBRARIES(testEphemeris ${extLinkerOptionTest})
+TARGET_LINK_LIBRARIES(testEphemeris ${TESTS_LIBRARIES})
 TARGET_COMPILE_DEFINITIONS(testEphemeris PRIVATE UNIT_TEST)
 ADD_DEPENDENCIES(buildTests testEphemeris)
 ADD_TEST(testEphemeris)

=== modified file 'src/StelLogger.cpp'
--- src/StelLogger.cpp	2016-07-05 15:30:52 +0000
+++ src/StelLogger.cpp	2017-01-12 21:08:38 +0000
@@ -254,6 +254,8 @@
 
 void StelLogger::debugLogHandler(QtMsgType type, const QMessageLogContext& ctx, const QString& msg)
 {
+	// *** NOTE: see original Qt source in qlogging.cpp (qDefaultMessageHandler) for sensible default code
+
 #if (QT_VERSION>=QT_VERSION_CHECK(5,4,0))
 	//use Qt to format the log message, if possible
 	//this uses the format set by qSetMessagePattern
@@ -268,24 +270,30 @@
 	if(fmt.isNull())
 		return;
 
+	//always append newline
+	fmt.append(QLatin1Char('\n'));
+
 #ifdef Q_OS_WIN
 	//Send debug messages to Debugger, if one is attached, instead of stderr
 	//This seems to avoid output delays in Qt Creator, allowing for easier debugging
 	//Seems to work fine with MSVC and MinGW
-	if(IsDebuggerPresent())
-		OutputDebugStringW(reinterpret_cast<LPCWSTR>(fmt.utf16()));
+	if (IsDebuggerPresent())
+	{
+		OutputDebugStringW(reinterpret_cast<const wchar_t *>(fmt.utf16()));
+	}
 	else
 #endif
-	//this does the same as the default handler in qlogging.cpp
-	fprintf(stderr, "%s\n", qPrintable(fmt));
-	fflush(stderr);
+	{
+		//this does the same as the default handler in qlogging.cpp
+		fprintf(stderr, "%s", qPrintable(fmt));
+		fflush(stderr);
+	}
 	writeLog(fmt);
 }
 
 void StelLogger::writeLog(QString msg)
 {
 	fileMutex.lock();
-	msg += "\n";
 	logFile.write(qPrintable(msg), msg.size());
 	log += msg;
 	fileMutex.unlock();

=== modified file 'src/StelMainView.cpp'
--- src/StelMainView.cpp	2016-12-11 22:57:16 +0000
+++ src/StelMainView.cpp	2017-01-12 21:08:38 +0000
@@ -32,10 +32,10 @@
 
 #include <QDebug>
 #include <QDir>
-#if STEL_USE_NEW_OPENGL_WIDGETS
+#ifdef USE_OLD_QGLWIDGET
+#include <QGLWidget>
+#else
 #include <QOpenGLWidget>
-#else
-#include <QGLWidget>
 #endif
 #include <QApplication>
 #include <QDesktopWidget>
@@ -61,24 +61,199 @@
 #endif
 #include <QOpenGLShader>
 #include <QOpenGLShaderProgram>
-#include <QGLFramebufferObject>
-#include <QGLShaderProgram>
+#include <QOpenGLFramebufferObject>
+#include <QOpenGLPaintDevice>
+#ifdef OPENGL_DEBUG_LOGGING
+#include <QOpenGLDebugLogger>
+#endif
 
 #include <clocale>
 
 // Initialize static variables
 StelMainView* StelMainView::singleton = NULL;
 
+#ifdef USE_OLD_QGLWIDGET
+class StelGLWidget : public QGLWidget
+#else
+class StelGLWidget : public QOpenGLWidget
+#endif
+{
+public:
+	StelGLWidget(StelMainView* parent)
+		:
+#ifdef USE_OLD_QGLWIDGET
+		  QGLWidget(parent),
+#else
+		  QOpenGLWidget(parent),
+#endif
+		  parent(parent),
+		  initialized(false)
+	{
+		qDebug()<<"StelGLWidget constructor";
+
+		//because we always draw the full background,
+		//lets skip drawing the system background
+		setAttribute(Qt::WA_OpaquePaintEvent);
+		setAutoFillBackground(false);
+	}
+
+	~StelGLWidget()
+	{
+		qDebug()<<"StelGLWidget destroyed";
+	}
+
+	virtual void initializeGL() Q_DECL_OVERRIDE
+	{
+		if(initialized)
+		{
+			qWarning()<<"Double initialization, should not happen";
+			Q_ASSERT(false);
+			return;
+		}
+
+		//This seems to be the correct place to initialize all
+		//GL related stuff of the application
+		//this includes all the init() calls of the modules
+
+#ifdef USE_OLD_QGLWIDGET
+		QOpenGLContext* ctx = context()->contextHandle();
+#else
+		QOpenGLContext* ctx = context();
+#endif
+		Q_ASSERT(ctx == QOpenGLContext::currentContext());
+		StelOpenGL::mainContext = ctx; //throw an error when StelOpenGL functions are executed in another context
+
+		qDebug()<<"initializeGL";
+		qDebug() << "OpenGL supported version: " << QString((char*)ctx->functions()->glGetString(GL_VERSION));
+		qDebug() << "Current Format: " << this->format();
+
+		if (qApp->property("onetime_compat33")==true)
+		{
+			// This may not return the version number set previously!
+			qDebug() << "StelGLWidget context format version:" << ctx->format().majorVersion() << "." << context()->format().minorVersion();
+			qDebug() << "StelGLWidget has CompatibilityProfile:" << (ctx->format().profile()==QSurfaceFormat::CompatibilityProfile ? "yes" : "no") << "(" <<context()->format().profile() << ")";
+		}
+
+		parent->init();
+		initialized = true;
+	}
+
+protected:
+	virtual void paintGL() Q_DECL_OVERRIDE
+	{
+		//this is actually never called because the
+		//QGraphicsView intercepts the paint event
+		//we have to draw in the background of the scene
+		//or as a QGraphicsItem
+		qDebug()<<"paintGL";
+	}
+	virtual void resizeGL(int w, int h) Q_DECL_OVERRIDE
+	{
+		//we probably can ignore this method,
+		//it seems it is also never called
+		qDebug()<<"resizeGL"<<w<<h;
+	}
+
+private:
+	StelMainView* parent;
+	bool initialized;
+};
+
 // A custom QGraphicsEffect to apply the night mode on top of the screen.
 class NightModeGraphicsEffect : public QGraphicsEffect
 {
 public:
-	NightModeGraphicsEffect(QObject* parent = NULL);
+	NightModeGraphicsEffect(StelMainView* parent = NULL)
+		: QGraphicsEffect(parent),
+		  parent(parent), fbo(NULL)
+	{
+		Q_ASSERT(parent->glContext() == QOpenGLContext::currentContext());
+
+		program = new QOpenGLShaderProgram(this);
+		QString vertexCode =
+				"attribute highp vec4 a_pos;\n"
+				"attribute highp vec2 a_texCoord;\n"
+				"varying highp   vec2 v_texCoord;\n"
+				"void main(void)\n"
+				"{\n"
+				"v_texCoord = a_texCoord;\n"
+				"gl_Position = a_pos;\n"
+				"}\n";
+		QString fragmentCode =
+				"varying highp vec2 v_texCoord;\n"
+				"uniform sampler2D  u_source;\n"
+				"void main(void)\n"
+				"{\n"
+				"	mediump vec3 color = texture2D(u_source, v_texCoord).rgb;\n"
+				"	mediump float luminance = max(max(color.r, color.g), color.b);\n"
+				"	gl_FragColor = vec4(luminance, 0.0, 0.0, 1.0);\n"
+				"}\n";
+		program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexCode);
+		program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentCode);
+		program->link();
+		vars.pos = program->attributeLocation("a_pos");
+		vars.texCoord = program->attributeLocation("a_texCoord");
+		vars.source = program->uniformLocation("u_source");
+	}
+
+	virtual ~NightModeGraphicsEffect()
+	{
+		Q_ASSERT(parent->glContext() == QOpenGLContext::currentContext());
+		//clean up fbo
+		delete fbo;
+	}
 protected:
-	virtual void draw(QPainter* painter);
+	virtual void draw(QPainter* painter) Q_DECL_OVERRIDE
+	{
+		Q_ASSERT(parent->glContext() == QOpenGLContext::currentContext());
+		QOpenGLFunctions* gl = QOpenGLContext::currentContext()->functions();
+
+		int mainFBO;
+		gl->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &mainFBO);
+
+		int pixelRatio = painter->device()->devicePixelRatio();
+		QSize size(painter->device()->width() * pixelRatio, painter->device()->height() * pixelRatio);
+		if (fbo && fbo->size() != size)
+		{
+			delete fbo;
+			fbo = NULL;
+		}
+		if (!fbo)
+		{
+			QOpenGLFramebufferObjectFormat format;
+			format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+			format.setInternalTextureFormat(GL_RGBA);
+			fbo = new QOpenGLFramebufferObject(size, format);
+		}
+
+		fbo->bind();
+		QOpenGLPaintDevice device(size);
+		QPainter fboPainter(&device);
+		drawSource(&fboPainter);
+		//dont use QOpenGLFramebufferObject::release here
+		gl->glBindFramebuffer(GL_FRAMEBUFFER,mainFBO);
+
+		painter->save();
+		painter->beginNativePainting();
+		program->bind();
+		const GLfloat pos[] = {-1, -1, +1, -1, -1, +1, +1, +1};
+		const GLfloat texCoord[] = {0, 0, 1, 0, 0, 1, 1, 1};
+		program->setUniformValue(vars.source, 0);
+		program->setAttributeArray(vars.pos, pos, 2);
+		program->setAttributeArray(vars.texCoord, texCoord, 2);
+		program->enableAttributeArray(vars.pos);
+		program->enableAttributeArray(vars.texCoord);
+		gl->glBindTexture(GL_TEXTURE_2D, fbo->texture());
+		gl->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+		program->release();
+		painter->endNativePainting();
+		painter->restore();
+	}
+
 private:
-	QGLFramebufferObject* fbo;
-	QGLShaderProgram *program;
+	StelMainView* parent;
+	QOpenGLFramebufferObject* fbo;
+	QOpenGLShaderProgram *program;
 	struct {
 		int pos;
 		int texCoord;
@@ -86,355 +261,271 @@
 	} vars;
 };
 
-NightModeGraphicsEffect::NightModeGraphicsEffect(QObject* parent) :
-	QGraphicsEffect(parent)
-	, fbo(NULL)
-{
-	program = new QGLShaderProgram(this);
-	QString vertexCode =
-		"attribute highp vec4 a_pos;\n"
-		"attribute highp vec2 a_texCoord;\n"
-		"varying highp   vec2 v_texCoord;\n"
-		"void main(void)\n"
-		"{\n"
-			"v_texCoord = a_texCoord;\n"
-			"gl_Position = a_pos;\n"
-		"}\n";
-	QString fragmentCode =
-		"varying highp vec2 v_texCoord;\n"
-		"uniform sampler2D  u_source;\n"
-		"void main(void)\n"
-		"{\n"
-		"	mediump vec3 color = texture2D(u_source, v_texCoord).rgb;\n"
-		"	mediump float luminance = max(max(color.r, color.g), color.b);\n"
-		"	gl_FragColor = vec4(luminance, 0.0, 0.0, 1.0);\n"
-		"}\n";
-	program->addShaderFromSourceCode(QGLShader::Vertex, vertexCode);
-	program->addShaderFromSourceCode(QGLShader::Fragment, fragmentCode);
-	program->link();
-	vars.pos = program->attributeLocation("a_pos");
-	vars.texCoord = program->attributeLocation("a_texCoord");
-	vars.source = program->uniformLocation("u_source");
-}
-
-// Qt 5.5 does not support setting the devicePixelRatio of a QGLFramebufferObject,
-// So here we make a sub class just so that we can return the correct ratio when
-// using the buffer on a retina display.
-class NightModeGraphicsEffectFbo : public QGLFramebufferObject
+class StelGraphicsScene : public QGraphicsScene
 {
 public:
-	NightModeGraphicsEffectFbo(const QSize& s, const QGLFramebufferObjectFormat& f, int pixelRatio_) :
-		QGLFramebufferObject(s, f), pixelRatio(pixelRatio_) {}
+	StelGraphicsScene(StelMainView* parent)
+		: QGraphicsScene(parent), parent(parent)
+	{
+		qDebug()<<"StelGraphicsScene constructor";
+	}
+
 protected:
-	virtual int metric(PaintDeviceMetric m) const
+
+	void keyPressEvent(QKeyEvent* event) Q_DECL_OVERRIDE
 	{
-		if (m == QPaintDevice::PdmDevicePixelRatio) return pixelRatio;
-		return QGLFramebufferObject::metric(m);
+		// Try to trigger a global shortcut.
+		StelActionMgr* actionMgr = StelApp::getInstance().getStelActionManager();
+		if (actionMgr->pushKey(event->key() + event->modifiers(), true)) {
+			event->setAccepted(true);
+			parent->thereWasAnEvent(); // Refresh screen ASAP
+			return;
+		}
+		//pass event on to items otherwise
+		QGraphicsScene::keyPressEvent(event);
 	}
+
 private:
-	int pixelRatio;
+	StelMainView* parent;
 };
 
-void NightModeGraphicsEffect::draw(QPainter* painter)
-{
-	int pixelRatio = painter->device()->devicePixelRatio();
-	QSize size(painter->device()->width() * pixelRatio, painter->device()->height() * pixelRatio);
-	if (fbo && fbo->size() != size)
-	{
-		delete fbo;
-		fbo = NULL;
-	}
-	if (!fbo)
-	{
-		QGLFramebufferObjectFormat format;
-		format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
-		format.setInternalTextureFormat(GL_RGBA);
-		fbo = new NightModeGraphicsEffectFbo(size, format, pixelRatio);
-	}
-	QPainter fboPainter(fbo);
-	drawSource(&fboPainter);
-
-	painter->save();
-	painter->beginNativePainting();
-	program->bind();
-	const GLfloat pos[] = {-1, -1, +1, -1, -1, +1, +1, +1};
-	const GLfloat texCoord[] = {0, 0, 1, 0, 0, 1, 1, 1};
-	program->setUniformValue(vars.source, 0);
-	program->setAttributeArray(vars.pos, pos, 2);
-	program->setAttributeArray(vars.texCoord, texCoord, 2);
-	program->enableAttributeArray(vars.pos);
-	program->enableAttributeArray(vars.texCoord);
-	glBindTexture(GL_TEXTURE_2D, fbo->texture());
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	program->release();
-	painter->endNativePainting();
-	painter->restore();
-}
-
-//! Render Stellarium sky. 
-class StelSkyItem : public QGraphicsWidget
+class StelRootItem : public QGraphicsObject
 {
 public:
-	StelSkyItem(QGraphicsItem* parent = NULL);
-	void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
+	StelRootItem(StelMainView* mainView, QGraphicsItem* parent = NULL)
+		: QGraphicsObject(parent), mainView(mainView)
+	{
+		setFlag(QGraphicsItem::ItemClipsToShape);
+		setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+		setFlag(QGraphicsItem::ItemIsFocusable);
+
+		setAcceptHoverEvents(true);
+
+#ifdef Q_OS_WIN
+		setAcceptTouchEvents(true);
+		grabGesture(Qt::PinchGesture);
+#endif
+		setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton);
+		previousPaintTime = StelApp::getTotalRunTime();
+	}
+
+	void setSize(const QSize& size)
+	{
+		prepareGeometryChange();
+		rect.setSize(size);
+	}
+
 protected:
-	void mousePressEvent(QGraphicsSceneMouseEvent* event);
-	void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);
-	void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
-	void wheelEvent(QGraphicsSceneWheelEvent *event);
-	void keyPressEvent(QKeyEvent *event);
-	void keyReleaseEvent(QKeyEvent *event);
-	void resizeEvent(QGraphicsSceneResizeEvent* event);
+	virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) Q_DECL_OVERRIDE
+	{
+		Q_UNUSED(option);
+		Q_UNUSED(widget);
+
+		//a sanity check
+		Q_ASSERT(mainView->glContext() == QOpenGLContext::currentContext());
+
+		const double now = StelApp::getTotalRunTime();
+		double dt = now - previousPaintTime;
+		//qDebug()<<"dt"<<dt;
+		previousPaintTime = now;
+
+		//update and draw
+		StelApp& app = StelApp::getInstance();
+		app.update(dt);
+
+		//important to call this, or Qt may have invalid state after we have drawn (wrong textures, etc...)
+		painter->beginNativePainting();
+		app.draw();
+		painter->endNativePainting();
+
+		mainView->drawEnded();
+	}
+
+	virtual QRectF boundingRect() const Q_DECL_OVERRIDE
+	{
+		return rect;
+	}
+
+	//*** Main event handlers to pass on to StelApp ***//
+	void mousePressEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE
+	{
+		QMouseEvent ev = convertMouseEvent(event);
+		StelApp::getInstance().handleClick(&ev);
+		event->setAccepted(ev.isAccepted());
+		if(ev.isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE
+	{
+		QMouseEvent ev = convertMouseEvent(event);
+		StelApp::getInstance().handleClick(&ev);
+		event->setAccepted(ev.isAccepted());
+		if(ev.isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	void mouseMoveEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE
+	{
+		QMouseEvent ev = convertMouseEvent(event);
+		QPointF pos = ev.pos();
+		event->setAccepted(StelApp::getInstance().handleMove(pos.x(), pos.y(), ev.buttons()));
+		if(event->isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	void wheelEvent(QGraphicsSceneWheelEvent *event) Q_DECL_OVERRIDE
+	{
+		QPointF pos = event->scenePos();
+		pos.setY(rect.height() - 1 - pos.y());
+		QWheelEvent newEvent(QPoint(pos.x(),pos.y()), event->delta(), event->buttons(), event->modifiers(), event->orientation());
+		StelApp::getInstance().handleWheel(&newEvent);
+		event->setAccepted(newEvent.isAccepted());
+		if(newEvent.isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	void keyPressEvent(QKeyEvent *event) Q_DECL_OVERRIDE
+	{
+		StelApp::getInstance().handleKeys(event);
+		if(event->isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	void keyReleaseEvent(QKeyEvent *event) Q_DECL_OVERRIDE
+	{
+		StelApp::getInstance().handleKeys(event);
+		if(event->isAccepted())
+			mainView->thereWasAnEvent();
+	}
+
+	//*** Gesture and touch support, currently only for Windows
 #ifdef Q_OS_WIN
-	bool event(QEvent * e);
+	bool event(QEvent * e) Q_DECL_OVERRIDE
+	{
+		switch (e->type()){
+			case QEvent::TouchBegin:
+			case QEvent::TouchUpdate:
+			case QEvent::TouchEnd:
+			{
+				QTouchEvent *touchEvent = static_cast<QTouchEvent *>(e);
+				QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
+
+				if (touchPoints.count() == 1)
+					setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton);
+
+				return true;
+				break;
+			}
+
+			case QEvent::Gesture:
+				setAcceptedMouseButtons(0);
+				return gestureEvent(static_cast<QGestureEvent*>(e));
+				break;
+
+			default:
+				return QGraphicsObject::event(e);
+		}
+	}
+
+private:
+	bool gestureEvent(QGestureEvent *event)
+	{
+		if (QGesture *pinch = event->gesture(Qt::PinchGesture))
+			pinchTriggered(static_cast<QPinchGesture *>(pinch));
+
+		return true;
+	}
+
+	void pinchTriggered(QPinchGesture *gesture)
+	{
+		QPinchGesture::ChangeFlags changeFlags = gesture->changeFlags();
+		if (changeFlags & QPinchGesture::ScaleFactorChanged) {
+			qreal zoom = gesture->scaleFactor();
+
+			if (zoom < 2 && zoom > 0.5){
+				StelApp::getInstance().handlePinch(zoom, true);
+			}
+		}
+	}
 #endif
+
 private:
+	//! Helper function to convert a QGraphicsSceneMouseEvent to a QMouseEvent suitable for StelApp consumption
+	QMouseEvent convertMouseEvent(QGraphicsSceneMouseEvent *event) const
+	{
+		//convert graphics scene mouse event to widget style mouse event
+		QEvent::Type t = QEvent::None;
+		switch(event->type())
+		{
+			case QEvent::GraphicsSceneMousePress:
+				t = QEvent::MouseButtonPress;
+				break;
+			case QEvent::GraphicsSceneMouseRelease:
+				t = QEvent::MouseButtonRelease;
+				break;
+			case QEvent::GraphicsSceneMouseMove:
+				t = QEvent::MouseMove;
+				break;
+			default:
+				qFatal("Invalid mouse event type %d",event->type());
+		}
+
+		QPointF pos = event->scenePos();
+		//Y needs to be inverted
+		pos.setY(rect.height() - 1 - pos.y());
+		return QMouseEvent(t,pos,event->button(),event->buttons(),event->modifiers());
+	}
+
+	QRectF rect;
 	double previousPaintTime;
-	// void onSizeChanged();
-#ifdef Q_OS_WIN
-	void pinchTriggered(QPinchGesture *gesture);
-	bool gestureEvent(QGestureEvent *event);
-#endif
+	StelMainView* mainView;
 };
 
 //! Initialize and render Stellarium gui.
 class StelGuiItem : public QGraphicsWidget
 {
 public:
-	StelGuiItem(QGraphicsItem* parent = NULL);
+	StelGuiItem(QGraphicsItem* parent = NULL)
+		: QGraphicsWidget(parent)
+	{
+		StelApp::getInstance().getGui()->init(this);
+	}
+
 protected:
-	void resizeEvent(QGraphicsSceneResizeEvent* event);
+	void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE
+	{
+		Q_UNUSED(event);
+		//widget->setGeometry(0, 0, size().width(), size().height());
+		StelApp::getInstance().getGui()->forceRefreshGui();
+	}
 private:
-	QGraphicsWidget *widget;
+	//QGraphicsWidget *widget;
 	// void onSizeChanged();
 };
 
-StelSkyItem::StelSkyItem(QGraphicsItem* parent)
-{
-	Q_UNUSED(parent);
-	setObjectName("SkyItem");
-	setFlag(QGraphicsItem::ItemHasNoContents, false);
-	setFlag(QGraphicsItem::ItemIsFocusable, true);
-	setAcceptHoverEvents(true);
-#ifdef Q_OS_WIN
-	setAcceptTouchEvents(true);
-	grabGesture(Qt::PinchGesture);
-#endif
-	setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton);
-	previousPaintTime = StelApp::getTotalRunTime();
-	setFocus();
-}
-
-void StelSkyItem::resizeEvent(QGraphicsSceneResizeEvent* event)
-{
-	QGraphicsWidget::resizeEvent(event);
-	StelApp::getInstance().glWindowHasBeenResized(scenePos().x(), scene()->sceneRect().height()-(scenePos().y()+geometry().height()), geometry().width(), geometry().height());
-}
-
-void StelSkyItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
-{
-	Q_UNUSED(option);
-	Q_UNUSED(widget);
-
-	const double now = StelApp::getTotalRunTime();
-	double dt = now - previousPaintTime;
-	previousPaintTime = now;
-
-	painter->beginNativePainting();
-	glClearColor(0, 0, 0, 1);
-	glClear(GL_COLOR_BUFFER_BIT);
-	StelApp::getInstance().update(dt);
-	StelApp::getInstance().draw();
-
-	painter->endNativePainting();
-}
-
-void StelSkyItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
-{
-	//To get back the focus from dialogs
-	setFocus();
-	QPointF pos = event->scenePos();
-	pos.setY(size().height() - 1 - pos.y());
-	QMouseEvent newEvent(QEvent::MouseButtonPress, QPoint(pos.x(), pos.y()), event->button(), event->buttons(), event->modifiers());
-	StelApp::getInstance().handleClick(&newEvent);
-}
-
-void StelSkyItem::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
-{
-	QPointF pos = event->scenePos();
-	pos.setY(size().height() - 1 - pos.y());
-	QMouseEvent newEvent(QEvent::MouseButtonRelease, QPoint(pos.x(), pos.y()), event->button(), event->buttons(), event->modifiers());
-	StelApp::getInstance().handleClick(&newEvent);
-}
-
-void StelSkyItem::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
-{
-	QPointF pos = event->scenePos();
-	pos.setY(size().height() - 1 - pos.y());
-	StelApp::getInstance().handleMove(pos.x(), pos.y(), event->buttons());
-}
-
-void StelSkyItem::wheelEvent(QGraphicsSceneWheelEvent *event)
-{
-	QPointF pos = event->scenePos();
-	pos.setY(size().height() - 1 - pos.y());
-	QWheelEvent newEvent(QPoint(pos.x(),pos.y()), event->delta(), event->buttons(), event->modifiers(), event->orientation());
-	StelApp::getInstance().handleWheel(&newEvent);
-}
-
-#ifdef Q_OS_WIN
-bool StelSkyItem::event(QEvent * e)
-{
-	switch (e->type()){
-	case QEvent::TouchBegin:
-	case QEvent::TouchUpdate:
-	case QEvent::TouchEnd:
-	{
-		QTouchEvent *touchEvent = static_cast<QTouchEvent *>(e);
-		QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
-
-		if (touchPoints.count() == 1)
-			setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton);
-
-		return true;
-		break;
-	}
-
-	case QEvent::Gesture:
-		setAcceptedMouseButtons(0);
-		return gestureEvent(static_cast<QGestureEvent*>(e));
-		break;
-
-	default:
-		return QGraphicsWidget::event(e);
-	}
-}
-
-bool StelSkyItem::gestureEvent(QGestureEvent *event)
-{
-	if (QGesture *pinch = event->gesture(Qt::PinchGesture))
-		pinchTriggered(static_cast<QPinchGesture *>(pinch));
-
-	return true;
-}
-
-void StelSkyItem::pinchTriggered(QPinchGesture *gesture)
-{
-	QPinchGesture::ChangeFlags changeFlags = gesture->changeFlags();
-	if (changeFlags & QPinchGesture::ScaleFactorChanged) {
-		qreal zoom = gesture->scaleFactor();
-
-		if (zoom < 2 && zoom > 0.5){
-			StelApp::getInstance().handlePinch(zoom, true);
-		}
-	}
-}
-#endif
-
-void StelSkyItem::keyPressEvent(QKeyEvent* event)
-{
-	StelApp::getInstance().handleKeys(event);
-}
-
-void StelSkyItem::keyReleaseEvent(QKeyEvent* event)
-{
-	StelApp::getInstance().handleKeys(event);
-}
-
-
-StelGuiItem::StelGuiItem(QGraphicsItem* parent) : QGraphicsWidget(parent)
-{
-	widget = new QGraphicsWidget(this);
-	StelApp::getInstance().getGui()->init(widget);
-}
-
-void StelGuiItem::resizeEvent(QGraphicsSceneResizeEvent* event)
-{
-	Q_UNUSED(event);
-	widget->setGeometry(0, 0, size().width(), size().height());
-	StelApp::getInstance().getGui()->forceRefreshGui();
-}
-
-#if STEL_USE_NEW_OPENGL_WIDGETS
-
-class StelQOpenGLWidget : public QOpenGLWidget
-{
-public:
-	StelQOpenGLWidget(QWidget* parent) : QOpenGLWidget(parent)
-	{
-		// TODO: Unclear if tese attributes make sense?
-		setAttribute(Qt::WA_PaintOnScreen);
-		setAttribute(Qt::WA_NoSystemBackground);
-		setAttribute(Qt::WA_OpaquePaintEvent);
-	}
-
-protected:
-	virtual void initializeGL()
-	{
-		qDebug() << "It appears this was never called?";
-		qDebug() << "OpenGL supported version: " << QString((char*)glGetString(GL_VERSION));
-
-		QOpenGLWidget::initializeGL();
-		this->makeCurrent(); // Do we need this?
-		// GZ I have no idea how to proceed, sorry.
-		QSurfaceFormat format=this->format();
-		qDebug() << "Current Format: " << this->format();
-		// TODO: Test something? The old tests may be obsolete as all OpenGL2 formats/contexts have these?
-	}
-	virtual void paintGL()
-	{
-		// TODO: what shall this do exactly?
-	}
-	virtual void resizeGL()
-	{
-		// TODO: what shall this do exactly?
-	}
-
-};
-
-#else
-class StelQGLWidget : public QGLWidget
-{
-public:
-	StelQGLWidget(QGLContext* ctx, QWidget* parent) : QGLWidget(ctx, parent)
-	{
-		setAttribute(Qt::WA_PaintOnScreen);
-		setAttribute(Qt::WA_NoSystemBackground);
-		setAttribute(Qt::WA_OpaquePaintEvent);
-	}
-
-protected:
-	virtual void initializeGL()
-	{
-		qDebug() << "It appears this is never called?";
-		Q_ASSERT(0);
-		qDebug() << "OpenGL supported version: " << QString((char*)glGetString(GL_VERSION));
-
-		QGLWidget::initializeGL();
-
-		qDebug() << "Current Context: " << this->format();
-		if (!format().stencil())
-			qWarning("Could not get stencil buffer; results will be suboptimal");
-		if (!format().depth())
-			qWarning("Could not get depth buffer; results will be suboptimal");
-		if (!format().doubleBuffer())
-			qWarning("Could not get double buffer; results will be suboptimal");
-	}
-
-};
-#endif
-
-
-StelMainView::StelMainView(QWidget* parent)
-	: QGraphicsView(parent), guiItem(NULL),
+StelMainView::StelMainView(QSettings* settings)
+	: QGraphicsView(),
+	  guiItem(NULL),
 	  gui(NULL),
+	  stelApp(NULL),
+	  updateQueued(false),
 	  flagInvertScreenShotColors(false),
 	  flagOverwriteScreenshots(false),
 	  screenShotPrefix("stellarium-"),
 	  screenShotDir(""),
-	  cursorTimeout(-1.f), flagCursorTimeout(false), minFpsTimer(NULL), maxfps(10000.f)
+	  cursorTimeout(-1.f), flagCursorTimeout(false), maxfps(10000.f)
 {
+	setAttribute(Qt::WA_OpaquePaintEvent);
+	setAutoFillBackground(false);
+
+	configuration = settings;
 	StelApp::initStatic();
+
+	minFpsTimer = new QTimer(this);
+	minFpsTimer->setTimerType(Qt::PreciseTimer);
+	minFpsTimer->setInterval(1000/minfps);
+	connect(minFpsTimer,SIGNAL(timeout()),this,SLOT(minFPSUpdate()));
 	
 	// Can't create 2 StelMainView instances
 	Q_ASSERT(!singleton);
@@ -444,83 +535,48 @@
 	initTitleI18n();
 	setObjectName("Mainview");
 
-	// Allows for precise FPS control
 	setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
 	setFrameShape(QFrame::NoFrame);
 	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-	setFocusPolicy(Qt::StrongFocus);
+	//because we only want child elements to have focus, we turn it off here
+	setFocusPolicy(Qt::NoFocus);
 	connect(this, SIGNAL(screenshotRequested()), this, SLOT(doScreenshot()));
 
 	lastEventTimeSec = 0;
 
-
-#if STEL_USE_NEW_OPENGL_WIDGETS
-	// Primary test for OpenGL existence
-	if (QSurfaceFormat::defaultFormat().majorVersion() < 2)
-	{
-		qWarning() << "No OpenGL 2 support on this system. Aborting.";
-		QMessageBox::critical(0, "Stellarium", q_("No OpenGL 2 found on this system. Please upgrade hardware or use MESA or an older version."), QMessageBox::Abort, QMessageBox::Abort);
-		exit(0);
-	}
-
-	//QSurfaceFormat format();
-	//// TBD: What options shall be default?
-	//QSurfaceFormat::setDefaultFormat(format);
-	////QOpenGLContext* context=new QOpenGLContext::create();
-	glWidget = new StelQOpenGLWidget(this);
-	//glWidget->setFormat(format);
+#ifdef OPENGL_DEBUG_LOGGING
+	glLogger = new QOpenGLDebugLogger(this);
+	connect(glLogger, SIGNAL(messageLogged(QOpenGLDebugMessage)), this, SLOT(logGLMessage(QOpenGLDebugMessage)));
+#endif
+
+	// VSync control
+	bool vsync = configuration->value("video/vsync", true).toBool();
+#if QT_VERSION >= QT_VERSION_CHECK(5,4,0)
+	// with the QOpenGLWidget, this seems to be needed on the default surface format before creating any windows
+	QSurfaceFormat defFmt = QSurfaceFormat::defaultFormat();
+	defFmt.setSwapInterval(vsync);
+	QSurfaceFormat::setDefaultFormat(defFmt);
+#endif
+
+	QSurfaceFormat widgetFormat = getDesiredGLFormat();
+	widgetFormat.setSwapInterval(vsync);
+	glWidget = new StelGLWidget(this);
+	//Set the surface format BEFORE showing the widget
+	//We could also set this as default format instead of just the widget's format,
+	//but I don't know if some background Qt stuff needs another buffer configuration or something,
+	//so let's be safe and just set it here
+#ifdef USE_OLD_QGLWIDGET
+	glWidget->setFormat(QGLFormat::fromSurfaceFormat(widgetFormat));
 #else
-	// Primary test for OpenGL existence
-	if (QGLFormat::openGLVersionFlags() < QGLFormat::OpenGL_Version_2_1)
-	{
-		qWarning() << "No OpenGL 2.1 support on this system. Aborting.";
-		QMessageBox::critical(0, "Stellarium", q_("No OpenGL 2 found on this system. Please upgrade hardware or use MESA or an older version."), QMessageBox::Abort, QMessageBox::Abort);
-		exit(1);
-	}
-
-	// Create an openGL viewport
-	QGLFormat glFormat(QGL::StencilBuffer | QGL::DepthBuffer | QGL::DoubleBuffer);
-	// Even if setting a version here, it may not be accepted in StelQGLWidget()!
-	// Currently, not setting a version explicitly works on Windows and Linux.
-	// Apparently some Macs have problems however and default to 2.1.
-	// We try a new CLI flag here which requests 3.3 Compatibiliy Profile which modern Macs should deliver.
-	// OpenGL Specs say this will deliver at least the requested version, if possible.
-	// TBD: Maybe this must make a differentiation between OpenGL and OpenGL ES!
-	// TBD: If this works for Mac, it should be requested on all Macs without CLI option!
-	if (qApp->property("onetime_compat33")==true)
-	{
-		if (!(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_3_3))
-		{
-			qWarning() << "No OpenGL 3.3 found here. We will get whatever is available.";
-			qDebug()   << "FYI: OpenGL Versions Supported: " << QGLFormat::openGLVersionFlags();
-		}
-		glFormat.setVersion(3, 3);
-		glFormat.setProfile(QGLFormat::CompatibilityProfile);
-	}
-	QGLContext* context=new QGLContext(glFormat);
-
-	if (context->format() != glFormat)
-	{
-		qWarning() << "Cannot provide requested OpenGL format. Apparently insufficient OpenGL resources on this system.";
-		QMessageBox::critical(0, "Stellarium", q_("Cannot acquire necessary OpenGL resources."), QMessageBox::Abort, QMessageBox::Abort);
-		exit(1);
-	}
-	glWidget = new StelQGLWidget(context, this);
-	if (qApp->property("onetime_compat33")==true)
-	{
-		// This may not return the version number set previously!
-		qDebug() << "StelQGLWidget context format version:" << glWidget->context()->format().majorVersion() << "." << glWidget->context()->format().minorVersion();
-		qDebug() << "StelQGLWidget has CompatibilityProfile:" << (glWidget->context()->format().profile()==QGLFormat::CompatibilityProfile ? "yes" : "no") << "(" <<glWidget->context()->format().profile() << ")";
-	}
+	glWidget->setFormat(widgetFormat);
 #endif
-
 	setViewport(glWidget);
 
-	setScene(new QGraphicsScene(this));
+	stelScene = new StelGraphicsScene(this);
+	setScene(stelScene);
 	scene()->setItemIndexMethod(QGraphicsScene::NoIndex);
-	rootItem = new QGraphicsWidget();
-	rootItem->setFocusPolicy(Qt::NoFocus);
+	rootItem = new StelRootItem(this);
 
 	// Workaround (see Bug #940638) Although we have already explicitly set
 	// LC_NUMERIC to "C" in main.cpp there seems to be a bug in OpenGL where
@@ -529,79 +585,157 @@
 	// circumstances, so here we set it again just to be on the safe side.
 	setlocale(LC_NUMERIC, "C");
 	// End workaround
+
+#ifdef USE_OLD_QGLWIDGET
+	// StelGLWidget::initializeGL is seemingly never called automatically with the QGLWidget, so we have to do it ourselves
+	//we have to force context creation here
+	glWidget->makeCurrent();
+	glWidget->initializeGL();
+#endif
 }
 
 void StelMainView::resizeEvent(QResizeEvent* event)
 {
-	scene()->setSceneRect(QRect(QPoint(0, 0), event->size()));
-	rootItem->setGeometry(0,0,event->size().width(),event->size().height());
+	if(scene())
+	{
+		const QSize& sz = event->size();
+		scene()->setSceneRect(QRect(QPoint(0, 0), sz));
+		rootItem->setSize(sz);
+		if(guiItem)
+			guiItem->setGeometry(QRectF(0.0f,0.0f,sz.width(),sz.height()));
+	}
 	QGraphicsView::resizeEvent(event);
 }
 
 void StelMainView::focusSky() {
-	scene()->setActiveWindow(0);
-	skyItem->setFocus();
+	//scene()->setActiveWindow(0);
+	rootItem->setFocus();
 }
 
 StelMainView::~StelMainView()
 {
+	//delete the night view graphic effect here while GL context is still valid
+	rootItem->setGraphicsEffect(Q_NULLPTR);
 	StelApp::deinitStatic();
 }
 
-void StelMainView::init(QSettings* conf)
-{
+QSurfaceFormat StelMainView::getDesiredGLFormat() const
+{
+#if QT_VERSION < QT_VERSION_CHECK(5,4,0)
+	//default-constructed format
+	QSurfaceFormat fmt;
+#else
+	//use the default format as basis
+	QSurfaceFormat fmt = QSurfaceFormat::defaultFormat();
+	qDebug()<<"Default surface format: "<<fmt;
+#endif
+
+	//if on an GLES build, do not set the format
+#ifndef QT_OPENGL_ES_2
+	// OGL 2.1 + FBOs should basically be the minimum required for Stellarium
+	fmt.setRenderableType(QSurfaceFormat::OpenGL);
+	fmt.setMajorVersion(2);
+	fmt.setMinorVersion(1);
+
+	// The following is NOT needed (or even supported) when we request a 2.1 context
+	// The implementation may give us a newer context,
+	// but compatibility with 2.1 should be ensured automatically
+	//fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
+	//fmt.setOption(QSurfaceFormat::DeprecatedFunctions);
+#endif
+
+	//request some sane buffer formats
+	fmt.setRedBufferSize(8);
+	fmt.setGreenBufferSize(8);
+	fmt.setBlueBufferSize(8);
+	fmt.setAlphaBufferSize(8);
+	fmt.setDepthBufferSize(24);
+	//I dont think we use the stencil buffer for anything
+	//but maybe Qt needs it
+	fmt.setStencilBufferSize(8);
+
+#ifdef OPENGL_DEBUG_LOGGING
+	//try to enable GL debugging using GL_KHR_debug
+	fmt.setOption(QSurfaceFormat::DebugContext);
+#endif
+	//vsync needs to be set on the default format for it to work
+	//fmt.setSwapInterval(0);
+
+	qDebug()<<"Desired surface format: "<<fmt;
+	return fmt;
+}
+
+void StelMainView::init()
+{
+#ifdef OPENGL_DEBUG_LOGGING
+	if(!QOpenGLContext::currentContext()->hasExtension(QByteArrayLiteral("GL_KHR_debug")))
+		qWarning()<<"GL_KHR_debug extension missing, OpenGL debug logger will likely not work";
+	if(glLogger->initialize())
+	{
+		qDebug()<<"OpenGL debug logger initialized";
+		QVector<GLuint> disabledMsgs;
+		//if your GL implementation spams some output you are not interested in,
+		//you can disable their message IDs here
+		//disabledMsgs.append(100);
+		glLogger->disableMessages(disabledMsgs);
+		glLogger->startLogging(QOpenGLDebugLogger::SynchronousLogging);
+		//the internal log buffer may not be empty, so check it
+		foreach(const QOpenGLDebugMessage& msg, glLogger->loggedMessages())
+		{
+			logGLMessage(msg);
+		}
+	}
+	else
+		qWarning()<<"Failed to initialize OpenGL debug logger";
+
+	connect(QOpenGLContext::currentContext(),SIGNAL(aboutToBeDestroyed()),this,SLOT(contextDestroyed()));
+	//for easier debugging, print the adress of the main GL context
+	qDebug()<<"CurCtxPtr:"<<QOpenGLContext::currentContext();
+#endif
+
+	qDebug()<<"StelMainView::init";
+
+	glInfo.mainContext = QOpenGLContext::currentContext();
+	glInfo.functions = glInfo.mainContext->functions();
+	glInfo.vendor = QString(reinterpret_cast<const char*>(glInfo.functions->glGetString(GL_VENDOR)));
+	glInfo.renderer = QString(reinterpret_cast<const char*>(glInfo.functions->glGetString(GL_RENDERER)));
+
 	gui = new StelGui();
 
-#if STEL_USE_NEW_OPENGL_WIDGETS
-	//glWidget->initializeGL(); // protected...
-	//Q_ASSERT(glWidget->isValid());
-#else
-	Q_ASSERT(glWidget->isValid());
-	glWidget->makeCurrent();
-#endif
+	QSettings* conf = configuration;
 
 	// Should be check of requirements disabled?
 	if (conf->value("main/check_requirements", true).toBool())
 	{
 		// Find out lots of debug info about supported version of OpenGL and vendor/renderer.
-		processOpenGLdiagnosticsAndWarnings(conf, glWidget);
+		processOpenGLdiagnosticsAndWarnings(conf, QOpenGLContext::currentContext());
 	}
 
-
-	stelApp= new StelApp();
+	//create and initialize main app
+	stelApp = new StelApp(this);
 	stelApp->setGui(gui);
 
 	stelApp->init(conf);
+	//this makes sure the app knows how large the window is
+	connect(stelScene,SIGNAL(sceneRectChanged(QRectF)),stelApp,SLOT(glWindowHasBeenResized(QRectF)));
+	//also immediately set the current values
+	stelApp->glWindowHasBeenResized(stelScene->sceneRect());
+
 	StelActionMgr *actionMgr = stelApp->getStelActionManager();
 	actionMgr->addAction("actionSave_Screenshot_Global", N_("Miscellaneous"), N_("Save screenshot"), this, "saveScreenShot()", "Ctrl+S");
 	actionMgr->addAction("actionSet_Full_Screen_Global", N_("Display Options"), N_("Full-screen mode"), this, "fullScreen", "F11");
 	
 	StelPainter::initGLShaders();
 
-	skyItem = new StelSkyItem();
-	guiItem = new StelGuiItem();
-	QGraphicsAnchorLayout* l = new QGraphicsAnchorLayout(rootItem);
-	l->setSpacing(0);
-	l->setContentsMargins(0,0,0,0);
-	l->addCornerAnchors(skyItem, Qt::TopLeftCorner, l, Qt::TopLeftCorner);
-	l->addCornerAnchors(skyItem, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
-	l->addCornerAnchors(guiItem, Qt::BottomLeftCorner, l, Qt::BottomLeftCorner);
-	l->addCornerAnchors(guiItem, Qt::TopRightCorner, l, Qt::TopRightCorner);
-	rootItem->setLayout(l);
+	guiItem = new StelGuiItem(rootItem);
 	scene()->addItem(rootItem);
+	//set the default focus to the sky
+	focusSky();
 	nightModeEffect = new NightModeGraphicsEffect(this);
 	updateNightModeProperty(StelApp::getInstance().getVisionModeNight());
+	//install the effect on the whole view
 	rootItem->setGraphicsEffect(nightModeEffect);
 
-	QSize size = glWidget->windowHandle()->screen()->size();
-	size = QSize(conf->value("video/screen_w", size.width()).toInt(),
-		     conf->value("video/screen_h", size.height()).toInt());
-
-	bool fullscreen = conf->value("video/fullscreen", true).toBool();
-
-	// Without this, the screen is not shown on a Mac + we should use resize() for correct work of fullscreen/windowed mode switch. --AW WTF???
-	resize(size);
-
 	QDesktopWidget *desktop = QApplication::desktop();
 	int screen = conf->value("video/screen_number", 0).toInt();
 	if (screen < 0 || screen >= desktop->screenCount())
@@ -611,6 +745,14 @@
 	}
 	QRect screenGeom = desktop->screenGeometry(screen);
 
+	QSize size = QSize(conf->value("video/screen_w", screenGeom.width()).toInt(),
+		     conf->value("video/screen_h", screenGeom.height()).toInt());
+
+	bool fullscreen = conf->value("video/fullscreen", true).toBool();
+
+	// Without this, the screen is not shown on a Mac + we should use resize() for correct work of fullscreen/windowed mode switch. --AW WTF???
+	resize(size);
+
 	if (fullscreen)
 	{
 		// The "+1" below is to work around Linux/Gnome problem with mouse focus.
@@ -632,26 +774,23 @@
 	flagInvertScreenShotColors = conf->value("main/invert_screenshots_colors", false).toBool();
 	setFlagCursorTimeout(conf->value("gui/flag_mouse_cursor_timeout", false).toBool());
 	setCursorTimeout(conf->value("gui/mouse_cursor_timeout", 10.f).toFloat());
-	maxfps = conf->value("video/maximum_fps",10000.f).toFloat();
-	minfps = conf->value("video/minimum_fps",10000.f).toFloat();
-	flagMaxFpsUpdatePending = false;
+	setMaxFps(conf->value("video/maximum_fps",10000.f).toFloat());
+	setMinFps(conf->value("video/minimum_fps",10000.f).toFloat());
 
 	// XXX: This should be done in StelApp::init(), unfortunately for the moment we need to init the gui before the
 	// plugins, because the gui creates the QActions needed by some plugins.
-	StelApp::getInstance().initPlugIns();
-
-	// activate DE430/431 
-	StelApp::getInstance().getCore()->initEphemeridesFunctions();
+	stelApp->initPlugIns();
 
 	// The script manager can only be fully initialized after the plugins have loaded.
-	StelApp::getInstance().initScriptMgr();
+	stelApp->initScriptMgr();
 
 	// Set the global stylesheet, this is only useful for the tooltips.
-	StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
+	StelGui* gui = dynamic_cast<StelGui*>(stelApp->getGui());
 	if (gui!=NULL)
 		setStyleSheet(gui->getStelStyle().qtStyleSheet);
-	connect(&StelApp::getInstance(), SIGNAL(visionNightModeChanged(bool)), this, SLOT(updateNightModeProperty(bool)));
+	connect(stelApp, SIGNAL(visionNightModeChanged(bool)), this, SLOT(updateNightModeProperty(bool)));
 
+	// I doubt this will have any effect on framerate, but may cause problems elsewhere?
 	QThread::currentThread()->setPriority(QThread::HighestPriority);
 #ifndef NDEBUG
 	// Get an overview of module callOrders
@@ -664,7 +803,6 @@
 		StelApp::getInstance().dumpModuleActionPriorities(StelModule::ActionHandleKeys);
 	}
 #endif
-	startMainLoop();
 }
 
 void StelMainView::updateNightModeProperty(bool b)
@@ -680,17 +818,11 @@
 // If problems are detected, warn the user one time, but continue. Warning panel will be suppressed on next start.
 // Work in progress, as long as we get reports about bad systems or until OpenGL startup is finalized and safe.
 // Several tests do not apply to MacOS X.
-#if STEL_USE_NEW_OPENGL_WIDGETS
-	void StelMainView::processOpenGLdiagnosticsAndWarnings(QSettings *conf, StelQOpenGLWidget* glWidget) const
-#else
-	void StelMainView::processOpenGLdiagnosticsAndWarnings(QSettings *conf, StelQGLWidget* glWidget) const
-#endif
+void StelMainView::processOpenGLdiagnosticsAndWarnings(QSettings *conf, QOpenGLContext *context) const
 {
 #ifdef Q_OS_MAC
 	Q_UNUSED(conf);
 #endif
-
-	QOpenGLContext* context=glWidget->context()->contextHandle();
 	QSurfaceFormat format=context->format();
 
 	// These tests are not required on MacOS X
@@ -706,12 +838,13 @@
 		qDebug() << "Neither OpenGL nor OpenGL ES detected: Unsupported Format!";
 	}
 #endif
+	QOpenGLFunctions* gl = context->functions();
 
-	QString glDriver(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+	QString glDriver(reinterpret_cast<const char*>(gl->glGetString(GL_VERSION)));
 	qDebug() << "Driver version string:" << glDriver;
-	qDebug() << "GL vendor is" << QString(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
-	QString glRenderer(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
-	qDebug() << "GL renderer is" << glRenderer;	
+	qDebug() << "GL vendor is" << QString(reinterpret_cast<const char*>(gl->glGetString(GL_VENDOR)));
+	QString glRenderer(reinterpret_cast<const char*>(gl->glGetString(GL_RENDERER)));
+	qDebug() << "GL renderer is" << glRenderer;
 
 	// Minimal required version of OpenGL for Qt5 is 2.1 and OpenGL Shading Language may be 1.20 (or OpenGL ES is 2.0 and GLSL ES is 1.0).
 	// As of V0.13.0..1, we use GLSL 1.10/GLSL ES 1.00 (implicitly, by omitting a #version line), but in case of using ANGLE we need hardware
@@ -739,7 +872,7 @@
 			qWarning() << "Oops... Insufficient OpenGL version. Mesa failed! Please send a bug report.";
 
 		QMessageBox::critical(0, "Stellarium", q_("Insufficient OpenGL version. Please update drivers, graphics hardware, or use --angle-mode (or --mesa-mode) option."), QMessageBox::Abort, QMessageBox::Abort);
-		#else		
+		#else
 		qWarning() << "Oops... Insufficient OpenGL version. Please update drivers, or graphics hardware.";
 		QMessageBox::critical(0, "Stellarium", q_("Insufficient OpenGL version. Please update drivers, or graphics hardware."), QMessageBox::Abort, QMessageBox::Abort);
 		#endif
@@ -747,7 +880,7 @@
 	}
 #endif
 	// This call requires OpenGL2+.
-	QString glslString(reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION)));
+	QString glslString(reinterpret_cast<const char*>(gl->glGetString(GL_SHADING_LANGUAGE_VERSION)));
 	qDebug() << "GL Shading Language version is" << glslString;
 
 	// Only give extended info if called on command line, for diagnostic.
@@ -1034,6 +1167,7 @@
 
 void StelMainView::deinit()
 {
+	glContextMakeCurrent();
 	deinitGL();
 	delete stelApp;
 	stelApp = NULL;
@@ -1057,7 +1191,7 @@
 		// Therefore moving is not possible. We must move to the stored position or at least defaults.
 		if ( (x()<0)  && (y()<0))
 		{
-			QSettings *conf = StelApp::getInstance().getSettings();
+			QSettings *conf = stelApp->getSettings();
 			QDesktopWidget *desktop = QApplication::desktop();
 			int screen = conf->value("video/screen_number", 0).toInt();
 			if (screen < 0 || screen >= desktop->screenCount())
@@ -1074,118 +1208,66 @@
 	emit fullScreenChanged(b);
 }
 
-void StelMainView::updateScene() {
-	// For some reason the skyItem is not updated when the night mode shader is on.
-	// To fix this we manually do it here.
-	skyItem->update();
-	scene()->update();
-}
+void StelMainView::drawEnded()
+{
+	updateQueued = false;
+
+	//requeue the next draw
+	if(needsMaxFPS())
+	{
+		updateQueued = true;
+		minFpsTimer->stop();
+		glWidget->update();
+	}
+	else
+	{
+		if(!minFpsTimer->isActive())
+			minFpsTimer->start();
+	}
+}
+
+void StelMainView::minFPSUpdate()
+{
+	if(!updateQueued)
+	{
+		updateQueued = true;
+		//qDebug()<<"minFPSUpdate";
+		glWidget->update();
+	}
+	else
+	{
+		//qDebug()<<"double update";
+	}
+}
+
+#ifdef OPENGL_DEBUG_LOGGING
+void StelMainView::logGLMessage(const QOpenGLDebugMessage &debugMessage)
+{
+	qDebug()<<debugMessage;
+}
+
+void StelMainView::contextDestroyed()
+{
+	qDebug()<<"Main OpenGL context destroyed";
+}
+#endif
 
 void StelMainView::thereWasAnEvent()
 {
+	//qDebug()<<"event";
 	lastEventTimeSec = StelApp::getTotalRunTime();
 }
 
-void StelMainView::maxFpsSceneUpdate()
-{
-	updateScene();
-	flagMaxFpsUpdatePending = false;
-}
-
-void StelMainView::drawBackground(QPainter*, const QRectF&)
+bool StelMainView::needsMaxFPS() const
 {
 	const double now = StelApp::getTotalRunTime();
-	const double JD_SECOND=0.000011574074074074074074;
 
 	// Determines when the next display will need to be triggered
 	// The current policy is that after an event, the FPS is maximum for 2.5 seconds
 	// after that, it switches back to the default minfps value to save power.
 	// The fps is also kept to max if the timerate is higher than normal speed.
-	const float timeRate = StelApp::getInstance().getCore()->getTimeRate();
-	const bool needMaxFps = (now - lastEventTimeSec < 2.5) || fabs(timeRate) > JD_SECOND;
-	if (needMaxFps)
-	{
-		if (!flagMaxFpsUpdatePending)
-		{
-			double duration = 1./getMaxFps();
-			int dur = (int)(duration*1000);
-
-			if (minFpsTimer!=NULL)
-			{
-				disconnect(minFpsTimer, SIGNAL(timeout()), 0, 0);
-				delete minFpsTimer;
-				minFpsTimer = NULL;
-			}
-			flagMaxFpsUpdatePending = true;
-			QTimer::singleShot(dur<5 ? 5 : dur, this, SLOT(maxFpsSceneUpdate()));
-		}
-	} else if (minFpsTimer == NULL) {
-		// Restart the minfps timer
-		minFpsChanged();
-	}
-
-	// Manage cursor timeout
-	if (cursorTimeout>0.f && (now-lastEventTimeSec>cursorTimeout) && flagCursorTimeout)
-	{
-		if (QGuiApplication::overrideCursor()==0)
-			QGuiApplication::setOverrideCursor(Qt::BlankCursor);
-	}
-	else
-	{
-		if (QGuiApplication::overrideCursor()!=0)
-			QGuiApplication::restoreOverrideCursor();
-	}
-}
-
-void StelMainView::startMainLoop()
-{
-	// Set a timer refreshing for every minfps frames
-	minFpsChanged();
-}
-
-void StelMainView::minFpsChanged()
-{
-	if (minFpsTimer!=NULL)
-	{
-		disconnect(minFpsTimer, SIGNAL(timeout()), 0, 0);
-		delete minFpsTimer;
-		minFpsTimer = NULL;
-	}
-
-	minFpsTimer = new QTimer(this);
-	connect(minFpsTimer, SIGNAL(timeout()), this, SLOT(updateScene()));
-
-	minFpsTimer->start((int)(1./getMinFps()*1000.));
-}
-
-
-
-void StelMainView::mouseMoveEvent(QMouseEvent* event)
-{
-	// We notify the application to increase the fps if a button has been
-	// clicked, but also if the cursor is currently hidden, so that it gets
-	// restored.
-	if (event->buttons() || QGuiApplication::overrideCursor()!=0)
-		thereWasAnEvent(); // Refresh screen ASAP
-	QGraphicsView::mouseMoveEvent(event);
-}
-
-void StelMainView::mousePressEvent(QMouseEvent* event)
-{
-	thereWasAnEvent(); // Refresh screen ASAP
-	QGraphicsView::mousePressEvent(event);
-}
-
-void StelMainView::mouseReleaseEvent(QMouseEvent* event)
-{
-	thereWasAnEvent(); // Refresh screen ASAP
-	QGraphicsView::mouseReleaseEvent(event);	
-}
-
-void StelMainView::wheelEvent(QWheelEvent* event)
-{
-	thereWasAnEvent(); // Refresh screen ASAP
-	QGraphicsView::wheelEvent(event);
+	const float timeRate = stelApp->getCore()->getTimeRate();
+	return (now - lastEventTimeSec < 2.5) || fabs(timeRate) > StelCore::JD_SECOND;
 }
 
 void StelMainView::moveEvent(QMoveEvent * event)
@@ -1193,38 +1275,21 @@
 	Q_UNUSED(event);
 
 	// We use the glWidget instead of the event, as we want the screen that shows most of the widget.
-	StelApp::getInstance().setDevicePixelsPerPixel(glWidget->windowHandle()->devicePixelRatio());
+	QWindow* win = glWidget->windowHandle();
+	if(win)
+		stelApp->setDevicePixelsPerPixel(win->devicePixelRatio());
 }
 
 void StelMainView::closeEvent(QCloseEvent* event)
 {
 	Q_UNUSED(event);
-	StelApp::getInstance().quit();
-}
-
-void StelMainView::keyPressEvent(QKeyEvent* event)
-{
-	thereWasAnEvent(); // Refresh screen ASAP
-	// Try to trigger a gobal shortcut.
-	StelActionMgr* actionMgr = StelApp::getInstance().getStelActionManager();
-	if (actionMgr->pushKey(event->key() + event->modifiers(), true)) {
-		event->setAccepted(true);
-		return;
-	}
-	QGraphicsView::keyPressEvent(event);
-}
-
-void StelMainView::keyReleaseEvent(QKeyEvent* event)
-{
-	thereWasAnEvent(); // Refresh screen ASAP
-	QGraphicsView::keyReleaseEvent(event);	
-}
-
+	stelApp->quit();
+}
 
 //! Delete openGL textures (to call before the GLContext disappears)
 void StelMainView::deinitGL()
 {
-	StelApp::getInstance().deinit();
+	stelApp->deinit();
 	delete gui;
 	gui = NULL;
 }
@@ -1240,11 +1305,12 @@
 void StelMainView::doScreenshot(void)
 {
 	QFileInfo shotDir;
-#if STEL_USE_NEW_OPENGL_WIDGETS
+#ifdef USE_OLD_QGLWIDGET
+	QImage im = glWidget->grabFrameBuffer();
+#else
 	QImage im = glWidget->grabFramebuffer();
-#else
-	QImage im = glWidget->grabFrameBuffer();
 #endif
+
 	if (flagInvertScreenShotColors)
 		im.invertPixels();
 
@@ -1289,7 +1355,21 @@
 	return glWidget->mapFromGlobal(QCursor::pos());
 }
 
-void StelMainView::setFocusOnSky()
-{
-	skyItem->setFocus();
+QOpenGLContext* StelMainView::glContext() const
+{
+#ifdef USE_OLD_QGLWIDGET
+	return glWidget->context()->contextHandle();
+#else
+	return glWidget->context();
+#endif
+}
+
+void StelMainView::glContextMakeCurrent()
+{
+	glWidget->makeCurrent();
+}
+
+void StelMainView::glContextDoneCurrent()
+{
+	glWidget->doneCurrent();
 }

=== modified file 'src/StelMainView.hpp'
--- src/StelMainView.hpp	2016-12-10 10:33:35 +0000
+++ src/StelMainView.hpp	2017-01-12 21:08:38 +0000
@@ -24,19 +24,13 @@
 #include <QGraphicsView>
 #include <QEventLoop>
 #include <QOpenGLContext>
-
-// This define (only used here and in StelMainView.cpp) is temporarily used
-// to allow uncompromised compiling while the migration to the new QOpenGL... classes
-// has not been done. As soon as Qt5.4 is out, we should finish this migration process!
-#define STEL_USE_NEW_OPENGL_WIDGETS 0
-
-#if STEL_USE_NEW_OPENGL_WIDGETS
-class QOpenGLWidget;
-class StelQOpenGLWidget;
-#else
-class QGLWidget;
-class StelQGLWidget;
+#include <QTimer>
+#ifdef OPENGL_DEBUG_LOGGING
+#include <QOpenGLDebugMessage>
 #endif
+
+class StelGLWidget;
+class StelGraphicsScene;
 class QMoveEvent;
 class QResizeEvent;
 class StelGuiBase;
@@ -49,16 +43,27 @@
 class StelMainView : public QGraphicsView
 {
 	friend class StelGuiItem;
-	friend class StelSkyItem;
+	friend class StelRootItem;
+	friend class StelGraphicsScene;
+	friend class NightModeGraphicsEffect;
 	Q_OBJECT
 	Q_PROPERTY(bool fullScreen READ isFullScreen WRITE setFullScreen NOTIFY fullScreenChanged)
 
 public:
-	StelMainView(QWidget* parent = NULL);
+	//! Contains some basic info about the OpenGL context used
+	struct GLInfo
+	{
+		QString vendor;
+		QString renderer;
+		QOpenGLContext* mainContext;
+		QOpenGLFunctions* functions;
+	};
+
+	StelMainView(QSettings* settings);
 	virtual ~StelMainView();
 
 	//! Start the main initialization of Stellarium
-	void init(class QSettings* conf);
+	void init();
 	void deinit();
 
 	//! Set the application title for the current language.
@@ -70,20 +75,33 @@
 
 	//! Delete openGL textures (to call before the GLContext disappears)
 	void deinitGL();
-	//! Return focus to the sky item.  To be used when we close a dialog.
-	void focusSky();
+
 	//! Return the parent gui widget, this should be used as parent to all
 	//! the StelDialog instances.
 	QGraphicsWidget* getGuiWidget() const {return guiItem;}
 	//! Return mouse position coordinates
 	QPoint getMousePos();
+
+	//! Returns the main application OpenGL context,
+	//! which should be used for all drawing Stellarium does
+	//! @sa glContextMakeCurrent()
+	//! @sa glContextDoneCurrent()
+	QOpenGLContext* glContext() const;
+	//! Make the main GL context (the one returned from glContext()) current
+	//! on the main view surface
+	void glContextMakeCurrent();
+	//! Releases the main GL context
+	void glContextDoneCurrent();
+
+	//! Returns the information about the GL context, this does not require the context to be active.
+	GLInfo getGLInformation() const { return glInfo; }
 public slots:
 
 	//! Set whether fullscreen is activated or not
 	void setFullScreen(bool);
 
-	//! Set focus on the sky
-	void setFocusOnSky();
+	//! Return focus to the sky item.  To be used when we close a dialog.
+	void focusSky();
 
 	///////////////////////////////////////////////////////////////////////////
 	// Specific methods
@@ -119,82 +137,86 @@
 	//! user events for some seconds to save power. However, if can be useful to set this to a high
 	//! value to improve playing smoothness in scripts.
 	//! @param m the new minimum fps setting.
-	void setMinFps(float m) {minfps=m; minFpsChanged();}
+	void setMinFps(float m) {minfps=m; minFpsTimer->setInterval(1000/minfps);}
 	//! Get the current minimum frames per second.
 	float getMinFps() {return minfps;}
 	//! Set the maximum frames per second.
 	//! @param m the new maximum fps setting.
+	//! @todo this setting currently does nothing
 	void setMaxFps(float m) {maxfps = m;}
 	//! Get the current maximum frames per second.
 	float getMaxFps() {return maxfps;}
 
-	void maxFpsSceneUpdate();
-	//! Updates the scene and process all events
-	void updateScene();
-
 	//! Notify that an event was handled by the program and therefore the
 	//! FPS should be maximized for a couple of seconds.
 	void thereWasAnEvent();
 
+	//! Determines if we should render as fast as possible,
+	//! or limit the FPS. This depends on the time the last user event
+	//! happened.
+	bool needsMaxFPS() const;
+
 protected:
-	virtual void mouseMoveEvent(QMouseEvent* event);
-	virtual void mousePressEvent(QMouseEvent* event);
-	virtual void mouseReleaseEvent(QMouseEvent* event);
-	virtual void keyPressEvent(QKeyEvent* event);
-	virtual void keyReleaseEvent(QKeyEvent* event);
-	virtual void wheelEvent(QWheelEvent* wheelEvent);
-	virtual void moveEvent(QMoveEvent* event);
-	virtual void closeEvent(QCloseEvent* event);
-	virtual void resizeEvent(QResizeEvent* event);
-
-	//! Update the mouse pointer state and schedule next redraw.
-	//! This method is called automatically by Qt.
-	virtual void drawBackground(QPainter* painter, const QRectF &rect);
-
+	//! Hack to determine current monitor pixel ratio
+	//! @todo Find a better way to handle this
+	virtual void moveEvent(QMoveEvent* event) Q_DECL_OVERRIDE;
+	//! Handle window closed event, calling StelApp::quit()
+	virtual void closeEvent(QCloseEvent* event) Q_DECL_OVERRIDE;
+	//! Handle window resized events, and change the size of the underlying
+	//! QGraphicsScene to be the same
+	virtual void resizeEvent(QResizeEvent* event) Q_DECL_OVERRIDE;
 signals:
 	//! emitted when saveScreenShot is requested with saveScreenShot().
 	//! doScreenshot() does the actual work (it has to do it in the main
 	//! thread, where as saveScreenShot() might get called from another one.
+	//!
+	//! @remark FS: is threaded access here even a possibility anymore, or a remnant of older code?
 	void screenshotRequested(void);
 	void fullScreenChanged(bool b);
-
 private slots:
 	// Do the actual screenshot generation in the main thread with this method.
 	void doScreenshot(void);
-	void minFpsChanged();
+	void minFPSUpdate();
+#ifdef OPENGL_DEBUG_LOGGING
+	void logGLMessage(const QOpenGLDebugMessage& debugMessage);
+	void contextDestroyed();
+#endif
 	void updateNightModeProperty(bool b);
 
 private:
-	//! Start the display loop
-	void startMainLoop();
-	
+	//! The graphics scene notifies us when a draw finished, so that we can queue the next one
+	void drawEnded();
+	//! Returns the desired OpenGL format settings,
+	//! on desktop this corresponds to a GL 2.1 context,
+	//! with 32bit RGBA buffer and 24/8 depth/stencil buffer
+	QSurfaceFormat getDesiredGLFormat() const;
 	//! provide extended OpenGL diagnostics in logfile.
 	void dumpOpenGLdiagnostics() const;
 	//! Startup diagnostics, providing test for various circumstances of bad OS/OpenGL driver combinations
 	//! to provide feedback to the user about bad OpenGL drivers.
-#if STEL_USE_NEW_OPENGL_WIDGETS
-	void processOpenGLdiagnosticsAndWarnings(QSettings *conf, StelQOpenGLWidget* glWidget) const;
-#else
-	void processOpenGLdiagnosticsAndWarnings(QSettings *conf, StelQGLWidget* glWidget) const;
-#endif
+	void processOpenGLdiagnosticsAndWarnings(QSettings *conf, QOpenGLContext* context) const;
 
 	//! The StelMainView singleton
 	static StelMainView* singleton;
 
-	QGraphicsWidget* rootItem;
-	QGraphicsWidget* skyItem;
+	GLInfo glInfo;
+
+	QSettings* configuration;
+
+	class StelRootItem* rootItem;
 	QGraphicsWidget* guiItem;
 	QGraphicsEffect* nightModeEffect;
 
-	//! The openGL window
-#if STEL_USE_NEW_OPENGL_WIDGETS
-	StelQOpenGLWidget* glWidget;
-#else
-	StelQGLWidget* glWidget;
-#endif
+	//! The openGL viewport of the graphics scene
+	//! Responsible for main GL setup, rendering is done in the scene background
+	StelGLWidget* glWidget;
+	//! Custom QGraphicsScene, this renders our scene background
+	StelGraphicsScene* stelScene;
+
 	StelGuiBase* gui;
 	class StelApp* stelApp;
 
+	bool updateQueued;
 	bool flagInvertScreenShotColors;
 	bool flagOverwriteScreenshots; //! if set to true, screenshot is named exactly screenShotPrefix.png and overwrites existing file
 
@@ -207,12 +229,15 @@
 
 	double lastEventTimeSec;
 
-	QTimer* minFpsTimer;
-	bool flagMaxFpsUpdatePending;
 	//! The minimum desired frame rate in frame per second.
 	float minfps;
 	//! The maximum desired frame rate in frame per second.
 	float maxfps;
+	QTimer* minFpsTimer;
+
+#ifdef OPENGL_DEBUG_LOGGING
+	QOpenGLDebugLogger* glLogger;
+#endif
 };
 
 

=== modified file 'src/core/OctahedronPolygon.cpp'
--- src/core/OctahedronPolygon.cpp	2015-03-24 16:31:04 +0000
+++ src/core/OctahedronPolygon.cpp	2017-01-12 21:08:38 +0000
@@ -91,7 +91,7 @@
 	}
 	res[res.size()-1]=']';
 	return res;
-};
+}
 
 OctahedronPolygon::OctahedronPolygon(const QVector<Vec3d>& contour) : fillCachedVertexArray(StelVertexArray::Triangles), outlineCachedVertexArray(StelVertexArray::Lines)
 {

=== modified file 'src/core/SpoutSender.cpp'
--- src/core/SpoutSender.cpp	2016-12-18 22:26:48 +0000
+++ src/core/SpoutSender.cpp	2017-01-12 21:08:38 +0000
@@ -18,7 +18,7 @@
  */
 
 #include "SpoutSender.hpp"
-#include "SpoutLibrary.h"
+#include "../../external/SpoutLibrary.h"
 
 Q_LOGGING_CATEGORY(spout,"stel.spout")
 

=== modified file 'src/core/StelApp.cpp'
--- src/core/StelApp.cpp	2017-01-09 17:24:41 +0000
+++ src/core/StelApp.cpp	2017-01-12 21:08:38 +0000
@@ -20,6 +20,7 @@
 #include "StelApp.hpp"
 
 #include "StelCore.hpp"
+#include "StelMainView.hpp"
 #include "StelUtils.hpp"
 #include "StelTextureMgr.hpp"
 #include "StelObjectMgr.hpp"
@@ -202,9 +203,10 @@
 /*************************************************************************
  Create and initialize the main Stellarium application.
 *************************************************************************/
-StelApp::StelApp(QObject* parent)
+StelApp::StelApp(StelMainView *parent)
 	: QObject(parent)
-	, core(NULL)	
+	, mainWin(parent)
+	, core(NULL)
 	, moduleMgr(NULL)
 	, localeMgr(NULL)
 	, skyCultureMgr(NULL)
@@ -226,8 +228,7 @@
 	, globalScalingRatio(1.f)
 	, fps(0)
 	, frame(0)
-	, timefr(0.)
-	, timeBase(0.)
+	, frameTimeAccum(0.)
 	, flagNightVision(false)
 	, confSettings(NULL)
 	, initialized(false)
@@ -390,6 +391,7 @@
 
 void StelApp::init(QSettings* conf)
 {
+	gl = QOpenGLContext::currentContext()->functions();
 	confSettings = conf;
 
 	devicePixelsPerPixel = QOpenGLContext::currentContext()->screen()->devicePixelRatio();
@@ -632,13 +634,13 @@
 		return;
 
 	++frame;
-	timefr+=deltaTime;
-	if (timefr-timeBase > 1.)
+	frameTimeAccum+=deltaTime;
+	if (frameTimeAccum > 1.)
 	{
 		// Calc the FPS rate every seconds
-		fps=(double)frame/(timefr-timeBase);
+		fps=(double)frame/frameTimeAccum;
 		frame = 0;
-		timeBase+=1.;
+		frameTimeAccum=0.;
 	}
 		
 	core->update(deltaTime);
@@ -668,11 +670,10 @@
 	renderBuffer->bind();
 }
 
-void StelApp::applyRenderBuffer(int drawFbo)
+void StelApp::applyRenderBuffer(GLuint drawFbo)
 {
 	if (!renderBuffer) return;
-	renderBuffer->release();
-	if (drawFbo) GL(glBindFramebuffer(GL_FRAMEBUFFER, drawFbo));
+	GL(gl->glBindFramebuffer(GL_FRAMEBUFFER, drawFbo));
 	viewportEffect->paintViewportBuffer(renderBuffer);
 }
 
@@ -682,11 +683,18 @@
 	if (!initialized)
 		return;
 
-	int drawFbo;
-	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &drawFbo);
+	//find out which framebuffer is the current one
+	//this is usually NOT the "zero" FBO, but one provided by QOpenGLWidget
+	GLint drawFbo;
+	GL(gl->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &drawFbo));
 
 	prepareRenderBuffer();
+	currentFbo = renderBuffer ? renderBuffer->handle() : drawFbo;
+
 	core->preDraw();
+	// Clear areas not redrawn by main viewport (i.e. fisheye square viewport)
+	GL(gl->glClearColor(0,0,0,0));
+	GL(gl->glClear(GL_COLOR_BUFFER_BIT));
 
 	const QList<StelModule*> modules = moduleMgr->getCallOrders(StelModule::ActionDraw);
 	foreach(StelModule* module, modules)
@@ -706,23 +714,24 @@
 /*************************************************************************
  Call this when the size of the GL window has changed
 *************************************************************************/
-void StelApp::glWindowHasBeenResized(float x, float y, float w, float h)
+void StelApp::glWindowHasBeenResized(const QRectF& rect)
 {
 	if (core)
-		core->windowHasBeenResized(x, y, w, h);
+		core->windowHasBeenResized(rect.x(), rect.y(), rect.width(), rect.height());
 	else
 	{
-		saveProjW = w;
-		saveProjH = h;
+		saveProjW = rect.width();
+		saveProjH = rect.height();
 	}
 	if (renderBuffer)
 	{
+		ensureGLContextCurrent();
 		delete renderBuffer;
 		renderBuffer = NULL;
 	}
 #ifdef ENABLE_SPOUT
 	if (spoutSender)
-		spoutSender->resize(w,h);
+		spoutSender->resize(rect.width(),rect.height());
 #endif
 }
 
@@ -788,7 +797,7 @@
 }
 
 // Handle mouse move
-void StelApp::handleMove(float x, float y, Qt::MouseButtons b)
+bool StelApp::handleMove(float x, float y, Qt::MouseButtons b)
 {
 	if (viewportEffect)
 		viewportEffect->distortXY(x, y);
@@ -796,8 +805,9 @@
 	foreach (StelModule* i, moduleMgr->getCallOrders(StelModule::ActionHandleMouseMoves))
 	{
 		if (i->handleMouseMoves(x*devicePixelsPerPixel, y*devicePixelsPerPixel, b))
-			return;
+			return true;
 	}
+	return false;
 }
 
 // Handle key press and release
@@ -857,6 +867,11 @@
 #endif
 }
 
+void StelApp::ensureGLContextCurrent()
+{
+	mainWin->glContextMakeCurrent();
+}
+
 // Return the time since when stellarium is running in second.
 double StelApp::getTotalRunTime()
 {
@@ -907,6 +922,7 @@
 	if (name == getViewportEffect()) return;
 	if (renderBuffer)
 	{
+		ensureGLContextCurrent();
 		delete renderBuffer;
 		renderBuffer = NULL;
 	}

=== modified file 'src/core/StelApp.hpp'
--- src/core/StelApp.hpp	2016-12-18 22:26:48 +0000
+++ src/core/StelApp.hpp	2017-01-12 21:08:38 +0000
@@ -30,9 +30,11 @@
 class StelObjectMgr;
 class StelLocaleMgr;
 class StelModuleMgr;
+class StelMainView;
 class StelSkyCultureMgr;
 class StelViewportEffect;
 class QOpenGLFramebufferObject;
+class QOpenGLFunctions;
 class QSettings;
 class QNetworkAccessManager;
 class QNetworkReply;
@@ -70,14 +72,14 @@
 
 public:
 	friend class StelAppGraphicsWidget;
-	friend class StelSkyItem;
+	friend class StelRootItem;
 
 	//! Create and initialize the main Stellarium application.
 	//! @param parent the QObject parent
 	//! The configFile will be search for in the search path by the StelFileMgr,
 	//! it is therefor possible to specify either just a file name or path within the
 	//! search path, or use a full path or even a relative path to an existing file
-	StelApp(QObject* parent=NULL);
+	StelApp(StelMainView* parent);
 
 	//! Deinitialize and destroy the main Stellarium application.
 	virtual ~StelApp();
@@ -160,9 +162,6 @@
 	// @return the max squared distance in pixels that any object has travelled since the last update.
 	void draw();
 
-	//! Call this when the size of the GL window has changed.
-	void glWindowHasBeenResized(float x, float y, float w, float h);
-
 	//! Get the ratio between real device pixel and "Device Independent Pixel".
 	//! Usually this value is 1, but for a mac with retina screen this will be value 2.
 	float getDevicePixelsPerPixel() const {return devicePixelsPerPixel;}
@@ -212,6 +211,8 @@
 	///////////////////////////////////////////////////////////////////////////
 	// Scriptable methods
 public slots:
+	//! Call this when the size of the GL window has changed.
+	void glWindowHasBeenResized(const QRectF &rect);
 
 	//! Set flag for activating night vision mode.
 	void setVisionModeNight(bool);
@@ -240,6 +241,17 @@
 	//! @return the FPS averaged on the last second
 	float getFps() const {return fps;}
 
+	//! Returns the default FBO handle, to be used when StelModule instances want to release their own FBOs.
+	//! Note that this is usually not the same as QOpenGLContext::defaultFramebufferObject(),
+	//! so use this call instead of the Qt version!
+	//! Valid through a StelModule::draw() call, do not use elsewhere.
+	quint32 getDefaultFBO() const { return currentFbo; }
+
+	//! Makes sure the correct GL context used for main drawing is made current.
+	//! This is always the case during init() and draw() calls, but if OpenGL access is required elsewhere,
+	//! this MUST be called before using any GL functions.
+	void ensureGLContextCurrent();
+
 	//! Return the time since when stellarium is running in second.
 	static double getTotalRunTime();
 
@@ -263,7 +275,6 @@
 	void progressBarRemoved(const StelProgressController*);
 	//! Called just before we exit Qt mainloop.
 	void aboutToQuit();
-
 private:
 
 	//! Handle mouse clics.
@@ -271,7 +282,7 @@
 	//! Handle mouse wheel.
 	void handleWheel(class QWheelEvent* event);
 	//! Handle mouse move.
-	void handleMove(float x, float y, Qt::MouseButtons b);
+	bool handleMove(float x, float y, Qt::MouseButtons b);
 	//! Handle key press and release.
 	void handleKeys(class QKeyEvent* event);
 	//! Handle pinch on multi touch devices.
@@ -281,11 +292,14 @@
 	void prepareRenderBuffer();
 	//! Used internally to set the viewport effects.
 	//! @param drawFbo the OpenGL fbo we need to render into.
-	void applyRenderBuffer(int drawFbo=0);
+	void applyRenderBuffer(quint32 drawFbo=0);
 
 	// The StelApp singleton
 	static StelApp* singleton;
 
+	//! The main window which is the parent of this object
+	StelMainView* mainWin;
+
 	// The associated StelCore instance
 	StelCore* core;
 
@@ -354,7 +368,7 @@
 
 	float fps;
 	int frame;
-	double timefr, timeBase;		// Used for fps counter
+	double frameTimeAccum;		// Used for fps counter
 
 	//! Define whether we are in night vision mode
 	bool flagNightVision;
@@ -388,8 +402,8 @@
 
 	// Framebuffer object used for viewport effects.
 	QOpenGLFramebufferObject* renderBuffer;
-
 	StelViewportEffect* viewportEffect;
+	QOpenGLFunctions* gl;
 	
 	bool flagShowDecimalDegrees;
 	// flag to indicate we want calculate azimuth from south towards west (as in old astronomical literature)
@@ -398,6 +412,9 @@
 	SpoutSender* spoutSender;
 #endif
 
+	// The current main FBO/render target handle, without requiring GL queries. Valid through a draw() call
+	quint32 currentFbo;
+
 };
 
 #endif // _STELAPP_HPP_

=== modified file 'src/core/StelCore.cpp'
--- src/core/StelCore.cpp	2017-01-06 13:26:03 +0000
+++ src/core/StelCore.cpp	2017-01-12 21:08:38 +0000
@@ -244,6 +244,9 @@
 	setCurrentProjectionTypeKey(getDefaultProjectionTypeKey());
 	updateMaximumFov();
 
+	// activate DE430/431
+	initEphemeridesFunctions();
+
 	// Register all the core actions.
 	QString timeGroup = N_("Date and Time");
 	QString movementGroup = N_("Movement and Selection");
@@ -503,10 +506,6 @@
 	currentProjectorParams.zFar = 500.;
 
 	skyDrawer->preDraw();
-
-	// Clear areas not redrawn by main viewport (i.e. fisheye square viewport)
-	glClearColor(0,0,0,0);
-	glClear(GL_COLOR_BUFFER_BIT);
 }
 
 

=== modified file 'src/core/StelOpenGL.cpp'
--- src/core/StelOpenGL.cpp	2014-06-11 15:48:31 +0000
+++ src/core/StelOpenGL.cpp	2017-01-12 21:08:38 +0000
@@ -16,10 +16,12 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#include <cstdio>
 #include "StelOpenGL.hpp"
-
-const char* getGLErrorText(int code) {
+#include <QDebug>
+
+QOpenGLContext* StelOpenGL::mainContext = NULL;
+
+const char* StelOpenGL::getGLErrorText(GLenum code) {
 	switch (code) {
 		case GL_INVALID_ENUM:
 			return "GL_INVALID_ENUM";
@@ -32,20 +34,18 @@
 		case GL_OUT_OF_MEMORY:
 			return "GL_OUT_OF_MEMORY";
 		default:
-			return "undefined error";
+			return "unknown GL error type";
 	}
 }
 
-int checkGLErrors(const char *file, int line)
+int StelOpenGL::checkGLErrors(const char *file, int line)
 {
 	int errors = 0;
-	while (true)
+	for(GLenum x; (x=mainContext->functions()->glGetError())!=GL_NO_ERROR; )
 	{
-		GLenum x = glGetError();
-		if (x == GL_NO_ERROR)
-			return errors;
-		printf("%s:%d: OpenGL error: %d (%s)\n",
-			file, line, x, getGLErrorText(x));
-		errors++;
+		++errors;
+		qCritical("%s:%d: OpenGL error: %d (%s)\n",
+			  file, line, x, getGLErrorText(x));
 	}
+	return errors;
 }

=== modified file 'src/core/StelOpenGL.hpp'
--- src/core/StelOpenGL.hpp	2016-12-10 10:33:35 +0000
+++ src/core/StelOpenGL.hpp	2017-01-12 21:08:38 +0000
@@ -1,6 +1,7 @@
 /*
  * Stellarium
  * Copyright (C) 2014 Fabien Chereau
+ * Copyright (C) 2016 Florian Schaukowitsch
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -20,185 +21,29 @@
 #ifndef _STELOPENGL_HPP_
 #define _STELOPENGL_HPP_
 
-#define GL_GLEXT_PROTOTYPES
-#include <qopengl.h>
-
 #include <QOpenGLFunctions>
 
-// On windows without ANGLE support, we should not directly call some
-// of the OpenGL functions, instead we have to use QOpenGLFunctions.
-//
-// Here we replace the functions with a macro that will invoke the proper
-// calls.
-#if defined(Q_OS_WIN) && !defined(Q_NO_OPENGL)
-#  define GLFUNC_(x) QOpenGLContext::currentContext()->functions()->x
-#else
-#  define GLFUNC_(x) x
-#endif
-
-#define glActiveTexture(...)        GLFUNC_(glActiveTexture(__VA_ARGS__))
-#define glAttachShader(...)         GLFUNC_(glAttachShader(__VA_ARGS__))
-#define glBindAttribLocation(...)   GLFUNC_(glBindAttribLocation(__VA_ARGS__))
-#define glBindBuffer(...)           GLFUNC_(glBindBuffer(__VA_ARGS__))
-#define glBindFramebuffer(...)      GLFUNC_(glBindFramebuffer(__VA_ARGS__))
-#define glBindRenderbuffer(...)     GLFUNC_(glBindRenderbuffer(__VA_ARGS__))
-#define glBlendColor(...)           GLFUNC_(glBlendColor(__VA_ARGS__))
-#define glBlendEquation(...)        GLFUNC_(glBlendEquation(__VA_ARGS__))
-#define glBlendEquationSeparate(...)    GLFUNC_(glBlendEquationSeparate(__VA_ARGS__))
-#define glBlendFuncSeparate(...)    GLFUNC_(glBlendFuncSeparate(__VA_ARGS__))
-#define glBufferData(...)           GLFUNC_(glBufferData(__VA_ARGS__))
-#define glBufferSubData(...)        GLFUNC_(glBufferSubData(__VA_ARGS__))
-#define glCheckFramebufferStatus(...)   GLFUNC_(glCheckFramebufferStatus(__VA_ARGS__))
-#define glClearDepthf(...)          GLFUNC_(glClearDepthf(__VA_ARGS__))
-#define glCompileShader(...)        GLFUNC_(glCompileShader(__VA_ARGS__))
-#define glCompressedTexImage2D(...) GLFUNC_(glCompressedTexImage2D(__VA_ARGS__))
-#define glCompressedTexSubImage2D(...)  GLFUNC_(glCompressedTexSubImage2D(__VA_ARGS__))
-#define glCopyTexSubImage2D(...)    GLFUNC_(glCopyTexSubImage2D(__VA_ARGS__)) // new for spout
-#define glCreateProgram(...)        GLFUNC_(glCreateProgram(__VA_ARGS__))
-#define glCreateShader(...)         GLFUNC_(glCreateShader(__VA_ARGS__))
-#define glDeleteBuffers(...)        GLFUNC_(glDeleteBuffers(__VA_ARGS__))
-#define glDeleteFramebuffers(...)   GLFUNC_(glDeleteFramebuffers(__VA_ARGS__))
-#define glDeleteProgram(...)        GLFUNC_(glDeleteProgram(__VA_ARGS__))
-#define glDeleteRenderbuffers(...)  GLFUNC_(glDeleteRenderbuffers(__VA_ARGS__))
-#define glDeleteShader(...)         GLFUNC_(glDeleteShader(__VA_ARGS__))
-#define glDepthRangef(...)          GLFUNC_(glDepthRangef(__VA_ARGS__))
-#define glDetachShader(...)         GLFUNC_(glDetachShader(__VA_ARGS__))
-#define glDisableVertexAttribArray(...) GLFUNC_(glDisableVertexAttribArray(__VA_ARGS__))
-#define glEnableVertexAttribArray(...)  GLFUNC_(glEnableVertexAttribArray(__VA_ARGS__))
-#define glFramebufferRenderbuffer(...)  GLFUNC_(glFramebufferRenderbuffer(__VA_ARGS__))
-#define glFramebufferTexture2D(...) GLFUNC_(glFramebufferTexture2D(__VA_ARGS__))
-#define glGenBuffers(...)           GLFUNC_(glGenBuffers(__VA_ARGS__))
-#define glGenerateMipmap(...)       GLFUNC_(glGenerateMipmap(__VA_ARGS__))
-#define glGenFramebuffers(...)      GLFUNC_(glGenFramebuffers(__VA_ARGS__))
-#define glGenRenderbuffers(...)     GLFUNC_(glGenRenderbuffers(__VA_ARGS__))
-#define glGetActiveAttrib(...)      GLFUNC_(glGetActiveAttrib(__VA_ARGS__))
-#define glGetActiveUniform(...)     GLFUNC_(glGetActiveUniform(__VA_ARGS__))
-#define glGetAttachedShaders(...)   GLFUNC_(glGetAttachedShaders(__VA_ARGS__))
-#define glGetAttribLocation(...)    GLFUNC_(glGetAttribLocation(__VA_ARGS__))
-#define glGetBufferParameteriv(...) GLFUNC_(glGetBufferParameteriv(__VA_ARGS__))
-#define glGetFramebufferAttachmentParameteriv(...)  GLFUNC_(glGetFramebufferAttachmentParameteriv(__VA_ARGS__))
-#define glGetProgramiv(...)         GLFUNC_(glGetProgramiv(__VA_ARGS__))
-#define glGetProgramInfoLog(...)    GLFUNC_(glGetProgramInfoLog(__VA_ARGS__))
-#define glGetRenderbufferParameteriv(...)   GLFUNC_(glGetRenderbufferParameteriv(__VA_ARGS__))
-#define glGetShaderiv(...)          GLFUNC_(glGetShaderiv(__VA_ARGS__))
-#define glGetShaderInfoLog(...)     GLFUNC_(glGetShaderInfoLog(__VA_ARGS__))
-#define glGetShaderPrecisionFormat(...) GLFUNC_(glGetShaderPrecisionFormat(__VA_ARGS__))
-#define glGetShaderSource(...)      GLFUNC_(glGetShaderSource(__VA_ARGS__))
-#define glGetUniformfv(...)         GLFUNC_(glGetUniformfv(__VA_ARGS__))
-#define glGetUniformiv(...)         GLFUNC_(glGetUniformiv(__VA_ARGS__))
-#define glGetUniformLocation(...)   GLFUNC_(glGetUniformLocation(__VA_ARGS__))
-#define glGetVertexAttribfv(...)    GLFUNC_(glGetVertexAttribfv(__VA_ARGS__))
-#define glGetVertexAttribiv(...)    GLFUNC_(glGetVertexAttribiv(__VA_ARGS__))
-#define glGetVertexAttribPointerv(...)  GLFUNC_(glGetVertexAttribPointerv(__VA_ARGS__))
-#define glIsBuffer(...) GLFUNC_(glIsBuffer(__VA_ARGS__))
-#define glIsFramebuffer(...)        GLFUNC_(glIsFramebuffer(__VA_ARGS__))
-#define glIsProgram(...)            GLFUNC_(glIsProgram(__VA_ARGS__))
-#define glIsRenderbuffer(...)       GLFUNC_(glIsRenderbuffer(__VA_ARGS__))
-#define glIsShader(...)             GLFUNC_(glIsShader(__VA_ARGS__))
-#define glLinkProgram(...)          GLFUNC_(glLinkProgram(__VA_ARGS__))
-#define glProgramParameteri(...)    GLFUNC_(glProgramParameteri(__VA_ARGS__)) // GZ TRIAL
-#define glProgramParameteriEXT(...)    GLFUNC_(glProgramParameteriEXT(__VA_ARGS__)) // GZ TRIAL
-#define glReleaseShaderCompiler(...)    GLFUNC_(glReleaseShaderCompiler(__VA_ARGS__))
-#define glRenderbufferStorage(...)  GLFUNC_(glRenderbufferStorage(__VA_ARGS__))
-#define glSampleCoverage(...)       GLFUNC_(glSampleCoverage(__VA_ARGS__))
-#define glShaderBinary(...)         GLFUNC_(glShaderBinary(__VA_ARGS__))
-#define glShaderSource(...)         GLFUNC_(glShaderSource(__VA_ARGS__))
-#define glStencilFuncSeparate(...)  GLFUNC_(glStencilFuncSeparate(__VA_ARGS__))
-#define glStencilMaskSeparate(...)  GLFUNC_(glStencilMaskSeparate(__VA_ARGS__))
-#define glStencilOpSeparate(...)    GLFUNC_(glStencilOpSeparate(__VA_ARGS__))
-#define glUniform1f(...)            GLFUNC_(glUniform1f(__VA_ARGS__))
-#define glUniform1fv(...)           GLFUNC_(glUniform1fv(__VA_ARGS__))
-#define glUniform1i(...)            GLFUNC_(glUniform1i(__VA_ARGS__))
-#define glUniform1iv(...)           GLFUNC_(glUniform1iv(__VA_ARGS__))
-#define glUniform2f(...)            GLFUNC_(glUniform2f(__VA_ARGS__))
-#define glUniform2fv(...)           GLFUNC_(glUniform2fv(__VA_ARGS__))
-#define glUniform2i(...)            GLFUNC_(glUniform2i(__VA_ARGS__))
-#define glUniform2iv(...)           GLFUNC_(glUniform2iv(__VA_ARGS__))
-#define glUniform3f(...)            GLFUNC_(glUniform3f(__VA_ARGS__))
-#define glUniform3fv(...)           GLFUNC_(glUniform3fv(__VA_ARGS__))
-#define glUniform3i(...)            GLFUNC_(glUniform3i(__VA_ARGS__))
-#define glUniform3iv(...)           GLFUNC_(glUniform3iv(__VA_ARGS__))
-#define glUniform4f(...)            GLFUNC_(glUniform4f(__VA_ARGS__))
-#define glUniform4fv(...)           GLFUNC_(glUniform4fv(__VA_ARGS__))
-#define glUniform4i(...)            GLFUNC_(glUniform4i(__VA_ARGS__))
-#define glUniform4iv(...)           GLFUNC_(glUniform4iv(__VA_ARGS__))
-#define glUniformMatrix2fv(...)     GLFUNC_(glUniformMatrix2fv(__VA_ARGS__))
-#define glUniformMatrix3fv(...)     GLFUNC_(glUniformMatrix3fv(__VA_ARGS__))
-#define glUniformMatrix4fv(...)     GLFUNC_(glUniformMatrix4fv(__VA_ARGS__))
-#define glUseProgram(...)           GLFUNC_(glUseProgram(__VA_ARGS__))
-#define glValidateProgram(...)      GLFUNC_(glValidateProgram(__VA_ARGS__))
-#define glVertexAttrib1f(...)       GLFUNC_(glVertexAttrib1f(__VA_ARGS__))
-#define glVertexAttrib1fv(...)      GLFUNC_(glVertexAttrib1fv(__VA_ARGS__))
-#define glVertexAttrib2f(...)       GLFUNC_(glVertexAttrib2f(__VA_ARGS__))
-#define glVertexAttrib2fv(...)      GLFUNC_(glVertexAttrib2fv(__VA_ARGS__))
-#define glVertexAttrib3f(...)       GLFUNC_(glVertexAttrib3f(__VA_ARGS__))
-#define glVertexAttrib3fv(...)      GLFUNC_(glVertexAttrib3fv(__VA_ARGS__))
-#define glVertexAttrib4f(...)       GLFUNC_(glVertexAttrib4f(__VA_ARGS__))
-#define glVertexAttrib4fv(...)      GLFUNC_(glVertexAttrib4fv(__VA_ARGS__))
-#define glVertexAttribPointer(...)  GLFUNC_(glVertexAttribPointer(__VA_ARGS__))
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
-#define glGetString(...)            GLFUNC_(glGetString(__VA_ARGS__))
-#endif
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
-#define glBindTexture(...)          GLFUNC_(glBindTexture(__VA_ARGS__))
-#define glBlendFunc(...)            GLFUNC_(glBlendFunc(__VA_ARGS__))
-#define glClear(...)                GLFUNC_(glClear(__VA_ARGS__))
-#define glClearColor(...)           GLFUNC_(glClearColor(__VA_ARGS__))
-#define glCullFace(...)             GLFUNC_(glCullFace(__VA_ARGS__))
-#define glDeleteTextures(...)       GLFUNC_(glDeleteTextures(__VA_ARGS__))
-#define glDepthMask(...)            GLFUNC_(glDepthMask(__VA_ARGS__))
-#define glDisable(...)              GLFUNC_(glDisable(__VA_ARGS__))
-#define glDrawArrays(...)           GLFUNC_(glDrawArrays(__VA_ARGS__))
-#define glDrawElements(...)         GLFUNC_(glDrawElements(__VA_ARGS__))
-#define glEnable(...)               GLFUNC_(glEnable(__VA_ARGS__))
-#define glGenTextures(...)          GLFUNC_(glGenTextures(__VA_ARGS__))
-#define glGetError(...)             GLFUNC_(glGetError(__VA_ARGS__))
-#define glGetIntegerv(...)          GLFUNC_(glGetIntegerv(__VA_ARGS__))
-#define glFrontFace(...)            GLFUNC_(glFrontFace(__VA_ARGS__))
-#define glIsEnabled(...)            GLFUNC_(glIsEnabled(__VA_ARGS__))
-#define glIsTexture(...)            GLFUNC_(glIsTexture(__VA_ARGS__))
-#define glLineWidth(...)            GLFUNC_(glLineWidth(__VA_ARGS__))
-#define glPixelStorei(...)          GLFUNC_(glPixelStorei(__VA_ARGS__))
-#define glPolygonOffset(...)        GLFUNC_(glPolygonOffset(__VA_ARGS__))
-#define glStencilMask(...)          GLFUNC_(glStencilMask(__VA_ARGS__))
-#define glTexImage2D(...)           GLFUNC_(glTexImage2D(__VA_ARGS__))
-#define glTexParameterf(...)        GLFUNC_(glTexParameterf(__VA_ARGS__))
-#define glTexParameterfv(...)       GLFUNC_(glTexParameterfv(__VA_ARGS__))
-#define glTexParameteri(...)        GLFUNC_(glTexParameteri(__VA_ARGS__))
-#define glTexParameteriv(...)       GLFUNC_(glTexParameteriv(__VA_ARGS__))
-#define glViewport(...)             GLFUNC_(glViewport(__VA_ARGS__))
-#endif
-
-#ifndef NDEBUG
+#ifndef QT_NO_DEBUG
 # define GL(line) do { \
+	/*for debugging, we make sure we use our main context*/\
+	Q_ASSERT(StelOpenGL::mainContext == QOpenGLContext::currentContext());\
 	line;\
-	if (checkGLErrors(__FILE__, __LINE__))\
-		exit(-1);\
+	Q_ASSERT_X(!StelOpenGL::checkGLErrors(__FILE__, __LINE__), "GL macro", "OpenGL errors encountered");\
 	} while(0)
 #else
 # define GL(line) line
 #endif
 
-// In ANGLE and other OpenGL ES systems, GL_LINE_SMOOTH is undefined.
-// We can define it here to not break compilation, but must test for real OpenGL context before calling.
-# ifndef GL_LINE_SMOOTH
-#  define GL_LINE_SMOOTH 0x0B20
-# endif
-
-const char* getGLErrorText(int code);
-int checkGLErrors(const char *file, int line);
-
-// To build on arm platforms we need to re-introduce the Qt 5.4 removed
-// typedefs and defines of GLdouble/GL_DOUBLE, which are not present in GLES
-#if defined(QT_OPENGL_ES_2)
-# ifndef GL_DOUBLE
-#  define GL_DOUBLE GL_FLOAT
-# endif
-# ifndef GLdouble
-typedef double GLdouble;
-# endif
-#endif
+//! Namespace containing some OpenGL helpers
+namespace StelOpenGL
+{
+	//! The main context as created by the StelMainView (only used for debugging)
+	extern QOpenGLContext* mainContext;
+
+	//! Converts a GLenum from glGetError to a string
+	const char* getGLErrorText(GLenum code);
+	//! Retrieves and prints all current OpenGL errors to console (glGetError in a loop)
+	int checkGLErrors(const char *file, int line);
+}
 
 #endif // _STELOPENGL_HPP_

=== modified file 'src/core/StelPainter.cpp'
--- src/core/StelPainter.cpp	2017-01-06 16:52:05 +0000
+++ src/core/StelPainter.cpp	2017-01-12 21:08:38 +0000
@@ -55,26 +55,50 @@
 StelPainter::BasicShaderVars StelPainter::colorShaderVars;
 StelPainter::TexturesColorShaderVars StelPainter::texturesColorShaderVars;
 
-StelPainter::GLState::GLState()
-{
-	blend = glIsEnabled(GL_BLEND);
-	glGetIntegerv(GL_BLEND_SRC_RGB, &blendSrcRGB);
-	glGetIntegerv(GL_BLEND_DST_RGB, &blendDstRGB);
-	glGetIntegerv(GL_BLEND_SRC_ALPHA, &blendSrcAlpha);
-	glGetIntegerv(GL_BLEND_DST_ALPHA, &blendDstAlpha);
-}
-
-StelPainter::GLState::~GLState()
-{
-	if (blend)
-	{
-		glEnable(GL_BLEND);
-		glBlendFuncSeparate(blendSrcRGB, blendDstRGB, blendSrcAlpha, blendDstAlpha);
-	}
-	else
-	{
-		glDisable(GL_BLEND);
-	}
+StelPainter::GLState::GLState(QOpenGLFunctions* gl)
+	: blend(false),
+	  blendSrc(GL_SRC_ALPHA), blendDst(GL_ONE_MINUS_SRC_ALPHA),
+	  depthTest(false),
+	  depthMask(false),
+	  cullFace(false),
+	  lineSmooth(false),
+	  lineWidth(1.0f),
+	  gl(gl)
+{
+
+}
+
+void StelPainter::GLState::apply()
+{
+	if(blend)
+		gl->glEnable(GL_BLEND);
+	else
+		gl->glDisable(GL_BLEND);
+	gl->glBlendFunc(blendSrc,blendDst);
+	if(depthTest)
+		gl->glEnable(GL_DEPTH_TEST);
+	else
+		gl->glDisable(GL_DEPTH_TEST);
+	gl->glDepthMask(depthMask);
+	if(cullFace)
+		gl->glEnable(GL_CULL_FACE);
+	else
+		gl->glDisable(GL_CULL_FACE);
+#ifdef GL_LINE_SMOOTH
+	if(!QOpenGLContext::currentContext()->isOpenGLES())
+	{
+		if (lineSmooth)
+			gl->glEnable(GL_LINE_SMOOTH);
+		else
+			gl->glDisable(GL_LINE_SMOOTH);
+	}
+#endif
+}
+
+void StelPainter::GLState::reset()
+{
+	*this = GLState(gl);
+	apply();
 }
 
 bool StelPainter::linkProg(QOpenGLShaderProgram* prog, const QString& name)
@@ -85,7 +109,7 @@
 	return ret;
 }
 
-StelPainter::StelPainter(const StelProjectorP& proj) : prj(proj)
+StelPainter::StelPainter(const StelProjectorP& proj) : QOpenGLFunctions(QOpenGLContext::currentContext()), glState(this)
 {
 	Q_ASSERT(proj);
 
@@ -106,13 +130,10 @@
 	}
 #endif
 
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_CULL_FACE);
+	//TODO: is this still required, and is there some Qt way to fix it? 0x11111111 is a bit peculiar, how was it chosen?
 	// Fix some problem when using Qt OpenGL2 engine
 	glStencilMask(0x11111111);
-	// Deactivate drawing in depth buffer by default
-	glDepthMask(GL_FALSE);
-	enableTexture2d(false);
+	glState.apply(); //apply default OpenGL state
 	setProjector(proj);
 }
 
@@ -126,6 +147,9 @@
 
 StelPainter::~StelPainter()
 {
+	//reset opengl state
+	glState.reset();
+
 #ifndef NDEBUG
 	GLenum er = glGetError();
 	if (er!=GL_NO_ERROR)
@@ -160,6 +184,87 @@
 	return QFontMetrics(currentFont);
 }
 
+void StelPainter::setBlending(bool enableBlending, GLenum blendSrc, GLenum blendDst)
+{
+	if(enableBlending != glState.blend)
+	{
+		glState.blend = enableBlending;
+		if(enableBlending)
+			glEnable(GL_BLEND);
+		else
+			glDisable(GL_BLEND);
+	}
+	if(enableBlending)
+	{
+		if(blendSrc!=glState.blendSrc||blendDst!=glState.blendDst)
+		{
+			glState.blendSrc = blendSrc;
+			glState.blendDst = blendDst;
+			glBlendFunc(blendSrc,blendDst);
+		}
+	}
+}
+
+void StelPainter::setDepthTest(bool enable)
+{
+	if(glState.depthTest != enable)
+	{
+		glState.depthTest = enable;
+		if(enable)
+			glEnable(GL_DEPTH_TEST);
+		else
+			glDisable(GL_DEPTH_TEST);
+	}
+}
+
+void StelPainter::setDepthMask(bool enable)
+{
+	if(glState.depthMask != enable)
+	{
+		glState.depthMask = enable;
+		if(enable)
+			glDepthMask(GL_TRUE);
+		else
+			glDepthMask(GL_FALSE);
+	}
+}
+
+void StelPainter::setCullFace(bool enable)
+{
+	if(glState.cullFace!=enable)
+	{
+		glState.cullFace = enable;
+		if(enable)
+			glEnable(GL_CULL_FACE);
+		else
+			glDisable(GL_CULL_FACE);
+	}
+}
+
+void StelPainter::setLineSmooth(bool enable)
+{
+#ifdef GL_LINE_SMOOTH
+	if (!QOpenGLContext::currentContext()->isOpenGLES() && enable!=glState.lineSmooth)
+	{
+		glState.lineSmooth = enable;
+		if(enable)
+			glEnable(GL_LINE_SMOOTH);
+		else
+			glDisable(GL_LINE_SMOOTH);
+	}
+#else
+	Q_UNUSED(enable); //noop
+#endif
+}
+
+void StelPainter::setLineWidth(float width)
+{
+	if(glState.lineWidth != width)
+	{
+		glState.lineWidth = width;
+		glLineWidth(width);
+	}
+}
 
 ///////////////////////////////////////////////////////////////////////////
 // Standard methods for drawing primitives
@@ -170,6 +275,7 @@
 	if (prj->maskType != StelProjector::MaskDisk)
 		return;
 
+	bool oldBlendState = glState.blend;
 	glDisable(GL_BLEND);
 	setColor(0.f,0.f,0.f);
 
@@ -219,6 +325,8 @@
 	}
 	drawFromArray(TriangleStrip, (slices+1)*2, 0, false);
 	enableClientStates(false);
+	if(oldBlendState)
+		glEnable(GL_BLEND);
 }
 
 void StelPainter::computeFanDisk(float radius, int innerFanSlices, int level, QVector<double>& vertexArr, QVector<float>& texCoordArr)
@@ -530,7 +638,6 @@
 
 void StelPainter::drawText(float x, float y, const QString& str, float angleDeg, float xshift, float yshift, bool noGravity)
 {
-	//StelPainter::GLState state; // Will restore the opengl state at the end of the function.
 	if (prj->gravityLabels && !noGravity)
 	{
 		drawTextGravity180(x, y, str, xshift, yshift);
@@ -545,7 +652,6 @@
 			angleDeg += prj->defaultAngleForGravityText;
 		tex->texture->bind();
 
-		enableTexture2d(true);
 		static float vertexData[8];
 		// compute the vertex coordinates applying the translation and the rotation
 		static const float vertexBase[] = {0., 0., 1., 0., 0., 1., 1., 1.};
@@ -579,11 +685,15 @@
 			texCoords[i*2+1] = tex->getTexSize().height() * (1 - i / 2);
 		}
 		setTexCoordPointer(2, GL_FLOAT, texCoords);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		glEnable(GL_BLEND);
+
+		//text drawing requires blending, but we reset GL state afterwards if necessary
+		bool oldBlending = glState.blend;
+		GLenum oldSrc = glState.blendSrc, oldDst = glState.blendDst;
+		setBlending(true);
 		enableClientStates(true, true);
 		setVertexPointer(2, GL_FLOAT, vertexData);
 		drawFromArray(TriangleStrip, 4, 0, false);
+		setBlending(oldBlending, oldSrc, oldDst);
 		enableClientStates(false, false);
 		tex->texture->release();
 		delete[] texCoords;
@@ -598,7 +708,6 @@
 		// painter.setFont(currentFont);
 		
 		QPainter painter(&device);
-		painter.beginNativePainting();
 		
 		QFont tmpFont = currentFont;
 		tmpFont.setPixelSize(currentFont.pixelSize()*prj->getDevicePixelsPerPixel()*StelApp::getInstance().getGlobalScalingRatio());
@@ -629,7 +738,11 @@
 			painter.drawText(x+xshift, y+yshift, str);
 		}
 		
-		painter.endNativePainting();
+		//important to call this before GL state restore
+		painter.end();
+
+		//QPainter messes up some GL state, begin/endNativePainting or save/restore does not help
+		glState.apply();
 	}
 }
 
@@ -1462,6 +1575,8 @@
 	if (!prj->getBoundingCap().intersects(poly->getBoundingCap()))
 		return;
 
+	bool oldCullFace = glState.cullFace;
+
 	switch (drawMode)
 	{
 		case SphericalPolygonDrawModeBoundary:
@@ -1473,7 +1588,7 @@
 		case SphericalPolygonDrawModeFill:
 		case SphericalPolygonDrawModeTextureFill:
 		case SphericalPolygonDrawModeTextureFillColormodulated:
-			glEnable(GL_CULL_FACE);
+			setCullFace(true);
 			// The polygon is already tesselated as triangles
 			if (doSubDivise || prj->intersectViewportDiscontinuity(poly->getBoundingCap()))
 				// flag for color-modulated textured mode (e.g. for Milky Way/extincted)
@@ -1481,7 +1596,7 @@
 			else
 				drawStelVertexArray(poly->getFillVertexArray(), false);
 
-			glDisable(GL_CULL_FACE);
+			setCullFace(oldCullFace);
 			break;
 		default:
 			Q_ASSERT(0);
@@ -1822,11 +1937,6 @@
 		glCullFace(GL_BACK);
 }
 
-void StelPainter::enableTexture2d(bool b)
-{
-	texture2dEnabled = b;
-}
-
 void StelPainter::initGLShaders()
 {
 	qDebug() << "Initializing basic GL shaders... ";

=== modified file 'src/core/StelPainter.hpp'
--- src/core/StelPainter.hpp	2016-05-01 05:52:39 +0000
+++ src/core/StelPainter.hpp	2017-01-12 21:08:38 +0000
@@ -1,4 +1,4 @@
-/*
+/*
  * Stellarium
  * Copyright (C) 2008 Fabien Chereau
  *
@@ -37,7 +37,7 @@
 //! Because openGL is not thread safe, only one instance of StelPainter can exist at a time, enforcing thread safety.
 //! As a coding rule, no openGL calls should be performed when no instance of StelPainter exist.
 //! Typical usage is to create a local instance of StelPainter where drawing operations are needed.
-class StelPainter
+class StelPainter : protected QOpenGLFunctions
 {
 public:
 	friend class VertexArrayProjector;
@@ -66,6 +66,11 @@
 	explicit StelPainter(const StelProjectorP& prj);
 	~StelPainter();
 
+	//! Returns a QOpenGLFunctions object suitable for drawing directly with OpenGL while this StelPainter is active.
+	//! This is recommended to be used instead of QOpenGLContext::currentContext()->functions() when a StelPainter is available,
+	//! and you only need to call a few GL functions directly.
+	inline QOpenGLFunctions* glFuncs() { return this; }
+
 	//! Return the instance of projector associated to this painter
 	const StelProjectorP& getProjector() const {return prj;}
 	void setProjector(const StelProjectorP& p);
@@ -227,6 +232,25 @@
 	//! Get the font metrics for the current font.
 	QFontMetrics getFontMetrics() const;
 
+	//! Enable OpenGL blending. By default, blending is disabled.
+	//! The additional parameters specify the blending mode, the default parameters are suitable for
+	//! "normal" blending operations that you want in most cases. Blending will be automatically disabled when
+	//! the StelPainter is destroyed.
+	void setBlending(bool enableBlending, GLenum blendSrc = GL_SRC_ALPHA, GLenum blendDst = GL_ONE_MINUS_SRC_ALPHA);
+
+	void setDepthTest(bool enable);
+
+	void setDepthMask(bool enable);
+
+	//! Set the OpenGL GL_CULL_FACE state, by default face culling is disabled
+	void setCullFace(bool enable);
+
+	//! Enables/disables line smoothing. By default, smoothing is disabled.
+	void setLineSmooth(bool enable);
+
+	//! Sets the line width. Default is 1.0f.
+	void setLineWidth(float width);
+
 	//! Create the OpenGL shaders programs used by the StelPainter.
 	//! This method needs to be called once at init.
 	static void initGLShaders();
@@ -235,9 +259,6 @@
 	//! This method needs to be called once before exit.
 	static void deinitGLShaders();
 
-	//! Set whether texturing is enabled.
-	void enableTexture2d(bool b);
-
 	// Thoses methods should eventually be replaced by a single setVertexArray
 	//! use instead of glVertexPointer
 	void setVertexPointer(int size, int type, const void* pointer) {
@@ -262,7 +283,7 @@
 		normalArray.size = 3; normalArray.type = type; normalArray.pointer = pointer;
 	}
 
-	//! use instead of glEnableClient
+	//! Simulates glEnableClientState, basically you describe what data the ::drawFromArray call has available
 	void enableClientStates(bool vertex, bool texture=false, bool color=false, bool normal=false);
 
 	//! convenience method that enable and set all the given arrays.
@@ -290,17 +311,27 @@
 	friend class StelTextureMgr;
 	friend class StelTexture;
 
-	//! RAII class used to store and restore the opengl state.
-	//! to use it we just need to instanciate it at the beginning of a method that might change the state.
-	class GLState
+	//! Helper struct to track the GL state and restore it to canonical values on StelPainter creation/destruction
+	struct GLState
 	{
-	public:
-		GLState();
-		~GLState();
+		GLState(QOpenGLFunctions *gl);
+
+		bool blend;
+		GLenum blendSrc, blendDst;
+		bool depthTest;
+		bool depthMask;
+		bool cullFace;
+		bool lineSmooth;
+		GLfloat lineWidth;
+
+		//! Applies the values stored here to set the GL state
+		void apply();
+		//! Resets the state to the default values (like a GLState was newly constructed)
+		//! and calls apply()
+		void reset();
 	private:
-		bool blend;
-		int blendSrcRGB, blendDstRGB, blendSrcAlpha, blendDstAlpha;
-	};
+		QOpenGLFunctions* gl;
+	} glState;
 
 	// From text-use-opengl-buffer
 	static QCache<QByteArray, struct StringTexture> texCache;
@@ -352,7 +383,6 @@
 	QFont currentFont;
 
 	Vec4f currentColor;
-	bool texture2dEnabled;
 	
 	static QOpenGLShaderProgram* basicShaderProgram;
 	struct BasicShaderVars {

=== modified file 'src/core/StelSkyDrawer.cpp'
--- src/core/StelSkyDrawer.cpp	2017-01-06 02:19:00 +0000
+++ src/core/StelSkyDrawer.cpp	2017-01-12 21:08:38 +0000
@@ -17,12 +17,6 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#ifndef GL_POINT_SPRITE
- #define GL_POINT_SPRITE 0x8861
-#endif
-#ifndef GL_VERTEX_PROGRAM_POINT_SIZE
- #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
-#endif
 
 #include "StelSkyDrawer.hpp"
 #include "StelProjector.hpp"
@@ -156,6 +150,8 @@
 // Init parameters from config file
 void StelSkyDrawer::init()
 {
+	initializeOpenGLFunctions();
+
 	// Load star texture no mipmap:
 	texHalo = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/star16x16.png");
 	texBigHalo = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/haloLune.png");
@@ -382,9 +378,7 @@
 
 	// Blending is really important. Otherwise faint stars in the vicinity of
 	// bright star will cause tiny black squares on the bright star, e.g. see Procyon.