cmake_minimum_required(VERSION 3.2)

set(MACOSX_BUNDLE_GUI_IDENTIFIER "org.navitproject.navit")
set(MACOSX_BUNDLE_BUNDLE_NAME "Navit")
message(STATUS "Building with CMake V${CMAKE_VERSION}")
if (DISABLE_CXX)
	project(navit C)
else(DISABLE_CXX)
	project(navit C CXX)
endif(DISABLE_CXX)

# Workaround for CMake issue 8345 / 9220, see http://trac.navit-project.org/ticket/1041
if(DEFINED CMAKE_CXX_COMPILER AND CMAKE_CXX_COMPILER MATCHES "^$")
	set(CMAKE_CXX_COMPILER CMAKE_CXX_COMPILER-NOTFOUND)
endif(DEFINED CMAKE_CXX_COMPILER AND CMAKE_CXX_COMPILER MATCHES "^$")
if (NOT DISABLE_CXX)
	enable_language(CXX OPTIONAL)
endif(NOT DISABLE_CXX)

set(NAVIT_VERSION_MAJOR "0")
set(NAVIT_VERSION_MINOR "5")
set(NAVIT_VERSION_PATCH "6")
if(ANDROID)
    set(PACKAGE_VERSION "${NAVIT_VERSION_MAJOR}.${NAVIT_VERSION_MINOR}.${NAVIT_VERSION_PATCH}.${ANDROID_ABI}")
else(ANDROID)
	set(PACKAGE_VERSION "${NAVIT_VERSION_MAJOR}.${NAVIT_VERSION_MINOR}.${NAVIT_VERSION_PATCH}")
endif(ANDROID)
set(PACKAGE_NAME "navit-git")
set(PACKAGE "navit" CACHE STRING "Navit package name")
set(PACKAGE_STRING "${PACKAGE} ${PACKAGE_VERSION}")

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/")
include("${PROJECT_SOURCE_DIR}/cmake/navit_macros.cmake")

IF(NOT CMAKE_BUILD_TYPE)
	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)

# binary name
set(NAVIT_BINARY navit CACHE STRING "Navit binary name")
# install path
set(BIN_DIR bin CACHE PATH "Navit bin path")
add_definitions ("-DBIN_DIR=\"${BIN_DIR}\"")
set(SHARE_DIR share/navit CACHE PATH "Navit share path")
add_definitions ("-DSHARE_DIR=\"${SHARE_DIR}\"")
set(LOCALE_DIR share/locale CACHE PATH "Navit locale path")
add_definitions ("-DLOCALE_DIR=\"${LOCALE_DIR}\"")
set(IMAGE_DIR share/navit/icons CACHE PATH "Navit image path")
add_definitions ("-DIMAGE_DIR=\"${IMAGE_DIR}\"")
set(TEXTURE_DIR share/navit/textures CACHE PATH "Navit texture path")
add_definitions ("-DTEXTURE_DIR=\"${TEXTURE_DIR}\"")
set(MAN_DIR share/man/man1 CACHE PATH "Navit man path")
add_definitions ("-DMAN_DIR=\"${MAN_DIR}\"")
set(HOMECONFIG_DIR .navit CACHE PATH "Navit config path in home dir")
add_definitions ("-DHOMECONFIG_DIR=\"${HOMECONFIG_DIR}\"")
# LIB_DIR
IF(UNIX AND NOT ANDROID AND NOT APPLE)
	IF (NOT LIBDIR)
		MESSAGE(STATUS "LIBDIR variable is not defined. It will be autodetected now.")
		MESSAGE(STATUS "You can set it manually with -DLIBDIR=<value>")
		# check 64 bit
		IF (CMAKE_SIZEOF_VOID_P EQUAL 4)
			SET(LIB_DIR lib/${PACKAGE} CACHE PATH "Navit 32bit bin path")
			MESSAGE(STATUS "   LIB_DIR (highest subdirectory if LIBDIR) is set to '${LIB_DIR}'")
		ELSE (CMAKE_SIZEOF_VOID_P EQUAL 4)
			SET(LIB_DIR lib64/${PACKAGE} CACHE PATH "Navit 64bit bin path")
			MESSAGE(STATUS "   LIB_DIR (highest subdirectory if LIBDIR) is set to '${LIB_DIR}'")
		ENDIF (CMAKE_SIZEOF_VOID_P EQUAL 4)
	ELSE (NOT LIBDIR)
		SET (LIB_DIR ${LIBDIR}/${PACKAGE} CACHE PATH "Navit lib path")
		MESSAGE(STATUS "   LIB_DIR is set to '${LIB_DIR}' because LIBDIR is set to ${LIBDIR}")
	ENDIF (NOT LIBDIR)
ELSE (UNIX AND NOT ANDROID AND NOT APPLE)
	SET(LIB_DIR lib/navit CACHE PATH "Navit unix bin path")
ENDIF (UNIX AND NOT ANDROID AND NOT APPLE)
foreach(EXTRA_MODULE ${EXTRA_MODULES})
	add_module(${EXTRA_MODULE} "extra module specified" TRUE)
endforeach()
add_definitions ("-DLIB_DIR=\"${LIB_DIR}\"")

if (EXTRA_LIBS)
	list(APPEND NAVIT_LIBS ${EXTRA_LIBS})
endif(EXTRA_LIBS)

if (EXTRA_INCLUDES)
	include_directories(${EXTRA_INCLUDES})
endif(EXTRA_INCLUDES)

if (EXTRA_LIBDIR)
	link_directories(${EXTRA_LIBDIR})
endif(EXTRA_LIBDIR)

### Detect environment

