diff --git a/umbrello/CMakeLists.txt b/umbrello/CMakeLists.txt
index 03be30c36..73715a2b5 100644
--- a/umbrello/CMakeLists.txt
+++ b/umbrello/CMakeLists.txt
@@ -1,674 +1,675 @@
 add_subdirectory( headings )
 
 if(ENABLE_OBJECT_DIAGRAM)
     set(ACTION_NEW_OBJECT_DIAGRAM "<Action name=\"new_object_diagram\"/>")
 endif()
 configure_file(umbrelloui.rc.cmake ${CMAKE_CURRENT_BINARY_DIR}/umbrelloui.rc @ONLY)
 if(BUILD_KF5)
     configure_file(ui.qrc.cmake ${CMAKE_CURRENT_BINARY_DIR}/ui.qrc @ONLY)
 endif()
 
 ########### set variables #############
 
 # php import support requires kdevplatform and kdev-php
 # which does not compile without NO_CAST_XX_ASCII
 if(NOT BUILD_PHP_IMPORT)
     add_definitions(-DQT_NO_CAST_TO_ASCII)
     add_definitions(-DQT_NO_CAST_FROM_ASCII)
 endif()
 # Some definitions for experimental code or debugging
 # TODO migrate debug settings to DEBUG_REGISTER macro
 #add_definitions(-DXMI_FLAT_PACKAGES)             # umlobject
 #add_definitions(-DDEBUG_LVITEM_INSERTION_ORDER)  # umllistviewitem
 #add_definitions(-DTRY_BUGFIX_120682)             # model_utils
 #add_definitions(-DVERBOSE_DEBUGGING)             # listpopupmenu, association, petaltree2uml,
                                                   # umlobject, umldoc, classifierlistpage
 if(UNIX)
     add_definitions(-D_GLIBCXX_PERMIT_BACKWARD_HASH)
 endif()
 
 add_definitions(-DCMAKE_BINARY_DIR="${CMAKE_BINARY_DIR}")
 
 include_directories(
   ${LIBXML2_INCLUDE_DIR}
   ${LIBXSLT_INCLUDE_DIR}
   ${CMAKE_CURRENT_SOURCE_DIR}/
   ${CMAKE_CURRENT_SOURCE_DIR}/clipboard/
   ${CMAKE_CURRENT_SOURCE_DIR}/cmds
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/ada/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/as/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/cpp/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/csharp/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/d/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/idl/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/java/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/js/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/pascal/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/perl/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/php/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/python/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/ruby/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/sql/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/tcl/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/vala/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/xml/
   ${CMAKE_CURRENT_SOURCE_DIR}/codegenwizard/
   ${CMAKE_CURRENT_SOURCE_DIR}/codeimport/
   ${CMAKE_CURRENT_SOURCE_DIR}/codeimport/csharp/
   ${CMAKE_CURRENT_SOURCE_DIR}/codeimpwizard/
   ${CMAKE_CURRENT_SOURCE_DIR}/debug/
   ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/
   ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/pages/
   ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/widgets/
   ${CMAKE_CURRENT_SOURCE_DIR}/docgenerators/
   ${CMAKE_CURRENT_SOURCE_DIR}/finder/
   ${CMAKE_CURRENT_SOURCE_DIR}/refactoring/
   ${CMAKE_CURRENT_SOURCE_DIR}/uml1model/
   ${CMAKE_CURRENT_SOURCE_DIR}/umlwidgets/
   ${CMAKE_CURRENT_SOURCE_DIR}/menus
   ${CMAKE_SOURCE_DIR}/lib/cppparser/
   ${CMAKE_SOURCE_DIR}/lib/interfaces/
 )
 
 set(libdebug_SRCS
     debug/debug_utils.cpp
 )
 
 set(libcodegenerator_SRCS
     codegenerators/advancedcodegenerator.cpp
     codegenerators/classifiercodedocument.cpp
     codegenerators/codeaccessormethod.cpp
     codegenerators/codeblock.cpp
     codegenerators/codeblockwithcomments.cpp
     codegenerators/codeclassfield.cpp
     codegenerators/codeclassfielddeclarationblock.cpp
     codegenerators/codecomment.cpp
     codegenerators/codedocument.cpp
     codegenerators/codegenerationpolicy.cpp
     codegenerators/codegenerator.cpp
     codegenerators/codegenfactory.cpp
     codegenerators/codegenobjectwithtextblocks.cpp
     codegenerators/codegenpolicyext.cpp
     codegenerators/codegen_utils.cpp
     codegenerators/codemethodblock.cpp
     codegenerators/codeoperation.cpp
     codegenerators/codeparameter.cpp
     codegenerators/ada/adawriter.cpp
     codegenerators/as/aswriter.cpp
     codegenerators/cpp/cppcodeclassfield.cpp
     codegenerators/cpp/cppcodecomment.cpp
     codegenerators/cpp/cppcodedocumentation.cpp
     codegenerators/cpp/cppcodegenerationform.cpp
     codegenerators/cpp/cppcodegenerationpolicy.cpp
     codegenerators/cpp/cppcodegenerationpolicypage.cpp
     codegenerators/cpp/cppcodegenerator.cpp
     codegenerators/cpp/cppheaderclassdeclarationblock.cpp
     codegenerators/cpp/cppheadercodeaccessormethod.cpp
     codegenerators/cpp/cppheadercodeclassfielddeclarationblock.cpp
     codegenerators/cpp/cppheadercodedocument.cpp
     codegenerators/cpp/cppheadercodeoperation.cpp
     codegenerators/cpp/cppmakecodedocument.cpp
     codegenerators/cpp/cppsourcecodeaccessormethod.cpp
     codegenerators/cpp/cppsourcecodeclassfielddeclarationblock.cpp
     codegenerators/cpp/cppsourcecodedocument.cpp
     codegenerators/cpp/cppsourcecodeoperation.cpp
     codegenerators/cpp/cppwriter.cpp
     codegenerators/csharp/csharpwriter.cpp
     codegenerators/d/dclassdeclarationblock.cpp
     codegenerators/d/dclassifiercodedocument.cpp
     codegenerators/d/dcodeaccessormethod.cpp
     codegenerators/d/dcodeclassfield.cpp
     codegenerators/d/dcodeclassfielddeclarationblock.cpp
     codegenerators/d/dcodecomment.cpp
     codegenerators/d/dcodedocumentation.cpp
     codegenerators/d/dcodegenerationpolicy.cpp
     codegenerators/d/dcodegenerationpolicypage.cpp
     codegenerators/d/dcodegenerator.cpp
     codegenerators/d/dcodeoperation.cpp
     codegenerators/d/dwriter.cpp
     codegenerators/hierarchicalcodeblock.cpp
     codegenerators/idl/idlwriter.cpp
     codegenerators/java/javaantcodedocument.cpp
     codegenerators/java/javaclassdeclarationblock.cpp
     codegenerators/java/javaclassifiercodedocument.cpp
     codegenerators/java/javacodeaccessormethod.cpp
     codegenerators/java/javacodeclassfield.cpp
     codegenerators/java/javacodeclassfielddeclarationblock.cpp
     codegenerators/java/javacodecomment.cpp
     codegenerators/java/javacodedocumentation.cpp
     codegenerators/java/javacodegenerationpolicy.cpp
     codegenerators/java/javacodegenerationpolicypage.cpp
     codegenerators/java/javacodegenerator.cpp
     codegenerators/java/javacodeoperation.cpp
     codegenerators/java/javawriter.cpp
     codegenerators/js/jswriter.cpp
     codegenerators/ownedcodeblock.cpp
     codegenerators/ownedhierarchicalcodeblock.cpp
     codegenerators/pascal/pascalwriter.cpp
     codegenerators/perl/perlwriter.cpp
     codegenerators/php/php5writer.cpp
     codegenerators/php/phpwriter.cpp
     codegenerators/python/pythonwriter.cpp
     codegenerators/ruby/rubyclassdeclarationblock.cpp
     codegenerators/ruby/rubyclassifiercodedocument.cpp
     codegenerators/ruby/rubycodeaccessormethod.cpp
     codegenerators/ruby/rubycodeclassfield.cpp
     codegenerators/ruby/rubycodeclassfielddeclarationblock.cpp
     codegenerators/ruby/rubycodecomment.cpp
     codegenerators/ruby/rubycodedocumentation.cpp
     codegenerators/ruby/rubycodegenerationpolicy.cpp
     codegenerators/ruby/rubycodegenerationpolicypage.cpp
     codegenerators/ruby/rubycodegenerator.cpp
     codegenerators/ruby/rubycodeoperation.cpp
     codegenerators/ruby/rubywriter.cpp
     codegenerators/simplecodegenerator.cpp
     codegenerators/sql/mysqlwriter.cpp
     codegenerators/sql/postgresqlwriter.cpp
     codegenerators/sql/sqlwriter.cpp
     codegenerators/tcl/tclwriter.cpp
     codegenerators/textblock.cpp
     codegenerators/vala/valawriter.cpp
     codegenerators/xml/xmlcodecomment.cpp
     codegenerators/xml/xmlelementcodeblock.cpp
     codegenerators/xml/xmlschemawriter.cpp
 )
 
 ki18n_wrap_ui(  libcodegenerator_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/cpp/cppcodegenerationformbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/d/dcodegenerationformbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/java/javacodegenerationformbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenerators/ruby/rubycodegenerationformbase.ui
 )
 
 set(libdocgenerator_SRCS
     docgenerators/docbook2xhtmlgeneratorjob.cpp
     docgenerators/docbookgenerator.cpp
     docgenerators/docbookgeneratorjob.cpp
     docgenerators/xhtmlgenerator.cpp
 )
 
 set(libdialogs_SRCS
     dialogs/activitydialog.cpp
     dialogs/associationpropertiesdialog.cpp
     dialogs/classpropertiesdialog.cpp
     dialogs/classwizard.cpp
     dialogs/codeeditor.cpp
     dialogs/codetextedit.cpp
     dialogs/codetexthighlighter.cpp
     dialogs/codeviewerdialog.cpp
     dialogs/diagramselectiondialog.cpp
     dialogs/dialog_utils.cpp
     dialogs/dontaskagain.cpp
     dialogs/exportallviewsdialog.cpp
     dialogs/finddialog.cpp
     dialogs/messagewidgetpropertiesdialog.cpp
     dialogs/multipagedialogbase.cpp
     dialogs/notedialog.cpp
     dialogs/objectnodedialog.cpp
     dialogs/overwritedialog.cpp
     dialogs/parameterpropertiesdialog.cpp
     dialogs/selectoperationdialog.cpp
     dialogs/settingsdialog.cpp
     dialogs/singlepagedialogbase.cpp
     dialogs/statedialog.cpp
     dialogs/umlattributedialog.cpp
     dialogs/umlinstanceattributedialog.cpp
     dialogs/umlcheckconstraintdialog.cpp
     dialogs/umlentityattributedialog.cpp
     dialogs/umlenumliteraldialog.cpp
     dialogs/umlfiledialog.cpp
     dialogs/umlforeignkeyconstraintdialog.cpp
     dialogs/umloperationdialog.cpp
     dialogs/umlroledialog.cpp
     dialogs/umltemplatedialog.cpp
     dialogs/umluniqueconstraintdialog.cpp
     dialogs/umlviewdialog.cpp
     dialogs/pages/activitypage.cpp
     dialogs/pages/notepage.cpp
     dialogs/pages/associationgeneralpage.cpp
     dialogs/pages/associationrolepage.cpp
     dialogs/pages/autolayoutoptionpage.cpp
     dialogs/pages/classassociationspage.cpp
     dialogs/pages/classgeneralpage.cpp
     dialogs/pages/classifierlistpage.cpp
     dialogs/pages/classoptionspage.cpp
     dialogs/pages/codegenerationpolicypage.cpp
     dialogs/pages/codeimportoptionspage.cpp
     dialogs/pages/codevieweroptionspage.cpp
     dialogs/pages/constraintlistpage.cpp
     dialogs/pages/defaultcodegenpolicypage.cpp
     dialogs/pages/diagramprintpage.cpp
     dialogs/pages/diagrampropertiespage.cpp
     dialogs/pages/dialogpagebase.cpp
     dialogs/pages/generaloptionpage.cpp
     dialogs/pages/packagecontentspage.cpp
     dialogs/pages/selectoperationpage.cpp
     dialogs/pages/umlroleproperties.cpp
     dialogs/pages/umlwidgetstylepage.cpp
     dialogs/widgets/documentationwidget.cpp
     dialogs/widgets/imagetypewidget.cpp
     dialogs/widgets/resolutionwidget.cpp
     dialogs/widgets/umlartifacttypewidget.cpp
     dialogs/widgets/umldatatypewidget.cpp
     dialogs/widgets/umlobjectnamewidget.cpp
     dialogs/widgets/umlpackagewidget.cpp
     dialogs/widgets/umlstereotypewidget.cpp
     dialogs/widgets/visibilityenumwidget.cpp
 )
 
 ki18n_wrap_ui(  libdialogs_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/codeviewerdialogbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/codevieweroptionsbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/exportallviewsdialogbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/finddialog.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/pages/autolayoutoptionpage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/pages/codeimportoptionspage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/pages/diagrampropertiespage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/pages/umlrolepropertiesbase.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/dialogs/umlinstanceattributedialog.ui
 )
 
 set(librefactoring_SRCS
     refactoring/refactoringassistant.cpp
 )
 
 set(libcodegenwizard_SRCS
     codegenwizard/codegenerationwizard.cpp
     codegenwizard/codegenoptionspage.cpp
     codegenwizard/codegenselectpage.cpp
     codegenwizard/codegenstatuspage.cpp
 )
 
 ki18n_wrap_ui(  libcodegenwizard_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenwizard/codegenoptionspage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenwizard/codegenselectpage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codegenwizard/codegenstatuspage.ui
 )
 
 set(libcodeimpwizard_SRCS
     codeimpwizard/codeimportingwizard.cpp
     codeimpwizard/codeimpselectpage.cpp
     codeimpwizard/codeimpstatuspage.cpp
     codeimpwizard/codeimpthread.cpp
 )
 
 ki18n_wrap_ui(  libcodeimpwizard_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/codeimpwizard/codeimpselectpage.ui
     ${CMAKE_CURRENT_SOURCE_DIR}/codeimpwizard/codeimpstatuspage.ui
 )
 
 set(libcodeimport_SRCS
     codeimport/adaimport.cpp
     codeimport/classimport.cpp
     codeimport/idlimport.cpp
     codeimport/import_utils.cpp
     codeimport/javaimport.cpp
     codeimport/nativeimportbase.cpp
     codeimport/pascalimport.cpp
     codeimport/pythonimport.cpp
     codeimport/sqlimport.cpp
     codeimport/csharp/csharpimport.cpp
+    codeimport/valaimport.cpp
 )
 if(BUILD_PHP_IMPORT)
     list(APPEND libcodeimport_SRCS
         codeimport/phpimport.cpp
     )
 endif()
 
 list(APPEND libcodeimport_SRCS
     codeimport/cppimport.cpp
 )
 
 set(libkdevcppparser_SRCS
     ${CMAKE_SOURCE_DIR}/lib/cppparser/ast.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/ast_utils.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/cachemanager.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/driver.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/errors.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/lexer.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/lexercache.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/lookup.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/parser.cpp
     ${CMAKE_SOURCE_DIR}/lib/cppparser/tree_parser.cpp
     ${CMAKE_SOURCE_DIR}/lib/interfaces/hashedstring.cpp
     codeimport/kdevcppparser/cpptree2uml.cpp
 )
 
 set(libclipboard_SRCS
     clipboard/idchangelog.cpp
     clipboard/umlclipboard.cpp
     clipboard/umldragdata.cpp
 )
 
 set(libcmds_SRCS
     cmds/cmdbaseobjectcommand.cpp
     cmds/cmdcreatediagram.cpp
     cmds/cmdhandlerename.cpp
     cmds/cmdremovediagram.cpp
     cmds/cmdsetstereotype.cpp
     cmds/cmdsetvisibility.cpp
     cmds/generic/cmdrenameumlinstancetype.cpp
     cmds/generic/cmdcreateumlobject.cpp
     cmds/generic/cmdremoveumlobject.cpp
     cmds/generic/cmdrenameumlobject.cpp
     cmds/widget/cmdbasewidgetcommand.cpp
     cmds/widget/cmdchangefont.cpp
     cmds/widget/cmdchangetextcolor.cpp
     cmds/widget/cmdchangelinecolor.cpp
     cmds/widget/cmdchangelinewidth.cpp
     cmds/widget/cmdchangefillcolor.cpp
     cmds/widget/cmdchangeusefillcolor.cpp
     cmds/widget/cmdchangemultiplicity.cpp
     cmds/widget/cmdchangevisualproperty.cpp
     cmds/widget/cmdcreatewidget.cpp
     cmds/widget/cmdmovewidget.cpp
     cmds/widget/cmdresizewidget.cpp
     cmds/widget/cmdremovewidget.cpp
     cmds/widget/cmdsetname.cpp
     cmds/widget/cmdsettxt.cpp
 )
 set(libmenus_SRCS
     menus/listpopupmenu.cpp
     menus/umllistviewpopupmenu.cpp
     menus/umlscenepopupmenu.cpp
     menus/associationwidgetpopupmenu.cpp
     menus/widgetbasepopupmenu.cpp
     menus/dialogspopupmenu.cpp
 )
 
 set(libumlwidgets_SRCS
     umlwidgets/activitywidget.cpp
     umlwidgets/actorwidget.cpp
     umlwidgets/artifactwidget.cpp
     umlwidgets/associationline.cpp
     umlwidgets/associationwidget.cpp
     umlwidgets/boxwidget.cpp
     umlwidgets/categorywidget.cpp
     umlwidgets/childwidgetplacement.cpp
     umlwidgets/childwidgetplacementpin.cpp
     umlwidgets/childwidgetplacementport.cpp
     umlwidgets/classifierwidget.cpp
     umlwidgets/combinedfragmentwidget.cpp
     umlwidgets/componentwidget.cpp
     umlwidgets/datatypewidget.cpp
     umlwidgets/entitywidget.cpp
     umlwidgets/enumwidget.cpp
     umlwidgets/floatingdashlinewidget.cpp
     umlwidgets/floatingtextwidget.cpp
     umlwidgets/forkjoinwidget.cpp
     umlwidgets/layoutgrid.cpp
     umlwidgets/linkwidget.cpp
     umlwidgets/messagewidget.cpp
     umlwidgets/nodewidget.cpp
     umlwidgets/notewidget.cpp
     umlwidgets/objectnodewidget.cpp
     umlwidgets/objectwidget.cpp
     umlwidgets/packagewidget.cpp
     umlwidgets/pinportbase.cpp
     umlwidgets/pinwidget.cpp
     umlwidgets/portwidget.cpp
     umlwidgets/preconditionwidget.cpp
     umlwidgets/regionwidget.cpp
     umlwidgets/seqlinewidget.cpp
     umlwidgets/signalwidget.cpp
     umlwidgets/statewidget.cpp
     umlwidgets/toolbarstateonewidget.cpp
     umlwidgets/umlwidget.cpp
     umlwidgets/usecasewidget.cpp
     umlwidgets/widget_factory.cpp
     umlwidgets/widget_utils.cpp
     umlwidgets/widgetbase.cpp
     umlwidgets/widgetlist_utils.cpp
     umlwidgets/statusbartoolbutton.cpp
 )
 
 set(libfinder_SRCS
     finder/findresults.cpp
     finder/umldocfinder.cpp
     finder/umlfinder.cpp
     finder/umllistviewfinder.cpp
     finder/umlscenefinder.cpp
 )
 
 set(libuml_SRCS
     uml1model/actor.cpp
     uml1model/artifact.cpp
     uml1model/association.cpp
     uml1model/attribute.cpp
     uml1model/category.cpp
     uml1model/checkconstraint.cpp
     uml1model/classifier.cpp
     uml1model/classifierlistitem.cpp
     uml1model/component.cpp
     uml1model/datatype.cpp
     uml1model/entity.cpp
     uml1model/entityattribute.cpp
     uml1model/entityconstraint.cpp
     uml1model/enum.cpp
     uml1model/enumliteral.cpp
     uml1model/folder.cpp
     uml1model/foreignkeyconstraint.cpp
     uml1model/node.cpp
     uml1model/operation.cpp
     uml1model/package.cpp
     uml1model/port.cpp
     uml1model/stereotype.cpp
     uml1model/template.cpp
     uml1model/umlattributelist.cpp
     uml1model/umlcanvasobject.cpp
     uml1model/umlclassifierlistitemlist.cpp
     uml1model/umlentityattributelist.cpp
     uml1model/umlentityconstraintlist.cpp
     uml1model/umlobject.cpp
     uml1model/umlobjectlist.cpp
     uml1model/umlrole.cpp
     uml1model/usecase.cpp
     uml1model/uniqueconstraint.cpp
     uml1model/instance.cpp
     uml1model/instanceattribute.cpp
 )
 
 set(umbrellobase_SRCS
     assocrules.cpp
     basictypes.cpp
     birdview.cpp
     codeviewerstate.cpp
     cmdlineexportallviewsevent.cpp
     diagramswindow.cpp
     diagram_utils.cpp
     objectswindow.cpp
     docwindow.cpp
     dotgenerator.cpp
     icon_utils.cpp
     import_argo.cpp
     import_rose.cpp
     layoutgenerator.cpp
     model_utils.cpp
     object_factory.cpp
     optionstate.cpp
     petalnode.cpp
     petaltree2uml.cpp
     stereotypeswindow.cpp
     toolbarstatearrow.cpp
     toolbarstateassociation.cpp
     toolbarstate.cpp
     toolbarstatefactory.cpp
     toolbarstatemessages.cpp
     toolbarstateother.cpp
     toolbarstatepool.cpp
     umlappprivate.cpp
     uml.cpp
     umldoc.cpp
     umllistview.cpp
     umllistviewitem.cpp
     umlscene.cpp
     umlview.cpp
     umlviewimageexporterall.cpp
     umlviewimageexporter.cpp
     umlviewimageexportermodel.cpp
     uniqueid.cpp
     worktoolbar.cpp
 )
 
 set(umbrellomodels_SRCS
     models/diagramsmodel.cpp
     models/objectsmodel.cpp
     models/stereotypesmodel.cpp
 )
 
 kconfig_add_kcfg_files(umbrellobase_SRCS umbrellosettings.kcfgc)
 
 set(libumbrello_SRCS
     ${libdebug_SRCS}
     ${libdialogs_SRCS}
     ${libfinder_SRCS}
     ${librefactoring_SRCS}
     ${libcodegenwizard_SRCS}
     ${libcodeimpwizard_SRCS}
     ${libclassparser_SRCS}
     ${libclipboard_SRCS}
     ${libkdevcppparser_SRCS}
     ${libcodeimport_SRCS}
     ${libcodegenerator_SRCS}
     ${libdocgenerator_SRCS}
     ${libcmds_SRCS}
     ${libmenus_SRCS}
     ${libuml_SRCS}
     ${libumlwidgets_SRCS}
     ${umbrellobase_SRCS}
     ${umbrellomodels_SRCS}
 )
 
 set(umbrello_SRCS
     main.cpp
 )
 
 set(LIB_BUILD_MODE STATIC)
 
 if(NOT BUILD_KF5)
     if(CMAKE_MAJOR_VERSION LESS 3)
         qt4_add_resources(libumbrello_SRCS icons.qrc)
     else()
         list(APPEND libumbrello_SRCS icons.qrc)
     endif()
     kde4_add_library(libumbrello ${LIB_BUILD_MODE} ${libumbrello_SRCS})
     set_target_properties(libumbrello PROPERTIES OUTPUT_NAME umbrello)
     target_link_libraries(libumbrello
         Qt4::QtCore
         Qt4::QtGui
         Qt4::QtXml
         Qt4::QtWebKit
         ${LIBXML2_LIBRARIES}
         ${LIBXSLT_LIBRARIES}
         ${KDE4_KTEXTEDITOR_LIBS}
         ${KDE4_KFILE_LIBS}
     )
 
     if(BUILD_PHP_IMPORT)
         target_link_libraries(libumbrello
             ${KDEVPLATFORM_INTERFACES_LIBRARIES}
             ${KDEVPLATFORM_LANGUAGE_LIBRARIES}
             ${KDEVPLATFORM_OUTPUTVIEW_LIBRARIES}
             ${KDEVPLATFORM_PROJECT_LIBRARIES}
             ${KDEVPLATFORM_SUBLIME_LIBRARIES}
             ${KDEVPLATFORM_SHELL_LIBRARIES}
             ${KDEVPLATFORM_UTIL_LIBRARIES}
             ${KDEVPLATFORM_VCS_LIBRARIES}
             ${KDEVPLATFORM_DEBUGGER_LIBRARIES}
             ${KDEVPLATFORM_DOCUMENTATION_LIBRARIES}
             ${KDEVPLATFORM_TESTS_LIBRARIES}
             ${KDEVPLATFORM_JSONTESTS_LIBRARIES}
             kdev4phpparser
         )
     endif()
     kde4_add_app_icon(umbrello_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/pics/global/kde4/hi*-apps-umbrello.png")
     kde4_add_executable(umbrello ${umbrello_SRCS})
     target_link_libraries(umbrello ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${KDE4_KTEXTEDITOR_LIBS} ${KDE4_KFILE_LIBS} libumbrello)
 else()
     if(CMAKE_MAJOR_VERSION LESS 3)
         qt5_add_resources(libumbrello_SRCS icons.qrc ${CMAKE_CURRENT_BINARY_DIR}/ui.qrc)
     else()
         list(APPEND libumbrello_SRCS icons.qrc ${CMAKE_CURRENT_BINARY_DIR}/ui.qrc)
     endif()
     add_library(libumbrello ${LIB_BUILD_MODE} ${libumbrello_SRCS})
     set_target_properties(libumbrello PROPERTIES OUTPUT_NAME umbrello)
     target_link_libraries(libumbrello
         Qt5::Widgets
         Qt5::Xml
         Qt5::PrintSupport
         Qt5::Svg
         Qt5::WebKitWidgets
         KF5::Archive
         KF5::Completion
         KF5::CoreAddons
         KF5::I18n
         KF5::IconThemes
         KF5::KIOCore
         KF5::KDELibs4Support
         KF5::TextEditor
         KF5::WidgetsAddons
         KF5::XmlGui
         KF5::Crash
         ${LIBXSLT_LIBRARIES}
         ${LIBXML2_LIBRARIES}
     )
     if(BUILD_PHP_IMPORT)
         target_link_libraries(libumbrello
             KDev::Interfaces
             KDev::Language
             KDev::Tests
             kdevphpparser
         )
     endif()
     ecm_add_app_icon(umbrello_SRCS
         ICONS
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/16-apps-umbrello.png
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/22-apps-umbrello.png
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/32-apps-umbrello.png
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/48-apps-umbrello.png
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/64-apps-umbrello.png
         ${CMAKE_CURRENT_SOURCE_DIR}/pics/global/128-apps-umbrello.png
     )
     add_executable(umbrello ${umbrello_SRCS})
     target_link_libraries(umbrello
         libumbrello
         KF5::Crash
         KF5::WindowSystem
         KF5::KDELibs4Support
     )
     set_target_properties(umbrello PROPERTIES OUTPUT_NAME umbrello5)
 endif()
 if(LIB_BUILD_MODE EQUAL SHARED)
     install(TARGETS libumbrello ${INSTALL_TARGETS_DEFAULT_ARGS} )
 endif()
 install(TARGETS umbrello ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 ########### install files #############
 
 if(NOT BUILD_KF5)
     install( PROGRAMS org.kde.umbrello.desktop DESTINATION  ${XDG_APPS_INSTALL_DIR} )
     install( FILES
         ${CMAKE_CURRENT_BINARY_DIR}/umbrelloui.rc
         DESTINATION ${UMBRELLO_DATA_INSTALL_DIR} )
 else()
     file(READ org.kde.umbrello.desktop UMBRELLO_DESKTOP_OUT)
     string(REPLACE "Exec=umbrello" "Exec=umbrello5" UMBRELLO_DESKTOP_OUT "${UMBRELLO_DESKTOP_OUT}")
     file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/org.kde.umbrello.desktop "${UMBRELLO_DESKTOP_OUT}")
     install( PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/org.kde.umbrello.desktop DESTINATION  ${XDG_APPS_INSTALL_DIR})
     install(FILES org.kde.umbrello.appdata.xml  DESTINATION  ${KDE_INSTALL_METAINFODIR})
 endif()
 
 install( FILES
     docgenerators/xmi2docbook.xsl
     docgenerators/docbook2xhtml.xsl
     docgenerators/xmi.css
     docgenerators/common.ent
     DESTINATION ${UMBRELLO_DATA_INSTALL_DIR} )
 
 install( DIRECTORY
     layouts
     DESTINATION ${UMBRELLO_DATA_INSTALL_DIR}
     PATTERN .svn EXCLUDE )
 
 add_subdirectory( pics )
diff --git a/umbrello/basictypes.cpp b/umbrello/basictypes.cpp
index 731102148..dd03fba8e 100644
--- a/umbrello/basictypes.cpp
+++ b/umbrello/basictypes.cpp
@@ -1,1228 +1,1235 @@
 /***************************************************************************
  * Copyright (C) 2011 by Andi Fischer <andi.fischer@hispeed.ch>            *
  *                                                                         *
  * This is free software; you can redistribute it and/or modify            *
  * it under the terms of the GNU General Public License as published by    *
  * the Free Software Foundation; either version 2, or (at your option)     *
  * any later version.                                                      *
  *                                                                         *
  * This software is distributed in the hope that it will be useful,        *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  * GNU General Public License for more details.                            *
  *                                                                         *
  * You should have received a copy of the GNU General Public License       *
  * along with this package; see the file COPYING.  If not, write to        *
  * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,   *
  * Boston, MA 02110-1301, USA.                                             *
  ***************************************************************************/
 
 #include "basictypes.h"
 
 #include "debug_utils.h"
 
 // kde includes
 #include <KLocalizedString>
 #if QT_VERSION < 0x050000
 #include <KGlobalSettings>
 #endif
 
 // qt includes
 #if QT_VERSION >= 0x050000
 #include <QFontDatabase>
 #endif
 #include <QRegExp>
 
 namespace Uml
 {
 
 namespace ModelType
 {
 
 /**
  * Convert ModelType item into QString representation.
  * @param item       item to convert
  * @return QString representation of ModelType
  */
 QString toString(Enum item)
 {
     switch (item) {
         case UseCase:
             return QString(QLatin1String("UseCase"));
         case Component:
             return QString(QLatin1String("Component"));
         case Deployment:
             return QString(QLatin1String("Deployment"));
         case EntityRelationship:
             return QString(QLatin1String("EntityRelationship"));
         case Logical:
         default:
             return QString(QLatin1String("Logical"));
     }
 }
 
 /**
  * Convert a string item into Model representation.
  * @param item   item to convert
  * @return Model object
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("UseCase"))
         return UseCase;
     else if (item == QLatin1String("Component"))
         return Component;
     else if (item == QLatin1String("Deployment"))
         return Deployment;
     else if (item == QLatin1String("EntityRelationship"))
         return EntityRelationship;
     else
         return Logical;
 }
 
 /**
  * Convert a integer item into ModelType representation.
  * @param item   integer value to convert
  * @return ModelType enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace ModelType
 
 //-----------------------------------------------------------------------------
 
 namespace Visibility {
 
 /**
  * Convert Visibility item into QString representation.
  * @param item       item to convert
  * @param mnemonic   if true then return a single character:
  *              "+" for public, "-" for private,
  *              "#" for protected or "~" for implementation
  * @return QString representation of Visibility
  */
 QString toString(Enum item, bool mnemonic)
 {
     switch (item) {
         case Protected:
             return (mnemonic ? QLatin1String("#") : QLatin1String("protected"));
         case Private:
             return (mnemonic ? QLatin1String("-") : QLatin1String("private"));
         case Implementation:
             return (mnemonic ? QLatin1String("~") : QLatin1String("implementation"));
         case Public:
         default:
             return (mnemonic ? QLatin1String("+") : QLatin1String("public"));
     }
 }
 
 /**
  * Convert a string item into Visibility representation.
  * @param item   item to convert
  * @return Visibility enum
  */
 Enum fromString(const QString& item, bool checkUnkown)
 {
     if (item == QLatin1String("public") || item == QLatin1String("+"))
         return Public;
     else if (item == QLatin1String("protected") || item == QLatin1String("#"))
         return Protected;
     else if (item == QLatin1String("private") || item == QLatin1String("-"))
         return Private;
     else if (item == QLatin1String("~"))
         return Implementation;
     else if (item == QLatin1String("signals"))
         return Protected;
     else if (item == QLatin1String("class"))
         return Private;
     else if (checkUnkown)
         return Unknown;
     else
         return Public;
 }
 
 /**
  * Convert a integer item into Visibility representation.
  * @param item   integer value to convert
  * @return Visibility enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace Visibility
 
 //-----------------------------------------------------------------------------
 
 namespace DiagramType {
 
 /**
  * Convert DiagramType item into QString representation.
  * @param item   item to convert
  * @return QString representation of DiagramType
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Undefined:
             return QLatin1String("Undefined");
         case Class:
             return QLatin1String("Class");
         case Object:
             return QLatin1String("Object");
         case UseCase:
             return QLatin1String("UseCase");
         case Sequence:
             return QLatin1String("Sequence");
         case Collaboration:
             return QLatin1String("Collaboration");
         case State:
             return QLatin1String("State");
         case Activity:
             return QLatin1String("Activity");
         case Component:
             return QLatin1String("Component");
         case Deployment:
             return QLatin1String("Deployment");
         case EntityRelationship:
             return QLatin1String("EntityRelationship");
         case N_DIAGRAMTYPES:   // must remain last
             return QLatin1String("N_DIAGRAMTYPES");
         default:
             return QLatin1String("? DiagramType ?");
     }
 }
 
 /**
  * Return string corresponding to DiagramType
  */
 QString toStringI18n(Enum item)
 {
     switch (item) {
        case Class:
            return i18n("Class Diagram");
        case UseCase:
            return i18n("Use Case Diagram");
        case Sequence:
            return i18n("Sequence Diagram");
        case Collaboration:
            return i18n("Collaboration Diagram");
        case State:
            return i18n("State Diagram");
        case Activity:
            return i18n("Activity Diagram");
        case Component:
            return i18n("Component Diagram");
        case Deployment:
            return i18n("Deployment Diagram");
        case EntityRelationship:
            return i18n("Entity Relationship Diagram");
         case Object:
             return i18n("Object Diagram");
        default:
            return i18n("No Diagram");
     }
 }
 
 /**
  * Convert a string item into DiagramType representation.
  * @param item   item to convert
  * @return DiagramType object
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("Undefined"))
         return Undefined;
     else if (item == QLatin1String("Class"))
         return Class;
     else if (item == QLatin1String("UseCase"))
         return UseCase;
     else if (item == QLatin1String("Sequence"))
         return Sequence;
     else if (item == QLatin1String("Collaboration"))
         return Collaboration;
     else if (item == QLatin1String("State"))
         return State;
     else if (item == QLatin1String("Activity"))
         return Activity;
     else if (item == QLatin1String("Component"))
         return Component;
     else if (item == QLatin1String("Deployment"))
         return Deployment;
     else if (item == QLatin1String("EntityRelationship"))
         return EntityRelationship;
     else
         return Undefined;
 }
 
 /**
  * Convert an integer item into DiagramType representation.
  * @param item   integer value to convert
  * @return DiagramType enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace DiagramType
 
 //-----------------------------------------------------------------------------
 
 namespace AssociationType {
 
 /**
  * Convert AssociationType item into QString representation.
  * @param item   item to convert
  * @return QString representation of AssociationType
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Generalization:
             return QLatin1String("Generalization");
         case Aggregation:
             return QLatin1String("Aggregation");
         case Dependency:
             return QLatin1String("Dependency");
         case Association:
             return QLatin1String("Association");
         case Association_Self:
             return QLatin1String("Association_Self");
         case Coll_Message_Asynchronous:
             return QLatin1String("Coll_Message_Asynchronous");
         case Coll_Message_Synchronous:
             return QLatin1String("Coll_Message_Synchronous");
         case Seq_Message:
             return QLatin1String("Seq_Message");
         case Coll_Message_Self:
             return QLatin1String("Coll_Message_Self");
         case Seq_Message_Self:
             return QLatin1String("Seq_Message_Self");
         case Containment:
             return QLatin1String("Containment");
         case Composition:
           return QLatin1String("Composition");
         case Realization:
           return QLatin1String("Realization");
         case UniAssociation:
           return QLatin1String("UniAssociation");
         case Anchor:
           return QLatin1String("Anchor");
         case State:
           return QLatin1String("State");
         case Activity:
           return QLatin1String("Activity");
         case Exception:
           return QLatin1String("Exception");
         case Category2Parent:
           return QLatin1String("Category2Parent");
         case Child2Category:
           return QLatin1String("Child2Category");
         case Relationship:
           return QLatin1String("Relationship");
         case Unknown:
             return QLatin1String("Unknown");
         default:
             return QLatin1String("? AssociationType ?");
     }
 }
 
 /**
  * Converts a AssociationType to its string representation.
  * @return  the string representation of the AssociationType
  */
 QString toStringI18n(Enum item)
 {
     switch (item) {
           case Generalization:
               return i18n("Generalization");
           case Aggregation:
               return i18n("Aggregation");
           case Dependency:
               return i18n("Dependency");
           case Association:
               return i18n("Association");
           case Association_Self:
               return i18n("Self Association");
           case Coll_Message_Asynchronous:
               return i18n("Collaboration Asynchronous Message");
           case Coll_Message_Synchronous:
               return i18n("Collaboration Synchronous Message");
           case Seq_Message:
               return i18n("Sequence Message");
           case Coll_Message_Self:
               return i18n("Collaboration Self Message");
           case Seq_Message_Self:
               return i18n("Sequence Self Message");
           case Containment:
               return i18n("Containment");
           case Composition:
               return i18n("Composition");
           case Realization:
               return i18n("Realization");
           case UniAssociation:
               return i18n("Uni Association");
           case Anchor:
               return i18n("Anchor");
           case State:
               return i18n("State Transition");
           case Activity:
               return i18n("Activity");
           case Exception:
               return i18n("Exception");
           case Category2Parent:
               return i18n("Category to Parent");
           case Child2Category:
               return i18n("Child to Category");
           case Relationship:
               return i18n("Relationship");
           case Unknown:
               return i18n("Unknown");
           default:
               return i18n("? AssociationType ?");
       };
 }
 
 /**
  * Convert a string item into AssociationType representation.
  * @param item   item to convert
  * @return AssociationType object
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("Generalization"))
         return Generalization;
     else if (item == QLatin1String("Aggregation"))
         return Aggregation;
     else if (item == QLatin1String("Dependency"))
         return Dependency;
     else if (item == QLatin1String("Association"))
         return Association;
     else if (item == QLatin1String("Association_Self"))
         return Association_Self;
     else if (item == QLatin1String("Coll_Message_Asynchronous"))
         return Coll_Message_Asynchronous;
     else if (item == QLatin1String("Coll_Message_Synchronous"))
         return Coll_Message_Synchronous;
     else if (item == QLatin1String("Seq_Message"))
         return Seq_Message;
     else if (item == QLatin1String("Coll_Message_Self"))
         return Coll_Message_Self;
     else if (item == QLatin1String("Seq_Message_Self"))
         return Seq_Message_Self;
     else if (item == QLatin1String("Containment"))
         return Containment;
     else if (item == QLatin1String("Composition"))
         return Composition;
     else if (item == QLatin1String("Realization"))
         return Realization;
     else if (item == QLatin1String("UniAssociation"))
         return UniAssociation;
     else if (item == QLatin1String("Anchor"))
         return Anchor;
     else if (item == QLatin1String("State"))
         return State;
     else if (item == QLatin1String("Activity"))
         return Activity;
     else if (item == QLatin1String("Exception"))
         return Exception;
     else if (item == QLatin1String("Category2Parent"))
         return Category2Parent;
     else if (item == QLatin1String("Child2Category"))
         return Child2Category;
     else if (item == QLatin1String("Relationship"))
         return Relationship;
     else
         return Unknown;
 }
 
 /**
  * Convert a integer item into ProgrammingLanguage representation.
  * @param item   integer value to convert
  * @return AssociationType enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 /**
  * Returns true if the given AssociationType has a representation as a
  * UMLAssociation.
  * @param item   the AssociationType enum value to check
  * @return  boolean value
  */
 bool hasUMLRepresentation(Enum item)
 {
     return (item == Generalization   ||
             item == Realization      ||
             item == Association      ||
             item == Association_Self ||
             item == UniAssociation   ||
             item == Aggregation      ||
             item == Relationship     ||
             item == Composition      ||
             item == Dependency       ||
             item == Category2Parent  ||
             item == Child2Category);
 }
 
 }  // end namespace AssociationType
 
 //-----------------------------------------------------------------------------
 
 namespace SignatureType {
 
 /**
  * Return string corresponding to the given SignatureType.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case NoSig:
             return QLatin1String("NoSig");
         case ShowSig:
             return QLatin1String("ShowSig");
         case SigNoVis:
             return QLatin1String("SigNoVis");
         case NoSigNoVis:
             return QLatin1String("NoSigNoVis");
         default:
             break;
     }
     return QString();
 }
 
 /**
  * Return SignatureType corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("NoSig"))
         return NoSig;
     if (item == QLatin1String("ShowSig"))
         return ShowSig;
     if (item == QLatin1String("SigNoVis"))
         return SigNoVis;
     if (item == QLatin1String("NoSigNoVis"))
         return NoSigNoVis;
     return NoSig;
 }
 
 /**
  * Convert a integer item into SignatureType representation.
  * @param item   integer value to convert
  * @return SignatureType enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace SignatureType
 
 //-----------------------------------------------------------------------------
 
 namespace TextRole {
 
 /**
  * Return string corresponding to the given TextRole.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Floating:
             return QLatin1String("Floating");
         case MultiA:
             return QLatin1String("MultiA");
         case MultiB:
             return QLatin1String("MultiB");
         case Name:
             return QLatin1String("Name");
         case Seq_Message:
             return QLatin1String("Seq_Message");
         case Seq_Message_Self:
             return QLatin1String("Seq_Message_Self");
         case Coll_Message:
             return QLatin1String("Coll_Message");
         case Coll_Message_Self:
             return QLatin1String("Coll_Message_Self");
         case State:
             return QLatin1String("State");
         case RoleAName:
             return QLatin1String("RoleAName");
         case RoleBName:
             return QLatin1String("RoleBName");
         case ChangeA:
             return QLatin1String("ChangeA");
         case ChangeB:
             return QLatin1String("ChangeB");
         default:
             break;
     }
     return QLatin1String("? TextRole ?");
 }
 
 /**
  * Return TextRole corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("Floating"))
         return Floating;
     if (item == QLatin1String("MultiA"))
         return MultiA;
     if (item == QLatin1String("MultiB"))
         return MultiB;
     if (item == QLatin1String("Name"))
         return Name;
     if (item == QLatin1String("Seq_Message"))
         return Seq_Message;
     if (item == QLatin1String("Seq_Message_Self"))
         return Seq_Message_Self;
     if (item == QLatin1String("Coll_Message"))
         return Coll_Message;
     if (item == QLatin1String("Coll_Message_Self"))
         return Coll_Message_Self;
     if (item == QLatin1String("State"))
         return State;
     if (item == QLatin1String("RoleAName"))
         return RoleAName;
     if (item == QLatin1String("RoleBName"))
         return RoleBName;
     if (item == QLatin1String("ChangeA"))
         return ChangeA;
     if (item == QLatin1String("ChangeB"))
         return ChangeB;
     return Floating;
 }
 
 /**
  * Convert a integer item into TextRole representation.
  * @param item   integer value to convert
  * @return TextRole enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace TextRole
 
 //-----------------------------------------------------------------------------
 
 namespace Changeability {
 
 /**
  * Convert Changeability::Enum value into QString representation.
  * @param item   The Changeability enum value to convert.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Changeability::Frozen:
             return QLatin1String("frozen");
         case Changeability::AddOnly:
             return QLatin1String("addOnly");
         case Changeability::Changeable:
             return QLatin1String("changeable");
         default:
             break;
     }
     return QLatin1String("? Changeability ?");
 }
 
 /**
  * Return Changeability::Enum corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("frozen"))
         return Frozen;
     if (item == QLatin1String("addOnly"))
         return AddOnly;
     if (item == QLatin1String("changeable"))
         return Changeable;
     return Changeable;
 }
 
 /**
  * Convert a integer item into Changeability representation.
  * @param item   integer value to convert
  * @return Changeability enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace Changeability
 
 //-----------------------------------------------------------------------------
 
 namespace SequenceMessage {
 
 /**
  * Return string corresponding to the given SequenceMessage.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Synchronous:
             return QLatin1String("Synchronous");
         case Asynchronous:
             return QLatin1String("Asynchronous");
         case Creation:
             return QLatin1String("Creation");
         case Lost:
             return QLatin1String("Lost");
         case Found:
             return QLatin1String("Found");
         default:
             break;
     }
     return QLatin1String("? SequenceMessage ?");
 }
 
 /**
  * Return SequenceMessage corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("Synchronous"))
         return Synchronous;
     if (item == QLatin1String("Asynchronous"))
         return Asynchronous;
     if (item == QLatin1String("Creation"))
         return Creation;
     if (item == QLatin1String("Lost"))
         return Lost;
     if (item == QLatin1String("Found"))
         return Found;
     return Synchronous;
 }
 
 /**
  * Convert a integer item into SequenceMessage representation.
  * @param item   integer value to convert
  * @return SequenceMessage enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace SequenceMessage
 
 //-----------------------------------------------------------------------------
 
 namespace RoleType {
 
 /**
  * Return string corresponding to the given RoleType.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case A:
             return QLatin1String("A");
         case B:
             return QLatin1String("B");
         default:
             break;
     }
     return QLatin1String("? RoleType ?");
 }
 
 /**
  * Return RoleType corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("A"))
         return A;
     if (item == QLatin1String("B"))
         return B;
     return A;
 }
 
 /**
  * Convert a integer item into RoleType representation.
  * @param item   integer value to convert
  * @return RoleType enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace RoleType
 
 //-----------------------------------------------------------------------------
 
 namespace ParameterDirection {
 
 /**
  * Return string corresponding to the given ParameterDirection.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case In:
             return QLatin1String("In");
         case InOut:
             return QLatin1String("InOut");
         case Out:
             return QLatin1String("Out");
         default:
             break;
     }
     return QLatin1String("? ParameterDirection ?");
 }
 
 /**
  * Return ParameterDirection corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("In"))
         return In;
     if (item == QLatin1String("InOut"))
         return InOut;
     if (item == QLatin1String("Out"))
         return Out;
     return In;
 }
 
 /**
  * Convert a integer item into ParameterDirection representation.
  * @param item   integer value to convert
  * @return ParameterDirection enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace ParameterDirection
 
 //-----------------------------------------------------------------------------
 
 namespace ProgrammingLanguage {
 
 /**
  * Return string corresponding to the given ProgrammingLanguage.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case ActionScript:
             return QLatin1String("ActionScript");
         case Ada:
             return QLatin1String("Ada");
         case Cpp:
             return QLatin1String("C++");
         case CSharp:
             return QLatin1String("C#");
         case D:
             return QLatin1String("D");
         case IDL:
             return QLatin1String("IDL");
         case Java:
             return QLatin1String("Java");
         case JavaScript:
             return QLatin1String("JavaScript");
         case MySQL:
             return QLatin1String("MySQL");
         case Pascal:
             return QLatin1String("Pascal");
         case Perl:
             return QLatin1String("Perl");
         case PHP:
             return QLatin1String("PHP");
         case PHP5:
             return QLatin1String("PHP5");
         case PostgreSQL:
             return QLatin1String("PostgreSQL");
         case Python:
             return QLatin1String("Python");
         case Ruby:
             return QLatin1String("Ruby");
         case SQL:
             return QLatin1String("SQL");
         case Tcl:
             return QLatin1String("Tcl");
         case Vala:
             return QLatin1String("Vala");
         case XMLSchema:
             return QLatin1String("XMLSchema");
         default:
             break;
     }
     return QString();
 }
 
 /**
  * Return ProgrammingLanguage corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("ActionScript"))
         return ActionScript;
     if (item == QLatin1String("Ada"))
         return Ada;
     if (item == QLatin1String("C++") || item == QLatin1String("Cpp"))  // "Cpp" only for bkwd compatibility
         return Cpp;
     if (item == QLatin1String("C#"))
         return CSharp;
     if (item == QLatin1String("D"))
         return D;
     if (item == QLatin1String("IDL"))
         return IDL;
     if (item == QLatin1String("Java"))
         return Java;
     if (item == QLatin1String("JavaScript"))
         return JavaScript;
     if (item == QLatin1String("MySQL"))
         return MySQL;
     if (item == QLatin1String("Pascal"))
         return Pascal;
     if (item == QLatin1String("Perl"))
         return Perl;
     if (item == QLatin1String("PHP"))
         return PHP;
     if (item == QLatin1String("PHP5"))
         return PHP5;
     if (item == QLatin1String("PostgreSQL"))
         return PostgreSQL;
     if (item == QLatin1String("Python"))
         return Python;
     if (item == QLatin1String("Ruby"))
         return Ruby;
     if (item == QLatin1String("SQL"))
         return SQL;
     if (item == QLatin1String("Tcl"))
         return Tcl;
     if (item == QLatin1String("Vala"))
         return Vala;
     if (item == QLatin1String("XMLSchema"))
         return XMLSchema;
     return Reserved;
 }
 
 /**
  * Convert a integer item into ProgrammingLanguage representation.
  * @param item   integer value to convert
  * @return ProgrammingLanguage enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 /**
  * Return extensions associated with the requested language.
  * @param item programming language index
  * @return extensions list
  */
 QStringList toExtensions(Enum item)
 {
     QStringList result;
     switch (item) {  //:TODO: More languages?
         case Uml::ProgrammingLanguage::Ada:
             result << QLatin1String("*.ads")
                    << QLatin1String("*.adb")
                    << QLatin1String("*.ada");
             break;
         case Uml::ProgrammingLanguage::Cpp:
             result << QLatin1String("*.h")
                    << QLatin1String("*.hpp")
                    << QLatin1String("*.hh")
                    << QLatin1String("*.hxx")
                    << QLatin1String("*.H");
             break;
         case Uml::ProgrammingLanguage::IDL:
             result << QLatin1String("*.idl");
             break;
         case Uml::ProgrammingLanguage::Java:
             result << QLatin1String("*.java");
             break;
         case Uml::ProgrammingLanguage::Pascal:
             result << QLatin1String("*.pas");
             break;
         case Uml::ProgrammingLanguage::Python:
             result << QLatin1String("*.py") << QLatin1String("*.pyw");
             break;
         case Uml::ProgrammingLanguage::CSharp:
             result << QLatin1String("*.cs");
             break;
         case Uml::ProgrammingLanguage::PHP:
             result << QLatin1String("*.php") << QLatin1String("*.inc");
             break;
         case Uml::ProgrammingLanguage::PHP5:
             result << QLatin1String("*.php") << QLatin1String("*.php5") << QLatin1String("*.inc");
             break;
+        case Uml::ProgrammingLanguage::Vala:
+            result << QLatin1String("*.vala") << QLatin1String("*.vapi");
+            break;
         default:
             break;
     }
     return result;
 }
 
 /**
  * Return clear text file extension description for the requested language.
  * @param item programming language index
  * @return extension
  */
 QString toExtensionsDescription(Enum item)
 {
     QString result = QString::fromLatin1("Files");
     switch (item) {  //:TODO: More languages?
         case Uml::ProgrammingLanguage::Ada:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::Cpp:
             result = QLatin1String("Header files");
             break;
         case Uml::ProgrammingLanguage::IDL:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::Java:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::Pascal:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::Python:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::CSharp:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::PHP:
             result = QLatin1String("Source files");
             break;
         case Uml::ProgrammingLanguage::PHP5:
             result = QLatin1String("Source files");
             break;
+        case Uml::ProgrammingLanguage::Vala:
+            result = QLatin1String("Source files");
+            break;
         default:
             break;
     }
     return toString(item) + QLatin1String(" ") + result;
 }
 
 bool isCaseSensitive(Enum item)
 {
     return (item != Uml::ProgrammingLanguage::Pascal &&
             item != Uml::ProgrammingLanguage::Ada &&
             item != Uml::ProgrammingLanguage::SQL &&
             item != Uml::ProgrammingLanguage::MySQL &&
             item != Uml::ProgrammingLanguage::PostgreSQL);
 }
 
 QString scopeSeparator(Enum item)
 {
     if (item == Uml::ProgrammingLanguage::Ada ||
         item == Uml::ProgrammingLanguage::CSharp ||
+        item == Uml::ProgrammingLanguage::Vala ||
         item == Uml::ProgrammingLanguage::Pascal ||
         item == Uml::ProgrammingLanguage::Java ||
         item == Uml::ProgrammingLanguage::JavaScript ||
         item == Uml::ProgrammingLanguage::Vala ||
         item == Uml::ProgrammingLanguage::Python)  // CHECK: more?
         return QLatin1String(".");
     return QLatin1String("::");
 }
 
 }  // end namespace ProgrammingLanguage
 
 //-----------------------------------------------------------------------------
 
 namespace Region {
 
 /**
  * Return string corresponding to the given Region.
  */
 QString toString(Enum item)
 {
     switch (item) {
         case Error:
             return QLatin1String("Error");
         case West:
             return QLatin1String("West");
         case North:
             return QLatin1String("North");
         case East:
             return QLatin1String("East");
         case South:
             return QLatin1String("South");
         case NorthWest:
             return QLatin1String("NorthWest");
         case NorthEast:
             return QLatin1String("NorthEast");
         case SouthEast:
             return QLatin1String("SouthEast");
         case SouthWest:
             return QLatin1String("SouthWest");
         case Center:
             return QLatin1String("Center");
         default:
             break;
     }
     return QLatin1String("? Region ?");
 }
 
 /**
  * Return Region corresponding to the given string.
  */
 Enum fromString(const QString& item)
 {
     if (item == QLatin1String("Error"))
         return Error;
     if (item == QLatin1String("West"))
         return West;
     if (item == QLatin1String("North"))
         return North;
     if (item == QLatin1String("East"))
         return East;
     if (item == QLatin1String("South"))
         return South;
     if (item == QLatin1String("NorthWest"))
         return NorthWest;
     if (item == QLatin1String("NorthEast"))
         return NorthEast;
     if (item == QLatin1String("SouthEast"))
         return SouthEast;
     if (item == QLatin1String("SouthWest"))
         return SouthWest;
     if (item == QLatin1String("Center"))
         return Center;
     return Error;
 }
 
 /**
  * Convert a integer item into Region representation.
  * @param item   integer value to convert
  * @return Region enum
  */
 Enum fromInt(int item)
 {
     return Enum(item);
 }
 
 }  // end namespace Region
 
 //-----------------------------------------------------------------------------
 
 //namespace Corner {
 
 /**
  * Return string corresponding to the given Corner.
  */
 QString Corner::toString(Enum item)
 {
     switch (item) {
         case TopLeft:
             return QLatin1String("TopLeft");
         case TopRight:
             return QLatin1String("TopRight");
         case BottomRight:
             return QLatin1String("BottomRight");
         case BottomLeft:
             return QLatin1String("BottomLeft");
         default:
             break;
     }
     return QLatin1String("? Corner ?");
 }
 
 /**
  * Return Corner corresponding to the given string.
  */
 Corner::Enum Corner::fromString(const QString& item)
 {
     if (item == QLatin1String("TopLeft"))
         return TopLeft;
     if (item == QLatin1String("TopRight"))
         return TopRight;
     if (item == QLatin1String("BottomRight"))
         return BottomRight;
     if (item == QLatin1String("BottomLeft"))
         return BottomLeft;
     return TopLeft;
 }
 
 /**
  * Convert a integer item into Corner representation.
  * @param item   integer value to convert
  * @return Corner enum
  */
 Corner::Enum Corner::fromInt(int item)
 {
     return Enum(item);
 }
 
 //}  // end namespace Corner
 
 //-----------------------------------------------------------------------------
 
 namespace ID {
 
 QDebug operator<<(QDebug out, ID::Type &type)
 {
     out.nospace() << "ID::Type: " << Uml::ID::toString(type);
     return out.space();
 }
 
 QString toString(const ID::Type &id)
 {
     return QLatin1String(id.c_str());
 }
 
 ID::Type fromString(const QString &id)
 {
     return qPrintable(id);
 }
 
 }  // end namespace ID
 
 
 /**
 * Return general system font.
 * @return font
 */
 
 QFont systemFont()
 {
 #if QT_VERSION >= 0x050000
     return QFontDatabase::systemFont(QFontDatabase::GeneralFont);
 #else
     return KGlobalSettings::generalFont();
 #endif
 }
 
 }  // end namespace Uml
 
 /**
  * Convert floating point number string with '.' or ',' as decimal point to qreal.
  * @param s floating point number string
  * @return floating point number
  * @note See https://bugs.kde.org/show_bug.cgi?id=357373 for more informations.
  */
 qreal toDoubleFromAnyLocale(const QString &s)
 {
     bool ok;
     qreal value = s.toDouble(&ok);
     if (!ok) {
         static QLocale hungary(QLocale::Hungarian);
         value = hungary.toDouble(s, &ok);
         if (!ok) {
             qCritical() << "could not read floating point number";
             value = 0;
         }
     }
     return value;
 }
diff --git a/umbrello/codeimport/classimport.cpp b/umbrello/codeimport/classimport.cpp
index 1dc9eb15a..f71a4d877 100644
--- a/umbrello/codeimport/classimport.cpp
+++ b/umbrello/codeimport/classimport.cpp
@@ -1,150 +1,153 @@
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *  copyright (C) 2006-2014                                                *
  *  Umbrello UML Modeller Authors <umbrello-devel@kde.org>                 *
  ***************************************************************************/
 
 // own header
 #include "classimport.h"
 
 // app includes
 #include "debug_utils.h"
 #include "folder.h"
 #include "uml.h"
 #include "umldoc.h"
 #include "idlimport.h"
 #include "pythonimport.h"
 #include "javaimport.h"
 #include "adaimport.h"
 #include "pascalimport.h"
 #include "sqlimport.h"
 #include "cppimport.h"
 #include "csharpimport.h"
 #include "codeimpthread.h"
+#include "valaimport.h"
 #ifdef ENABLE_PHP_IMPORT
 #include "phpimport.h"
 #endif
 
 // kde includes
 #include <KLocalizedString>
 
 // qt includes
 #include <QRegExp>
 
 /**
  * Factory method.
  * @param fileName  name of imported file
  * @return the class import object
  */
 ClassImport *ClassImport::createImporterByFileExt(const QString &fileName, CodeImpThread* thread)
 {
     ClassImport *classImporter;
     if (fileName.endsWith(QLatin1String(".idl")))
         classImporter = new IDLImport(thread);
     else if (fileName.contains(QRegExp(QLatin1String("\\.pyw?$"))))
         classImporter = new PythonImport(thread);
     else if (fileName.endsWith(QLatin1String(".java")))
         classImporter = new JavaImport(thread);
     else if (fileName.contains(QRegExp(QLatin1String("\\.ad[sba]$"))))
         classImporter = new AdaImport(thread);
     else if (fileName.endsWith(QLatin1String(".pas")))
         classImporter = new PascalImport(thread);
     else if (fileName.endsWith(QLatin1String(".cs")))
         classImporter = new CSharpImport(thread);
+    else if (fileName.contains(QRegExp(QLatin1String(".va[lp][ai]$"))))
+        classImporter = new ValaImport(thread);
     else if (fileName.endsWith(QLatin1String(".sql")))
         classImporter = new SQLImport(thread);
 #ifdef ENABLE_PHP_IMPORT
     else if (fileName.endsWith(QLatin1String(".php")))
         classImporter = new PHPImport(thread);
 #endif
     else
         classImporter = new CppImport(thread);  // the default.
     return classImporter;
 }
 
 ClassImport::ClassImport(CodeImpThread* thread)
   : m_thread(thread),
     m_enabled(true)
 {
 }
 
 ClassImport::~ClassImport()
 {
 }
 
 /**
  * Do initializations before importing a single file.
  * This is called by importFile() before calling parseFile().
  * @todo check if the default implementation should do anything
  */
 void ClassImport::initPerFile()
 {
 }
 
 /**
  * Import files.
  * @param fileNames  List of files to import.
  */
 bool ClassImport::importFiles(const QStringList& fileNames)
 {
     initialize();
     UMLDoc *umldoc = UMLApp::app()->document();
     uint processedFilesCount = 0;
     bool result = true;
     umldoc->setLoading(true);
     umldoc->setImporting(true);
     foreach (const QString& fileName, fileNames) {
         umldoc->writeToStatusBar(i18n("Importing file: %1 Progress: %2/%3",
                                  fileName, processedFilesCount, fileNames.size()));
         if (!importFile(fileName))
             result = false;
         processedFilesCount++;
     }
     umldoc->setLoading(false);
     umldoc->setImporting(false);
     umldoc->writeToStatusBar(result ? i18nc("ready to status bar", "Ready.") : i18nc("failed to status bar", "Failed."));
     return result;
 }
 
 /**
  * Import a single file.
  * @param fileName  The file to import.
  */
 bool ClassImport::importFile(const QString& fileName)
 {
     initPerFile();
     return parseFile(fileName);
 }
 
 void ClassImport::setRootPath(const QString &path)
 {
     m_rootPath = path;
 }
 
 /**
  * Write info to a logger or to the debug output.
  * @param file   the name of the parsed file
  * @param text   the text to write
  */
 void ClassImport::log(const QString& file, const QString& text)
 {
     if (m_thread) {
         m_thread->emitMessageToLog(file, text);
     }
     else {
         uDebug() << file << " - " << text;
     }
 }
 
 /**
  * Write info to a logger or to the debug output.
  * @param text   the text to write
  */
 void ClassImport::log(const QString& text)
 {
     log(QString(), text);
 }
diff --git a/umbrello/codeimport/csharp/csharpimport.cpp b/umbrello/codeimport/csharp/csharpimport.cpp
index f76d2da86..65cb684a7 100644
--- a/umbrello/codeimport/csharp/csharpimport.cpp
+++ b/umbrello/codeimport/csharp/csharpimport.cpp
@@ -1,768 +1,774 @@
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   copyright (C) 2011-2014                                               *
  *   Umbrello UML Modeller Authors <umbrello-devel@kde.org>                *
  ***************************************************************************/
 
 // own header
 #include "csharpimport.h"
 
 // app includes
 #include "attribute.h"
 #include "classifier.h"
 #include "codeimpthread.h"
 #include "debug_utils.h"
 #include "enum.h"
 #include "import_utils.h"
 #include "operation.h"
 #include "package.h"
 #include "uml.h"
 #include "umldoc.h"
 #include "umlpackagelist.h"
 
 // qt includes
 #include <QFile>
 #include <QRegExp>
 #include <QStringList>
 #include <QTextStream>
 
 QStringList CSharpImport::s_filesAlreadyParsed;
 int CSharpImport::s_parseDepth = 0;
 
 /**
  * Constructor.
  */
 CSharpImport::CSharpImport(CodeImpThread* thread)
   : NativeImportBase(QLatin1String("//"), thread),
     m_defaultCurrentAccess(Uml::Visibility::Public)
 {
+    m_language = Uml::ProgrammingLanguage::CSharp;
     setMultiLineComment(QLatin1String("/*"), QLatin1String("*/"));
     initVars();
 }
 
 /**
  * Destructor.
  */
 CSharpImport::~CSharpImport()
 {
 }
 
+QString CSharpImport::fileExtension()
+{
+    return(QLatin1String(".cs"));
+}
+
 /**
  * Reimplement operation from NativeImportBase.
  */
 void CSharpImport::initVars()
 {
     m_isStatic = false;
 }
 
 /**
  * Figure out if the type is really an array or template of the given typeName.
  * Catenate possible template arguments/array dimensions to the end of the type name.
  * @param typeName   the type name
  * @return the type name with the additional information
  */
 QString CSharpImport::joinTypename(const QString& typeName)
 {
     QString typeNameRet(typeName);
     if (m_srcIndex + 1 < m_source.size()) {
         if (m_source[m_srcIndex + 1] == QLatin1String("<") ||
             m_source[m_srcIndex + 1] == QLatin1String("[")) {
             int start = ++m_srcIndex;
             if (! skipToClosing(m_source[start][0]))
                 return typeNameRet;
             for (int i = start; i <= m_srcIndex; ++i) {
                 typeNameRet += m_source[i];
             }
         }
     }
     // to handle multidimensional arrays, call recursively
     if ((m_srcIndex + 1 < m_source.size()) && (m_source[m_srcIndex + 1] == QLatin1String("["))) {
         typeNameRet = joinTypename(typeNameRet);
     }
     return typeNameRet;
 }
 
 /**
  * Implement abstract operation from NativeImportBase.
  * @param word   whitespace delimited item
  */
 void CSharpImport::fillSource(const QString& word)
 {
     QString lexeme;
     const uint len = word.length();
     for (uint i = 0; i < len; ++i) {
         const QChar& c = word[i];
         if (c.isLetterOrNumber() || c == QLatin1Char('_') || c == QLatin1Char('.')) {
             lexeme += c;
         } else {
             if (!lexeme.isEmpty()) {
                 m_source.append(lexeme);
                 lexeme.clear();
             }
             m_source.append(QString(c));
         }
     }
     if (!lexeme.isEmpty())
         m_source.append(lexeme);
 }
 
 /**
  * Spawn off an import of the specified file.
  * @param file   the specified file
  */
 void CSharpImport::spawnImport(const QString& file)
 {
     // if the file is being parsed, don't bother
     if (s_filesAlreadyParsed.contains(file)) {
         return;
     }
     if (QFile::exists(file)) {
         CSharpImport importer;
         QStringList fileList;
         fileList.append(file);
         s_filesAlreadyParsed.append(file);
         importer.importFiles(fileList);
     }
 }
 
 /**
  * Returns the UML Object if found, or null otherwise.
  * @param name        name of the uml object
  * @param parentPkg   parent package
  * @return null or the uml objecct
  */
 UMLObject* CSharpImport::findObject(const QString& name, UMLPackage *parentPkg)
 {
     UMLDoc *umldoc = UMLApp::app()->document();
     UMLObject * o = umldoc->findUMLObject(name, UMLObject::ot_UMLObject, parentPkg);
     return o;
 }
 
 /**
  * Try to resolve the specified class the current class depends on.
  * @param className  the name of the class
  */
 UMLObject* CSharpImport::resolveClass(const QString& className)
 {
     uDebug() << "trying to resolve " << className;
     // keep track if we are dealing with an array
     bool isArray = className.contains(QLatin1Char('['));
     // remove any [] so that the class itself can be resolved
     QString baseClassName = className;
     baseClassName.remove(QLatin1Char('['));
     baseClassName.remove(QLatin1Char(']'));
 
     // java has a few implicit imports.  Most relevant for this is the
     // current package, which is in the same directory as the current file
     // being parsed
     QStringList file = m_currentFileName.split(QLatin1Char('/'));
     // remove the filename.  This leaves the full path to the containing
     // dir which should also include the package hierarchy
     file.pop_back();
 
     // the file we're looking for might be in the same directory as the
     // current class
     QString myDir = file.join(QLatin1String("/"));
-    QString myFile = myDir + QLatin1Char('/') + baseClassName + QLatin1String(".cs");
+    QString myFile = myDir + QLatin1Char('/') + baseClassName + fileExtension();
     if (QFile::exists(myFile)) {
         spawnImport(myFile);
         if (isArray) {
             // we have imported the type. For arrays we want to return
             // the array type
             return Import_Utils::createUMLObject(UMLObject::ot_Class, className, currentScope());
         }
         return findObject(baseClassName, currentScope());
     }
 
     // the class we want is not in the same package as the one being imported.
     // use the imports to find the one we want.
     QStringList package = m_currentPackage.split(QLatin1Char('.'));
     int dirsInPackageCount = package.size();
 
     for (int count = 0; count < dirsInPackageCount; ++count) {
         // pop off one by one the directories, until only the source root remains
         file.pop_back();
     }
     // this is now the root of any further source imports
     QString sourceRoot = file.join(QLatin1String("/")) + QLatin1Char('/');
 
     for (QStringList::Iterator pathIt = m_imports.begin();
             pathIt != m_imports.end(); ++pathIt) {
         QString import = (*pathIt);
         QStringList split = import.split(QLatin1Char('.'));
         split.pop_back(); // remove the * or the classname
         if (import.endsWith(QLatin1Char('*')) || import.endsWith(baseClassName)) {
             // check if the file we want is in this imported package
             // convert the org.test type package into a filename
-            QString aFile = sourceRoot + split.join(QLatin1String("/")) + QLatin1Char('/') + baseClassName + QLatin1String(".cs");
+            QString aFile = sourceRoot + split.join(QLatin1String("/")) + QLatin1Char('/') + baseClassName + fileExtension();
             if (QFile::exists(aFile)) {
                 spawnImport(aFile);
                 // we need to set the package for the class that will be resolved
                 // start at the root package
                 UMLPackage *parent = 0;
                 UMLPackage *current = 0;
 
                 for (QStringList::Iterator it = split.begin(); it != split.end(); ++it) {
                     QString name = (*it);
                     UMLObject *ns = Import_Utils::createUMLObject(UMLObject::ot_Package,
                                     name, parent);
                     current = ns->asUMLPackage();
                     parent = current;
                 } // for
                 if (isArray) {
                     // we have imported the type. For arrays we want to return
                     // the array type
                     return Import_Utils::createUMLObject(UMLObject::ot_Class, className, current);
                 }
                 // now that we have the right package, the class should be findable
                 return findObject(baseClassName, current);
             } // if file exists
         } // if import matches
     } //foreach import
     return 0; // no match
 }
 
 /**
  * Keep track of the current file being parsed and reset the list of imports.
  * @param filename   the name of the file being parsed
  */
 bool CSharpImport::parseFile(const QString& filename)
 {
     uDebug() << filename;
     m_currentFileName = filename;
     m_imports.clear();
     // default visibility is Impl, unless we are an interface, then it is
     // public for member vars and methods
     m_defaultCurrentAccess = Uml::Visibility::Implementation;
     m_currentAccess = m_defaultCurrentAccess;
     s_parseDepth++;
     // in the case of self referencing types, we can avoid parsing the
     // file twice by adding it to the list
     s_filesAlreadyParsed.append(filename);
     NativeImportBase::parseFile(filename);
     s_parseDepth--;
     if (s_parseDepth <= 0) {
         // if the user decides to clear things out and reparse, we need
         // to honor the request, so reset things for next time.
         s_filesAlreadyParsed.clear();
         s_parseDepth = 0;
     }
     return true;
 }
 
 /**
  * Implement abstract operation from NativeImportBase.
  * compilation-unit:
  *     using-directives?  global-attributes?  namespace-member-declarations?
  * @return success status of operation
  */
 bool CSharpImport::parseStmt()
 {
     const QString& keyword = m_source[m_srcIndex];
     //uDebug() << '"' << keyword << '"';
 
     if (keyword == QLatin1String("using")) {
         return parseUsingDirectives();
     }
 
     if (keyword == QLatin1String("namespace")) {
         return parseNamespaceMemberDeclarations();
     }
 
     if (keyword == QLatin1String("[")) {
         return parseAttributes();  //:TODO: more than one
     }
 
     // type-declaration - class, interface, struct, enum, delegate
     if (isClassModifier(keyword) || isTypeDeclaration(keyword)) {
         // more than one modifier possible
         QString nextKeyword = keyword;
         while (isClassModifier(nextKeyword)) {
             nextKeyword = advance();
         }
         if (nextKeyword == QLatin1String("class")) {
             return parseClassDeclaration(nextKeyword);
         }
         if (nextKeyword == QLatin1String("interface")) {
             return parseClassDeclaration(nextKeyword);
         }
         if (nextKeyword == QLatin1String("struct")) {
             return parseStructDeclaration();
         }
         if (nextKeyword == QLatin1String("enum")) {
             return parseEnumDeclaration();
         }
         if (nextKeyword == QLatin1String("delegate")) {
             return parseDelegateDeclaration();
         }
     }
 
 
 /*
     if (keyword == QLatin1String("static")) {
         m_isStatic = true;
         return true;
     }
 
     // if we detected static previously and keyword is { then this is a static block
     if (m_isStatic && keyword == QLatin1String("{")) {
         // reset static flag and jump to end of static block
         m_isStatic = false;
         return skipToClosing(QLatin1Char('{'));
     }
 
     if ((keyword == QLatin1String("override")) ||
             (keyword == QLatin1String("virtual")) ||
             (keyword == QLatin1String("sealed"))) {
         //:TODO: anything to do here?
         return true;
     }
 */
 
     if (keyword == QLatin1String("#")) {   // preprocessor directives
         QString ppdKeyword = advance();
         uDebug() << "found preprocessor directive " << ppdKeyword;
         //:TODO: anything to do here?
         return true;
     }
 
 //     if (keyword == QLatin1String("@")) {   // annotation
 //         advance();
 //         if (m_source[m_srcIndex + 1] == QLatin1String("(")) {
 //             advance();
 //             skipToClosing(QLatin1Char('('));
 //         }
 //         return true;
 //     }
 
     if (keyword == QLatin1String("[")) {   // ...
         advance();
         skipToClosing(QLatin1Char('['));
         return true;
     }
 
     if (keyword == QLatin1String("}")) {
         if (scopeIndex())
             m_klass = popScope()->asUMLClassifier();
         else
             uError() << "too many }";
         return true;
     }
 
     // At this point, we expect `keyword' to be a type name
     // (of a member of class or interface, or return type
     // of an operation.) Up next is the name of the attribute
     // or operation.
     if (! keyword.contains(QRegExp(QLatin1String("^\\w")))) {
         uError() << "ignoring " << keyword << " at "
                  << m_srcIndex << ", " << m_source.count() << " in " << m_klass;  //:TODO: ->name();
         return false;
     }
 
     QString typeName = m_source[m_srcIndex];
     typeName = joinTypename(typeName);
     // At this point we need a class.
     if (m_klass == 0) {
         uError() << "no class set for " << typeName;
         return false;
     }
     QString name = advance();
     QString nextToken;
     if (typeName == m_klass->name() && name == QLatin1String("(")) {
         // Constructor.
         nextToken = name;
         name = typeName;
         typeName.clear();
     } else {
         nextToken = advance();
     }
     if (name.contains(QRegExp(QLatin1String("\\W")))) {
         uError() << "expecting name in " << name;
         return false;
     }
     if (nextToken == QLatin1String("(")) {
         // operation
         UMLOperation *op = Import_Utils::makeOperation(m_klass, name);
         m_srcIndex++;
         while (m_srcIndex < m_source.count() && m_source[m_srcIndex] != QLatin1String(")")) {
             QString typeName = m_source[m_srcIndex];
             if (typeName == QLatin1String("final") || typeName.startsWith(QLatin1String("//"))) {
                 // ignore the "final" keyword and any comments in method args
                 typeName = advance();
             }
             typeName = joinTypename(typeName);
             QString parName = advance();
             // the Class might not be resolved yet so resolve it if necessary
             UMLObject *obj = resolveClass(typeName);
             if (obj) {
                 // by prepending the package, unwanted placeholder types will not get created
                 typeName = obj->fullyQualifiedName(QLatin1String("."));
             }
             /* UMLAttribute *att = */ Import_Utils::addMethodParameter(op, typeName, parName);
             if (advance() != QLatin1String(","))
                 break;
             m_srcIndex++;
         }
         // before adding the method, try resolving the return type
         UMLObject *obj = resolveClass(typeName);
         if (obj) {
             // using the fully qualified name means that a placeholder type will not be created.
             typeName = obj->fullyQualifiedName(QLatin1String("."));
         }
         Import_Utils::insertMethod(m_klass, op, m_currentAccess, typeName,
                                    m_isStatic, m_isAbstract, false /*isFriend*/,
                                    false /*isConstructor*/, false, m_comment);
         m_isAbstract = m_isStatic = false;
         // reset the default visibility
         m_currentAccess = m_defaultCurrentAccess;
         // At this point we do not know whether the method has a body or not.
         do {
             nextToken = advance();
         } while (nextToken != QLatin1String("{") && nextToken != QLatin1String(";"));
         if (nextToken == QLatin1String(";")) {
             // No body (interface or abstract)
             return true;
         } else {
             return skipToClosing(QLatin1Char('{'));
         }
     }
     // At this point we know it's some kind of attribute declaration.
     while(1) {
         while (nextToken != QLatin1String(",") && nextToken != QLatin1String(";")) {
             if (nextToken == QLatin1String("=")) {
                 if ((nextToken = advance()) == QLatin1String("new")) {
                     advance();
                     if ((nextToken = advance()) == QLatin1String("(")) {
                         skipToClosing(QLatin1Char('('));
                         if ((nextToken = advance()) == QLatin1String("{")) {
                             skipToClosing(QLatin1Char('{'));
                         } else {
                             skipStmt();
                             break;
                         }
                     } else {
                         skipStmt();
                         break;
                     }
                 } else {
                     skipStmt();
                     break;
                 }
             } else {
                 name += nextToken;  // add possible array dimensions to `name'
             }
             nextToken = advance();
             if (nextToken.isEmpty()) {
                 break;
             }
         }
         // try to resolve the class type, or create a placeholder if that fails
         UMLObject *type = resolveClass(typeName);
         if (type) {
             Import_Utils::insertAttribute(
                         m_klass, m_currentAccess, name,
                         type->asUMLClassifier(), m_comment, m_isStatic);
         } else {
             Import_Utils::insertAttribute(
                         m_klass, m_currentAccess, name,
                         typeName, m_comment, m_isStatic);
         }
         // UMLAttribute *attr = o->asUMLAttribute();
         if (nextToken != QLatin1String(",")) {
             // reset the modifiers
             m_isStatic = m_isAbstract = false;
             break;
         }
         name = advance();
         nextToken = advance();
     }
     // reset visibility to default
     m_currentAccess = m_defaultCurrentAccess;
     if (m_srcIndex < m_source.count()) {
         if (m_source[m_srcIndex] != QLatin1String(";")) {
             uError() << "ignoring trailing items at " << name;
             skipStmt();
         }
     } else {
         uError() << "index out of range: ignoring statement " << name;
         skipStmt();
     }
     return true;
 }
 
 /**
  * Parsing the statement 'using'.
  * Keep track of imports so we can resolve classes we are dependent on.
  * @return   success status of parsing
  */
 bool CSharpImport::parseUsingDirectives()
 {
     QString import = advance();
     log(QLatin1String("using ") + import);
     if (import.contains(QLatin1Char('='))) {
         //this is an alias to represent the namespace name
         //:TODO: import = import + advance();
     }
     m_imports.append(import);
 
     // move past ;
     skipStmt();
     return true;
 }
 
 /**
  * Parsing global attributes.
  * @return   success status of parsing
  */
 bool CSharpImport::parseGlobalAttributes()
 {
     //:TODO:
     return true;
 }
 
 /**
  * Parsing the statement 'namespace'.
  * @return   success status of parsing
  */
 bool CSharpImport::parseNamespaceMemberDeclarations()
 {
     QString m_currentNamespace = advance();
     log(QLatin1String("namespace ") + m_currentNamespace);
     // move past {
     skipStmt(QLatin1String("{"));
     return true;
 }
 
 /**
  * Parsing attributes.
  * @return   success status of parsing
  */
 bool CSharpImport::parseAttributes()
 {
     QString attribute = advance();
     log(QLatin1String("attribute ") + attribute);
     skipStmt(QLatin1String("]"));
     return true;
 }
 
 /**
  * Check if keyword is belonging to a type-declaration.
  * @return   result of check
  */
 bool CSharpImport::isTypeDeclaration(const QString& keyword)
 {
     if (keyword == QLatin1String("class")     ||
         keyword == QLatin1String("struct")    ||
         keyword == QLatin1String("interface") ||
         keyword == QLatin1String("enum")      ||
         keyword == QLatin1String("delegate")) {
         // log("type-declaration: " + keyword);
         return true;
     }
     else {
         return false;
     }
 }
 
 /**
  * Check if keyword is a class-modifier.
  * @return   result of check
  */
 bool CSharpImport::isClassModifier(const QString& keyword)
 {
     if (isCommonModifier(keyword)  ||
         keyword == QLatin1String("abstract")    ||
         keyword == QLatin1String("sealed")) {
         // log("class-modifier: " + keyword);
         if (keyword == QLatin1String("abstract")) {
             m_isAbstract = true;
         }
         return true;
     }
     else {
         return false;
     }
 }
 
 /**
  * Check if keyword is a interface, struct, enum or delegate modifier.
  * @return   result of check
  */
 bool CSharpImport::isCommonModifier(const QString& keyword)
 {
     if (keyword == QLatin1String("new")       ||
         keyword == QLatin1String("public")    ||
         keyword == QLatin1String("protected") ||
         keyword == QLatin1String("internal")  ||
         keyword == QLatin1String("private")) {
         if (keyword == QLatin1String("public")) {
             m_currentAccess = Uml::Visibility::Public;
         }
         if (keyword == QLatin1String("protected")) {
             m_currentAccess = Uml::Visibility::Protected;
         }
         if (keyword == QLatin1String("private")) {
             m_currentAccess = Uml::Visibility::Private;
         }
         return true;
     }
     else {
         return false;
     }
 }
 
 /**
  * Parsing the statement 'enum'.
  * @return   success status of parsing
  */
 bool CSharpImport::parseEnumDeclaration()
 {
     const QString& name = advance();
     log(QLatin1String("enum ") + name);
     UMLObject *ns = Import_Utils::createUMLObject(UMLObject::ot_Enum,
                         name, currentScope(), m_comment);
     UMLEnum *enumType = ns->asUMLEnum();
     if (enumType == 0)
         enumType = Import_Utils::remapUMLEnum(ns, currentScope());
     skipStmt(QLatin1String("{"));
     while (m_srcIndex < m_source.count() - 1 && advance() != QLatin1String("}")) {
         QString next = advance();
         if (next == QLatin1String("=")) {
             next = advance();
             if (enumType != 0)
                 Import_Utils::addEnumLiteral(enumType, m_source[m_srcIndex - 2], QString(), m_source[m_srcIndex]);
             next = advance();
         } else {
             if (enumType != 0)
                 Import_Utils::addEnumLiteral(enumType, m_source[m_srcIndex - 1]);
         }
         if (next == QLatin1String("{") || next == QLatin1String("(")) {
             if (! skipToClosing(next[0]))
                 return false;
             next = advance();
         }
         if (next != QLatin1String(",")) {
             if (next == QLatin1String(";")) {
                 // @todo handle methods in enum
                 // For now, we cheat (skip them)
                 m_source[m_srcIndex] = QLatin1Char('{');
                 if (! skipToClosing(QLatin1Char('{')))
                     return false;
             }
             break;
         }
     }
     return true;
 }
 
 /**
  * Parsing a struct-declaration.
  * @return   success status of parsing
  */
 bool CSharpImport::parseStructDeclaration()
 {
     const QString& name = advance();
     log(QLatin1String("struct ") + name + QLatin1String(" --> parsing not yet implemented!"));
     return true;
 }
 
 /**
  * Parsing a delegate-declaration.
  * @return   success status of parsing
  */
 bool CSharpImport::parseDelegateDeclaration()
 {
     // return-type identifier (formal-parameter-list?) ;
     const QString& returnType = advance();
     const QString& name = advance();
     log(QLatin1String("delegate ") + name + QLatin1String("with return-type ") + returnType);
     skipStmt(QLatin1String(";"));
     return true;
 }
 
 /**
  * Parsing the statement 'class' or 'interface'.
  * @return   success status of parsing
  */
 bool CSharpImport::parseClassDeclaration(const QString& keyword)
 {
     const QString& name = advance();
     const UMLObject::ObjectType ot = (keyword == QLatin1String("class") ? UMLObject::ot_Class
                                                                         : UMLObject::ot_Interface);
     log(keyword + QLatin1Char(' ') + name);
     UMLObject *ns = Import_Utils::createUMLObject(ot, name, currentScope(), m_comment);
     pushScope(m_klass = ns->asUMLClassifier());
     m_klass->setStatic(m_isStatic);
     m_klass->setVisibilityCmd(m_currentAccess);
     // The UMLObject found by createUMLObject might originally have been created as a
     // placeholder with a type of class but if is really an interface, then we need to
     // change it.
     m_klass->setBaseType(ot);
     // TODO: UMLClassifier::setBaseType() resets abstract flag
     m_klass->setAbstract(m_isAbstract);
     m_isAbstract = m_isStatic = false;
     // if no modifier is specified in an interface, then it means public
     if (m_klass->isInterface()) {
         m_defaultCurrentAccess =  Uml::Visibility::Public;
     }
 
     if (advance() == QLatin1String(";"))    // forward declaration
         return true;
 
     if (m_source[m_srcIndex] == QLatin1String("<")) {
         // template args - preliminary, rudimentary implementation
         // @todo implement all template arg syntax
         uint start = m_srcIndex;
         if (! skipToClosing(QLatin1Char('<'))) {
             uError() << "import C# (" << name << "): template syntax error";
             return false;
         }
         while(1) {
             const QString arg = m_source[++start];
             if (! arg.contains(QRegExp(QLatin1String("^[A-Za-z_]")))) {
                 uDebug() << "import C# (" << name << "): "
                          << "cannot handle template syntax (" << arg << ")";
                 break;
             }
             /* UMLTemplate *tmpl = */ m_klass->addTemplate(arg);
             const QString next = m_source[++start];
             if (next == QLatin1String(">"))
                 break;
             if (next != QLatin1String(",")) {
                 uDebug() << "import C# (" << name << "): "
                          << "cannot handle template syntax (" << next << ")";
                 break;
             }
         }
         advance();  // skip over ">"
     }
 
     if (m_source[m_srcIndex] == QLatin1String(":")) {   // derivation
         while (m_srcIndex < m_source.count() - 1 && advance() != QLatin1String("{")) {
             const QString& baseName = m_source[m_srcIndex];
             // try to resolve the interface we are implementing, if this fails
             // create a placeholder
             UMLObject *interface = resolveClass(baseName);
             if (interface) {
                 Import_Utils::createGeneralization(m_klass, interface->asUMLClassifier());
             } else {
                 uDebug() << "implementing interface " << baseName
                          << " is not resolvable. Creating placeholder";
                 Import_Utils::createGeneralization(m_klass, baseName);
             }
             if (advance() != QLatin1String(","))
                 break;
         }
     }
 
     if (m_source[m_srcIndex] != QLatin1String("{")) {
         uError() << "ignoring excess chars at " << name
                  << " (" << m_source[m_srcIndex] << ")";
         skipStmt(QLatin1String("{"));
     }
     return true;
 }
diff --git a/umbrello/codeimport/csharp/csharpimport.h b/umbrello/codeimport/csharp/csharpimport.h
index b45805882..39a7373bd 100644
--- a/umbrello/codeimport/csharp/csharpimport.h
+++ b/umbrello/codeimport/csharp/csharpimport.h
@@ -1,84 +1,90 @@
 /***************************************************************************
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  copyright (C) 2011-2014                                                *
  *  Umbrello UML Modeller Authors <umbrello-devel@kde.org>                 *
  ***************************************************************************/
 
 #ifndef CSHARPIMPORT_H
 #define CSHARPIMPORT_H
 
 #include "nativeimportbase.h"
 
 class UMLObject;
 
 /**
  * C# code import.
  * Grammar of C# can be found at http://msdn.microsoft.com/en-us/library/Aa664812 .
  * @author Andi Fischer (copied from JavaImport)
  * Bugs and comments to umbrello-devel@kde.org or http://bugs.kde.org
  */
 class CSharpImport : public NativeImportBase
 {
 public:
     explicit CSharpImport(CodeImpThread* thread = 0);
     virtual ~CSharpImport();
+    virtual QString fileExtension();
 
 protected:
     void initVars();
 
     bool parseStmt();
 
     void fillSource(const QString& word);
 
     bool parseFile(const QString& filename);
 
     UMLObject* resolveClass (const QString& className);
 
     void spawnImport(const QString& file);
 
     QString joinTypename(const QString& typeName);
 
     bool        m_isStatic;         ///< static flag for the member var or method
     QString     m_currentFileName;  ///< current filename being parsed
     QString     m_currentPackage;   ///< current package of the file being parsed
     QStringList m_imports;          ///< imports included in the current file
     Uml::Visibility::Enum m_defaultCurrentAccess;  ///< current visibility for when the visibility is absent
 
     /**
      * Keep track of the files we have already parsed so we don't
      * reparse the same ones over and over again.
      */
     static QStringList s_filesAlreadyParsed;
 
     /**
      * Keep track of the parses so that the filesAlreadyParsed
      * can be reset when we're done.
      */
     static int s_parseDepth;
 
+    /**
+     * required for language specific suport
+     */
+    Uml::ProgrammingLanguage::Enum m_language;
+
 private:
     static UMLObject* findObject(const QString& name, UMLPackage *parentPkg);
 
     bool parseUsingDirectives();
     bool parseGlobalAttributes();
     bool parseNamespaceMemberDeclarations();
     bool parseAttributes();
 
     // type-declaration
     bool parseClassDeclaration(const QString& keyword);
     bool parseStructDeclaration();
     // bool parseInterfaceDeclaration();
     bool parseEnumDeclaration();
     bool parseDelegateDeclaration();
 
     bool isTypeDeclaration(const QString& keyword);
     bool isClassModifier(const QString& keyword);
     bool isCommonModifier(const QString& keyword);
 
 };
 
 #endif
diff --git a/umbrello/codeimport/valaimport.cpp b/umbrello/codeimport/valaimport.cpp
new file mode 100644
index 000000000..5ffa1121a
--- /dev/null
+++ b/umbrello/codeimport/valaimport.cpp
@@ -0,0 +1,27 @@
+/***************************************************************************
+ *  This program is free software; you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  the Free Software Foundation; either version 2 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  copyright (C) 2018                                                     *
+ *  Umbrello UML Modeller Authors <umbrello-devel@kde.org>                 *
+ ***************************************************************************/
+
+#include "valaimport.h"
+
+ValaImport::ValaImport(CodeImpThread *thread)
+    : CSharpImport(thread)
+{
+    m_language = Uml::ProgrammingLanguage::Vala;
+}
+
+ValaImport::~ValaImport()
+{
+
+}
+
+QString ValaImport::fileExtension()
+{
+    return QLatin1String(".vala");
+}
diff --git a/umbrello/codeimport/valaimport.h b/umbrello/codeimport/valaimport.h
new file mode 100644
index 000000000..2d998bda1
--- /dev/null
+++ b/umbrello/codeimport/valaimport.h
@@ -0,0 +1,25 @@
+/***************************************************************************
+ *  This program is free software; you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  the Free Software Foundation; either version 2 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  copyright (C) 2018                                                     *
+ *  Umbrello UML Modeller Authors <umbrello-devel@kde.org>                 *
+ ***************************************************************************/
+
+#ifndef VALAIMPORT_H
+#define VALAIMPORT_H
+
+#include "csharpimport.h"
+
+class ValaImport : public CSharpImport
+{
+public:
+    explicit ValaImport(CodeImpThread* thread = 0);
+    virtual ~ValaImport();
+    QString fileExtension();
+
+};
+
+#endif // VALAIMPORT_H