diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce8ff7442..950fc9bd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,297 +1,299 @@
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 
 project(umbrello)
 
 if(POLICY CMP0028)
     cmake_policy(SET CMP0028 OLD)
 endif()
 
 if(POLICY CMP0057)
     cmake_policy(SET CMP0057 NEW)
 endif()
 
 # KDE Application Version, managed by release script
 set (RELEASE_SERVICE_VERSION_MAJOR "20")
 set (RELEASE_SERVICE_VERSION_MINOR "07")
 set (RELEASE_SERVICE_VERSION_MICRO "70")
 
 set(UMBRELLO_VERSION_MAJOR "2")
-set(UMBRELLO_VERSION_MINOR "30")
+set(UMBRELLO_VERSION_MINOR "31")
 if (RELEASE_SERVICE_VERSION_MICRO GREATER_EQUAL 70)
-    math(EXPR UMBRELLO_VERSION_MINOR "${UMBRELLO_VERSION_MINOR}-0")
+    math(EXPR UMBRELLO_VERSION_MINOR "${UMBRELLO_VERSION_MINOR}+1")
 endif()
 
 set(UMBRELLO_VERSION_PATCH ${RELEASE_SERVICE_VERSION_MICRO})
 
 option(BUILD_APIDOC "Create api documentation" ON)
 
 option(BUILD_ICONS "Create icons from svg source" OFF)
 
 option(BUILD_CURSOR_ICONS "Create cursor icons from svg source" OFF)
 
 option(BUILD_ICONS_INTO_SIZE_RELATED_DIRS "place icons into separate directories (for debugging purpose)" OFF)
 
 option(BUILD_KF5 "Build for KDE Frameworks 5" ON)
 
 option(BUILD_PHP_IMPORT "Build with php import support" ON)
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 include(Macros)
 
 set(CMAKE_AUTORCC ON)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -fno-delete-null-pointer-checks")
     # TODO: after removing kdelibs4support this could also be removed
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 endif()
 
 if(NOT BUILD_KF5)
     set(APP_SUFFIX)
     set(LIB_PREFIX Qt4::Qt)
     set(CMAKE_AUTOMOC ON)
     set(CMAKE_INCLUDE_CURRENT_DIR ON)
     include(ECMKDE4Macros)
     set(QT_MIN_VERSION "4.8.0")
     set(KDEV_MIN_VERSION 1.7.3)
     set(KDEV_SOURCE_DIR lib/kdev4-php)
     set(KDEV_COMPONENTS)
 else()
     set(APP_SUFFIX 5)
     set(LIB_PREFIX Qt5::)
     # we need some parts of the ECM CMake helpers
     find_package(ECM 1.1.0 REQUIRED NO_MODULE)
     list(APPEND CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
     include(KDEInstallDirs)
     include(KDECompilerSettings NO_POLICY_SCOPE)
     include(KDECMakeSettings)
     include(FeatureSummary)
     include(ECMInstallIcons)
     include(ECMSetupVersion)
     include(ECMOptionalAddSubdirectory)
     include(ECMAddAppIcon)
     include(ECMAddTests)
     set(QT_MIN_VERSION "5.2.0")
     set(KDEV_MIN_VERSION 5.1.2)
     set(KDEV_SOURCE_DIR lib/kdev5-php)
     set(KDEV_COMPONENTS KDev::Interfaces KDev::Language KDev::Shell)
 endif()
 
 # search packages used by Qt
 find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS
     Core
     Gui
     PrintSupport
     Svg
     Test
     Widgets
     Xml
     WebKitWidgets
 )
 
 # search packages used by KDE
 find_package(KF5 REQUIRED COMPONENTS
     Archive
     Completion
     Config
     CoreAddons
     Crash
     DocTools
     I18n
     IconThemes
     KDELibs4Support
     KIO
     TextEditor
     WidgetsAddons
     WindowSystem
     XmlGui
 )
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     string(REPLACE "-Wsuggest-override" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 endif()
 
 if(BUILD_PHP_IMPORT)
     find_package(KDevelop-PG-Qt)
     find_package(KDevPlatform ${KDEV_MIN_VERSION} COMPONENTS ${KDEV_COMPONENTS})
 endif()
 if(KDEVPGQT_FOUND AND KDEVPLATFORM_FOUND)
     message(STATUS "requirements available - enable building php code import")
     include_directories(
         ${KDEVPGQT_INCLUDE_DIR}
         ${KDEVPLATFORM_INCLUDE_DIR}
         ${CMAKE_SOURCE_DIR}/${KDEV_SOURCE_DIR}/parser
         ${CMAKE_BINARY_DIR}/${KDEV_SOURCE_DIR}/parser
     )
     set(NO_INSTALL 1)
     set(BUILD_PARSER_ONLY 1)
     set(BUILD_PHP_IMPORT 1)
     add_definitions(
         -DKDEVPHPPARSER_EXPORT=
         -DENABLE_PHP_IMPORT
     )
     add_subdirectory(lib/kdevplatform)
     add_subdirectory(${KDEV_SOURCE_DIR})
 else()
     set(BUILD_PHP_IMPORT 0)
 endif()
 
 set(UMBRELLO_DATA_INSTALL_DIR ${DATA_INSTALL_DIR}/umbrello${APP_SUFFIX})
 
 if(NOT BUILD_KF5)
     macro_display_feature_log()
     KDE4_NO_ENABLE_FINAL(umbrello)
 else()
     set(BUILD_UNITTESTS 1)
 
     ki18n_install(po)
     kdoctools_install(po)
 endif()
 
 if(POLICY CMP0071)
   cmake_policy(SET CMP0071 OLD)
 endif()
 
 # use some compile flags
 add_definitions(
     -DQT_NO_SIGNAL_SLOTS_KEYWORDS
     -DQT_NO_URL_CAST_FROM_STRING
 )
 
 # set default umbrello version
 # umbrello version could be overridden by cmake command line using -DUMBRELLO_VERSION_STRING=major.minor.patch
 if(NOT UMBRELLO_VERSION_STRING)
     set(UMBRELLO_VERSION_STRING "${UMBRELLO_VERSION_MAJOR}.${UMBRELLO_VERSION_MINOR}.${UMBRELLO_VERSION_PATCH}")
     if(EXISTS ${CMAKE_SOURCE_DIR}/.git)
         execute_process(
             COMMAND git rev-parse --short HEAD
             WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
             OUTPUT_VARIABLE _hash
         )
         if(_hash)
            string(REPLACE "\n" "" hash ${_hash})
            set(UMBRELLO_VERSION_STRING "${UMBRELLO_VERSION_STRING}-${hash}")
         endif()
     endif()
 endif()
 
 message(STATUS "Using umbrello version ${UMBRELLO_VERSION_STRING}")
 add_definitions(-DUMBRELLO_VERSION_STRING="${UMBRELLO_VERSION_STRING}")
 
 message(STATUS "Using automoc4 version ${AUTOMOC4_VERSION}")
 message(STATUS "Using cmake version ${CMAKE_VERSION}")
 message(STATUS "Using Qt version ${QTVERSION}")
 
 find_package(LibXslt)
 set_package_properties(LibXslt PROPERTIES
     DESCRIPTION "A library to transform XMLfiles into other XML files."
     URL "http://xmlsoft.org/XSLT"
     TYPE REQUIRED)
 
 find_package(LibXml2)
 set_package_properties(LibXml2 PROPERTIES
     DESCRIPTION "Libraries used to develop XML applications."
     URL "http://xmlsoft.org"
     TYPE REQUIRED)
 
 include_directories(
     ${CMAKE_BINARY_DIR}
 )
 
 #
 # Unstable features should not be enabled in stable branches
 # This macro limits unstable feature to development branches
 # by only adding -DENABLE_<name> to the compile command when
 # the patch level is >= 70 which includes releases from master
 # beta and rc releases. On cmake configure time a related status
 # note is displayed.
 #
 # syntax:  add_unstable_feature(<name>)
 #
 # In code wrap feature related code with
 #
 #  #ifdef ENABLE_<name>
 #    <feature code>
 #  #endif
 #
 macro(add_unstable_feature name)
     if(UMBRELLO_VERSION_PATCH GREATER 69)
         add_definitions(-DENABLE_${name})
         set(ENABLE_${name} 1)
         message(STATUS "Enable unstable feature ${name} - use '#ifdef ENABLE_${name}' in related code")
     else()
         set(ENABLE_${name} 0)
         message(STATUS "Disable unstable feature ${name}")
     endif()
 endmacro(add_unstable_feature)
 
 add_unstable_feature(WIDGET_SHOW_DOC) # show documentation in classes ticket xxx
 add_unstable_feature(NEW_CODE_GENERATORS) # new c++ code generator
 add_unstable_feature(UML_OBJECTS_WINDOW) # objects dock window
 add_unstable_feature(XMIRESOLUTION) # see https://bugs.kde.org/show_bug.cgi?id=90103
 add_unstable_feature(COMBINED_STATE_DIRECT_EDIT) # experimental feature
 
 # Current object diagram implementation does not follow UML 1.4 standard
 # because of using umbrello specific XMI tag (UML:InstanceAttribute).
 add_unstable_feature(OBJECT_DIAGRAM) # see https://bugs.kde.org/show_bug.cgi?id=123633
 
 # requires cmake >= 3.9.6
 find_package(Doxygen OPTIONAL_COMPONENTS dot)
 if(DOXYGEN_FOUND AND BUILD_APIDOC)
     message(STATUS "found doxygen package")
-    find_program(QHELPGENERATOR_EXECUTABLE qhelpgenerator)
+    find_program(QHELPGENERATOR_EXECUTABLE NAMES qhelpgenerator qhelpgenerator-qt5)
     message(STATUS "found qhelpgenerator ${QHELPGENERATOR_EXECUTABLE}")
     set(DOXYGEN_ABBREVIATE_BRIEF "The $name class" "The $name widget")
     set(DOXYGEN_CALL_GRAPH YES)
     set(DOXYGEN_EXCLUDE_PATTERNS */lib/*)
     set(DOXYGEN_EXTRACT_ALL YES)
     set(DOXYGEN_EXTRACT_PACKAGE YES)
     set(DOXYGEN_EXTRACT_PRIVATE YES)
     set(DOXYGEN_EXTRACT_STATIC YES)
     set(DOXYGEN_GENERATE_HTMLHELP YES)
-    set(DOXYGEN_HAVE_DOT YES)
+    set(DOXYGEN_HAVE_DOT ${DOXYGEN_HAVE_DOT})
+    set(DOXYGEN_DOT_IMAGE_FORMAT svg)
     set(DOXYGEN_MARKDOWN_SUPPORT NO)
-    set(DOXYGEN_MAX_DOT_GRAPH_DEPTH 1000)
+    set(DOT_GRAPH_MAX_NODES 0)
+    set(DOXYGEN_MAX_DOT_GRAPH_DEPTH 0)
     set(DOXYGEN_PROJECT_BRIEF "Umbrello UML Modeller is a Unified Modelling Language (UML) diagram program based on KDE Technology")
     set(DOXYGEN_PROJECT_NUMBER ${UMBRELLO_VERSION_STRING})
     #set(DOXYGEN_PROJECT_LOGO ${CMAKE_SOURCE_DIR}/umbrello/pics/global/hi32-apps-umbrello.png)
     set(DOXYGEN_SOURCE_BROWSER NO)
     set(DOXYGEN_UML_LOOK YES)
     set(DOXYGEN_USE_PDFLATEX NO)
     set(DOXYGEN_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/apidoc)
 
     if(QHELPGENERATOR_EXECUTABLE)
         set(DOXYGEN_GENERATE_QHP YES)
         set(DOXYGEN_QCH_FILE ${CMAKE_BINARY_DIR}/umbrello.qch)
         set(DOXYGEN_QHP_NAMESPACE org.kde.umbrello)
         set(DOXYGEN_QHG_LOCATION ${QHELPGENERATOR_EXECUTABLE})
         set(DOXYGEN_QHP_VIRTUAL_FOLDER doc)
         install(FILES ${DOXYGEN_QCH_FILE} DESTINATION ${QT_DOC_DIR}/qch COMPONENT Devel)
     endif()
 
     doxygen_add_docs(apidoc
         ALL
         ${CMAKE_SOURCE_DIR}
         COMMENT "generating api doc"
     )
 
     install(DIRECTORY ${CMAKE_BINARY_DIR}/apidoc DESTINATION ${UMBRELLO_DATA_INSTALL_DIR})
 endif()
 
 if(LIBXSLT_FOUND AND LIBXML2_FOUND)
     add_subdirectory(umbrello)
     add_subdirectory(doc)
     add_subdirectory(tools)
 endif(LIBXSLT_FOUND AND LIBXML2_FOUND)
 
 add_subdirectory(maintainer)
 
 # for automatic unit tests
 if(BUILD_UNITTESTS)
     ecm_optional_add_subdirectory(unittests)
 endif()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index 68b6d1621..fd3ed4a67 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -1,200 +1,204 @@
 
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 set(SRC_PATH ../umbrello)
 
 include_directories(
       ${LIBXML2_INCLUDE_DIR}
       ${LIBXSLT_INCLUDE_DIR}
       ${CMAKE_SOURCE_DIR}
       ${SRC_PATH}
       ${SRC_PATH}/debug/
       ${SRC_PATH}/dialogs/
       ${SRC_PATH}/dialogs/pages
       ${SRC_PATH}/dialogs/widgets
       ${SRC_PATH}/clipboard
       ${SRC_PATH}/cmds
       ${SRC_PATH}/codegenerators
       ${SRC_PATH}/codegenerators/ada/
       ${SRC_PATH}/codegenerators/as/
       ${SRC_PATH}/codegenerators/cpp/
       ${SRC_PATH}/codegenerators/csharp/
       ${SRC_PATH}/codegenerators/d/
       ${SRC_PATH}/codegenerators/idl/
       ${SRC_PATH}/codegenerators/java/
       ${SRC_PATH}/codegenerators/js/
       ${SRC_PATH}/codegenerators/pascal/
       ${SRC_PATH}/codegenerators/perl/
       ${SRC_PATH}/codegenerators/php/
       ${SRC_PATH}/codegenerators/python/
       ${SRC_PATH}/codegenerators/ruby/
       ${SRC_PATH}/codegenerators/sql/
       ${SRC_PATH}/codegenerators/tcl/
       ${SRC_PATH}/codegenerators/vala/
       ${SRC_PATH}/codegenerators/xml/
       ${SRC_PATH}/codegenwizard
       ${SRC_PATH}/codeimport
       ${SRC_PATH}/debug
       ${SRC_PATH}/dialogs
       ${SRC_PATH}/docgenerators
       ${SRC_PATH}/menus/
       ${SRC_PATH}/refactoring
       ${SRC_PATH}/uml1model/
       ${SRC_PATH}/umlwidgets/
       ${CMAKE_CURRENT_BINARY_DIR}
 )
 
 if(NOT BUILD_KF5)
     set(LIBS
         Qt4::QtCore
         Qt4::QtGui
         Qt4::QtXml
         Qt4::QtTest
         Qt4::QtWebKit
         ${KDE4_KFILE_LIBS}
         ${LIBXML2_LIBRARIES}
         ${LIBXSLT_LIBRARIES}
         libumbrello
     )
 else()
     set(LIBS
         Qt5::Xml
         Qt5::Test
         Qt5::Widgets
         Qt5::WebKitWidgets
         KF5::I18n
         KF5::Crash
         ${LIBXML2_LIBRARIES}
         ${LIBXSLT_LIBRARIES}
         libumbrello
     )
 endif()
 
 ecm_add_test(
     testbasictypes.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testbasictypes
 )
 
 ecm_add_test(
     testumlobject.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testumlobject
 )
 
 ecm_add_test(
     testassociation.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testassociation
 )
 
 ecm_add_test(
     testclassifier.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testclassifier
 )
 
 ecm_add_test(
     testpackage.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testpackage
 )
 
 ecm_add_test(
     testcppwriter.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testcppwriter
 )
 
 ecm_add_test(
     testpythonwriter.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testpythonwriter
 )
 
 ecm_add_test(
     testoptionstate.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testoptionstate
 )
 
 ecm_add_test(
     testumlcanvasobject.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testumlcanvasobject
 )
 
 ecm_add_test(
     testpreconditionwidget.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testpreconditionwidget
 )
 
 ecm_add_test(
     testwidgetbase.cpp
     testbase.cpp
     LINK_LIBRARIES ${LIBS}
     TEST_NAME testwidgetbase
 )
 
 set(testumlroledialog_SRCS
     testumlroledialog.cpp
 )
 
 add_executable(testumlroledialog ${testumlroledialog_SRCS})
 target_link_libraries(testumlroledialog ${LIBS})
 
 add_executable(testcrashhandler testcrashhandler.cpp)
 target_link_libraries(testcrashhandler ${LIBS})
 
 add_executable(testlistpopupmenu testlistpopupmenu.cpp testbase.cpp)
 target_link_libraries(testlistpopupmenu ${LIBS})
 
 find_package(LLVM CONFIG)
 find_package(Clang CONFIG)
 if(NOT Clang_FOUND)
     find_package(CLANG QUIET)
 endif()
 if(LLVM_FOUND AND (Clang_FOUND OR CLANG_FOUND))
     message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
     message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
     message(STATUS "Found CLANG ${CLANG_PACKAGE_VERSION}")
-
+    if(LLVM_PACKAGE_VERSION VERSION_LOWER_EQUAL "8.0.0")
+        set(ENABLE_LLVM_TESTCASES 1)
+    endif()
+endif()
+if(ENABLE_LLVM_TESTCASES)
     include_directories(${LLVM_INCLUDE_DIRS})
     add_definitions(${LLVM_DEFINITIONS})
 
     include_directories(${CLANG_INCLUDE_DIRS})
     add_definitions(${CLANG_DEFINITIONS})
 
     # Now build our tools
     add_executable(testllvm testllvm.cpp)
 
     # Find the libraries that correspond to the LLVM components
     # that we wish to use
     if(LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL "7.0.0")
         set(llvm_libs LLVM)
     else()
         llvm_map_components_to_libnames(llvm_libs support core irreader analysis)
     endif()
 
     # Link against LLVM libraries
     target_link_libraries(testllvm ${llvm_libs} clangFrontend clangTooling clangBasic clangSerialization)
 
     add_executable(testllvmparser testllvmparser.cpp)
     if(LLVM_PACKAGE_VERSION VERSION_LESS "7.0.0")
         llvm_map_components_to_libnames(llvm_libs support)
     endif()
     target_link_libraries(testllvmparser ${llvm_libs} clangFrontend clangTooling clangAST clangBasic clangSerialization ${LIBS})
     ecm_mark_nongui_executable(testllvm testllvmparser)
 endif()
 
 add_custom_target(check COMMAND ${CMAKE_BUILD_TOOL} test)