add_plugin(support/espeak "Default" FALSE)
add_feature(INTERNAL_ESPEAK_COMPLETE "build complete internal libespeak" FALSE)
add_plugin(support/ezxml "native Glib found" FALSE)
add_plugin(support/glib "native Glib found" FALSE)
add_plugin(support/zlib "native zlib found" FALSE)
add_plugin(support/libpng "native libpng found" FALSE)
add_plugin(support/wordexp "native wordexp found" FALSE)
add_plugin(support/gettext_intl "native libintl found" FALSE)
add_module(font/freetype "freetype not found" FALSE)
add_module(graphics/android "FreeType library not found" FALSE)
add_module(graphics/gd "FreeType library not found" FALSE)
add_module(graphics/gtk_drawing_area "FreeType library not found" FALSE)
add_module(graphics/opengl "FreeType library not found" FALSE)
add_module(graphics/sdl "Required library not found" FALSE)
add_module(graphics/egl "Required library not found" FALSE)
add_module(graphics/qt_qpainter "Qt libraries not found" FALSE)
add_module(graphics/qt5 "Qt5 libraries not found" FALSE)
add_module(graphics/svg_debug "native Glib not found" FALSE)
add_module(gui/qml "Qt Declarative not found" FALSE)
add_module(gui/qt5_qml "Qt5 Declarative not found" FALSE)
add_module(gui/gtk "GTK libs not found" FALSE)
add_module(vehicle/geoclue "geoclue lib not found" FALSE)
add_module(vehicle/gpsd "gpsd lib not found" FALSE)
add_module(vehicle/gypsy "gypsy lib not found" FALSE)
add_module(binding/win32 "Default" FALSE)
add_module(binding/dbus "dbus-glib-1 not found" FALSE)
add_module(binding/python "python libraries not found" FALSE)
add_module(speech/dbus "dbus-glib-1 not found" FALSE)
add_module(speech/cmdline "neither system() nor CreateProcess() found" FALSE)
add_module(speech/qt5_espeak "Qt5 multimedia not found" FALSE)
add_module(vehicle/gpsd_dbus "dbus-glib-1 not found" FALSE)
add_module(vehicle/qt5 "Qt5 libraries not found" FALSE)
add_module(speech/speech_dispatcher "speech_dispatcher lib not found" FALSE)
add_module(map/garmin "Garmin library not found" FALSE)
add_feature(USE_NATIVE_LANGUAGE_SUPPORT "Gettext not found and not on Windows" FALSE)
set(CPACK_PROJECT_CONFIG_FILE "${CMAKE_SOURCE_DIR}/cpack.cmake")
set(CPACK_PACKAGE_VENDOR "Navit team")
set(CPACK_PACKAGE_VERSION_MAJOR ${NAVIT_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${NAVIT_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH "${NAVIT_VERSION_PATCH}")
set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README.md")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/GPL-2")
set(CPACK_NSIS_PACKAGE_NAME "Navit ${PACKAGE_VERSION}")
set(CPACK_PACKAGE_FILE_NAME ${PACKAGE})
set(CPACK_PACKAGE_EXECUTABLES "navit;Navit")
set(CPACK_NSIS_HELP_LINK "http://www.navit-project.org/?page=contact")
set(CPACK_NSIS_URL_INFO_ABOUT "http://www.navit-project.org")
if(WIN32)
	add_feature(USE_NSIS "makensis not found" FALSE)
	FIND_PROGRAM(NSIS_EXECUTABLE NAMES makensis makensis.exe)
	if(NSIS_EXECUTABLE)
		set_with_reason(USE_NSIS "makensis found" TRUE)
	endif(NSIS_EXECUTABLE)

	set(CPACK_GENERATOR ZIP)
	if(USE_NSIS)
		list(APPEND CPACK_GENERATOR NSIS)
	endif(USE_NSIS)
	set(CPACK_PACKAGE_INSTALL_DIRECTORY Navit)
endif(WIN32)
INCLUDE (CPack)

INCLUDE (CheckIncludeFiles)
INCLUDE (CheckLibraryExists)
INCLUDE (CheckFunctionExists)
INCLUDE (CheckSymbolExists)

if(ANDROID)
	set(ENV{PKG_CONFIG_DIR} "")
	set(ENV{PKG_CONFIG_LIBDIR} "${CMAKE_SYSROOT}/usr/lib/pkgconfig:${CMAKE_SYSROOT}/usr/share/pkgconfig")
	set(ENV{PKG_CONFIG_SYSROOT_DIR} ${CMAKE_SYSROOT})
endif(ANDROID)

################################
#  pkg-config based detection  #
################################

find_package(PkgConfig)
if(PKG_CONFIG_FOUND)
	pkg_check_modules ( GMODULE gmodule-2.0 )
	if (GMODULE_FOUND)
		set(HAVE_GMODULE 1)
		include_directories(${GMODULE_INCLUDE_DIRS})
		list(APPEND NAVIT_LIBS ${GMODULE_LIBRARIES})
	endif(GMODULE_FOUND)

	pkg_check_modules (GLIB2 glib-2.0>=2.10)
	if (GLIB2_FOUND)
		set(HAVE_GLIB 1)
		include_directories(${GLIB2_INCLUDE_DIRS})
		list(APPEND NAVIT_LIBS ${GLIB2_LIBRARIES})
	else(GLIB2_FOUND)
		set_with_reason(support/glib "Glib not found" TRUE ${INTL_LIBS})
	endif(GLIB2_FOUND)

	pkg_check_modules(FONTCONFIG "fontconfig >= 2.2.0")
	pkg_check_modules(DBUS "dbus-1 >= 1.4")
	pkg_check_modules(DBUSGLIB dbus-glib-1)
	if(DBUSGLIB_FOUND)
		include_directories(${DBUSGLIB_INCLUDE_DIRS})
		set_with_reason(binding/dbus "dbus-glib-1 found" TRUE ${DBUSGLIB_LIBRARIES})
		set_with_reason(speech/dbus "dbus-glib-1 found" TRUE ${DBUSGLIB_LIBRARIES})
		set_with_reason(vehicle/gpsd_dbus "dbus-glib-1 found" TRUE ${DBUSGLIB_LIBRARIES})
	endif()

	pkg_check_modules(LIBLOCATION liblocation)
	# Accept even old versions of libgps, because N810 uses an old version (see #1179).
	pkg_check_modules(LIBGPS libgps)
	pkg_check_modules(LIBGPS19 libgps>=2.90)
	# libgpsd<V3.1 is buggy if LC_ALL is set.
	pkg_check_modules(LIBGPS_NEW libgps>=3.1)
	pkg_check_modules(LIBGARMIN libgarmin)
	pkg_check_modules(IMLIB2 imlib2)
	if(IMLIB2_FOUND)
		set(HAVE_IMLIB2 1)
	endif(IMLIB2_FOUND)

	# Geoclue
	pkg_check_modules ( GeoClue libgeoclue-2.0 )
	if(GeoClue_FOUND)
		include_directories(${GeoClue_INCLUDE_DIRS})
		set_with_reason(vehicle/geoclue "libgeoclue found" TRUE
			${GeoClue_LIBRARIES})
	endif(GeoClue_FOUND)
else(PKG_CONFIG_FOUND)
    set_with_reason(support/glib "Glib not found" TRUE ${INTL_LIBS})
endif(PKG_CONFIG_FOUND)

#find_package(Iconv)
#find_package(Gmodule)
find_package(ZLIB)
find_package(Freetype)
#find_library(SDL2MAIN SDL2)
#find_library(SDL2IMAGE SDL2_image)
find_package(SDL)
#find_package(SDL_ttf)
find_package(SDL_image)

find_library(GLES2 GLESv2)
find_package(OpenGL)
find_package(GLUT)
find_package(GTK2 2.6 COMPONENTS gtk)
find_package(Gettext)
find_package(PNG)
find_package(PythonLibs)
find_package(Threads)

#Qt detection
if (NOT DISABLE_QT)
	find_package(Qt5Widgets)
	find_package(Qt5Quick)
	find_package(Qt5Positioning)
	if (Qt5Widgets_FOUND OR Qt5Quick_FOUND OR Qt5Sensors_FOUND)
		add_feature (USE_QWIDGET "Qt5 Qt5Widget not found" FALSE)
		add_feature (USE_QML "Qt5 Qt5Quick not found" FALSE)
		if (Qt5Widgets_FOUND OR Qt5Quick_FOUND)
			find_package(Qt5Svg REQUIRED)
			find_package(Qt5DBus REQUIRED)
			find_package(Qt5Multimedia)
			find_package(espeak)
		endif (Qt5Widgets_FOUND OR Qt5Quick_FOUND)
		if (Qt5Positioning_FOUND)
			find_package(Qt5Sensors REQUIRED)
		endif (Qt5Positioning_FOUND)
	else (Qt5Widgets_FOUND OR Qt5Quick_FOUND OR Qt5Sensors_FOUND)
		# Unfortunately, CMake seems to ignore the "OPTIONAL_COMPONENTS" flag,
		# and actually requires all components to be installed. Maybe this can
		# be fixed later...
		find_package(Qt4 4.7 COMPONENTS QtCore OPTIONAL_COMPONENTS QtGui QtXml QtDeclarative QtSvg)
	endif (Qt5Widgets_FOUND OR Qt5Quick_FOUND OR Qt5Sensors_FOUND)
endif (NOT DISABLE_QT)

#Simple checks
CHECK_INCLUDE_FILES(wordexp.h HAVE_WORDEXP)
CHECK_INCLUDE_FILES(endian.h HAVE_ENDIAN_H)
CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
CHECK_INCLUDE_FILES(byteswap.h HAVE_BYTESWAP_H)
CHECK_LIBRARY_EXISTS(gypsy gypsy_control_get_default "" GYPSY_FOUND)
CHECK_INCLUDE_FILES(libspeechd.h HAVE_LIBSPEECHD)
CHECK_INCLUDE_FILES(sys/socket.h HAVE_SOCKET)
CHECK_INCLUDE_FILES(sys/shm.h HAVE_SHMEM)
CHECK_FUNCTION_EXISTS(snprintf   HAVE_SNPRINTF)
if (NOT HAVE_SNPRINTF)
	CHECK_FUNCTION_EXISTS(_snprintf  HAVE_DECL__SNPRINTF)
	if (HAVE_DECL__SNPRINTF)
		set(HAVE_SNPRINTF 1)
	endif(HAVE_DECL__SNPRINTF)
endif(NOT HAVE_SNPRINTF)
CHECK_INCLUDE_FILES(locale.h HAVE_LC_MESSAGES)
CHECK_INCLUDE_FILES(libintl.h HAVE_LIBINTL)
CHECK_INCLUDE_FILES(sys/time.h HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILES(getopt.h HAVE_GETOPT_H)
CHECK_INCLUDE_FILES(string.h HAVE_STRING_H)
CHECK_FUNCTION_EXISTS(gettimeofday HAVE_GETTIMEOFDAY)
CHECK_SYMBOL_EXISTS(system stdlib.h HAVE_SYSTEM)
CHECK_SYMBOL_EXISTS(CreateProcess windows.h HAVE_CREATEPROCESS)
CHECK_SYMBOL_EXISTS(stpcpy string.h HAVE_STPCPY)
CHECK_FUNCTION_EXISTS(sbrk HAVE_SBRK)
CHECK_FUNCTION_EXISTS(getdelim HAVE_GETDELIM)
CHECK_FUNCTION_EXISTS(getline HAVE_GETLINE)
CHECK_FUNCTION_EXISTS(fsync HAVE_FSYNC)


### Configure build
#Required libraries, supplied with navit
if (NOT HAVE_LIBINTL)
	set_with_reason(support/gettext_intl "native libintl missing" TRUE)
	set(USE_LIBGNUINTL TRUE)
else()
	CHECK_LIBRARY_EXISTS(intl libintl_fprintf "" NEEDS_LIBINTL)
	if (NEEDS_LIBINTL)
		list(APPEND NAVIT_LIBS intl)
		set(INTL_LIBS intl)
	endif(NEEDS_LIBINTL)
endif(NOT HAVE_LIBINTL)

if (CMAKE_USE_PTHREADS_INIT)
	if (NOT ANDROID)
		list(APPEND NAVIT_LIBS pthread)
	endif(NOT ANDROID)
endif(CMAKE_USE_PTHREADS_INIT)

if(ZLIB_FOUND)
	set(HAVE_ZLIB 1)
	include_directories(${ZLIB_INCLUDE_DIRS})
	list(APPEND NAVIT_LIBS ${ZLIB_LIBRARIES})
else(ZLIB_FOUND)
	message(STATUS "using internal zlib")
	set_with_reason(support/zlib "native zlib missing" TRUE)
endif(ZLIB_FOUND)
if(PNG_FOUND)
	set(HAVE_PNG 1)
	include_directories(${PNG_INCLUDE_DIR})
	list(APPEND NAVIT_LIBS ${PNG_LIBRARIES})
else(PNG_FOUND)
	message(STATUS "using internal libpng")
	set_with_reason(support/libpng "native libpng missing" TRUE)
endif(PNG_FOUND)
if (NOT HAVE_WORDEXP)
	message(STATUS "wordexp.h not found. use internal wordexp")
	set_with_reason(support/wordexp "native wordexp missing" TRUE)
endif()
if (NOT GLIB2_FOUND)
	set_with_reason(support/ezxml "Glib not found" TRUE)
else(NOT GLIB2_FOUND)
	set_with_reason(graphics/svg_debug "Glib found" TRUE)
endif(NOT GLIB2_FOUND)


if(FREETYPE_FOUND)
	pkg_check_modules(FRIBIDI fribidi)
	pkg_check_modules(FRIBIDI2 fribidi>=0.19.0)
	include_directories(${FREETYPE_INCLUDE_DIRS})
	set_with_reason(font/freetype "freetype found" TRUE "${FREETYPE_LIBRARY};${FONTCONFIG_LDFLAGS};${FRIBIDI_LIBRARIES}")
else(FREETYPE_FOUND)
	MESSAGE("No freetype library found, graphics modules may not be available")
	set_with_reason(graphics/android "FreeType library not found" FALSE)
	set_with_reason(graphics/gd "FreeType library not found" FALSE)
	set_with_reason(graphics/gtk_drawing_area "FreeType library not found" FALSE)
	set_with_reason(graphics/opengl "FreeType library not found" FALSE)
	set_with_reason(graphics/sdl "FreeType library not found" FALSE)
	set_with_reason(graphics/egl "FreeType library not found" FALSE)
endif(FREETYPE_FOUND)

if(FONTCONFIG_FOUND)
	set(HAVE_FONTCONFIG 1)
endif(FONTCONFIG_FOUND)

if (QT_FOUND)
	if (QT_QTCORE_FOUND AND QT_QTGUI_FOUND AND FREETYPE_FOUND)
		include(${QT_USE_FILE})
		set_with_reason(graphics/qt_qpainter "Qt libraries found" TRUE ${QT_LIBRARIES})

		if (QT_QTDECLARATIVE_FOUND AND QT_QTXML_FOUND)
			set_with_reason(gui/qml "Qt Declarative found" TRUE ${QT_LIBRARIES})
		endif()

		if (QT_QTSVG_FOUND)
			set(HAVE_QT_SVG 1)
		elseif( USE_SVG AND graphics/qt_qpainter)
			message( WARNING "QT compiled without SVG support")
		endif()
	endif()
endif(QT_FOUND)
if (Qt5Widgets_FOUND OR Qt5Quick_FOUND)
	set(Qt5_ADDITIONAL_LIBRARIES "")
	if(Qt5Widgets_FOUND)
		set_with_reason(USE_QWIDGET "Qt5Widgets found" TRUE)
		if(USE_QWIDGET)
			set(Qt5_ADDITIONAL_LIBRARIES ${Qt5_ADDITIONAL_LIBRARIES} ${Qt5Widgets_LIBRARIES})
		endif()
	endif()
	if(Qt5Quick_FOUND)
		set_with_reason(USE_QML "Qt5Quick found" TRUE)
		if(USE_QML)
			set(Qt5_ADDITIONAL_LIBRARIES ${Qt5_ADDITIONAL_LIBRARIES} ${Qt5Quick_LIBRARIES})
			set_with_reason(gui/qt5_qml "Qt5 found" TRUE
				${Qt5Quick_LIBRARIES})
		else()
			set_with_reason(gui/qt5_qml "feature USE_QML disabled for graphics/qt5" FALSE)
		endif()

	endif()
	set_with_reason(graphics/qt5 "Qt5 found" TRUE
		${Qt5_ADDITIONAL_LIBRARIES}
		${Qt5Svg_LIBRARIES}
		${Qt5DBus_LIBRARIES})
	if (Qt5Multimedia_FOUND)
		if (espeak_FOUND)
			set_with_reason(support/espeak "native espeak found" FALSE)
			set_with_reason(speech/qt5_espeak "Qt5Multimedia and libespeak found" TRUE
				${Qt5Multimedia_LIBRARIES}
				${espeak_LIBRARIES})
		else()
			set_with_reason(support/espeak "native espeak missing" TRUE)
			set_with_reason(INTERNAL_ESPEAK_COMPLETE "speech_qt5_espeak requires full libespeak" TRUE)
			set_with_reason(speech/qt5_espeak "Qt5Multimedia found" TRUE
				${Qt5Multimedia_LIBRARIES})
		endif()
	endif()
endif ()
if (Qt5Positioning_FOUND)
	set_with_reason(vehicle/qt5 "Qt5 Positioning found" TRUE
		${Qt5Positioning_LIBRARIES}
		${Qt5Sensors_LIBRARIES})
endif ()
if(GTK2_FOUND)
	# Include gtk.h with "SYSTEM" to avoid GCC compiler warning for gtkitemfactory.h.
	include_directories(SYSTEM ${GTK2_GTK_INCLUDE_DIR})
	include_directories(${GTK2_INCLUDE_DIRS})
	set(HAVE_GTK2 1)
	set_with_reason(gui/gtk "GTK libs found" TRUE ${GTK2_LIBRARIES})
	if(FREETYPE_FOUND)
		set_with_reason(graphics/gtk_drawing_area "GTK libs found" TRUE ${GTK2_LIBRARIES})
	endif(FREETYPE_FOUND)
endif(GTK2_FOUND)

CHECK_LIBRARY_EXISTS(freeimage FreeImage_Load "" HAVE_FREEIMAGE)
if (USE_OPENGLES OR USE_OPENGLES2)
	CHECK_LIBRARY_EXISTS(EGL eglInitialize "" HAVE_EGL)
endif(USE_OPENGLES OR USE_OPENGLES2)
if (FREETYPE_FOUND)
	if (OPENGL_FOUND AND OPENGL_GLU_FOUND AND GLUT_FOUND AND OPENGL_INCLUDE_DIR)
		message (STATUS "opengl found: ${OPENGL_gl_LIBRARY}")
		include_directories(${OPENGL_INCLUDE_DIR})
		if (USE_OPENGLES2)
			set(USE_OPENGLES TRUE)
			set(GRAPHICS_OPENGL_LIBRARY GLESv2 EGL)
		elseif (USE_OPENGLES)
			set(GRAPHICS_OPENGL_LIBRARY GLESv1_CM EGL)
		else()
			set(GRAPHICS_OPENGL_LIBRARY ${OPENGL_gl_LIBRARY};${OPENGL_glu_LIBRARY};${GLUT_glut_LIBRARY})
		endif(USE_OPENGLES2)
		if (HAVE_FREEIMAGE)
			list(APPEND GRAPHICS_OPENGL_LIBRARY freeimage)
		endif(HAVE_FREEIMAGE)
		set_with_reason(graphics/opengl "Found OpenGL" TRUE ${GRAPHICS_OPENGL_LIBRARY})
	else()
		message (STATUS "opengl not found")
	endif()
else()
	message (STATUS "no Freetype found")
endif(FREETYPE_FOUND)

if(SDL_FOUND AND SDLIMAGE_FOUND AND FREETYPE_FOUND)
	include_directories( ${SDL_INCLUDE_DIR} ${SDL_IMAGE_INCLUDE_DIRS})
	set(SDL_IMAGE 1)
	if(SDLTTF_FOUND)
		set(SDL_TTF 1)
		list(APPEND SDL_LIBRARY ${SDLTTF_LIBRARY})
	else(SDLTTF_FOUND)
		list(APPEND SDL_LIBRARY ${FREETYPE_LIBRARY})
	endif(SDLTTF_FOUND)
	set_with_reason(graphics/sdl "SDL/SDL_image libs found" TRUE ${SDL_LIBRARY} ${SDLIMAGE_LIBRARY})
endif(SDL_FOUND AND SDLIMAGE_FOUND AND FREETYPE_FOUND)

if(SDL2MAIN AND SDL2IMAGE AND GLES2)
	set_with_reason(graphics/egl "SDL2/SDL2_image libs found" TRUE ${SDL2MAIN} ${SDL2IMAGE} ${GLES2})
	message(STATUS "EGL libs found : ${SDL2MAIN} ${SDL2IMAGE} ${GLES2}")
endif(SDL2MAIN AND SDL2IMAGE AND GLES2)

if (LIBGPS_FOUND)
	if (LIBGPS_NEW_FOUND)
		set(VEHICLE_GPSD_REASON "gpsd lib found")
	else(LIBGPS_NEW_FOUND)
		set(VEHICLE_GPSD_REASON "WARNING: old gpsd lib found, buggy if LC_ALL is set")
	endif(LIBGPS_NEW_FOUND)
	set_with_reason(vehicle/gpsd ${VEHICLE_GPSD_REASON} TRUE ${LIBGPS_LDFLAGS})
endif(LIBGPS_FOUND)

if (GYPSY_FOUND)
	set_with_reason(vehicle/gypsy "gypsy lib found" TRUE)
endif(GYPSY_FOUND)

if (LIBGARMIN_FOUND)
	include_directories(${LIBGARMIN_INCLUDE_DIRS})
	set_with_reason(map/garmin "Garmin library found" TRUE ${LIBGARMIN_LDFLAGS})
endif(LIBGARMIN_FOUND)

if(PYTHONLIBS_FOUND)
	set_with_reason(binding/python "python libraries [${PYTHONLIBS_VERSION_STRING}] found" TRUE ${PYTHON_LIBRARIES})
endif()

if (HAVE_LIBSPEECHD)
	set_with_reason(speech/speech_dispatcher "speech_dispatcher lib found" TRUE speechd)
endif(HAVE_LIBSPEECHD)

if (HAVE_SYSTEM)
	set_with_reason(speech/cmdline "system() call is available" TRUE)
endif(HAVE_SYSTEM)

if (HAVE_CREATEPROCESS)
	set_with_reason(speech/cmdline "CreateProcess() call is available" TRUE)
endif(HAVE_CREATEPROCESS)

if (GETTEXT_FOUND)
	set_with_reason(USE_NATIVE_LANGUAGE_SUPPORT "Gettext found" TRUE)
endif(GETTEXT_FOUND)

#Independent modules
add_module(graphics/null "Default" TRUE)
add_module(osd/core "Default" TRUE)
add_module(vehicle/demo "Default" TRUE)
add_module(vehicle/file "Default" TRUE)
add_module(vehicle/null "Default" FALSE)
add_module(gui/internal "Default" TRUE)
add_module(map/binfile "Default" TRUE)
add_module(map/filter "Default" TRUE)
if(NOT MSVC)
	add_module(map/mg "Default" TRUE)
endif(NOT MSVC)
add_module_plugin(support/shapefile "Default" TRUE)
set(map_shapefile_INCLUDES "${CMAKE_SOURCE_DIR}/navit/support/shapefile")
#set(map_shapefile_LIBRARY_DIRS "${CMAKE_BINARY_DIR}/navit/support/shapefile")
set(map_shapefile_LIBS "support_shapefile")
add_module(map/shapefile "Default" TRUE)
add_module(map/textfile "Default" TRUE)
add_module(map/csv "Default" TRUE)

#Modules without test yet
add_module(plugin/pedestrian "Default" FALSE)
add_module(plugin/j1850 "Default" FALSE)
add_module(speech/android "Default" FALSE)
add_module(speech/espeak "Default" FALSE)
add_module(speech/iphone "Default" FALSE)
add_module(traffic/dummy "Default" TRUE)
add_module(traffic/null "Default" TRUE)
add_module(traffic/traff_android "Default" FALSE)
add_module(vehicle/android "Default" FALSE)
add_module(vehicle/iphone "Default" FALSE)
add_module(vehicle/wince "Default" FALSE)
add_module(graphics/cocoa "Default" FALSE)

# other features
add_feature(USE_PLUGINS "default" TRUE)
add_feature(USE_ROUTING "default" TRUE)
add_feature(USE_SVG "default" TRUE)
add_feature(SVG2PNG "default" TRUE)
add_feature(SAMPLE_MAP "default" TRUE)
add_feature(NETWORK_INFO "default" FALSE)
add_feature(GUI_INTERNAL_VISUAL_DBG "default" FALSE)

if (GUI_INTERNAL_VISUAL_DBG)
	list(FIND ALL_MODULES  gui/internal GUI_INTERNAL_ENABLED)
	if ( ${GUI_INTERNAL_ENABLED} LESS 0 )
		message(WARNING "GUI_INTERNAL_VISUAL_DBG enabled but gui/internal module is not included in compilation")
	endif()
endif(GUI_INTERNAL_VISUAL_DBG)

IF(NOT svg2png_scaling)
	IF(NOT ANDROID)
		set(svg2png_scaling 0 16 32 48 64 96)
	ELSE()
		set(svg2png_scaling -1 24 32 48 64 96 128)
	ENDIF()
ENDIF()
IF(NOT svg2png_scaling_flag)
	IF(NOT ANDROID)
		set(svg2png_scaling_flag 32)
	ELSE()
		set(svg2png_scaling_flag -1 24 32 64 96)
	ENDIF()
ENDIF()
IF(NOT svg2png_scaling_nav)
	IF(NOT ANDROID)
		set(svg2png_scaling_nav 64)
	ELSE()
		set(svg2png_scaling_nav -1 24 32 48 64 96 128)
	ENDIF()
ENDIF()
IF(NOT svg2png_scaling_textures)
	IF(NOT ANDROID)
		set(svg2png_scaling_textures 0)
	ELSE()
		set(svg2png_scaling_textures 0)
	ENDIF()
ENDIF()

add_feature(DBUS_USE_SYSTEM_BUS "default" FALSE)
add_feature(BUILD_MAPTOOL "default" TRUE)
add_feature(XSL_PROCESSING "default" TRUE)

set(SUPPORTED_XSLT_PROCESSORS "saxonb-xslt;saxon;saxon8;saxon-xslt;xsltproc;transform.exe")
find_program(XSLT_PROCESSOR NAMES ${SUPPORTED_XSLT_PROCESSORS})
if(XSLT_PROCESSOR)
	message(STATUS "Found XSLT processor: ${XSLT_PROCESSOR}")
	execute_process(COMMAND ${XSLT_PROCESSOR} -snone ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test.xml ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test.xslt
		RESULT_VARIABLE SAXON_ERROR OUTPUT_QUIET ERROR_QUIET)
	if (NOT SAXON_ERROR)
		set (XSLT_PROCESSOR_OPTIONS -snone)
	endif()
	# additional parameter is passed to the stylesheet processor as transformation parameter
	macro(compose_xslt_transform_command CMDVAR XSLT_FILE SRC_XML DEST_XML)
		if(${XSLT_PROCESSOR} MATCHES "xsltproc")
			set(${CMDVAR} COMMAND ${XSLT_PROCESSOR} ${XSLT_PROCESSOR_OPTIONS} ${XSLT_FILE} ${SRC_XML} >${DEST_XML})
		else()
			set(${CMDVAR} COMMAND ${XSLT_PROCESSOR} ${XSLT_PROCESSOR_OPTIONS} ${SRC_XML} ${XSLT_FILE} ${ARGN} >${DEST_XML})
		endif()
	endmacro()
else()
	cfg_feature(XSL_PROCESSING "Saxon missing" FALSE)
endif(XSLT_PROCESSOR)

if (NOT XSL_PROCESSING)
	message(WARNING "No XSLT processor available. You have to configure "
		"navit.xml yourself, or install an XSLT processor (supported: "
		"${SUPPORTED_XSLT_PROCESSORS}).")
endif()

### Platform specific settings
if(NOT CACHE_SIZE)
	SET(CACHE_SIZE 1048576)
endif(NOT CACHE_SIZE)

if(WIN32 OR WINCE)
	SET(CMAKE_EXECUTABLE_SUFFIX ".exe") #remove it when wince'll use cmake 3
	add_module(graphics/win32 "Windows detected" TRUE)
	add_plugin(support/win32 "Windows detected" TRUE)

	SET(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff -I ${CMAKE_CURRENT_SOURCE_DIR}/navit/gui/win32/resources <DEFINES> -i <SOURCE> -o <OBJECT>")
	set_with_reason(binding/win32 "Windows detected" TRUE)

	# vehicle_file is broken for windows. use vehicle_wince instead
	# whicle_wince isn't buildable on non-CE windows ssytems

	# plugins currently not supported on windows
	set_with_reason(USE_PLUGINS "win32: currently not supported" FALSE)

	set(HAVE_API_WIN32_BASE 1)
	set(EZXML_NOMMAP 1)

	# Image stuff
	if(NOT graphics/qt_qpainter)
		set_with_reason(USE_SVG "win32: SVGs currently not supported" FALSE)
	else(NOT graphics/qt_qpainter)
		MESSAGE(STATUS "win32: SVGs may not be supported by every available graphics")
	endif(NOT graphics/qt_qpainter)

	set(BIN_DIR bin)
	set(SHARE_DIR ./)
	set(LOCALE_DIR locale)
	set(IMAGE_DIR icons)
	set(TEXTURE_DIR textures)


	if(HAVE_GTK2 AND NOT MSVC)
		#GTK requires special compile flags
		add_definitions("-mms-bitfields")
	endif(HAVE_GTK2 AND NOT MSVC)
	if(MSVC AND support/espeak)
		add_definitions(-DPLATFORM_WINDOWS)
	endif(MSVC AND support/espeak)
	CHECK_LIBRARY_EXISTS(ws2_32 WSAStartup "" HAVE_WINSOCK)
	if(HAVE_WINSOCK)
		list(APPEND NAVIT_LIBS ws2_32)
	else()
		CHECK_LIBRARY_EXISTS(ws2 WSAStartup "" HAVE_WINSOCK_2)
		if(HAVE_WINSOCK_2)
			set(HAVE_WINSOCK 1)
			list(APPEND NAVIT_LIBS ws2)
		endif()
	endif(HAVE_WINSOCK)

	if(MSVC)
		set(HAVE_PRAGMA_PACK 1)
		add_plugin(support/xgetopt "Windows detected" TRUE)
	endif(MSVC)
	set_with_reason(USE_NATIVE_LANGUAGE_SUPPORT "Windows detected" TRUE)
	enable_language(RC)

	set(XSLTS "windows;${XSLTS}" CACHE STRING "define a semicolon seperated list of XSLTs to process")
endif()
if (WIN32 AND NOT WINCE)
	set(HAVE_API_WIN32 1)
	set(HAVE_STDINT_H 1)
	list(APPEND NAVIT_LIBS winmm)
	set_with_reason(speech/cmdline "using native tts system of windows instead of espeak" TRUE)
        set(HAVE_PRAGMA_PACK 1)
endif()
if(WINCE)
	add_plugin(support/libc "wince detected" TRUE)
	set(HAVE_API_WIN32_CE 1)
	set(BUILD_MAPTOOL FALSE)
	# mingw32ce since gcc 4.7.0 needs HAVE_PRAGMA_PACK as __attribute__((packed)) is broken, see gcc bug 52991
	set(HAVE_PRAGMA_PACK 1)
	set_with_reason(vehicle/file "wince: currently broken" FALSE)
	set_with_reason(vehicle/wince "wince detected" TRUE)
	set_with_reason(support/ezxml "Windows detected" TRUE)
	set_with_reason(speech/espeak "Windows detected" TRUE)
	#speech/espeak does use windows threads, and therefore needs only parts of
	#espeak lib. INTERNAL_ESPEAK_COMPLETE controls this.
	set_with_reason(INTERNAL_ESPEAK_COMPLETE "Windows detected" FALSE)
	set_with_reason(support/espeak "Windows detected" TRUE)
endif()
if (APPLE OR USE_UIKIT)
	set_with_reason(vehicle/iphone "apple detected" TRUE)
	set_with_reason(graphics/cocoa "apple detected" TRUE)
	if (EXISTS "${CMAKE_OSX_SYSROOT}/System/Library/PrivateFrameworks/VoiceServices.framework")
		set_with_reason(speech/iphone "apple detected" TRUE)
	endif()
	set(BUILD_BUNDLE TRUE CACHE BOOLEAN "build an osx bundle")
endif()

if(CMAKE_SIZEOF_VOID_P LESS 8)
	set_with_reason(BUILD_MAPTOOL "maptool works only on 64 bit architectures" FALSE)
endif()

if(BUILD_MAPTOOL)
	find_package(Protobuf-c REQUIRED)
	if(NOT PROTOBUF_C_FOUND)
		set_with_reason(BUILD_MAPTOOL "PROTOBUF-C not found" FALSE)
	endif()
endif()

set(LOCALEDIR "${LOCALE_DIR}")

find_program(BZCAT NAMES bzcat)
if (SAMPLE_MAP)
	if(CMAKE_CROSSCOMPILING)
		cfg_feature(SAMPLE_MAP "downloading binary map because of cross compiling" TRUE)
		set(DOWNLOAD_SAMPLE_MAP TRUE)
	elseif(NOT BZCAT)
		cfg_feature(SAMPLE_MAP "downloading binary map because of missing bzcat" TRUE)
		set(DOWNLOAD_SAMPLE_MAP TRUE)
	elseif(NOT BUILD_MAPTOOL)
		cfg_feature(SAMPLE_MAP "downloading binary map because maptool compilation is disabled" TRUE)
		set(DOWNLOAD_SAMPLE_MAP TRUE)
	endif(CMAKE_CROSSCOMPILING)
endif(SAMPLE_MAP)

check_symbol_exists (getifaddrs "sys/types.h;ifaddrs.h" HAS_IFADDRS)
if (HAS_IFADDRS)
	cfg_feature(NETWORK_INFO "ifaddrs.h found" TRUE)
endif(HAS_IFADDRS)

if(ANDROID)
	message(STATUS "Using generator " ${CMAKE_GENERATOR})
	if (NOT ${CMAKE_GENERATOR} STREQUAL Ninja)
		find_program(ANDROID_LOCATION NAMES android android.bat)
		if (NOT ANDROID_LOCATION)
			message_error( "Could not find 'Android SDK and AVD Manager'. Please install the android sdk and add the <android-sdk>/tools directory to the search path.")
		endif()
		set(XSLTS "android;${XSLTS}" CACHE STRING "define a semicolon seperated list of XSLTs to process")
	endif (NOT ${CMAKE_GENERATOR} STREQUAL Ninja)
	list(APPEND NAVIT_LIBS log)
	set(HAVE_API_ANDROID 1)
	set_with_reason(speech/cmdline "Android detected" FALSE)
	set_with_reason(graphics/null "Android detected" FALSE)
	set_with_reason(graphics/android "Android detected" TRUE)
	set_with_reason(speech/android "Android detected" TRUE)
	set_with_reason(traffic/traff_android "Android detected" TRUE)
	set_with_reason(vehicle/android "Android detected" TRUE)
	set_with_reason(vehicle/file "Android detected" FALSE)
	set_with_reason(vehicle/gpsd "Android detected" FALSE)
	set_with_reason(map/filter "Android detected" FALSE)
	set_with_reason(map/garmin "Android detected" FALSE)
	set_with_reason(USE_NATIVE_LANGUAGE_SUPPORT "Android detected" TRUE)
	#   set_with_reason(plugin/pedestrian "Android detected" TRUE)
	set_with_reason(support/libpng "Android detected" FALSE)
	set(SHARED_LIBNAVIT TRUE)

	add_feature(XPM2PNG "Android detected" TRUE)
	set(NAVIT_COMPILE_FLAGS "${NAVIT_COMPILE_FLAGS} -fPIC")

endif(ANDROID)

if(FREETYPE_FOUND AND NOT FONTCONFIG_FOUND)
	add_subdirectory( "${CMAKE_CURRENT_SOURCE_DIR}/navit/fonts")
endif()

# Image conversion
find_program(IMAGE_CONVERTER NAMES convert)
execute_process(COMMAND ${IMAGE_CONVERTER} -list format OUTPUT_VARIABLE CONVERT_FORMATS)
if(CONVERT_FORMATS MATCHES ".*XPM[ *][ ]*XPM[ ]*r[w-].*")
	set(IMAGE_CONVERTER_XPM ${IMAGE_CONVERTER})
endif()

set(CMAKE_APPBUNDLE_PATH "")
if (SVG2PNG)
	if (NOT IMAGE_CONVERTER_SVGZ)
		set (SVG_CONVERTER_PROGS rsvg-convert ksvgtopng ksvgtopng4 inkscape)
		set (CMAKE_FIND_APPBUNDLE "NEVER")
		find_program(IMAGE_CONVERTER_SVGZ NAMES ${SVG_CONVERTER_PROGS} PATHS /Applications/Inkscape.app/Contents/Resources/bin)
		if (NOT IMAGE_CONVERTER_SVGZ)
			if(CONVERT_FORMATS MATCHES ".*[ ]*SVG[ ]*r[w-].*")
				set(IMAGE_CONVERTER_SVGZ ${IMAGE_CONVERTER})
			endif()
		endif()
	endif(NOT IMAGE_CONVERTER_SVGZ)
	if (NOT IMAGE_CONVERTER_SVG)
		set(IMAGE_CONVERTER_SVG ${IMAGE_CONVERTER_SVGZ})
	endif(NOT IMAGE_CONVERTER_SVG)

	message(STATUS "SVG2PNG-Converter: ${IMAGE_CONVERTER_SVGZ}")
	if (NOT IMAGE_CONVERTER_SVGZ)
		message(WARNING "No SVG2PNG converter found. Please install one of the following tools: ${SVG_CONVERTER_PROGS}, or imagemagick with svg support")
		set_with_reason(SVG2PNG "no converter found" FALSE)
	endif(NOT IMAGE_CONVERTER_SVGZ)
endif(SVG2PNG)

if (XPM2PNG)
	message(STATUS "XPM2PNG-Converter: ${IMAGE_CONVERTER_XPM}")
	if (NOT IMAGE_CONVERTER_XPM)
		message(WARNING "No XPM2PNG converter found. Please install imagemagick with xpm support")
		set_with_reason(XPM2PNG "no converter found" FALSE)
	endif(NOT IMAGE_CONVERTER_XPM)
endif(XPM2PNG)

set(XSLTS ${XSLTS} CACHE STRING "define a semicolon seperated list of XSLTs to process")

# Plugins
if(USE_PLUGINS)
	set(MODULE_BUILD_TYPE "MODULE")
	add_definitions("-fPIC")
	list(APPEND NAVIT_LIBS dl)
else()
	set(MODULE_BUILD_TYPE "STATIC")
endif(USE_PLUGINS)
message(STATUS "Use plugins: ${MODULE_BUILD_TYPE}")

CHECK_INCLUDE_FILES (malloc.h HAVE_MALLOC_H)
CHECK_INCLUDE_FILES ("sys/param.h;sys/mount.h" HAVE_SYS_MOUNT_H)
CHECK_INCLUDE_FILES (unistd.h HAVE_UNISTD_H)
CHECK_FUNCTION_EXISTS (getcwd HAVE_GETCWD)
CHECK_FUNCTION_EXISTS (memalign HAVE_MEMALIGN)
CHECK_FUNCTION_EXISTS (valloc HAVE_VALLOC)
CHECK_FUNCTION_EXISTS (posix_memalign HAVE_POSIX_MEMALIGN)
CHECK_FUNCTION_EXISTS (popen HAVE_POPEN)
CHECK_FUNCTION_EXISTS (_atoi64 HAVE__ATOI64)

CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
			   "${CMAKE_CURRENT_BINARY_DIR}/config.h" )

# Compile with -Wall -Wextra. We need all the help we can get from the compiler :-).
# Disabled warnings:
# -Wno-missing-field-initializers: Used a lot, does not seem problematic.
# -Wno-unused-parameter: Unfortunately occurs frequently because of
#                        functions implementing the interface of a plugin.
# -Wno-sign-compare: We currently just use int almost everywhere.
#                    Unclear if it's really worth correcting.
add_compiler_flag_if_available("-Wall")
add_compiler_flag_if_available("-Wno-unused-parameter")
add_compiler_flag_if_available("-Wno-sign-compare")
add_compiler_flag_if_available("-Wno-missing-field-initializers")
add_compiler_flag_if_available("-Wundef")
add_compiler_flag_if_available("-Wcast-align")
add_compiler_flag_if_available("-Wpointer-arith")
add_compiler_flag_if_available("-Wextra")
add_compiler_flag_if_available("-Wdate-time")
add_compiler_flag_if_available("-Wmissing-prototypes")
add_compiler_flag_if_available("-Wstrict-prototypes")
add_compiler_flag_if_available("-Wformat-security")
add_compiler_flag_if_available("-Werror=format-security")
add_compiler_flag_if_available("-fstack-protector-strong")
add_compiler_flag_if_available("-D_FORTIFY_SOURCE=2")

if (EXTRA_DEFINES)
	add_definitions("${EXTRA_DEFINES}")
endif(EXTRA_DEFINES)

if (NOT NAVIT_DEPENDENCY_ERROR)
	message("\nSummary:\n")

	set(SUMMARY_COMPONENTS ${ALL_PLUGINS} ${ALL_MODULE_PLUGINS} ${ALL_MODULES})
	list(SORT SUMMARY_COMPONENTS)

	set(LAST_TYPE NONE)
	foreach ( SUMMARY_COMP ${SUMMARY_COMPONENTS})
		# split path to type and name
		string(REPLACE "/" ";" SUMMARY_COMP_LIST ${SUMMARY_COMP})
		list(GET SUMMARY_COMP_LIST 0 SUMMARY_COMP_TYPE)
		list(LENGTH SUMMARY_COMP_LIST SUMMARY_COMP_LIST_LENGTH)
		if ( SUMMARY_COMP_LIST_LENGTH GREATER 1 )
			list(GET SUMMARY_COMP_LIST 1 SUMMARY_COMP_NAME)
		else()
			set(SUMMARY_COMP_NAME ${SUMMARY_COMP})
		endif()
		if ( NOT ${LAST_TYPE} STREQUAL ${SUMMARY_COMP_TYPE})
			message("\n--->>> ${SUMMARY_COMP_TYPE}")
			set(LAST_TYPE ${SUMMARY_COMP_TYPE})
		endif()
		if (${SUMMARY_COMP})
			message("Enabled   ${SUMMARY_COMP_NAME} ( ${${SUMMARY_COMP}_REASON} )")
		else()
			message("Disabled  ${SUMMARY_COMP_NAME} ( ${${SUMMARY_COMP}_REASON} )")
		endif()
	endforeach()

	list(SORT ALL_FEATURES)
	message("\n--->>> Features")
	foreach ( FEATURE ${ALL_FEATURES})
		if ( ${FEATURE} )
			message("Enabled   ${FEATURE} ( ${${FEATURE}_REASON} )")
		else()
			message("Disabled  ${FEATURE} ( ${${FEATURE}_REASON} )")
		endif()
	endforeach()

	if (XSL_PROCESSING)
		if (XSLTS)
			message("\nProcessing XSLT files: ${XSLTS}")
		else()
			message("\nProcessing XSLT files: NONE")
		endif(XSLTS)
		message("See navit/xslt for available XSLT files, and put them into "
			"cache variable 'XSLTS' (without extension .xslt).")
	endif(XSL_PROCESSING)

	message("\nTo configure your build use 'cmake -L' to find changeable variables and run cmake again with 'cmake -D <var-name>=<your value> ...'.")
endif(NOT NAVIT_DEPENDENCY_ERROR)

add_subdirectory (navit)
add_subdirectory (man)


if (USE_NATIVE_LANGUAGE_SUPPORT)
	add_subdirectory (po)
endif(USE_NATIVE_LANGUAGE_SUPPORT)